How to Commit Changes with Both Title and Description from Command Line

Structured Requirements for Git Commit Messages

In software development, the quality of Git commit messages significantly impacts project maintainability. Many developers accustomed to GitHub's web interface prefer separating commit messages into title and description sections, creating a structured approach that makes change history more readable.

Basic Command Line Commit Methods

In terminal environments, Git provides multiple ways to create commit messages containing both title and description. The most straightforward approach uses the -m parameter with the git commit command.

Using Multiple -m Parameters

By using the -m parameter multiple times, you can specify title and description separately:

git commit -m "Fix user login validation logic" -m "Detailed description:
- Fixed password strength validation rules
- Optimized error message display
- Added login attempt limit";

This method is simple and direct. The content after the first -m parameter becomes the commit title, while subsequent -m parameters provide the description. Git automatically adds empty lines between title and description.

Editor Mode Committing

For more complex commit messages, use editor mode:

git commit

Executing this command opens Git's configured default editor (such as Vim, VS Code, etc.). In the editor, write the commit title on the first line, leave one empty line, then write the detailed description. This approach allows for more detailed, formatted description content.

Editor Configuration and Usage

To improve commit message writing efficiency, configure familiar text editors.

Configuring VS Code as Git Editor

git config --global core.editor "code --wait"

After configuration, executing git commit automatically opens VS Code editor, providing a more user-friendly interface with syntax highlighting.

Vim Editor Usage Tips

For Vim users, master these basic operations:

• Press i to enter insert mode and start editing
• Press ESC to exit insert mode
• Type :wq to save and exit

Commit Message Best Practices

Good commit messages should follow certain conventions:

Title Format Requirements

• Maximum 50 characters in length
• Use imperative mood
• Capitalize first letter
• No period at the end

Description Content Standards

• Detail the reason and content of changes
• Organize content using bullet points
• Maximum 72 characters per line
• Explain the impact of changes

Change Staging and Commit Workflow

Before creating commits, properly stage changed files.

Selective Change Staging

git add --patch filename.go

This command allows interactive selection of code chunks (hunks) to stage, suitable for breaking large changes into multiple logical commits.

Commit Status Checking

git status
git diff --staged

Check staged area status and differences before committing to ensure accuracy of commit content.

Pushing and Remote Repository Synchronization

After completing local commits, push changes to remote repositories.

First Branch Push

git push -u origin HEAD

This command pushes the current branch to the remote repository and establishes tracking relationship.

Subsequent Pushes

git push origin HEAD

For branches with established tracking relationships, use this command for regular pushes.

Advanced Commit Management Techniques

In actual development, more refined commit management may be necessary.

Commit Amendment

git commit --amend

Used to modify the most recent commit's message or content, suitable for situations where errors are discovered immediately after committing.

Commit Squashing

When preparing to merge branches, use interactive rebase to squash multiple related commits:

git rebase -i HEAD~3

By changing multiple pick to squash or fixup, you can merge commit history.

Error Handling and Undo Operations

When commits contain errors, Git provides multiple undo methods.

Local Commit Undo

git reset HEAD~

This command undoes the most recent commit while preserving changes in the working directory.

Force Push Considerations

Exercise extreme caution when using git push --force, as this rewrites remote repository history and may affect other collaborators.

Conclusion

By properly utilizing various Git command line features, developers can create structured, informative commit messages. Whether using the simple -m parameter approach or the fully-featured editor mode, both can meet requirements in different scenarios. Combined with good commit habits and workflows, this effectively enhances project maintainability and team collaboration efficiency.