Gibt es eine Möglichkeit, Positionsargumente in bash zu vermeiden?

Den gemeinsamen Weg, das zu tun, ist die Zuordnung der Argumente zu den lokalen Variablen in der Funktion, d.h.:

copy() {
    local from=${1}
    local to=${2}

    # ...
}

Andere Lösung kann sein getopt-Stil-option parsing.

copy() {
    local arg from to
    while getopts 'f:t:' arg
    do
        case ${arg} in
            f) from=${OPTARG};;
            t) to=${OPTARG};;
            *) return 1 # illegal option
        esac
    done
}

copy -f /tmp/a -t /tmp/b

Leider bash nicht umgehen kann, lange Optionen, die würde mehr lesbar, d.h.:

copy --from /tmp/a --to /tmp/b

Dafür benötigen Sie entweder die externe getopt Programm (was ich denke hat lange option unterstützt nur auf GNU-Systemen) oder die Umsetzung des lange option-parser von hand, D. H.:

copy() {
    local from to

    while [[ ${1} ]]; do
        case "${1}" in
            --from)
                from=${2}
                shift
                ;;
            --to)
                to=${2}
                shift
                ;;
            *)
                echo "Unknown parameter: ${1}" >&2
                return 1
        esac

        if ! shift; then
            echo 'Missing parameter argument.' >&2
            return 1
        fi
    done
}

copy --from /tmp/a --to /tmp/b

Siehe auch: Verwendung von getopts in bash-shell-Skript, um long-und short-Kommandozeilen-Optionen

Können Sie auch faul sein, und einfach die 'Variablen', die als Argumente an die Funktion, also:

copy() {
    local "${@}"

    # ...
}

copy from=/tmp/a to=/tmp/b

und Sie haben ${from} und ${to} in der Funktion als lokale Variablen.

Nur beachten, dass das gleiche Problem wie unten gilt — wenn eine bestimmte variable wird nicht übergeben, es wird vererbt vom übergeordneten Umwelt. Sie können hinzufügen, ein "safety-line" wie:

copy() {
    local from to    # reset first
    local "${@}"

    # ...
}

um sicherzustellen, dass ${from} und ${to} werden gelöscht, wenn Sie nicht bestanden.

Und wenn etwas sehr schlecht von Ihrem Interesse ist, Sie könnte auch die Zuordnung der Argumente als Globale Variablen beim Aufruf der Funktion, d.h.:

from=/tmp/a to=/tmp/b copy

Dann könnte man nur verwenden ${from} und ${to} innerhalb der copy() Funktion. Beachten Sie, dass nur Sie sollte dann immer alle übergeben Parameter. Andernfalls wird eine zufällige variable kann Leck in der Funktion.

from= to=/tmp/b copy   # safe
to=/tmp/b copy         # unsafe: ${from} may be declared elsewhere

Wenn Sie die bash-4.1 (glaube ich), Sie können auch versuchen, mit assoziativen arrays. Es wird Ihnen erlauben, benannte Argumente übergeben, aber es wird hässlich. So etwas wie:

args=( [from]=/tmp/a [to]=/tmp/b )
copy args

Und dann in copy() müssten Sie schnappen Sie sich das array.

InformationsquelleAutor der Antwort Michał Górny

Shell-Funktionen haben vollen Zugriff auf alle Variablen in der aufrufenden Bereichs, außer für diejenigen Variablen-Namen, die als lokale Variablen innerhalb der Funktion selbst. Darüber hinaus werden nicht-lokale Variablen innerhalb einer Funktion verfügbar ist, auf der Außenseite nach dem die Funktion aufgerufen wurde. Betrachten Sie das folgende Beispiel:

A=aaa
B=bbb

echo "A=$A B=$B C=$C"

example() {
    echo "example(): A=$A B=$B C=$C"

    A=AAA
    local B=BBB
    C=CCC

    echo "example(): A=$A B=$B C=$C"
}

example

echo "A=$A B=$B C=$C"

Diesem snippet hat die folgende Ausgabe:

A=aaa B=bbb C=
example(): A=aaa B=bbb C=
example(): A=AAA B=BBB C=CCC
A=AAA B=bbb C=CCC

Der offensichtliche Nachteil dieses Ansatzes ist, dass die Funktionen sind nicht in sich abgeschlossen, und die Einstellung eine variable außerhalb einer Funktion kann unerwünschte Nebenwirkungen. Würde es auch machen die Dinge schwieriger, wenn Sie wollten, die zum übergeben von Daten an eine Funktion ohne Zuweisung an eine variable zuerst, da diese Funktion nicht über Parameter mehr.

Der häufigste Weg, um dies zu umgehen, ist die Verwendung lokale Variablen für Argumente und eine temporäre variable innerhalb einer Funktion:

example() {
   local A="$1" B="$2" C="$3" TMP="/tmp"

   ...
}

Dies vermeidet das verschmutzen der shell-namespace mit der Funktions-lokalen Variablen.

InformationsquelleAutor der Antwort thkala

Ich persönlich war in der Hoffnung, um zu sehen, eine Art von syntax, wie

func(a b){
    echo $a
    echo $b
}

Aber da, das ist nicht eine Sache, und ich sehe durchaus ein paar Referenzen auf Globale Variablen (nicht ohne den VORBEHALT der Festlegung des lösungsumfangs und der Benennung von Konflikten), ich werde teilen mein Ansatz.

Mithilfe der copy Funktion von Michal ' s Antwort:

copy(){
    cp $from $to
}
from=/tmp/a
to=/tmp/b
copy

Das ist schlecht, weil from und to sind solche breiten Worten, dass eine beliebige Anzahl von Funktionen kann mit dieser. Sie könnten schnell am Ende mit einem Namenskonflikt oder ein "Leck" auf Ihre Hände.

letter(){
    echo "From: $from"
    echo "To:   $to"
    echo
    echo "$1"
}

to=Emily
letter "Hello Emily, you're fired for missing two days of work."

# Result:
#   From: /tmp/a
#   To:   Emily

#   Hello Emily, you're fired for missing two days of work.

Also mein Ansatz ist es, "namespace". Ich nenne die variable nach der Funktion und löschen Sie Sie, nachdem die Funktion fertig ist. Natürlich, ich verwenden Sie nur für optionale Werte, die Standardwerte haben. Ansonsten benutze ich nur positionale Argumente.

copy(){
    if [[ $copy_from ]] && [[ $copy_to ]]; then
        cp $copy_from $copy_to
        unset copy_from copy_to
    fi
}
copy_from=/tmp/a
copy_to=/tmp/b
copy # Copies /tmp/a to /tmp/b
copy # Does nothing, as it ought to
letter "Emily, you're 'not' re-hired for the 'not' bribe ;)"
# From: (no /tmp/a here!)
# To:

# Emily, you're 'not' re-hired for the 'not' bribe ;)

Ich würde einen schrecklichen Chef...

In der Praxis, meine Funktions-Namen sind aufwändiger, als "Kopie" oder "Brief".

Jüngstes Beispiel, um mein Gedächtnis ist get_input()die gi_no_sort und gi_prompt.

• gi_no_sort ist ein true/false-Wert, der bestimmt, ob der Abschluss Vorschläge sortiert sind oder nicht. Standardmäßig auf true
• gi_prompt ist ein string, der ist...naja, das ist selbsterklärend. Defaults to "".

Die eigentlichen Argumente der Funktion sind die Quelle der oben genannten "Vollendung Vorschläge" für die input-Eingabeaufforderung, und wie gesagt, die Liste ist entnommen aus $@ in der Funktion, die "benannte Argumente" sind optional^[1]und es gibt keine offensichtliche Möglichkeit, zu unterscheiden zwischen einem string soll als ein Abschluss und ein boolean - /prompt-Nachricht, oder wirklich alles, was durch Leerzeichen getrennte in bash, für diese Angelegenheit^[2]; die oben genannte Lösung endete spart mir viel ärger.

Hinweise:

1. So eine hart codierte shift und $1$2 usw. Frage.

2. E. g. ist "0 Enter a command: {1..9} $(ls)" einen Wert von 0"Enter a command:"und eine Reihe von 1 2 3 4 5 6 7 8 9 <directory contents>? Oder sind "0""Enter""a"und "command:" Teil von diesem Satz? Die Bash übernimmt die letzteren, ob Sie es wollen oder nicht.

InformationsquelleAutor der Antwort Braden Best

Argumente zugeschickt bekommen Funktionen als ein Tupel aus einzelnen Elementen, so haben Sie keine Namen, als solche, die nur Positionen. dies ermöglicht einige interessante Möglichkeiten, wie unten, aber es bedeutet, dass Sie stecken mit $1. $2, usw. ob Karte Sie besser auf die Namen, kommt die Frage auf, wie gross die Funktion ist, und wie viel deutlicher machen wird, Lesen Sie den code. wenn seine komplexe, Kartierung aussagekräftige Namen ($BatchID, $FirstName, $SourceFilePath) ist eine gute Idee. für die einfachen Sachen aber, es ist wahrscheinlich nicht notwendig. Ich certianly würde nicht stören, wenn Sie mit Namen wie $arg1.

nun, wenn Sie wollen einfach nur echo zurück, die Parameter, Sie können Durchlaufen Sie diese:

for $arg in "$@"
do
  echo "$arg"
done

nur ein fun-fact ist, es sei denn, Sie Bearbeiten die Liste, sind Sie wahrscheinlich daran interessiert, etwas mehr nützlich

InformationsquelleAutor der Antwort Frank Thomas