Я хочу, чтобы с помощью моего сценария оболочки вызывались длинные и короткие формы параметров командной строки.
Я знаю, что getopts
это можно использовать, но, как и в Perl, я не смог сделать то же самое с shell.
Любые идеи о том, как это можно сделать, чтобы я мог использовать такие параметры, как:
./shell.sh --copyfile abc.pl /tmp/
./shell.sh -c abc.pl /tmp/
Выше обе команды означают одно и то же для моей оболочки, но, используя getopts
, я не смог реализовать их?
bash
command-line-arguments
getopt
getopts
gagneet
источник
источник
Ответы:
Есть три реализации, которые можно рассмотреть:
Баш встроен
getopts
. Это не поддерживает длинные имена параметров с префиксом двойной тире. Он поддерживает только односимвольные параметры.Реализация BSD UNIX отдельной
getopt
команды (именно это использует MacOS). Это также не поддерживает длинные опции.GNU реализация автономная
getopt
. GNUgetopt(3)
(используется командной строкойgetopt(1)
в Linux) поддерживает парсинг длинных опций.Некоторые другие ответы показывают решение для использования встроенной команды bash
getopts
для имитации длинных опций. Это решение фактически делает короткую опцию, чей символ "-". Таким образом, вы получаете «-» в качестве флага. Затем все, что следует за этим, становится OPTARG, и вы проверяете OPTARG с вложеннымcase
.Это умно, но с оговорками:
getopts
не может применить опцию спецификации Он не может возвращать ошибки, если пользователь указывает неверную опцию. Вы должны сделать свою собственную проверку ошибок, когда вы анализируете OPTARG.Поэтому, хотя можно написать больше кода, чтобы обойти отсутствие поддержки длинных опций, это намного больше работы и частично сводит на нет цель использования парсера getopt для упрощения вашего кода.
источник
getopt
иgetopts
это разные звери, и люди, кажется, немного не понимают, что они делают.getopts
является встроенной командой дляbash
обработки параметров командной строки в цикле и назначения каждой найденной опции и значения по очереди встроенным переменным, чтобы вы могли в дальнейшем обрабатывать их.getopt
однако это внешняя служебная программа, которая фактически не обрабатывает ваши параметры так , как это делают , например, bashgetopts
,Getopt
модуль Perl или модули Pythonoptparse
/argparse
. Все, чтоgetopt
делает, - это канонизирует передаваемые параметры - т.е. преобразует их в более стандартную форму, чтобы сценарию оболочки было проще их обрабатывать. Например, приложениеgetopt
может преобразовать следующее:в это:
Вы должны сделать фактическую обработку самостоятельно. Вам вообще не нужно использовать,
getopt
если вы накладываете различные ограничения на способ задания опций:-o
выше) значение должно идти в качестве отдельного аргумента (после пробела).Почему использовать
getopt
вместоgetopts
? Основная причина в том, что только GNUgetopt
предоставляет вам поддержку параметров командной строки с длинными именами. 1 (GNUgetopt
является по умолчанию в Linux. Mac OS X и FreeBSD поставляются с базовой и не очень полезнойgetopt
, но можно установить версию GNU; см. Ниже.)Например, вот пример использования GNU
getopt
из моего скрипта под названиемjavawrap
:Это позволяет вам указать параметры, подобные
--verbose -dm4096 --minh=20 --maxhe 40 --debugfi="/Users/John Johnson/debug.txt"
или похожие. Эффект от вызоваgetopt
состоит в том, чтобы канонизировать параметры, чтобы--verbose -d -m 4096 --minheap 20 --maxheap 40 --debugfile "/Users/John Johnson/debug.txt"
вам было легче обрабатывать их. Квотирования вокруг"$1"
и"$2"
имеет важное значение , поскольку это гарантирует , что аргументы с пробелами в них получить обрабатываются должным образом.Если вы удалите первые 9 строк (все через
eval set
строку), код все равно будет работать ! Однако ваш код будет более разборчивым в отношении того, какие варианты он принимает: в частности, вам придется указать все параметры в «канонической» форме, описанной выше. С помощьюgetopt
, однако, вы можете группировать однобуквенные опции, использовать более короткие не двусмысленные формы длинных опций, использовать либо стиль--file foo.txt
или--file=foo.txt
, либо использовать стиль-m 4096
или-m4096
, смешивать опции и не-опции в любом порядке и т. Д.getopt
также выводит сообщение об ошибке, если найдены нераспознанные или неоднозначные параметры.ПРИМЕЧАНИЕ . На самом деле существуют две совершенно разные версии
getopt
, базоваяgetopt
и GNUgetopt
, с разными функциями и разными соглашениями о вызовах. 2 Basic неgetopt
работает: он не только не обрабатывает длинные опции, но и не может даже обрабатывать встроенные пробелы внутри аргументов или пустых аргументов, тогда какgetopts
делает это правильно. Приведенный выше код не будет работать в основномgetopt
. GNUgetopt
по умолчанию устанавливается в Linux, но в Mac OS X и FreeBSD его нужно устанавливать отдельно. В Mac OS X установите MacPorts ( http://www.macports.org ), а затем выполнитеsudo port install getopt
установку GNUgetopt
(обычно в/opt/local/bin
) и убедитесь, что/opt/local/bin
путь к вашей оболочке впереди/usr/bin
, На FreeBSD установитеmisc/getopt
.Краткое руководство по изменению примера кода для вашей собственной программы: из первых нескольких строк все является «образцом», который должен оставаться неизменным, кроме строки, которая вызывает
getopt
. Вы должны изменить имя программы после-n
, указать короткие опции после-o
и длинные опции после--long
. Поставьте двоеточие после параметров, которые принимают значение.Наконец, если вы видите код, который имеет только
set
вместоeval set
, он был написан для BSDgetopt
. Вы должны изменить его, чтобы использоватьeval set
стиль, который отлично работает с обеими версиямиgetopt
, в то время как обычныйset
не работает с GNUgetopt
.1 На самом деле,
getopts
inksh93
поддерживает параметры с длинными именами, но эта оболочка используется не так часто, какbash
. Вzsh
, используйте,zparseopts
чтобы получить эту функциональность.2 Технически, «GNU
getopt
» является неправильным; эта версия была написана для Linux, а не для проекта GNU. Однако он следует всем соглашениям GNU, и термин «GNUgetopt
» обычно используется (например, во FreeBSD).источник
getopt
в Linux это не утилита GNU, а традиционнаяgetopt
изначально не из BSD, а из AT & T Unix. ksh93getopts
(также из AT & T) поддерживает длинные опции в стиле GNU.POSIXLY_CORRECT
), в то время как «Getopt с расширенными возможностями Linux» ошибочно предполагает, что эта версия существует только на Linux.getopt
может быть легко перенесен на другие Unices, но многие другие программы дляutil-linux
Linux специфичны для Linux). Все не-GNU программы, использующие GNU getopt (3), понимают$POSIX_CORRECT
. Например, вы бы не сказали, чтоaplay
GNU именно по этим причинам. Я подозреваю, что когда FreeBSD упоминает GNU getopt, они имеют в виду GNU getopt (3) C API.getopt
util, а не на getopt (3).Встроенную функцию Bash getopts можно использовать для анализа длинных опций, поместив символ тире, за которым следует двоеточие, в optspec:
После копирования в исполняемый файл name =
getopts_test.sh
в текущем рабочем каталоге , можно произвести выводОчевидно, что getopts не выполняет ни
OPTERR
проверку, ни разбор аргументов для длинных опций. Приведенный выше фрагмент скрипта показывает, как это можно сделать вручную. Основной принцип также работает в оболочке Debian Almquist («тире»). Обратите внимание на особый случай:Обратите внимание, что, как указывает GreyCat из http://mywiki.wooledge.org/BashFAQ , этот прием использует нестандартное поведение оболочки, которое допускает аргумент option (то есть имя файла в «-f filename») быть присоединенным к опции (как в "-ffilename"). Стандарт POSIX гласит, что между ними должен быть пробел, который в случае «- longoption» завершит разбор параметров и превратит все longoptions в аргументы, не являющиеся параметрами.
источник
!
вval="${!OPTIND}
?getopts
автоматически увеличивается толькоOPTIND
на 1, но в нашем случае нам нужно увеличить его на 2, поэтому мы увеличиваем его на 1 вручную, а затемgetopts
автоматически увеличиваем на 1 для нас.$
необходимости.OPTIND=$(( $OPTIND + 1 ))
может быть простоOPTIND=$(( OPTIND + 1 ))
. Еще более интересно то, что вы даже можете назначать и увеличивать переменные внутри арифметического выражения, так что можно сокращать его дальше: $(( ++OPTIND ))
или даже(( ++OPTIND ))
принимать во внимание, что оно++OPTIND
всегда будет положительным, так что это не приведет к отключению запуска оболочки с-e
параметром. :-) gnu.org/software/bash/manual/html_node/Shell-Arithmetic.html--very-bad
дает предупреждение?Встроенная
getopts
команда по-прежнему, AFAIK, ограничена только односимвольными параметрами.Существует (или раньше) внешняя программа
getopt
, которая реорганизовала бы набор параметров, чтобы было легче анализировать. Вы можете адаптировать этот дизайн для обработки длинных вариантов тоже. Пример использования:Вы можете использовать аналогичную схему с
getoptlong
командой.Обратите внимание, что основным недостатком внешней
getopt
программы является сложность обработки аргументов с пробелами в них и точного их сохранения. Вот почему встроенныйgetopts
модуль лучше, хотя и ограничен тем, что обрабатывает только однобуквенные опции.источник
eval set
с кавычками (см. Мой ответ ниже), чтобы он также корректно работал с GNU getopt (по умолчанию в Linux) и правильно обрабатывал пробелы.${1+"$@"}
странно и расходитесь с тем, что необходимо в современных оболочках, особенно с любой оболочкой, которую вы найдете в Linux. См. Использование $ 1: + "$ @"} в / bin / sh для обсуждение этого обозначения.)eval set
что правильно поступает как с GNU, так и с BSDgetopt
, в то время как plainset
делает правильно только с BSDgetopt
. Таким образом, вы также можете использовать его,eval set
чтобы побудить людей привыкнуть к этому. Кстати, я не поняла, что${1+"$@"}
это больше не нужно. Я должен написать вещи, которые работают как на Mac OS X, так и на Linux - между ними они создают большую переносимость. Я только что проверил и"$@"
действительно делать правильные вещи на всехsh
,bash
,ksh
иzsh
под Mac OS X; конечно под Linux тоже.Вот пример, который на самом деле использует getopt с длинными параметрами:
источник
eval set
с кавычками (см. Мой ответ ниже), чтобы он также корректно работал с GNU getopt (по умолчанию в Linux) и правильно обрабатывал пробелы.getopt
то время как вопрос о том,getopts
хотя.(--
,(-*
и(*
действительные модели? Чем они отличаются от--
,-*
а*
?(--)
идентичен--)
вcase
строфе. Странно видеть неравномерное отступление и непоследовательное использование этих необязательных начальных скобок, но текущий код ответа выглядит для меня верным.Длинные опции могут быть проанализированы стандартной
getopts
встроенной функцией как «аргументы» для-
«опции»Это переносная и нативная оболочка POSIX - никаких внешних программ или ошибок не требуется.
Это руководство реализует длинные опции в качестве аргументов для
-
опции, поэтому--alpha
рассматриваетсяgetopts
как-
с аргументомalpha
и--bravo=foo
как-
с аргументомbravo=foo
. Истинный аргумент может быть собран с помощью простой замены:${OPTARG#*=}
.В этом примере
-b
и-c
(и их длинные формы,--bravo
и--charlie
) имеют обязательные аргументы. Аргументы в пользу длинных опций приводятся после знаков равенства, например--bravo=foo
(разделители пробелов для длинных опций будет трудно реализовать, см. Ниже).Поскольку в нем используется
getopts
встроенная функция , это решение поддерживает использование, подобноеcmd --bravo=foo -ac FILE
(которое объединяет параметры-a
и-c
чередует длинные параметры со стандартными параметрами), в то время как большинство других ответов здесь либо борются, либо не выполняют этого.Когда опция - тире (
-
), это длинная опция.getopts
проанализирует фактическую длинную опцию$OPTARG
, например,--bravo=foo
исходные наборыOPT='-'
иOPTARG='bravo=foo'
. Вif
строфе задается$OPT
содержимое$OPTARG
перед первым знаком равенства (bravo
в нашем примере), а затем удаляется его с начала$OPTARG
(с результатом=foo
на этом шаге или пустой строкой, если ее нет=
). Наконец, мы лишаем аргумент ведущих=
. На данный момент,$OPT
это либо короткая опция (один символ), либо длинная опция (2+ символа).case
То соответствует либо коротким или длинным вариантам. Для коротких опцийgetopts
автоматически жалуется на опции и пропущенные аргументы, поэтому мы должны скопировать их вручную, используяneeds_arg
функцию, которая неизбежно завершается, когда$OPTARG
пуста.??*
Состояние будет соответствовать любому оставшемуся длинному варианту (?
соответствует одному символу и*
соответствует нулю или больше, так что??*
соответствует 2+ символов), что позволяет нам выдавать сообщение об ошибке «Illegal варианта» перед выходом.(Примечание об именах переменных в верхнем регистре: обычно советуем резервировать все переменные в верхнем регистре для системного использования. Я сохраняю их
$OPT
в верхнем регистре, чтобы они соответствовали$OPTARG
, но это нарушает это соглашение. Я думаю, это подходит, потому что это то, что система должна была сделать, и это должно быть безопасно, потому что нет стандартов (afaik), которые используют такую переменную.)Чтобы жаловаться на неожиданные аргументы длинных опций, подражайте тому, что мы сделали для обязательных аргументов: используйте вспомогательную функцию. Просто переверните тест, чтобы пожаловаться на аргумент, когда он не ожидается:
В более старой версии этого ответа была попытка принять длинные варианты с аргументами, разделенными пробелом, но это было ненадежно;
getopts
может преждевременно прекратить работу, если предположить, что аргумент выходит за рамки его действия, и приращение вручную$OPTIND
не работает во всех оболочках.Это будет достигнуто с помощью одного из этих методов:
eval "bravo=\"\$$OPTIND\""
bravo="${!OPTIND}"
P
Zsh :bravo="${(P)OPTIND}"
а затем заключил с чем-то вроде
[ $# -gt $OPTIND ] && OPTIND=$((OPTIND+1))
источник
letter-c
нуждается в аргументах, не будет ли его достаточно использоватьletter-c)
?*
кажется излишним.getopts
останавливается на первом позиционном аргументе, поскольку он не предназначен для работы с ними. Это позволяет суб-команде со своими аргументами, напримерgit diff --color
, таким образом , я бы интерпретироватьcommand --foo=moo bar --baz waz
как имеющие в--foo
качестве аргументаcommand
и в--baz waz
качестве аргумента (с опцией) кbar
югу от команды. Это можно сделать с помощью приведенного выше кода. Я отвергаю,--bravo -blah
потому что--bravo
требует аргумента, и неясно, что-blah
это не другой вариант.eval
в оболочке POSIX, оно перечислено ниже остальной части ответа.Взгляните на shFlags, который является переносимой библиотекой оболочки (то есть sh, bash, dash, ksh, zsh в Linux, Solaris и т. Д.).
Это делает добавление новых флагов таким же простым, как добавление одной строки в ваш скрипт, и предоставляет автоматически сгенерированную функцию использования.
Вот простое
Hello, world!
использование shFlag :Для ОС, которые имеют расширенный getopt, который поддерживает длинные опции (например, Linux), вы можете сделать:
В остальном вы должны использовать короткий вариант:
Добавить новый флаг так же просто, как добавить новый
DEFINE_ call
.источник
Использование
getopts
с короткими / длинными опциями и аргументамиРаботает со всеми комбинациями, например:
Некоторые объявления для этого примера
Как будет выглядеть функция использования
getops
с длинными / короткими флагами, а также длинными аргументамиВывод
Объединяя вышесказанное в единый сценарий
источник
eval
подходом для разнесенных аргументов на длинных опциях и нашел его ненадежным для определенных оболочек (хотя я ожидаю, что он будет работать с bash, и в этом случае вам не придется использоватьeval
). См. Мой ответ о том, как принимать аргументы длинных опций,=
и мои отмеченные попытки использования пробела. Мое решение не делает внешние вызовы, в то время как это используетcut
несколько раз.Другой путь...
источник
$args
переназначении? Это может быть сделано даже без ошибок, но этот код будет терять пробелы в опциях и аргументах (я не думаю, что$delim
трюк сработает). Вместо этого вы можете запуститьset
внутри вfor
цикле , если вы достаточно внимательны , чтобы очистить его только на первой итерации. Вот более безопасная версия без башизмов.Я вроде решил так:
Я тупой или что-то?
getopt
иgetopts
так запутанно.источник
-ltr
или-lt -r
так же-l -t -r
). Кроме того, он обеспечивает некоторую обработку ошибок и простой способ сдвинуть обработанные параметры после завершения обработки опций.Если вам не нужна
getopt
зависимость, вы можете сделать это:Конечно, тогда вы не можете использовать длинные опции стиля с одной чертой. И если вы хотите добавить сокращенные версии (например, --verbos вместо --verbose), то вам нужно добавить их вручную.
Но если вы хотите получить
getopts
функциональность вместе с длинными опциями, это простой способ сделать это.Я также положил этот фрагмент в суть .
источник
--)
кажется,shift ;
пропал без вести. На данный момент--
он останется первым аргументом без опций.--
опция должна бытьshift
там. Я говорю , что это лучше , потому что альтернативы либо платформы зависимые версииgetopt
илиgetopts_long
или вы должны заставить короткие варианты , которые будут использоваться только в начале команды (то есть - вы используетеgetopts
затем обрабатывать длинные опции впоследствии), в то время как это дает какой - либо заказ и полный контроль.Встроенный
getopts
не может этого сделать. Существует внешняя программа getopt (1), которая может сделать это, но вы можете получить ее только в Linux из пакета util-linux . Он поставляется с примером скрипта getopt-parse.bash .Существует также
getopts_long
написано как функция оболочки.источник
getopt
был включен в FreeBSD версии 1.0 в 1993 году и с тех пор является частью FreeBSD. Как таковой, он был принят из FreeBSD 4.x для включения в проект Apple Darwin. Начиная с OS X 10.6.8, страница руководства, включенная Apple, остается точной копией страницы руководства FreeBSD. Так что да, он включен в OS X и другие операционные системы помимо Linux. -1 на этот ответ за дезинформацию.,
источник
"${1:0:1}"
для аргумента # 1, подстрока с индексом 0, длина 1. Это не позволяет смешивать короткие и длинные опции.В
ksh93
,getopts
поддерживает длинные имена ...Или так, учебники, которые я нашел, сказали. Попробуйте и посмотрите.
источник
Я только пишу сценарии оболочки время от времени и выпадает из практики, поэтому любые отзывы приветствуются.
Используя стратегию, предложенную @Arvid Requate, мы заметили некоторые пользовательские ошибки. Пользователь, который забудет включить значение, случайно получит имя следующего параметра как значение:
приведет к тому, что значение "loglevel" будет выглядеть как "--toc = TRUE". Этого можно избежать.
Я адаптировал некоторые идеи о проверке ошибок пользователя для CLI из http://mwiki.wooledge.org/BashFAQ/035 обсуждения ручного разбора. Я вставил проверку ошибок в обработку аргументов "-" и "-".
Затем я начал возиться с синтаксисом, поэтому любые ошибки здесь - это моя вина, а не первоначальные авторы.
Мой подход помогает пользователям, которые предпочитают вводить длинные с или без знака равенства. То есть он должен иметь тот же отклик на «--loglevel 9», что и «--loglevel = 9». В методе - / space невозможно узнать наверняка, забыл ли пользователь аргумент, поэтому необходимо некоторое предположение.
Если вы начинаете с этого, есть интересная разница между форматами "--opt = value" и "--opt value". При знаке равенства аргумент командной строки отображается как «opt = value», а работа, выполняемая при разборе строки, разделяется на «=». Напротив, при использовании значения «--opt» имя аргумента - «opt», и мы сталкиваемся с проблемой получения следующего значения в командной строке. Вот где @Arvid Requate использовал $ {! OPTIND}, косвенную ссылку. Я до сих пор не понимаю этого, ну, вообще, и комментарии в BashFAQ, кажется, предостерегают против этого стиля ( http://mywiki.wooledge.org/BashFAQ/006 ). Кстати, я не думаю, что комментарии предыдущего автора о важности OPTIND = $ (($ OPTIND + 1)) верны. Я хочу сказать,
В последней версии этого сценария флаг -v означает распечатку VERBOSE.
Сохраните его в файле с именем «cli-5.sh», сделайте исполняемым, и любой из них сработает или потерпит неудачу желаемым образом
Вот пример выходных данных проверки ошибок в пользовательском intpu
Вы должны рассмотреть возможность включения -v, потому что он печатает внутреннюю часть OPTIND и OPTARG
источник
OPTIND=$(( $OPTIND + 1 ))
: это необходимо всякий раз, когда вы «проглатываете» параметр OPTIND (например, когда он используется--toc value
: значение находится в параметре с номером $ OPTIND. Как только вы получите его для значения toc, вы должны сообщить getopts, что следующий параметр для анализа не является значением, но тот, что после него (следовательно,:OPTIND=$(( $OPTIND + 1 ))
. и ваш сценарий (а также сценарий, на который вы ссылаетесь) отсутствуют, после завершения:shift $(( $OPTIND -1 ))
(поскольку getopts завершился после анализа параметров 1 в OPTIND-1, вам нужно их сместить так, чтобы$@
теперь все оставшиеся «неопционные» параметрыИзобретая еще одну версию колеса ...
Эта функция является (надеюсь) POSIX-совместимой заменой обычной борновой оболочки для GNU getopt. Он поддерживает короткие / длинные опции, которые могут принимать обязательные / необязательные аргументы / без аргументов, а способ задания опций практически идентичен GNU getopt, поэтому преобразование тривиально.
Конечно, это по-прежнему значительный кусок кода, который нужно вставить в сценарий, но он занимает примерно половину строк хорошо известной функции оболочки getopt_long и может быть предпочтительным в тех случаях, когда вы просто хотите заменить существующее использование GNU getopt.
Это довольно новый код, так что YMMV (и определенно, пожалуйста, дайте мне знать, если он не совместим с POSIX по какой-либо причине - с самого начала была задумана переносимость, но у меня нет полезной тестовой среды POSIX).
Код и пример использования следующие:
Пример использования:
источник
Принятый ответ очень хорошо указывает на все недостатки встроенного bash
getopts
. Ответ заканчивается:И хотя я в принципе согласен с этим утверждением, я чувствую, что количество раз, когда мы все реализовывали эту функцию в различных сценариях, оправдывает необходимость приложить немного усилий для создания «стандартизированного», хорошо протестированного решения.
Таким образом, я «обновил» bash, встроенный
getopts
путем реализацииgetopts_long
в чистом bash, без внешних зависимостей. Использование функции на 100% совместимо со встроеннымgetopts
.Включив
getopts_long
(который размещен на GitHub ) в скрипт, ответ на исходный вопрос может быть реализован так же просто, как:источник
У меня еще недостаточно представителей, чтобы комментировать или голосовать за его решение, но ответ Sme очень хорошо сработал для меня. Единственная проблема, с которой я столкнулся, заключалась в том, что аргументы в конечном итоге были заключены в одинарные кавычки (так что я их вычеркнул).
Я также добавил несколько примеров использования и текст справки. Я включу мою слегка расширенную версию здесь:
источник
Здесь вы можете найти несколько разных подходов для разбора сложных параметров в bash: http://mywiki.wooledge.org/ComplexOptionParsing
Я создал следующий, и я думаю, что он хороший, потому что это минимальный код и работают как длинные, так и короткие опции. Длинный параметр также может иметь несколько аргументов с этим подходом.
источник
Я работал над этой темой довольно долго ... и создал свою собственную библиотеку, которую вам нужно будет найти в вашем основном скрипте. Смотрите libopt4shell и cd2mpc для примера. Надеюсь, поможет !
источник
Улучшенное решение:
источник
Может быть, проще использовать ksh, только для части getopts, если нужны длинные параметры командной строки, так как это проще сделать там.
источник
Я хотел что-то без внешних зависимостей, со строгой поддержкой bash (-u), и мне нужно было, чтобы это работало даже на старых версиях bash. Это обрабатывает различные типы параметров:
Просто вставьте следующее в верхней части вашего скрипта:
И используйте это так:
источник
Чтобы поддерживать кросс-платформенную совместимость и избежать зависимости от внешних исполняемых файлов, я перенес некоторый код с другого языка.
Я нахожу это очень простым в использовании, вот пример:
Требуемый BASH немного длиннее, чем мог бы быть, но я хотел избежать зависимости от ассоциативных массивов BASH 4. Вы также можете скачать это прямо с http://nt4.com/bash/argparser.inc.sh
источник
Если все ваши длинные параметры имеют уникальные и совпадающие первые символы в качестве коротких параметров, например,
Такой же как
Вы можете использовать это перед getopts, чтобы переписать $ args:
Спасибо за mtvee за вдохновение ;-)
источник
если просто так вы хотите вызвать скрипт
тогда вы можете пойти по этому простейшему пути с помощью getopt и --longoptions
попробуйте это, надеюсь, это полезно
источник
getopts «может быть использован» для анализа длинных опций, если вы не ожидаете, что у них будут аргументы ...
Вот как это сделать:
Если вы попытаетесь использовать OPTIND для получения параметра для длинной опции, getopts будет рассматривать его как первый необязательный позиционный параметр и прекратит синтаксический анализ любых других параметров. В таком случае вам лучше справиться с этим вручную с помощью простого оператора case.
Это будет "всегда" работать:
Хотя он не такой гибкий, как getopts, и вам приходится делать большую часть кода проверки ошибок самостоятельно в экземплярах кейса ...
Но это вариант.
источник
Встроенный
getopts
анализирует только короткие параметры (кроме ksh93), но вы все равно можете добавить несколько строк сценариев, чтобы getopts обрабатывал длинные параметры.Вот часть кода, найденная в http://www.uxora.com/unix/shell-script/22-handle-long-options-with-getopts
Вот тест:
В противном случае в недавнем Korn Shell ksh93,
getopts
естественно , можно анализировать длинные параметры и даже отображать страницу руководства. (См. Http://www.uxora.com/unix/shell-script/20-getopts-with-man-page-and-long-options )источник
Th встроенной OS X (BSD) Getopt не поддерживает длинные варианты, но версия GNU делает:
brew install gnu-getopt
. Затем, что - то подобное:cp /usr/local/Cellar/gnu-getopt/1.1.6/bin/getopt /usr/local/bin/gnu-getopt
.источник
EasyOptions обрабатывает короткие и длинные опции:
источник