Mi ci sono voluti quasi 10 anni di utilizzo di Linux per porre questa domanda. Era tutto prova ed errore e navigazione casuale a tarda notte in Internet.

Ma le persone non dovrebbero aver bisogno di 10 anni per questo. Se avessi appena iniziato con Linux, vorrei sapere: quando alias, quando scrivere e quando scrivere una funzione?

Per quanto riguarda gli alias, uso gli alias per operazioni molto semplici che non accettano argomenti.

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

Sembra ovvio. Ma alcune persone lo fanno:

alias command="bash bashscriptname"

(e aggiungilo al .bashrcfile)

C'è una buona ragione per farlo? Ci sto provando molto, ma sinceramente non riesco a pensare a nessuna circostanza in cui vorrei farlo. Quindi, se esiste un caso limite in cui ciò potrebbe fare la differenza, rispondi di seguito.

Perché è lì che vorrei semplicemente inserire qualcosa nel mio PATH e chmod +xquesto, che è un'altra cosa che è arrivata dopo anni di tentativi ed errori su Linux.

Il che mi porta al prossimo argomento. Ad esempio, ho aggiunto una cartella nascosta ( .scripts/) nella home directory al mio PATH semplicemente aggiungendo una riga a my .bashrc( PATH=$PATH:/home/username/.scripts/), quindi qualsiasi cosa eseguibile lì si completerà automaticamente.

Se ne avessi bisogno.

Non ne ho davvero bisogno, però? Lo userei solo per le lingue che non sono la shell, come Python.

Se è la shell, posso semplicemente scrivere una funzione all'interno della stessa .bashrc:

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

Come ho affermato, ho scoperto molto attraverso prove ed errori. E ho visto davvero la bellezza delle funzioni solo quando il mio computer è morto e sono stato costretto a usare i computer delle persone intorno a me quando non li stavano usando.

Invece di spostare un'intera directory di script da un computer all'altro, ho finito per sostituire il mio .bashrc di tutti con il mio, dal momento che non avevano mai nemmeno fatto una singola modifica.

Ma mi sono perso qualcosa?

Quindi, cosa diresti a un utente Linux principiante di quando alias, quando scrivere e quando scrivere una funzione?

Se non è ovvio, suppongo che le persone che risponderanno utilizzeranno tutte e tre le opzioni. Se usi solo alias, o usi solo script, o usi solo funzioni - o se usi solo alias e script o alias e funzioni o script e funzioni - questa domanda non è realmente rivolta a te.

Un alias non dovrebbe effettivamente (in generale) fare altro che cambiare le opzioni predefinite di un comando. Non è altro che una semplice sostituzione di testo sul nome del comando. Non può fare nulla con gli argomenti ma passarli al comando che effettivamente esegue. Quindi, se hai semplicemente bisogno di aggiungere un argomento all'inizio di un singolo comando, un alias funzionerà. Esempi comuni sono

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

Una funzione dovrebbe essere usata quando devi fare qualcosa di più complesso di un alias ma che non sarebbe utile da solo. Ad esempio, prendi questa risposta su una domanda che ho posto sulla modifica grepdel comportamento predefinito a seconda che si tratti di una pipeline:

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

È un esempio perfetto di una funzione perché è troppo complesso per un alias (richiede valori predefiniti diversi in base a una condizione), ma non è qualcosa di cui avrai bisogno in uno script non interattivo.

Se ottieni troppe funzioni o funzioni troppo grandi, inseriscile in file separati in una directory nascosta e sorgente nel tuo ~/.bashrc:

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

Una sceneggiatura dovrebbe essere autonoma. Dovrebbe avere valore come qualcosa che può essere riutilizzato o utilizzato per più di uno scopo.

Le altre risposte forniscono alcune linee guida generali morbide basate sul gusto personale, ma ignorano molti fatti pertinenti che si dovrebbero considerare quando si decide tra script, funzioni o alias.

Alias ​​e funzioni ¹

• L'intero contenuto di alias e funzioni è archiviato nella memoria della shell.
• Una conseguenza naturale di ciò è che gli alias e le funzioni possono essere utilizzati solo dalla shell corrente e non da altri programmi che è possibile richiamare dalla shell come editor di testo, script o persino istanze figlio della stessa shell.
• Gli alias e le funzioni vengono eseguiti dalla shell corrente, ovvero vengono eseguiti all'interno e influiscono sull'ambiente corrente della shell. ² Non è necessario alcun processo separato per eseguire un alias o una funzione.

Script

• Le conchiglie non mantengono gli script in memoria. Invece, gli script vengono letti dai file in cui sono memorizzati ogni volta che sono necessari. Se lo script viene trovato tramite una $PATHricerca, molte shell memorizzano un hash del suo nome percorso in memoria per risparmiare tempo nelle ricerche future $PATH, ma questa è l'estensione dell'impronta di memoria di uno script quando non viene utilizzata.

• Gli script possono essere invocati in più modi rispetto a funzioni e alias. Possono essere passati come argomento a un interprete, come sh script, o invocati direttamente come eseguibili, nel qual caso l'interprete nella riga shebang (ad es. #!/bin/sh) Viene invocato per eseguirlo. In entrambi i casi, lo script viene eseguito da un processo interprete separato con un proprio ambiente separato da quello della shell, il cui ambiente lo script non può influire in alcun modo. In effetti, la shell dell'interprete non deve nemmeno corrispondere alla shell che invoca. Poiché gli script invocati in questo modo sembrano comportarsi come qualsiasi normale eseguibile, possono essere utilizzati da qualsiasi programma.

  Infine, uno script può essere letto e gestito dalla shell corrente con ., o in alcune conchiglie, source. In questo caso, lo script si comporta in modo molto simile a una funzione che viene letta su richiesta anziché essere costantemente tenuta in memoria.

Applicazione

Alla luce di quanto sopra, possiamo fornire alcune linee guida generali per stabilire se creare qualcosa di uno script o una funzione / alias.

• Altri programmi oltre alla shell devono essere in grado di usarlo? In tal caso, deve essere una sceneggiatura.

• Vuoi che sia disponibile solo da una shell interattiva? È comune voler modificare il comportamento predefinito di molti comandi quando eseguito in modo interattivo senza influire su comandi / script esterni. In questo caso, utilizzare un alias / set di funzioni nel file rc "solo modalità interattiva" della shell (per bashquesto è .bashrc).

• Deve cambiare l'ambiente della shell? Sia una funzione / alias o uno script di provenienza sono possibili scelte.

• È qualcosa che usi frequentemente? Probabilmente è più efficiente tenerlo in memoria, quindi rendilo una funzione / alias, se possibile.

• Al contrario, è qualcosa che usi solo raramente? In tal caso, non ha senso avere la memoria del maiale quando non ne hai bisogno, quindi rendilo uno script.

^{¹ Sebbene funzioni e alias presentino alcune differenze importanti, sono raggruppate perché le funzioni possono fare tutto ciò che possono fare gli alias. Gli alias non possono avere variabili locali né elaborare argomenti, e sono scomodi per qualcosa di più lungo di una riga.}

^{² Ogni processo in esecuzione in un sistema Unix ha un ambiente costituito da un gruppo di variable=valuecoppie che spesso contengono impostazioni di configurazione globali, come LANGper le impostazioni internazionali predefinite e PATHper specificare il percorso di ricerca eseguibile.}

Penso che dipenda dai gusti di ogni persona. Per me la logica è questa:

• Per prima cosa provo a creare un alias, perché è il più semplice.
• Se la cosa è troppo complicata per rientrare in una riga, provo a renderla una funzione.
• Quando la funzione inizia a crescere oltre una dozzina di righe, la inserisco in uno script.

Non c'è davvero nulla che ti impedisca di fare qualcosa che funzioni .

Almeno parzialmente è una questione di gusti personali. D'altra parte ci sono alcune distinzioni funzionali chiare:

• alias: adatto solo per semplici sostituzioni di testo, senza argomenti / parametri
• funzioni: facile da scrivere / usare, capacità di scripting full shell, disponibile solo in bash
• script: più o meno come funzioni, ma disponibili (richiamabili) anche al di fuori di bash

Guardando gli script di shell che ho fatto negli ultimi anni ho più o meno smesso di scrivere alias (perché tutti tendono a crescere nel tempo in funzioni) e faccio script solo se devono essere disponibili anche da ambienti non bash.

PS: Per quanto riguarda in alias command="bash bashscriptname"realtà non vedo alcun motivo per farlo. Anche se bashscriptnamenon è in $ PATH, un semplice alias c=/path/to/scriptsarebbe abbastanza.

Ecco alcuni punti aggiuntivi su alias e funzioni:

• Alias ​​e funzione con lo stesso nome possono coesistere
• lo spazio dei nomi alias viene prima cercato (vedi primo esempio)
• gli alias non possono essere (annullati) in subshells o ambienti non interattivi (vedi secondo esempio)

Per esempio:

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

Come possiamo vedere, esistono spazi dei nomi separati per alias e funzioni; maggiori dettagli possono essere trovati usando declare -A -p BASH_ALIASESe declare -f f, che stampa le loro definizioni (entrambi sono memorizzati in memoria).

Esempio che mostra le limitazioni degli 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

Come possiamo vedere gli alias non sono annidabili, a differenza delle funzioni. Inoltre, il loro utilizzo è limitato alle sessioni interattive.

Infine, nota che puoi avere un calcolo arbitrario in un alias dichiarando una funzione che la chiama immediatamente, in questo modo:

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

che è già ampiamente utilizzato in caso di alias Git. Il vantaggio di farlo oltre a dichiarare una funzione è che il tuo alias non può essere semplicemente sovrascritto dal sorgente (o dall'uso .) di uno script che sembra dichiarare una funzione con lo stesso nome.

Quando scrivere una sceneggiatura ...

• Gli script assemblano componenti software (ovvero strumenti, comandi, processi, eseguibili, programmi) in componenti più complessi, che possono essere assemblati in componenti ancora più complessi.
• Gli script sono generalmente resi eseguibili in modo che possano essere chiamati per nome. Quando viene chiamato, viene generato un nuovo sottoprocesso per l'esecuzione dello script. Le copie di tutte le exportvariabili e / o funzioni ed vengono passate per valore allo script. Le modifiche a tali variabili non si propagano allo script principale.
• Gli script possono anche essere caricati (provenienti) come se fossero parte dello script chiamante. Questo è analogo a ciò che alcune altre lingue chiamano "import" o "include". Quando provengono, eseguono all'interno del processo esistente. Non viene generato alcun sottoprocesso.

Quando scrivere una funzione ...

• Le funzioni sono effettivamente script di shell precaricati. Si comportano in modo leggermente migliore rispetto alla chiamata di uno script separato, ma solo se devono essere letti dal disco meccanico. La proliferazione odierna di unità flash, SSD e la normale memorizzazione nella cache di Linux nella RAM non utilizzata rende tale miglioramento in gran parte non misurabile.
• Le funzioni servono come mezzo principale di bash per ottenere modularità, incapsulamento e riutilizzo. Migliorano la chiarezza, l'affidabilità e la manutenibilità degli script.
• Le regole di sintassi per chiamare una funzione sono identiche a quelle per chiamare un eseguibile. Una funzione con lo stesso nome di un eseguibile verrebbe invocata invece dell'eseguibile.
• Le funzioni sono locali per lo script in cui si trovano.
• Le funzioni possono essere esportate ( copiate per valore ) in modo che possano essere utilizzate all'interno di script chiamati. Pertanto, le funzioni si propagano solo ai processi figlio, mai ai genitori.
• Le funzioni creano comandi riutilizzabili che sono spesso assemblati in librerie (uno script con solo definizioni di funzioni) che possono essere acquistati da altri script.

Quando scrivere un alias ...

• Gli alias Bash non funzionano all'interno di costrutti di script shell come if / then e for / do loop , quindi dovrebbero essere usati solo come scorciatoie da tastiera su una riga di comando interattiva. Pertanto, tutte le definizioni di alias di solito risiedono all'interno dello script di accesso appropriato come ~/.profileo ~/.bashrc.

All'interno di script come gli script di libreria, a volte è necessario un alias per una funzione, ad esempio quando una funzione viene rinominata ma è richiesta la compatibilità con le versioni precedenti. Questo può essere realizzato creando una semplice funzione con il vecchio nome che passa tutti i suoi argomenti alla nuova funzione ...

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

Un'altra cosa che non credo sia stata sollevata: una funzione viene eseguita nel contesto del processo di invocazione, mentre uno script crea una nuova shell.

Questo potrebbe essere importante per le prestazioni: una funzione è più veloce, poiché non lo è fork()e exec(). In circostanze normali, la differenza è banale, ma se si sta eseguendo il debug di un sistema che ha esaurito la memoria e si sta scaricando la pagina, potrebbe fare una grande differenza.

Inoltre, se si desidera modificare l'ambiente shell corrente, è necessario utilizzare una funzione. Ad esempio, una funzione potrebbe cambiare la ricerca dei comandi $PATHper la shell corrente, ma uno script non può, poiché opera su una copia fork / exec di $PATH.

Script, alias, script e funzione non si escludono a vicenda. È possibile archiviare alias e funzioni negli script.

Gli script sono solo codice reso persistente . Funzioni utili e alias che ti piacerebbe usare in futuro sono memorizzati negli script. Tuttavia, uno script è spesso una raccolta di più di una funzione.

Poiché gli alias non sono parametrizzati , sono molto limitati; di solito per definire alcuni parametri predefiniti.

Una funzione è un'unità di codice separata , un concetto ben definito di poche righe di codice che non possono essere separate in parti più piccole e utili; uno che può essere riutilizzato direttamente o altro da altre funzioni.

Se dovrebbe essere molto veloce, rendilo un alias o una funzione.

Se dovrebbe essere utilizzabile al di fuori della tua shell preferita, rendilo uno script. ¹

Se accetta argomenti, rendilo una funzione o uno script.

Se deve contenere caratteri speciali, rendilo un alias o uno script. ²

Se deve funzionare con sudo, rendilo un alias o uno script. ³

Se si desidera modificarlo facilmente senza disconnettersi e accedere, uno script è più semplice. ⁴

Le note

¹ Oppure trasformalo in un alias, inseriscilo ~/.enve export ENV="$HOME/.env"impostalo, ma è complicato farlo funzionare in modo portabile.

² I nomi delle funzioni devono essere identificativi, quindi devono iniziare con una lettera e possono contenere solo lettere, cifre e caratteri di sottolineatura. Ad esempio, ho un alias alias +='pushd +1'. Non può essere una funzione.

³ E aggiungi l'alias alias sudo='sudo '. Idem qualsiasi altro comando, come strace, gdbecc che prende un comando come primo parametro.

⁴ Vedi anche: fpath. Certo che puoi anche fare source ~/.bashrco simili, ma questo ha spesso altri effetti collaterali.

Solo per aggiungere alcune note:

• Con sudo è possibile utilizzare solo script separati (come se fosse necessario modificare un file di sistema), ad esempio:

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

• Solo gli alias o le funzioni potrebbero sostituire i comandi di sistema con lo stesso nome (supponendo che tu aggiunga i tuoi script dir alla fine di PATH, che penso sia consigliabile per sicurezza in caso di creazione accidentale o malevola di script con nome identico a un comando di sistema), per esempio:

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

• Gli alias e le funzioni richiedono meno memoria e tempo per l'esecuzione, ma impiegano del tempo per caricarsi (poiché la shell deve interpretarli tutti prima di mostrare il prompt). Tenerne conto se si eseguono regolarmente nuovi processi di shell, ad esempio:

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

Oltre a ciò, è possibile utilizzare la forma più semplice possibile, ovvero prima considerare l'alias, quindi la funzione, quindi lo script.

La mia regola empirica è:

• alias - un comando, nessun parametro
• funzioni - un comando alcuni parametri
• script - diversi comandi, nessun parametro

In un ambiente multiutente (o multi sysamin), uso gli script per tutto, anche se finisce per essere un breve wrapper "exec qualcosa ....".

Certo, è tecnicamente più lento / meno efficiente di un alias o di una funzione, ma non importa quasi mai - e purché sia ​​nel percorso, uno script funziona sempre.

La tua funzione potrebbe essere chiamata da cron, da qualcosa con un ambiente ridotto o modificato come sudo o env, oppure l'utente potrebbe semplicemente utilizzare una shell diversa per te, tutto o che probabilmente romperà un alias o una funzione.

Se hai qualcosa di sensibile alle prestazioni, gestiscilo come un caso speciale, o meglio ancora, considera che un trigger per riscrivere in un linguaggio di scripting più funzionale.

Se stiamo parlando di funzionalità che verranno utilizzate solo in altri script, allora puoi anche considerare la definizione di una shell standard e la scrittura di uno script della libreria di funzioni che può essere. proveniente da tutti gli altri script.

T

Un esempio per una situazione in cui ti piacerebbe molto usare un alias.

So che questo è un vecchio post, ma vorrei sottolineare una situazione in cui ho quasi dovuto usare una combinazione di alias con uno script e ho scelto di non usare una funzione.

Ho una sceneggiatura ~/.bin/chiamata setupche fa quanto segue: ¹

1. mi porta in una determinata directory.
2. definisce alcune variabili.
3. stampa i messaggi sullo stato della directory. ²

Il punto è che se avessi appena eseguito setup <project-name>non avrei definito quelle variabili e non sarei arrivato alla directory. La soluzione che ho trovato per essere il migliore è stato quello di aggiungere questo script per PATHe aggiungere alias setup=". ~/.bin/setup"al ~/.bashrco qualsiasi altra cosa.

Appunti:

1. Ho usato uno script per questa attività e non una funzione non perché è particolarmente lunga ma perché posso modificarlo e non devo eseguire il sorgente del file dopo una modifica se voglio aggiornarne l'utilizzo.
2. Un caso simile mi è successo quando ho creato una sceneggiatura per ricaricare tutti i miei dotfile. ³

1. Lo script è disponibile nel mio repository dotfiles in .bin/.
2. Informazioni sullo script : do a questo script un argomento che è un nome per il progetto che ho definito in anticipo. Successivamente lo script sa portarmi nella directory giusta in base a un determinato csvfile. Le variabili che definisce sono prese dal makefile in quella directory. La sceneggiatura viene eseguita successivamente ls -le git statusper mostrarmi cosa sta succedendo lì.
3. Questo script è disponibile anche nel mio repository dotfiles anche sotto .bin/.

Quando scrivere una sceneggiatura

Quando si desidera eseguire il comando da uno strumento diverso dalla shell.

Questo include vim (per me): avendo scritto filtri e altri programmi come script, posso fare qualcosa come :%!my-filterfiltrare un file attraverso il programma dal mio editor.

Se my-filterfosse una funzione o un alias, ciò non sarebbe possibile.