Wyświetl argumenty powłoki w odwrotnej kolejności

Trochę utknąłem. Moim zadaniem jest wydrukowanie argumentów na skrypcie w odwrotnej kolejności, z wyjątkiem trzeciej i czwartej.

Mam ten kod:

#!/bin/bash

i=$#
for arg in "$@"
do
    case $i
    in
        3) ;;
        4) ;;
        *) eval echo "$i. Parameter: \$$i";;
    esac
    i=`expr $i - 1`
done

Ponieważ nienawidzę eval (pozdrowienia dla PHP), szukam rozwiązania bez niego, ale nie jestem w stanie go znaleźć.

Jak mogę dynamicznie zdefiniować pozycję argumentu?

PS: Nie, to nie praca domowa, uczę się muszli do egzaminu, więc staram się rozwiązywać stare egzaminy.

evaljest jedynym przenośnym sposobem na uzyskanie dostępu do parametru pozycyjnego poprzez jego dynamicznie wybraną pozycję. Skrypt byłby bardziej przejrzysty, gdybyś wyraźnie zapętlił indeks zamiast wartości (których nie używasz). Zauważ, że nie potrzebujesz, exprchyba że chcesz, aby twój skrypt działał w antycznych powłokach Bourne'a; $((…))arytmetyka jest w POSIX. Ogranicz użycie evaldo najmniejszego możliwego fragmentu; na przykład nie używaj eval echo, przypisz wartość do zmiennej tymczasowej.

i=$#
while [ "$i" -gt 0 ]; do
  if [ "$i" -ne 3 ] && [ "$i" -ne 2 ]; then
    eval "value=\${$i}"
    echo "Parameter $i is $value"
  fi
  i=$((i-1))
done

W bash można użyć ${!i}wartości parametru, którego nazwa to $i. Działa $ito, gdy jest albo nazwanym parametrem, albo liczbą (oznaczającą parametr pozycyjny). Podczas gdy możesz to zrobić, możesz skorzystać z innych funkcji wygody bash.

for ((i=$#; i>0; i--)); do
  if ((i != 3 && i != 4)); then
    echo "Parameter $i is ${!i}"
  fi
done

Trzymam skrypt reversena mojej ścieżce, który robi to:

#!/bin/sh

if [ "$#" -gt 0 ]; then
    arg=$1
    shift
    reverse "$@"
    printf '%s\n' "$arg"
fi

Przykładowe użycie:

$ reverse a b c '*' '-n'
-n
*
c
b
a

Możesz także użyć funkcji zamiast dedykowanego skryptu.

Jest to prawidłowe i niegroźne użycie eval. Masz pełną kontrolę nad tworzoną treścią eval.

Jeśli nadal sprawia ci to złe przeczucia, to jeśli nie zależy ci na przenośności, możesz użyć ${!i}składni pośredniej Basha .

Zakładając, że parametry pozycyjne nie zawierają znaków nowej linii:

[ "$#" -gt 0 ] && printf '%s\n' "$@" | #print in order
sed '3,4 d' |                          #skip 3 and 4
tac                                    #reverse (try tail -r on
                                       #non-GNU systems).

Test:

set 1 2 3 4 5 6
printf '%s\n' "$@" | 
sed '3,4 d' |
tac

Wyjście testowe:

6
5
2
1

Z zsh:

$ set a 'foo bar' c '' '*'
$ printf '<%s>\n' "${(Oa)@}"
<*>
<>
<c>
<foo bar>
<a>

Oajest flagą rozwinięcia parametru do sortowania elementów tablicy po rozwinięciu w indeksach tablicy odwrotnej .

Aby wykluczyć 3 i 4:

$ printf '<%s>\n' "${(Oa)@[5,-1]}" "${(Oa)@[1,2]}"
<*>
<foo bar>
<a>

Z praktycznie każdą powłoką:

printf '{ PS4=\${$(($#-$x))}; } 2>&3; 2>&1\n%.0s' |
x=LINENO+1 sh -sx "$@" 3>/dev/null

I nie musisz używać podpowłoki. Na przykład:

set -x a b c
{ last= PS4=\${last:=\${$#}}; set +x; } 2>/dev/null
echo "$last"

... drukuje ...

c

A oto funkcja powłoki, która może ustawić aliasdla ciebie powłokę , która wypisze argumenty do przodu lub do tyłu:

tofro() case $1 in (*[!0-9]*|'') ! :;;(*) set "$1"
        until   [ "$1" -eq "$(($#-1))" ]    &&
                shift && alias args=":; printf \
            \"%.\$((\$??\${#*}:0))s%.\$((!\$??\${#*}:0))s\n\" $* "
        do      [ "$#" -gt 1 ] &&
                set "$@ \"\${$#}\" " '"${'"$((1+$1-$#))"'}"' ||
                set "$1" '"$1" "${'"$1"'}"'
        done;   esac

Nie próbuje przechowywać wartości literałów dla żadnych argumentów, ale umieszcza taki ciąg w args alias:

:;printf    "%.$(($??${#*}:0))s%.$((!$??${#*}:0))s\n" \
            "$1" "${3}" "${2}"  "${2}" "${3}"  "${1}"

... i dlatego przechowuje tylko odniesienia do parametrów wstecz i do przodu. Będzie przechowywać do liczby podanej jako argument. Tak więc powyższe aliaszostało wygenerowane jak:

tofro 3

printfNa zachowanie ma wpływ wartość zwracana z poprzedniego polecenia - które zawsze jest :poleceniem zerowym, a więc zwykle prawdziwe. printfpominie połowę swoich argumentów przy każdym drukowaniu - co domyślnie spowoduje wydrukowanie argumentów od najmniejszej do największej. Jeśli jednak po prostu to zrobisz:

! args

... drukuje je w odwrotnej kolejności.

Ponieważ alias nie przechowuje żadnych literalnych wartości, jego wartość pozostaje statyczna, podczas gdy rzeczywiste argumenty mogą się zmieniać, ale nadal będzie odwoływać się do tylu, ile może. Na przykład:

set one two three
tofro 3
args; ! args
shift; args; ! args

... które drukuje ...

one
two
three
three
two
one
two
three


three
two

Ale resetowanie aliasu można wykonać w następujący sposób:

tofro 2
args; ! args

... i tak drukuje ...

two
three
three
two

declare -a argv=( "$@" )
for (( i=$((${#argv[@]}-1)) ; i>=0 ; i=$(($i-1)) )) ; do
        echo "${argv[$i]}"
        # use "${argv[$i]}" in here...
done