Il m'a fallu près de 10 ans d’utilisation de Linux pour poser cette question. Il s’agissait d’essais et d’erreur et de naviguer au hasard sur Internet tard dans la nuit.

Mais les gens ne devraient pas avoir besoin de 10 ans pour cela. Si je commençais tout juste avec Linux, je voudrais savoir: quand alias, quand écrire un script et quand écrire une fonction?

En ce qui concerne les alias, j'utilise des alias pour des opérations très simples qui ne prennent pas d'arguments.

alias houston='cd /home/username/.scripts/'

Cela semble évident. Mais certaines personnes font ceci:

alias command="bash bashscriptname"

(et l'ajouter au .bashrcfichier)

Y a-t-il une bonne raison de le faire? J'essaie vraiment très fort, mais je ne peux vraiment pas penser à une situation dans laquelle je voudrais faire cela. Donc, s'il y a un cas extrême où cela ferait une différence, veuillez répondre ci-dessous.

Parce que c’est là que je voudrais simplement mettre quelque chose dans mon chemin PATH chmod +x, ce qui est une autre chose qui est arrivée après des années d’essais et d’erreur en Linux.

Ce qui m'amène au sujet suivant. Par exemple, j'ai ajouté .scripts/à PATH un dossier caché ( ) dans le répertoire de base en ajoutant simplement une ligne à ma .bashrc( PATH=$PATH:/home/username/.scripts/), ainsi tout élément exécutable se trouvant automatiquement ici se termine automatiquement.

Si j'en avais besoin.

Je n'ai pas vraiment besoin de ça, n'est-ce pas? Je ne l'utiliserais que pour les langages qui ne sont pas le shell, comme Python.

Si c'est le shell, je peux juste écrire une fonction à l'intérieur même .bashrc:

funcname () {
  somecommand -someARGS "$@"
}

Comme je l'ai dit, j'ai découvert beaucoup de choses par essais et erreurs. Et je n’ai vraiment vu la beauté des fonctions que lorsque mon ordinateur est mort et j’ai été forcé d’utiliser les ordinateurs des gens autour de moi quand ils ne les utilisaient pas.

Au lieu de déplacer tout un répertoire de scripts d'un ordinateur à l'autre, j'ai fini par remplacer simplement le fichier .bashrc de tous les autres par le mien, car ils n'avaient même jamais apporté une seule modification.

Mais ai-je manqué quelque chose?

Alors, que diriez-vous à un utilisateur Linux débutant de quand alias, quand écrire un script et quand écrire une fonction?

Si ce n'est pas évident, je suppose que les personnes qui répondront utiliseront les trois options. Si vous utilisez uniquement des alias, ou que des scripts, ou que vous utilisez uniquement des fonctions - ou si vous utilisez uniquement des alias et des scripts ou des alias et des fonctions ou des scripts et des fonctions - cette question ne vous concerne pas vraiment.

En général, un alias ne devrait pas (en général) faire plus que modifier les options par défaut d'une commande. Ce n'est rien de plus qu'un simple remplacement de texte sur le nom de la commande. Il ne peut rien faire avec des arguments, mais les passe à la commande qu'il exécute. Donc, si vous devez simplement ajouter un argument devant une seule commande, un alias fonctionnera. Des exemples courants sont

# Make ls output in color by default.
alias ls="ls --color=auto"
# make mv ask before overwriting a file by default
alias mv="mv -i"

Une fonction doit être utilisée lorsque vous devez faire quelque chose de plus complexe qu'un alias, mais que cela ne serait pas utile par lui-même. Par exemple, répondez à une question que j’ai posée concernant le changement grepde comportement par défaut selon qu’il s’agisse ou non d’un pipeline:

grep() { 
    if [[ -t 1 ]]; then 
        command grep -n "$@"
    else 
        command grep "$@"
    fi
}

C'est un exemple parfait de fonction car elle est trop complexe pour un alias (nécessitant des valeurs par défaut différentes en fonction d'une condition), mais ce n'est pas quelque chose dont vous aurez besoin dans un script non interactif.

Si vous obtenez trop de fonctions ou des fonctions trop volumineuses, placez-les dans des fichiers séparés dans un répertoire caché et sourcez-les dans ~/.bashrc:

if [ -d ~/.bash_functions ]; then
    for file in ~/.bash_functions/*; do
        . "$file"
    done
fi

Un script doit être autonome. Il devrait avoir une valeur en tant que quelque chose qui peut être réutilisé ou utilisé à plusieurs fins.

Les autres réponses fournissent des directives générales souples basées sur les goûts personnels, mais ignorent de nombreux faits pertinents à prendre en compte lors du choix entre scripts, fonctions ou alias.

Alias ​​et fonctions ¹

• Tout le contenu des alias et des fonctions est stocké dans la mémoire du shell.
• Une conséquence naturelle de cela est que les alias et les fonctions ne peuvent être utilisés que par le shell actuel, et non par d'autres programmes que vous pouvez appeler à partir du shell, tels que des éditeurs de texte, des scripts ou même des instances enfants du même shell.
• Les alias et les fonctions sont exécutés par le shell actuel, c'est-à-dire qu'ils s'exécutent dans l'environnement actuel du shell et les affectent2. Aucun processus séparé n'est nécessaire pour exécuter un alias ou une fonction.

Les scripts

• Les shells ne gardent pas les scripts en mémoire. Au lieu de cela, les scripts sont lus à partir des fichiers où ils sont stockés chaque fois qu'ils sont nécessaires. Si le script est trouvé via une $PATHrecherche, de nombreux shells stockent un hachage de son nom de chemin en mémoire pour gagner du temps lors des $PATHrecherches ultérieures , mais il s'agit de l'étendue de l'empreinte mémoire d'un script lorsqu'il n'est pas utilisé.

• Les scripts peuvent être appelés de différentes manières que les fonctions et les alias. Ils peuvent être passés sous forme d'argument à un interprète, par exemple sh script, ou directement invoqués en tant qu'exécutable, auquel cas l'interpréteur dans la ligne shebang (par exemple #!/bin/sh) est appelé pour l'exécuter. Dans les deux cas, le script est exécuté par un processus interpréteur distinct avec son propre environnement, distinct de celui de votre shell, environnement dans lequel le script ne peut avoir aucune incidence. En effet, le shell interprète n'a même pas besoin de correspondre au shell appelant. Comme les scripts invoqués de cette manière semblent se comporter comme n'importe quel exécutable ordinaire, ils peuvent être utilisés par n'importe quel programme.

  Enfin, un script peut être lu et exécuté par le shell en cours avec ., ou , dans certains coquillages, source. Dans ce cas, le script se comporte presque comme une fonction lue à la demande au lieu d’être constamment gardée en mémoire.

Application

Compte tenu de ce qui précède, nous pouvons proposer des directives générales pour définir un script, une fonction ou un alias.

• Est-ce que d'autres programmes que votre shell doivent être capables de l'utiliser? Si c'est le cas, il doit s'agir d'un script.

• Voulez-vous seulement qu'il soit disponible à partir d'un shell interactif? Il est courant de vouloir modifier le comportement par défaut de nombreuses commandes lors d'une exécution interactive sans affecter les commandes / scripts externes. Dans ce cas, utilisez un alias / fonction défini dans le fichier rc "du mode interactif uniquement" du shell ( bashc'est le cas .bashrc).

• Faut-il changer l'environnement du shell? Une fonction / alias ou un script source sont des choix possibles.

• Est-ce quelque chose que vous utilisez fréquemment? Il est probablement plus efficace de le garder en mémoire, alors faites-en une fonction / un alias si possible.

• Inversement, est-ce quelque chose que vous utilisez rarement? Dans ce cas, il ne sert à rien d'avoir de la mémoire quand vous n'en avez pas besoin, alors faites-en un script.

^{¹ Bien que les fonctions et les alias présentent des différences importantes, ils sont regroupés car les fonctions peuvent tout faire comme les alias. Les alias ne peuvent pas avoir de variables locales, ils ne peuvent pas non plus traiter d'arguments, et ils sont peu pratiques pour une longueur supérieure à une ligne.}

^{² Chaque processus en cours dans un système Unix a un environnement constitué de plusieurs variable=valuepaires de paramètres qui contiennent souvent des paramètres de configuration globaux, comme LANGpour les paramètres régionaux par défaut et PATHpour spécifier un chemin de recherche exécutable.}

Je pense que c'est au goût de chacun. Pour moi, la logique est la suivante:

• J'essaie d'abord de créer un alias, car c'est le plus simple.
• Si la chose est trop compliquée pour tenir dans une ligne, j'essaye d'en faire une fonction.
• Lorsque la fonction commence à dépasser une douzaine de lignes, je la mets dans un script.

Rien ne vous empêche réellement de faire quelque chose qui fonctionne .

Au moins partiellement, c'est une question de goût personnel. Par ailleurs, il existe des distinctions fonctionnelles claires:

• alias: convient uniquement pour les remplacements de texte simples, sans arguments ni paramètres
• fonctions: facile à écrire / utiliser, capacité de script shell complète, disponible uniquement dans bash
• scripts: plus ou moins comme des fonctions, mais disponibles (appelables) en dehors de bash

En ce qui concerne les scripts shell que j'ai effectués ces dernières années, j'ai plus ou moins arrêté d'écrire des alias (car ils ont tous tendance à devenir des fonctions au fil du temps) et n'effectuez des scripts que s'ils doivent également être disponibles à partir d'environnements non bash.

PS: En ce qui alias command="bash bashscriptname"me concerne, je ne vois aucune raison de le faire. Même si bashscriptnamen'est pas dans $ PATH, un simple alias c=/path/to/scriptsuffirait.

Voici quelques points supplémentaires sur les alias et les fonctions:

• Un alias et une fonction du même nom peuvent coexister
• alias namespace est recherché en premier (voir premier exemple)
• les alias ne peuvent pas être (non) définis dans des sous-shell ou un environnement non interactif (voir deuxième exemple)

Par exemple:

alias f='echo Alias'; f             # prints "Alias"
function f { echo 'Function'; }; f  # prints "Alias"
unalias f; f                        # prints "Function"

Comme nous pouvons le constater, il existe des espaces de noms distincts pour les alias et les fonctions; plus de détails peuvent être trouvés en utilisant declare -A -p BASH_ALIASESet declare -f f, qui imprime leurs définitions ( les deux sont stockées dans la mémoire).

Exemple montrant les limitations des alias:

alias a='echo Alias'
a        # OK: prints "Alias"
eval a;  # OK: prints "Alias"
( alias a="Nested"; a );  # prints "Alias" (not "Nested")
( unalias a; a );         # prints "Alias"
bash -c "alias aa='Another Alias'; aa"  # ERROR: bash: aa: command not found

Comme on peut le constater, les alias ne sont pas imbriquables, contrairement aux fonctions. En outre, leur utilisation est limitée aux sessions interactives.

Enfin, notez que vous pouvez avoir un calcul arbitraire dans un alias en déclarant une fonction comme l'appelant immédiatement, comme ceci:

alias a_complex_thing='f() { do_stuff_in_function; } f'

qui est déjà largement utilisé en cas de pseudonymes Git. L'avantage de le faire par rapport à la déclaration d'une fonction est que votre alias ne peut pas être simplement écrasé par la source (ou l'utilisation .) d'un script qui déclare une fonction de même nom.

Quand écrire un script ...

• Les scripts assemblent des composants logiciels (outils, commandes, processus, exécutables, programmes, etc.) en composants plus complexes, qui peuvent eux-mêmes être assemblés en composants encore plus complexes.
• Les scripts sont généralement rendus exécutables afin qu'ils puissent être appelés par leur nom. Lorsqu'il est appelé, un nouveau sous-processus est généré pour l'exécution du script. Les copies de toutes les exportvariables et / ou fonctions édifiées sont transmises au script par valeur . Les modifications apportées à ces variables ne sont pas répercutées dans le script parent.
• Les scripts peuvent également être chargés (source) comme s'ils faisaient partie du script d'appel. Ceci est analogue à ce que certaines autres langues appellent "importer" ou "inclure". Lorsqu'ils sont recherchés, ils s'exécutent dans le processus existant. Aucun sous-processus n'est généré.

Quand écrire une fonction ...

• Les fonctions sont effectivement des scripts shell préchargés. Ils fonctionnent un peu mieux que d’appeler un script séparé, mais seulement s’il doit être lu à partir d’un disque mécanique. La prolifération actuelle de clés USB, de disques SSD et de la mise en cache normale de Linux dans de la RAM non utilisée rend cette amélioration pratiquement impossible à mesurer.
• Les fonctions sont le principal moyen utilisé par bash pour réaliser la modularité, l’encapsulation et la réutilisation. Ils améliorent la clarté, la fiabilité et la maintenabilité des scripts.
• Les règles de syntaxe pour appeler une fonction sont identiques à celles pour appeler un exécutable. Une fonction portant le même nom qu'un exécutable serait appelée à la place de l'exécutable.
• Les fonctions sont locales au script dans lequel elles se trouvent.
• Les fonctions peuvent être exportées ( copiées par valeur ) afin de pouvoir être utilisées dans des scripts appelés. Ainsi, les fonctions ne se propagent qu’aux processus enfants, jamais aux parents.
• Les fonctions créent des commandes réutilisables qui sont souvent assemblées dans des bibliothèques (un script avec uniquement des définitions de fonctions) qui doivent être extraites par d'autres scripts.

Quand écrire un alias ...

• Les alias Bash ne fonctionnent pas dans les structures de script shell comme les boucles if / then et for / do. Ils ne doivent donc être utilisés que comme raccourcis clavier dans une ligne de commande interactive. Ainsi, toutes les définitions d'alias résident généralement dans le script de connexion approprié, tel que ~/.profileou ~/.bashrc.

Dans les scripts tels que les scripts de bibliothèque, un alias pour une fonction est parfois nécessaire, par exemple lorsqu'une fonction est renommée mais que la compatibilité avec les versions antérieures est requise. Cela peut être accompli en créant une fonction simple avec l'ancien nom qui transmet tous ses arguments à la nouvelle fonction ...

# A bash in-script 'alias'
function oldFunction () { newFunction "$@"; }

Une autre chose que je ne crois pas a été évoquée: une fonction s’exécute dans le contexte du processus d’appel, alors qu’un script crée un nouveau shell.

Cela pourrait être important pour la performance - une fonction est plus rapide, car il n'a pas fork()et exec(). Dans des circonstances normales, la différence est triviale, mais si vous déboguez un système qui manque de mémoire et qui détruit les pages, cela pourrait faire une grande différence.

De plus, si vous souhaitez modifier votre environnement shell actuel, vous devez utiliser une fonction. Par exemple, une fonction peut changer la recherche de commande $PATHpour le shell actuel, mais pas un script, car il fonctionne sur une copie fork / exec de $PATH.

Script et alias et script et fonction ne s'excluent pas mutuellement. Vous pouvez et stockez des alias et des fonctions dans des scripts.

Les scripts ne sont que du code qui est rendu persistant . Les fonctions utiles et les alias que vous aimerez utiliser à l'avenir sont stockés dans des scripts. Cependant, un script est souvent un ensemble de plusieurs fonctions.

Comme les alias ne sont pas paramétrés , ils sont très limités. habituellement pour définir certains paramètres par défaut.

Une fonction est une unité de code séparée , un concept bien défini de quelques lignes de code qui ne peuvent pas être séparées en parties plus petites et utiles. l'un qui peut être réutilisé directement ou autre par d'autres fonctions.

Si cela doit être très rapide, faites-en un alias ou une fonction.

S'il doit être utilisable en dehors de votre shell préféré, faites-en un script. ¹

Si cela prend des arguments, faites-en une fonction ou un script.

S'il doit contenir des caractères spéciaux, faites-en un alias ou un script. ²

Si cela doit fonctionner avec sudo, faites-en un alias ou un script. ³

Si vous souhaitez le modifier facilement sans vous déconnecter, un script est plus facile. ⁴

Notes de bas de page

¹ Ou faites-en un alias, mettez-le ~/.envet définissez-le export ENV="$HOME/.env", mais c'est compliqué de le faire fonctionner de manière portable.

² Les noms de fonction doivent être des identificateurs, ils doivent donc commencer par une lettre et ne peuvent contenir que des lettres, des chiffres et des traits de soulignement. Par exemple, j'ai un alias alias +='pushd +1'. Cela ne peut pas être une fonction.

³ Et ajoutez l'alias alias sudo='sudo '. Ditto toute autre commande comme strace, gdb, etc. , qui prend une commande comme premier argument.

⁴ Voir aussi: fpath. Bien sûr, vous pouvez également faire source ~/.bashrcou similaire, mais cela a souvent d'autres effets secondaires.

Juste pour ajouter quelques notes:

• Avec sudo, seul un script séparé peut être utilisé (par exemple, si vous devez modifier un fichier système), par exemple:

sudo v /etc/rc.conf  #where v runs vim in a new terminal window;

• Seuls des alias ou des fonctions peuvent remplacer les commandes système sous le même nom (en supposant que vous ajoutiez vos scripts à la fin de PATH, ce qui, à mon avis, est recommandé pour la sécurité en cas de création accidentelle ou malveillante d'un script dont le nom est identique à une commande système), par exemple:

alias ls='ls --color=auto'  #enable colored output;

• Les alias et les fonctions prennent moins de mémoire et de temps d'exécution, mais prennent du temps à se charger (car le shell doit tous les interpréter avant d'afficher votre invite). Tenez-en compte si vous exécutez régulièrement de nouveaux processus shell, par exemple:

# pressing key to open new terminal
# waiting for a few seconds before shell prompt finally appears.

Sinon, vous pouvez utiliser la forme la plus simple possible, c'est-à-dire d'abord considérer alias, ensuite fonction, puis script.

Ma règle de base est:

• alias - une commande, pas de paramètres
• fonctions - une commande quelques paramètres
• script - plusieurs commandes, pas de paramètres

Dans un environnement multi-utilisateur (ou multi-sysamin), j'utilise des scripts pour tout, même si cela finit par être un bref wrapper 'exec thing ....'.

Bien sûr, il est techniquement plus lent / moins efficace qu'un alias ou une fonction, mais cela n'a presque jamais d'importance - et à condition que cela soit dans le chemin, un script fonctionne toujours.

Votre fonctionnalité peut être appelée depuis cron, depuis quelque chose dont l’environnement est réduit ou modifié, tel que sudo ou env, ou l’utilisateur peut simplement utiliser un shell différent: tout ou susceptible de rompre un alias ou une fonction.

Si vous avez des problèmes de performances, traitez cela comme un cas spécial, ou mieux encore, considérez cela comme un déclencheur pour réécrire dans un langage de script plus fonctionnel.

Si nous parlons de fonctionnalités qui ne seront utilisées que dans d’autres scripts, vous pouvez également envisager de définir un shell standard et d’écrire un script de bibliothèque de fonctions qui peut tout simplement être. source I à tous les autres scripts.

T

Exemple pour une situation dans laquelle vous aimeriez probablement utiliser un alias.

Je sais que ceci est un ancien post, mais je voudrais signaler une situation dans laquelle j'ai presque dû utiliser une combinaison d'alias avec un script et j'ai choisi de ne pas utiliser de fonction.

J'ai un script ~/.bin/appelé setupqui fait ce qui suit: ¹

1. m'amène à un certain répertoire.
2. définit quelques variables.
3. affiche des messages sur l'état du répertoire. ²

Le fait est que si je me contentais de courir, setup <project-name>je n'aurais pas défini ces variables et je n'aurais pas eu accès au répertoire du tout. La solution que je trouve être le meilleur était d'ajouter ce script PATHet ajouter alias setup=". ~/.bin/setup"à ~/.bashrcou autre.

Remarques:

1. J'ai utilisé un script pour cette tâche et non une fonction, non pas parce qu'il est particulièrement long, mais parce que je peux le modifier et que je n'ai pas besoin de source le fichier après une modification si je veux actualiser son utilisation.
2. Un cas similaire m'est apparu lorsque j'ai créé un script pour recharger tous mes fichiers de points. ³

1. Le script est disponible dans le répertoire de mon fichier .fichiers sous .bin/.
2. A propos du script : Je donne à ce script un argument qui est un nom pour le projet que j'ai défini dans advanced. Ensuite, le script sait comment m'amener au bon répertoire en fonction d'un csvfichier donné. Les variables qu'il définit sont issues du makefile de ce répertoire. Le script se lance après ls -let git statusme montre ce qui se passe là-bas.
3. Ce script est également disponible dans le référentiel de mon fichier dotfiles .bin/également.

Quand écrire un script

Lorsque vous souhaitez exécuter la commande à partir d'un outil autre que le shell.

Cela inclut vim (pour moi): ayant des filtres écrits et d’autres programmes sous forme de scripts, je peux faire quelque chose comme :%!my-filterfiltrer un fichier à travers le programme à partir de mon éditeur.

S'il my-filters'agissait d'une fonction ou d'un alias, cela ne serait pas possible.