5.5 Обработка строк

Octave поддерживает широкий спектр функций для обработки строк. Так как строка — это просто матрица, простые манипуляции можно выполнить с помощью стандартных операторов. Следующий пример демонстрирует, как заменить все пробелы символами подчёркивания.

quote = ...
  "First things first, but not necessarily in that order";
quote( quote == " " ) = "_"
⇒ quote =
    First_things_first,_but_not_necessarily_in_that_order

Для более сложных манипуляций, таких как поиск, замена и использование регулярных выражений, в Octave доступны следующие функции.

: deblank (s)

Удаляет хвостовые пробелы и нули из s.

Если s является матрицей, deblank обрезает каждую строку до длины самой длинной строки. Если s — это ячейный массив строк, операция выполняется рекурсивно на каждом элементе строки.

Примеры:

deblank ("    abc  ")
     ⇒  "    abc"

deblank ([" abc   "; "   def   "])
     ⇒  [" abc  " ; "   def"]

См. также: strtrim.

: strtrim (s)

Удаляет начальные и хвостовые пробелы из s.

Если s является матрицей, strtrim обрезает каждую строку до длины самой длинной строки. Если s — это ячейный массив строк, операция выполняется рекурсивно на каждом элементе строки.

Например:

strtrim ("    abc  ")
     ⇒  "abc"

strtrim ([" abc   "; "   def   "])
     ⇒  ["abc  "  ; "  def"]

См. также: deblank.

: strtrunc (s, n)

Усекает строку s до длины n.

Если s — матрица символов, то количество столбцов корректируется.

Если s — ячейный массив строк, то операция выполняется над каждым элементом ячейки, и возвращается новый ячейный массив.

: findstr (s, t)

: findstr (s, t, overlap)

Эта функция устарела. Используйте strfind вместо неё.

Возвращает вектор всех позиций в большей из двух строк s и t, где начинается вхождение меньшей из двух строк.

Если необязательный аргумент overlap имеет значение true (по умолчанию), возвращаемый вектор может включать перекрывающиеся позиции. Например:

findstr ("ababab", "a")
     ⇒ [1, 3, 5];
findstr ("abababa", "aba", 0)
     ⇒ [1, 5]

Внимание: findstr устарела. Используйте strfind во всех новых кодах.

См. также: strfind, strmatch, strcmp, strncmp, strcmpi, strncmpi, find.

: idx = strchr (str, chars)

: idx = strchr (str, chars, n)

: idx = strchr (str, chars, n, direction)

: [i, j] = strchr (…)

Ищет в строке str вхождения символов из набора chars.

Значение возвращаемого значения(й), а также аргументы n и direction ведут себя идентично как в find.

Это будет быстрее, чем использование regexp в большинстве случаев.

См. также: find.

: index (s, t)

: index (s, t, direction)

Возвращает позицию первого вхождения строки t в строку s или 0, если вхождение не найдено.

s также может быть строковой матрицей или ячейным массивом строк.

Например:

index ("Teststring", "t")
    ⇒ 4

Если direction имеет значение "first", возвращает первый найденный элемент. Если direction имеет значение "last", возвращает последний найденный элемент.

См. также: find, rindex.

: rindex (s, t)

Возвращает позицию последнего вхождения строки t в строку s, или 0, если вхождение не найдено.

s также может быть строковой матрицей или ячейным массивом строк.

Например:

rindex ("Teststring", "t")
     ⇒ 6

Функция rindex эквивалентна index с direction установленным на "last".

См. также: find, index.

: idx = strfind (str, pattern)

: idx = strfind (cellstr, pattern)

: idx = strfind (…, "overlaps", val)

: idx = strfind (…, "forcecelloutput", val)

Ищет pattern в строке str и возвращает начальный индекс каждого такого вхождения в вектор idx.

Если вхождение не найдено, или pattern длиннее str, или pattern само пустое, то idx — это пустой массив [].

Необязательный аргумент "overlaps" определяет, может ли шаблон совпадать в каждой позиции в str (true), или только для уникальных вхождений полного шаблона (false). По умолчанию — true.

Если указан ячейный массив строк cellstr, то idx — ячейный массив векторов, как указано выше.

Необязательный аргумент "forcecelloutput" принудительно возвращает idx как ячейный массив векторов. По умолчанию — false.

Примеры:

strfind ("abababa", "aba")
     ⇒ [1, 3, 5]


strfind ("abababa", "aba", "overlaps", false)
     ⇒ [1, 5]


strfind ({"abababa", "bebebe", "ab"}, "aba")
     ⇒
        {
          [1,1] =

             1   3   5

          [1,2] = [](1x0)
          [1,3] = [](1x0)
        }


strfind ("abababa", "aba", "forcecelloutput", true)
     ⇒
        {
          [1,1] =

             1   3   5
        }

См. также: regexp, regexpi, find.

: str = strjoin (cstr)

: str = strjoin (cstr, delimiter)

Объединяет элементы ячейного массива строк cstr в одну строку.

Если delimiter не указан, элементы cstr разделяются пробелом.

Если delimiter задан как строка, ячейный массив строк объединяется с использованием этой строки. Поддерживаются escape-последовательности.

Если delimiter является ячейным массивом строк длиной на один меньше, чем cstr, то элементы cstr объединяются, чередуя элементы ячейного массива delimiter. Escape-последовательности не поддерживаются.

strjoin ({'Octave','Scilab','Lush','Yorick'}, '*')
      ⇒ 'Octave*Scilab*Lush*Yorick'

См. также: strsplit.

: strmatch (s, A)

: strmatch (s, A, "exact")

Эта функция устарела. Используйте альтернативу, например strncmp или strcmp вместо неё.

Возвращает индексы элементов A, которые начинаются со строки s.

Второй аргумент A должен быть строкой, матрицей символов или ячейным массивом строк.

Если третий аргумент "exact" не задан, то s должен совпадать с A до длины s. При поиске совпадений хвостовые пробелы и нули в s и A игнорируются.

Например:

strmatch ("apple", "apple juice")
     ⇒ 1

strmatch ("apple", ["apple  "; "apple juice"; "an apple"])
     ⇒ [1; 2]

strmatch ("apple", ["apple  "; "apple juice"; "an apple"], "exact")
     ⇒ [1]

Внимание: strmatch устарела (и может давать некорректные результаты в MATLAB при использовании с ячейными массивами строк. Используйте strncmp (обычный случай) или strcmp (случай "exact") во всех новых кодах. Другие возможные замены, в зависимости от применения, включают regexp или validatestring.

См. также: strncmp, strcmp, regexp, strfind, validatestring.

: [tok, rem] = strtok (str)

: [tok, rem] = strtok (str, delim)

Находит все символы в строке str до, но не включая, первого символа, присутствующего в строке delim.

str также может быть ячейным массивом строк, в котором случае функция выполняется для каждой отдельной строки и возвращает ячейный массив токенов и остатков.

Лидирующие разделители игнорируются. Если delim не указан, предполагаются пробелы.

Если требуется rem, он содержит остаток строки, начиная с первого разделителя.

Примеры:

strtok ("this is the life")
     ⇒ "this"

[tok, rem] = strtok ("14*27+31", "+-*/")
     ⇒
        tok = 14
        rem = *27+31

См. также: index, strsplit, strchr, isspace.

: [cstr] = strsplit (str)

: [cstr] = strsplit (str, del)

: [cstr] = strsplit (…, name, value)

: [cstr, matches] = strsplit (…)

Разделить строку str с помощью разделителей, указанных в del, и вернуть ячейковый массив строк подстрок.

Если разделитель не указан, строка разделяется по пробелам {" ", "\f", "\n", "\r", "\t", "\v"}. В противном случае разделитель del должен быть строкой или ячейковым массивом строк. По умолчанию последовательные разделители во входной строке s сводятся к одному, что приводит к одному разделению.

Поддерживаемые аргументы name/value:

• collapsedelimiters, который может принимать значение true (по умолчанию) или false.
• delimitertype, который может принимать значение "simple" (по умолчанию) или "regularexpression". Простой разделитель точно соответствует тексту как он написан. В противном случае используется синтаксис регулярных выражений, описанный в regexp.

Необязательный второй вывод matches возвращает разделители, которые были сопоставлены в исходной строке.

Примеры с простыми разделителями:

strsplit ("a b c")
      ⇒
          {
            [1,1] = a
            [1,2] = b
            [1,3] = c
          }

strsplit ("a,b,c", ",")
      ⇒
          {
            [1,1] = a
            [1,2] = b
            [1,3] = c
          }

strsplit ("a foo b,bar c", {" ", ",", "foo", "bar"})
      ⇒
          {
            [1,1] = a
            [1,2] = b
            [1,3] = c
          }

strsplit ("a,,b, c", {",", " "}, "collapsedelimiters", false)
      ⇒
          {
            [1,1] = a
            [1,2] =
            [1,3] = b
            [1,4] =
            [1,5] = c
          }

Примеры с разделителями регулярных выражений:

strsplit ("a foo b,bar c", ',|\s|foo|bar', ...
          "delimitertype", "regularexpression")
⇒
{
            [1,1] = a
            [1,2] = b
            [1,3] = c
}

strsplit ("a,,b, c", '[, ]', "collapsedelimiters", false, ...
          "delimitertype", "regularexpression")
⇒
{
            [1,1] = a
            [1,2] =
            [1,3] = b
            [1,4] =
            [1,5] = c
}

strsplit ("a,\t,b, c", {',', '\s'}, "delimitertype", "regularexpression")
⇒
{
            [1,1] = a
            [1,2] = b
            [1,3] = c
}

strsplit ("a,\t,b, c", {',', ' ', '\t'}, "collapsedelimiters", false)
⇒
{
            [1,1] = a
            [1,2] =
            [1,3] =
            [1,4] = b
            [1,5] =
            [1,6] = c
}

См. также: ostrsplit, strjoin, strtok, regexp.

: [cstr] = ostrsplit (s, sep)

: [cstr] = ostrsplit (s, sep, strip_empty)

Разделить строку s с использованием одного или нескольких разделителей sep и вернуть ячейковый массив строк.

Последовательные разделители и разделители на границах приводят к пустым строкам, если strip_empty не равно true. Значение по умолчанию для strip_empty — false.

Двумерные массивы символов разделены разделителями и исходными границами столбцов.

Пример:

ostrsplit ("a,b,c", ",")
      ⇒
          {
            [1,1] = a
            [1,2] = b
            [1,3] = c
          }

ostrsplit (["a,b" ; "cde"], ",")
      ⇒
          {
            [1,1] = a
            [1,2] = b
            [1,3] = cde
          }

См. также: strsplit, strtok.

: [a, …] = strread (str)

: [a, …] = strread (str, format)

: [a, …] = strread (str, format, format_repeat)

: [a, …] = strread (str, format, prop1, value1, …)

: [a, …] = strread (str, format, format_repeat, prop1, value1, …)

Эта функция устарела. Используйте textscan вместо неё.

Считывание данных из строки.

Строка str разбивается на слова, которые многократно сопоставляются с указателями в format. Первое слово сопоставляется с первым указателем, второе со вторым и так далее. Если слов больше, чем указателей, процесс повторяется до тех пор, пока все слова не будут обработаны.

Строка format описывает, как слова в str должны быть обработаны. Она может содержать любую комбинацию следующих указателей:

%s

Слово обрабатывается как строка.

%f

%n

Слово обрабатывается как число и преобразуется в double.

%d

%u

Слово обрабатывается как число и преобразуется в int32.

%*

%*f

%*s

Слово пропускается.

Для %s и %d, %f, %n, %u и соответствующих %*s … указателей может быть указана необязательная ширина, например, %Ns и т. д., где N — целое число > 1. Для %f разрешены указатели формата, такие как %N.Mf.

literals

Кроме того, формат может содержать буквальные строковые символы; эти символы будут пропущены во время чтения.

Обработанные слова, соответствующие первому указателю, возвращаются в первом выходном аргументе, и так далее для остальных указателей.

По умолчанию format — "%f", что означает, что числа считываются из str. Это сработает, если str содержит только числовые поля.

Например, строка

str = "\
Bunny Bugs   5.5\n\
Duck Daffy  -7.5e-5\n\
Penguin Tux   6"

может быть прочитана с помощью

[a, b, c] = strread (str, "%s %s %f");

Необязательный числовой аргумент format_repeat может быть использован для ограничения числа считываемых элементов:

-1

(по умолчанию) считывает всю строку до конца.

N

Считать N раз nargout элементов. 0 (ноль) — допустимое значение для format_repeat.

Поведение strread может быть изменено с помощью пар свойство-значение. Признаются следующие свойства:

"commentstyle"

Части str рассматриваются как комментарии и будут пропущены. value — стиль комментария и может быть любым из следующих.

• "shell" Всё от # символов до ближайшей строки.
• "c" Всё между /* и */.
• "c++" Всё от // символов до ближайшей строки.
• "matlab" Всё от % символов до ближайшей строки.
• пользовательские. Два варианта: (1) Одна строка или 1x1 ячейковая строка: Пропускать всё справа от неё; (2) 2x1 ячейковый массив строк: пропускать всё между левой и правой строками.

"delimiter"

Любой символ в value будет использоваться для разделения str на слова (значение по умолчанию = любой пробел). Обратите внимание, что пробел неявно добавляется в набор символов-разделителей, если не указан указатель преобразования формата "%s"; см. параметр "whitespace" ниже. Набор символов-разделителей не может быть пустым; в случае необходимости Octave заменяет пробел в качестве разделителя.

"emptyvalue"

Значение, возвращаемое для пустых числовых значений в данных, неразделённых пробелами. Значение по умолчанию — NaN. Когда тип данных не поддерживает NaN (например, int32), по умолчанию используется ноль.

"multipledelimsasone"

Обрабатывать серию последовательных разделителей без пробелов между ними как один разделитель. Последовательности разделителей не обязательно должны быть вертикальными "aligned".

"treatasempty"

Рассматривать одиночные вхождения (окружённые разделителями или пробелами) строки(строк) в value как отсутствующие значения.

"returnonerror"

Если value истинно (1, по умолчанию), игнорировать ошибки чтения и возвращаться нормально. Если ложно (0), возвращать ошибку.

"whitespace"

Любой символ в value будет интерпретироваться как пробел и обрезаться; строка, определяющая пробел, должна быть заключена в двойные кавычки для правильной обработки специальных символов, таких как "\t". В каждом поле данных несколько последовательных пробелов сводятся к одному пробелу, а ведущие и хвостовые пробелы удаляются. Значение по умолчанию для пробелов — " \b\r\n\t" (обратите внимание на пробел). Пробел всегда добавляется в набор символов-разделителей, если не указан хотя бы один указатель преобразования формата "%s" формата; в этом случае только пробелы, явно указанные в "delimiter" сохраняются как разделитель и удаляются из набора символов пробелов. Если символы пробелов должны сохраняться как есть (например, в строках), укажите пустое значение (т. е. "") для "whitespace"; очевидно, что пробел не может быть разделителем в таком случае.

Когда количество слов в str не соответствует точно кратному числу указателей преобразования формата, поведение strread зависит от последнего символа str:

последний символ = "\n"

Столбцы данных дополняются пустыми полями или NaN, чтобы все столбцы имели одинаковую длину

последний символ не "\n"

Столбцы данных не дополняются; strread возвращает столбцы неодинаковой длины

См. также: textscan, sscanf.

: newstr = strrep (str, ptn, rep)

: newstr = strrep (cellstr, ptn, rep)

: newstr = strrep (…, "overlaps", val)

Заменить все вхождения шаблона ptn в строке str на строку rep и вернуть результат.

Необязательный аргумент "overlaps" определяет, может ли шаблон соответствовать в любой позиции в str (истина), или только уникальным появлениям всего шаблона (ложь). По умолчанию — истина.

s также может быть ячейковым массивом строк, в этом случае замена выполняется для каждого элемента, и возвращается ячейковый массив.

Пример:

strrep ("This is a test string", "is", "&%$")
    ⇒  "Th&%$ &%$ a test string"

См. также: regexprep, strfind.

: newstr = erase (str, ptn)

Удалить все вхождения ptn в str.

str и ptn могут быть обычными строками, ячейковым массивом строк или массивом символов.

Примеры

## string, single pattern
erase ("Hello World!", " World")
    ⇒ "Hello!"

## cellstr, single pattern
erase ({"Hello", "World!"}, "World")
    ⇒ {"Hello", "!"}

## string, multiple patterns
erase ("The Octave interpreter is fabulous", ...
       {"interpreter ", "The "})
    ⇒ "Octave is fabulous"

## cellstr, multiple patterns
erase ({"The ", "Octave interpreter ", "is fabulous"}, ...
       {"interpreter ", "The "})
    ⇒ {"", "Octave ", "is fabulous"}

Примечание по программированию: erase удаляет первое вхождение шаблона в строке, когда есть перекрывающиеся вхождения. Например:

erase ("abababa", "aba")
    ⇒ "b"

См. strrep для обработки перекрытий.

См. также: strrep, regexprep.

: substr (s, offset)

: substr (s, offset, len)

Возвращает подстроку s, которая начинается с символа с номером offset и имеет длину len символов.

Нумерация позиций для смещений начинается с 1. Если offset отрицательное, извлечение начинается на этом расстоянии от конца строки.

Если len опущено, подстрока простирается до конца s. Отрицательное значение len извлекает подстроку до положения, отстоящего на len символов от конца строки.

Примеры:

substr ("This is a test string", 6, 9)
     ⇒ "is a test"
substr ("This is a test string", -11)
     ⇒ "test string"
substr ("This is a test string", -11, -7)
     ⇒ "test"

Эта функция смоделирована по аналогии с одноимённой функцией в Perl.

: [s, e, te, m, t, nm, sp] = regexp (str, pat)

: […] = regexp (str, pat, "opt1", …)

Сопоставление с шаблоном регулярного выражения в строке.

Ищет pat в строке str (кодировка UTF-8) и возвращает позиции и подстроки совпадений, или пустые значения, если совпадений нет.

Шаблон поиска pat может содержать стандартные операторы регулярных выражений, включая:

.

Соответствие любому символу

* + ? {}

Операторы повторения, обозначающие

*

Соответствие нулю или более раз

+

Соответствие одному или более раз

?

Соответствие нулю или одному разу

{n}

Соответствие ровно n раз

{n,}

Соответствие n или более раз

{m,n}

Соответствие от m до n раз

[…] [^…]

Операторы списка. Шаблон будет соответствовать любому символу, указанному между "[" и "]". Если первый символ — "^", шаблон будет соответствовать любому символу, кроме тех, которые указаны в скобках.

В операторах списка также могут использоваться escape-последовательности, определённые ниже. Например, шаблон для числа с плавающей точкой может быть [-+.\d]+.

() (?:)

Оператор группирования. Первая форма (только скобки) также создаёт маркер.

|

Оператор альтернации. Сопоставление с одним из набора регулярных выражений. Альтернативы должны быть ограничены оператором группирования ().

^ $

Операторы привязки. Требуют, чтобы шаблон встречался в начале (^) или конце ($) строки.

Кроме того, следующие экранированные символы имеют специальное значение.

\d

Соответствие любой цифре

\D

Соответствие любой не-цифре

\s

Соответствие любому символу пробела

\S

Соответствие любому не-символу пробела

\w

Соответствие любому символу слова

\W

Соответствие любому не-символу слова

\<

Соответствие началу слова

\>

Соответствие концу слова

\B

Соответствие внутри слова

Примечание об реализации: для совместимости с MATLAB, escape-последовательности в pat (например, "\n" => перевод строки) расширяются даже когда pat определён с одинарными кавычками. Чтобы отключить расширение, используйте двойной обратный слэш перед escape-последовательностью (например, \\n) или используйте функцию regexptranslate.

Выходные данные regexp по умолчанию имеют порядок, указанный ниже

s

Индексы начала каждой совпадающей подстроки

e

Индексы конца каждой совпадающей подстроки

te

Границы каждого сопоставленного токена, окружённого (…) в pat

m

Массив ячеек текста каждого совпадения

t

Массив ячеек текста каждого сопоставленного токена

nm

Структура, содержащая текст каждого сопоставленного именованного токена, при этом имя используется в качестве имени поля. Именованный токен обозначается (?<name>…).

sp

Массив ячеек текста, не возвращённого сопоставлением, т.е. то, что остаётся, если вы разделили строку на основе pat.

Конкретные выходные аргументы или порядок выходных аргументов могут быть выбраны с помощью дополнительных аргументов opt. Эти аргументы — строки, и соответствие между выходными аргументами и опциональными аргументами:

	'start'	s
	'end'	e
	'tokenExtents'	te
	'match'	m
	'tokens'	t
	'names'	nm
	'split'	sp

Дополнительные аргументы перечислены ниже.

‘once’

Возвращает только первое вхождение шаблона.

‘matchcase’

Делает сопоставление чувствительным к регистру. (по умолчанию)

Альтернативно, используйте (?-i) в шаблоне.

‘ignorecase’

Игнорирует регистр при сопоставлении шаблона со строкой.

Альтернативно, используйте (?i) в шаблоне.

‘stringanchors’

Сопоставляет символы привязки в начале и конце строки. (по умолчанию)

Альтернативно, используйте (?-m) в шаблоне.

‘lineanchors’

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

Альтернативно, используйте (?m) в шаблоне.

‘dotall’

Шаблон . сопоставляет все символы, включая символ перевода строки. (по умолчанию)

Альтернативно, используйте (?s) в шаблоне.

‘dotexceptnewline’

Шаблон . сопоставляет все символы, кроме символа перевода строки.

Альтернативно, используйте (?-s) в шаблоне.

‘literalspacing’

Все символы в шаблоне, включая пробелы, значимы и используются в сопоставлении с шаблоном. (по умолчанию)

Альтернативно, используйте (?-x) в шаблоне.

‘freespacing’

Шаблон может содержать произвольные пробелы и комментарии, начинающиеся с символа ‘#’.

Альтернативно, используйте (?x) в шаблоне.

‘noemptymatch’

Совпадения нулевой длины не возвращаются. (по умолчанию)

‘emptymatch’

Возвращает совпадения нулевой длины.

regexp ('a', 'b*', 'emptymatch') возвращает [1 2] потому что есть ноль или более 'b' символов в позициях 1 и конца строки.

Примечание о ограничении стека: Поиск шаблона выполняется рекурсивной функцией, которая может привести к переполнению стека программы при большом количестве совпадений. Например,

regexp (repmat ('a', 1, 1e5), '(a)+')

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

См. также: regexpi, strfind, regexprep.

: [s, e, te, m, t, nm, sp] = regexpi (str, pat)

: […] = regexpi (str, pat, "opt1", …)

Нечувствительное к регистру сопоставление с шаблоном регулярного выражения в строке.

Ищет pat в строке str (кодировка UTF-8) и возвращает позиции и подстроки совпадений, или пустые значения, если совпадений нет. Подробнее о синтаксисе шаблона поиска см. в regexp.

См. также: regexp.

: outstr = regexprep (string, pat, repstr)

: outstr = regexprep (string, pat, repstr, "opt1", …)

Заменяет все вхождения шаблона pat в string на repstr.

Шаблон — регулярное выражение, как описано для regexp. См. regexp.

Все строки должны быть закодированы в UTF-8.

Строка замены может содержать $i, которое заменяет i-ю пару скобок в строке совпадения. Например,

regexprep ("Bill Dunn", '(\w+) (\w+)', '$2, $1')

возвращает "Dunn, Bill"

Дополнительно к опциям regexp:

‘once’

Заменяет только первое вхождение pat в результате.

‘warnings’

Этот параметр присутствует для совместимости, но игнорируется.

Примечание об реализации: для совместимости с MATLAB, escape-последовательности в pat (например, "\n" => перевод строки) расширяются даже когда pat определён с одинарными кавычками. Чтобы отключить расширение, используйте двойной обратный слэш перед escape-последовательностью (например, \\n) или используйте функцию regexptranslate.

См. также: regexp, regexpi, strrep.

: regexptranslate (op, s)

Перевести строку для использования в регулярном выражении.

Это может включать либо замену символов-подстановок, либо экранирование специальных символов.

Поведение контролируется op, который может принимать следующие значения

"wildcard"

Символы-подстановки ., *, и ? заменяются символами-подстановками, подходящими для регулярного выражения. Например:

regexptranslate ("wildcard", "*.m")
     ⇒ '.*\.m'

"escape"

Символы $.?[], имеющие специальное значение для регулярных выражений, экранируются, чтобы они обрабатывались буквально. Например:

regexptranslate ("escape", "12.5")
     ⇒ '12\.5'

См. также: regexp, regexpi, regexprep.

: untabify (t)

: untabify (t, tw)

: untabify (t, tw, deblank)

Заменяет символы ТАБУ в t пробелами.

Входные данные t могут быть двумерным массивом символов или ячейкой массива строк. Выходной тип данных совпадает с входным типом.

Ширина табуляции задаётся tw и по умолчанию равна восьми.

Если необязательный аргумент deblank равен true, пробелы в конце символьных данных будут удалены.

Следующий пример читает файл и записывает его нетабулированную версию, удаляя пробелы в конце.

fid = fopen ("tabbed_script.m");
text = char (fread (fid, "uchar")');
fclose (fid);
fid = fopen ("untabified_script.m", "w");
text = untabify (strsplit (text, "\n"), 8, true);
fprintf (fid, "%s\n", text{:});
fclose (fid);

См. также: strjust, strsplit, deblank.

: idx = unicode_idx (str)

Возвращает массив с индексами каждого символа кодировки UTF-8 в str.

unicode_idx ("aäbc")
     ⇒ [1, 2, 2, 3, 4]