Que signifie “ déclarer ” dans Bash?

Dans la plupart des cas, il suffit dune déclaration implicite dans bash

asdf="some text" 

Mais, parfois, vous voulez que la valeur dune variable soit uniquement un entier (donc au cas où elle changerait plus tard, même automatiquement, elle ne pourrait être changée quen un entier, par défaut à zéro dans certains cas), et peut utiliser:

declare -i num 

ou

declare -i num=15 

Parfois, vous voulez des tableaux, puis vous avez besoin de declare

declare -a asdf # indexed type 

ou

Vous pouvez trouver de bons tutoriels sur les tableaux dans bash lorsque vous naviguez sur Internet avec la chaîne de recherche » bash array tutorial « (sans guillemets), pour exemple

linuxconfig.org/how-to-use-arrays-in-bash-script

Je pense que ce sont les cas les plus courants lorsque vous déclarez des variables.

Veuillez noter également que

• dans une fonction, declare rend la variable locale (dans la fonction)

• sans aucun nom, elle liste toutes les variables (dans le shell actif)

  declare 

Enfin, vous obtenez un bref résumé des fonctionnalités de la commande intégrée du shell declare dans bash avec la commande

help declare 

Commentaires

• Bonjour de lOP! Je pense que votre réponse est excellente et je lai votée et merci pour cette réponse, à mon avis, très didactique. Je viens de suggérer une modification mineure qui, à mon humble avis, la rend encore plus facile et accessible à lire pour les nouveaux arrivants; veuillez suivre cette suggestion.
• Je viens de voir que user:muru a voté pour rejeter la modification; sachez que moi et muru avons  » affronté  » plusieurs fois dans les différentes sections de ce site et je suppose que son rejet nest pas ‘ t objectif et est en fait nuisible par rapport aux changements directs présentés dans la page de suggestion dédition ici: unix.stackexchange.com/review/suggested -edits / 325749
• @JohnDoea, jai vu quun autre utilisateur a également rejeté vos modifications. Je pense que certaines de vos modifications sont bonnes, mais certaines dentre elles changeront le message par rapport à ce que je voulais, donc je ne les aimerais pas. Je peux modifier la réponse pour inclure ce que je pense être de bonnes modifications.
• merci; comme vous le savez probablement, rejeter les modifications est bien plus courant en SE que les accepter (même partiellement); merci de mavoir fait savoir quun autre utilisateur a rejeté la modification (je nai ‘ pas voir avant honnêtement) et davoir envisagé dinsérer au moins certaines de mes modifications à votre réponse; Je respecte beaucoup,

La sortie de help declare est assez concis. Une explication plus claire peut être trouvée dans man bash ou info bash – ce dernier étant la source de ce qui suit.

Tout dabord, quelques définitions. À propos des variables et attributs :

Un paramètre est une entité qui stocke des valeurs. … Une variable est un paramètre désigné par un name. Une variable a une valeur et zéro ou plusieurs attributs . Les attributs sont attribués à laide de la commande intégrée declare …

Et à propos du declare intégré :

declare

 declare [-aAfFgilnrtux] [-p] [name[=value] …]  

Déclarez des variables et donnez-leur des attributs. Si aucun nom nest donné, affichez les valeurs des variables à la place.

…

-n
Donnez à chaque name lattribut nameref , ce qui en fait une référence de nom à une autre variable. Cette autre variable est définie par la valeur de nom . Toutes les références, affectations et modifications dattribut à nom , à lexception de celles qui utilisent ou modifient lattribut -n lui-même, sont effectuées sur la variable référencée par la valeur de nom . …

Notez que les variables référence de nom ne sont disponibles que dans Bash 4.3 ou version ultérieure ¹ .

De plus, pour une introduction utile à declare et aux attributs variables dans Bash, je vous indiquerais ceci Répondez à  » Que font declare name et declare -g?  » (qui se concentre principalement sur la portée des variables « , cependant).

Fondamentalement ² , declare name=[value] équivaut à laffectation name=[value] que vous connaissez probablement. Dans les deux cas, name reçoit la valeur NULL valeur si value est manquant.

Notez que le declare name légèrement différent, à la place, nest pas défini la variable name ³ :

 $ declare name ## With the -p option, declare is used to display ## attributes and values of variables $ declare -p name declare -- name ## "name" exists ## Parameter expansion can be used to reveal if a variable is set: ## "isunset" is substituted to "name" only if unset $ echo "${name-isunset}" isunset  

Ainsi, la variable name peut être:

• déclarée et non défini , après declare name;
• déclaré et défini avec null comme valeur, après name= ou declare name=;
• déclaré , set et avec une valeur non nulle après name=value ou .

Plus généralement, declare [options] name=value

1. crée la variable name – qui est un paramètre avec un nom, qui à son tour nest quune partie de la mémoire que vous pouvez utiliser pour stocker des informations ⁴ ;
2. attribue la valeur value;
3. définit éventuellement les attributs de name « , qui définissent à la fois le type de valeur peut stocker (pas en termes de type , à proprement parler, puisque le langage de Bash nest pas tapé) et les façons dont il peut être manipulé.

Les attributs sont probablement plus facile à expliquer avec un exemple: lutilisation de declare -i name définira lattribut  » integer  » de name, le laissant être traité comme un entier; citant le manuel ,  » lévaluation arithmétique sera effectuée lorsque la variable se verra attribuer une valeur « :

 ## Let"s compare an ordinary variable with an integer $ declare var $ declare -i int $ var="1+1" $ int="1+1" $ echo "$var" 1+1 ## The literal "1+1" $ echo "$int" 2 ## The result of the evaluation of 1+1  

À la lumière de ce qui précède, ce qui se passe dans le code ilkkachu est que:

1. Une variable nommée ref est déclarée, avec le  » nameref  » jeu dattributs, et le contenu de $1 (le premier argument de position) est attribué à it:

    declare -n ref="$1"  

   Le but dune variable de référence de nom telle que ref est de contenir le nom dune autre variable, qui ne serait généralement pas connue à lavance, peut-être parce que nous voulons quelle soit définie dynamiquement (par exemple parce que nous voulons réutiliser un morceau de code et lavoir appliqué à plusieurs variables), et à fournissent un moyen pratique de sy référer (et de le manipuler). (Pas le seul, cependant: lindirection est une alternative; voir Extension des paramètres du shell ).

2. Quand la valeur de la variable tmp1 est affectée à ref:

    ref=$tmp1  

   une variable supplémentaire, dont le nom est la valeur de ref, est déclarée implicitement. La valeur de tmp1 est également indirectement attribuée à la variable implicitement déclarée au moyen de cette affectation explicite à ref .

Dans le contexte de votre question associée , appelez read_and_verify as

 read_and_verify domain "Prompt text here..."  

déclarera la variable domain et attribuez-lui la valeur tmp1 (cest-à-dire lentrée de lutilisateur). Il est exactement conçu pour réutiliser le code qui interagit avec lutilisateur et exploiter une variable nameref pour déclarer domain et quelques autres variables.

Pour regarder de plus près la partie implicite, nous pouvons reproduire le processus étape par étape:

 ## Assign a value to the first positional argument $ set -- "domain" ## Declare the same "tmp1" variable as in your code $ tmp1="value for domain" ## Declare a "ref" variable with the nameref attribute set and ## assign the value "domain" to it $ declare -n ref="$1" ## Note that there is no "domain" variable yet $ declare -p domain bash: declare: domain: not found ## Assign a value to "ref" and, indirectly, to the "domain" variable ## that is implicitly declared $ ref=$tmp1 ## Verify that a variable named "domain" now exists, and that ## its value is that of "tmp1" $ declare -p domain declare -- domain="value for domain" ## Verify that "ref" is actually a reference to "domain" $ domain="new value" $ echo "$domain" new value $ declare -p ref declare -n ref="domain" $ echo "$ref" new value  

¹ _{Référence: CHANGES fichier, section  » 3. Nouvelles fonctionnalités de Bash « , point  » w « .
Cela peut être pertinent: par exemple, CentOS Linux 7.6 (actuellement le dernière version) est livré avec Bash 4.2 .}

² _{Comme dhabitude avec shell builtins, une explication et exhaustive et concise est insaisissable car ils effectuent des actions diverses, éventuellement hétérogènes. Je me concentrerai uniquement sur la déclaration, l’attribution et la définition d’attributs, et j’envisagerai de répertorier, de définir la portée et de supprimer des attributs comme étant hors du champ de cette réponse.}

³ _{Ce comportement de declare -p a été introduit dans Bash 4.4. Référence: CHANGES fichier, section  » 3. Nouvelles fonctionnalités de Bash « , point  » f « .
Comme G-Man signalé dans les commentaires, dans Bash 4.3 declare name; declare -p name génère une erreur. Mais vous pouvez toujours vérifier que name existe avec declare -p | grep "declare -- name".}

⁴ _{FullBashGuide, Paramètres sur mywiki.wooledge.org}

Commentaires

• (1) Je ne peux pas reproduire les résultats que vous affichez dans votre premier bloc de code: declare name suivi de declare -p name renvoie « bash: declare: name: not found ». (Bien que declare -p | grep na donne declare -- name.) (2) Je pense quil est un peu trompeur de présenter echo "${name-isunset}" dans le contexte de declare name, dans la mesure où il traite une variable non déclarée (cest-à-dire non définie) comme une variable déclarée mais variable non définie . (3) Vous voudrez peut-être mentionner que les namerefs ne sont disponibles que dans les versions 4.3 et supérieures de bash.
• @ G-Man Merci pour vos remarques! Je ‘ les aborderai dès que possible et je ‘ mettrai à jour ma réponse le cas échéant. Quant à (1), mon GNU bash, version 5.0.7(1)-release (x86_64-pc-linux-gnu) sur Arch Linux donne toujours les résultats que jai montrés. Peut-être que ce comportement na été introduit que récemment, je ‘ enquêterai là-dessus.
• Ouais; Je ‘ m utilise uniquement la version 4.3.
• @ G-Man Réponse mise à jour avec des notes sur (1) et (3). À propos de (2): je voulais illustrer que declare x ne ‘ t set x, tandis que declare x= le fait. Je nai pas pu ‘ trouver une référence pour soutenir lassertion que declare -- x (comme sortie de declare -p x) signifie  » non défini « , tandis que declare -- x="" signifie  » set « ; jai donc introduit lextension ${parameter-word}, même si elle ne peut pas faire la distinction entre  » unset  » et  » nexiste ‘ « , comme vous le faites remarquer. Je ‘ ne sais pas comment puis-je clarifier cela dans ma réponse (sans distraire le lecteur de ce point), cependant.

Je vais essayer dexpliquer cela, mais pardonnez-moi si je ne suivrai pas lexemple que vous avez fourni. Je vais plutôt essayer de vous guider le long de ma propre approche, différente.

Vous dites que vous comprenez déjà des concepts tels que «variables» et «développer», etc. donc je vais juste en survoler quelques-uns connaissances de base qui, autrement, exigeraient une concentration plus approfondie.

Je commencerai donc par dire que, au maximum basic , la commande declare est juste un moyen pour vous de dire à Bash que vous avez besoin dune valeur de variable (cest-à-dire une valeur qui pourrait changer pendant lexécution du script), et que vous allez faites référence à cette valeur en utilisant un nom spécifique, précisément le nom que vous indiquez à côté de la commande declare elle-même.

Cest-à-dire:

 declare foo="bar"  

dit à Bash que vous voulez que la variable nommée foo ait la valeur bar.

Mais .. attendez une minute .. nous pouvons faites cela sans utiliser du tout declare, nest-ce pas. Comme dans:

 foo="bar"  

Très vrai.

Eh bien , il se trouve que laffectation simple ci-dessus est en fait un moyen implicite pour .. en fait .. déclarer une variable.

( Il se trouve également que ce qui précède est un de quelques façons de change la valeur de la variable nommée foo; en effet cest précisément la plus directe, façon concise, évidente, simple .. mais ce nest pas la seule .. .. Jy reviendrai plus tard .. ).

Mais alors, si cest le cas bien possible de déclarer un « nom qui marquera les valeurs des variables » (juste « variable » daprès, par souci de brièveté) sans utiliser du tout declare, pourquoi voudriez-vous utiliser cette commande pompeuse «déclarer»?

La réponse réside dans le fait que ce qui précède implique t manière de déclarer une variable (foo="bar"), cela .. implicitement .. fait que Bash considère cette variable comme étant du type le plus couramment utilisé dans le scénario dutilisation typique dun shell .

Ce type est le type chaîne, cest-à-dire une séquence de caractères sans signification particulière. Par conséquent, une chaîne est ce que vous obtenez lorsque vous utilisez la déclaration implicite.

Mais vous, en tant que programmeur, devez parfois plutôt considérer une variable comme, par exemple, un nombre .. sur lequel vous devez faire de larithmétique opérations .. et en utilisant une déclaration implicite comme foo=5+6 ne fera que Bash attribuera la valeur 11 à foo comme vous pourriez vous attendre. Il attribuera plutôt à foo la séquence des trois caractères 5 + 6.

Donc .. vous avez besoin dun moyen de dire à Bash que vous voulez que foo soit considéré comme un nombre, pas comme un string .. et cest pour cela quun declare explicite est utile.

Dites simplement:

 declare -i foo=5+6 # <<- note the "-i" option: it means "integer"  

et Bash se fera un plaisir de faire le calcul pour vous, et attribuer la valeur numérique 11 à la variable foo.

Autrement dit: en disant declare -i foo vous donnez à la variable foo le attribut dêtre un nombre entier.

Déclarer des nombres (précisément des entiers, parce que Bash ne comprend toujours pas les décimales, les virgules flottantes, etc.) peut être la première raison dutiliser declare, mais ce nest pas la seule raison. Comme vous lavez déjà compris, il existe quelques autres attributs que vous pouvez attribuer aux variables. Par exemple, vous pouvez demander à Bash de toujours mettre la valeur dune variable en majuscule quoi quil arrive: si vous dites declare -u foo, à partir de là, lorsque vous dites foo=bar Bash assigne en fait la chaîne BAR à la variable foo.

Pour donner lun de ces attributs à une variable, vous devez utiliser la commande declare, il ny a pas dautre choix.

Maintenant, un autre des Les attributs que vous pouvez donner via declare sont le tristement célèbre «name-ref», l’attribut -n. ( Et maintenant je vais reprendre le concept que jai mis en attente plus tôt ).

Lattribut name-ref, en gros, permet aux programmeurs Bash de changer la valeur dune autre manière dune variable. Cela donne plus précisément un moyen indirect de le faire.

Voici comment ça marche:

Vous declare une variable ayant lattribut -n, et cest très recommandé (mais pas strictement obligatoire, mais cela simplifie les choses) que vous donniez également une valeur à cette très variable sur le même declare. Comme ceci:

 declare -n baz="foo"  

Cela indique à Bash que, à partir de là le, chaque fois que vous utiliserez ou modifierez la valeur de la variable nommée baz, il utilisera ou changera en fait la valeur de la variable nommée foo.

Ce qui signifie quà partir de ce moment-là, vous Vous pouvez dire quelque chose comme baz=10+3 pour que foo obtienne la valeur 13.En supposant bien sûr que foo a été précédemment déclaré comme un entier (declare -i) comme nous lavons fait il y a une minute, sinon il obtiendra la séquence des quatre caractères 1 0 + 3.

Aussi: si vous modifiez directement la valeur de foo, comme dans foo=15, vous verrez 15 également en disant echo “${baz}”. Cela est dû au fait que la variable baz déclarée comme nom-ref de foo reflète toujours les foo valeur.

La commande declare -n ci-dessus est dite « nom-référence » car elle crée la variable baz référez au nom dune autre variable. En fait, nous avons déclaré que baz a la valeur « foo » qui, en raison de loption -n, est traitée par Bash comme le nom de une autre variable.

Maintenant, pourquoi sur Terre voudriez-vous faire ça?

Eh bien … cela vaut la peine de dire que cest une fonctionnalité pour des besoins assez avancés.

En fait, si avancée que lorsquun programmeur fait face à un problème qui nécessiterait vraiment une référence de nom, il lest aussi il est probable que ce problème devrait plutôt être résolu en utilisant un langage de programmation approprié au lieu de Bash.

Lun de ces besoins avancés est, par exemple, lorsque vous, en tant que programmeur, ne pouvez pas le savoir pendant le développement quelle variable vous devrez utiliser dans un point spécifique dun script, mais elle sera entièrement connue de manière dynamique au moment de lexécution. Et étant donné quil ny a aucun moyen pour un programmeur dintervenir au moment de lexécution, la seule option est de prévoir à lavance une telle situation dans le script, et un « name-ref » peut être le seul viable chemin. En tant que cas dutilisation largement connu de ce besoin avancé, pensez aux plug-ins, par exemple. Le programmeur dun programme «plug-in» doit prévoir au préalable des plug-ins à venir (et éventuellement tiers). Par conséquent, le programmeur devra utiliser des fonctionnalités comme une référence de nom dans Bash.

Un autre besoin avancé est lorsque vous devez gérer une énorme quantité de données dans la RAM et vous aussi besoin de transmettre ces données aux fonctions de votre script qui aussi doivent modifier ces données en cours de route. Dans ce cas, vous pouvez certainement copier ces données dune fonction à une autre (comme le fait Bash lorsque vous faites dest_var="${src_var}" ou lorsque vous invoquez des fonctions comme dans myfunc "${src_var}"), mais étant donné que ces données sont énormes, cela entraînerait un énorme gaspillage de RAM et pour une opération très inefficace. Donc, la solution si de telles situations surviennent nest pas dutiliser une copie des données, mais une référence à ces données. Dans Bash, un nom-ref. Ce cas dutilisation est vraiment la norme dans tout langage de programmation moderne, mais il est tout à fait exceptionnel en ce qui concerne Bash, car Bash est principalement conçu pour des scripts simples et courts qui traitent principalement des fichiers et des commandes externes et donc les scripts Bash doivent rarement passer énormément quantité de données entre les fonctions. Et lorsque les fonctions dun script ont besoin de partager certaines données (y accéder et les modifier), cela est généralement réalisé en utilisant simplement une variable globale, ce qui est tout à fait la norme dans les scripts Bash autant que très obsolète dans les langages de programmation appropriés.

Ensuite, il peut y avoir un cas dutilisation notable pour les références de noms dans Bash, et (peut-être ironiquement) il est associé lorsque vous utilisez encore dautres types de variables:

1. variables déclarées en tant que «tableaux indexés» (declare -a)
2. variables déclarées en tant que «tableaux associatifs» (declare -A).

Il sagit dun type de variables qui peuvent être plus facilement (et plus efficacement) transmises avec des fonctions en utilisant des noms-refs au lieu dune copie normale, même sils ne transportent pas dénormes quantités de données.

Si tous ces exemples semblent bizarres, et toujours incompréhensibles, cest uniquement parce que les noms-refs sont en effet un sujet avancé, et un besoin rare pour le scénario dutilisation typique de B ash.

Je pourrais vous parler doccasions où, pour ma part, jai trouvé une utilisation pour les noms de référence dans Bash, mais jusquà présent, ils ont été principalement pour des besoins assez «ésotériques» et compliqués, et je suis peur que si je les décrivais, je ne ferais que compliquer les choses pour vous à ce stade de votre apprentissage. Pour ne citer que le moins complexe (et peut-être pas ésotérique): renvoyer des valeurs à partir de fonctions. Bash ne prend pas vraiment en charge cette fonctionnalité, jai donc obtenu la même chose en utilisant des noms-refs. Cest dailleurs exactement ce que fait votre exemple de code.

En plus de cela, un petit conseil personnel, qui serait en fait mieux adapté pour un commentaire mais je nai pas été en mesure de le condenser suffisamment pour sadapter aux limites des commentaires de StackExchange.

Je pense que le plus que vous devriez faire pour le moment est simplement dexpérimenter avec les références de nom en utilisant les exemples simples que jai montrés et peut-être avec lexemple de code que vous avez fourni, sans tenir compte pour le moment la partie «pourquoi sur terre» et se concentrant uniquement sur la partie «comment ça marche». En expérimentant un peu, la partie «comment» peut mieux sombrer dans votre esprit, de sorte que la partie «pourquoi» vous soit claire en temps voulu lorsque (ou si) vous aurez un réel problème pratique pour lequel un nom- ref serait vraiment utile.

Commentaires

• LL3 Jaime beaucoup votre réponse et jai fait un pouce vers le haut: je comprends enfin ce que déclare – – ne pas déclarer les variables mais déclarer leurs attributs; mais malheureusement, jai perdu la trace lorsque vous avez commencé à expliquer ce quest un nom-ref. Je nai aucune idée de ce quil fait et pourquoi lutiliser.
• Cest – pourquoi donnerait cet attribut
• @JohnDoea je vois. Peut-être que vous pourriez laisser ce sujet pour le moment. Il est probablement trop tôt pour saisir ce concept au stade actuel de votre apprentissage. Quoi quil en soit, jai élargi ma réponse avec plus dexemples et aussi un petit addendum personnel sur la façon dont je pense que vous devriez procéder. Jai également mis des lignes horizontales pour délimiter lexplication générale de declare de lexplication spécifique de -n de laddendum personnel. Jai aussi fait un peu de reformulation ici et là mais rien de substantiel, donc je pense que vous pouvez simplement relire la partie -n plus le petit addendum.
• Merci, je pense que ‘ est daccord pour que japprenne à ce sujet maintenant, jai juste besoin dune explication que je peux comprendre et je devrais relire votre réponse entière aujourdhui, je ‘ Je suis ici.
• Vous mentionnez foo="bar" et declare foo="bar" . Vous voudrez peut-être mentionner (ne serait-ce que dans une note de bas de page) que, dans une fonction shell, declare foo="bar" crée une variable locale et foo="bar" crée un variable globale.

En général, declare dans le shell bash définit (ou supprime ou affiche) des attributs sur les variables. Un attribut est une sorte dannotation qui dit « ceci est une référence de nom », ou « ceci est un tableau associatif », ou « cette variable doit toujours être évaluée comme un entier », ou « cette variable est en lecture seule et ne peut pas be re-set « , ou » cette variable est exportée (une variable denvironnement) « etc.

Le typeset intégré est un synonyme de declare dans bash, car typeset est utilisé dans dautres shells (ksh, doù il provient, et zsh, par exemple) pour définir les attributs de variable.

En regardant de plus près lexemple de référence de nom dans la question:

La fonction shell que vous montrez, avec un peu de code supplémentaire qui lutilise:

#!/bin/bash function read_and_verify { read -p "Please enter value for "$1": " tmp1 read -p "Please repeat the value to verify: " tmp2 if [ "$tmp1" != "$tmp2" ]; then echo "Values unmatched. Please try again."; return 2 else declare -n ref="$1" ref=$tmp1 fi } read_and_verify foo printf "The variable "foo" has the value "%s"\n" "$foo" 

Exécution de ceci:

 $ bash script.sh Please enter value for "foo": hello Please repeat the value to verify: hello? Values unmatched. Please try again. The variable "foo" has the value "" 

Cela montre que la variable foo nest définie sur rien lorsque lutilisateur entre deux différents chaînes.

Cela montre que la variable foo est définie sur la chaîne que lutilisateur a saisie lorsquil a entré la même chaîne deux fois .

La façon dont $foo obtient la valeur hello dans la partie principale du script est par les lignes suivantes dans la fonction shell:

declare -n ref="$1" ref=$tmp1 

où $tmp1 est la chaîne hello saisi par lutilisateur, et $1 est la chaîne foo transmise sur la ligne de commande de la fonction à partir de la partie principale du script.

Notez que la variable ref est déclarée avec declare -n comme variable de référence de nom et que la valeur foo est donné comme valeur dans cette déclaration. Cela signifie quà partir de là, jusquà ce que la variable passe hors de portée, toute utilisation de la variable ref sera identique à lutilisation de foo. La variable ref est une variable de référence de nom faisant référence à foo à ce stade.

Cela a pour conséquence que lattribution dune valeur à ref, comme cela est fait sur la ligne suivant la déclaration, attribuera la valeur à foo.

La valeur hello est alors disponible dans $foo dans la partie principale du script.