Trabalhando com matrizes no Linux Shell Script - Parte 8

Não podemos imaginar uma linguagem de programação sem o conceito de matrizes. Não importa como eles são implementados entre vários idiomas. Em vez disso, as matrizes nos ajudam a consolidar dados, semelhantes ou diferentes, sob um nome simbólico.

Aqui, como estamos preocupados com scripts de shell, este artigo o ajudará a brincar com alguns scripts de shell que fazem uso desse conceito de matrizes.

Inicialização e uso da matriz

Com versões mais recentes do Bash, ele suporta matrizes unidimensionais. Uma matriz pode ser explicitamente declarada pelo declarar Builtina de concha.

declarar -a var 

Mas não é necessário declarar variáveis ​​de matriz como acima. Podemos inserir elementos individuais para combinar diretamente da seguinte maneira.

var [xx] = 

onde 'xx' indica o índice de matriz. Para desreferenciar os elementos da matriz, use a sintaxe do suporte encaracolado, eu.e.

$ var [xx] 

Observação: A indexação de matriz sempre começa com 0.

Outra maneira conveniente de inicializar uma matriz inteira é usando o par de parênteses, como mostrado abaixo.

var = (elemento1 elemento2 elemento3… elementn) 

Há ainda outra maneira de atribuir valores às matrizes. Essa maneira de inicialização é uma subcategoria do método explicado anteriormente.

Array = ([xx] = [xx] =…) 

Também podemos ler/atribuir valores para matriz durante o tempo de execução usando o ler Builtina de concha.

Leia -uma matriz 

Agora, ao executar a declaração acima dentro de um script, ele aguarda alguma entrada. Precisamos fornecer os elementos da matriz separados pelo espaço (e não de retorno do carro). Depois de inserir os valores, pressione Enter para terminar.

Para atravessar os elementos da matriz que também podemos usar para loop.

para i em “$ Array [@]” faça #acessar cada elemento como $ i… feito 

O script a seguir resume o conteúdo desta seção específica.

#!/BIN/BASH Array1 [0] = One Array1 [1] = 1 echo $ Array1 [0] echo $ Array1 [1] Array2 = (um dois) echo $ Array2 [0] Echo $  Array2 [2] Array3 = ([9] = nove [11] = 11) echo $ Array3 [9] echo $ Array3 [11] Read -a Array4 para i em "$ Array4 [@] "Do eco $ eu saí de sair 0 

Várias operações em matrizes

Muitas das operações de string padrão funcionam em matrizes . Veja o script de amostra a seguir que implementa algumas operações nas matrizes (incluindo operações de string).

#!/Bin/Bash Array = (sapo de elefante de gato de gato Apple) #Print Primeiro elemento echo $ Array [0] echo $ Array: 0 #Display Todos os elementos echo $ Array [@] echo $ Array [ @]: 0 #Display Todos os elementos, exceto o primeiro eco $ Array [@]: 1 #Display Elements em um intervalo de eco $ Array [@]: 1: 4 #Length of First Element echo $  # #Array [0] echo $ #Array #Number of Elements Echo $ #Array [*] echo $ #Array [@] #Replacing Substring echo $ Array [@] // A/A Exit 0 

A seguir, a saída produzida na execução do script acima.

maçã maçã maçã gato gato cachorro elefante sapo maçã gato gato cachorro elefante sapo morcego gato cachorro elefante sapo morcego gato cão elefante 5 5 6 6 maçã gato gato gato de gato elefante sapo 

Eu acho que não há significado em explicar o script acima em detalhes, pois é auto-explicativo. Se necessário, dedicarei uma parte desta série exclusivamente em manipulações de string.

Substituição de comando com matrizes

A substituição de comando atribui a saída de um comando ou vários comandos em outro contexto. Aqui neste contexto de matrizes, podemos inserir a saída de comandos como elementos individuais de matrizes. A sintaxe é a seguinte.

Array = ($ (comando)) 

Por padrão, o conteúdo na saída do comando separado por espaços brancos é conectado à matriz como elementos individuais. O script a seguir listam o conteúdo de um diretório, que são arquivos com 755 permissões.

#!/bin/bash err = 27 ext = 0 se [$# -ne 1]; Então eco "uso: $ 0", saia $ err fi se [ ! -d $ 1]; Então eco "diretório $ 1 não existe" Exit $ err fi temp = ($ (encontre $ 1 -MaxDepth 1 -Type F)) para i em "$ temp [@]" do per = $ (ls -l $ $ i) se ['expr $ perm: 0: 10: "-rwxr-xr-x"' -eq 10]; Então echo $ i ##*/ fi feito saída $ ext 

Simulando matrizes bidimensionais

Podemos representar facilmente uma matriz bidimensional usando uma matriz 1-dimensional. Em Linha de ordem principal Os elementos de representação em cada linha de uma matriz são progressivamente armazenados em índices de matriz de maneira seqüencial. Para uma matriz MXN, a fórmula para o mesmo pode ser escrita como.

matriz [i] [j] = Array [n*i+j] 

Veja outro script de amostra para adicionar 2 matrizes e imprimir a matriz resultante.

#!/bin/bash leia -p "Digite a ordem da matriz [mxn]:" t m = $ t: 0: 1 n = $ t: 2: 1 echo "Digite os elementos para a primeira matriz" para i em ' seq 0 $ (($ M-1)) 'faça para j em' seq 0 $ (($ n-1) '', leia x [$ (($ n*$ i+$ j)] feito eco feito " Digite os elementos da segunda matriz "para i em 'seq 0 $ (($ m-1))' faça para j em 'seq 0 $ (($ n-1)' ', leia y [$ (($ n* $ i+$ j))] z [$ (($ n*$ i+$ j))] = $ (($ x [$ (($ n*$ i+$ j))]+$ y [$ (($ n*$ i+$ J))])) MATRIXA ECHO "APÓS A adição é" para i em 'seq 0 $ (($ m-1))' faça para j em 'seq 0 $ (( $ n -1)) 'do echo -ne "$ z [$ (($ n*$ i+$ j)]] \ t" feito echo -e "\ n" saia saia 0 

Embora haja limitações para implementar matrizes dentro do script de shell, ela se torna útil em algumas situações, especialmente quando lidamos com a substituição de comando. Olhando do ponto de vista administrativo, o conceito de matrizes abriu o caminho para o desenvolvimento de muitos scripts de fundo em sistemas GNU/Linux.