`Completion' is where you hit a particular command key (TAB is the standard one) and the shell tries to guess the word you are typing and finish it for you --- a godsend for long file names, in particular, but in zsh there are many, many more possibilities than that.
There is also a related process, `expansion', where the shell sees
you have typed something which would be turned by the shell into
something else, such as a variable turning into its value ($PWD
becomes /home/users/mydir) or a history reference (!! becomes
everything on the last command line). In zsh, when you hit TAB it
will look to see if there is an expansion to be done; if there is,
it does that, otherwise it tries to perform completion. (You can
see if the word would be expanded --- not completed --- by TAB by
\C-x g, which lists expansions.) Expansion is generally
fairly intuitive and not under user control; for the rest of the
chapter I will discuss completion only.
An elegant completion system appeared in version 4, replacing the old
compctl command. This is based on functions called automatically for
completion in particular contexts (for example, there is a function
_cd to handle completion for the
cd command) and is
installed automatically with the shell, so all you need to do, in
principal, is to arrange for this to be loaded. Putting `
compinit; compinit' in your
.zshrc should be enough if the system is
The simplest sort is filename completion, mentioned above. Unless you have made special arrangements, as described below, then after you type a command name, anything else you type is assumed by the completion system to be a filename. If you type part of a word and hit TAB, zsh will see if it matches the first part a filename and if it does it will automatically insert the rest.
The other simple type is command completion, which applies (naturally) to the first word on the line. In this case, zsh assumes the word is some command to be executed lying in your $PATH (or something else you can execute, like a builtin command, a function or an alias) and tries to complete that.
However, the new completion system is highly sensitive to context
and comes with completions for many UNIX commands. These are
automatically loaded when you run
compinit as described above.
So the real answer to the question `what can be completed?' is
`anything where an automated guess is possible'. Just hit TAB
and see if the shell manages to guess correctly.
Often there will be more than one possible completion: two files
start with the same characters, for example. Zsh has a lot of
flexibility for what it does here via its options. The default is
for it to beep and completion to stop until you type another
character. You can type
\C-D to see all the possible completions.
(That's assuming you're at the end of the line, otherwise
delete the next character and you have to use
ESC-\C-D.) This can be
changed by the following options, among others:
NO_BEEPset, that annoying beep goes away
NO_LIST_BEEP, beeping is only turned off for ambiguous completions
AUTO_LISTset, when the completion is ambiguous you get a list without having to type
BASH_AUTO_LISTset, the list only happens the second time you hit tab on an ambiguous completion
LIST_AMBIGUOUS, this is modified so that nothing is listed if there is an unambiguous prefix or suffix to be inserted --- this can be combined with
BASH_AUTO_LIST, so that where both are applicable you need to hit tab three times for a listing.
MENU_COMPLETEset, one completion is always inserted completely, then when you hit TAB it changes to the next, and so on until you get back to where you started
AUTO_MENU, you only get the menu behaviour when you hit TAB again on the ambiguous completion.
ALWAYS_LAST_PROMPT, which causes the cursor to return to the line you were editing after printing the list, provided that is short enough.
AUTO_MENUtogether give an intuitive combination. Note that from version 3.1
LIST_AMBIGUOUSis set by default; if you use autolist, you may well want to `unsetopt listambiguous'.
Sometimes you have a word on the command-line which is incomplete in the middle. Normally if you hit tab in zsh, it will simply go to the end of the word and try to complete there. However, there are two ways of changing this.
First, there is the option COMPLETE_IN_WORD. This tries to fill in
the word at the point of the cursor. For example, if the current
foobar, then with the option set, you can
foobar by moving the cursor to the
b and hitting tab.
To complete just what's before the cursor, ignoring anything after, you
need the function
expand-or-complete-prefix: it works mostly like the
usual function bound to tab, but it ignores anything on the right of the
cursor. If you always want this behaviour (some other shells do this),
bind it to tab; otherwise put another binding, e.g.
^X TAB in
bindkey "^X^I" expand-or-complete-prefix
The completion system's handling of filenames allows you to complete
multiple segments of a path in one go, so for example
can expand to
/usr/local/bin or anything else that matches. This
saves you having to expand the middle part of the path separately.
The main resource is the
zshcompsys manual page. It's complicated,
I'm afraid, far too much to go into here. See also the user guide
referred to above, or copy one of the very many existing functions. For
a professionally produced guide, see the book `From Bash to Z Shell:
Conquering the Command Line' by Oliver Kiddle, Jerry Peek and Peter
Stephenson (me), published by Apress, ISBN 1-59059-376-6. Chapter 10
tells you how to configure the completion system and chapter 15 how
to write your own completion functions.
If you're using the completion system the shell will decide what to complete when you hit TAB. That's usually the right thing for the context, but sometimes you just want to complete files, like TAB used to do in the old days. You can set up this up as follows:
zle -C complete-file complete-word _generic zstyle ':completion:complete-file::::' completer _files bindkey '^xF' complete-fileThis turns the key
\C-x Finto a command
complete-filewhich goes straight to the completion system's file completion command, ignoring the normal context. Change the binding how you like.
Note the way the form of completion to use is specified by picking a
`completer' called `
_files'. You can define any completion
to be bound to a keystroke by putting the appropriate completion
function at that point. Then change all occurrences of
complete-file' to a name of your own.
If you simply want to try filename completion as a default when other
completions fail, add it to the `
completer' style for normal
completion, for example:
zstyle ':completion:*' completer _complete _ignored _filesThis adds filename completion to the end of the default types of completion. Your actual completer style may include other actions, such as expansion or approximate completion.