Знакомство с текстовыми утилитами UNIX

Использование стандартных утилит операционной системы для работы с текстом

Эта статья познакомит вас с основами работы с текстом в UNIX. В ней приводится обзор наиболее распространенных стандартных команд, имеющихся в большинстве систем семейства UNIX. Часто пользователи игнорируют эти стандартные команды, отдавая предпочтение установленным в системе более современным средствам работы с текстом, таким как Perl, Python или Ruby. Эта обзорная статья будет полезна тем, кто использует или изучает UNIX/Linux, а также всем желающим обновить свои знания об этих операционных системах.

Брэд Йос, инженер по миграции, IBM

Брэд Йос (Brad Yoes) – инженер по миграции в корпорации IBM. Начав работать с UNIX в 1993 году, Брэд имеет 15-летний опыт в области миграции приложений. Свободное время посвящает своей семье, чтению документальной литературы и бегу трусцой.



16.04.2013

Введение

Основная философия UNIX заключается в том, чтобы создавать программы (или процессы), которые умеют делать только одну вещь, но делают ее отлично. Эта философия требует тщательного подхода к разработке интерфейсов и способов объединения этих мелких (и, хочется надеяться, более простых) процессов для получения требуемых результатов. Обычно между этими интерфейсами передаются текстовые данные. Со временем было разработано множество продвинутых текстовых редакторов и языков. Что касается языков, то сначала это был perl, позже появились python и ruby. Хотя эти и другие языки являются достаточно мощными инструментами обработки текста, они не всегда доступны, особенно в производственной среде. В этой статье будет рассмотрен ряд базовых команд UNIX для работы с текстом, а также будет продемонстрировано на примерах, как можно использовать их по отдельности и в связке для решения различных задач, которые также могут быть решены с помощью современных языков. Многим читателям будет проще ознакомиться с этими командами на конкретных примерах, чем из теоретических рассуждений. Не забывайте, что работа, набор доступных опций и вывод этих команд в различных UNIX-подобных операционных системах могут различаться.


Команда cat

Команда cat – одна из самых простых команд. Она используется для создания и объединения файлов, а также для добавления и просмотра их содержимого.

Можно создать файл с помощью команды cat и оператора '>', который перенаправляет стандартный ввод (stdin) в файл. При использовании оператора '>' содержимое указанного конечного файла замещается новым содержимым. Текст, вводимый после этой конструкции, перенаправляется в файл, указанный справа после оператора '> '. Управляющие сигналы ctrl-d и end-of-file возвращают пользователя в командную оболочку.

Пример создания файла с помощью команды cat:
$ cat > grocery.list
apples
bananas
plums
<ctrl-d>
$

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

Пример добавления текста в файл с помощью команды cat:
$ cat >> grocery.list
carrots
<ctrl-d>

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

Пример выполнения команды cat без флагов:
$ cat grocery.list
apples
bananas
plums
carrots

Команду cat можно использовать для нумерации строк в файле.

Пример нумерации строк с помощью команды cat:
$ cat -n grocery.list
     1  apples
     2  bananas
     3  plums
     4  carrots

Команда nl

Команда nl отфильтровывает строки, считываемые с устройства stdin или из указанного файла. Результаты записываются в устройство stdout и могут быть перенаправлены в файл или на вход другого процесса. Работа nl определяется различными опциями командной строки.

По умолчанию команда nl выполняет нумерацию строк, что соответствует запуску команды cat -n.

Пример использования команды nl по умолчанию:
$nl grocery.list
     1  apples
     2  bananas
     3  plums
     4  carrots

Для нумерации только определенных строк используйте опцию -b. После этой опции указываются аргумент "тип". Этот тип сообщает команде nl, какие строки должны быть пронумерованы: 'a' – нумеровать все строки, 't' – не нумеровать пустые строки либо строки, состоящие только из пробельных символов, 'n' – не нумеровать никакие строки. В нашем примере был указан тип 'p' (т. е. pattern – шаблон). При использовании этого типа команда nl нумерует строки на основе заданного регулярного выражения, в приведенном ниже примере – все строки, начинающиеся с символов 'a' и 'b'.

Пример нумерации строк на основе регулярного выражения с помощью команды nl:
$ nl -b p^[ba] grocery.list
     1  apples
     2  bananas
       plums
       carrots

По умолчанию команда nl отделяет номера строк от их содержимого символом табуляции. Для указания другого разделителя (например, знака '=') используйте опцию -s.

Пример указания разделителя в команде nl:
$nl –s= grocery.list
     1=apples
     2=bananas
     3=plums
     4=carrots

Команда wc

Команда wc (wordcount – подсчет слов) определяет количество строк, слов (разделенных пробелами) и символов, содержащихся в указанных файлах или в данных, получаемых с устройства stdin.

Пример использования команды wc:
$wc grocery.list
       4       4      29 grocery.list
$wc -l grocery.list
       4 grocery.list
$wc -w grocery.list
       4 grocery.list
$wc -c grocery.list
      29 grocery.list

Команда grep

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

Для демонстрации работы этой команды мы создадим новый файл в дополнение к файлу grocery.list.

$cat grocery.list2
Apple Sauce
wild rice
black beans
kidney beans
dry apples
Пример простого использования команды grep:
$ grep apple grocery.list grocery.list2
grocery.list:apples
grocery.list2:dry apples

Команда grep имеет внушительное количество опций. Примеры использования некоторых из них представлены ниже.

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

Команда grep – подсчет количества совпадений в файлах:
$ grep -c apple grocery.list grocery.list2
grocery.list:1
grocery.list2:1

При поиске совпадений в нескольких файлах можно использовать опцию –h, которая подавляет вывод имен файлов.

Команда grep – скрытие имени файла в выводе:
$ grep -h apple grocery.list grocery.list2
apples
dry apples

Во многих случаях требуется выполнять поиск совпадений без учета регистра символов. Для отключения чувствительности к регистру используйте опцию -i.

Команда grep – отключение чувствительности к регистру
$ grep -i apple grocery.list grocery.list2

grocery.list:apples
grocery.list2:Apple Sauce
grocery.list2:dry apples

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

Команда grep – вывод только имен файлов:
$ grep -l carrot grocery.list grocery.list2
grocery.list

Можно сделать так, что в выводе будут содержаться номера строк. Для этого предназначена опция -n.

Команда grep – вывод, содержащий номера строк:
$ grep -n carrot grocery.list grocery.list2
grocery.list:4:carrots

При необходимости можно вывести строки, которые, наоборот, не содержат совпадений. Это делается при помощи опции -v.

Команда grep – поиск несовпадений:
$ grep -v beans grocery.list2
Apple Sauce
wild rice
dry apples

Иногда искомый шаблон может представлять собой "слово", т. е. группу символов, ограниченную пробелами или другими символами – например, подчеркиваниями или скобками. В большинстве версий команды grep имеется опция -w, упрощающая написание таких поисковых запросов.

Команда grep – вывод совпадений по словам:
$ grep -w apples grocery.list grocery.list2
grocery.list:apples
grocery.list2:dry apples

Потоки, конвейеры, перенаправления, команда tee и синтаксис here docs

По умолчанию терминал UNIX содержит три потока – один для ввода данных и два – для вывода. Поток ввода называется stdin и обычно связан с клавиатурой (также можно использовать другие устройства ввода или получить поток ввода из другого процесса). Стандартное устройство вывода называется stdout и обычно выводит данные на терминал; также может направлять данные на вход других процессов (в качестве потока stdin). Другой поток вывода называется stderr и используется в основном для вывода уведомлений на терминал (так же, как и stdout). Каждый из этих потоков имеет свой собственный файловый дескриптор и может быть перенаправлен отдельно от остальных потоков, даже если все они связаны с терминалом. Этим потокам соответствуют следующие файловые дескрипторы:

  • stdin = 0
  • stdout = 1
  • stderr = 2

Потоки можно перенаправлять в файлы или передавать на вход другим процессам (т. н. конвейер). Рассмотрим пример, когда, например, программисту требуется объединить потоки stdout и stderr, а затем вывести их на терминал и одновременно сохранить результаты в файл для последующего анализа. Конструкция 2>&1 перенаправляет поток stderr с файловым дескриптором 2 на устройство &1, являющееся 'указателем' на поток stdout. Оператор '|' создает конвейер (pipe). Конвейер соединяет поток stdout процесса из левой части (в следующем примере это команда make) с потоком stdin процесса из правой части (tee). Команда tee дублирует (объединенный) поток stdout, посылая данные и на терминал, и в файл build.log.

Пример объединения и разделения стандартных потоков:
$ make –f build_example.mk 2>&1 | tee build.log

Рассмотрим еще один пример – создание копии текстового файла с помощью команды cat и перенаправления потока.

Пример перенаправления для создания резервного файла:
$ cat < grocery.list > grocery.list.bak

Мы уже показывали, как с помощью команды nl, добавить номера строк в файл, выводимый на устройство stdout. Чтобы передать поток stdout (получаемый от команды cat grocery.list) другому процессу (команде nl), можно использовать конвейер.

Пример простого конвейера с использованием команды nl:
$ cat grocery.list | nl
     1  apples
     2  bananas
     3  plums
     4  carrots

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

Пример сомандрй grep – конвейером и перенаправлением с устройства stdin:
$ grep -i apple < grocery.list2
Apple Sauce
dry apples
$cat grocery.list2 | grep -i apple
Apple Sauce
dry apples

Иногда текстовый блок может передаваться в команду или файл как часть сценария. Для этого используется механизм под названием 'here document', или 'here-doc'. Для того чтобы включить фрагмент here-doc в сценарий, используется оператор ' << ', перенаправляющий весь последующий текст вплоть до завершающей метки. Эта метка указывается после оператора <<.

Пример простого использования синтаксиса here-doc в командной строке:
$ cat << EOF
> oranges
> mangos
> pinapples
> EOF
oranges
mangos
pinapples

В следующем примере показано, как перенаправить этот вывод в файл; здесь вместо завершающей метки 'EOF' используется метка '!'. Команда tr (она будет рассмотрена позже) переводит текст, содержащийся в блоке here-doc, в верхний регистр.

Пример простого использования синтаксиса here-doc с перенаправлением в файл:
cat << ! > grocery.list3
oranges
mangos
pinapples
!
$ cat grocery.list3
oranges
mangos
pinapples
$tr [:lower:] [:upper:] << !
> onions
> !
ONIONS

Команды head и tail

Команды head и tail предназначены для просмотра верхней (head) и нижней (tail) частей файла. Чтобы просмотреть содержимое двух первых или двух последних строк файла, выполните соответствующие команды с опцией–n. Аналогично, опция –c позволяет просматривать первые или последние символы в файле.

Пример простого использования команд head и tail:
$ head -n2 grocery.list
apples
bananas
$ tail -n2 grocery.list
plums
carrots
$ head -c12 grocery.list
apples
banan
$ tail -c12 grocery.list
ums
carrots

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


Команда tr

Команда tr переводит символы из потока stdin и выводит их в поток stdout. В общем виде команда tr работает с двумя наборами символов и замещает символы из первого набора символами из второго набора. Команда tr и некоторые другие команды работают с рядом предопределенных классов (наборов) символов.

Вот эти классы:

  • alnum – алфавитно-цифровые символы
  • alpha – алфавитные символы
  • blank – пробельные символы
  • cntrl – управляющие символы
  • digit – цифровые символы
  • graph – графические символы
  • lower – алфавитные символы нижнего регистра
  • print – печатные символы
  • punct – знаки пунктуации
  • space – символы пробела
  • upper – символы верхнего регистра
  • xdigit – шестнадцатеричные цифры

Команда tr может преобразовывать символы из нижнего регистра в верхний.

Пример команды tr – преобразование строки в верхний регистр:
$ echo "Who is the standard text editor?" |tr [:lower:] [:upper:]
WHO IS THE STANDARD TEXT EDITOR?

Команду tr можно также использовать для удаления из строки указанных символов.

Пример команды tr – удаление символов из строки:
$ echo 'ed, of course!' |tr -d aeiou
d, f crs!

Далее, команду tr можно использовать для замены любых указанных символов знаками пробела. Если несколько указанных символов образуют последовательность, то они заменяются одним знаком пробела.

В разных операционных системах опция –s работает по-разному.

Пример команды tr – замена символов знаками пробела:
$ echo 'The ed utility is the standard text editor.' |tr -s astu ' '
The ed ili y i he nd rd ex edi or.

Опцию –s можно использовать для удаления лишних символов пробелов из строки.

$ echo 'extra     spaces – 5’ | tr -s [:blank:]
extra spaces - 5
$ echo ‘extra		tabs – 2’ | tr -s [:blank:]
extra   tabs – 2

Распространенной проблемой при совместной работе с файлами в UNIX и Windows являются разделители строк. В UNIX разделитель представляет собой символ новой строки, тогда как в Windows задействовано два символа – возврат каретки и последующий символ новой строки. Эта проблема форматирования решается с помощью команды tr и перенаправления.

Пример команды tr – удаление символов возврата каретки:
$ tr -d '\r' < dosfile.txt > unixfile.txt

Команда colrm

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

Пример удаления столбцов с помощью команды colrm:
$ cat grocery.list |colrm 4
app
ban
plu
car
$ cat grocery.list |colrm 4 5
apps
banas
plu
carts

Команды expand и unexpand

Команда expand заменяет символы табуляции символами пробела, а команда unexpand – наоборот. Эти команды принимают данные из потока stdin или из файлов, указанных в командной строке. Опция –t позволяет задавать одну или несколько позиций табуляции.

Пример использования команд expand и unexpand:
$ cat grocery.list|head -2|nl|nl
     1       1  apples
     2       2  bananas
$ cat grocery.list|head -2|nl|nl|expand -t 5
     1         1    apples
     2         2    bananas
$ cat grocery.list|head -2|nl|nl|expand -t 5,20
     1                   1 apples
     2                   2 bananas
$ cat grocery.list|head -2|nl|nl|expand -t 5,20|unexpand -t 1,5
                1                   1 apples
                2                   2 bananas

Команды comm, cmp и diff

Для демонстрации этих команд создадим два новых файла.

Создание файлов для последующих примеров:
cat << EOF > dummy_file1.dat
011 IBM 174.99
012 INTC 22.69
013 SAP 59.37
014 VMW 102.92
EOF
cat << EOF > dummy_file2.dat
011  IBM 174.99
012 INTC 22.78
013 SAP 59.37
014 vmw 102.92
EOF

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

Примеры использования команды diff:
$ diff dummy_file1.dat dummy_file2.dat
1,2c1,2
< 011 IBM 174.99
< 012 INTC 22.69
---
> 011  IBM 174.99
> 012 INTC 22.78
4c4
< 014 VMW 102.92
---
> 014 vmw 102.92

$ diff -w dummy_file1.dat dummy_file2.dat
2c2
< 012 INTC 22.69
---
> 012 INTC 22.78
4c4
< 014 VMW 102.92
---
> 014 vmw 102.92

$ diff -i dummy_file1.dat dummy_file2.dat
1,2c1,2
< 011 IBM 174.99
< 012 INTC 22.69
---
> 011  IBM 174.99
> 012 INTC 22.78

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

Пример использования команды comm:
$ comm dummy_file1.dat dummy_file2.dat
        011  IBM 174.99
011 IBM 174.99
012 INTC 22.69
        012 INTC 22.78
                013 SAP 59.37
014 VMW 102.92
        014 vmw 102.92

$ comm -12 dummy_file1.dat dummy_file2.dat
013 SAP 59.37

Команда cmp тоже сравнивает два файла, однако, в отличие от команд comm и diff, эта команда по умолчанию выводит номер байта и номер строки, содержащих отличия.

Пример использования команды cmp:
$ cmp dummy_file1.dat dummy_file2.dat
dummy_file1.dat dummy_file2.dat differ: char 5, line 1

Команда fold

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

Пример использования команды fold:
$ fold -w8 dummy_file1.dat
011 IBM
174.99
012 INTC
 22.69
013 SAP
59.37
014 VMW
102.92

Команда paste

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

Создание файлов для последующих примеров:
cat << EOF > dummy1.txt
IBM
INTC
SAP
VMW
EOF
cat << EOF > dummy2.txt
174.99
22.69
59.37
102.92
EOF
Команда paste, пример 1 – строки из нескольких файлов:
$ paste dummy1.txt dummy2.txt grocery.list
IBM     174.99  apples
INTC    22.69   bananas
SAP     59.37   plums
VMW     102.92  carrots

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

Команда paste, пример 2 – строки из нескольких файлов:
$ paste -s dummy1.txt dummy2.txt grocery.list
IBM     INTC    SAP     VMW
174.99  22.69   59.37   102.92
apples  bananas plums   carrots

Если указан только один файл или если командой paste обрабатывается поток stdin, то по умолчанию входные данные будут выведены в одном столбце. При использовании опции –s вывод будет сформирован в виде одной строки. Так как вывод представляет собой единственную строку, то для того чтобы отделить возвращаемые поля, используйте разделитель (по умолчанию используется символ табуляции). В следующем примере мы используем команду find для поиска директорий, которые могут содержать 64-разрядные библиотеки, а затем формируем путь для его добавления в качестве значения переменной $LD_LIBRARY_PATH.

Примеры команды paste с использованием разделителя:
$ find /usr -name lib64 -type d|paste -s -d:
/usr/lib/qt3/lib64:/usr/lib/debug/usr/lib64:/usr/X11R6/lib/X11/locale/lib64:/usr/X11R6/
lib64:/usr/lib64:/usr/local/ibm/gsk7_64/lib64:/usr/local/lib64

$ paste -d, dummy1.txt dummy2.txt
IBM,174.99
INTC,22.69
SAP,59.37
VMW,102.92

Команда bc

Если вам необходимо выполнить в командной оболочке простые математические вычисления, то обратите внимание на команду bc ("basic calculator" или "bench calculator" – простой калькулятор). Некоторые командные оболочки могут выполнять простые вычисления с помощью встроенных средств, а некоторые используют для этого программу expr. С помощью bc можно единообразно выполнять вычисления в любой командной оболочке или UNIX-системе – не забывайте только о расширениях различных производителей.

Пример использования команды bc – простые вычисления:
$ echo 2+3|bc
5

$ echo 3*3+2|bc
11

$ VAR1=$(echo 2^8|bc)
$ echo $VAR1
256

$ echo "(1+1)^8"|bc
256

Команда bc может выполнять и более сложные вычисления. Эта команда представляет собой интерпретатор со своими собственными и пользовательскими функциями, синтаксисом и управлением потоками данных, как в языках программирования. По умолчанию команда bc не использует десятичные знаки и округляет значения до целочисленных, но точность вывода можно повысить с помощью специальной опции scale. Как показывает следующий пример, команда bc может работать с очень большими числами и с очень высокой точностью. Для изменения основания системы счисления входных и выходных данных используются опции ibase и obase. В следующем примере выполняются следующие действия:

  • Опция obase изменяет основание системы счисления по умолчанию (десятичное) для выходных данных, преобразуя результат в шестнадцатеричное число.
  • Вычисляется квадратный корень из 2.
  • С помощью опции scale задается количество десятичных знаков.
  • Вычисляется значение 2 в степени 128 для демонстрации возможности работы с большими числами.
  • В командной оболочке ksh вычисляется и выводится процентная величина.
Пример использования команды bc – еще немного вычислений:
$ echo "obase=16; 2^8-1"|bc
FF

$ echo "99/70"|bc
1

$ echo "scale=20; 99/70"|bc
1.41428571428571428571

$ echo "scale=20;sqrt(2)"|bc
1.41421356237309504880

$ echo 2^128|bc
340282366920938463463374607431768211456

$ printf "Percentage: %2.2f%%\n" $(echo .9963*100|bc)
Percentage: 99.63%

Подробную информацию о команде bc, включая примеры, вы найдете на ее man-странице.


Команда split

Команда split полезна, когда нужно разбить большой файл данных на более мелкие для обработки. В следующем примере у нас имеется большой файл BigFile.dat, содержащий 165782 строки (это нам показывает команда wc). Опция -l указывает команде split, какое максимальное количество строк должен содержать каждый конечный файл. Команда split позволяет указывать префикс для имен конечных файлов (в следующем примере используется префикс BigFile_). С помощью других опций можно управлять суффиксами, а опция -p в системах семейства BSD позволяет разбивать файлы на части на основе регулярных выражений (как это делает команда csplit). Дополнительную информацию вы найдете на man-странице команды split.

Пример использования команды split:
$ wc BigFile.dat
165782  973580 42557440 BigFile.dat

$ split -l 15000 BigFile.dat BigFile_

$ wc BigFile*
  165782  973580 42557440 BigFile.dat
   15000   87835 3816746 BigFile_aa
   15000   88483 3837494 BigFile_ab
   15000   89071 3871589 BigFile_ac
   15000   88563 3877480 BigFile_ad
   15000   88229 3855486 BigFile_ae
    7514   43817 1908914 BigFile_af
  248296 1459578 63725149 total

Команда cut

Команда cut используется для 'обрезания' секций файлов или данных, получаемых из потока stdin, на основе столбцов. Эта команда урезает данные побайтно (опция -b), посимвольно (опция -c) или по списку указанных полей (опция -f). Список полей либо позиции байтов/символов указываются с помощью разделенных запятыми списков и дефисов. Если необходимо вывести только одно поле или позицию, просто укажите требуемый номер. С помощью дефиса можно указать диапазон полей; например аргумент 1-3 выводит поля (или позиции) с 1 по 3, аргумент -2 –данные от начала строки до поля (байта/символа) 2, а аргумент 3- – данные, начиная с поля (позиции) 3 до конца строки. Можно указать несколько полей через запятую. Из полезных опций можно выделить опции –d (задает разделитель полей) и –s (не выводит строки, не содержащие разделителей).

Примеры использования команды cut:
$ cat << EOF > dummy_cut.dat
# this is a data file
ID,Name,Score
13BA,John Smith,100
24BC,Mary Jones,95
34BR,Larry Jones,94
36FT,Joe Ruiz,93
40RM,Kay Smith,91
EOF

$ cat dummy_cut.dat |cut -d, -f1,3
# this is a data file
ID,Score
13BA,100
24BC,95
34BR,94
36FT,93
40RM,91

$ cat dummy_cut.dat |cut -b6-
s is a data file
me,Score
John Smith,100
Mary Jones,95
Larry Jones,94
Joe Ruiz,93
Kay Smith,91

$ cat dummy_cut.dat |cut -f1- -d, -s
ID,Name,Score
13BA,John Smith,100
24BC,Mary Jones,95
34BR,Larry Jones,94
36FT,Joe Ruiz,93
40RM,Kay Smith,91

Команда uniq

Как правило, команда uniq используется для удаления повторяющихся строк из входного файла или устройства stdin. Для правильной работы этой команды повторяющиеся строки должны располагаться во входном потоке друг за другом. Обычно входные данные команды uniq заранее отсортированы, поэтому данное условие выполняется. Часто используются две следующие опции команды uniq: -c (показывает, сколько раз повторялась каждая строка) и –d (выводит только повторяющиеся строки).

Примеры использования команды uniq:
$ cat << EOF > dummy_uniq.dat

13BAR   Smith   John    100
13BAR   Smith   John    100
24BC    Jone    Mary    95
34BRR   Jones   Larry   94
36FT    Ruiz    Joe     93
40REM   Smith   Kay     91
13BAR   Smith   John    100
99BAR   Smith   John    100
13XIV   Smith   Cindy   91


EOF

$ cat dummy_uniq.dat | uniq

13BAR   Smith   John    100
24BC    Jone    Mary    95
34BRR   Jones   Larry   94
36FT    Ruiz    Joe     93
40REM   Smith   Kay     91
13BAR   Smith   John    100
99BAR   Smith   John    100
13XIV   Smith   Cindy   91

$ cat dummy_uniq.dat | sort |uniq

13BAR   Smith   John    100
13XIV   Smith   Cindy   91
24BC    Jone    Mary    95
34BRR   Jones   Larry   94
36FT    Ruiz    Joe     93
40REM   Smith   Kay     91
99BAR   Smith   John    100

$ cat dummy_uniq.dat | sort |uniq -d

13BAR   Smith   John    100

$ cat dummy_uniq.dat | sort |uniq -c
   3
   3 13BAR   Smith   John    100
   1 13XIV   Smith   Cindy   91
   1 24BC    Jone    Mary    95
   1 34BRR   Jones   Larry   94
   1 36FT    Ruiz    Joe     93
   1 40REM   Smith   Kay     91
   1 99BAR   Smith   John    100

Команда sort

Команда sort используется для сортировки строк файла или потока stdin в определенной последовательности (например, в алфавитном или числовом порядке). На итоговый вывод команды sort и некоторых других команд могут влиять различные переменные среды, например, LC_ALL, LC_COLLATE или LANG. В следующем примере обратите внимание на то, как выводятся две отдельные повторяющиеся записи (строка, содержащая IBM, и пустая строка).

Пример команды sort – запуск по умолчанию:
$ cat << EOF > dummy_sort1.dat

014 VMW, 102.92
013 INTC, 22.69
012 sap,  59.37
011 IBM, 174.99
011 IBM, 174.99

EOF

$ sort dummy_sort1.dat


011 IBM, 174.99
011 IBM, 174.99
012 sap,  59.37
013 INTC, 22.69
014 VMW, 102.92

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

Пример команды sort – сортировка с выделением уникальных записей:
$ sort -u dummy_sort1.dat

011 IBM, 174.99
012 sap,  59.37
013 INTC, 22.69
014 VMW, 102.92

Иногда бывает нужна обратная сортировка. По умолчанию команда sort сортирует значения от меньшего к большему (при работе с числами) либо в алфавитном порядке (в случае символьной сортировки). Для выполнения обратной сортировки используйте опцию -r.

Пример команды sort – обратная сортировка:
$ sort -ru dummy_sort1.dat
014 VMW, 102.92
013 INTC, 22.69
012 sap,  59.37
011 IBM, 174.99

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

Пример команды sort – сортировка по ключу:
$ sort -k2 -u dummy_sort1.dat

011 IBM, 174.99
013 INTC, 22.69
014 VMW, 102.92
012 sap,  59.37

Если необходимо выполнить сортировку без учета регистра символов, используйте команду sort с опцией -f. Обратите внимание на то, что в следующем примере указано несколько опций; в некоторых версиях UNIX эти опции должны быть указаны в другом порядке.

Пример команды sort – сортировка без учета регистра:
$ sort -k2 -f -u dummy_sort1.dat

011 IBM, 174.99
013 INTC, 22.69
012 sap,  59.37
014 VMW, 102.92

До сих пор сортировка выполнялась в алфавитном порядке. Для сортировки в числовом порядке используется опция –n.

Пример команды sort – сортировка в числовом порядке:
$ sort -n -k3 -u dummy_sort1.dat

013 INTC, 22.69
012 sap,  59.37
014 VMW, 102.92
011 IBM, 174.99

Входные данные могут содержать разделители полей, отличные от пробельных символов. Чтобы задать символ-разделитель, отличный от используемого по умолчанию (например, запятую), используйте опцию –t.

Пример команды sort – сортировка по полю с использованием заданного разделителя:
$ sort -k2 -t"," -un dummy_sort1.dat

013 INTC, 22.69
012 sap,  59.37
014 VMW, 102.92
011 IBM, 174.99

Команда join

Те, кто имел дело с написанием запросов для баз данных, догадаются о предназначении команды join (объединить). Как и большинство команд UNIX, эта команда выводит данные на устройство stdout. Для "соединения" двух файлов их указанные поля сравниваются построчно. Если поля не указаны, то команда join сравнивает все поля, начиная от начала каждой строки. В качестве разделителя полей по умолчанию используются пробельные символы (в некоторых системах это либо одинарный пробел, либо несколько пробелов, расположенных подряд). Когда команда join находит совпадение полей, то для каждой пары строк в соответствующих файлах, содержащих это поле, выводится одна результирующая строка. Для получения правильных результатов оба файла должны быть отсортированы по сравниваемым полям. Реализация команды join может быть разной в разных системах.

Следующий пример демонстрирует соединение двух файлов по первому полю (вариант по умолчанию); используется опция –t, которая задает символ-разделитель, поля разделяются запятыми. С точки зрения оператора СУБД эта команда выполняет внутреннее соединение, выводя только строки, содержащие совпадения.

Пример команды join – использование разделителя полей, отличного от разделителя по умолчанию:
cat << EOF > dummy_join1.dat
011,IBM,Palmisano
012,INTC,Otellini
013,SAP,Snabe
014,VMW,Maritz
015,ORCL,Ellison
017,RHT,Whitehurst
EOF

cat << EOF > dummy_join2.dat
011,174.99,14.6
012,22.69,10.4
013,59.37,26.4
014,102.92,106.1
016,27.77,31.2
EOF

cat << EOF > dummy_join3.dat
IBM,Armonk
INTC,Santa Clara
SAP,Walldorf
VMW,Palo Alto
ORCL,Redwood City
EMC,Hopkinton
EOF

$ join -t, dummy_join1.dat dummy_join2.dat
011,IBM,Palmisano,174.99,14.6
012,INTC,Otellini,22.69,10.4
013,SAP,Snabe,59.37,26.4
014,VMW,Maritz,102.92,106.1

Для указания полей, по которым необходимо "соединять" файлы, можно использовать опцию -j[1,2] x (или просто -1 x или -2 x). Опция -j1 2 или -1 2 указывает на второе поле в файле 1 – первом файле, указанном в команде. В этом примере показано, как соединить файлы по полю 1 в первом файле и полю 2 во втором файле и вывести только совпадающие строки (внутреннее соединение).

Пример команды join – соединение по указанным полям:
$ join -t, -j1 1 -j2 2 dummy_join3.dat dummy_join1.dat
IBM,Armonk,011,Palmisano
INTC,Santa Clara,012,Otellini
SAP,Walldorf,013,Snabe
VMW,Palo Alto,014,Maritz
ORCL,Redwood City,015,Ellison

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

Пример команды join – левое внешнее соединение:
$ join -t, -a1 dummy_join1.dat dummy_join2.dat
011,IBM,Palmisano,174.99,14.6
012,INTC,Otellini,22.69,10.4
013,SAP,Snabe,59.37,26.4
014,VMW,Maritz,102.92,106.1
015,ORCL,Ellison
017,RHT,Whitehurst

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

Пример команды join – полное внешнее соединение:
$ join -t, -a1 -a2 -j1 2 -j2 1 dummy_join1.dat dummy_join3.dat
IBM,011,Palmisano,Armonk
INTC,012,Otellini,Santa Clara
SAP,013,Snabe,Walldorf
VMW,014,Maritz,Palo Alto
ORCL,015,Ellison,Redwood City
EMC,Hopkinton
017,RHT,Whitehurst

Команда sed

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

Простой пример замены с помощью команды sed демонстрирует использование опции –e для указания выражения (списка инструкций по редактированию). При одном запуске команды sed можно указать несколько выражений. Обратите внимание на компоненты, из которых состоит инструкция sed. Символ "s" в начале инструкции говорит о том, что это команда замены. Далее используется символ "/" в качестве разделителя и указывается шаблон "IBM", который необходимо заменить. Затем между двумя разделителями "/" указывается строка, на которую необходимо заменить исходный шаблон. Символ "g" в конце инструкции означает, что изменения необходимо выполнить глобально в текущем текстовом буфере. Третья команда в этом примере иллюстрирует одновременное использование трех инструкций: заменить обратные косые черты прямыми, заменить пробелы символами подчеркивания и удалить символы двоеточия (обратите внимание на то, как символ "\" указывается с помощью escape-последовательности).

Примеры команды sed – базовая замена и использование нескольких инструкций
$ echo "IBM 174.99" |sed –e 's/IBM/International Business Machines/g'
International Business Machines 174.99

$ echo "Oracle DB"|sed -e 's/Oracle/IBM/g' -e 's/DB/DB2/g'
IBM DB2

$ echo "C:\Program Files\PuTTY\putty.exe"| sed -e 's/\\/\//g' -e 's/ /_/g' -e 's/://g'
C/Program_Files/PuTTY/putty.exe

В следующем примере будет создан файл для демонстрации других возможностей команды sed. Кроме замены текста, эта команда часто используется для его фильтрации. Несмотря на то, что в качестве фильтра в UNIX часто используется команда grep, нет ничего необычного в том, что существует множество способов для работы с текстом в командной строке. В следующем примере будет продемонстрировано использование команды sed delete для удаления строк, начинающихся с "#" или " #". Для сравнения эти же действия будут выполнены с помощью команды grep.

Пример команды sed – фильтрация:
cat << EOF > dummy_sed.txt
# top of file
  # the next line here
# Last Name, Phone
Smith, 555-1212
Jones, 555-5555 # last number
EOF

$ sed '/^[[:space:]]*#/d' dummy_sed.txt
Smith, 555-1212
Jones, 555-5555 # last number

$ grep -v  ^[[:space:]]*# dummy_sed.txt
Smith, 555-1212
Jones, 555-5555 # last number

Для лучшего понимания работы команды sed рассмотрим еще несколько шаблонов; для этого создадим еще один текстовый файл. Первый шаблон sed показывает, как удалить из каждой строки файла последние четыре символа (строки представляют собой имена файлов). Следующий шаблон удаляет все символы справа от точки "." (т. е. расширение файла целиком). Далее представлен шаблон, удаляющий пустые строки; здесь используется специальный символ – амперсанд "&", позволяющий использовать шаблон поиска в качестве части вывода. В данной команде IBM является частью входного шаблона и включается в состав вывода с помощью амперсанда. Последний шаблон из этого примера показывает, как можно использовать команду sed для удаления символа возврата каретки из текстового файла, полученного из Windows-системы. Конструкцию "^M" можно ввести в инструкцию или в командную строку, нажав последовательно комбинации клавиш ctrl-v и ctrl-m. Учтите, что на ввод этой комбинации могут влиять особенности конкретного терминала.

Пример команды sed – еще несколько дополнительных шаблонов:
cat << EOF > filelist.txt
PuTTY.exe

sftp.exe
netstat.exe
servernames.list
EOF

$ sed 's/....$//' filelist.txt
PuTTY

sftp
netstat
servernames.

$ sed 's/\..*$//g' filelist.txt
PuTTY

sftp
netstat
servernames

$ sed '/^$/d' filelist.txt
PuTTY.exe
sftp.exe
netstat.exe
servernames.list

$ echo "IBM 174.99" |sed 's/IBM/&-International Business Machines/g'
IBM-International Business Machines 174.99

$ cat dosfile.txt | sed 's/^M//' > unixfile.txt

Команды sed можно применять к указанным диапазонам адресов. В следующих примерах показано несколько способов управления адресацией в sed. Опция "-n" изменяет поведение sed по умолчанию, при котором вывод содержит каждую строку ввода. В первом примере sed работает со строками 4-7. Обратите внимание на то, что вывод содержит только первую строку таблицы (строки файла с 4 по 7). В следующем примере выводятся только первая и последняя строки файла. В некоторых версиях sed можно указывать в шаблонах диапазоны адресов, которые будут передаваться в команду. Обратите внимание на то, что в выводе запятые удаляются только из таблицы, но не из комментариев.

Пример команды sed – диапазоны адресов:
cat << EOF > dummy_table.frag
<!--This, is a comment. -->
<p>This, is a paragraph.</p>
<table border="1">
<tr>
<td>row 1, 1st cell</td>
<td>row 1, 2nd cell</td>
</tr>
<tr>
<td>row 2, 1st cell</td>
<td>row 2, 2nd cell</td>
</tr>
</table>
<!--This, is another comment. -->
EOF

$ sed -n 4,7p dummy_table.frag
<tr>
<td>row 1, 1st cell</td>
<td>row 1, 2nd cell</td>
</tr>

$ sed -n -e 1p -e \$p dummy_table.frag
<!--This, is a comment. -->
<!--This, is another comment. -->

$ sed '/^<table/,/^<\/table/s/,//g' dummy_table.frag
<!--This, is a comment. -->
<p>This, is a paragraph.</p>
<table border="1">
<tr>
<td>row 1 1st cell</td>
<td>row 1 2nd cell</td>
</tr>
<tr>
<td>row 2 1st cell</td>
<td>row 2 2nd cell</td>
</tr>
</table>
<!--This, is another comment. -->

Шаблоны внутри выражения можно группировать и затем ссылаться на них как на часть вывода. Это может быть полезно в различных ситуациях, например, при перестановках значений или позиционных переменных. Для выделения шаблонов в выражении используются круглые скобки, сопровождаемые обратной косой чертой: \(здесь_находится_шаблон\). На шаблон можно ссылаться в любом месте выражения с помощью конструкции \n, где n – порядковый номер шаблона среди отмеченных. В следующей таблице разобьем выражение на части, чтобы было легче понять, как оно работает.

ШаблонКомментарии
/^#.*$/dУдаляет из вывода строки, начинающиеся с #
/^$/dУдаляет из вывода пустые строки
s/\([:a-z:]*\):\(.*\) /\2:\1 /Выбирает первую строку символов в нижнем регистре, оканчивающуюся двоеточием, после чего выбирает строку символов, следующую за двоеточием. В выводе выбранные строки меняются местами.
Пример команды sed – группировка шаблонов:
cat << EOF > sed_chown_example.txt
# use sed to swap the group:owner to owner:group

sudo chown dba:jdoe oraenv.ksh
sudo chown staff:jdoe sysenv.ksh
...
EOF

$ sed '/^#.*$/d;/^$/d;s/\([:a-z:]*\):\(.*\) /\2:\1 /' sed_chown_example.txt
sudo chown jdoe:dba oraenv.ksh
sudo chown jdoe:staff sysenv.ksh
...

Команда awk

Команда awk может быть очень удобна при работе с текстом. Она может выполнять такие действия, как анализ, фильтрация и форматирование текста. Команда awk принимает данные с устройства stdin или из файлов и по умолчанию выводит данные на устройство stdout. Существует множество версий команды awk под различными именами – например, nawk и gawk. Различные версии этой команды от различных авторов работают по-разному. Команда awk отличается от всех остальных команд, рассмотренных в этой статье, тем, что она представляет собой язык программирования. Этот язык содержит внутренние функции для математических вычислений, работы со строками, управления обменом данных и форматирования текста. Программисты могут определять свои собственные функции, объединяя их в библиотеки, или создавать автономные сценарии. Поскольку awk обладает очень широкими возможностями, мы рассмотрим лишь некоторые из них. Дополнительную информацию вы можете найти на man-страницах или в разделе Ресурсы.

Для начала рассмотрим листинг, в котором awk используется в качестве фильтра, выводя список только заполненных на 100% файловых систем Linux. Для разделения столбцов по умолчанию awk использует пробел. В следующем примере проверяется столбец 5, поскольку именно он содержит процент использования дискового пространства. Если диск используется на 100%, то в первом примере это значение будет выведено на устройство stdout. Следующий оператор расширяет действие первого, дополнительно форматируя вывод, который затем можно отправить по электронной почте или записать в log-файл. В последнем примере показано, как найти совпадение с указанным числом.

Пример команды awk – фильтрация:
$ df –k
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda1             61438632  61381272     57360 100% /
udev                    255788       148    255640   1% /dev
/dev/mapper/datavg     6713132   3584984   3128148  54% /data
rmthost1:/archives/backup    -         -         -   -  /backups
rmthost1:/archives/          -         -         -   -  /amc
rmthost1:/archives/data2     -         -         -   -  /data2

$ df -k |awk '$5 ~ /100%/ {print $0}'
/dev/sda1             61438632  61381272     57360 100% /

$ df -k |awk '$5 ~ /100%/ {printf("full filesystem: %s, mountpoint: %s\n",$6,$1)}'
full filesystem: /, mountpoint: /dev/sda1

$ df -k |awk '$4 > 3000000  {print $0}'
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/mapper/datavg     6713132   3584984   3128148  54% /data

Иногда данные в файле разделяются не пробельными символами. В качестве примера можно взять файл /etc/passwd, в котором столбцы разделяются двоеточиями (":"). В следующем примере показано, как с помощью опции –F команды awk можно вывести на экран имена и идентификаторы первых 5 пользователей из файла /etc/passwd. Далее с помощью функции substr() выводятся первые три символа столбца 1 файла /etc/passwd.

Пример команды awk – использование символа-разделителя полей и строковой функции:
$ cat /etc/passwd |awk -F: '{printf("%s %s\n", $1,$3)}' |head -5
root 0
daemon 1
bin 2
sys 3
adm 4

cat /etc/passwd |awk -F: '{printf("%s \n", substr($1,1,3))}'|head -5
roo
dae
bin
sys
adm

Системные администраторы и программисты часто пишут сценарии awk для выполнения определенных задач. Ниже рассмотрен пример написанной на awk программы для вычисления средней величины всех значений в третьем столбце файла. Математические действия выполняются вручную путем добавления данных столбца 3 в переменную суммы. NR – это специальная внутренняя переменная, которую awk использует для отслеживания количества обработанных записей. Средняя величина значений в столбце 3 определяется путем деления значения переменной суммы на значение переменной NR. Программа также выводит промежуточные данные и результаты, поэтому понять логику ее работы очень просто.

Пример команды awk – математическая программа:
cat << EOF > dummy_file2.dat
011  IBM 174.99
012 INTC 22.78
013 SAP 59.37
014 vmw 102.92
EOF

$ cat avg.awk
awk 'BEGIN {total=0;}
           {printf("tot: %.2f arg3: %.2f NR: %d\n",total, $3, NR); total+=$3;}
     END {printf "Total:%.3f Average:%.3f \n",total,total/NR}'

$ cat dummy_file2.dat | avg.awk
tot: 0.00 arg3: 174.99 NR: 1
tot: 174.99 arg3: 22.78 NR: 2
tot: 197.77 arg3: 59.37 NR: 3
tot: 257.14 arg3: 102.92 NR: 4
Total:360.060 Average:90.015

Средства командного интерпретатора для работы со строками

Командный интерпретатор может служить мощным языком программирования. Подобно awk, командные интерпретаторы могут выполнять множество действий: работа со строками и массивами, математические вычисления, управление обменом данными, файловые операции. В следующем примере будет показано, как извлекать части строки с одной стороны. Выполняемые операции не изменяют значения строк, а просто показывают, как бы выглядели результаты – это часто используется для присвоения значений переменным. Символ процента "%" используется для усечения правой части шаблона, а символ решетки "#" – для усечения левой.

Пример сценария командного интерпретатора – извлечение строк:
$ cat string_example1.sh
#!/bin/sh
FILEPATH=/home/w/wyoes/samples/ksh_samples-v1.0.ksh
echo '${FILEPATH}      =' ${FILEPATH}      "  # полный путь"
echo '${#FILEPATH}     =' ${#FILEPATH}      "  # длина строки"
echo '${FILEPATH%.*}   =' ${FILEPATH%.*}   "  # усечение справа от последней точки"
echo '${FILEPATH%%.*}  =' ${FILEPATH%%.*}  "  # усечение справа от первой точки"
echo '${FILEPATH%%/w*} =' ${FILEPATH%%/w*} "  # усечение справа
 от первого пробельного символа"
echo '${FILEPATH#/*/*/}  =' ${FILEPATH#/*/*/}  "  # усечение слева
 от третьей косой черты"
echo '${FILEPATH##/*/} =' ${FILEPATH##/*/} "  # усечение слева
 от последней косой черты"

$ ./string_example1.sh
${FILEPATH}=/home/w/wyoes/samples/ksh_samples-v1.0.ksh # полный путь
${#FILEPATH} = 42                                      # длина строки
${FILEPATH%.*}=/home/w/wyoes/samples/ksh_samples-v1.0  # усечение справа
 от последней точки
${FILEPATH%%.*}=/home/w/wyoes/samples/ksh_samples-v1   # усечение справа
 от первой точки
${FILEPATH%%/w*}=/home                                 # усечение справа от
 первого пробельного символа
${FILEPATH#/*/*/}=wyoes/samples/ksh_samples-v1.0.ksh   # усечение слева
 от третьей косой черты
${FILEPATH##/*/}=ksh_samples-v1.0.ksh                  # усечение слева от
 последней косой черты

Предположим, что системному администратору требуется преобразовать расширения нескольких jpg-файлов в нижний регистр. Поскольку операционные системы UNIX учитывают регистр символов, некоторым приложениям могут потребоваться расширения в нижнем регистре, а, возможно, администратор просто хочет упорядочить расширения. Изменение расширений для большого количества файлов вручную или с помощью графической оболочки может занять многие часы. Следующий простой сценарий решает эту проблему. В этом примере используются два файла. Первый сценарий, setup_files.ksh, создает пример простого дерева каталогов и заполняет его несколькими файлами. Также он формирует список файлов, расширения которых, возможно, потребуется изменить. Второй сценарий, fix_extension.ksh, считывает полученный список файлов и изменяет расширения там, где это необходимо. Для усечения имени файла справа от последней точки "." (т. е. для усечения расширения файла) используется строковый оператор % (как часть команды mv). В обоих сценариях также используется команда find, которая выводит итоговые результаты по завершении их работы.

Пример сценария командного интерпретатора – изменение файловых расширений:
$ cat setup_files.ksh
mkdir /tmp/mv_demo
[ ! -d /tmp/mv_demo ] && exit

cd /tmp/mv_demo
mkdir tmp JPG 'pictures 1'
touch a.JPG b.jpg c.Jpg d.jPg M.jpG P.jpg JPG_file.JPG JPG.file2.jPg file1.JPG.Jpg 'tmp/
pic 2.Jpg' 10.JPG.bak 'pictures 1/photo.JPG' JPG/readme.txt JPG/sos.JPG

find . -type f|grep -i "\.jpg$" |sort| tee file_list.txt

$ ./setup_files.ksh
./JPG.file2.jPg
./JPG/sos.JPG
./JPG_file.JPG
./M.jpG
./P.jpg
./a.JPG
./b.jpg
./c.Jpg
./d.jPg
./file1.JPG.Jpg
./pictures 1/photo.JPG
./tmp/pic 2.Jpg

$ cd /tmp/mv_demo
$ cat /tmp/fix_extension.ksh
while read f ; do
    mv "${f}" "${f%.*}.jpg"
done < file_list.txt

find . -type f|grep -i "\.jpg$" |sort

$ /tmp/fix_extension.ksh
./JPG.file2.jpg
./JPG/sos.jpg
./JPG_file.jpg
./M.jpg
./P.jpg
./a.jpg
./b.jpg
./c.jpg
./d.jpg
./file1.JPG.jpg
./pictures 1/photo.jpg
./tmp/pic 2.jpg

Следуя идее создания полезных и универсальных инструментов, можно изменить сценарий из последнего примера и сделать его более общим. На ум сразу приходят такие вещи, как, например, передача имен изменяемых файлов в потоке (например, являющемся частью конвейера). Можно также добавить различные опции для указания файловых расширений (например, .mp3 или .mov), которые нужно изменить, или для их форматирования (верхний, нижний или смешанный регистр). Возможности ограничены лишь вашим воображением и наличием свободного времени.


Заключение

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

Ресурсы

Научиться

Получить продукты и технологии

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

Обсудить

Комментарии

developerWorks: Войти

Обязательные поля отмечены звездочкой (*).


Нужен IBM ID?
Забыли Ваш IBM ID?


Забыли Ваш пароль?
Изменить пароль

Нажимая Отправить, Вы принимаете Условия использования developerWorks.

 


Профиль создается, когда вы в первый раз заходите в developerWorks. Выберите данные в своем профиле (имя, страна/регион, компания) которые будут общедоступными и будут отображаться, когда вы публикуете какую-либо информацию. Вы можете изменить данные вашего ИБМ аккаунта в любое время.

Вся введенная информация защищена.

Выберите имя, которое будет отображаться на экране



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

Отображаемое имя должно иметь длину от 3 символов до 31 символа. Ваше Имя в системе должно быть уникальным. В качестве имени по соображениям приватности нельзя использовать контактный e-mail.

Обязательные поля отмечены звездочкой (*).

(Отображаемое имя должно иметь длину от 3 символов до 31 символа.)

Нажимая Отправить, Вы принимаете Условия использования developerWorks.

 


Вся введенная информация защищена.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=40
Zone=AIX и UNIX
ArticleID=870578
ArticleTitle=Знакомство с текстовыми утилитами UNIX
publish-date=04162013