Arrays in Unix-Shell?

Question

Wie erstelle ich ein Array in Unix Shell Scripting?

Answer 1

Sie der folgenden Art versuchen:

#!/bin/bash 
declare -a arr 

i=0 
j=0 

    for dir in $(find /home/rmajeti/programs -type d) 
    do 
     arr[i]=$dir 
     i=$((i+1)) 
    done 


    while [ $j -lt $i ] 
    do 
     echo ${arr[$j]} 
     j=$((j+1)) 
    done 

Answer 2

#!/bin/bash 

# define a array, space to separate every item 
foo=(foo1 foo2) 

# access 
echo ${foo[1]} 

# add or changes 
foo[0]=bar 
foo[2]=cat 
foo[1000]=also_OK 

Sie können die ABS "Advanced Bash-Scripting Guide" lesen

Answer 3

in bash, erstellen Sie Array wie folgt

arr=(one two three) 

die Elemente

aufrufen

$ echo ${arr[0]} 
one 
$ echo ${arr[2]} 
three 

für Benutzereingaben zu fragen, können Sie lesen

read -p "Enter your choice: " choice 

ist das, was Sie fordern.?

Answer 4

Die Bourne-Shell und C-Shell haben keine Arrays, IIRC.

Zusätzlich haben, was andere gesagt, in Bash Sie die Anzahl der Elemente in einem Array erhalten können wie folgt:

elements=${#arrayname[@]} 

und sie in Scheiben schneiden Stil Operationen:

arrayname=(apple banana cherry) 
echo ${arrayname[@]:1}     # yields "banana cherry" 
echo ${arrayname[@]: -1}     # yields "cherry" 
echo ${arrayname[${#arrayname[@]}-1]} # yields "cherry" 
echo ${arrayname[@]:0:2}     # yields "apple banana" 
echo ${arrayname[@]:1:1}     # yields "banana" 

Answer 5

In KSH Sie tun es:

set -A array element1 element2 elementn 

# view the first element 
echo ${array[0]} 

# Amount elements (You have to substitute 1) 
echo ${#array[*]} 

# show last element 
echo ${array[ $((${#array[*]} - 1)) ]} 

Answer 6

Try this:

echo "Find the Largest Number and Smallest Number of a given number" 
echo "---------------------------------------------------------------------------------" 
echo "Enter the number" 
read n 

while [ $n -gt 0 ] #For Seperating digits and Stored into array "x" 
do 
     x[$i]=`expr $n % 10` 
     n=`expr $n/10` 
done 

echo "Array values ${x[@]}" # For displaying array elements 


len=${#x[*]} # it returns the array length 


for ((i=0; i<len; i++)) # For Sorting array elements using Bubble sort 
do 
    for ((j=i+1; j<len; j++)) 
    do 
     if [ `echo "${x[$i]} > ${x[$j]}"|bc` ] 
     then 
       t=${x[$i]} 
       t=${x[$i]} 
       x[$i]=${x[$j]} 
       x[$j]=$t 
     fi 
     done 
done 


echo "Array values ${x[*]}" # Displaying of Sorted Array 


for ((i=len-1; i>=0; i--)) # Form largest number 
do 
    a=`echo $a \* 10 + ${x[$i]}|bc` 
done 

echo "Largest Number is : $a" 

l=$a #Largest number 

s=0 
while [ $a -gt 0 ] # Reversing of number, We get Smallest number 
do 
     r=`expr $a % 10` 
     s=`echo "$s * 10 + $r"|bc` 
     a=`expr $a/10` 
done 
echo "Smallest Number is : $s" #Smallest Number 

echo "Difference between Largest number and Smallest number" 
echo "==========================================" 
Diff=`expr $l - $s` 
echo "Result is : $Diff" 


echo "If you try it, We can get it" 

Answer 7

Bourne-Shell unterstützt keine Arrays. Es gibt jedoch zwei Möglichkeiten, das Problem zu behandeln.

Verwenden Positions Shell Parameter $ 1, $ 2, etc .:

$ set one two three 
$ echo $* 
one two three 
$ echo $# 
3 
$ echo $2 
two 

Verwenden variable Auswertungen:

$ n=1 ; eval a$n="one" 
$ n=2 ; eval a$n="two" 
$ n=3 ; eval a$n="three" 
$ n=2 
$ eval echo \$a$n 
two 

Answer 8

Um die Werte von keybord zu lesen und Einsatzelement in Array

# enter 0 when exit the insert element 
echo "Enter the numbers" 
read n 
while [ $n -ne 0 ] 
do 
    x[$i]=`expr $n` 
    read n 
    let i++ 
done 

#display the all array elements 
echo "Array values ${x[@]}" 
echo "Array values ${x[*]}" 

# To find the array length 
length=${#x[*]} 
echo $length 

Answer 9

Der folgende Code erstellt und druckt ein Array von Zeichenfolgen in der Shell:

#!/bin/bash 
array=("A" "B" "ElementC" "ElementE") 
for element in ${array[@]} 
do 
    echo $element 
done 

echo "" 
echo "Nbr of elements:" ${#array[@]} 

echo "" 
echo ${array[@]} 

Ergebnis:

A 
B 
ElementC 
ElementE 

Nbr of elements: 4 

A B ElementC ElementE 

Answer 10

Wenn Sie für Räume eine Schlüsselwertspeicher mit Unterstützung wollen benutzen Sie den -A Parameter:

declare -A programCollection 
programCollection["xwininfo"]="to aquire information about the target window." 

for program in ${!programCollection[@]} 
do 
    echo "The program ${program} is used ${programCollection[${program}]}" 
done 

http://linux.die.net/man/1/bash „Assoziative Arrays erstellt -A Namen deklarieren. "

Answer 11

Ein Array kann in zwei Tagen geladen werden.

set -A TEST_ARRAY alpha beta gamma 

oder

X=0 # Initialize counter to zero. 

- Legen Sie das Array mit den Strings von Alpha-, Beta- und Gamma-

for ELEMENT in alpha gamma beta 
do 
    TEST_ARRAY[$X]=$ELEMENT 
    ((X = X + 1)) 
done 

Außerdem glaube ich folgenden Informationen helfen können:

Die Shell unterstützt eindimensionale Arrays. Die maximale Anzahl der Array-Elemente beträgt 1.024. Wenn ein Array definiert ist, wird es automatisch auf 1.024 Elemente dimensioniert. Ein eindimensionales Array enthält eine Sequenz von Array-Elementen, die wie die auf einer Bahngleis verbundenen Boxcars miteinander verbunden sind.

Falls Sie das Array zuzugreifen:

echo ${MY_ARRAY[2] # Show the third array element 
gamma 


echo ${MY_ARRAY[*] # Show all array elements 
- alpha beta gamma 


echo ${MY_ARRAY[@] # Show all array elements 
- alpha beta gamma 


echo ${#MY_ARRAY[*]} # Show the total number of array elements 
- 3 


echo ${#MY_ARRAY[@]} # Show the total number of array elements 
- 3 

echo ${MY_ARRAY} # Show array element 0 (the first element) 
- alpha 

Answer 12

Ihre Frage bezieht "Unix-Shell-Scripting", ist aber bash markiert. Das sind zwei verschiedene Antworten.

Die POSIX-Spezifikation für Shells hat nichts über Arrays zu sagen, da die ursprüngliche Bourne-Shell sie nicht unterstützt hat. Selbst heute, unter FreeBSD, Ubuntu Linux und vielen anderen Systemen, hat /bin/sh keine Array-Unterstützung. Wenn Sie also Ihr Skript in verschiedenen Bourne-kompatiblen Shells verwenden möchten, sollten Sie sie nicht verwenden. Alternativ, wenn Sie eine bestimmte Shell annehmen, stellen Sie sicher, dass Sie den vollständigen Namen in die Shebang-Zeile eingeben, z. #!/usr/bin/env bash.

myArray=(first "second element" 3rd) 

und Zugangselemente wie diese können

$ echo "${myArray[1]}" 
second element 

Sie alle erhalten:

Wenn Sie bash oder zsh oder eine moderne Version von ksh verwenden, können Sie ein Array wie folgt erstellen die Elemente über "${myArray[@]}". Sie können die Slice-Notation $ {array [@]: start: length} verwenden, um den Teil des Arrays, auf den verwiesen wird, z. "${myArray[@]:1}", um das erste Element zu verlassen.

Die Länge des Arrays ist ${#myArray[@]}. Sie können ein neues Array mit allen Indizes aus einem vorhandenen Array mit "${!myArray[@]}" erhalten.

Ältere Versionen von ksh vor ksh93 hatten auch Arrays, aber nicht die Klammer-basierte Notation, noch unterstützten sie Slicing. Sie könnten jedoch ein Array wie folgt erstellen:

set -A myArray -- first "second element" 3rd