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

Синопсис

string collect [-N | --no-trim-newlines] [STRING ...]
string escape [-n | --no-quoted] [--style=] [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 REPLACE [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=] [STRING ...]
string upper [-q | --quiet] [STRING ...]

Описание

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

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

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

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

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

“collect” подкоманда

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

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

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

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

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

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

Примеры

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

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

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

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

“escape” и “unescape” подкоманды

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

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

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

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

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

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

Примеры

>_ echo \x07 | string escape
\cg

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

“join” и “join0” подкоманды

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

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

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

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

Примеры

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

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

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

“length” подкоманда

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

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

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

Примеры

>_ string length 'hello, world'
12

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

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

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

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

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

“lower” подкоманда

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

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

“match” подкоманда

string match [-a | --all] [-e | --entire] [-i | --ignore-case]
             [-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 в противном случае.

Примеры соответствия 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 расширяет каждую СТРОКУ до заданной видимой ширины, добавляя СИМВОЛ слева. Это означает ширину всех видимых символов вместе, исключая последовательности 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 может использоваться для отображения того, что fish считает шириной.

“repeat” подкоманда

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

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

Используйте -f или --fields для вывода определённых полей. Если заданное поле не существует, команда завершается с кодом 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,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] [(-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 по умолчанию работает в режиме совпадения по шаблону, а replace по умолчанию работает с буквальным соответствием. Если установить режим регулярных выражений, они используют регулярные выражения PCRE, что сопоставимо с опцией -P grep. match по умолчанию выводит только совпадение, что похоже на grep с -o (используйте --entire, чтобы включить поведение наподобие grep).

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

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