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 объединяет свои аргументы СТРОКА в одну строку, разделённую РАЗДЕЛИТЕЛЕМ, который может быть пустой строкой. Код возврата: 0, если по крайней мере одно объединение выполнено, или 1 в противном случае. Если заданы -n или --no-empty , пустые строки исключаются из рассмотрения (например, string join -n + a b "" c будет расширяться до a+b+c , а не до a+b++c).

string join0 объединяет свои аргументы СТРОКА в одну строку, разделённую нулевым байтом (NUL), и добавляет заключительный 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

>_ 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 '(\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 обрезает каждое СТРОКУ до заданной видимой ширины и добавляет многоточие для обозначения обрезки. «Видимая ширина» означает ширину всех видимых символов, сложенных вместе, за исключением управляющих последовательностей и с учетом fish_emoji_width и fish_ambiguous_width. Это количество колонок в терминале, занимаемое СТРОКОЙ.

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

Если задан параметр -m или --max, происходит обрезка до заданной ширины. В противном случае используется наименьшая ненулевая ширина всех входных строк. Значение max 0 означает, что обрезка не выполняется, все СТРОКИ выводятся как есть.

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

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

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

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

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

Возвращаемое значение равно 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 повторяет СТРОКУ -n или --count раз. Параметр -m или --max ограничит количество выводимых символов (исключая перевод строки). Этот параметр может использоваться сам по себе или в сочетании с --count. Если оба параметра --count и --max присутствуют, выводится максимальное количество символов, пока размер итоговой строки не станет меньше максимального, в этом случае строка будет повторяться до тех пор, пока не будет достигнуто значение count. Оба параметра --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, но заменяет неперекрывающиеся совпадающие подстроки строкой замены и выводит результат. По умолчанию ШАБЛОН рассматривается как буквальная подстрока для поиска.

Если задан параметр -r или --regex, ШАБЛОН интерпретируется как регулярное выражение, совместимое с Perl, и ЗАМЕНА может содержать управляющие последовательности стиля 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 разделяет каждую СТРОКУ по разделителю РАЗДЕЛИТЕЛЬ, который может быть пустой строкой. Если указан параметр -m или --max, на каждой СТРОКЕ выполняется не более MAX разделений. Если задан параметр -r или --right, разделение выполняется справа налево. Это полезно в сочетании с -m или --max. С -n или --no-empty пустые результаты исключаются из рассмотрения (например, hello\n\nworld будет расширяться до двух строк, а не трех). Код возврата: 0, если было выполнено хотя бы одно разделение, или 1 в противном случае.

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

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

string split0 разделяет каждую СТРОКУ по нулевому байту (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. Положительные значения индекса относятся к началу строки, а отрицательные — к концу. Значение по умолчанию для начала — 1. Длина подстроки может быть задана с помощью -l или --length. Если длина или конец не заданы, подстрока простирается до конца каждой строки. Код возврата: 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 удаляет начальные и конечные пробелы из каждой СТРОКИ. Если задан параметр -l или --left, удаляются только начальные пробелы. Если задан параметр -r или --right, удаляются только конечные пробелы. Параметр -c или --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.