Qual è il vantaggio di usare $ () invece di backtick negli script di shell?

Esistono due modi per acquisire l'output della riga di comando in bash:

1. Bacchette legacy Bourne ``:

   var=`command`

2. $() sintassi (che per quanto ne so è specifica di Bash, o almeno non supportata da vecchie shell non POSIX come l'originale Bourne)

   var=$(command)

C'è qualche vantaggio nell'usare la seconda sintassi rispetto ai backtick? O i due sono completamente equivalenti al 100%?

Il principale è la possibilità di annidarli , comandi all'interno dei comandi, senza perdere la sanità mentale cercando di capire se una qualche forma di fuga funzionerà sui backtick.

Un esempio, sebbene in qualche modo inventato:

deps=$(find /dir -name $(ls -1tr 201112[0-9][0-9]*.txt | tail -1l) -print)

che ti darà un elenco di tutti i file nella /dirstruttura di directory che hanno lo stesso nome del primo file di testo datato di dicembre 2011 ^(a) .

Un altro esempio potrebbe essere quello di ottenere il nome (non il percorso completo) della directory principale:

pax> cd /home/pax/xyzzy/plugh
pax> parent=$(basename $(dirname $PWD))
pax> echo $parent
xyzzy

^(a) Ora quel comando specifico potrebbe non funzionare davvero, non ho testato la funzionalità. Quindi, se mi voti per questo, hai perso di vista l'intento :-) È inteso solo come un'illustrazione su come annidare, non come uno snippet pronto per la produzione privo di bug.

Supponiamo di voler trovare la directory lib corrispondente a dove gccè installato. Hai una scelta:

libdir=$(dirname $(dirname $(which gcc)))/lib

libdir=`dirname \`dirname \\\`which gcc\\\`\``/lib

Il primo è più facile del secondo: usa il primo.

Il backticks ( `...`) è la sintassi legacy richiesta solo dalla più antica delle bourne-shell non compatibili con $(...)POSIX ed è POSIX e più preferita per diversi motivi:

• Le barre rovesciate ( \) all'interno dei backtick vengono gestite in modo non ovvio:

  $ echo "`echo \\a`" "$(echo \\a)"
  a \a
  $ echo "`echo \\\\a`" "$(echo \\\\a)"
  \a \\a
  # Note that this is true for *single quotes* too!
  $ foo=`echo '\\'`; bar=$(echo '\\'); echo "foo is $foo, bar is $bar" 
  foo is \, bar is \\

• La citazione annidata all'interno $()è molto più conveniente:

  echo "x is $(sed ... <<<"$y")"

  invece di:

  echo "x is `sed ... <<<\"$y\"`"

  o scrivendo qualcosa come:

  IPs_inna_string=`awk "/\`cat /etc/myname\`/"'{print $1}' /etc/hosts`

  perché $()utilizza un contesto completamente nuovo per la quotazione

  che non è portatile come le conchiglie Bourne e Korn richiederebbero queste barre rovesciate, mentre Bash e Dash non lo fanno.

• La sintassi per le sostituzioni dei comandi di annidamento è più semplice:

  x=$(grep "$(dirname "$path")" file)

  di:

  x=`grep "\`dirname \"$path\"\`" file`

  perché $()impone un contesto completamente nuovo per la quotazione, quindi ogni sostituzione di comando è protetta e può essere trattata da sola senza particolare preoccupazione per la quotazione e la fuga. Quando si usano i backtick, diventa più brutto dopo due e sopra i livelli.

  Pochi altri esempi:

  echo `echo `ls``      # INCORRECT
  echo `echo \`ls\``    # CORRECT
  echo $(echo $(ls))    # CORRECT

• Risolve un problema di comportamento incoerente quando si usano i backquotes:

  • echo '\$x' uscite \$x
  • echo `echo '\$x'` uscite $x
  • echo $(echo '\$x') uscite \$x

• La sintassi Backticks ha restrizioni storiche sul contenuto del comando incorporato e non può gestire alcuni script validi che includono backquotes, mentre il $()modulo più recente può elaborare qualsiasi tipo di script incorporato valido.

  Ad esempio, questi script incorporati altrimenti validi non funzionano nella colonna di sinistra, ma funzionano ^{sull'IEEE di} destra :

  echo `                         echo $(
  cat <<\eof                     cat <<\eof
  a here-doc with `              a here-doc with )
  eof                            eof
  `                              )
  
  
  echo `                         echo $(
  echo abc # a comment with `    echo abc # a comment with )
  `                              )
  
  
  echo `                         echo $(
  echo '`'                       echo ')'
  `                              )

Pertanto la sintassi per la sostituzione del comando$ -prefisso dovrebbe essere il metodo preferito, poiché è visivamente chiaro con sintassi pulita (migliora la leggibilità umana e della macchina), è annidabile e intuitivo, l'analisi interna è separata ed è anche più coerente (con tutte le altre espansioni che vengono analizzate tra virgolette) in cui i backtick sono l'unica eccezione e il carattere viene facilmente mimetizzato quando è adiacente per renderlo ancora più difficile da leggere, specialmente con caratteri piccoli o insoliti.`"

Fonte: Perché si $(...)preferisce `...`(backtick)? a BashFAQ

Guarda anche:

• Sezione standard POSIX "2.6.3 Sostituzione comando"
• Motivazione POSIX per includere la sintassi $ ()
• Sostituzione comando
• bash-hackers: sostituzione dei comandi

Da man bash:

          $(command)
   or
          `command`

   Bash performs the expansion by executing command and replacing the com-
   mand  substitution  with  the  standard output of the command, with any
   trailing newlines deleted.  Embedded newlines are not deleted, but they
   may  be  removed during word splitting.  The command substitution $(cat
   file) can be replaced by the equivalent but faster $(< file).

   When the old-style backquote form of substitution  is  used,  backslash
   retains  its  literal  meaning except when followed by $, `, or \.  The
   first backquote not preceded by a backslash terminates the command sub-
   stitution.   When using the $(command) form, all characters between the
   parentheses make up the command; none are treated specially.

Oltre alle altre risposte,

$(...)

spicca visivamente meglio di

`...`

I bastoncini sembrano troppo apostrofi; questo varia a seconda del carattere che stai utilizzando.

(E, come ho appena notato, i backtick sono molto più difficili da inserire negli esempi di codice inline.)

$() consente la nidificazione.

out=$(echo today is $(date))

Penso che i backtick non lo permettano.

È lo standard POSIX che definisce la $(command)forma di sostituzione dei comandi. La maggior parte delle shell in uso oggi sono conformi a POSIX e supportano questa forma preferita rispetto alla notazione arcaica di backtick. La sezione di sostituzione dei comandi (2.6.3) del documento Shell Language descrive questo:

La sostituzione dei comandi consente di sostituire l'output di un comando al posto del nome del comando stesso. La sostituzione del comando deve avvenire quando il comando è racchiuso come segue:

$(command)

o (versione retroquotata):

`command`

La shell espande la sostituzione del comando eseguendo il comando in un ambiente subshell (consultare Shell Execution Environment ) e sostituendo la sostituzione del comando (il testo del comando più il "$ ()" o backquotes racchiuso) con l'output standard del comando, rimuovendo sequenze di uno o più <newline>caratteri alla fine della sostituzione. I <newline>caratteri incorporati prima della fine dell'output non devono essere rimossi; tuttavia, possono essere trattati come delimitatori di campo ed eliminati durante la divisione del campo, a seconda del valore di IFS e delle quotazioni in vigore. Se l'output contiene byte nulli, il comportamento non è specificato.

All'interno dello stile di sostituzione del comando retroquadrato, <backslash>deve conservare il suo significato letterale, tranne se seguito da: ' $', ' `' o <backslash>. La ricerca del backquote corrispondente deve essere soddisfatta dal primo backquote non quotato senza escape; durante questa ricerca, se si incontra un backquote senza escape all'interno di un commento della shell, un documento qui, una sostituzione di comando incorporata del modulo $ ( comando ) o una stringa tra virgolette, si verificano risultati indefiniti. Una stringa tra virgolette singole o doppie che inizia, ma non termina, all'interno della `...`sequenza " " produce risultati indefiniti.

Con il modulo $ ( comando ), tutti i caratteri che seguono la parentesi aperta alla parentesi di chiusura corrispondente costituiscono il comando . È possibile utilizzare qualsiasi script shell valido per il comando , ad eccezione di uno script costituito esclusivamente da reindirizzamenti che produce risultati non specificati.

I risultati della sostituzione dei comandi non devono essere elaborati per un'ulteriore espansione della tilde, espansione dei parametri, sostituzione dei comandi o espansione aritmetica. Se si verifica una sostituzione di comando tra virgolette doppie, la divisione dei campi e l'espansione del percorso non devono essere eseguite sui risultati della sostituzione.

La sostituzione dei comandi può essere nidificata. Per specificare l'annidamento all'interno della versione retroquotata, l'applicazione deve precedere i backquotes interni con <backslash>caratteri; per esempio:

\`command\`

La sintassi del linguaggio dei comandi della shell ha un'ambiguità per le espansioni che iniziano con "$((", che può introdurre un'espansione aritmetica o una sostituzione di comando che inizia con una subshell. L'espansione aritmetica ha la precedenza; vale a dire, la shell deve prima determinare se può analizzare l'espansione come espansione aritmetica e deve solo analizzare l'espansione come comando sostituzione se determina che non può analizzare l'espansione come espansione aritmetica. La shell non ha bisogno di valutare espansioni nidificate quando esegue questa determinazione. Se incontra la fine dell'input senza aver già determinato che non può analizzare l'espansione come espansione aritmetica, il shell considera l'espansione come un'espansione aritmetica incompleta e segnala un errore di sintassi. Un'applicazione conforme deve garantire che separa " $(" e "('in due token (ovvero, separarli con uno spazio bianco) in una sostituzione di comando che inizia con una subshell. Ad esempio, una sostituzione di comando contenente una singola subshell potrebbe essere scritta come:

$( (command) )

Questa è una domanda precedente, ma ho trovato un esempio perfettamente valido di $(...)over `...`.

Stavo usando un desktop remoto su Windows con Cygwin e volevo scorrere il risultato di un comando. Purtroppo, il personaggio di backtick era impossibile da inserire, a causa della cosa del desktop remoto o dello stesso cygwin.

È ragionevole presumere che un segno di dollaro e le parentesi saranno più facili da digitare in configurazioni così strane.