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. Это наиболее полезно в сочетании с инструментами, которые принимают входные данные, разделённые нулевым байтом, например, 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)] [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 считается допустимым совпадением только если он соответствует всей строке.

Если указаны --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

Примеры совпадений regex

>_ 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, заполняйте пробелами вместо пробелов.

Вывод выравнивается до максимальной ширины всех входных строк. Если указан -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 и --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 указаны, выполняется не более 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 по умолчанию работает в режиме 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.