Perché 0 è vero ma falso è 1 nella shell?

false; echo $?

Quanto sopra verrà prodotto 1, il che è contraddittorio con tutti gli altri linguaggi di programmazione che conosco.

Qualche motivo in questo?

È una convenzione, ma particolarmente utile se ci pensi. In generale, se un programma ha successo, è tutto ciò che devi sapere. Se fallisce, tuttavia, potrebbe essere necessario conoscere tutti i tipi di informazioni sull'errore: perché si è verificato, come risolverlo, ecc. Avere zero "successo" medio e un errore medio diverso da zero ti consente di controllare abbastanza facilmente il successo e, se lo desideri, esamina l'errore specifico per ulteriori dettagli. Molte API e framework hanno una convenzione simile: le funzioni che hanno esito positivo restituiscono 0 e quelle che non riescono restituiscono un codice di errore che descrive il particolare caso di errore.

Bash è un linguaggio di programmazione (scripting), ma è anche una shell e un'interfaccia utente. Se0 era un errore, il programma potrebbe presentare solo un tipo di errore.

Tuttavia in Bash, qualsiasi valore diverso da zero è un errore e possiamo utilizzare qualsiasi numero compreso tra 1 e 255 per rappresentare un errore. Ciò significa che possiamo avere molti diversi tipi di errori. 1è un errore generale, 126significa che un file non può essere eseguito, 127significa "comando non trovato", ecc. Ecco un elenco di codici di uscita Bash con significati speciali che mostrano alcuni dei codici di uscita più comuni.

Esistono anche molti tipi di successo (lo stato di uscita è 0). Tuttavia, un successo ti consentirà di procedere al passaggio successivo: puoi ad esempio stampare i risultati su una schermata o eseguire un comando, ecc.

Ci sono due problemi correlati qui.

In primo luogo, la domanda dell'OP, perché 0 è vero ma falso è 1 nella shell? e il secondo, perché le applicazioni restituiscono 0 per il successo e diverso da zero per il fallimento?

Per rispondere alla domanda del PO dobbiamo capire la seconda domanda. Le numerose risposte a questo post hanno descritto che questa è una convenzione e hanno elencato alcune delle sottigliezze che questa convenzione offre. Alcune di queste sottigliezze sono riassunte di seguito.

Perché le applicazioni restituiscono 0 per il successo e diverso da zero per il fallimento?

Il codice che richiama un'operazione deve conoscere due cose sullo stato di uscita dell'operazione. L'operazione è terminata con successo? [* 1] E se l'operazione non è terminata correttamente, perché l'operazione è terminata senza successo? Qualsiasi valore potrebbe essere utilizzato per indicare il successo. Ma 0 è più conveniente di qualsiasi altro numero perché è portabile tra le piattaforme. Riassumendo la risposta di xibo a questa domanda il 16 agosto 2011:

Zero è indipendente dalla codifica.

Se volessimo memorizzare uno (1) in una parola intera a 32 bit, la prima domanda sarebbe "parola big-endian o parola little-endian?", Seguita da "quanto tempo sono i byte che compongono una parola little-endian?" ", mentre lo zero sarà sempre lo stesso.

Inoltre ci si deve aspettare che alcune persone lanciano errno a char o short ad un certo punto, o anche a float. (int) ((char) ENOLCK) non è ENOLCK quando char non è lungo almeno 8 bit (le macchine con caratteri ASCII a 7 bit sono supportate da UNIX), mentre (int) ((char) 0) è 0 indipendente dal dettagli architettonici di char.

Una volta stabilito che 0 sarà il valore restituito per il successo, ha senso utilizzare qualsiasi valore diverso da zero per il fallimento. Ciò consente a molti codici di uscita di rispondere alla domanda sul perché l'operazione non è riuscita.

Perché 0 è vero ma falso è 1 nella shell?

Uno degli usi fondamentali delle shell è automatizzare i processi tramite script. Di solito questo significa invocare un'operazione e quindi fare qualcos'altro in base allo stato di uscita dell'operazione. Philippe A. ha spiegato bene nella sua risposta a questo post che

In bash e nelle shell unix in generale, i valori restituiti non sono booleani. Sono codici di uscita interi.

È quindi necessario interpretare lo stato di uscita di queste operazioni come un valore booleano. Ha senso mappare uno 0stato di uscita riuscito ( ) a vero e qualsiasi stato di uscita diverso da zero / errore a falso. Ciò consente l'esecuzione condizionale dei comandi di shell concatenati.

Ecco un esempio mkdir deleteme && cd $_ && pwd. Poiché la shell interpreta 0 come vero, questo comando funziona convenientemente come previsto. Se la shell dovesse interpretare 0 come falso, dovresti invertire lo stato di uscita interpretato per ogni operazione.

In breve, non avrebbe senso che la shell interpretasse 0 come falso, data la convenzione secondo cui le applicazioni restituiscono 0 per uno stato di uscita riuscito.

[* 1]: Sì, molte volte le operazioni devono restituire più di un semplice messaggio di successo, ma questo va oltre lo scopo di questo thread.

Vedi anche l' Appendice E nella Advanced Bash-Scripting Guide

L'unico punto fondamentale che trovo importante da capire è questo. In bash e nelle shell unix in generale, i valori restituiti non sono booleani. Sono codici di uscita interi. Pertanto, è necessario valutarli secondo la convenzione dicendo che 0 significa successo e altri valori indicano un errore.

Con test, [ ]o [[ ]]gli operatori, le condizioni di bash valutano come vero nel caso di un codice di uscita pari a 0 (il risultato di / bin / true). Altrimenti valutano come false.

Le stringhe vengono valutate in modo diverso rispetto ai codici di uscita:

if [ 0 ] ; then echo not null ; fi
if [ $(echo 0) ] ; then echo not null ; fi

if [ -z "" ] ; then echo null ; fi

L' (( ))operatore aritmetico interpreta 1 e 0 come vero e falso. Ma quell'operatore non può essere utilizzato come sostituto completo di test,[ ] o [[ ]]. Ecco un esempio che mostra quando l'operatore aritmetico è utile:

for (( counter = 0 ; counter < 10 ; counter ++ )) ; do
  if (( counter % 2 )) ; then echo "odd number $counter" ; fi
done

È solo una convenzione che un codice di uscita 0 significhi successo. EXIT_SUCCESS sarà 0 su quasi tutti i sistemi moderni.

MODIFICARE:

"perché sia ​​il test 0 che il test 1 restituiscono 0 (successo)?"

Questa è una domanda completamente diversa. La risposta è che il passaggio di un singolo argomento per il test ha sempre esito positivo a meno che tale argomento non sia la stringa nulla (""). Vedere la documentazione di Open Group .

In genere i programmi restituiscono zero in caso di successo, diverso da zero in caso di fallimento; falserestituisce 1 perchéèun valore diverso da zero conveniente, ma generalmente qualsiasi valore diverso da zero significa un errore di qualche tipo e molti programmi restituiranno valori diversi da zero per indicare diverse modalità di errore

AFAIK questo deriva dalla convenzione C che dovresti restituire 0 se ha successo. Vedere:

man close

La maggior parte delle API C (POSIX) è costruita in questo modo. http://en.wikipedia.org/wiki/C_POSIX_library

è una convenzione che risale ai primi giorni di Unix.

Per convenzione, tutte le chiamate di sistema restituiscono 0 in caso di esito positivo, diverso da zero in caso contrario, poiché è possibile utilizzare numeri diversi per indicare diversi motivi del fallimento.

I gusci seguono questa convenzione, 0 significa che l'ultimo comando è riuscito, diversamente da zero. Allo stesso modo, il valore di ritorno diverso da zero è utile per i messaggi di errore di output: ad esempio 1: "cervello morto", 2: "senza cuore" e così via.

Stai cercando di equiparare vero / falso con successo / fallimento.

Sono due dicotomie completamente, anche se sottilmente all'inizio, diverse!

Nello scripting di shell non esiste il vero / falso. Le "espressioni" della shell non vengono interpretate come vero / falso. Piuttosto, le "espressioni" di shell sono processi che riescono o falliscono.

Ovviamente, un processo potrebbe fallire per molte ragioni. Quindi abbiamo bisogno di un set di codici più ampio per mappare i possibili errori. Gli interi positivi fanno il trucco. D'altra parte, se il processo ha successo, significa che ha fatto esattamente quello che doveva fare. Poiché esiste un solo modo per farlo, è necessario un solo codice. 0 fa il trucco.

In C, stiamo creando un programma. In uno script di shell, stiamo eseguendo una serie di programmi per ottenere qualcosa.

Differenza!

Forse un buon modo per ricordarlo è:

• Codici di ritorno risposta "qual è la risposta?" vero (o altro risultato) o falso
• I codici di uscita rispondono "qual è il problema?" codice di uscita o nessun problema (0)