Shell Unix

Shell Bash sur Linux

Un shell Unix est un interpréteur de commandes destiné aux systèmes d'exploitation Unix et de type Unix qui permet d'accéder aux fonctionnalités internes du système d'exploitation. C'est l'interface utilisateur du système d'exploitation, il permet entre autres de se déplacer dans l'arborescence du système, créer, éditer ou supprimer des répertoires et des fichiers. Il se présente sous la forme d'une interface en ligne de commande accessible depuis la console ou un terminal. L'utilisateur lance des commandes sous forme d'une entrée texte exécutée ensuite par le shell. Les commandes sont des fichiers exécutables, située dans certains répertoires du système. Le shell est donc un programme qui peut exécuter ces commandes ; il se trouve dans le répertoire `/bin`.

Les systèmes d'exploitation de type Unix disposent le plus souvent d'un shell. Il existe une trentaine de shell différents. À l'origine, l'interpréteur de commandes par défaut était sh. Aujourd'hui bash est le shell le plus répandu.

## Historique des shells Unix

[modifier | modifier le code]

Le premier shell est le Thompson shell (en) apparu en 1971 avec la première version d’Unix et écrit par Ken Thompson, l'un des créateurs d'Unix. Il est remplacé par le Bourne shell, écrit par Stephen Bourne, en 1977 pour la version 7 d'Unix.

En 1978, Bill Joy, alors étudiant à l'Université de Californie à Berkeley, crée csh (C shell), une évolution du shell dont la syntaxe s'inspire de celle du langage C. Il permet notamment la réutilisation de l'historique des commandes. Une version plus moderne du csh est ensuite publiée sous le nom tcsh.

Le Korn shell (ksh) est publié en 1983 par David Korn. Il est compatible avec le Bourne shell, reprend certaines fonctionnalités de csh et ajoute des fonctions de scripts avancées disponibles dans des langages plus évolués tels que le Perl.

Le Bourne-Again shell (bash) apparait quant à lui en 1988. Il est écrit par Brian Fox pour la Free Software Foundation dans le cadre du projet GNU. C'est le shell de nombreuses implémentations libres d'Unix, telles que les systèmes GNU/Linux. Il est compatible avec le Bourne shell dont il se veut une implémentation libre.

Paul Falstad crée zsh en 1990 alors qu'il est étudiant à l'université de Princeton. Ce shell reprend les fonctions les plus pratiques de bash, csh, tcsh.

## Shells

[modifier | modifier le code]

À l'origine, l'interpréteur de commandes par défaut était sh, qui donna naissance à de nombreuses variantes, dont csh, étendu en tcsh, ou ksh, ou encore rc. Aujourd'hui bash, s'inspirant de sh, ksh, et csh, est le shell le plus répandu, bien qu'il existe d'autres interpréteurs de commandes, comme zsh, ou ash.

* Shell de Stephen Bourne
* Bourne shell (sh)
* Bourne-Again shell (bash)
* csh : C shell
* tcsh (Tenex C shell, version moderne du csh)
* Shell de David Korn : Korn shell (ksh)
* Shell de Kenneth Almquist, utilisé lorsqu'il est nécessaire d'avoir un shell prenant peu de place sur le disque, clone de la variante SVR4 du Bourne shell;
* Ash (Almquist SHell)
* Dash shell (Debian Almquist Shell)
* Zsh (zsh), reprenant les fonctions les plus pratiques de bash, ksh et tcsh.
* fish

## Utilisation

[modifier | modifier le code]

Le shell est un programme, exécutable en mode terminal, qui se trouve dans le répertoire `/bin`[1], et qui permet à l'utilisateur d’interagir avec le système en utilisant des commandes. L'utilisateur tape une commande, et le shell va interpréter cette commande et l'exécuter[2]. Une commande est un fichier exécutable, se trouvant dans certains répertoires du système[1]. La localisation du répertoire de chaque commande dépend du type de distribution Linux. Il est possible d'utiliser la commande `whereis` pour connaitre cette localisation[3].

### Exemple

[modifier | modifier le code]

Une session avec l'interpréteur tcsh :

[ske:~] ske% cd /usr/
[ske:/usr] ske% ls
bin             lib             local           share
include         libexec         sbin            standalone
[ske:/usr] ske% top
[ske:/usr] ske% cd /tmp
[ske:/tmp] ske% ls -l
total 152
-rw-r--r--  1 ske   admin  68328 15 Apr 10:54 93633C68062E855100FCE70A
-rw-r--r--  1 ske   admin      0 19 Apr 09:28 cs_cache_lock_501
-rw-r--r--  1 root  admin    644 23 Apr 09:05 mcx_compositor
drwxr-xr-x  3 ske   admin    102 19 Apr 11:39 pb-man
-rw-r--r--  1 ske   admin     74 15 Apr 10:54 reload-stub.s
srwxrw-rw-  1 root  admin      0 23 Apr 09:04 slp_ipc
[ske:/tmp] ske% echo Hello World >test.tmp
[ske:/tmp] ske% cat test.tmp
Hello World
[ske:/tmp] ske% rm test.tmp
[ske:/tmp] ske%

Si on regarde la première ligne de cet exemple :

`[ske:~] ske% cd /usr/`

Entre crochets, `[ske:~]` nous indique que l'on se trouve dans le répertoire (dossier) home de l'utilisateur. C'est ce que signifie le signe tilde[4]. Ensuite, `ske%` est le signal d'invit (prompt), en attente d'une commande. La première commande tapée est ici `cd`, qui permet de changer de répertoire. Elle est suivie du nom de répertoire `/usr/`.

Sur la deuxième ligne, on voit que l'on s'est effectivement déplacé : on se trouve maintenant dans le répertoire usr, comme l'indique le début de la ligne : `[ske:/usr]`. On utilise la commande `ls`, qui permet d'afficher les sous-répertoires et fichiers présents dans le répertoire courant. Ceux ci s'affichent alors sur la sortie standard, c'est-à-dire notre terminal, on voit qu'il s'agit ici de bin, lib, local, share, include, libexec, sbin et standalone.

### Gestion des entrées/sorties et redirection

[modifier | modifier le code]

Les shells permettent de réaliser des redirections. Une redirection consiste à rediriger l'entrée ou la sortie d'une commande vers une autre commande ou un fichier.

#### Redirection droite simple

[modifier | modifier le code]

Syntaxe :

commande > fichier

Le résultat de l'invocation de la commande `commande` sera écrit dans le fichier `fichier`, en écrasant le précédent contenu.

Exemple :

$: cat file
Welcome
$: echo "Hello world" > file
$: cat file
Hello world

#### Redirection droite double

[modifier | modifier le code]

Syntaxe :

commande >> fichier

Le résultat de l'invocation de la commande `commande` sera écrit dans le fichier `fichier`, à la suite des données déjà présentes.

Exemple :

$: cat file
Welcome
$: echo "Hello world" >> file
$: cat file
Welcome
Hello world

#### Redirection gauche simple

[modifier | modifier le code]

Syntaxe :

commande < fichier

La commande `commande` va lire le contenu du fichier `fichier` au lieu de lire sur l'entrée standard (clavier).

Exemple :

$: cat < file
Welcome

#### Redirection gauche double

[modifier | modifier le code]

Syntaxe :

commande << END

La commande `commande` va lire sur l'entrée standard jusqu'à ce que le mot suivant la double redirection soit rencontré.

Exemple :

$: cat << TOTO
? foo
? bar
? moomoo
? TOTO
foo
bar
moomoo

### Pipe

[modifier | modifier le code]

Syntaxe :

commande_1 | commande_2

Le résultat de la commande `commande_1` va être redirigé dans l'entrée de la seconde commande `commande_2`.

Exemple :

$: echo "Hello world" | grep -o "Hello"
Hello

## Fichier de configuration

[modifier | modifier le code]

| sh  | ksh  | csh  | tcsh  | bash  | zsh

|
|
|
|
|
|

`/etc/.login` |  |  | login  | login  |  |
`/etc/csh.cshrc` |  |  | yes  | yes  |  |
`/etc/csh.login` |  |  | login  | login  |  |
`~/.tcshrc` |  |  |  | yes  |  |
`~/.cshrc` |  |  | yes  | yes[note 1] |  |
`~/etc/ksh.kshrc` |  | int.  |  |  |  |
`/etc/sh.shrc` | int.[note 2] |  |  |  |  |
`$ENV (typically ~/.kshrc)`[5] | int.[note 3][note 4] | int.  |  |  | int.[note 5] |
`~/.login` |  |  | login  | login  |  |
`~/.logout` |  |  | login  | login  |  |
`/etc/profile` | login  | login  |  |  | login  | login[note 6]
`~/.profile` | login  | login  |  |  | login[note 7] | login[note 6]
`~/.bash_profile` |  |  |  |  | login[note 7] |
`~/.bash_login` |  |  |  |  | login[note 7] |
`~/.bash_logout` |  |  |  |  | login  |
`~/.bashrc` |  |  |  |  | int.+n/login  |
`/etc/zshenv` |  |  |  |  |  | yes
`/etc/zprofile` |  |  |  |  |  | login
`/etc/zshrc` |  |  |  |  |  | int.
`/etc/zlogin` |  |  |  |  |  | login
`/etc/zlogout` |  |  |  |  |  | login
`~/.zshenv` |  |  |  |  |  | yes
`~/.zprofile` |  |  |  |  |  | login
`~/.zshrc` |  |  |  |  |  | int.
`~/.zlogin` |  |  |  |  |  | login

## Analogie chez d'autres systèmes d'exploitation

[modifier | modifier le code]

Article détaillé : Interpréteur de commandes.

Dans les différents systèmes d'exploitation Microsoft Windows, le programme analogue est command.com, ou cmd.exe.

## Notes et références

[modifier | modifier le code]

### Notes

[modifier | modifier le code]

1. ↑ only if `~/.tcshrc` not found
2. ↑ Newer versions of the Bourne Shell only
3. ↑ Available on systems that support the "User Portability Utilities option"; value of the variable must be an absolute path, and it is ignored "if the user's real and effective user IDs or real and effective group IDs are different."[6]
4. ↑ $ENV is $HOME/.shrc in newer versions of the Bourne Shell
5. ↑ Same behavior as `sh`, but only if invoked as `sh` (bash 2+) or, since bash 4.2, also if invoked explicitly in POSIX compatibility mode (with options `--posix` or `-o posix`)[7].
6. ↑ a et b Only in sh/ksh compatibility mode (when invoked as bash, sh, ksh)
7. ↑ a b et c in fact, the first readable of `~/.bash_profile`, `~/.bash_login` and `~/.profile`; and only `~/.profile` if invoked as `sh` or, as of at least Bash 4.2, if invoked explicitly in POSIX compatibility mode (with options `--posix` or `-o posix`)

### Références

[modifier | modifier le code]

1. ↑ a et b Karim Mezhoud, « Shell-Regex » [PDF], sur https://wiki.ubuntu.com
2. ↑ Damien Masson, Univ MLV, « Le shell Principales commandes » [PDF] (cours), sur http://igm.univ-mlv.fr
3. ↑ « Trouver le chemin d'une commande avec whereis », sur fr.linux-console.net (consulté le 3 janvier 2025)
4. ↑ « Qu'est-ce que Tilde sous Linux », sur fr.linux-console.net (consulté le 3 janvier 2025)
5. ↑ SCO Unix Group, SCO Unixware 7 documentation, 22 Apr 2004, retrieved 18 Oct 2012.
6. ↑ (en) « Shell Command Language », opengroup.org (consulté le 15 juin 2015)
7. ↑ (en) « Bash Reference Manual: Bash Startup Files », gnu.org (consulté le 15 juin 2015)

* Brian Blackmore, « UNIX shell differences » (consulté le 13 février 2012)

## Voir aussi

[modifier | modifier le code]

### Articles connexes

[modifier | modifier le code]

* Interpréteur de commandes
* Commandes Unix
* Shell (informatique)
* Reverse shell

v · m

Shell Unix

* ash
* bash
* bsh
* csh
* dash
* tcsh
* ksh
* zsh
* fish

v · m

Langages de programmation

Concurrents |

* Ada
* Erlang
* Go
* Modula-2

Déclaratifs |

* Clips
* Prolog
* Mercury

Fonctionnels |

* Clojure
* Common Lisp
* Erlang
* F#
* Gallina
* Haskell
* Lisp
* ML
* OCaml
* Opa
* Scheme
* Standard ML

Impératifs |

* Algol
* APL
* Assembleur
* Basic
* BCPL
* C
* Cobol
* DOPE
* Forth
* Fortran
* Julia
* Limbo
* Lua
* Modula-2
* MUMPS
* Natural
* NQC
* NXC
* OPL
* Pascal
* Perl
* PL/I
* RPG
* PowerShell
* Rust
* Tcl
* WLangage

Orientés objet |

* ActionScript
* AppleScript
* C++
* C#
* CoffeeScript
* D
* Delphi
* Eiffel
* Groovy
* Haxe
* Java
* JavaScript
* Lisaac
* Logo
* Objective-C
* PHP
* Python
* Ruby
* Scala
* Scratch
* Simula
* Smalltalk
* Swift
* Kotlin
* Visual Basic

* Liste de langages de programmation

* Portail de l’informatique
* Portail de la programmation informatique

*[[PDF]]: Document au format Portable Document Format (PDF) d'Adobe
*[(en)]: Langue : anglais
*[v]: Voir ce modèle.
*[m]: Modifier ce modèle. Merci de prévisualiser avant de sauvegarder.