Read bash: 5 практических примеров команды read в Linux

Содержание

5 практических примеров команды read в Linux

С помощью команды read вы можете сделать ваш bash-скрипт интерактивным, принимая вводимые пользователем данные. Научитесь использовать команду чтения в Linux с этими практическими примерами.

 

Что такое команда read в Linux?

Команда read в Linux – это способ взаимодействия пользователей с вводом с клавиатуры, который вы можете увидеть как stdin (стандартный ввод) или другие подобные описания.

Другими словами, если вы хотите, чтобы ваш bash-скрипт принимал ввод от пользователя, вам придется использовать команду read.

Мы собираемся написать несколько простых скриптов bash, чтобы показать вам практическое использование команды read.

 

Прочитайте примеры команды read

Команда read может сбить с толку, особенно для тех, кто плохо знаком со сценариями оболочки. Сценарии, которые мы собираемся использовать здесь, очень просты для понимания и должны легко следовать, особенно если вы практикуете вместе с учебным пособием.

 

Основные концепции программирования

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

Когда вы используете read, вы связываетесь с терминалом bash, который хотите захватить ввод от пользователя. По умолчанию команда создаст переменную для сохранения этого ввода.

read [options] variable_name

 

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

 

1. Команда read без параметров

Когда вы печатаете read без каких-либо дополнительных опций, вам нужно нажать Enter, чтобы начать захват. Система будет захватывать ввод, пока вы снова не нажмете ввод.

По умолчанию эта информация будет храниться в переменной с именем $REPLY.

Для упрощения работы с первым примером мы будем использовать символ ↵, который будет отображаться при нажатии клавиши ввода.

read ↵
привет мир ↵
echo $REPLY ↵
привет мир

 

Подробнее о переменных

Как мы упоминали ранее, переменная $REPLY встроена в read, поэтому вам не нужно объявлять ее.

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

Когда вы хотите вызвать переменную, вы будете использовать $ перед именем. Вот пример, где мы создаем переменную AndreyEx и присваиваем ей значение ввода.

Вы можете использовать команду echo, чтобы убедиться, что команда read сделала свое дело:

read AndreyEx ↵
Администрирование серверов на основе Linux.
echo $AndreyEx ↵
Администрирование серверов на основе Linux.

 

Напоминание

Имена переменных чувствительны к регистру.

 

2. Оперативный вариант -p

Если вы пишете сценарий и хотите захватить ввод пользователя, существует опция чтения, чтобы создать подсказку, которая может упростить ваш код. Кодирование это все о эффективности, верно?

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

Поэтому вместо того, чтобы писать две строки кода, вот так:

echo "Каково ваше желаемое имя пользователя? "
read username

 

Вы можете использовать опцию -p с командой read следующим образом:

read -p "Каково ваше желаемое имя пользователя? " username

 

Ввод будет сохранен в переменной $username.

 

3. «Secret» / Тихая опция -s

Мы написали скрипт Simpe Bash, чтобы продемонстрировать следующий флаг. Сначала взгляните на результат.

bash secret.sh
Каково ваше желаемое имя пользователя? destr_old
Ваше имя пользователя будет destr_old.
Пожалуйста, введите пароль, который вы хотите использовать:

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

 

Вот содержание, secret.sh, если вы хотите воссоздать его.

#!/bin/bash
read -p "Каково ваше желаемое имя пользователя? " username
echo "Ваше имя пользователя будет" $username"."
read -s -p "Пожалуйста, введите пароль, который вы хотите использовать: " password
echo
echo "Вы вошли" $password "для вашего пароля."
echo "Маскировка того, что введено, не скрывает данные в любом случае."

 

Как видите, опция -s маскировала ввод при вводе пароля. Тем не менее, это поверхностный метод и не предлагает реальной безопасности.

4. Использование ограничения символов с опцией -n

Вы можете добавить ограничение к входу и ограничить его количеством символов длиной n.

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

read -n 5 -p "Каково ваше желаемое имя пользователя? " username

 

Просто добавьте, -n N где N номер вашего выбора.

Мы сделали то же самое для нашего пароля.

bash secret.sh
Каково ваше желаемое имя пользователя? destr_old
Ваше имя пользователя будет destr.
Пожалуйста, введите пароль, который вы хотите использовать:
Вы ввели Pas_1 для вашего пароля.

 

Как видите, программа перестала собирать ввод после 5 символов для имени пользователя.

Тем не менее, мы все еще могли написать МЕНЬШЕ, чем 5 символов, пока мы нажмем ↵после ввода.

Если вы хотите ограничить это, вы можете использовать -N (вместо -n). Эта модификация делает так, что требуется ровно 5 символов, ни меньше, ни больше.

 

5. Хранение информации в массиве -a

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

[email protected]:~$ read -a array
abc def 123 x y z
[email protected]:~$ echo  ${array[@]}
abc def 123 x y z
[email protected]:~$ echo  ${array[@]:0:3}
abc def 123
[email protected]:~$ echo  ${array[0]}
abc
[email protected]:~$ echo  ${array[5]}
z

 

Если вы плохо знакомы с массивами или видите, их в bash впервые, мы опишем:

  • Введите нужные элементы, разделенные пробелами.
  • Если мы поместим только переменную @, она будет повторяться и печатать весь цикл.
  • Символ @ представляет номер элемента, а после двоеточий мы можем указать итерацию от индекса 0 до индекса 3 (как написано здесь).
  • Печатает элемент с индексом 0.
  • Аналогично приведенному выше, но демонстрирует, что элементы разделены пространством

Бонусный совет: добавление функции тайм-аута

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

[email protected]:~$ read -t 3
[email protected]:~$

 

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

 

Заключение

Мы надеемся, что эта статья помогло вам начать работу с командой чтения в Linux. Как всегда, мы рады услышать от наших читателей информацию, которая им интересна. Оставьте комментарий ниже и поделитесь с нами своими мыслями!

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

программирование в shell. Руководство разработчика.

Команда read читает одну строку из стандартного входного потока и записывает ее содержимое в указанные переменные. Если задана единственная переменная, в нее записывается вся строка. В результате ввода команды read без параметров строка помешается в переменную среды $reply. При указании нескольких переменных в первую из них записывается первое слово строки, во вторую — второе слово и т. д. Последней переменной присваивается остаток строки.

Общий формат команды таков:

read переменная1 переменная2…

В следующем примере в переменную name записывается весь вводимый с клавиатуры текст до тех пор, пока не будет нажата клавиша [Enter]:

$ read name Джон Алан Доу $ echo $name

Джон Алан Доу

Представленная ниже команда заносит введенные имя и фамилию в две переменные. В качестве разделителя между словами используется пробел.

$ read name surname

Джон Доу

$ echo $name $surname

Джон Доу

Если во входной строке больше слов, чем указано переменных, в последнюю переменную записываются все оставшиеся слова:

$ read name surname Джоя Алан Доу

$ echo $name

Джон

$ echo $surnane

Алан Доу

Следующий сценарий вызывает отдельную команду read для чтения каждой переменной:

$ cat var_test

#!/bin/sh

# var_test

echo "Имя:c"

read name

echo "Отчество:c"

read middle

echo "Фамилия:c"

read surname

В Linux…

Вместо управляющего символа с в команде echo следует указывать опцию -n:

$ cat var_test

#!/bin/sh

# var_test

echo -n "Имя:"

read name

echo -n "Отчество:"

read middle

echo -n "Фамилия:"

read surname

Поделитесь на страничке

Следующая глава >

Основные команды Bash | Losst

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

Основная задача оболочки — выполнять команды, но кроме утилит, расположенных в файловой системе, Bash имеет свой набор команд, многими из которых вы пользуетесь каждый день сами этого не понимая. Эти команды Bash находятся не на диске, а встроены в саму оболочку. В этой статье мы рассмотрим основные команды bash в linux, которые могут быть полезны в некоторых ситуациях.

Содержание статьи:

Основные команды Bash

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

1. source

Эта команда позволяет прочитать и выполнить все команды из указанного файла в текущей командной оболочке. Это значит, что все заданные в нем переменные окружения будут видны во всех скриптах или командах, которые вы будете выполнять. Напомню, что если вы запускаете обычный скрипт и объявляете в нем переменную, то она будет доступна только ему потому что для скриптов создается отдельный экземпляр оболочки. Он наследует переменные родителя, но не наоборот. Эта команда часто применяется для обновления окружения после chroot:

source /etc/profile

 

2. alias

Команда alias позволяет создавать псевдонимы для других команд. Например, вы можете настроить так, чтобы когда вы вводите update, выполнялась команда sudo apt update && sudo apt upgrade. Если вызвать команду без параметров, то она выведет список уже заданных псевдонимов. Смотрите подробнее о том как создавать алиасы Linux в отдельной статье.

alias

3. bind

С помощью этой команды вы можете связать нажатие клавиши с определенной командной или функцией. Например, настроим, чтобы при нажатии F12 в окне терминала выполнялась команда pwd:

bind '"\e[24~":"pwd\n"'

4. cd

Команда cd используется очень часто при работе с папками в терминале. Она позволяет сменить текущую папку на произвольную. Можно использовать чтобы не набирать длинные пути, также она необходима при компиляции. По умолчанию, текущая папка — домашняя:

cd /

5. declare

Встроенная команда bash — declare позволяет объявлять переменные. Опция -a позволяет вывести все уже существующие переменные окружения. В отличии от обычного объявления вы можете задать различные параметры, например, сделать переменную только для чтения с помощью опции -r. Также можно объявлять функции.

declare VAR=test

6. dirs

Команда dirs отображает историю смены текущей папки. Каждая предыдущая папка отображается с новой строки. С помощью опции -n можно указать, сколько последних элементов выводить.

dirs

7. echo

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

echo "Это строка"

 

8. enable

Команда enable позволяет включать или отключать встроенные команды bash. Для включения встроенной команды достаточно передать ее в параметрах. Если вы хотите отключить команду, используйте опцию -n, после этого вместо встроенной команды, будет выполняться утилита из файловой системы.

enable -n echo

9. exit

Универсальная команда, которая позволяет закрыть сеанс оболочки, выйти из терминала или завершить текущую сессию.

10. export

Еще одна команда для объявления переменных. Все объявленные с помощью нее переменные экспортируются во внешнее окружение среды и будут доступны всем скриптам и программам. С помощью опции -p вы можете посмотреть экспортированные на данный момент переменные.

export VAR=test

 

11. bg

Команда bg позволяет посмотреть команды, которые выполняются в фоне. Если вы нажмете сочетание клавиш Ctrl+Z, то утилита будет свернута в фоновый режим. Этой командой вы можете посмотреть все такие процессы для данной оболочки.

bg

12. fg

Эта команда позволяет восстановить команду из фона, в параметрах ей нужно передать только идентификатор нужного процесса, который вы можете узнать с помощью bg.

fg 1

 

 

13. history

Команда history linux позволяет посмотреть историю команд, которые вы выполняли ранее. Здесь сохраняется более 1000 последних команд, вы можете все их увидеть, выполнять по них поиск и так далее. Вы можете задать нужное количество записей просто передав нужное значение.

history 10

14. kill

Команда kill может быть системной утилитой или командой оболочки. Она позволяет отправить указанному процессу сигнал. Например, SIGKILL, SIGTERM и другие. С помощью нее вы можете завершить процесс по его PID или идентификатору Bash.

15. let

Команда let выполняет функцию калькулятора, ей нужно передать математическое выражение, которое она подсчитает. Можно передать несколько таких выражений.

let "2+2"

16. popd

Это еще одна команда, которая используется для навигации по каталогах. Команда удаляет последнюю директорию из стека каталогов. Таким образом, вы перемещаетесь в ранее выбранную текущую папку с помощью cd, на уровень выше. Команде можно передать в параметрах сколько папок нужно удалить. Для этого добавьте плюс, а затем цифру.

17. printf

Эта команда похожа на echo по своему назначению  похожа на echo. Она позволяет вывести в терминал строку, но перед выводом вы можете настроить ее форматирование. Синтаксис форматирования очень похож на тот, что используется в популярных языках программирования, таких как Си или PHP. Например, с помощью этой команды bash вы можете подставить значения переменных в произвольные места строки:

printf "Var: %s\n" "$VAR"

18. pushd

Команда pushd выполняет действие, обратное до popd и по назначению аналогична cd. Она устанавливает указанную папку на верхушку стека директорий, тем самым меняет текущую рабочую директорию на указанную вами.

19. pwd

Позволяет отобразить текущую рабочую папку:

pwd

 

20. read

С помощью команды read, вы можете прочитать строку из стандартного ввода или файла в переменную. Есть подобные ей команды оболочки bash, которые позволяют считывать строку в массив. Команде можно передать файл для считывания, а также несколько переменных:

read VAR

21. suspend

Позволяет приостановить выполнение оболочки пока не будет отправлен сигнал SIGCONT. Можно также приостановить выполнение одного из процессов, выполняющихся в фоне.

22. umask

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

23. time

Встроенная команда time позволяет замерять время выполнения любого скрипта или программы. Измеряется отдельно время выполнения программы и время на ввод пользователя.

time ls

24. wait

Наш список команд bash завершает wiat. Она позволяет ожидать пока указанный процесс завершит свое выполнение. Вы можете использовать PID или идентификатор Bash для выбора нужного процесса.

Выводы

В этой статье мы рассмотрели основные команды Bash, которые вы можете применять для управления терминалом Linux. Наверное, вы и не догадывались, что многие из часто используемых программ на самом деле встроенные команды bash. Если у вас остались вопросы, спрашивайте в комментариях!

Ввод значений пользователем в Bash с помощью команды read

Про то, как выводить данные в Bash помощью команды read написан ряд статей, в которых разобраны с примерами принципы вывода информации для пользователя в консоли *unix. В этой статье разберём, как вводить данные, которые могут потребоваться для работы скрипта. Именно для этих целей предназначена команда read. Она имеет ряд опций, но я ограничусь рассмотрением только выводом подсказки при запросе переменной и тем, как сделать ввод пароля вслепую (чтобы никто не подсмотрел).

Как ввести значение с клавиатуры в Bash с помощью команды read

В простейшем случае для ввода с клавиатуры строки в качестве переменной, нужно вызвать функцию read и после пробела написать имя переменной, в которую требуется передать введённое значение. Рассмотрим это на примере (переменная будет var):

[email protected]:~# read var

После того, как нажат Enter, курсор перейдёт на новую строку и можно вводить значение. После того, как значение введено, нужно ещё раз нажать Enter. Таким образом, введённое значение будет присвоено переменной. В нашем случае var.

Для того, чтобы вывести на экран значение этой переменой с помощью команды echo, нужно перед именем переменной поставить знак доллара $. Выглядеть в итоге это будет как-то так:

[email protected]:~# read var
тест пользовательского ввода
[email protected]:~# echo $var
тест пользовательского ввода
[email protected]:~#

Ввод значения с клавиатуры, начинающийся с подсказки в Bash с помощью команды read

Для того, чтобы пользователь знал, что требуется ввести, ему нужно дать подсказку в виде текста. Это можно сделать с помощью команды echo, убрав перевод на новую строку с помощью опции  (можно прочитать по → этой ссылке),но можно все сделать гораздо проще с помощью команды read, используя опцию -p:

[email protected]:~# read -p "Введите имя: " var
Введите имя: Виктория
[email protected]:~# echo "Было введено имя: " $var
Было введено имя:  Виктория

Объяснения кажется излишни — вроде должно быть понятно, как работает вывод подсказки в команде read.

Скрытый ввод значения (пароля) с клавиатуры в Bash с помощью команды read

Ну и рассмотрим ещё одну опцию -s, которая позволяет скрыто вводить (пароли) с клавиатуры. После ввода пароля, для его завершения, нужно также нажать Enter. После этого введённое значение попадёт в переменную:

[email protected]:~# read -sp "Введите пароль: "  password && echo
Введите пароль:
[email protected]:~# echo "Был введён пароль: " $password
Был введён пароль:  ПаРоЛь
[email protected]:~#

В примере выше, опции -s и -p должны идти именно в таком порядке, если нужна подсказка, но записать их можно либо как в примере -sp, либо -s -p. Команда read работать будет одинаково.

Ну и после ввода пароля дописана команда && echo, которая позволяет перевести курсор на новую строку после скрытого ввода значения переменной. Иначе перевод строки не сработает и будет не удобно продолжать работу в консоли.

Резюме

Таким образом, с помощью команды read в Bash можно передавать значения, вводя их с клавиатуры и даже выдавать подсказки пользователю, чтобы он понимал, какие данные у него запрашиваются.

Заберите ссылку на статью к себе, чтобы потом легко её найти 😉

Выберите, то, чем пользуетесь чаще всего:

Спасибо за внимание, оставайтесь на связи! Ниже ссылка на форум и обсуждение ; )

Как читать файл построчно в Bash

При написании сценариев Bash вы иногда окажетесь в ситуациях, когда вам нужно читать файл построчно. Например, у вас может быть текстовый файл, содержащий данные, которые должны обрабатываться сценарием.

В этой статье мы расскажем о том, как построчно читать файл в Bash.

 

Наиболее общий синтаксис для чтения файла построчно:

while IFS= read -r line
do
  echo "$line"
done < input_file

или эквивалентная однострочная версия:

while IFS= read -r line; do echo $line; done < input_file
Как это работает?

Входной файл ( input_file) – это имя файла, который вы хотите открыть командой для чтения read. Команда read читает файл построчно, присваивая каждую строку переменной line. Как только все строки обработаны, цикл while прекратится. Внутренний разделитель полей (IFS) устанавливается в пустую строку, чтобы сохранить начальные и конечные пробелы, что является поведением команды по умолчанию read.

 

Давайте посмотрим на следующий пример. Предположим, у нас есть файл с именем, distros.txt содержащий список некоторых наиболее популярных дистрибутивов Linux и менеджеры пакетов, разделенные запятой (,):

distros.txt

Ubuntu,apt
Debian,apt
CentOS,yum
Arch Linux,pacman
Fedora,dnf

Чтобы прочитать файл построчно, вы должны запустить следующий код в вашем терминале:

while IFS= read -r line
do
  echo "$line"
done < distros.txt

<

Код будет читать файл построчно, назначать строку переменной и выводить ее. По простоте вы увидите тот же вывод, что и при отображении содержимого файла с помощью команды cat.

Что если вы хотите распечатать только дистрибутивы, которые используют apt? Один из способов – проверить, содержит ли строка подстроку apt :

while IFS= read -r line
do
  if [[ "$line" == *"apt"* ]]; then
    echo "$line"
  fi
done < distros.txt

При чтении файла строка за строкой вы также можете передать более одной переменной в команду чтения, которая разделит строку на поля на основе IFS. Первое поле присваивается первой переменной, второе – второй переменной и т. д. Если полей больше, чем переменных, оставшиеся поля присваиваются последней переменной.

В следующем примере мы устанавливаем IFS для запятой (,) и передаем две переменные distro и pm команде чтения. Все от начала строки до первой запятой будет присвоено первой переменной ( distro), а остальная часть строки будет назначена второй переменной ( pm):

while IFS=, read -r distro pm
do
  echo "$pm" менеджер пакетов для "$distro"
done < distros.txt
apt менеджер пакетов для Ubuntu
apt менеджер пакетов для Debian
yum менеджер пакетов для CentOS
pacman менеджер пакетов для Arch Linux
dnf менеджер пакетов для Fedora

Подстановка процесса позволяет вам передавать вывод команды в виде имени файла:

while IFS= read -r line
do
  echo "$line"
done < <(cat input_file )

Здесь строка является вариантом heredoc. Строка (cat input_file ) будет содержать новые строки:

while IFS= read -r line
do
  echo "$line"
done <<< $(cat input_file )

Вы также можете предоставить вход для цикла, используя дескриптор файла:

while IFS= read -r -u9 line
do
  echo "$line"
done 9< input_file

При работе с файловыми дескрипторами используйте число от 4 до 9, чтобы избежать конфликта с внутренними файловыми дескрипторами оболочки.

 

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

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Основы BASH. Часть 2 / Хабр

Основы BASH. Часть 2.

Извиняюсь за такую большую задержку между статьями, но сессия дает о себе знать в самый неподходящий момент 🙂

Всем спасибо за замечания, критику и дополнения, которые были озвучены в комментариях к прошлой

статье

.

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

Начнем.


Циклы. Цикл for-in.

Оператор for-in предназначен для поочередного обращения к значениям перечисленным в списке. Каждое значение поочередно в списке присваивается переменной.

Синтаксис следующий:


for переменная in список_значений
do
команды
done

Рассмотрим небольшой пример:


#!/bin/bash
for i in 0 1 2 3 4 #переменной $i будем поочередно присваивать значения от 0 до 4 включительно
do
echo "Console number is $i" >> /dev/pts/$i #Пишем в файл /dev/pts/$i(файл виртуального терминала) строку "Console number is $i"
done #цикл окончен
exit 0

После выполнения примера в первых 5 виртуальных консолях(терминалах) появится строка с её номером. В переменную $i поочередно подставляются значения из списка и в цикле идет работа со значением этой переменной

Циклы. Цикл while.

Цикл while сложнее цикла for-in и используется для повторения команд, пока какое-то выражение истинно( код возврата = 0).

Синтаксис оператора следующий:


while выражение или команда возвращающая код возврата
do
команды
done

Пример работы цикла рассмотрим на следующем примере:


#!/bin/bash
again=yes #присваиваем значение "yes" переменной again
while [ "$again" = "yes" ] #Будем выполнять цикл, пока $again будет равно "yes"
do
echo "Please enter a name:"
read name
echo "The name you entered is $name"

echo "Do you wish to continue?"
read again
done
echo "Bye-Bye"

А теперь результат работы скрипта:


[email protected]:~$ ./bash3_primer1.sh
Please enter a name:
ite
The name you entered is ite
Do you wish to continue?
yes
Please enter a name:
mihail
The name you entered is mihail
Do you wish to continue?
no
Bye-Bye

Как видим цикл выполняется до тех пор, пока мы не введем что-то отличное от «yes». Между do и done можно описывать любые структуры, операторы и т.п., все они будут выполнятся в цикле.Но следует быть осторожным с этим циклом, если вы запустите на выполнение в нём какую-либо команду, без изменения переменной выражения, вы можете попасть в бесконечный цикл.
Теперь об условии истинности. После while, как и в условном операторе if-then-else можно вставлять любое выражение или команду, которая возвращает код возврата, и цикл будет исполнятся до тех пор, пока код возврата = 0! Оператор «[» аналог команды test, которая проверяет истинность условия, которое ей передали.

Рассмотрим еще один пример, я взял его из книги Advanced Bash Scripting. Уж очень он мне понравился :), но я его немного упростил. В этом примере мы познакомимся с еще одним типом циклов UNTIL-DO. Эта практически полный аналог цикла WHILE-DO, только выполняется пока какое-то выражение ложно.
Вот пример:

#!/bin/bash
echo "Введите числитель: "
read dividend
echo "Введите знаменатель: "
read divisor

dnd=$dividend #мы будем изменять переменные dividend и divisor,
#сохраним их знания в других переменных, т.к. они нам
#понадобятся
dvs=$divisor
remainder=1

until [ "$remainder" -eq 0 ]
do
let "remainder = dividend % divisor"
dividend=$divisor
divisor=$remainder
done

echo "НОД чисел $dnd и $dvs = $dividend"

Результат выполнения скрипта:


[email protected]:~$ ./bash3_primer3.sh
Введите числитель:
100
Введите знаменатель:
90
НОД чисел 100 и 90 = 10

Математические операции

Команда let.

Команда let производит арифметические операции над числами и переменными.

Рассмотрим небольшой пример, в котором мы производим некоторые вычисления над введенными числами:


#!/bin/bash
echo "Введите a: "
read a
echo "Введите b: "
read b

let "c = a + b" #сложение
echo "a+b= $c"
let "c = a / b" #деление
echo "a/b= $c"
let "c <<= 2" #сдвигает c на 2 разряда влево
echo "c после сдвига на 2 разряда: $c"
let "c = a % b" # находит остаток от деления a на b
echo "$a / $b. остаток: $c "

Результат выполнения:


[email protected]:~$ ./bash3_primer2.sh
Введите a:
123
Введите b:
12
a+b= 135
a/b= 10
c после сдвига на 2 разряда: 40
123 / 12. остаток: 3

Ну вот, как видите ничего сложного, список математических операций стандартный:

+ — сложение

— — вычитание

* — умножение

/ — деление

** — возведение в степень

% — модуль(деление по модулю), остаток от деления

let позволяет использовать сокращения арифметических команд, тем самым сокращая кол-во используемых переменных. Например: a = a+b эквивалентно a +=b и т.д


Работа с внешними программами при написании shell-скриптов

Для начала немного полезной теории.


Перенаправление потоков.

В bash(как и многих других оболочках) есть встроенные файловые дескрипторы: 0 (stdin), 1 (stdout), 2 (stderr).

stdout — Стандартный вывод. Сюда попадает все что выводят программы

stdin — Стандартный ввод. Это все что набирает юзер в консоли

stderr — Стандартный вывод ошибок.

Для операций с этими дескрипторами, существуют специальные символы: > (перенаправление вывода),


cat /dev/random > /dev/null

перенаправить вывод команды cat /dev/random в /dev/null (абсолютно бесполезная операция :)) ) или


ls -la > listing

записать в файл listing содержание текущего каталога (уже полезней)

Если есть необходимость дописывать в файл(при использовании «>» он заменятеся), необходимо вместо «>» использовать «>>»


sudo < my_password

после просьбы sudo ввести пароль, он возьмется из файла my_password, как будто вы его ввели с клавиатуры.

Если необходимо записать в файл только ошибки, которые могли возникнуть при работе программы, то можно использовать:


./program_with_error 2> error_file

цифра 2 перед «>» означает что нужно перенаправлять все что попадет в дескриптор 2(stderr).

Если необходимо заставить stderr писать в stdout, то это можно можно след. образом:


./program_with_error 2>&1

символ «&» означает указатель на дескриптор 1(stdout)

(Поумолчанию stderr пишет на ту консоль, в котрой работает пользователь(вренее пишет на дисплей)).

2.Конвееры.

Конвеер — очень мощный инструмент для работы с консолью Bash. Синтаксис простой:


команда1 | команда 2

— означает, что вывод команды 1 передастся на ввод команде 2

Конвееры можно группировать в цепочки и выводить с помощью перенаправления в файл, например:


ls -la | grep «hash» |sort > sortilg_list

вывод команды ls -la передается команде grep, которая отбирает все строки, в которых встретится слово hash, и передает команде сортировке sort, которая пишет результат в файл sorting_list. Все довольно понятно и просто.

Чаще всего скрипты на Bash используются в качестве автоматизации каких-то рутинных операций в консоли, отсюда иногда возникает необходимость в обработке stdout одной команды и передача на stdin другой команде, при этом результат выполнения одной команды должен быть неким образом обработан. В этом разделе я постораюсь объяснить основные принципы работы с внешними командами внутри скрипта. Думаю что примеров я привел достаточно и можно теперь писать только основные моменты.

1. Передача вывода в переменную.

Для того чтобы записать в переменную вывод какой-либо команды, достаточно заключить команду в « ковычки, например


a = `echo "qwerty"`
echo $a

Результат работы: qwerty

Однако если вы захотите записать в переменную список директорий, то необходимо, должным образом обработать результат для помещения данных в переменную. Рассмотрим небольшой, пример:


LIST=`find /svn/ -type d 2>/dev/null| awk '{FS="/"} {print $4}'| sort|uniq | tr '\n' ' '`
for ONE_OF_LIST in $LIST
do
svnadmin hotcopy /svn/$ONE_OF_LIST /svn/temp4backup/$ONE_OF_LIST
done

Здесь мы используем цикл for-do-done для архивирование всех директорий в папке /svn/ с помощью команды svnadmin hotcopy(что в нашем случае не имеет никого значения, просто как пример). Наибольшй интерес вызывает строка:

LIST=`find /svn/ -type d 2>/dev/null| awk '{FS="/"} {print $4}'| sort|uniq | tr '\n' ' '`

В ней переменной LIST присваивается выполнение команды find, обработанной командами awk, sort, uniq,tr(все эти команды мы рассматривать не будем, ибо это отдельная статья). В переменной LIST будут имена всех каталогов в папке /svn/ пгомещенных в одну строку(для того чтобы её стравить циклу.

Как видно, все не сложно, достаточно понять принцип и написать пару своих скриптов. В заключении статьи хочу пожелать удачи в изучении BASH и Linux в целом. Критика, как водится приветствуется. Следующая статья возможно будет посвещена использованию таких программ как sed, awk.

Статьи на unix-admin.su

Команда чтения Bash — Linux Hint

Прочтите или умрите, друзья. Команда чтения так же важна, как позиционные параметры и команда echo. Как еще вы собираетесь перехватывать вводимые пользователем данные, принимать пароли, писать функции, выполнять цикл и просматривать дескрипторы файлов? Читать дальше.

Что читается?

Read — это встроенная команда bash, которая считывает содержимое строки в переменную. Он позволяет разбивать слова, привязанные к специальной переменной оболочки IFS. Он в основном используется для перехвата пользовательского ввода, но может использоваться для реализации функций, принимающих ввод со стандартного ввода.

Bash читает встроенную справку по командам

Прежде чем мы углубимся в то, как использовать команду чтения в сценариях bash, вот как мы получаем помощь. Там вы должны увидеть все параметры, доступные для команды чтения, а также описания, которые мы постараемся охватить в примерах.

Командная строка

Выход

читать: читать [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars]
[-p приглашение] [-t тайм-аут] [-u fd] [имя…]

Прочитать строку из стандартного ввода и разбить ее на поля.

Считывает одну строку из стандартного ввода или из файлового дескриптора FD
, если задана опция -u. Строка разбивается на поля, как при разбиении слова
, и первое слово назначается первому ИМЕНИ, второе слово
— второму ИМЯ и так далее, при этом любые оставшиеся слова присваиваются
последнему ИМЯ. Только символы, найденные в $ IFS, распознаются как разделители слова
.

Если ИМЯ не указана, считанная строка сохраняется в переменной REPLY.

Опции:
-a массив назначает прочитанные слова последовательным индексам массива
переменная ARRAY, начиная с нуля
-d delim продолжается до тех пор, пока не будет прочитан первый символ DELIM, а не
, чем новая строка
-e используйте Readline для строка в интерактивной оболочке
-i text использовать ТЕКСТ в качестве начального текста для Readline
-n nchars return после чтения символов NCHARS вместо ожидания
для новой строки, но соблюдайте разделитель, если меньше

символов

NCHARS читается до delimiter
-N nchars возвращаются только после чтения точно NCHARS символов, если не встречается
EOF или время чтения не истекает, игнорируя любой разделитель

-p выводит строку PROMPT без завершающей новой строки до
попытка чтения
-r не разрешает обратная косая черта для экранирования любых символов
-s не отображает ввод, поступающий с терминала
-t тайм-аут тайм-аут и возвращает ошибку, если полная строка из 9 Вход 0002 не считывается в течение TIMEOUT секунд.Значение переменной
TMOUT — это тайм-аут по умолчанию. TIMEOUT может быть дробным числом
. Если TIMEOUT равен 0, чтение немедленно возвращает
, не пытаясь прочитать какие-либо данные, возвращая
успеха, только если входные данные доступны для указанного файлового дескриптора
. Статус выхода больше 128
, если превышен тайм-аут
-u fd читать из файлового дескриптора FD вместо стандартного ввода

Статус выхода:
Код возврата равен нулю, если не встречается конец файла, время чтения out
(в этом случае больше 128), ошибка присвоения переменной

Перехват пользовательского ввода

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

Захват строки ввода

Чтобы поймать строку ввода ИМЕНИ и параметры не требуются при чтении. Если NAME не указано, переменная с именем REPLY используется для хранения пользовательского ввода.

Команды

{
echo -n «Введите что-нибудь и нажмите Enter:»;
прочитано;
echo Вы набрали $ {REPLY}
}

Выход

Введите что-нибудь и нажмите Enter: something (новая строка)
Вы что-то набрали

Получение слова ввода

Чтобы поймать слово ввода, требуется опция -d.В случае слова мы бы установили -d на пробел, читаем «-d». То есть, когда пользователь нажимает пробел, чтение загрузит ОТВЕТ со словом.

Обратите внимание, что если задана опция -d, возврат не работает должным образом. Чтобы вернуться на место при попытке поймать слово ввода, можно использовать параметр -e, читаем -e ‘-d‘.

Команды

{
echo -n «Введите что-нибудь и нажмите пробел:»;
читать «-d»;
эхо «»;
echo «Вы набрали $ {REPLY}»
}

Выход

Введите что-нибудь и нажмите пробел: something (пробел)
Вы что-то набрали

Подсказка

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

Запрашивать слово у пользователя

При перехвате слова ввода мы использовали echo для записи Type something и нажимали пробел: на стандартный вывод перед чтением ‘-d‘. Параметр -p позволяет отображать сообщение перед чтением со стандартного ввода.

Команды

{
read -p ‘Введите что-нибудь и нажмите пробел:’ ‘-d’;
эхо «»;
echo «Вы набрали $ {REPLY}»
}

Выход

Введите что-нибудь и нажмите пробел: something (пробел)
Вы что-то набрали

Подсказка пользователя секрет

При перехвате пользовательского ввода без его отображения в терминале пригодится опция -s.read -s -p позволяет вам уловить и скрыть ввод пользователя следующим образом.

Команды

{
read -s -p ‘Введите то, что я обещаю сохранить в секрете:’
echo «»;
echo «Твоя тайна со мной в безопасности»; отключить ОТВЕТ;
эхо «$ {REPLY}»
}

Выход

Введите слово, которое я обещаю сохранить в секрете:
Ваш секрет в безопасности

Функции с использованием чтения

Вот примеры функций в bash, которые используют чтение и стандартный ввод

Основная концепция

Функции, использующие чтение, используют стандартный ввод данных и параметры.Основной ввод, который должен быть обработан, например строки в файле, передаются через стандартный ввод через конвейер. Другой входной параметр if-any и option передаются как параметры.

чтение -t 1 ИМЯ1 ИМЯ2 …

чтение — встроенная команда

-t 1 запрещает сценарию bash бесконечно ждать возврата строки через стандартный ввод. Если стандартный ввод изначально пуст, функция возвращается с кодом выхода 142, означающим, что в течение установленного периода ожидания

дата не была прочитана.

ИМЯ1 ИМЯ2 — имена переменных

… может быть указано много имен переменных

Теперь, когда основа заложена, давайте посмотрим, как выглядят знакомые функции, реализованные с помощью read.

Функция соединения с использованием чтения

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

Скрипт

#! / Bin / bash
## join
## версия 0.0.2 — исправить параметры рекурсии
####################### #########################
join () {{локальный неограничитель; indelimiter = «$ {1-}»; локальный перехватчик;
outdelimiter = «$ {2-.} «;}
локальный автомобиль
локальный CDR
локальный IFS
IFS =» $ {indelimiter} «
read -t 1 car cdr || return
test» $ {cdr} «|| {echo» $ {car} » ; return;}
echo «$ {car} $ {outdelimiter} $ {cdr}» | $ {FUNCNAME} «$ {indelimiter}»
«$ {outdelimiter}»
}
######### ######################################
## сгенерировано create-stub2. sh v0.1.2
## в понедельник, 17 июня 2019 г. 12:24:59 +0900
## см.
############ ####################################

Источник: присоединиться.sh
Командная строка

Выход

Командная строка

эхо а б | присоединиться | присоединиться . \ |

Выход

Функции карты с использованием чтения

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

Скрипт

#! / Bin / bash
## map
## версия 0.0,1 — исходный
######################################################################## ####
map () {{local function_name; function_name = «$ {1}»; }
локальный автомобиль
локальный CDR
локальный IFS
IFS = «$ {indelimiter-}»
read -t 1 car CDR || return
test «$ (declare -f $ {function_name})» || return
test «$ {car}» || { правда ; возвращение ; }
$ {function_name} $ {car}
echo «$ {cdr}» | $ {FUNCNAME} «$ {function_name}»
}
########################################################################### #############
## сгенерировано create-stub2.sh v0.1.2
## вт, 18 июня 2019 г. 08:33:49 +0900
## см.
############ ####################################

Источник: map.sh
Команды

pow () {местный -i i = $ {1}; эхо $ ((я ** 2)); }
echo {1..10} | карта pow

Выход

Функция фильтрации с использованием чтения

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

Скрипт

#! / Bin / bash
## filter
## версия 0.0.1 — исходный
######################### #######################
filter () {{local function_name; function_name = «$ {1}»; }
локальный автомобиль
локальный CDR
локальный IFS
IFS = «$ {indelimiter-}»
read -t 1 car CDR || return
test «$ (declare -f $ {function_name})» || return
test «$ {car}» || { правда ; возвращение ; }
$ {function_name} «$ {car}» || echo -n «$ {car}»
echo «$ {cdr}» | $ {FUNCNAME} «$ {function_name}»
}
########################################################################### #############
## сгенерировано create-stub2.sh v0.1.2
## вт, 18 июня 2019 13:19:54 +0900
## см.
############ ####################################

Источник: filter.sh

Команды

odd () {местный -i i = $ {1}; контрольная работа ! $ ((i% 2)) -экв 1; }
echo {1..10} | фильтр нечетный

Выход

Циклы с использованием чтения

Циклы с использованием чтения позволяют вам перебирать строки файла, который должен быть сгенерирован или уже существует.

Базовый цикл при чтении для левой стороны (lhs)

У нас есть команда или функция (lhs), которая может генерировать строки в файле, которые можно перебирать с помощью цикла чтения и цикла while.

Construct

л / с | while read
do
true
done
lhs — это команда, которая возвращает список строк

Команды

seq 5 | во время чтения i
do
echo $ {i}
done

Выход

Базовый цикл при чтении для правой стороны (правая сторона)

У нас есть файл (rhs) со строками, которые можно прокручивать, используя цикл чтения и while.

Construct

while read
do
true
done
rhs — файл, содержащий строки

Команды

seq 5> rhs
при чтении i
do
echo $ {i}
done
Output

1
2
3
4
5

Пользовательский левый экран в цикле с использованием чтения

У нас есть поток слов, который мы хотели бы перебрать, используя read.

Construct

(
IFS = «»
lhs | при чтении
do
true
done
)

lhs — это список слов

Команды

(
IFS = «»
эхо {1..5} | во время чтения i
do
echo «$ {i}
done
)

Выход

Чтение с любого fd вместо стандартного ввода

Встроенная опция чтения, часто остающаяся нетронутой, — это та, которая позволяет вам указать, из какого файлового дескриптора читать, read -u FD. По умолчанию FD принимается за стандартный ввод.

Основная концепция

Когда открытому файлу присваиваются дескрипторы файла. Перенаправление ввода-вывода в bash позволяет оставить файл открытым с определенным файловым дескриптором.Нам разрешено записывать в файл, читать из него и закрывать его, когда мы закончим.

_ ()
{
cat / dev / null> myfifo; # пусто myfifo
exec 3 echo «Hello, World! — from fd 3″> myfifo; # записать в myfifo
read -u 3; # читать строку из fd 3
exec 3> & -; # close fd 3
echo $ {REPLY} # строка вывода считывается из fd 3 перед закрытием
}
_ # Hello, World! с фд 3

Создание поезда с файловыми дескрипторами и чтение -u FD

Ради интереса решил собрать шлейф с файловыми дескрипторами и прочитать -u FD.Каждому файловому дескриптору написан номер. Каждый файловый дескриптор читает из файлового дескриптора 1 ниже и присоединяется к себе.

Командная строка

bash linuxhint.com/build/test-read-fd.sh поезд 10

Выход

инициализация fds …
инициализация fd 3 …
fd 3 инициализация
инициализация fd 4 …
fd 4 инициализация
fds инициализация
чтение из fd 3 и 4 …
4 3
fds перед очисткой
0 1 2 3 4 5
уборка…
очистка fds …
завершена очистка fds
fds после очистки
0 1 2 3

Функция пропуска с использованием read -u FD

Если вы используете

uname -a
MINGW64_NT-10.0 DESKTOP-XVVVVVV 2.7.0 (0.307 / 5/3)
17.02.2017 14:20 x86_64 Msys
bash —version
GNU bash, версия 4.4.12 (1) -release (x86_64-pc-msys)

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

uname -a
Linux 4.9.0-8-amd64 # 1 SMP Debian 4.9.144-3.1 (2019-02-19) x86_64 GNU / Linux
bash —version
GNU bash, версия 4.4.12 (1) — релиз (x86_64-pc-linux-gnu)

скип не слетает.

Функция

skip () {read -u 31; }

Команды

пропустить
эхо-линия пропущена
истинно

Выход

Итог

Встроенная функция чтения в bash не просто улавливает ввод пользователя.Его можно использовать в функциях, циклах и обмене между файловыми дескрипторами, используемыми в сценариях bash. Иногда исследование с использованием дескрипторов чтения и файлов может дать пасхальные яйца.

.

Примеры команд чтения сценария Bash

Команда чтения

Примеры команд чтения Bash

Получение ввода от команды чтения

Команда чтения — это встроенная функция, которая позволяет сценариям интерактивно перехватывать информацию, введенную пользователями. Базовый синтаксис команды «чтение» следующий:

чтение [параметры] VAR1 VAR2 …. VARN

Команда чтения используется для получения строки ввода в переменную.Каждый аргумент должен быть именем переменной без символа «$» в начале. Встроенная команда считывает строку ввода и разделяет строку на отдельные слова с помощью разделителя полей « IFS ». (см. IFS. По умолчанию для «IFS» используется пробел. Каждое слово в строке сохраняется в переменной слева направо. Первое слово сохраняется в первой переменной, второе слово — во второй переменной и т. д. on. Если переменных меньше, чем слов, тогда все оставшиеся слова присваиваются последней переменной.Если у вас больше переменных, чем определено слов, то любые лишние переменные устанавливаются в значение null. Если в строке чтения не указаны имена переменных, то при чтении используется переменная по умолчанию REPLY.

читать пример

  
#! / bin / bash
#
читать первый средний последний
echo "Привет, $ первый, $ средний, $ последний"
   

Вывод из приведенного выше примера чтения

  
john @ john-desktop: ~ / scripts $ ./read1.sh
земля Linux
Привет, земля Linux
   

В приведенном выше примере «чтения» мы передали значения «land», «of» и «linux» в переменные «first», «middle» и «last».Затем они отображаются с помощью команды echo.

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

читать пример

  
#! / bin / bash
#
echo "Введите 3 слова и нажмите ENTER:"
читать первый средний последний
echo "Привет, $ первый, $ средний, $ последний"
   

Вывод из приведенного выше примера чтения

  
john @ john-desktop: ~ / scripts $./read2.sh
Введите 3 слова и нажмите ENTER:
земля Linux
Привет, земля Linux
   

Мы также можем использовать флаг « -p » с командой чтения:



читать -p пример

читать -p пример

  
#! / bin / bash
#
read -p "Пожалуйста, введите 3 слова, а затем нажмите ENTER:" первое среднее последнее
echo "Привет, $ первый, $ средний, $ последний"
   

Вывод из приведенного выше примера чтения -p

  
john @ john-desktop: ~ / scripts $./read3.sh
Пожалуйста, введите 3 слова и нажмите ENTER: land of linux
Привет, земля Linux
   

В приведенном выше примере мы используем переменные first, middle и last после нашего приглашения. Мы всегда можем разделить приглашение на несколько строк следующим образом:

read -p example

  
#! / bin / bash
#
read -p "Сначала введите первое слово, а затем нажмите ENTER:"
read -p "Пожалуйста, введите второе слово и нажмите ENTER:" средний
read -p "Пожалуйста, введите последнее слово, а затем нажмите ENTER:" последний
echo "Привет, $ первый, $ средний, $ последний"
   

Вывод из приведенного выше примера чтения -p

  
john @ john-desktop: ~ / scripts $./read4.sh
Пожалуйста, введите первое слово и нажмите ENTER: земля
Пожалуйста, введите второе слово и нажмите ENTER: из
Пожалуйста, введите последнее слово и нажмите ENTER: linux
Привет, земля Linux
   

читать пример — поймать все

Иногда слов может быть больше, чем определенных переменных. Это обрабатывается просто тем, что все лишние слова записываются в последнюю определенную нами переменную:

read -p example

  
#! / bin / bash
#
read -p "Пожалуйста, введите несколько слов и нажмите ENTER:" vara varb varc
echo "вара содержит $ вара"
echo "varb содержит $ varb"
echo "varc содержит все оставшиеся слова $ varc"
   

Вывод из приведенного выше примера чтения -p

  
john @ john-desktop: ~ / scripts $./read5.sh
Пожалуйста, введите несколько слов и нажмите ENTER: один два три четыре пять шесть
вара содержит один
varb содержит два
varc содержит оставшиеся слова три четыре пять шесть
   

Как мы можем видеть в приведенном выше примере, значения «один» и «два» были присвоены переменным «vara» и «varb». Остающийся вход был назначен единственной переменной «varc». Переменная «varc» содержит «три четыре пять шесть».


Опции, доступные для команды чтения

Ниже представлена ​​таблица, содержащая другие параметры, которые можно использовать со встроенной командой чтения:


Чтение
Опция Описание
-a ANAME Слова назначаются последовательно переменной массива ANAME
-d DELIM Первый символ DELIM используется для завершения строки ввода
-e строка чтения используется для получения строки
-n NCHARS чтение возвращается после чтения NCHARS
-п ЗАПРОС Отобразить PROMPT без символа новой строки в конце.Подсказка отображается только при поступлении с терминала.
-r Обратная косая черта не действует как escape-символ
Бесшумный режим. Персонажи не отображаются с терминала
-t ТАЙМ-АУТ завершится по таймауту через TIMEOUT секунд.Только с Терминала
-u FD читать ввод из файлового дескриптора FD

.

Как читать файл построчно в сценарии Bash — Linux Hint

Как бы вы написали сценарий Bash, который может обрабатывать текстовый файл по одной строке за раз. Сначала вам нужен синтаксис и подход к чтению файла построчно. Методы этого подхода показаны в этом руководстве.

Предположим, у вас есть файл с именем company.txt , который содержит названия компаний. Этот файл содержит следующее содержимое.

Company.txt
Samsung
Nokia
LG
Symphony
iphone

Пример -1: чтение содержимого файла из командной строки

Предположим, вы хотите прочитать файл компании .txt , построчно из командной строки без команды ‘cat’ . Выполните следующую команду, чтобы выполнить задачу. , а цикл будет читать каждую строку из файла company.txt на каждом шаге и сохранять содержимое строки в переменной $ line , которая будет напечатана позже.

$ при чтении строки; сделать echo $ line; done

Пример -2: Чтение содержимого файла с помощью скрипта

Создайте файл bash и добавьте следующий код для чтения содержимого определенного файла.Здесь существующее имя файла сохраняется в переменной $ filename , а переменная $ n используется для хранения значения номера строки этого файла. Как и в предыдущем примере, цикл и используется для чтения этого файла с номером строки.

#! / Bin / bash
filename = ‘company.txt’
n = 1
при чтении строки; do
# чтение каждой строки
echo «Line No. $ n: $ line»
n = $ ((n + 1))
done <$ filename

Выполните следующую команду, чтобы выполнить сценарий.

Запустите команду ‘cat’ с файлом company.txt , чтобы отобразить исходное содержимое файла company.txt .

Пример -3: Передача имени файла из командной строки и чтение файла

Создайте файл bash и добавьте следующий сценарий. Этот сценарий берет имя файла из аргумента командной строки. Значение первого аргумента считывается переменной $ 1, которая будет содержать имя файла для чтения. Если файл существует в текущем местоположении, тогда цикл , а будет читать файл построчно, как в предыдущем примере, и печатать содержимое файла.

#! / Bin / bash
filename = $ 1
при чтении строки; do
# чтение каждой строки
echo $ line
done <$ filename

Запустите приведенный выше сценарий с файлом employee.txt в качестве значения аргумента. Выходные данные покажут содержимое файла employee.txt , удалив лишнее пространство. Вы можете показать исходное содержимое файла employee.txt с помощью команды «cat» .

$ bash readfile2.txt employee.txt
$ cat employee.txt

Пример — 4: Чтение файла без экранирования обратной косой черты

Если вы хотите прочитать каждую строку файла, опуская обратную косую черту, тогда вам нужно использовать опцию ‘-r’ с командой чтения в в цикле .

#! / Bin / bash
при чтении -r строка; do
# Чтение каждой строки
echo $ line
done

Создайте файл с именем company2.txt с обратной косой чертой и выполните следующую команду для выполнения сценария. На выходе будет показано содержимое файла без обратной косой черты.

Вам потребуется прочитать файл для многих целей программирования. Например, вы можете легко найти или сопоставить любой конкретный контент из любого файла, прочитав каждую строку отдельно.Так что это важная задача для любого программирования. В этом руководстве показаны несколько простых примеров чтения файла в сценарии bash. Это поможет вам получить представление о чтении содержимого файла построчно с помощью цикла while в сценарии bash и более эффективно применять его в сценарии. Для получения дополнительной информации смотрите видео!

.

читать справочную страницу — Linux

читать справочную страницу — Linux — SS64.com

Прочитать одну строку из стандартного ввода (или из файла) и присвоить слово (слова) имени (именам) переменной.

 Синтаксис
      читать [-ers] [-a  aname ] [-d  delim ] [-i  text ] [-n  nchars ]
         [-N  nchars ] [-p  prompt ] [-r] [-s] [-t  timeout ] [-u  fd ]
            [ название  ...]

Ключ
   -a  aname  
слов назначаются последовательным индексам переменной массива aname , начиная с 0.
aname сбрасывается до присвоения новых значений. Другие аргументы имени игнорируются.

-d delim
Первый символ delim используется для завершения строки ввода, а не новой строки.
-e Если стандартный ввод поступает с терминала, для получения строки используется строка чтения. -i текст Если для чтения строки используется строка чтения, текст помещается в буфер редактирования перед началом редактирования.
-n nchars
чтение возвращается после чтения nchars символов вместо ожидания полной строки ввода.-N nchars чтение возвращается после прочтения ровно символов символов, а не ожидания полной строки ввода, если не встречается EOF или не истекло время чтения. Символы-разделители встречаются в входные данные не обрабатываются особым образом и не вызывают возврата при чтении до тех пор, пока не будет прочитано символов символов.
-p prompt
Отобразить подсказку при стандартной ошибке без символа новой строки перед попыткой чтения
любого ввода.Подсказка отображается, только если ввод поступает с терминала.
-r Обратная косая черта не действует как escape-символ. Обратная косая черта считается частью
строки. В частности, пара обратной косой черты и новой строки не может использоваться в качестве продолжения строки.

-s Бесшумный режим. Если ввод поступает с терминала, символы не отображаются.
-t timeout
Причина, по которой чтение завершается по тайм-ауту и ​​возвращает ошибку, если вся строка ввода не читается
в течение timeout секунд.Этот параметр не действует, если чтение не считывает ввод от
терминала или канала.
-u fd Чтение ввода из файлового дескриптора fd .

Это встроенная оболочка BASH для отображения вашего локального синтаксиса из типа приглашения bash: help [r] ead

Одна строка считывается из стандартного ввода, и первое слово присваивается первому имени , второму слово ко второму имени и так далее, с оставшимися словами и их промежуточными разделителями, назначенными последнему имени .

Если из стандартного ввода было прочитано меньше слов, чем имен, оставшимся амям присваиваются пустые значения.
Символы в значении переменной IFS используются для разделения строки на слова.

Символ обратной косой черты ‘\’ может использоваться для удаления любого специального значения для следующего считываемого символа и для продолжения строки.
Если имена не указаны, прочитанная строка присваивается переменной REPLY .

Код возврата равен нулю, если не обнаружен конец файла или читает время вышло.

Примеры

#! / Bin / bash
читать var_year
echo «Год: $ var_year»

echo -n «Введите свое имя и нажмите [ENTER]:»
читать var_name
echo «Ваше имя: $ var_name»

$ читать
$ echo Вы ввели $ REPLY

«Программы предназначены для чтения людьми и только случайно для выполнения компьютерами» ~ Дональд Кнут

Связанные команды linux:

mapfile — считывает строки из стандартного ввода в переменную индексированного массива.
select — Принять ввод с клавиатуры.
Эквивалентные команды Windows: SET / P — запрос на ввод данных пользователем.


Авторские права © 1999-2020 SS64.com
Некоторые права защищены.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *