cedricAbonnel/abonnel-www
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

publish: La commande type sous Linux

Browse Source
This commit is contained in:
Cédrix
2026-05-16 19:09:20 +02:00
parent 13d596fe40
commit 58c1464833
5 changed files with 116 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
df68156a-007f-46d7-97c3-a6ef221b2290/draft_overlay.json
-11
View File
@@ -1,11 +0,0 @@
{
"title": "La commande `type` sous Linux",
"_updated_at": "2026-05-16 17:09:18",
"slug": "type",
"published": true,
"published_at": "2023-02-19 08:31",
"category": "Informatique",
"tags": [],
"seo_title": "",
"seo_description": ""
}
df68156a-007f-46d7-97c3-a6ef221b2290/draft_overlay.md
-72
View File
@@ -1,72 +0,0 @@
# La commande `type` sous Linux
La commande `type` permet de savoir comment le shell interprète un nom de commande : alias, fonction, primitive (builtin), mot-clé du shell ou exécutable sur le disque. C'est un outil précieux pour comprendre pourquoi une commande se comporte d'une certaine manière et pour déboguer son environnement shell.
`type` est une primitive intégrée à Bash (et conforme à POSIX), il n'y a donc rien à installer.
## Syntaxe
```bash
type [options] nom [nom ...]
```
Où `nom` est la commande à examiner. Plusieurs noms peuvent être passés en argument.
## Les options
- **`-a`** : affiche **toutes** les interprétations possibles du nom, dans l'ordre où le shell les considère (alias, fonction, builtin, puis exécutables trouvés dans `PATH`).
- **`-t`** : affiche un mot unique décrivant le type de la commande : `alias`, `function`, `builtin`, `keyword` ou `file`. Pratique dans les scripts.
- **`-p`** : affiche le chemin de l'exécutable qui serait lancé. Ne produit **aucune sortie** si le nom correspond à un alias, une fonction ou un builtin.
- **`-P`** : force la recherche dans `PATH` et affiche le chemin de l'exécutable correspondant, **même si** le nom est aussi un alias ou une fonction.
## Exemples
Vérifier un alias :
```bash
$ type ls
ls est un alias vers « ls --color=auto »
```
Afficher toutes les interprétations d'un nom :
```bash
$ type -a ls
ls est un alias vers « ls --color=auto »
ls est /usr/bin/ls
```
Identifier une primitive du shell :
```bash
$ type cd
cd est une primitive du shell
```
Vérifier un exécutable binaire :
```bash
$ type grep
grep est /usr/bin/grep
```
Obtenir uniquement le type, utile en script :
```bash
$ type -t grep
file
$ type -t cd
builtin
```
Récupérer le chemin d'un binaire en ignorant un éventuel alias :
```bash
$ type -P ls
/usr/bin/ls
```
En résumé, `type` est l'outil le plus fiable pour répondre à la question « qu'est-ce qui s'exécute réellement quand je tape cette commande ? », là où `which` ne voit que les fichiers du `PATH`.
df68156a-007f-46d7-97c3-a6ef221b2290/index.md
+39 -30
View File
@@ -1,63 +1,72 @@
# type
# La commande `type` sous Linux
![Déterminer comment une commande est interprétée](1200px-gnulinux.jpg)
La commande `type` permet de savoir comment le shell interprète un nom de commande : alias, fonction, primitive (builtin), mot-clé du shell ou exécutable sur le disque. C'est un outil précieux pour comprendre pourquoi une commande se comporte d'une certaine manière et pour déboguer son environnement shell.
La commande `type` sous Linux est utilisée pour déterminer comment une commande est interprétée par le shell. Elle peut être utilisée pour identifier si une commande est un alias, une fonction ou un exécutable binaire.
`type` est une primitive intégrée à Bash (et conforme à POSIX), il n'y a donc rien à installer.
La syntaxe de base de la commande est la suivante :
## Syntaxe
```BASH
type [options] [name]
```bash
type [options] nom [nom ...]
```
Où `name` est le nom de la commande que vous voulez vérifier. Si aucun nom de commande n'est fourni, la commande `type` affichera un message d'aide avec une liste de toutes les commandes internes du shell.
Où `nom` est la commande à examiner. Plusieurs noms peuvent être passés en argument.
## Les options
Voici une description des différentes options `[-aftpP]` disponibles avec la commande `type` sous Linux :
- L'option `-a` permet d'afficher toutes les interprétations possibles d'une commande, y compris les alias, les fonctions et les exécutables binaires. Si une commande a plusieurs interprétations possibles, elles seront affichées les unes après les autres.
- **`-a`** : affiche **toutes** les interprétations possibles du nom, dans l'ordre où le shell les considère (alias, fonction, builtin, puis exécutables trouvés dans `PATH`).
- L'option `-f` permet d'afficher le chemin complet de l'exécutable binaire correspondant à une commande. Si la commande est un alias ou une fonction, cette option n'a pas d'effet.
- **`-t`** : affiche un mot unique décrivant le type de la commande : `alias`, `function`, `builtin`, `keyword` ou `file`. Pratique dans les scripts.
- L'option `-t` permet d'afficher le type de la commande, c'est-à-dire si elle est un alias, une fonction ou un exécutable binaire. Cette option n'affiche que le premier type d'interprétation de la commande.
- **`-p`** : affiche le chemin de l'exécutable qui serait lancé. Ne produit **aucune sortie** si le nom correspond à un alias, une fonction ou un builtin.
- L'option `-p` permet d'afficher le nom de la fonction ou de l'alias correspondant à une commande. Si la commande est un exécutable binaire, cette option n'a pas d'effet.
- **`-P`** : force la recherche dans `PATH` et affiche le chemin de l'exécutable correspondant, **même si** le nom est aussi un alias ou une fonction.
- L'option `-P` permet de spécifier un préfixe à utiliser pour l'affichage du résultat. Cette option peut être utile pour ajouter des informations supplémentaires à la sortie de la commande.
## Exemples
Voici quelques exemples d'utilisation :
-- Pour vérifier si une commande est un alias :
Vérifier un alias :
```BASH
```bash
$ type ls
ls est un alias vers « ls --color=auto »
ls est un alias vers « ls --color=auto »
```
```BASH
Afficher toutes les interprétations d'un nom :
```bash
$ type -a ls
ls est un alias vers « ls --color=auto »
ls est un alias vers « ls --color=auto »
ls est /usr/bin/ls
```
-- Pour vérifier si une commande est une primitive (builtin) / fonction :
Identifier une primitive du shell :
```BASH
```bash
$ type cd
cd est une primitive du shell
```
```BASH
$ type -a cd
cd est une primitive du shell
cd est /usr/bin/cd
```
Vérifier un exécutable binaire :
-- Pour vérifier si une commande est un exécutable binaire :
```BASH
```bash
$ type grep
grep est /usr/bin/grep
```
En utilisant la commande `type`, vous pouvez facilement déterminer comment une commande est interprétée par le shell, ce qui peut être utile pour comprendre le comportement d'une commande et déboguer les problèmes éventuels.
Obtenir uniquement le type, utile en script :
```bash
$ type -t grep
file
$ type -t cd
builtin
```
Récupérer le chemin d'un binaire en ignorant un éventuel alias :
```bash
$ type -P ls
/usr/bin/ls
```
En résumé, `type` est l'outil le plus fiable pour répondre à la question « qu'est-ce qui s'exécute réellement quand je tape cette commande ? », là où `which` ne voit que les fichiers du `PATH`.
df68156a-007f-46d7-97c3-a6ef221b2290/meta.json
+14 -5
View File
@@ -1,18 +1,27 @@
{
"uuid": "df68156a-007f-46d7-97c3-a6ef221b2290",
"slug": "type",
"title": "type",
"title": "La commande `type` sous Linux",
"author": "cedric@abonnel.fr",
"published": true,
"published_at": "2023-02-19 08:31:11",
"featured": false,
"published_at": "2023-02-19 08:31",
"created_at": "2023-02-19 08:31:11",
"updated_at": "2023-02-19 08:31:11",
"revisions": [],
"updated_at": "2026-05-16 17:09:20",
"revisions": [
{
"n": 1,
"date": "2026-05-16 17:09:20",
"comment": "Titre modifié, contenu modifié",
"title": "type"
}
],
"cover": "",
"files_meta": [],
"external_links": [],
"seo_title": "",
"seo_description": "",
"og_image": "",
"category": "Informatique"
"category": "Informatique",
"tags": []
}
df68156a-007f-46d7-97c3-a6ef221b2290/revisions/0001.md
+63
View File
@@ -0,0 +1,63 @@
# type
![Déterminer comment une commande est interprétée](1200px-gnulinux.jpg)
La commande `type` sous Linux est utilisée pour déterminer comment une commande est interprétée par le shell. Elle peut être utilisée pour identifier si une commande est un alias, une fonction ou un exécutable binaire.
La syntaxe de base de la commande est la suivante :
```BASH
type [options] [name]
```
Où `name` est le nom de la commande que vous voulez vérifier. Si aucun nom de commande n'est fourni, la commande `type` affichera un message d'aide avec une liste de toutes les commandes internes du shell.
## Les options
Voici une description des différentes options `[-aftpP]` disponibles avec la commande `type` sous Linux :
- L'option `-a` permet d'afficher toutes les interprétations possibles d'une commande, y compris les alias, les fonctions et les exécutables binaires. Si une commande a plusieurs interprétations possibles, elles seront affichées les unes après les autres.
- L'option `-f` permet d'afficher le chemin complet de l'exécutable binaire correspondant à une commande. Si la commande est un alias ou une fonction, cette option n'a pas d'effet.
- L'option `-t` permet d'afficher le type de la commande, c'est-à-dire si elle est un alias, une fonction ou un exécutable binaire. Cette option n'affiche que le premier type d'interprétation de la commande.
- L'option `-p` permet d'afficher le nom de la fonction ou de l'alias correspondant à une commande. Si la commande est un exécutable binaire, cette option n'a pas d'effet.
- L'option `-P` permet de spécifier un préfixe à utiliser pour l'affichage du résultat. Cette option peut être utile pour ajouter des informations supplémentaires à la sortie de la commande.
## Exemples
Voici quelques exemples d'utilisation :
-- Pour vérifier si une commande est un alias :
```BASH
$ type ls
ls est un alias vers « ls --color=auto »
```
```BASH
$ type -a ls
ls est un alias vers « ls --color=auto »
ls est /usr/bin/ls
```
-- Pour vérifier si une commande est une primitive (builtin) / fonction :
```BASH
$ type cd
cd est une primitive du shell
```
```BASH
$ type -a cd
cd est une primitive du shell
cd est /usr/bin/cd
```
-- Pour vérifier si une commande est un exécutable binaire :
```BASH
$ type grep
grep est /usr/bin/grep
```
En utilisant la commande `type`, vous pouvez facilement déterminer comment une commande est interprétée par le shell, ce qui peut être utile pour comprendre le comportement d'une commande et déboguer les problèmes éventuels.