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

Описание

string collect [(-N | --no-trim-newlines)] [STRING...]
string escape [(-n | --no-quoted)] [--style=xxx] [STRING...]
string join [(-q | --quiet)] 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)] [(-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 REPLACEMENT [STRING...]
string split [(-m | --max) MAX] [(-n | --no-empty)] [(-q | --quiet)] [(-r | --right)] SEP [STRING...]
string split0 [(-m | --max) MAX] [(-n | --no-empty)] [(-q | --quiet)] [(-r | --right)] [STRING...]
string sub [(-s | --start) START] [(-l | --length) LENGTH] [(-q | --quiet)] [STRING...]
string trim [(-l | --left)] [(-r | --right)] [(-c | --chars CHARS)] [(-q | --quiet)] [STRING...]
string unescape [--style=xxx] [STRING...]
string upper [(-q | --quiet)] [STRING...]

Описание

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

Аргументы STRING берутся из командной строки, если стандартный ввод не подключён к конвейеру или файлу, в противном случае они читаются со стандартного ввода, по одной строке STRING на строку. Недопустимо передавать аргументы STRING и в командной строке, и со стандартного ввода.

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

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

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

"collect" подкоманда

string collect [(-N | --no-trim-newlines)] [STRING...]

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

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

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

Примеры

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

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

"escape" и "unescape" подкоманды

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

string escape экранирует каждую строку STRING одним из трех способов. Первый — --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 соединяет свои аргументы STRING в одну строку, разделённую SEP, которая может быть пустой строкой. Код возврата: 0, если хотя бы одно соединение было выполнено, или 1 в противном случае.

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

Примеры

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

"length" подкоманда

string length [(-q | --quiet)] [STRING...]

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

Примеры

>_ string length 'hello, world'
12

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

"lower" подкоманда

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

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

"match" подкоманда

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

string match проверяет каждую строку STRING на соответствие PATTERN и выводит соответствующие подстроки. Только первое соответствие для каждой строки STRING отображается, если не указан -a или --all, в этом случае отображаются все соответствия.

Если вы укажете -e или --entire, то каждая соответствующая строка выводится, включая любой префикс или суффикс, не совпадающий с шаблоном (эквивалентно grep без флага -o). Вы, очевидно, можете получить тот же результат, добавив * или .* в зависимости от того, указан ли флаг --regex. Флаг --entire просто способ избежать усложнения шаблона и сделать намерение string match более ясным. Без флагов --entire и --regex, PATTERN должен соответствовать всей строке STRING, прежде чем он будет отображён.

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

Если указаны --index или -n, каждое совпадение отображается как начальная позиция (с 1) и длина. По умолчанию PATTERN интерпретируется как шаблон glob, сопоставляемый с каждым полным аргументом STRING. Шаблон glob считается допустимым соответствием только в том случае, если он соответствует всей строке STRING.

Если указаны --regex или -r, PATTERN интерпретируется как совместимое с Perl регулярное выражение, которое не обязательно должно соответствовать всей строке STRING. Для регулярного выражения, содержащего группы захвата, будут отображаться несколько элементов для каждого совпадения: одно для всего совпадения и одно для каждой группы захвата. В этом случае будет отображаться только соответствующая часть строки STRING, если не указан --entire.

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

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

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

Примеры с использованием шаблонов glob

>_ 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" подкоманда

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

string pad расширяет каждую строку STRING до заданной ширины, добавляя CHAR слева.

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

Если указаны -c или --char, использовать 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.

"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. --count и --max принимают число, большее или равное нулю; в случае нуля ничего не будет выведено. Если указаны -N или --no-newline, в выводе не будет символа новой строки в конце. Код возврата: 0, если сгенерированная строка не пустая, 1 в противном случае.

Примеры

Примеры использования подкоманды repeat

>_ 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 указано, то выполняется не более MAX разделений для каждой строки STRING. Если -r или --right задано, разделение выполняется справа налево. Это полезно в сочетании с -m или --max. С -n или --no-empty, пустые результаты исключаются из рассмотрения (например, hello\n\nworld будет расширяться до двух строк, а не трёх). Код возвращает 0, если по крайней мере одно разделение было выполнено, или 1 в противном случае.

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

См. также опцию --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,5 '' abc
a
c

Примеры с разделителями NUL

>_ # 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. Если длина или конец не указаны, подстрока продолжается до конца каждой строки 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 match по умолчанию — режим glob, в то время как у replace по умолчанию — режим буквального соответствия. Если установлен режим regex, они используют регулярные выражения 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.