Dev Faq
0
votes

Comportement et structure essentielle de la liste d'arguments Bash

Le code de l'échantillon ci-dessous montre que les arguments / arguments peuvent être facilement inspectés avec une commande imprimée à une ligne, alors qu'un tableau créé à partir des arguments ne peut pas être inspecté avec la même commande. Et il nous rappelle que l'approche "variable" perd la distinction entre les arguments individuels, si un argument est contenant des espaces.

est là un moyen de copier le tableau d'un script vers un nouvel objet qui peut être examiné avec celui-ci qui peut être examiné avec celui-ci. -Le commande printf -line?

est la liste d'arguments d'un script identique dans sa structure et son comportement à n'importe quel objet (analogue à un tableau, une variable, etc.) que l'on peut créer dans un script Bash? xxx

4 commentaires

Pourquoi pas seulement comteargs = $ # ? Ou même comme comteargs = $ (printf "% .0s." "$ @" | Wc -c) ? Appelant printf "% s" 1 + 1 | BC est comme Overkill, même de l'expansion arithmétique Bash (((comteargs ++)) serait suffisant.

Dès que vous convertissez la matrice en une chaîne, vous perdez la structure et je ne pense pas qu'il y ait un moyen de le récupérer.

Il suffit de le garder dans un tableau.

Les tableaux existent précisément parce que argvariable = "$ @" ne parvient pas à préserver la distinction entre les espaces de séparateur de mots.

3 Réponses :

1
votes

est la liste d'arguments d'un script identique dans sa structure et son comportement à n'importe quel objet (analogue à une matrice, une variable, etc.) que l'on peut créer dans un script Bash?

Oui, et non. Il y a des similitudes, principalement à un tableau. Essayons de créer une liste et de comparer des arguments avec un tableau Ar :

  • Obtenez l'argument Count: $ # vs $ {# arr [@]}
  • accès ex. 3ème argument / élément: 3 $ vs $ {arr [3]}
  • Access N-ème argument / élément: $ {@: $ N: 1} vs $ {arrated]} . Mais la tranchée de tableau fonctionnera également sur les tableaux: $ {arr [@]: $ n: 1} . .
  • SET NTH ARGUMENT: BUH, vous devriez faire Set - $ {@: 1: $ (((N-1))} NEWVALUE $ {@: $ ((n + 1))} < / code> vs arr [$ n] = newvalue
  • Changement de droite: shift ou, eh bien, set - "$ {@: 2}" vs arr = ("$ {arr [{arr [@ @ @] : 1} ")
  • argument est toujours continu 0 $ 1 $ 2 $ , pendant que vous pouvez arr = (); arr [10] = valeur; arr [100] = valeur .
  • Obtenir des index: quelque chose le long $ (SEQ $ #) vs $ {! arr [@]}
  • est correctement échappé: "$ @" vs "$ {arr [@]}"
  • Obtenez en tant que chaîne unique: "$ *" vs "$ {arr [*]}"

    résumer:

    • Arguments dans les scripts doivent être consultés à l'aide de $ @ et $ .
    • Vous pouvez utiliser sur $ @ beaucoup comme sur les tableaux, mais vous ne pouvez pas facilement assigner et / ou supprimer des éléments.
    • Il y a aussi la commande spéciale shift , qui déplace les arguments.
    • les "paramètres spéciaux" $ @ $ * $ # # et $ < href = "https://pubs.opengroup.org/onlinepubs/007904875/utilities/shift.html" rel = "nofollow noreferrer"> shift et SET Les commandes sont spécifiées par POSIX Shell . Les tableaux Bash sont disponibles uniquement sur Bash.

      à votre script:

      • argvariaable = "$ @" développe $ @ et le rejoint en utilisant ifs . Donc, vous terminerez avec une seule chaîne. Ceci est égal à argvariable = "$ *" . Donc, l'échappement des arguments est perdue.
      • comteargs = "0" pour x dans "$ {@}" fais comtéargs = $ (printf '% s \ n' "1 + $ comteargs" | BC) printf '% s \ n' "$ comteargs: '$ x'" fait Ceci peut être simplement simplifié pour compter l'ex. NeufLines à partir de impression% .0s Sortie: comteargs = $ (printf "% .0s \ n" "$ @" | wc -l) . Sinon, vous pouvez utiliser une fonction d'aide simple: cntarg () {echo "$ #"; }; Countrgs = $ (CNTARG "$ @") . Faire $ (printf '% s \ n' "1 + $ comteargs" | BC) est un overkill-supports de coquille expr commande et bash prend en charge l'expansion arithmétique $ ((...)) . Vous pouvez simplement comteargs = $ ((((((comteargs + 1)) ou même (((comteargs ++)) pour incrémenter une variable.
      • "$ {argvariable [@]}" - argvariable n'est pas un tableau. Faire "$ {argvariable [@]}" est égal à "$ argvariable" . .

        Y a-t-il un moyen de copier le tableau d'argument d'un script vers un nouvel objet qui peut être examiné avec cette commande de printf d'une ligne?

        enregistrer la liste sur un tableau, comme vous le faites dans déclarer -a argarray = commande. xxx

        Vous pouvez alors Accès et exploiter sur argarray beaucoup comme sur $ @ .

1 commentaires

Correction: Les matrices Bash sont indexées de zéro (au moins par défaut), le troisième élément sera donc $ {arr [2]} et le n -th sera < code> $ {arr [n-1]} . En outre, il existe un moyen plus simple d'obtenir le N -th -Th argument: $ {! N} .

0
votes

Réponse à "Il y a un moyen de copier l'article d'un script à un nouvel objet qui peut être examiné avec cette commande d'impression à une ligne?":

après xxx

Le code xxx

produit exactement la même sortie que xxx

concernant "est le Liste d'arguments d'un script identique dans sa structure et son comportement à n'importe quel objet (analogue à une matrice, une variable, etc.) que l'on peut créer dans un script Bash? ", L'objet" l'objet "le plus proche de la liste des arguments ( Paramètres de position ) est le tableau. Les tableaux sont considérablement plus puissants cependant. Par exemple, des éléments de tableau peuvent être ajoutés, définis ou supprimés individuellement; et les tableaux peuvent être clairsemés. Voir Paramètres de positionnement (Manuel de référence Bash) et < href = "https://www.gnu.org/software/bash/manual/bash.html#aire" rel = "NOFollow NOREFERRER"> Arrays (Manuel de référence Bash) .

Notez qu'une liste comptée d'éléments de tableau peut être imprimée avec: xxx

0 commentaires
0
votes

La réponse à

Y a-t-il un moyen de copier le tableau d'argument d'un script vers un nouvel objet qui peut être examiné avec cette commande de printf d'une ligne? p> blockQuote>

est sans équivoque "oui. Utilisez un tableau, mais faites-le correctement." La lacune la plus importante de mon code d'échantillon était la suivante P> xxx pré>

qui est maintenant corrigée ci-dessous. Ainsi, il est logique de créer régulièrement argarray code> au début d'un script. Ensuite, les arguments eux-mêmes sont préservés pour une référence ultérieure. p>

Notez qu'avec un tableau, un moyen supplémentaire d'inspecter les éléments, non forts> disponibles avec les arguments eux-mêmes, est déclarer -p argarray code>. p>

Les plus petites lacunes, maintenant corrigées grâce aux réponses, étaient p>

  1. la méthode "Overkill" d'incrémentation de comtétargs li>
  2. mon terme imprécis "variable" lorsque "chaîne" aurait été plus claire li>
  3. Ne pas préciser que je voulais non seulement connaître le nombre total d'arguments, mais pour afficher leurs indices numériques. LI> ol>

    i Gardez le traitement "String" en bas de ce code d'échantillon, comme un rappel que le tournant les arguments en une chaîne est une mauvaise idée. P> 

    > bash-example.sh
arguments, printf:The dog ate the "mouse" 
arguments, printf:but
arguments, printf:the
arguments, printf:cat?
/Users/BNW/u/kh/bin/bash-example.sh: line 11: declare: @: not found
arguments indexed, loop:
1: 'The dog ate the "mouse" '
2: 'but'
3: 'the'
4: 'cat?'

argarray, printf:The dog ate the "mouse" 
argarray, printf:but
argarray, printf:the
argarray, printf:cat?
declare -a argarray='([0]="The dog ate the \"mouse\" " [1]="but" [2]="the" [3]="cat?")'
argarray indexed, loop:
1: 'The dog ate the "mouse" '
2: 'but'
3: 'the'
4: 'cat?'

argstring, printf:The dog ate the "mouse"  but the cat?
declare -- argstring="The dog ate the \"mouse\"  but the cat?"
argstring indexed, curly brackets, loop:
1: 'The dog ate the "mouse"  but the cat?'
argstring indexed, not bracketed, loop:
1: 'The'
2: 'dog'
3: 'ate'
4: 'the'
5: '"mouse"'
6: 'but'
7: 'the'
8: 'cat?'

0 commentaires

Articles qui pourrait vous intéresser :

Empilez plusieurs colonnes en une sans ignorer les cellules vides
Recherche du nombre de doublons uniquement et uniquement à la fin d'un tableau numpy
JS: filtre le tableau d'objets par valeur maximale par catégorie
Faire pivoter les éléments d'un tableau