Array à imprimé bash avec Newlines

Un tableau est un conteneur contenant les mêmes éléments de type de données, soit un type entier ou un type de flotteur. Nous pouvons gérer les tableaux en effectuant plusieurs opérations sur eux. Une Delima couramment utilisée est de casser le tableau et d'imprimer chaque mot sur une nouvelle ligne. Cette fonctionnalité est discutée dans l'article d'aujourd'hui. Pour comprendre ce concept, vous devez accéder à un terminal Ubuntu pour effectuer des termes liés à Bash sur Ubuntu. Nous avons couvert le sujet des échantillons les plus simples à critiques pour la compréhension de l'utilisateur.

Exemple 1

Dans cet exemple, prenez une variable et attribuez la valeur. La valeur est une longue chaîne. Pour avoir le résultat de la chaîne dans de nouvelles lignes, nous attribuerons la valeur de la variable à un tableau. Pour garantir le nombre d'éléments présents dans la chaîne, nous imprimerons le nombre d'éléments en utilisant une commande respective.

S a = ”Je suis étudiant. J'aime la programmation »
$ arr = ($ a)
$ echo «arr a $ # arr [@] éléments."

Vous verrez que la valeur résultante a affiché le message avec les numéros d'élément. Où le signe '#' est utilisé pour ne compter que le nombre de mots présents. [@] montre le numéro d'index des éléments de chaîne. Et le signe «$» est pour la variable.

Pour imprimer chaque mot sur une nouvelle ligne, nous devons utiliser les clés «% s '\ n». '% s' est de lire la chaîne jusqu'à la fin. En même temps, '\ n' déplace les mots vers la ligne suivante. Pour afficher le contenu du tableau, nous n'utiliserons pas le panneau «#». Car il n'apporte que le nombre total des éléments présents.

$ printf "'% s' \ n" "$ arr [@]"

Vous pouvez observer à partir de la sortie que chaque mot est affiché sur la nouvelle ligne. Et chaque mot est cité avec une seule citation parce que nous l'avons fourni dans la commande. Ceci est facultatif pour vous convertir la chaîne sans citations simples.

Exemple 2

Habituellement, une chaîne est divisée en un tableau ou des mots simples en utilisant des onglets et des espaces, mais cela conduit généralement à de nombreuses pauses. Nous avons utilisé une autre approche ici, qui est l'utilisation de IFS. Cet environnement IFS s'occupe de montrer que la façon dont une chaîne est cassée et convertie en petits tableaux. IFS a une valeur par défaut de "\ n \ t". Cela signifie que l'espace, une nouvelle ligne et un onglet peuvent passer la valeur dans la ligne suivante.

Dans l'instance actuelle, nous n'utiliserons pas la valeur par défaut de IFS. Mais au lieu de cela, nous le remplacerons par un seul caractère de Newline, ifs = $ '\ n'. Donc, si vous utilisez l'espace et les onglets, cela ne fera pas la rupture de la chaîne.

Maintenant, prenez trois chaînes et stockez-les dans la variable de chaîne. Vous verrez que nous avons déjà écrit les valeurs en utilisant des onglets à la ligne suivante. Lorsque vous prenez l'impression de ces cordes, elle formera une seule ligne au lieu de trois.

$ str = ”i m un étudiant
J'aime la programmation
Ma langue préférée est .filet."
$ echo $ str

Il est maintenant temps d'utiliser IFS dans la commande avec le personnage de Newline. En même temps, affectez les valeurs de la variable au tableau. Après avoir déclaré cela, prenez une impression.

$ Ifs = $ '\ n' arr = ($ str)
$ printf "% s \ n" "$ arr [@]"

Vous pouvez voir le résultat. Cela montre que chaque chaîne est affichée individuellement sur une nouvelle ligne. Ici, toute la chaîne est traitée comme un seul mot.

Une chose doit être notée ici: une fois la commande terminée, les paramètres par défaut des IF sont à nouveau retournés.

Exemple 3

Nous pouvons également limiter les valeurs du tableau à afficher sur chaque nouvelle ligne. Prenez une chaîne et placez-la dans la variable. Maintenant, convertissez-le ou stockez-le dans le tableau comme nous l'avons fait dans nos exemples précédents. Et prenez simplement l'impression en utilisant la même méthode que décrite précédemment.

Remarquez maintenant la chaîne d'entrée. Ici, nous avons utilisé des citations doubles sur la partie du nom deux fois. Nous avons vu que le tableau a cessé de s'afficher sur la ligne suivante chaque fois qu'elle rencontre un arrêt complet. Ici, un arrêt complet est utilisé après les doubles quotes. Ainsi, chaque mot sera affiché sur des lignes séparées. L'espace entre les deux mots est traité comme un point de rupture.

$ x = (name = ”Ahmad Ali mais". J'aime lire. «Sujet préféré = biologie»)
$ arr = ($ x)
$ printf "% s \ n" "$ arr [@]"

Comme le stop complet est après «Butt», la rupture du tableau est arrêtée ici. «I» a été écrit sans aucun espace entre le plein arrêt, il est donc séparé de l'ensemble.

Considérez un autre exemple d'un concept similaire. Donc le mot suivant n'est pas affiché après l'arrêt complet. Vous pouvez donc voir que seul le premier mot est affiché en conséquence.

$ x = (name = ”shawa”. «FAV Subject» = «English»)

Exemple 4

Ici, nous avons deux cordes. Avoir 3 éléments chacun à l'intérieur de la parenthèse.

$ array1 = (pomme banane pêche)
$ array2 = (mangue orange cerise)

Ensuite, nous devons afficher le contenu des deux chaînes. Déclarer une fonction. Ici, nous avons utilisé le mot-clé «composition», puis attribué un tableau à une variable et d'autres tableaux à une autre variable. Maintenant, nous pouvons imprimer les deux tableaux respectivement.

$ a ()
Typet -N FirstArray = 1 $ secondaire = 2 $
Printf '% s \ n' 1er: «$ FirstArray [@]»
Printf '% s \ n' 2nd: “$ SecondArray [@]”

Maintenant, pour prendre l'impression de la fonction, nous utiliserons le nom de la fonction avec les deux noms de chaîne comme indiqué précédemment.

$ un array1 array2

Il est visible à partir du résultat que chaque mot des deux tableaux est affiché sur une nouvelle ligne.

Exemple 5

Ici, un tableau est déclaré avec trois éléments. Pour les séparer sur de nouvelles lignes, nous avons utilisé un tuyau et un espace cité avec Double-Quotes. Chaque valeur du tableau de l'index respectif agit comme entrée pour la commande après le tuyau.

$ array = (Linux Unix PostgreSQL)
$ echo $ array [*] | tr "" "\ n"

C'est ainsi que l'espace fonctionne pour afficher chaque mot d'un tableau sur une nouvelle ligne.

Exemple 6

Comme nous le savons déjà, le fonctionnement de «\ n» dans n'importe quelle commande déplace les mots entiers après la ligne suivante. Voici un exemple simple pour développer ce concept de base. Chaque fois que nous utilisons «\» avec «n» n'importe où dans la phrase, cela mène à la ligne suivante.

$ printf "% b \ n" "Tout ce qui brille est \ pas de l'or"

Donc la phrase est divisée par deux et déplacée vers la ligne suivante. En passant vers l'exemple suivant, «% b \ n» est remplacé. Ici, un «-e» constant est également utilisé dans la commande.

$ echo -e «Bonjour le monde! Je suis nouveau ici"

Donc les mots après «\ n» sont déplacés vers la ligne suivante.

Exemple 7

Nous avons utilisé un fichier bash ici. C'est un programme simple. Le but est de montrer la méthodologie d'impression utilisée ici. C'est une "boucle". Chaque fois que nous prenons l'impression d'un tableau via une boucle, cela conduit également à la rupture du tableau en mots séparés sur Newlines.

Pour le mot dans $ a
Faire
Echo $ mot
fait

Nous allons maintenant prendre l'impression de la commande d'un fichier.

Conclusion

Il existe plusieurs façons d'aligner vos données de tableau sur les lignes alternatives au lieu de l'afficher sur une seule ligne. Vous pouvez utiliser l'une des options données dans vos codes pour les rendre efficaces.