As conchas Unix (como Bash, Zsh, SH) não têm matrizes da mesma maneira que idiomas de nível superior como Python ou C ++. Eles lidam com as matrizes de uma maneira menos estruturada, normalmente usando strings separados por espaço em branco ou técnicas especiais. Veja como você pode trabalhar com estruturas semelhantes a matrizes em diferentes contextos do Unix Shell:

1. Strings separados por espaço em branco:

Este é o método mais simples. Você armazena essencialmente elementos como uma única string, separada por espaços (ou outros delimitadores que escolher). O acesso a elementos individuais requer manipulação de string.

`` `BASH
my_array ="Apple Banana Cherry"

Acessando o primeiro elemento (assumindo a separação de espaço):

primeiro_element ="$ {my_array %% *}" #Removes tudo a partir do primeiro espaço em diante.
eco "$ primeiro_element" # saída:maçã

Acessando o segundo elemento:

Second_Element ="$ {my_array #*}" #Remove tudo até o primeiro espaço.
Second_Element ="$ {Second_Element %% *}" #Removes tudo a partir do primeiro espaço em diante
eco "$ second_element" # saída:banana

#Iterating (menos eficiente):
Para frutas em $ my_array; fazer
eco "$ fruit"
feito
`` `

Limitações: Essa abordagem é propensa a erros se os elementos da matriz contêm espaços.


2. Usando matrizes em Bash (e outras conchas com suporte de matriz):

Bash (e algumas outras conchas modernas) fornecem suporte de matriz mais robusto.

`` `BASH

Declare uma matriz

my_array =("Apple" "Banana" "Cherry")

Acessando elementos:

eco "$ {my_array [0]}" # saída:maçã
eco "$ {my_array [1]}" # saída:banana

Obtendo o comprimento da matriz:

echo "$ { # my_array [@]}" # saída:3

iterando:

para i em "$ {! my_array [@]}"; Faça #itere através dos índices
eco "$ {my_array [i]}"
feito

ou iterar diretamente através de elementos:

para frutas em "$ {my_array [@]}"; fazer
eco "$ fruit"
feito

#Elementos de adição:
my_array+=("date")
echo "$ {my_array [3]}" #output:data

#Apinging to Array:
my_array+=(uva laranja)

#Removing Elements (menos direto, requer mudança):
Unset 'my_array [1]' #Removes elemento no índice 1 (banana)
#Note que os índices não descem automaticamente. Não há mudança interna após a exclusão.

Imprima a matriz modificada:

para frutas em "$ {my_array [@]}"; fazer
eco "$ fruit"
feito


`` `

Considerações importantes:

* citando: Sempre as variáveis ​​de matriz de citações (por exemplo, `" $ {my_array [@]} "`) para impedir a divisão e o globo de palavras, o que pode levar a um comportamento inesperado. Isso é especialmente crítico quando os elementos da matriz podem conter espaços ou caracteres especiais.
* ÍNDICE 0: As matrizes em Bash são indexadas em 0, o que significa que o primeiro elemento está no índice 0.
* específico da concha: A sintaxe e os recursos disponíveis para matrizes podem variar um pouco, dependendo do shell específico que você está usando (Bash, Zsh, Ksh, etc.).


3. Usando ferramentas de linha de comando para operações semelhantes a matrizes:

Para manipulações de matriz mais complexas (classificação, filtragem etc.), você geralmente achará mais eficiente usar utilitários de linha de comando externos como `awk`,` sed` ou `sort`. Essas ferramentas se destacam no processamento de texto, que podem ser adaptadas para trabalhar com dados estruturados como seqüências delimitadas.

Por exemplo, para classificar os elementos de uma string de se separou de espaço em branco:


`` `BASH
my_array ="Apple Banana Cherry"
eco "$ my_array" | tr '' '\ n' | classificar | tr '\ n' ''
`` `


Em resumo, embora as conchas Unix não tenham estruturas de matriz ricas e embutidas, como outros idiomas, o suporte da matriz do Bash é adequado para muitas tarefas. Para manipulações complexas, considere aproveitar o poder dos utilitários de processamento de texto. Lembre -se de sempre citar suas variáveis ​​de matriz corretamente para evitar possíveis erros.