ChatGPT解决这个技术问题 Extra ChatGPT

How do I make git use the editor of my choice for editing commit messages?

How do I globally configure git to use a particular editor (e.g. vim) for commit messages?

"How to get git to go to vim for commit comments from the git-go?"
What's wrong with EMACS (smile) ?

M
Mateen Ulhaq

Setting the default editor for Git

Pick one:

Set core.editor in your Git config: git config --global core.editor "vim"

Set the GIT_EDITOR environment variable: export GIT_EDITOR=vim

Setting the default editor for all programs

Set the standardized VISUAL and EDITOR environment variables*:

export VISUAL=vim
export EDITOR="$VISUAL"

NOTE: Setting both is not necessarily needed, but some programs may not use the more-correct VISUAL. See VISUAL vs. EDITOR.

Fixing compatibility issues

Some editors require a --wait flag, or they will open a blank page. For example:

Sublime Text (if correctly set up; or use the full path to the executable in place of subl): export VISUAL="subl --wait"

VS Code (after adding the shell command): export VISUAL="code --wait"


The EDITOR environment variable has the advantage that a number of other programs will respect it as well.
Note that git config --global would write to your personal (per-user) git configuration file. On Unices it is ~/.gitconfig. So this would configure it for all your repositories.
you can test you successfully changed it by trying to amend the last commit message. git commit --amend
If you're doing option #1 in Windows and have spaces in the path to the editor (say, if it's under Program Files) then whack single-quotes inside your double-quotes. e.g. "'C:/Program Files (x86)/Whatever/App.exe'" - obvious to some but it wasn't to me!
@Abramodj -w is not necessary; -w {scriptout} saves all characters you type when editing to replay later. Perhaps you are confusing it with -f, which is necessary when calling the GUI version of Vim. That is, if you use mvim, then the editor you specify should be mvim -f rather than mvim.
M
Mateen Ulhaq

Run:

git config --global core.editor "vim"

From man git-commit:

ENVIRONMENT AND CONFIGURATION VARIABLES The editor used to edit the commit log message will be chosen from the GIT_EDITOR environment variable, the core.editor configuration variable, the VISUAL environment variable, or the EDITOR environment variable (in that order).


Btw, the above is true for CVS and SVN, and I guess other version controls.
@armandino: Yes, the others might use VISUAL or EDITOR, but they certainly don't use GIT_EDITOR or core.editor.
Thanks for clarifying Mark. I meant the EDITOR variable. I believe the GIT_EDITOR (if defined) simply overrides it.
Yep - svnbook.red-bean.com/en/1.1/ch07.html#svn-ch-7-sect-1.3.2 So in theory, if I'm using both svn and git, setting $VISUAL or $EDITOR would be the best solution to cover both by default!
For the sake of completeness, core.editor means [core] editor = ... in the file
K
Koen.

On Ubuntu and also Debian (thanks @MichielB) changing the default editor is also possible by running:

sudo update-alternatives --config editor

Which will prompt the following:

There are 4 choices for the alternative editor (providing /usr/bin/editor).

  Selection    Path                Priority   Status
------------------------------------------------------------
  0            /bin/nano            40        auto mode
  1            /bin/ed             -100       manual mode
  2            /bin/nano            40        manual mode
* 3            /usr/bin/vim.basic   30        manual mode
  4            /usr/bin/vim.tiny    10        manual mode

Press enter to keep the current choice[*], or type selection number: 

On Debian this also works, thanks! It defaults to pico - argh.
Of course it works on Debian; it's a Debian feature, which, like most things (ooh, controversial!), Ubuntu merely inherits. Debian's alternatives system is a much easier way to manage defaults for the supported program types. For reference: debian-administration.org/article/91/…
It works, while GIT_EDITOR and EDITOR not work --ubuntu
@haziz: On my system, one of the listed options is Emacs (others include various versions of Vim, plus nano and ed).
@haziz update-alternatives will show any editors that have been installed. Koen just doesn't have Emacs installed.
D
Dave Jarvis

In windows 7, while adding the "Sublime" editor it was still giving me an error:

Aborting commit due to empty commit message.

Sublime was not able to keep the focus.

To fix this I opened the .gitconfig file in c:/users/username/ folder and added the following line with --wait option outside the single quotes.

[core]
      editor = 'F:/Program Files/Sublime Text 2/sublime_text.exe' --wait

Hope its helpful to somebody facing similar issue with Sublime.


Nice! Thanks Anmol, I was having that issue where it was committing on an empty message.
Why would you want to use sublime for git commits?
Any editor for git commit will mostly be used to add multiple lines of comments and Sublime is a programmer choice for various reason for many developers. People generally have a tendency to use one editor for most of their coding and other works. Sublime is just a personal choice, it can be any editor.
Instead of editing gitconfig manually you can use this command git config --global core.editor "'C:/Program Files/Sublime Text 3/subl.exe' --wait"
H
Henrik Høyer

In Windows 7, setting editor to Notepad++

Open any text editor.

Open this file: C:\Users\YOUR_USERNAME\.gitconfig

Add this section to the bottom:

For 64 bit Notepad++ use:

[core]
    editor = 'C:/Program Files/Notepad++/notepad++.exe' -multiInst -notabbar

For 32 bit Notepad++ use:

[core]
    editor = 'C:/Program Files (x86)/Notepad++/notepad++.exe' -multiInst -notabbar

Save and close the file.

When you're committing with git, just write git commit and press Enter. It will pop open Notepad++.

Write your commit message at the top of the file, and save and close the file. Done!


finally someone who knows how to write it simple! Thanks. But you should mentioned, that in the path to notepad have to be used '/' or double backslash '\\', otherwise git will complain...
You may need to add at least -multiInst as a parameter to notepad++ and possibly -notabbar. Do this if git doesn't seem to know when you've finished editing the file and either waits forever or not at all.
to set the config on the commandline, I need double quotes inside single quotes like >git config --global core.editor '"C:/Program Files (x86)/Notepad++/notepad++.exe"'
still opens the normal notepad for me
To add the Notepadd++ params, I had to do this: editor = 'C:/Program Files (x86)/Notepad++/notepad++.exe' -multiInst -notabbar - that is, params outside the delimiting single quotes
M
Mateen Ulhaq

To make Visual Studio Code (vscode) the default git editor:

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

t
tristanbailey

And if you are working with designers using the command line then Pico, and dont know short cuts ;)

git config --global core.editor "pico"

Or

export VISUAL=pico
export EDITOR=pico

C
Community

Atom as your git editor

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

Atom needs to be configured to run from the command line for the above to work: OS X: install shell commands from Atom: menu bar > Atom > Install Shell Commands Windows: no action required - atom is configured to run from the command line by default


VSCode users: git config --global core.editor "code --wait"
N
Nick Volynkin

Setting Sublime Text 2 as Git commit editor in Mac OSX 10

Run this command:

$ git config --global core.editor "/Applications/Sublime\ Text\ 2.app/Contents/SharedSupport/bin/subl"

Or just:

$ git config --global core.editor "subl -w"

Somehow it's not delivering the text to git. I got 'Aborting commit due to empty commit message.' error.
I have used the first command to setup SL. cmd + S then cmd +W to close editor
Visual Studio Code also support the -w parameter. Eg. $ git config --global core.editor "code -w". Neat stuff
Alternate answer here: stackoverflow.com/a/48212377/4561887, with Linux example.
H
Hamfri

To make vim the default editor for git on ubuntu 20:04 run the following command:

git config --global core.editor vim

S
SherylHohman

This provides an answer for people who arrive at this Question that may want to link an editor other than vim.

The linked resource, by Github,is likely to be kept up to date, when editors are updated, even if answers on SO (including this one) are not.

Associating Text Editors with git

Github's post shows exactly what to type in to your command line for various editors, including the options/flags specific to each editor for it to work best with git.

Notepad++:
git config --global core.editor "'C:/Program Files (x86)/Notepad++/notepad++.exe' -multiInst -notabbar -nosession -noPlugin"

Sublime Text:
git config --global core.editor "'c:/Program Files/sublime text 3/subl.exe' -w"

Atom:
git config --global core.editor "atom --wait"

The commands above assume your editor has been installed in the default directory for a windows machine.

The commands basically add the text between double-quotes to .gitconfig in your home directory.
On a windows machine home is likely to be C:\Users\your-user-name, where your-user-name is your login name.
From the command line, you can reach this directory by typing in cd ~.

for example, a command above would be add the following line under the [core] section like so:
[core] editor = 'C:/Program Files/sublime text 3/subl.exe' -w

If you have a different editor, just replace with the path to your editor, using either method above. (and hope no flags are needed for optimal usage.)


Thanks, I was struggling with the fact that just "vim" launched the "internal" vim instance for Git (without my preferences, etc.). Providing the full path to my instance solved the issue!
S
Sнаđошƒаӽ

Windows: setting notepad as the default commit message editor

git config --global core.editor notepad.exe

Hit Ctrl+S to save your commit message. To discard, just close the notepad window without saving.

In case you hit the shortcut for save, then decide to abort, go to File->Save as, and in the dialog that opens, change "Save as type" to "All files (*.*)". You will see a file named "COMMIT_EDITMSG". Delete it, and close notepad window.

Edit: Alternatively, and more easily, delete all the contents from the open notepad window and hit save. (thanks mwfearnley for the comment!)

I think for small write-ups such as commit messages notepad serves best, because it is simple, is there with windows, opens up in no time. Even your sublime may take a second or two to get fired up when you have a load of plugins and stuff.


Instead of going to File->Save as, you could blank the file (or comment out any non-blank lines), and then Git will abort due to an empty commit message.
better you add the line like this core.editor = 'notepad' .git/COMMIT_EDITMSG --wait so it opens and saves the default edit message and you dont need "save as"
B
Bendlas

For emacs users

.emacs:

(server-start)

shellrc:

export EDITOR=emacsclient

Here's how to set emacs in terminal mode when comiting git config --global core.editor "emacs -nw"
I use git config --global core.editor "emacs -nw -q", where the -q skips initialization files.
G
Gabriel Staples

Best settings for Sublime Text 3 or 4 as your Git editor (Windows & Linux instructions):

To follow these instructions in Windows make sure you have installed Git for Windows. In Windows, I like to use Git Bash so that it feels more like Linux.

First, we want to create a special Sublime Text project so that we can specify special project settings we want set whenever Git calls the editor, to make things easier when editing in Git. For example, I normally set my ruler to 120 chars in most projects, but for Git commit messages I want it to be 72 characters so that it fits nicely in a terminal when you call git log or git lg.

1. Create a Sublime Text project with settings we want to use to edit Git commit messages

Open Sublime Text and go to menu "File""New Window" to create a new anonymous project. Go to menu "Project""Save Project As..." and choose a place to save it. In Linux I saved it in my Linux home directory with the file name .gitconfig.sublime-project. Its path is therefore: ~/.gitconfig.sublime-project. In Windows also save it in your home directory, for example: C:\Users\MY_USER_NAME\.gitconfig.sublime-project Now go to menu "Project""Edit Project" to edit the project settings. Paste the following and save the settings. Make any further edits for your project settings if desired.

{
    // For folder settings help see here: https://www.sublimetext.com/docs/3/projects.html

    "folders":
    [

    ],

    "settings":
    {

        // Disables horizontal scrolling if enabled.
        // May be set to true, false, or "auto", where it will be disabled for
        // source code, and otherwise enabled.
        "word_wrap": false,

        // Set to a value other than 0 to force wrapping at that column rather than the
        // window width
        "wrap_width": 0,

        // Columns in which to display vertical rulers
        "rulers": [72, 50], //72 is recommended by git for commit message content, and 50 for commit titles

        // The number of spaces a tab is considered equal to
        "tab_size": 4,

        // Set to true to insert spaces when tab is pressed
        "translate_tabs_to_spaces": true,
    },

    "build_systems":
    [

    ]

}

2. Set the editor to be used by Git

Now we need to set the editor to be used by Git, by editing the .gitconfig file.

For Linux:

Your user copy of this will be located in ~/.gitconfig. Open this file and add the following lines. Be sure to use the proper path name to the Git project you just created above! I'm using ~/.gitconfig.sublime-project.

[core]
    editor = subl --project ~/.gitconfig.sublime-project --wait

The --wait is important, as it forces Git to wait until you close the file before it continues on. The --project line is important to tell Sublime Text which project you want opened whenever Git opens Sublime Text.

Per @digitaldreamer's answer above (https://stackoverflow.com/a/2596835/4561887), "subl can be replaced by the full path of the executable but [the alias subl] is usually available when [Sublime is] correctly installed."

For Windows:

For Windows, first read the Linux instructions for background information. Now we will do something almost identical.

(OPTIONAL: create a subl alias for use in Git Bash):

Open up a text editor (for example, Notepad, Notepad++, Sublime Text, Geany, etc.), and create a file called ".bash_profile" in your home directory. Its path will therefore be: C:\Users\MY_USER_NAME\.bash_profile. Save the following into it:

alias subl="/c/Program\ Files/Sublime\ Text\ 3/subl.exe"

This creates a Git Bash alias called subl that we can now use in Git Bash for Windows, to easily open Sublime Text. This step isn't required, but it's useful for general Git Bash use. Now you can call subl ., for instance, in Git Bash to open up a new Sublime Text project in your current directory.

(MANDATORY):

Edit the .gitconfig file found in your home directory: C:\Users\MY_USER_NAME\.gitconfig, by adding the following to it. Notice the subtle changes from the Linux instructions above:

[core]
  editor = 'C:/Program Files/Sublime Text 3/subl.exe' --project ~/.gitconfig.sublime-project --wait

Notice that you must specify the full path to the Sublime Text executable. Note the direction of the slashes! Use / NOT \ to separate folders in the path name! (Thanks VonC for helping me see this).

Our subl alias we made for Git Bash above doesn't work here, so you can't use it like we did in the Linux example, instead you must specify the whole path as shown above.

The ~ symbol, however, does still work here to get to your Windows home directory.

2.5. (Optional) Install the "Git" package into Sublime Text 3.

This gives you syntax highlighting for git commit messages, as well as access to other Git commands such as git blame (which I use frequently in Sublime Text) or git commit (which I don't use in Sublime Text since I'd prefer the command-line for general Git flow, as I've mentioned in my comments below this answer).

To install a package: First, ensure “Package Control” is installed. Next, press Ctrl + Shift + P (same as Tools → Command Palette) and type all or part of “Package Control: Install Package”, then press Enter. In the search box that comes up, search for the package "Git" and hit Enter on it, or click on it, to automatically install it.

Once installed, Ctrl + Shift + P then searching for "git" will bring up Git commands you can use internally inside Sublime Text now, such as git blame.

3. Use it

Now when you call git commit, for instance, as normal from the command-line, Sublime Text will open up into the .gitconfig.sublime-project we created above, with that project's settings! As you type a paragraph you'll notice it extends past the ruler we set since soft word-wrap is off. To force hard wrap via auto-inserted hard-returns at the end of each line, put your cursor on the long line you want auto-wrapped and press Alt + Q. It will now hard-wrap/hard-fold at 72 characters, which is what we set in the project settings' "rulers" parameter above.

Now, save your commit message with Ctrl + S, and exit (to complete your git commit) with Ctrl + Shift + W.

Done!

Related:

Git mergetool with Meld on Windows https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles


That looks quite detailed. +1
In Sublime Text 3, there is now a Git Commit syntax type. You can skip the custom "sublime-text project" step now.
I disagree: that does syntax highlighting only. My custom project doesn't touch syntax higlighting: it sets rulers and gives a context for your git commits to open up in so they don't open up in whatever project you have or last had open. The two are unrelated; do them both.
I just added step 2.5, BUT (bit "but" here): I don't always use Sublime Text 3 as my editor (sometimes I use Eclipse since it has far superior symbol tracking and indexing than Sublime even though it's otherwise a crappy editor compared to Sublime), and I really prefer to use Git from the command-line, so I most definitely do not recommend skipping Step 1 even if you install the "Git" package into Sublime as I've described in Step 2.5 just now. Yes you can do Git Commits straight from Sublime but I'd prefer the command line.
TIP: If you use sublime with git and also use trim_trailing_white_space_on_save you want to add an alias for patch adding because removing trailing white space breaks patch edits where it's very much meaningful. This can be achieved with something like this: git config --global alias.patch "-c core.editor=vim add --patch"
M
Matteo Rolla

Mvim as your git editor

Like all the other GUI applications, you have to launch mvim with the wait flag.

git config --global core.editor "mvim --remote-wait"

--remote-wait-silent to avoid ugly error message :)
P
Peter Mortensen

For Mac OS X, using TextEdit or the natural environmental editor for text:

git config --global core.editor "open -W -n"

b
bigtheo

there is a list of commad that you can use but for vs code use this

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

this is the link for all editor :https://git-scm.com/book/en/v2/Appendix-C%3A-Git-Commands-Setup-and-Config


b
brcolow

For Windows users who want to use neovim with the Windows Subsystem for Linux:

git config core.editor "C:/Windows/system32/bash.exe --login -c 'nvim .git/COMMIT_EDITMSG'"

This is not a fool-proof solution as it doesn't handle interactive rebasing (for example). Improvements very welcome!


B
Ben Saufley

Just because I came here looking for a one-time solution (in my case, I usually use vim but this one time I wanted to use VS Code) for a single command and others might want to know as well:

GIT_EDITOR='code -w' git rebase -i …

Here's my git/hub version just for context:

git version 2.24.2 (Apple Git-127)
hub version 2.14.1

X
Xiao Hanyu

Just try EDITOR=vim git commit.

Or you can set your EDITOR to vim by export EDITOR=vim in your bashrc.


D
DLRdave

For users of TextWrangler from the Mac app store:

git config --global core.editor "open -n -W -a TextWrangler"

Also, make sure your "TextWrangler > Preferences > Application > When TextWrangler becomes active:" setting is set to "Do nothing"

This works for me on OS X 10.11.4 with TextWrangler 5.0.2 from the Mac app store.

Explanation:

The -n means open in a new instance.

The -W means to wait until the application exits before using the contents of the edited file as the commit message.

The -a TextWrangler means use the TextWrangler application to open the file.

See man open in your Mac Terminal app for more details.


If TextWrangler is already open your solution will open another instance with the same file set of the first one. This seems dangerous.
I did install the TextWrangler command line tools (barebones.com/support/textwrangler/cmd-line-tools.html) and then used git config --global core.editor "edit -w". This will open the commit message in the current instance and as soon as you close only this commit message document, the commit will continue.
É
Édouard Lopez

When using git-review I had to modify sequence.editor value to be able to do interactive rebase (git rebase -i -p):

git config --global sequence.editor "gvim"  # or whatever your prefer

gvim require: apt install vim-gtk

References

#2944 Interactive Rebase failed with warning: "Vim: Warning: Output is not to a terminal"

Install section of sjurba/rebase-editor


l
leanne

On macOS Big Sur (11.0) beta for TextMate: none of the environment variable options worked. (Set all three: GIT_EDITOR, VISUAL, and EDITOR.)

Finally set the global core.editor in git, and that worked:
git config --global core.editor "~/bin/mate -w"


C
Carson

For Windows, Neovim:

# .gitconfig

[core]
    editor='C:/tools/neovim/Neovim/bin/nvim-qt.exe'

P
Petra

For IntelliJ users

When i was trying to git rebase i was getting the following error: 'hint: Waiting for your editor to close the file... code -n -w: code: command not found error: There was a problem with the editor 'code -n -w'.'

https://i.stack.imgur.com/iKVF5.png

The problem was that I did not have the command code added in my environment PATH variable. And i didn't want to use Visual Studio Code from my terminal. So that is why it prompted "command not found". I solved this by deleting

editor = code -n -w

from the core section in my .gitconfig file. Git worked properly again.


Y
Yutaka

For EmEditor users

To set EmEditor as the default text editor for Git, open Git Bash, and type:

git config --global core.editor "emeditor.exe -sp"

EmEditor v19.9.2 or later required.


s
saulspatz

For MAC, BBEdit:

First, open BBEdit, click on the BBEdit logo, and choose Install Command-Line Tools.

Then from the command line,

git config --global core.editor "BBEdit -w"

N
Nick Volynkin

For Textmate Users

This opens Textmate editor in when you want to edit your commits. Requires textmate command line tools to be installed.

git config --global core.editor "mate -w"


@givanse what do you mean?
I guess he means it's trivial by analogy to the vim answer ?
hmm no it isn't, but if you use something else than vim (such as textmate).
textmate also has a "wait" option, so for me, it's this: git config --global core.editor "/usr/local/bin/mate -w"
M
Mike Cheel

For Windows users who want to use Kinesics Text Editor

Create a file called 'k.sh', add the following text and place in your home directory (~):

winpty "C:\Program Files (x86)\Kinesics Text Editor\x64\k.exe" $1

At the git prompt type:

git config --global core.editor ~/k.sh