# Fish (Unix shell)

Fish (or friendly interactive shell- stylized in lowercase) is a Unix-like shell with a focus on interactivity and usability. Fish is designed to be feature-rich by default, rather than highly configurable. Fish is considered an exotic shell since it does not adhere to POSIX shell standards, at the discretion of its maintainers.

## Features

Fish displays incremental suggestions as the user types, based on command history and the current directory. This functions similarly to Bash's Ctrl+R history search, but is always on, giving the user continuous feedback while typing commands. Fish also includes feature-rich tab completion, with support for expanding file paths (with wildcards and brace expansion), environment variables, and command-specific completions. Command-specific completions, including options with descriptions, can be to some extent generated from the commands' man pages, but custom completions can also be included with software or written by users of the shell.
The creator of Fish preferred to add new features as commands rather than syntax. This made features more discoverable, as the built-in features allow searching commands with options and help texts. Functions can also include human readable descriptions. A special help command gives access to all the fish documentation in the user's web browser.

## Syntax

The syntax resembles a POSIX compatible shell (such as Bash), but deviates in many ways

### No implicit subshell

Some language constructs, like pipelines, functions and loops, have been implemented using so called subshells in other shell languages. Subshells are child programs that run a few commands in order to perform a task, then exit back to the parent shell. This implementation detail typically has the side effect that any state changes made in the subshell, such as variable assignments, do not propagate to the main shell. Fish never creates subshells for language features; all builtins happen within the parent shell.

#### Variable assignment example

This Bash example doesn't do what it seems: because the loop body is a subshell, the update to $found is not persistent.
Workaround:
Fish example:

## Universal variables

Fish has a feature known as universal variables, which allows a user to permanently assign a value to a variable across all the user's running fish shells. The variable value is remembered across logouts and reboots, and updates are immediately propagated to all running shells.

## Other features

* Advanced tab completion (with support for writing custom completions).
* Syntax highlighting with extensive error checking.
* Support for the X clipboard.
* Smart terminal handling based on terminfo.
* Searchable command history.
* Web-based configuration (fish_config).

## Bash/fish translation table

| Feature | Bash syntax | fish syntax | Comment |
| variable expansion: with word splitting and glob interpretation | $var or ${var[@]} or ${var[*]} | deliberately omitted | Identified as a primary cause of bugs in posix compatible shell languages |
| variable expansion: scalar | "$var" | deliberately omitted | Every variable is an array |
| variable expansion: array | "${var[@]}" | $var | Quoting not necessary to suppress word splitting and glob interpretation. Instead, quoting signifies serialization. |
| variable expansion: as a space separated string | "${var[*]}" | "$var" | Quoting not necessary to suppress word splitting and glob interpretation. Instead, quoting signifies serialization. |
| edit line in text editor | Ctrl+X,Ctrl+E | Alt+E | Upon invocation, moves line input to a text editor |
| evaluate line input | Ctrl+Alt+E | — | Evaluates expressions in-place on the line editor |
| history completion | Ctrl+R | implicit | |
| history substitution | !! | deliberately omitted | Not discoverable |
| explicit subshell | (expression) | fish -c expression |
| command substitution | "$(expression)" | "$(expression)" or (expression | string collect) | |
| process substitution | <(expression) | (expression | psub) | Command, not syntax |
| logical operators | !cmd && echo FAIL || echo OK | not command and echo FAIL or echo OK | Command, not syntax |
| variable assignment | var=value | set var value | Command, not syntax |
| string processing: replace | "${HOME/alice/bob}" | string replace alice bob $HOME | Command, not syntax |
| string processing: remove prefix or suffix pattern, non-greedily or greedily | var=a.b.c "${var#*.}" #b.c "${var##*.}" #c "${var%.*}" #a.b "${var%%.*}" #a | string replace --regex '.*?\.(.*)' '$1' a.b.c #b.c string replace --regex '.*\.(.*)' '$1' a.b.c #c string replace --regex '(.*)\..*' '$1' a.b.c #a.b string replace --regex '(.*?)\..*' '$1' a.b.c #a | Command, not syntax |
| export variable | export var | set --export var | Options discoverable via tab completion |
| function-local variable | local var | by default | Options discoverable via tab completion |
| scope-local variable | no equivalent | set --local var | Options discoverable via tab completion |
| remove variable | unset var | set --erase var | Options discoverable via tab completion |
| check if a variable exists | test -v var | set --query var | Options discoverable via tab completion |
| array initialization | var=( a b c ) | set var a b c | Every variable is an array |
| array iteration | for i in "${var[@]}"; do echo "$i" done | for i in $var echo $i end | Every variable is an array |
| argument vector: all arguments | "$@" | $argv | Every variable is an array |
| argument vector: indexing | "$1" | $argv[1] | Every variable is an array |
| argument vector: length | $# | (count $argv) | Every variable is an array |
| argument vector: shift | shift | set --erase argv[1] | Every variable is an array |
| array representation in environment variables | PATH="$PATH:$HOME/.local/bin" | set PATH $PATH $HOME/.local/bin | fish assumes colon as array delimiter for translating variables to and from the environment. This aligns with many array-like environment variables, like $PATH and $LS_COLORS. |
| export and run | LANG=C.UTF-8 python3 | env LANG=C.UTF-8 python3 | env LANG=C.UTF-8 python3 works in any shell, as env is a standalone program. |
| arithmetic | $((10/3)) | math '10/3' | expr 10 / 3 works in any shell, as expr is a standalone program. |
| escape sequence | $'\e' | \e | printf '\e' works in both shells; their printf builtins are both compatible with the GNU printf standalone program. |
| single quoted string: escape sequences | 'mom'\''s final backslash: \' | 'mom\'s final backslash: \\' | Bash only requires replacement of the single quote itself in single quoted strings, but the replacement is 4 characters long. The same replacement works in fish, but fish supports a regular escape sequence for this, thus requires escaping backslashes too (except permits single backslashes that don't precede another backslash or single quote). |