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 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 выполняет операции со строками.

Аргументы типа STRING берутся из командной строки, если стандартный ввод не подключен к конвейеру или файлу, в противном случае они считываются со стандартного ввода, по одной строке 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 экранирует каждую строку 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 в противном случае. Если -n или --no-empty указано, пустые строки исключаются из рассмотрения (например, string join -n + a b "" c расширяется до a+b+c, а не a+b++c).

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] [-V | --visible] [STRING ...]

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

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

>_ 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 проверяет каждую строку STRING на соответствие PATTERN и выводит совпадающие подстроки. Только первое совпадение для каждой строки STRING отображается, если не указан -a или --all, в этом случае отображаются все совпадения.

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

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

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

Если указано --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 в противном случае.

>_ 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 слева. Это означает ширину всех видимых символов, сложенных вместе, исключая последовательности escape и учитывая fish_emoji_width и fish_ambiguous_width. Это количество столбцов в терминале, которые занимает строка STRING.

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

Если используется -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.
• длина строки с опцией --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. Обе опции --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-стилевые escape-последовательности, такие как 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 будет расширяться до двух строк, а не трёх).

Используйте опцию -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, после чего следует значение индекса с единицы. Положительные значения индекса относятся к началу строки, отрицательные — к концу строки. Значение start по умолчанию — 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 по умолчанию — совпадение шаблонов, а у 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.