Fish (Unix shell)

Short description: User-friendly interactive Unix shell

Fish

The fish shell. Its tagline, "fish - the friendly interactive shell", is displayed at the top.

Original author(s)| Axel Liljencrantz
Developer(s)| Fish-shell developers[1]
Initial release| 13 February 2005; 21 years ago (2005-02-13)
Written in| Rust
Operating system| Unix-like
Type| Unix shell
License| GPL-2.0-only[2]
Website| fishshell.com

fish is a Unix shell with a focus on interactivity and usability. Fish is designed to give the user features by default, rather than by configuration.[3] Fish is considered an exotic shell since it does not adhere to POSIX shell standards, at the discretion of the maintainers.[4]

## Contents

* 1 Highlights
* 2 Syntax
* 2.1 No implicit subshell
* 2.1.1 Variable assignment example
* 3 Universal variables
* 4 Other features
* 5 Bash/fish translation table
* 6 See also
* 7 References
* 8 External links

## Highlights

Fish has "search as you type" automatic suggestions based on history and current directory. This is essentially like Bash's history search, but because it is always on instead of being a separate mode, the user gets continuous feedback while writing the command line, and can select suggestions with the arrow keys, or as in Bash, press for a tab completion instead. Tab-completion is feature-rich and has expanding file paths (with wildcards and brace expansion), variables, and many command specific completions. Command-specific completions, including options with descriptions, can to some extent be generated from the commands' man pages.

Fish prefers features as commands rather than syntax. This makes features discoverable in terms of commands with options and help texts. Functions can also carry a human readable description. A special help command gives access to all the fish documentation in the user's web browser.[5]

## Syntax

The syntax resembles a POSIX compatible shell (such as Bash), but deviates in important ways where the creators believe the POSIX shell was badly designed.[6]

# Variable assignment

# Set the variable 'foo' to the value 'bar'.
# Fish doesn't use the = operator, which is inherently whitespace sensitive.
# The 'set' command extends to work with arrays, scoping, etc.

> set foo bar
> echo $foo
bar

# Command substitution

# Assign the output of the command 'pwd' into the variable 'wd'.
# Fish doesn't use backticks (``), which can't be nested and may be confused with single quotes (' ').

> set wd (pwd)
> set wd $(pwd) # since version 3.4
> echo $wd

# Array variables. 'A' becomes an array with 5 values:
> set A 3 5 7 9 12
# Array slicing. 'B' becomes the first two elements of 'A':
> set B $A[1 2]
> echo $B
3 5
# You can index with other arrays and even command
# substitution output:
> echo $A[(seq 3)]
3 5 7
# Erase the third and fifth elements of 'A'
> set --erase A[$B]
> echo $A
3 5 9

# for-loop, convert jpegs to pngs
> for i in *.jpg
convert $i (basename $i .jpg).png
end

# fish supports multi-line history and editing.
# Semicolons work like newlines:
> for i in *.jpg; convert $i (basename $i .jpg).png; end

# while-loop, read lines /etc/passwd and output the fifth
# colon-separated field from the file. This should be
# the user description.
> while read line
set arr (echo $line|tr : \n)
echo $arr[5]
end < /etc/passwd

# String replacement (replacing all i by I)
> string replace -a "i" "I" "Wikipedia"
WIkIpedIa

### 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 for the shell and then exit. 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 forks off so-called subshells; all builtins are always fully functional.

# This will not work in many other shells, since the 'read' builtin
# will run in its own subshell. In Bash, the right side of the pipe
# can't have any side effects. In ksh, the below command works, but
# the left side can't have any side effects. In fish and zsh, both
# sides can have side effects.
> cat *.txt | read line

#### 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.

found=''
cat /etc/fstab | while read dev mnt rest; do
if test "$mnt" = "/"; then
found="$dev"

done

Workaround:

found=''
while read dev mnt rest; do
if test "$mnt" = "/"; then
found="$dev"

done < /etc/fstab

Fish example:

set found ''
cat /etc/fstab | while read dev mnt rest
if test "$mnt" = "/"
set found $dev
end
end

## Universal variables

Fish has a feature known as universal variables, which allow 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.

# This will make emacs the default text editor. The '--universal' (or '-U') tells fish to
# make this a universal variable.
> set --universal EDITOR emacs

# This command will make the current working directory part of the fish
# prompt turn blue on all running fish instances.
> set --universal fish_color_cwd blue

## Other features

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

## Bash/fish translation table

Feature | Bash syntax | fish syntax | Comment

|
|
|

variable expansion:
with word splitting and glob interpretation |

$var

${var[@]}

${var[*]}

| deliberately omitted | Identified as a primary cause of bugs in posix compatible shell languages[7]
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"

edit line in text editor | , |  | Upon invocation, moves line input to a text editor
evaluate line input |  | N/A[8] | Evaluates expressions in-place on the line editor
history completion |  | 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

variable assignment |

var=value

set var value

string processing:
replace |

"${HOME/alice/bob}"

string replace alice bob $HOME

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

export variable |

export var

set --export var

| Options discoverable via tab completion
function-local variable |

local var

| by default
scope-local variable | no equivalent  |

set --local var

remove variable |

unset var

set --erase var

check if a variable exists |

test -v var

set --query var

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

argument vector:
all arguments |

"$@"

$argv

argument vector:
indexing |

"$1"

$argv[1]

argument vector:
length |

(count $argv)

argument vector:
shift |

shift

set --erase argv[1]

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'

| `printf '\e'` works in both shells; their `printf` builtins are both compatible with the GNU `printf` standalone program.[9]
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).

## See also

* Comparison of command shells

## References

1. ↑ "fish shell team members". GitHub.com. https://github.com/fish-shell?tab=members.
2. ↑ fishshell.com License for fish
3. ↑ Liljencrantz, Axel (2005-05-17). "Fish - A user-friendly shell". Linux Weekly News. https://lwn.net/Articles/136232.
4. ↑ "Fish docs: design". https://fishshell.com/docs/current/design.html.
5. ↑ Linux.com. CLI Magic: Enhancing the shell with fish. Retrieved 2010-03-24.
6. ↑ Paul, Ryan (19 December 2005). "An in-depth look at fish: the friendly interactive shell". https://arstechnica.com/information-technology/2005/12/linux-20051218/2/. "the Posix syntax has several missing or badly implemented features, including variable scoping, arrays, and functions. For this reason, fish strays from the Posix syntax in several important places."
7. ↑ "Bash Pitfalls". http://mywiki.wooledge.org/BashPitfalls. "This page shows common errors that Bash programmers make. (…) You will save yourself from many of these pitfalls if you simply always use quotes and never use word splitting for any reason! Word splitting is a broken legacy misfeature inherited from the Bourne shell that's stuck on by default if you don't quote expansions. The vast majority of pitfalls are in some way related to unquoted expansions, and the ensuing word splitting and globbing that result."
8. ↑ "RFC: Add binding to expand/evaluate tokens on commandline". 2013-05-16. https://github.com/fish-shell/fish-shell/issues/751.
9. ↑ "printf does not support \e". 11 Jul 2013. https://github.com/fish-shell/fish-shell/issues/910.

## External links

* – containing documentation and downloads
* fish on GitHub (active)
* fish on Gitorious (obsolete)
* fish on SourceForge (obsolete)
* Fish-users – general discussion list for fish users
* Shell Translation Dictionary \- another Bash/Fish translation table

* v
* t
* e

Unix shells

* Almquist
* Bash
* Bourne
* csh
* es
* fish
* Hamilton
* Korn
* PWB
* rc
* sash
* tcsh
* Thompson
* Wish
* Zsh

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Fish (Unix shell). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Fish_(Unix_shell)&oldid=541334"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template