string - обработка строк

Синтаксис

string collect [-a | --allow-empty] [-N | --no-trim-newlines] [STRING ...]
string escape [-n | --no-quoted] [--style=] [STRING ...]
string join [-q | --quiet] [-n | --no-empty] SEP [STRING ...]
string join0 [-q | --quiet] [STRING ...]
string length [-q | --quiet] [STRING ...]
string lower [-q | --quiet] [STRING ...]
string match [-a | --all] [-e | --entire] [-i | --ignore-case]
             [-g | --groups-only] [-r | --regex] [-n | --index]
             [-q | --quiet] [-v | --invert]
             PATTERN [STRING ...]
string pad [-r | --right] [(-c | --char) CHAR] [(-w | --width) INTEGER]
           [STRING ...]
string repeat [(-n | --count) COUNT] [(-m | --max) MAX] [-N | --no-newline]
              [-q | --quiet] [STRING ...]
string replace [-a | --all] [-f | --filter] [-i | --ignore-case]
               [-r | --regex] [-q | --quiet] PATTERN REPLACE [STRING ...]
string shorten [(-c | --char) CHARS] [(-m | --max) INTEGER]
               [-N | --no-newline] [-l | --left] [-q | --quiet] [STRING ...]
string split [(-f | --fields) FIELDS] [(-m | --max) MAX] [-n | --no-empty]
             [-q | --quiet] [-r | --right] SEP [STRING ...]
string split0 [(-f | --fields) FIELDS] [(-m | --max) MAX] [-n | --no-empty]
              [-q | --quiet] [-r | --right] [STRING ...]
string sub [(-s | --start) START] [(-e | --end) END] [(-l | --length) LENGTH]
           [-q | --quiet] [STRING ...]
string trim [-l | --left] [-r | --right] [(-c | --chars) CHARS]
            [-q | --quiet] [STRING ...]
string unescape [--style=] [STRING ...]
string upper [-q | --quiet] [STRING ...]

Описание

string выполняет операции со строками.

Аргументы СТРОКА берутся из командной строки, если стандартный ввод не подключён к конвейеру или файлу; в противном случае они считываются со стандартного ввода, по одной СТРОКЕ на строку. Недопустимо использовать аргументы СТРОКА как в командной строке, так и со стандартного ввода.

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

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

Доступны следующие подкоманды.

Подкоманда «collect»

string collect [-a | --allow-empty] [-N | --no-trim-newlines] [STRING ...]

string collect собирает свой ввод в один выходной аргумент, не разбивая вывод при использовании в подстановке команд. Это полезно при попытке собрать многострочный вывод другой команды в переменную. Код завершения: 0, если какой-либо выходной аргумент не пуст, или 1 в противном случае.

Команда типа echo (cmd | string collect) в основном эквивалентна цитируемой подстановке команд (echo "$(cmd)"). Основное различие заключается в том, что первая вычисляется в нуль или один элемент, тогда как цитируемая подстановка команд всегда вычисляется в один элемент из-за интерполяции строк.

Если вызвана с несколькими аргументами вместо ввода, string collect сохраняет каждый аргумент отдельно, где количество выходных аргументов равно количеству аргументов, переданных в string collect.

Любые хвостовые символы новой строки во входных данных обрезаются, как и при подстановке "$(cmd)". Используйте --no-trim-newlines, чтобы отключить это поведение, что может быть полезно при выполнении команды, такой как set contents (cat filename | string collect -N).

При использовании --allow-empty, string collect всегда выводит один (пустой) аргумент. Это можно использовать, чтобы предотвратить исчезновение аргумента.

>_ echo "zero $(echo one\ntwo\nthree) four"
zero one
two
three four

>_ echo \"(echo one\ntwo\nthree | string collect)\"
"one
two
three"

>_ echo \"(echo one\ntwo\nthree | string collect -N)\"
"one
two
three
"

>_ echo foo(true | string collect --allow-empty)bar
foobar

Подкоманды «escape» и «unescape»

string escape [-n | --no-quoted] [--style=] [STRING ...]
string unescape [--style=] [STRING ...]

string escape экранирует каждую СТРОКУ одним из трёх способов. Первый — --style=script. Это значение по умолчанию. Оно изменяет строку так, чтобы её можно было передать обратно eval для получения исходного аргумента. По умолчанию все специальные символы экранируются, а кавычки используются для упрощения вывода, когда это возможно. Если задано -n или --no-quoted, упрощённый формат с кавычками не используется. Код завершения: 0, если хотя бы одна строка была экранирована, или 1 в противном случае.

--style=var гарантирует, что строка может быть использована как имя переменной, кодируя шестнадцатерично все небуквенно-цифровые символы. Строка сначала преобразуется в UTF-8, прежде чем быть закодированной.

--style=url гарантирует, что строка может быть использована как URL, кодируя шестнадцатерично любые символы, которые не являются допустимыми в URL. Строка сначала преобразуется в UTF-8, прежде чем быть закодированной.

--style=regex экранирует входную строку для буквального сопоставления в выражении регулярного выражения. Строка сначала преобразуется в UTF-8, прежде чем быть закодированной.

string unescape выполняет обратную операцию подкоманды string escape. Если строка для экранирования не отформатирована должным образом, она игнорируется. Например, string unescape --style=var (string escape --style=var $str) вернёт исходную строку. Поддержка экранирования для --style=regex отсутствует.

>_ echo \x07 | string escape
\cg

>_ string escape --style=var 'a1 b2'\u6161
a1_20_b2_E6_85_A1_

Подкоманды «join» и «join0»

string join [-q | --quiet] SEP [STRING ...]
string join0 [-q | --quiet] [STRING ...]

string join соединяет свои аргументы СТРОКА в одну строку, разделённую SEP, которая может быть пустой строкой. Код завершения: 0, если было выполнено хотя бы одно соединение, или 1 в противном случае. Если -n или --no-empty заданы, пустые строки исключаются из рассмотрения (например, string join -n + a b "" c расширится до a+b+c, а не a+b++c).

string join0 соединяет свои аргументы СТРОКА в одну строку, разделённую нулевым байтом (NUL), и добавляет конечный NUL. Это наиболее полезно в сочетании с инструментами, которые принимают входные данные, разделённые нулевым байтом, например sort -z. Код завершения: 0, если было выполнено хотя бы одно соединение, или 1 в противном случае.

Поскольку Unix использует NUL в качестве терминатора строки, передача вывода string join0 в качестве аргумента команде (через подстановку команд) фактически не сработает. Fish передаст правильные байты, но команда не сможет определить, где заканчивается аргумент. Это ограничение передачи аргументов Unix.

>_ seq 3 | string join ...
1...2...3

# Give a list of NUL-separated filenames to du (this is a GNU extension)
>_ string join0 file1 file2 file\nwith\nmultiple\nlines | du --files0-from=-

# Just put the strings together without a separator
>_ string join '' a b c
abc

Подкоманда «length»

string length [-q | --quiet] [-V | --visible] [STRING ...]

string length сообщает о длине каждого аргумента строки в символах. Код завершения: 0, если хотя бы один непустой СТРОКА был задан, или 1 в противном случае.

С -V или --visible, используется видимая ширина аргументов. Это означает, что он будет отбрасывать последовательности escape, о которых знает fish, учитывать $fish_emoji_width и $fish_ambiguous_width. Также будет учитываться каждая строка (разделённая \n) отдельно, а с символом возврата каретки (\r) будет учитываться только самая широкая часть строки. Цель состоит в измерении количества столбцов, которые занимает СТРОКА в текущем терминале.

>_ string length 'hello, world'
12

>_ set str foo
>_ string length -q $str; echo $status
0
# Equivalent to test -n "$str"

>_ string length --visible (set_color red)foobar
# the set_color is discounted, so this is the width of "foobar"
6

>_ string length --visible 🐟🐟🐟🐟
# depending on $fish_emoji_width, this is either 4 or 8
# in new terminals it should be
8

>_ string length --visible abcdef\r123
# this displays as "123def", so the width is 6
6

>_ string length --visible a\nbc
# counts "a" and "bc" as separate lines, so it prints width for each
1
2

Подкоманда «lower»

string lower [-q | --quiet] [STRING ...]

string lower преобразует каждый аргумент строки в нижний регистр. Код завершения: 0, если хотя бы одна строка была преобразована в нижний регистр, в противном случае 1. Это означает, что в сочетании с флагом -q вы можете легко проверить, находится ли строка уже в нижнем регистре.

Подкоманда «match»

string match [-a | --all] [-e | --entire] [-i | --ignore-case]
             [-g | --groups-only] [-r | --regex] [-n | --index]
             [-q | --quiet] [-v | --invert]
             PATTERN [STRING ...]

string match проверяет каждую СТРОКУ на соответствие ШАБЛОНУ и печатает совпадающие подстроки. Только первое соответствие для каждой СТРОКИ сообщается, если не задано -a или --all, в этом случае сообщаются все соответствия.

Если задано -e или --entire, то каждая совпадающая строка выводится, включая любой префикс или суффикс, не сопоставленный шаблоном (эквивалентно grep без флага -o). Очевидно, можно добиться того же результата, добавив * или .* в зависимости от того, задан ли флаг --regex. Флаг --entire просто способ избежать усложнения шаблона таким образом и сделать намерение string match более ясным. Без --entire и --regex, ШАБЛОН должен соответствовать всей СТРОКЕ, прежде чем он будет сообщён.

Сопоставление может быть сделано регистронезависимым с помощью --ignore-case или -i.

Если задано --groups-only или -g, сообщаются только захватывающие группы — это означает, что полное соответствие пропускается. Это несовместимо с --entire и --invert и требует --regex. Это полезно как простой инструмент для извлечения вместо string replace, так что вы можете просто выбрать «эту часть» строки.

Если задано --index или -n, каждое соответствие сообщается как позиция начала (от 1) и длина. По умолчанию ШАБЛОН интерпретируется как шаблон glob, сопоставляемый с каждым аргументом СТРОКА целиком. Шаблон glob считается допустимым соответствием только в том случае, если он соответствует всей СТРОКЕ.

Если задано --regex или -r, ШАБЛОН интерпретируется как регулярное выражение, совместимое с Perl, которое не обязательно должно соответствовать всей СТРОКЕ. Для регулярного выражения, содержащего захватывающие группы, для каждого соответствия будут сообщены несколько элементов: один для всего соответствия и один для каждой захватывающей группы. В этом случае будет сообщена только совпадающая часть СТРОКИ, если не задано --entire.

При сопоставлении с помощью регулярных выражений, string match автоматически задаёт переменные для всех именованных захватывающих групп ((?<name>expression)). Для каждой именованной захватывающей группы будет создана переменная с именем группы в области действия по умолчанию и задано значение захватывающей группы в первом сопоставленном аргументе. Если именованная захватывающая группа соответствовала пустой строке, переменная будет установлена в пустую строку (как set var ""). Если она не соответствовала, переменная будет установлена в ничего (как set var). При использовании --regex с --all это поведение меняется. Каждая именованная переменная будет содержать список соответствий, где первое соответствие будет содержаться в первом элементе, второе — во втором и так далее. Если группа была пустой или не соответствовала, соответствующий элемент будет пустой строкой.

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

Код завершения: 0, если найдено хотя бы одно совпадение, или 1 в противном случае.

>_ string match '?' a
a

>_ string match 'a*b' axxb
axxb

>_ string match -i 'a??B' Axxb
Axxb

>_ string match -- '-*' -h foo --version bar
# To match things that look like options, we need a `--`
# to tell string its options end there.
-h
--version

>_ echo 'ok?' | string match '*\?'
ok?

# Note that only the second STRING will match here.
>_ string match 'foo' 'foo1' 'foo' 'foo2'
foo

>_ string match -e 'foo' 'foo1' 'foo' 'foo2'
foo1
foo
foo2

>_ string match 'foo?' 'foo1' 'foo' 'foo2'
foo1
foo2

>_ string match -r 'cat|dog|fish' 'nice dog'
dog

>_ string match -r -v "c.*[12]" {cat,dog}(seq 1 4)
dog1
dog2
cat3
dog3
cat4
dog4

>_ string match -r -- '-.*' -h foo --version bar
# To match things that look like options, we need a `--`
# to tell string its options end there.
-h
--version

>_ string match -r '(\d\d?):(\d\d):(\d\d)' 2:34:56
2:34:56
2
34
56

>_ string match -r '^(\w{2,4})\1$' papa mud murmur
papa
pa
murmur
mur

>_ string match -r -a -n at ratatat
2 2
4 2
6 2

>_ string match -r -i '0x[0-9a-f]{1,8}' 'int magic = 0xBadC0de;'
0xBadC0de

>_ echo $version
3.1.2-1575-ga2ff32d90
>_ string match -rq '(?<major>\d+).(?<minor>\d+).(?<revision>\d+)' -- $version
>_ echo "You are using fish $major!"
You are using fish 3!

>_ string match -raq ' *(?<sentence>[^.!?]+)(?<punctuation>[.!?])?' "hello, friend. goodbye"
>_ printf "%s\n" -- $sentence
hello, friend
goodbye
>_ printf "%s\n" -- $punctuation
.

>_ string match -rq '(?<word>hello)' 'hi'
>_ count $word
0

Подкоманды «pad» и «shorten»

string pad [-r | --right] [(-c | --char) CHAR] [(-w | --width) INTEGER]
           [STRING ...]

string pad расширяет каждую СТРОКУ до заданной видимой ширины, добавляя СИМВОЛ слева. Это означает ширину всех видимых символов вместе, исключая последовательности escape и учитывая fish_emoji_width и fish_ambiguous_width. Это количество столбцов в терминале, занимаемых СТРОКОЙ.

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

Если задано -r или --right, добавляет отступ после строки.

Если задано -c или --char, отступ выполняется символом СИМВОЛ вместо пробела.

Вывод отступается до максимальной ширины всех входных строк. Если задано -w или --width, используется, по крайней мере, это значение.

>_ string pad -w 10 abc abcdef
       abc
    abcdef

>_ string pad --right --char=🐟 "fish are pretty" "rich. "
fish are pretty
rich.  🐟🐟🐟🐟

>_ string pad -w$COLUMNS (date)
# Prints the current time on the right edge of the screen.

См. также

• Команда printf может выполнять простое выравнивание, например, printf %10s\n работает так же, как string pad -w10.
• длина строки с опцией --visible может использоваться для отображения того, какой ширины считает строка рыбка.

string shorten [(-c | --char) CHARS] [(-m | --max) INTEGER]
               [-N | --no-newline] [-l | --left] [-q | --quiet] [STRING ...]

string shorten обрезает каждую строку STRING до заданной видимой ширины и добавляет многоточие, чтобы указать на обрезку. «Видимая ширина» означает ширину всех видимых символов, добавленных вместе, исключая управляющие последовательности и учитывая fish_emoji_width и fish_ambiguous_width. Это количество столбцов в терминале, занимаемых строкой STRING.

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

Если заданы -m или --max, обрезка выполняется по заданной ширине. В противном случае используется наименьшая ненулевая ширина всех входных строк. Максимальное значение 0 означает, что никаких сокращений не происходит, все строки STRING выводятся как есть.

Если задана -N или --no-newline, используется только первая строка (или последняя строка с --left) каждой строки STRING, и добавляется многоточие, если строка содержит несколько строк. Это работает только для строк, передаваемых в качестве аргументов; несколько строк, переданных через стандартный ввод, будут интерпретироваться как отдельные строки STRING.

Если заданы -c или --char, вместо многоточия добавляется символ CHAR. Он также может быть пустым или состоять более чем из одного символа.

Если задана -l или --left, текст удаляется слева вместо того, чтобы удалить справа, поэтому выводятся самые длинные суффиксы строки, которые помещаются в заданную ширину. При --no-newline это будет последняя строка, а не первая.

Если задана -q или --quiet, string shorten выполняется только для возвращаемого значения — если что-то будет обрезанно, возвращается 0, в противном случае — 1.

По умолчанию многоточие — …. Если fish считает вашу систему несовместимой из-за локалей, будет использоваться ....

Возвращаемое значение равно 0, если произошло какое-либо сокращение, и 1 в противном случае.

>_ string shorten foo foobar
# No width was given, we infer, and "foo" is the shortest.
foo
fo…

>_ string shorten --char="..." foo foobar
# The target width is 3 because of "foo",
# and our ellipsis is 3 too, so we can't really show anything.
# This is the default ellipsis if your locale doesn't allow "…".
foo
...

>_ string shorten --char="" --max 4 abcdef 123456
# Leaving the char empty makes us not add an ellipsis
# So this truncates at 4 columns:
abcd
1234

>_ touch "a multiline"\n"file"
>_ for file in *; string shorten -N -- $file; end
# Shorten the multiline file so we only show one line per file:
a multiline…

>_ ss -p | string shorten -m$COLUMNS -c ""
# `ss` from Linux' iproute2 shows socket information, but prints extremely long lines.
# This shortens input so it fits on the screen without overflowing lines.

>_ git branch | string match -rg '^\* (.*)' | string shorten -m20
# Take the current git branch and shorten it at 20 columns.
# Here the branch is "builtin-path-with-expand"
builtin-path-with-e…

>_ git branch | string match -rg '^\* (.*)' | string shorten -m20 --left
# Taking 20 columns from the right instead:
…in-path-with-expand

См. также

• Подкоманда string’s pad выполняет обратное действие по сравнению с этой командой, добавляя выравнивание до заданной ширины.
• Команда printf может выполнять простое выравнивание, например, printf %10s\n работает так же, как string pad -w10.
• длина строки с опцией --visible может использоваться для отображения того, какой ширины считает строка рыбка.

Подкоманда «repeat»

string repeat [(-n | --count) COUNT] [(-m | --max) MAX] [-N | --no-newline]
              [-q | --quiet] [STRING ...]

string repeat повторяет строку STRING -n или --count раз. Опция -m или --max ограничит количество выводимых символов (исключая перевод строки). Эта опция может использоваться сама по себе или в сочетании с --count. Если присутствуют как --count, так и --max, будет выводиться максимальное количество символов, если размер повторяющейся строки меньше максимума, в этом случае строка будет повторяться до тех пор, пока не будет достигнуто заданное количество повторений. И --count, и --max принимают число, большее или равное нулю; в случае нуля ничего не будет выведено. Если задана -N или --no-newline, в выводе не будет символа новой строки в конце. Код выхода: 0, если сгенерированная строка не пуста, 1 в противном случае.

>_ string repeat -n 2 'foo '
foo foo

>_ echo foo | string repeat -n 2
foofoo

>_ string repeat -n 2 -m 5 'foo'
foofo

>_ string repeat -m 5 'foo'
foofo

Подкоманда «replace»

string replace [-a | --all] [-f | --filter] [-i | --ignore-case]
               [-r | --regex] [-q | --quiet] PATTERN REPLACEMENT [STRING ...]

string replace похожа на string match, но заменяет неперекрывающиеся совпадающие подстроки строкой-заменителем и выводит результат. По умолчанию PATTERN обрабатывается как подстрока для поиска.

Если задана -r или --regex, PATTERN интерпретируется как регулярное выражение, совместимое с Perl, а REPLACEMENT может содержать управляющие последовательности в стиле C (например, t), а также ссылки на группы захвата по номеру или имени, как $n или ${n}.

Если вы задаёте флаг -f или --filter, то каждая входная строка выводится только в том случае, если была произведена замена. Это полезно в тех случаях, когда вы иначе использовали бы выражение: a_cmd | string match pattern | string replace pattern new_pattern. Вы можете вместо этого записать a_cmd | string replace --filter pattern new_pattern.

Код выхода: 0, если была произведена хотя бы одна замена, или 1 в противном случае.

>_ string replace is was 'blue is my favorite'
blue was my favorite

>_ string replace 3rd last 1st 2nd 3rd
1st
2nd
last

>_ string replace -a ' ' _ 'spaces to underscores'
spaces_to_underscores

>_ string replace -r -a '[^\d.]+' ' ' '0 one two 3.14 four 5x'
0 3.14 5

>_ string replace -r '(\w+)\s+(\w+)' '$2 $1 $$' 'left right'
right left $

>_ string replace -r '\s*newline\s*' '\n' 'put a newline here'
put a
here

Подкоманды «split» и «split0»

string split [(-f | --fields) FIELDS] [(-m | --max) MAX] [-n | --no-empty]
             [-q | --quiet] [-r | --right] SEP [STRING ...]
string split0 [(-f | --fields) FIELDS] [(-m | --max) MAX] [-n | --no-empty]
              [-q | --quiet] [-r | --right] [STRING ...]

string split разделяет каждую строку STRING по разделителю SEP, который может быть пустой строкой. Если задана -m или --max, на каждой строке STRING выполняется не более MAX разделений. Если задана -r или --right, разделение выполняется справа налево. Это полезно в сочетании с -m или --max. С -n или --no-empty пустые результаты исключаются из рассмотрения (например, hello\n\nworld будет расширяться до двух строк, а не трёх). Код выхода: 0, если было выполнено хотя бы одно разделение, или 1 в противном случае.

Используйте -f или --fields, чтобы вывести определённые поля. FIELDS — это строка, разделенная запятыми, с номерами и/или диапазонами полей. Каждое поле индексируется с единицы и будет выведено на отдельной строке. Если заданное поле не существует, команда завершается с кодом 1 и ничего не выводит, если не используется --allow-empty.

См. также опцию --delimiter команды read.

string split0 разделяет каждую строку STRING по нулю (NUL). Опции те же, что и у string split, за исключением того, что разделитель не задаётся.

split0 обладает важным свойством, что его вывод не подвергается дальнейшему разделению при использовании в подстановке команд, что позволяет подстановке команд создавать элементы, содержащие переводы строк. Это наиболее полезно при использовании с утилитами Unix, которые генерируют нули, такими как find -print0 или sort -z. См. примеры split0 ниже.

>_ string split . example.com
example
com

>_ string split -r -m1 / /usr/local/bin/fish
/usr/local/bin
fish

>_ string split '' abc
a
b
c

>_ string split --allow-empty -f1,3-4,5 '' abcd
a
c
d

>_ # Count files in a directory, without being confused by newlines.
>_ count (find . -print0 | string split0)
42

>_ # Sort a list of elements which may contain newlines
>_ set foo beta alpha\ngamma
>_ set foo (string join0 $foo | sort -z | string split0)
>_ string escape $foo[1]
alpha\ngamma

Подкоманда «sub»

string sub [(-s | --start) START] [(-e | --end) END] [(-l | --length) LENGTH]
           [-q | --quiet] [STRING ...]

string sub выводит подстроку каждой строки-аргумента. Начало/конец подстроки можно указать с помощью -s/-e или --start/--end, после которых следует значение индекса с единицы. Положительные индексы относятся к началу строки, а отрицательные — к концу строки. Значение по умолчанию для начала — 1. Длину подстроки можно указать с помощью -l или --length. Если длина или конец не указаны, подстрока продолжается до конца каждой строки STRING. Код выхода: 0, если выполнена хотя бы одна операция подстроки, 1 в противном случае. --length исключает --end.

>_ string sub --length 2 abcde
ab

>_ string sub -s 2 -l 2 abcde
bc

>_ string sub --start=-2 abcde
de

>_ string sub --end=3 abcde
abc

>_ string sub -e -1 abcde
abcd

>_ string sub -s 2 -e -1 abcde
bcd

>_ string sub -s -3 -e -2 abcde
c

Подкоманда «trim»

string trim [-l | --left] [-r | --right] [(-c | --chars) CHARS]
            [-q | --quiet] [STRING ...]

string trim удаляет начальные и конечные пробелы из каждой строки STRING. Если задана -l или --left, удаляются только начальные пробелы. Если задана -r или --right, удаляются только конечные пробелы. Переключатель -c или --chars приводит к удалению символов из CHARS вместо пробелов. Код выхода: 0, если было удалено хотя бы один символ, или 1 в противном случае.

>_ string trim ' abc  '
abc

>_ string trim --right --chars=yz xyzzy zany
x
zan

Подкоманда «upper»

string upper [-q | --quiet] [STRING ...]

string upper преобразует каждый аргумент-строку в верхний регистр. Код выхода: 0, если хотя бы одна строка была преобразована в верхний регистр, в противном случае 1. Это означает, что в сочетании с флагом -q можно легко проверить, находится ли строка уже в верхнем регистре.

Регулярные выражения

Обе подкоманды match и replace поддерживают регулярные выражения при использовании опции -r или --regex. Диалект — PCRE2.

В общем случае, специальные символы по умолчанию являются специальными, поэтому a+ соответствует одному или нескольким символам “a”, а a\+ соответствует символу “a”, за которым следует символ “+”. (a+) соответствует одному или нескольким символам “a” в группе захвата ((?:XXXX) обозначает группу без захвата). Для параметра замены replace, $n ссылается на n-ую группу совпадения. В параметре совпадения \n (например, \1) ссылается на группы.

Некоторые функции включают повторения:

• * соответствует 0 или более повторениям предыдущего выражения
• + 1 или более
• ? 0 или 1.
• {n} ровно n (где n — число)
• {n,m} по крайней мере n, но не более m.
• {n,} n или более

Классы символов, некоторые из важнейших:

• . любой символ, кроме новой строки
• \d десятичная цифра и \D, не десятичная цифра
• \s пробел и \S, не пробел
• \w символ «слова» и \W, символ «не слова»
• [...] (где «…» — некоторые символы) — множество символов
• [^...] — обратное заданному множеству символов
• [x-y] — диапазон символов от x до y
• [[:xxx:]] — именованное множество символов
• [[:^xxx:]] — обратное именованному множеству символов
• [[:alnum:]] : «буквенно-цифровой»
• [[:alpha:]] : «буквенный»
• [[:ascii:]] : «0-127»
• [[:blank:]] : «пробел или табуляция»
• [[:cntrl:]] : «управляющий символ»
• [[:digit:]] : «десятичная цифра»
• [[:graph:]] : «печать, за исключением пробела»
• [[:lower:]] : «маленькая буква»
• [[:print:]] : «печать, включая пробел»
• [[:punct:]] : «печать, за исключением буквенно-цифровых символов»
• [[:space:]] : «пробельный символ»
• [[:upper:]] : «большая буква»
• [[:word:]] : «то же, что и w»
• [[:xdigit:]] : «шестнадцатеричная цифра»

Группы:

• (...) — группа захвата
• (?:...) — группа без захвата
• \n — обратная ссылка (где n — номер группы, начиная с 1)
• $n — ссылка из выражения замены на группу в выражении совпадения.

И еще кое-что:

• \b обозначает границу слова, \B — нет границы слова.
• ^ — начало строки или строки, $ — конец.
• | — «альтернация», т.е. «или».

Сравнение с другими инструментами

Большинство операций, которые поддерживает string, также могут быть выполнены внешними инструментами. Некоторые из них включают grep, sed и cut.

Если вы знакомы с ними, полезно знать, чем string отличается от них.

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

В отличие от grep, string по умолчанию работает в режиме glob, а replace по умолчанию работает в режиме буквального соответствия. При установке в режим регулярных выражений они используют регулярные выражения PCRE, что сопоставимо с опцией grep -P. match по умолчанию печатает только совпадение, что похоже на grep с -o (используйте --entire, чтобы включить поведение в стиле grep).

Как и команда sed s/old/new/, string replace все еще выводит строки, которые не соответствуют. sed -n в сочетании с модификатором или командой /p подобна string replace -f.

string split somedelimiter является заменой для tr somedelimiter \n.