Краткость по сравнению с удобочитаемостью: второй план

Как Вы видели, эта проблема признается в решениях, которые являются умеренно долгими и несколько повторяющимися, но очень читаемыми (terdon's и ответы удара A.B.'s), а также тех, которые являются очень короткими, но необладающими интуицией и намного меньше самодокументирования (Python Tim, и колотите ответы и ответ жемчуга glenn jackman). Все эти подходы ценны.

Можно также решить эту проблему с кодом посреди континуума между компактностью и удобочитаемостью. Этот подход почти так же читаем как более длительные решения с длиной ближе к небольшим, тайным решениям.

#!/usr/bin/env bash

read -erp 'Enter numeric grade (q to quit): '
case $REPLY in [qQ]) exit;; esac

declare -A cutoffs
cutoffs[F]=59 cutoffs[D]=69 cutoffs[C]=79 cutoffs[B]=89 cutoffs[A]=100

for letter in F D C B A; do
    ((REPLY <= cutoffs[$letter])) && { echo $letter; exit; }
done
echo "Grade out of range."

В этом решении для удара я включал некоторые пустые строки для улучшения удобочитаемости, но Вы могли удалить их, если бы Вы хотели это еще короче.

Пустые строки включали, это на самом деле незначительно короче, чем compactified, все еще довольно читаемый вариант решения для удара A.B.'s. Его основные преимущества перед тем методом:

• Это более интуитивно.
• Легче изменить границы между классами (или добавить дополнительные классы).
• Это автоматически принимает вход с продвижением и конечными пробелами (см. ниже для объяснения как (( )) работы).

Все три из этих преимуществ возникают, потому что этот метод использует вход пользователя в качестве числовых данных, а не путем ручного исследования его составляющих цифр.

Как это Работы

1. Считайте вход от пользователя. Позвольте им использовать клавиши со стрелками для перемещений в тексте, который они ввели (-e) и не интерпретируйте \ как символ ESC (-r).
   _{Этот сценарий не является многофункциональным решением - видят ниже для улучшения - но те полезные функции только делают его двумя символами дольше. Я всегда рекомендую использовать -r с read, если Вы не знаете, что необходимо позволить пользователю предоставить \ Escape.}
2. Если пользователь записал q или Q, выход.
3. Создайте ассоциативный массив (declare -A). Заполните его с самым высоким числовым классом, связанным с каждой буквенной оценкой.
4. Цикл через буквенные оценки от самого низкого до самого высокого, проверяя, является ли обеспеченное пользователями число достаточно небольшим для попадения в числовой диапазон каждой буквенной оценки.
   _{С (( )) арифметическая оценка, имена переменной не должны быть расширены с $. (В большинстве других ситуаций, если Вы хотите использовать значение переменной вместо его имени, необходимо сделать это.)}
5. Если это падает в диапазоне, распечатайте класс и выход.
   _{Для краткости я использую короткое замыкание и оператор (&&) вместо if-then.}
6. Если концы цикла и никакой диапазон были подобраны, предположите, что введенный номер слишком высок (более чем 100), и скажите пользователю, что это было вне диапазона.

Как это Ведет себя со Странным Входом

Как другие короткие отправленные решения, тот сценарий не проверяет вход прежде, чем предположить, что это - число. Арифметическая оценка ((( ))) автоматически ведущий и запаздывающий пробел полос, таким образом, это не проблема, но:

• Вход, который не похож на число вообще, интерпретируется как 0.
• С входом, который похож на число (т.е. если он запускается с цифры), но содержит недопустимые символы, сценарий испускает ошибки.
• Многоразрядный вход, запускающийся с 0 интерпретируется как являющийся в восьмеричном. Например, сценарий скажет, что Вы 77 являетесь C, в то время как 077 D. Хотя некоторые пользователи могут хотеть это, по всей вероятности не делайте и это может вызвать беспорядок.
• Зато, при предоставлении арифметического выражения этот сценарий автоматически упрощает его и определяет связанную буквенную оценку. Например, это скажет Вам, что 320/4 является B.

Расширенная, полнофункциональная версия

По тем причинам можно хотеть использовать что-то вроде этого расширенный сценарий, который проверяет, чтобы гарантировать, что вход хорош, и включает некоторые другие улучшения.

#!/usr/bin/env bash
shopt -s extglob

declare -A cutoffs
cutoffs[F]=59 cutoffs[D]=69 cutoffs[C]=79 cutoffs[B]=89 cutoffs[A]=100

while read -erp 'Enter numeric grade (q to quit): '; do
    case $REPLY in  # allow leading/trailing spaces, but not octal (e.g. "03") 
        *( )@([1-9]*([0-9])|+(0))*( )) ;;
        *( )[qQ]?([uU][iI][tT])*( )) exit;;
        *) echo "I don't understand that number."; continue;;
    esac

    for letter in F D C B A; do
        ((REPLY <= cutoffs[$letter])) && { echo $letter; continue 2; }
    done
    echo "Grade out of range."
done

Это - все еще довольно компактное решение.

Какие опции это добавляет?

Ключевые пункты этого расширенного сценария:

• Контроль ввода. вход проверок сценария terdon с if [[ ! $response =~ ^[0-9]*$ ]] ..., таким образом, я показываю иначе, который жертвует некоторой краткостью, но более устойчив, позволяя пользователю ввести продвижение и конечные пробелы и отказ позволить выражение, которое могло бы или не могло бы быть предназначено как восьмеричное (если это не нуль).
• Я использовал case с расширенным globbing вместо [[ с =~ оператор соответствия регулярного выражения (как в ответе terdon). Я сделал это, чтобы показать, что (и как) это может также быть сделано тот путь. Шарики и regexps являются двумя способами указать шаблоны, которые соответствуют тексту, и любой метод хорошо для этого приложения.
• Как сценарий удара A.B.'s, я включил все это во внешний цикл (кроме начального создания cutoffs массив). Это запрашивает числа и дает соответствующие буквенные оценки, пока терминальный вход доступен, и пользователь не сказал этому выходить. Оценка по do...done вокруг кода в Вашем вопросе похоже на желание этого.
• Для создания выхода легкого я принимаю любой нечувствительный к регистру вариант q или quit.

Этот сценарий использует несколько конструкций, которые могут быть незнакомыми новичкам; они детализированы ниже.

Объяснение: использование continue

Когда я хочу перескочить через остальную часть тела внешнего while цикл, я использую continue команда. Это возвращает его до вершины цикла, чтобы считать более вход и выполнить другое повторение.

В первый раз, когда я делаю это, единственный цикл, в котором я нахожусь, является внешним while цикл, таким образом, я могу звонить continue без аргумента. (Я нахожусь в a case создайте, но это не влияет на операцию break или continue.)

        *) echo "I don't understand that number."; continue;;

Во второй раз, однако, я нахожусь во внутреннем for цикл, который самостоятельно вкладывается во внешнем while цикл. Если я использовал continue без аргумента это было бы эквивалентно continue 1 и продолжил бы внутреннее for цикл вместо внешнего while цикл.

        ((REPLY <= cutoffs[$letter])) && { echo $letter; continue 2; }

Так в этом случае я использую continue 2 заставить удар найти и продолжить второй цикл вместо этого.

Объяснение: case Маркировки с шариками

Я не использую case выяснять, какое мусорное ведро буквенной оценки число падает в (как в ответе удара A.B.'s). Но я действительно использую case чтобы решить, нужно ли вход пользователя рассмотреть:

• верный номер, *( )@([1-9]*([0-9])|+(0))*( )
• команда выхода, *( )[qQ]?([uU][iI][tT])*( )
• что-либо еще (и таким образом недопустимый вход), *

Это шарики оболочки.

• Каждый сопровождается a ) это не подобрано никаким открытием (, который является caseсинтаксис для разделения шаблона от команд, которые работают, когда это подобрано.
• ;; caseсинтаксис для указания на конец команд для выполнения за особым соответствием случая (и что никакие последующие случаи не должны быть протестированы после выполнения их).

Обычная оболочка globbing обеспечивает * соответствовать нулю или большему количеству символов, ? соответствовать точно одному символу и символьным классам/диапазонам в [ ] скобки. Но я использую расширенный globbing, который идет кроме того. Расширенный globbing включен по умолчанию при использовании bash в интерактивном режиме, но отключен по умолчанию при запущении скрипта. shopt -s extglob команда наверху сценария включает его.

Объяснение: расширенный Globbing

*( )@([1-9]*([0-9])|+(0))*( ), то, которое проверяет на числовой вход, соответствует последовательности:

• Нуль или больше пробелов (*( )). *( ) создайте нуль соответствий или больше шаблона в круглых скобках, которые вот просто пространство.
  _{Существует на самом деле два вида горизонтального пробела, пробелов и вкладок, и часто желательно соответствовать вкладкам также. Но я не волнуюсь о том здесь, потому что этот сценарий записан для ручного, интерактивного входа, и -e флаг к read включает GNU readline. Это - так пользователь, может двинуться вперед-назад в их тексте с левыми и правыми клавишами со стрелками, но он имеет побочный эффект общего препятствования тому, чтобы вкладки были введены буквально.}
• Одно возникновение (@( )) из любого (|):
  • Ненулевая цифра ([1-9]) сопровождаемый нулем или больше (*( )) из любой цифры ([0-9]).
  • Один или несколько (+( )) из 0.
• Нуль или больше пробелов (*( )), снова.

*( )[qQ]?([uU][iI][tT])*( ), то, которое проверяет на команду выхода, соответствует последовательности:

• Нуль или больше пробелов (*( )).
• q или Q ([qQ]).
• Дополнительно - т.е. нуль или случаи (?( ))-:
  • u или U ([uU]) сопровождаемый i или I ([iI]) сопровождаемый t или T ([tT]).
• Нуль или больше пробелов (*( )), снова.

Вариант: проверка входа с расширенным регулярным выражением

Если Вы предпочитаете тестировать вход пользователя против регулярного выражения, а не шарика оболочки, Вы могли бы предпочесть использовать эту версию, которая работает то же, но использование [[ и =~ (как в ответе terdon) вместо case и расширенный globbing.

#!/usr/bin/env bash
shopt -s nocasematch

declare -A cutoffs
cutoffs[F]=59 cutoffs[D]=69 cutoffs[C]=79 cutoffs[B]=89 cutoffs[A]=100

while read -erp 'Enter numeric grade (q to quit): '; do
    # allow leading/trailing spaces, but not octal (e.g., "03")
    if [[ ! $REPLY =~ ^\ *([1-9][0-9]*|0+)\ *$ ]]; then
        [[ $REPLY =~ ^\ *q(uit)?\ *$ ]] && exit
        echo "I don't understand that number."; continue
    fi

    for letter in F D C B A; do
        ((REPLY <= cutoffs[$letter])) && { echo $letter; continue 2; }
    done
    echo "Grade out of range."
done

Возможные преимущества этого подхода состоят в том что:

• В данном случае синтаксис немного более прост, по крайней мере, во втором шаблоне, где я проверяю на команду выхода. Это вызвано тем, что я смог установить nocasematch опция оболочки и затем все варианты случая q и quit были покрыты автоматически.

  Это что shopt -s nocasematch команда делает. shopt -s extglob команда опущена, поскольку globbing не используется в этой версии.

• Навыки регулярного выражения более распространены, чем мастерство в extglobs удара.

Объяснение: регулярные выражения

Что касается шаблонов, указанных направо от =~ оператор, вот то, как те регулярные выражения работают.

^\ *([1-9][0-9]*|0+)\ *$, то, которое проверяет на числовой вход, соответствует последовательности:

• Начало - т.е. левый край - строки (^).
• Нуль или больше (*, прикладной постфикс) пробелы. Пространство не должно обычно быть \- оставленный в регулярном выражении, но это необходимо с [[ предотвратить синтаксическую ошибку.
• Подстрока (( )) это один или другой (|) из:
  • [1-9][0-9]*: ненулевая цифра ([1-9]) сопровождаемый нулем или больше (*, прикладной постфикс) любой цифры ([0-9]).
  • 0+: один или несколько (+, прикладной постфикс) 0.
• Нуль или больше пробелов (\ *), как прежде.
• Конец - т.е. правый край - строки ($).

В отличие от этого, case маркировки, которые соответствуют против целого протестированного выражения, =~ возвращает true, если какая-либо часть его левого выражения соответствует шаблону, данному как его правое выражение. Это то, почему ^ и $ привязки, указывая начало и конец строки, необходимы здесь и не соответствуют синтаксически ничему появляющемуся в методе с case и extglobs.

Круглые скобки необходимы для создания ^ и $ свяжите с разъединением [1-9][0-9]* и 0+. Иначе это было бы разъединение ^[1-9][0-9]* и 0+$, и соответствуйте любому входу, запускающемуся с ненулевой цифры или заканчивающемуся a 0 (или оба, которые могли бы все еще включать промежуточные нецифры).

^\ *q(uit)?\ *$, то, которое проверяет на команду выхода, соответствует последовательности:

• Начало строки (^).
• Нуль или больше пробелов (\ *, посмотрите выше объяснения).
• Буква q. Или Q, с тех пор shopt nocasematch включен.
• Дополнительно - т.е. нуль или случаи (постфикс ?) - подстроки (( )):
  • u, сопровождаемый i, сопровождаемый t. Или, с тех пор shopt nocasematch включен u может быть U; независимо, i может быть I; и независимо, t может быть T. (Таким образом, возможности не ограничены uit и UIT.)
• Нуль или больше пробелов снова (\ *).
• Конец строки ($).