Manipulation de cordes de bash
Ce qui est appelé ci-dessus comme des seaux, c'est ce que nous appelons les variables dans la plupart des langages de programmation. En outre, en s'appuyant sur le concept de base d'une variable, un concept que nous appelons est introduit.
Le typage est un nom pour le comportement de stockage et d'attribution attendu d'une variable. Alors, à quoi cela ressemble-t-il à notre retour à des seaux?
Dans le petit monde de seau, nous avons créé pour nos programmes, les seaux ont des noms. C'est ça.
Supposons maintenant que nos programmes n'ont pas le luxe d'avoir un nombre infini de sacs Jetson à leur disposition à utiliser comme seaux. Avant qu'un seau ne soit nommé et rempli de son contenu, le programme doit décider de la forme et de la constitution de chaque seau qu'il touche. Je sais que cela semble un peu exagéré mais c'est un mal nécessaire. Tous les seaux sont liés par leur type.
Manipulation de cordes en bash
À quoi cela ressemble à notre retour à Bash?
Les fonctions, les tableaux et les chaînes sont stockés en variables. Bash utilise ce que nous appelons les attributs pour signaler les modifications des comportements en affectation. Bien qu'il y ait un système pour modifier le comportement de l'attribution variable, quand tout se résume, les valeurs sont stockées en variables sous forme de cordes.
Dans Bash, un programme vit pour mettre des chaînes dans les variables et les nommer pour une utilisation ultérieure. Ces chaînes sont disponibles pour manipuler tout au long de la vie du programme. Le programme vit pour manipuler les cordes.
Ici, nous couvrirons la manipulation de la corde de bash dans la respiration et autant de profondeur que possible pour être accessible aux lecteurs de toutes les marques et formes. Continuer à lire.
Qu'est-ce que la manipulation des cordes dans Bash
La manipulation de cordes est une opération sur une chaîne modifiant son contenu. En bash, la manipulation des cordes se présente sous deux formes: la manipulation de la chaîne de bash pure et la manipulation de la chaîne via des commandes externes. Ici, nous toucherons les deux types de manipulation de cordes.
Supposons que nous ayons une variable dans Bash tenant une chaîne que nous souhaitons manipuler la chaîne nommée. Dans le cas où plus d'une chaîne existe, nous nommons la chaîne Strings, String2,… De plus, nous pouvons choisir de nommer une chaîne quelque chose de plus significatif que la chaîne pour promouvoir la compréhension du contenu de la chaîne et de l'utilisation prévue.
CONCATENATES CORDES - LISTANCE CORDES DANS UNE TRANDE
En bash, le moyen facile de concaténer les chaînes est de répertorier les chaînes dans l'ordre. La chaîne résultante est une nouvelle chaîne contenant toutes les chaînes répertoriées.
$ String1 $ String2…
Exemple: concaténation de la chaîne en répertoriant les chaînes en chaîne
String = "One";
String2 = "Two";
String3 = $ String $ String2;
echo $ String3
Sortir
un deux
Listing des chaînes dans un tableau
Dans Bash, une autre façon de concaténer les chaînes est de répertorier les chaînes dans un tableau et d'utiliser l'expansion des paramètres pour étendre le tableau dans la chaîne concaténée. Cependant, contrairement à l'exemple ci-dessus, la suppression des éléments de tableau de séparation des espaces blancs peut nécessiter un travail supplémentaire.
Array ($ Strings $ Strings2…)
Exemple: Concaténation des cordes en répertoriant les chaînes dans un tableau
Strings = ("One" "Two");
echo $ Strings [@]
Sortir
un deux
Raccourcir une chaîne - déplacer une chaîne vers la gauche
Une façon de raccourcir une chaîne est de déplacer son contenu vers la gauche. Les contenus de chaîne décalés vers la gauche disparaissent, ce qui entraîne une chaîne plus courte.
Exemple: boucle de gauche à gauche
String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
pour i dans $ (seq 0 $ (($ # string - 1)));
faire
echo $ String: $ i;
fait
Sortir
abcdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
cdefghijklmnopqrstuvwxyz
defghijklmnopqrstuvwxyz
efghijklmnopqrstuvwxyz
fghijklmnopqrstuvwxyz
ghijklmnopqrstuvwxyz
hijklmnopqrstuvwxyz
ijklmnopqrstuvwxyz
jklmnopqrstuvwxyz
klmnopqrstuvwxyz
lmnopqrstuvwxyz
mnopqrstuvwxyz
nopqrstuvwxyz
opqrstuvwxyz
pqrstuvwxyz
QRSTUVWXYZ
rstuvwxyz
stuvwxyz
tuvwxyz
uvwxyz
vwxyz
wxyz
xyz
yz
z
Changez une chaîne vers la droite, obtenez un sous-chaîne de chaîne
Une autre façon de raccourcir une chaîne en bash est d'obtenir la sous-chaîne d'une chaîne. L'opération résultante peut être utilisée pour implémenter une opération de décalage vers la droite similaire à la méthode ci-dessus.
Exemple: boucle droite de changement de vitesse
String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
pour i dans $ (seq 0 $ (($ # string - 1)));
faire
echo $ String: 0: $ # string -i;
fait
Sortir
abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxy
abcdefghijklmnopqrstuvwx
abcdefghijklmnopqrstuvw
abcdefghijklmnopqrstuv
abcdefghijklmnopqrstu
abcdefghijklmnopqrst
abcdefghijklmnopqrs
abcdefghijklmnopqr
abcdefghijklmnopq
abcdefghijklmnop
abcdefghijklmno
abcdefghijklmn
abcdefghijklm
abcdefghijkl
abcdefghijk
abcdefghij
abcdefghi
abcdefgh
abcdefg
a B c d e F
abcde
a B c d
abc
un B
un
Exemple: Pyramide de boucle de changement
Pour le plaisir, combinons les deux exemples de boucle de décalage ci-dessus pour dessiner une étape de notre terminal.
Exemple: étape de boucle de décalage
String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
pour i dans $ (seq 0 $ (($ # string - 1)));
faire
echo $ String: 0: $ # string -i;
fait
| tac;
pour i dans $ (seq 0 $ (($ # string - 1)));
faire
echo $ String: $ i;
fait
Sortir
un
un B
abc
a B c d
abcde
a B c d e F
abcdefg
abcdefgh
abcdefghi
abcdefghij
abcdefghijk
abcdefghijkl
abcdefghijklm
abcdefghijklmn
abcdefghijklmno
abcdefghijklmnop
abcdefghijklmnopq
abcdefghijklmnopqr
abcdefghijklmnopqrs
abcdefghijklmnopqrst
abcdefghijklmnopqrstu
abcdefghijklmnopqrstuv
abcdefghijklmnopqrstuvw
abcdefghijklmnopqrstuvwx
abcdefghijklmnopqrstuvwxy
abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
cdefghijklmnopqrstuvwxyz
defghijklmnopqrstuvwxyz
efghijklmnopqrstuvwxyz
fghijklmnopqrstuvwxyz
ghijklmnopqrstuvwxyz
hijklmnopqrstuvwxyz
ijklmnopqrstuvwxyz
jklmnopqrstuvwxyz
klmnopqrstuvwxyz
lmnopqrstuvwxyz
mnopqrstuvwxyz
nopqrstuvwxyz
opqrstuvwxyz
pqrstuvwxyz
QRSTUVWXYZ
rstuvwxyz
stuvwxyz
tuvwxyz
uvwxyz
vwxyz
wxyz
xyz
yz
z
Capitalisez toute la chaîne en bash
Dans BASH4 ou version ultérieure, vous pouvez capitaliser les caractères imprimables en utilisant l'expansion des paramètres comme suit.
$ String ^^
Supposons que nous jetons les 10 premiers mots de la sortie de l'exemple de pas de boucle de décalage dans une variable appelée pyramide. Notez que non modifié, le comportement attendu de faire écho à son contenu est le suivant.
Commande
pyramid = "A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ"
echo $ pyramid
Sortir
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
Notez que comme vous vous en doutez, il n'y a pas de plafonds. Soufflons-le. C'est-à-dire que nous allons faire tous ses plafonds de personnages.
Commande
echo $ pyramid ^^
Sortir
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
C'était facile! Que diriez-vous si nous voulons convertir la première lettre dans une chaîne en bouchons comme une phrase? Oui nous pouvons! Tout ce que nous devons faire est d'essayer un peu moins dur, un personnage de moins pour être exact.
Capitaliser uniquement la première lettre d'une chaîne
Peut-être que la capitalisation de toute la chaîne n'est pas la technique de manipulation de la chaîne de bash que vous recherchez. Et si vous n'avez besoin que de capitaliser la première lettre comme une phrase?
Commandes
pyramid = "A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ"
echo $ pyramid ^
Sortir
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
Supposons maintenant que nous sommes plus intéressés à convertir les chaînes en minuscules. Heureusement, il existe une pure façon bash pour ce faire; c'est-à-dire une expansion des paramètres.
Convertir toute la corde en minuscules en bash
Convertissez une chaîne en minuscules en bash en utilisant l'opérateur d'expansion des paramètres Double-Comma («,,»).
Commandes
pyramid = "A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ";
echo $ pyramid;
echo $ pyramid ,,
Sortir
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
Convertir uniquement la première lettre d'une chaîne en minuscules
Convertissez le premier caractère dans une corde en minuscules en bash en utilisant l'opérateur d'extension paramètre à commande unique («»).
Commandes
pyramid = "A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ";
echo $ pyramid;
echo $ pyramid,
Sortir
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
A ab ABC ABCD ABCDE ABCDEF ABCDEFG ABCDEFGH ABCDEFGHI ABCDEFGHIJ
Attribuez une valeur à une chaîne vide et renvoyez sa valeur
Souvent, vous souhaitez définir un secours pour une chaîne vide et faire persister sa valeur à travers un script bash tel que le cas lorsque vous acceptez éventuellement des variables de l'environnement. Cela peut être accompli en utilisant l'expansion des paramètres.
Commandes
echo [$ str];
echo [$ str: = vide];
echo [$ str]
Sortir
[]
[vide]
[vide]
Remarques: STR est supposé non attribué
Remplacez un motif se produisant dans une chaîne une fois de bash
Nous avons une chaîne assise dans une variable et voulons remplacer la première occurrence d'une sous-chaîne. Voici comment.
Utilisation de base
$ Str / Pattern / Remplacement
Commandes
str = "011011000110100101111100111010101100001101000011010010111110011101000010111
0011000110110111101101101 ";
echo $ str;
echo $ str / 111/000
Sortir
01101100011010010110111001110101011000011010000110100101101110011101
0000101110011000110110111101101101
0110110001101001011000000000000101000010000110100001101001011000000001
0000100000011000110110000111101101
Remplacez toutes les occurrences d'un motif dans une chaîne en bash
Nous avons une chaîne dans une variable et voulons remplacer toutes les occurrences d'une sous-chaîne. Voici comment.
Utilisation de base
$ Str // Pattern / Remplacement
Commandes
str = "01101100011010010110111001110101111100001101000011010010110111001110
10000101110011000110110111101101101 ";
echo $ str;
echo $ str // 111/000
Sortir
011011000110100101101110011101010110000110100001101001011011100
11101000011110011000110110111101101101
0110110001101001011000000000011010000100001101000011010010110000000
000100001000000110001101100001101101101
Comment manipuler les chaînes en bash en utilisant des commandes externes
Pour manipuler les chaînes dans Bash à l'aide d'une commande externe, nous devons utiliser une fonctionnalité que le manuel de bash appelle la substitution de commande. Bref, tout ce qui se trouve à l'intérieur $ () ou "est traité comme une commande et substitué en place. Franchement, je préfère la première façon; Cependant, vous pouvez utiliser soit. Le moyen facile d'utiliser la substitution de commande est d'attribuer le résultat de la substitution de commande à une variable comme suit.
Commandes
résultat = $ (commande)
Dans le cas de la manipulation de la chaîne à l'aide d'une commande externe dans Bash, nous aurions besoin de tuer l'écho d'une chaîne à la commande, à moins que le passage de la chaîne à la commande en tant que paramètre soit accepté. Voici à quoi devrait ressembler le nouveau résultat.
Commandes
result = $ (echo "$ result" | commande)
Maintenant, essayons de faire quelque chose de réel. Cependant, réduisez une chaîne contenant des mots au dernier mot de la chaîne? Pour cet exemple, utilisons la commande externe GAWK.
Notes sur les commandes suivantes. Faisons tout en minuscules et nous débarrassons des périodes. La citation est par Linus Torvalds. C'est une citation vraiment populaire.
Commandes
quote = "parler est bon marché. Montre-moi le code."
last_word = $ (echo "$ quote //./ "| GAWK 'print $ (nf)');
echo "$ last_word ,,"
Sortir
code
Conclusion sur la manipulation des cordes en bash
Ici, nous avons couvert comment manipuler les cordes de la manière pure bash ainsi que l'utilisation de commandes externes. Pour les techniques de manipulation de la chaîne de bash pure, une fonctionnalité appelée expansion des paramètres a été utilisée. D'un autre côté, dans le cas des commandes externes, la substitution de commande a été utilisée. Certes, en écrivant cette pièce, j'ai amélioré ma capacité à manipuler des cordes en bash. J'espère que tu as aussi fait.
Notez que le sujet de cette discussion n'a pas été traité dans son intégralité. Cependant, les exercices sont laissés à ceux qui souhaitent bricoler un peu plus. Pour d'autres manipulations de chaînes non contenues dans cet article, vous pouvez me contacter directement ou contacter l'éditeur.
C'est assez de manipulation de cordes, pour l'instant… merci,