Differenza tra ritorno e uscita nelle funzioni Bash

Qual è la differenza tra l' istruzione returne exitnelle funzioni di Bash rispetto ai codici di uscita?

Da man bashsu return [n];

Fa interrompere l'esecuzione di una funzione e restituisce il valore specificato da n al suo chiamante. Se n viene omesso, lo stato di ritorno è quello dell'ultimo comando eseguito nel corpo della funzione.

... su exit [n]:

Fa uscire la shell con uno stato di n. Se n viene omesso, lo stato di uscita è quello dell'ultimo comando eseguito. Una trap su EXIT viene eseguita prima che la shell termini.

MODIFICARE:

Secondo la modifica della domanda, per quanto riguarda i codici di uscita, returnnon ha nulla a che fare con i codici di uscita. I codici di uscita sono destinati ad applicazioni / script , non a funzioni. Quindi, a questo proposito, l'unica parola chiave che imposta il codice di uscita dello script (quella che può essere catturata dal programma chiamante usando la $?variabile shell) è exit.

MODIFICA 2:

La mia ultima dichiarazione di riferimento exitsta causando alcuni commenti. È stato fatto per differenziare returne exitper la comprensione dell'OP, e in effetti, in un dato punto di uno script programma / shell, exitè l'unico modo per terminare lo script con un codice di uscita al processo chiamante.

Ogni comando eseguito nella shell produce un "codice di uscita" locale: imposta la $?variabile di quel codice, e può essere utilizzato con if, &&e altri operatori ai condizionale eseguire altri comandi.

Questi codici di uscita (e il valore della $?variabile) vengono ripristinati da ogni esecuzione del comando.

Per inciso, il codice di uscita dell'ultimo comando eseguito dallo script viene utilizzato come codice di uscita dello script stesso come visto dal processo di chiamata.

Infine, le funzioni, quando chiamate, agiscono come comandi di shell rispetto ai codici di uscita. Il codice di uscita della funzione ( all'interno della funzione) viene impostato utilizzando return. Pertanto, quando return 0viene eseguita una funzione , l'esecuzione della funzione termina, fornendo un codice di uscita pari a 0.

returnfarà sì che la funzione corrente esca dall'ambito, mentre exitfarà terminare lo script nel punto in cui viene chiamato. Ecco un programma di esempio per spiegare questo:

#!/bin/bash

retfunc()
{
    echo "this is retfunc()"
    return 1
}

exitfunc()
{
    echo "this is exitfunc()"
    exit 1
}

retfunc
echo "We are still here"
exitfunc
echo "We will never see this"

Produzione

$ ./test.sh
this is retfunc()
We are still here
this is exitfunc()

Non credo che nessuno abbia veramente risposto completamente alla domanda perché non descrivono come vengono usati i due. OK, penso che sappiamo che exit uccide lo script, dovunque venga chiamato e puoi assegnargli uno stato come exit o exit 0 o exit 7 e così via. Questo può essere usato per determinare come lo script è stato costretto a fermarsi se chiamato da un altro script ecc. Basta all'uscita.

return quando chiamato restituirà il valore specificato per indicare il comportamento della funzione, generalmente un 1 o uno 0. Ad esempio:

    #!/bin/bash
    isdirectory() {
      if [ -d "$1" ]
      then
        return 0
      else
        return 1
      fi
    echo "you will not see anything after the return like this text"
    }

controlla in questo modo:

    if isdirectory $1; then echo "is directory"; else echo "not a directory"; fi

o in questo modo:

    isdirectory || echo "not a directory"

In questo esempio, il test può essere utilizzato per indicare se la directory è stata trovata. notare che qualsiasi cosa dopo il ritorno non verrà eseguita nella funzione. 0 è vero ma falso è 1 nella shell, diverso dagli altri linguaggi prog.

Per maggiori informazioni sulle funzioni: http://www.linuxjournal.com/content/return-values-bash-functions

NOTA: la funzione isdirectory è solo a scopo didattico. Questo non dovrebbe essere il modo in cui esegui tale opzione in uno script reale.

Ricorda, le funzioni sono interne a uno script e normalmente ritornano da dove sono state chiamate usando l'istruzione return. La chiamata di uno script esterno è completamente un'altra questione e gli script di solito terminano con un'istruzione exit.

La differenza "tra l'istruzione return e exit nelle funzioni BASH rispetto ai codici di uscita" è molto piccola. Entrambi restituiscono uno stato, non valori di per sé. Uno stato zero indica il successo, mentre qualsiasi altro stato (da 1 a 255) indica un errore. L'istruzione return tornerà allo script da dove è stata chiamata, mentre l'istruzione exit finirà l'intero script da dove viene incontrata.

return 0  # returns to where the function was called.  $? contains 0 (success).

return 1  # returns to where the function was called.  $? contains 1 (failure).

exit 0  # exits the script completely.  $? contains 0 (success).

exit 1  # exits the script completely.  $? contains 1 (failure).

Se la tua funzione termina semplicemente senza alcuna dichiarazione di ritorno, lo stato dell'ultimo comando eseguito viene restituito come codice di stato (e verrà inserito $?).

Ricorda, return e exit restituiscono un codice di stato da 0 a 255, disponibile in $?. Non è possibile inserire altro in un codice di stato (ad es. Return "cat"); non funzionerà. Tuttavia, uno script può restituire 255 diversi motivi di errore utilizzando i codici di stato.

È possibile impostare le variabili contenute nello script chiamante o ottenere risultati echo nella funzione e utilizzare la sostituzione dei comandi nello script chiamante; ma lo scopo di return e exit è passare codici di stato, non valori o risultati di calcolo come ci si potrebbe aspettare in un linguaggio di programmazione come C.

A volte, esegui uno script usando .o source.

. a.sh

Se si include un exitin a.sh, non solo terminerà lo script, ma terminerà la sessione della shell.

Se includi a returnin a.sh, semplicemente interrompe l'elaborazione dello script.

In parole semplici (principalmente per i principianti nella codifica), possiamo dire,

`return` : exits the function,
`exit()` : exits the program(called as process while running)

Anche se hai osservato, questo è molto semplice ma ...,

`return` : is the keyword
`exit()` : is the function

• exitterminare il processo corrente ; con o senza codice di uscita, considera questo un sistema più che una funzione di programma. Si noti che durante l'approvvigionamento, exitla shell terminerà, tuttavia, quando in esecuzione sarà solo exitlo script.

• returnda una funzione tornare all'istruzione dopo la chiamata, con o senza un codice di ritorno. returnè facoltativo ed è implicito alla fine della funzione. returnpuò essere utilizzato solo all'interno di una funzione.

Voglio aggiungere che, pur essendo di provenienza, non è facile per exitlo script all'interno di una funzione senza uccidere la shell. Penso che un esempio sia migliore in uno script "test"

#!/bin/bash
function die(){
   echo ${1:=Something terrible wrong happen}
   #... clean your trash
   exit 1
}

[ -f /whatever/ ] || die "whatever is not available"
# now we can proceed
echo "continue"

facendo quanto segue:

user$ ./test
Whatever is not available
user$

test - e - la shell si chiuderà.

user$ . ./test
Whatever is not available

solo testfinirà e il prompt mostrerà.

La soluzione è racchiudere la potenziale procedura in (e)

#!/bin/bash
function die(){
   echo $(1:=Something terrible wrong happen)
   #... clean your trash
   exit 1
}

( # added        
    [ -f /whatever/ ] || die "whatever is not available"
    # now we can proceed
    echo "continue"
) # added

ora, in entrambi i casi, testuscirà solo .

La domanda del PO: Qual è la differenza tra l'istruzione return e exit nelle funzioni BASH rispetto ai codici d'uscita?

In breve, sono necessari alcuni chiarimenti:

• Non è richiesta un'istruzione (return | exit) per terminare l'esecuzione di una (funzione | shell). Una (funzione | shell) termina quando raggiunge la fine del suo elenco di codici, anche senza alcuna istruzione (return | exit).
• Un'istruzione (return | exit) non è richiesta per restituire un valore da una terminata (funzione | shell). Ogni processo ha una variabile incorporata $? che ha sempre un valore numerico. È una variabile speciale che non può essere impostata come "? = 1", ma è impostata solo in modi speciali (vedi sotto *). Il valore di $? dopo l'ultimo comando da eseguire nella (chiamata funzione | shell secondaria) è il valore che viene restituito alla (funzione chiamante | shell padre). Questo è vero se l'ultimo comando eseguito è ("return [n]" | "exit [n]") o plain ("return" o qualcos'altro che sembra essere l'ultimo comando nel codice delle funzioni chiamate.

Nell'elenco elenco sopra, scegliere tra "(x | y)" o sempre il primo elemento o sempre il secondo elemento per ottenere rispettivamente istruzioni su funzioni e ritorno o shell e uscita.

Ciò che è chiaro è che entrambi condividono l'uso comune della variabile speciale $? per passare valori verso l'alto dopo che terminano.

* Ora per i modi speciali che $? può essere impostato:

• Quando una funzione chiamata termina e ritorna al suo chiamante allora $? nel chiamante sarà uguale al valore finale di $? nella funzione terminata.
• Quando una shell genitore attende in modo implicito o esplicito su una singola sub shell e viene rilasciata al termine di quella sub shell, allora $? nella shell genitore sarà uguale al valore finale di $? nella sub shell terminata.
• Alcune funzioni integrate possono modificare $? a seconda del loro risultato. Ma alcuni non lo fanno.
• Funzioni integrate "return" e "exit", quando seguite da un argomento numerico sia $? con argomento e termina l'esecuzione.

Vale la pena notare che $? può essere assegnato un valore chiamando exit in una sub shell, in questo modo:

# (exit 259)
# echo $?
3  

Prima di tutto, returnè una parola chiave e il exitmio amico è una funzione.

Detto questo, ecco una spiegazione più semplice.

return Restituisce un valore da una funzione.

exit Esce o abbandona la shell corrente.