Что делает, “в то время как тестовые $ #-gt 0” делают?

Запустите следующий скрипт, чтобы понять, что означают переменные. Сохраните скрипт как somescript.sh и вызовите скрипт с некоторыми входными параметрами.

#!/bin/bash
echo "I display the total parameters passed to this script from commandline"
echo $#
echo "I display all the parameter values"
echo "Input: $@"
echo "I display the first parameter value"
echo "$1"

shift 
echo "After shift: $@"

$# ==> параметры скрипта передали

test ==> команда оценки условия

-gt ==> представляет больше чем

test a -gt b ==> true если a больше чем b, false иначе

Складывая все вместе:

while test $# -gt 0 ==> пока передается больше параметров (причина изменения - сдвиг)

Что делает вещи хитрыми, так это сдвиг в теле цикла while.

$1 ==> всегда представляет собой первый параметр

Чтобы сделать это более конкретным, допустим, вы передаете параметры a, b и c.

$1 ==> представляет собой a, так как это Ваш первый параметр

, вызываемый сейчас shift, a больше нет, и ваш список параметров теперь b и c, поэтому если вы выберете 1, то это будет b, так как это первый параметр в списке. При повторном вызове сдвига список параметров теперь просто c, поэтому $1 теперь является c. При повторном вызове shift список параметров остается пустым, поэтому условие while не будет успешно выполнено (так как список параметров уже не больше 0, так как теперь он равен нулю), что приведет к завершению цикла while.

Каковы преимущества использования сдвига и обращения к текущему параметру как $1?

Это дает вам гибкость, чтобы не знать заранее в вашем скрипте, сколько параметров передается в скрипте и независимо от этого, чтобы итерация через них один за другим, ссылаясь в цикле while на текущий параметр всегда как $1, так как это означает, что заголовок списка параметров. К сдвигуing в конце концов список параметров будет пустым, поэтому важно иметь условие while, чтобы проверить, больше ли он нуля, чтобы завершить цикл и не бесконечно.

Если вы простите меня за переработку ответов, я думаю, вы найдете это полезным.

_fn() { set -- "$@" $(cat)
    while ${1+:} false ; do 
        echo "$1" && [ "$1" = "arg2" ] && echo "$1"
        $YOUR_CHK
        shift
    done
}

echo "arg2" | _fn "arg1"

OUTPUT

arg1
arg2
arg2

Это обрабатывает оба аргумента в командной строке и stdin. Он запускает цикл while только для их проверки, пока в массиве параметров сохраняется хотя бы один аргумент. Он отбрасывает каждый проверяемый аргумент, поэтому часть $YOUR_CHK должна так или иначе сохранять информацию, которую вы считаете ценной.

_fn вел бы себя так же, если бы его содержимое было телом скрипта, или как оно есть в виде функции оболочки.

_fn обрабатывает stdin - в данном случае "arg2" echo ed поверх |pipe -. в первой строке setting его позиционный параметр shell $@array ко всему, что передается в командной строке - или "$@" - и все cat выплёвывается через $(comand substitution).

, в то время как первым параметром _fn's $1 является ${set+}, мы заменяем встроенный оболочку :true на удовлетворение условия цикла , в то время как. Как только $1 не будет установлено, что замена не состоится, условие вычисляется как false и , в то время как цикл разрывается.

Для каждой итерации цикла , пока в цикле _fn() echo является его первым параметром $1 &&, если успешно (echo является всегда. successful) [ tests ] чтобы увидеть, равен ли $1 строке "arg2" &&, если [ test ] снова успешно _fn() echoes $1.

$YOUR_CHK - это null-op - это переменная unset, которая ничего не вычисляет перед тем, как оболочка выполнит какой-нибудь код.

За каждую итерацию цикла в то время как мы сдвигаем первый параметр $1. Итак, на итерации 1 "$@" выглядит так:

arg1 arg2

Но после того, как мы сдвинули в первый раз выглядит так:

arg2

А после того, как мы сдвинули в последний раз выглядит так:

Итак, мы снова возвращаемся к ${1+: } false - так как $1 теперь не установлен, оболочка не заменит :true, а вместо этого вычисляется только false, что разрывает цикл , в то время как и завершает цикл _fn().