Les backticks (c.-à-d. `Cmd`) dans * sh shells ont-ils été dépréciés?

J'ai vu ce commentaire à maintes resockets sur Unix et Linux ainsi que sur d'autres sites qui utilisent le phrasé «backticks ont été dépréciés», en ce qui concerne les shells comme Bash & Zsh.

Cette déclaration est vraie ou fausse?

Citant la spécification Open Group sur les langages de command Shell , en particulier cette section «2.6.3 Substitution de command» cette déclaration concernant la dépréciation de backtick est en réalité fausse. Les deux forms de la substitution de command, backticks ( `..cmd..` ) ou dollar parens ( $(..cmd..) ) sont toujours supscopes dans la mesure où la spécification va.

extrait

La substitution de command permet de substituer la sortie d'une command à la place du nom de la command elle-même. La substitution de command doit se produire lorsque la command est jointe comme suit:

  $(command) or (backquoted version): `command` 

Le shell doit étendre la substitution de command en exécutant la command dans un environnement de sous-shell (voir environnement d'exécution de shell) et en remplaçant la substitution de command (le text de la command plus les $() ou backquotes) avec la sortie standard de la command un ou plusieurs caractères à la fin de la substitution. Les caractères incorporés avant la fin de la sortie ne doivent pas être supprimés; cependant, ils peuvent être traités comme des délimiteurs de champ et éliminés lors de la division de champ, en fonction de la valeur de l'IFS et de la citation qui est en vigueur. Si la sortie contient des octets NULL, le comportement n'est pas spécifié.

Dans le style de substitution des commands, <backslash> doit conserver sa signification littérale, sauf si elle est suivie de: '$', ' \` 'ou <backslash> . La search de la contrepartie correspondante doit être satisfaite par la première réponse non-échappée sans guillemets; lors de cette search, si une réponse secondaire non-échappée est rencontrée dans un commentaire shell, un ici-document, une substitution de command incorporée du formulaire $(command) ou une string citée, des résultats indéfinis se produisent. Une string à guillemets simples ou à guillemets doubles qui commence, mais ne se termine pas, dans la séquence " `...` "produit des résultats indéfinis.

Avec le formulaire $(command) , tous les caractères suivant la parenthèse ouvrante à la parenthèse fermante correspondante constituent la command. Tout script shell valide peut être utilisé pour la command, à l'exception d'un script constitué uniquement de réapathements produisant des résultats non spécifiés.

Alors, pourquoi tout le monde dit que les backticks ont été dépréciés?

Parce que la plupart des cas d'utilisation devraient utiliser la forme du dollar parens par rapport aux points d'arrêt. Bon nombre des sites les plus réputés (y compris U & L) le mentionnent souvent aussi, donc c'est un bon conseil, mais c'est juste ça, un bon conseil.

  • BashFAQ # 082 – Pourquoi est-ce que $ (…) est préféré à `…` (backticks)?

extrait

`...` est la syntaxe héritée requirejse uniquement par le plus ancien des boîtiers Bourne non compatibles POSIX. Il y a plusieurs raisons de toujours préférer la syntaxe $(...)

  • Bash Hackers Wiki – Syntaxe obsolète et obsolète

extrait

C'est l'ancienne forme compatible avec Bourne de la substitution de command . Les syntaxes `COMMANDS` et $(COMMANDS) sont spécifiées par POSIX, mais ce dernier est grandement préféré, bien que le premier soit malheureusement toujours très répandu dans les scripts. Les substitutions de commands de style nouveau sont largement implémentées par chaque shell moderne (et ensuite certains). La seule raison d'utiliser backticks est la compatibilité avec un vrai shell Bourne (comme Heirloom). Les substitutions de commands backtick nécessitent une échappée spéciale lorsqu'elles sont nestedes, et les exemples trouvés dans la nature sont souvent cités incorrectement. Voir: Pourquoi est-ce que $ (…) est préféré à `…` (backticks)? .

  • Justification standard POSIX

extrait

En raison de ces comportements incohérents, il est déconseillé d'utiliser des substitutions de commands en arrière-plan pour les nouvelles applications qui imbriquent des substitutions de commands ou tentent d'intégrer des scripts complexes.

NOTE: Ce troisième extrait (ci-dessus) est probablement la source de pourquoi beaucoup considèrent les backticks comme étant dépréciés. Il montre plusieurs situations où les backticks ne fonctionneront tout simplement pas, mais la nouvelle méthode parens du dollar:

En outre, la syntaxe en arrière-plan a des ressortingctions historiques sur le contenu de la command incorporée. Bien que le nouveau formulaire "$ ()" puisse traiter n'importe quel type de script incorporé valide, le formulaire en arrière-plan ne peut pas gérer certains scripts valides incluant des references en return.

Si vous continuez à lire cette section, les échecs sont mis en surbrillance, montrant comment ils échoueraient en utilisant des backticks, mais travaillez en utilisant la nouvelle notation parens en dollars.

Conclusions

Il est donc généralement préférable d'utiliser des parens en fonction du dollar par rapport aux points d'arrêt, mais vous n'utilisez pas quelque chose qui a été techniquement déconseillé. Après avoir lu tout cela, vous devriez avoir l'emporter que vous êtes fortement encouragés à utiliser des parens à less que vous ayez un besoin pressant d'utiliser des backticks.

Ce n'est pas déprécié, mais les backticks ( `...`

  • Les backslashes ( \ ) à l'intérieur des backticks sont traités de manière non évidente:

     $ 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 citation nestede à l'intérieur de $() est beaucoup plus pratique:

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

    au lieu de:

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

    ou écrire quelque chose comme:

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

    parce que $() utilise un context entièrement nouveau pour citer

    ce qui n'est pas portable car les obus Bourne et Korn nécessiteraient ces backslashes, alors que Bash et Dash ne le font pas.

  • La syntaxe pour l'imbrication des substitutions de commands est plus simple:

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

    que:

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

    parce que $() applique un context entièrement nouveau pour la citation, de sorte que chaque substitution de command est protégée et peut être traitée seule sans souci particulier de citation et d'échappement. Lorsque vous utilisez des backticks, il devient plus laid et plus laid après deux niveaux et plus.

    Quelques exemples supplémentaires:

     echo `echo `ls`` # INCORRECT echo `echo \`ls\`` # CORRECT echo $(echo $(ls)) # CORRECT 
  • Il résout un problème de comportement incohérent lors de l'utilisation de backquotes:

    • echo '\$x' sorties \$x
    • echo `echo '\$x'` sorties $x
    • echo $(echo '\$x') sorties \$x
  • La syntaxe des backticks a des ressortingctions historiques sur le contenu de la command incorporée et ne peut pas gérer certains scripts valides incluant des backquotes, alors que le nouveau formulaire $() peut traiter n'importe quel type de script incorporé valide.

    Par exemple, ces scripts incorporés autrement valides ne fonctionnent pas dans la colonne de gauche, mais fonctionnent bien sur la bonne IEEE :

     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 ')' ` ) 

Par conséquent, la syntaxe pour la substitution de command $ -prefixed devrait être la méthode préférée, car elle est visuellement claire avec une syntaxe propre (améliore la lisibilité humaine et machine), elle est nestede et intuitive, son parsing interne est séparée et elle est plus cohérente avec toutes les autres expansions qui sont analysées à l'intérieur des guillemets doubles) où les backticks sont la seule exception et le caractère est facilement camouflé lorsqu'il est adjacent à " rendre encore plus difficile à lire, en particulier avec des fonts petites ou inhabituelles.

Source: Pourquoi est-ce que $(...) préféré à `...` (backticks)? à BashFAQ

Voir également:

  • Section standard POSIX "2.6.3 Substitution de command"
  • Justification POSIX pour inclure la syntaxe $ ()
  • Substitution de command
  • bash-hackers: substitution de command