Сравнение языков программирования (строковые функции)

Строковые функции используются в языках программирования для манипулирования строкой или запроса информации о ней (некоторые делают и то, и другое).

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

Для функций, которые манипулируют строками, современные объектно-ориентированные языки, такие как C# и Java , имеют неизменяемые строки и возвращают копию (во вновь выделенной динамической памяти), в то время как другие, такие как C, манипулируют исходной строкой, если программист не копирует данные в новую строку. См., например, Конкатенацию ниже.

Самый простой пример строковой функции — это length(string) функция. Эта функция возвращает длину строкового литерала .

например length("hello world") вернул бы 11.

В других языках могут быть строковые функции с похожим или точно таким же синтаксисом, параметрами или результатами. Например, во многих языках функция длины обычно представляется как len(string) . Приведенный ниже список общих функций призван помочь избежать этой путаницы.

Общие строковые функции (многоязычный справочник)

Ниже перечислены строковые функции, общие для многих языков, включая различные используемые имена. Приведенный ниже список общих функций призван помочь программистам найти эквивалентную функцию на языке. строк Обратите внимание: конкатенация и регулярные выражения обрабатываются на отдельных страницах. Утверждения, написанные каймами («…»), необязательны.

ЧарАт

Определение	`charAt(string,integer)` возвращает символ.
Описание	Возвращает символ по индексу в строке.
Эквивалент	См. подстроку длиной 1 символ.

Формат	Языки	Базовый индекс
`string[i]`	Алгол 68 , APL , Джулия , Паскаль , Object Pascal ( Delphi ), Seed7	1
`string[i]`	C , C++ , C# , Cobra , D , FreeBASIC , Go , Python , ^{[ 1 ]} PHP , Руби , ^{[ 1 ]} Windows PowerShell , JavaScript , APL	0
`string{i}`	PHP (устарело в версии 5.3)	0
`string(i)`	Есть	≥1
`Mid(string,i,1)`	ВБ	1
`MID$(string,i,1)`	БАЗОВЫЙ	1
`string.Chars(i)`	VB.NET	0
`string(i:i)`	Фортран	1
`string.charAt(i)`	Ява , JavaScript	0
`string.[i]`	OCaml , F#	0
`string.chars().nth(i)`	Ржавчина ^{[ 2 ]}	0
`string[i,1]`	Выберите базовый	1
`String.sub (string, i)`	Стандартный ML	0
`string !! i`	Хаскелл	0
`(string-ref string i)`	Схема	0
`(char string i)`	Общий Лисп	0
`(elt string i)`	ИСЛИСП	0
`(get string i)`	Кложур	0
`substr(string, i, 1)`	Перл 5 ^{[ 1 ]}	0
`substr(string, i, 1)` `string.substr(i, 1)`	Раку ^{[ 3 ]}	0
`substr(string, i, 1)`	ПЛ/Я	1
`string.at(i)`	C++ (STL) (с проверкой границ)	0
`lists:nth(i, string)`	Эрланг	1
`[string characterAtIndex:i]`	Цель-C ( `NSString *` только)	0
`string.sub(string, i, i)` `(string):sub(i, i)`	Два ^{[ 1 ]}	1
`string at: i`	Smalltalk (с проверкой границ)	1
`string index string i`	Ткл	0
`StringTake[string, {i}]`	Математика , Язык Wolfram ^{[ 1 ]}	1
`string@i`	Эйфелева	1
`string (i:1)`	КОБОЛ	1
`${string_param:i:1}`	Баш	0
`i⌷string`	АПЛ	0 или 1

{ Example in Pascal }
var
  MyStr: string = 'Hello, World';
  MyChar: Char;
begin
  MyChar := MyStr[2];          // 'e'

# Example in ALGOL 68 #
"Hello, World"[2];             // 'e'

// Example in C
#include <stdio.h>             // for printf
char MyStr[] = "Hello, World";
printf("%c", *(MyStr+1));      // 'e'
printf("%c", *(MyStr+7));      // 'W'
printf("%c", MyStr[11]);       // 'd'
printf("%s", MyStr);           // 'Hello, World'
printf("%s", "Hello(2), World(2)"); // 'Hello(2), World(2)'

// Example in C++
#include <iostream>            // for "cout"
#include <string.h>            // for "string" data type
using namespace std;
char MyStr1[] = "Hello(1), World(1)";
string MyStr2 = "Hello(2), World(2)";
cout << "Hello(3), World(3)";  // 'Hello(3), World(3)'
cout << MyStr2[6];             // '2'
cout << MyStr1.substr (5, 3);  // '(1)'

// Example in C#
"Hello, World"[2];             // 'l'

# Example in Perl 5
substr("Hello, World", 1, 1);  # 'e'

# Examples in Python
"Hello, World"[2]              #  'l'
"Hello, World"[-3]             #  'r'

# Example in Raku
"Hello, World".substr(1, 1);   # 'e'

' Example in Visual Basic
Mid("Hello, World",2,1)

' Example in Visual Basic .NET
"Hello, World".Chars(2)    '  "l"c

" Example in Smalltalk "
'Hello, World' at: 2.        "$e"

//Example in Rust
"Hello, World".chars().nth(2);   // Some('l')

Сравнить (целочисленный результат)

Определение	`compare(string₁,string₂)` возвращает целое число.
Описание	Сравнивает две строки друг с другом. Если они эквивалентны, возвращается ноль. В противном случае большинство этих подпрограмм вернут положительный или отрицательный результат, соответствующий тому, _{ли строка 1} является лексикографически соответственно _{больше или меньше строки 2} . Исключением являются процедуры Scheme и Rexx, которые возвращают индекс первого несоответствия, и Smalltalk, которые отвечают на код сравнения, сообщающий, как получатель сортирует относительно строкового параметра.

Формат	Языки
`IF string₁<string₂ THEN -1 ELSE ABS (string₁>string₂) FI`	АЛГОЛ 68
`cmp(string₁, string₂)`	Питон 2
`(string₁ > string₂) - (string₁ < string₂)`	Питон
`strcmp(string₁, string₂)`	С , PHP
`std.string.cmp(string₁, string₂)`	Д
`StrComp(string₁, string₂)`	VB , Объектный Паскаль ( Делфи )
`string₁ cmp string₂`	Жемчуг , Рак
`string₁ compare: string₂`	Smalltalk ( Писк , Фаро )
`string₁ <=> string₂`	Руби , C++ (STL, C++20 ) ^{[ 4 ]}
`string₁.compare(string₂)`	C++ (STL), Swift (основной)
`compare(string₁, string₂)`	Рекс , Сид7
`CompareStr(string₁, string₂)`	Паскаль , Объектный Паскаль ( Делфи )
`string₁.compareTo(string₂)`	Кобра , Ява
`string₁.CompareTo(string₂)`	ВБ.NET , C# , F#
`(compare string₁ string₂)`	Кложур
`(string= string₁ string₂)`	Общий Лисп
`(string-compare string₁ string₂ p< p= p>)`	Схема (СРФИ 13)
`(string= string₁ string₂)`	ИСЛИСП
`compare string₁ string₂`	OCaml
`String.compare (string₁, string₂)`	Стандартный ML ^{[ 5 ]}
`compare string₁ string₂`	Хаскелл ^{[ 6 ]}
`[string]::Compare(string₁, string₂)`	Windows PowerShell
`[string₁ compare:string₂]`	Цель-C ( `NSString *` только)
`LLT(string₁,string₂)` `LLE(string₁,string₂)` `LGT(string₁,string₂)` `LGE(string₁,string₂)`	Фортран ^{[ 7 ]}
`string₁.localeCompare(string₂)`	JavaScript
`bytes.Compare([]byte(string₁), []byte(string₂))`	Идти
`string compare string₁ string₂`	Ткл
`compare(string₁,string₂,count)`	ПЛ/Я ^{[ 8 ]}
`string₁.cmp(string₂)`	Ржавчина ^{[ 9 ]}

# Example in Perl 5
"hello" cmp "world";       # returns -1

# Example in Python
cmp("hello", "world")      # returns -1

# Examples in Raku
"hello" cmp "world";       # returns Less
"world" cmp "hello";       # returns More
"hello" cmp "hello";       # returns Same

/** Example in Rexx */
compare("hello", "world")  /* returns index of mismatch: 1 */

; Example in Scheme
(use-modules (srfi srfi-13))
; returns index of mismatch: 0
(string-compare "hello" "world" values values values)

Сравнение (реляционный оператор, логический результат)

Определение	`string₁ OP string₂` ИЛИ `(compare string₁ string₂)` возвращает логическое значение.
Описание	Лексикографически сравнивает две строки, используя реляционный оператор или функцию. Возвращен логический результат.

Формат	Языки
`string₁ OP string₂`, где `OP` может быть любым из `=, <>, <, >, <=` и `>=`	Паскаль , Object Pascal ( Delphi ), OCaml , Seed7 , Standard ML , BASIC , VB , VB .NET , F#
`string₁ OP string₂`, где `OP` может быть любым из `=, /=, ≠, <, >, <=, ≤` и `≥`; Также: `EQ, NE, LT, LE, GE` и `GT`	АЛГОЛ 68
`(stringOP? string₁ string₂)`, где `OP` может быть любым из `=, -ci=, <, -ci<, >, -ci>, <=, -ci<=, >=` и `-ci>=` (операторы, начинающиеся с ' `-ci`' не чувствительны к регистру)	Схема
`(stringOP string₁ string₂)`, где `OP` может быть любым из `=, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >=` и `-ci>=` (операторы, начинающиеся с ' `-ci`' не чувствительны к регистру)	Схема (СРФИ 13)
`(stringOP string₁ string₂)`, где `OP` может быть любым из `=, -equal, /=, -not-equal, <, -lessp, >, -greaterp, <=, -not-greaterp, >=` и `-not-lessp` (вербальные операторы нечувствительны к регистру)	Общий Лисп
`(stringOP string₁ string₂)`, где `OP` может быть любым из `=, /=, <, >, <=,` и `>=`	ИСЛИСП
`string₁ OP string₂`, где `OP` может быть любым из `=, \=, <, >, <=` и `>=`	Рекс
`string₁ OP string₂`, где `OP` может быть любым из `=, ¬=, <, >, <=, >=, ¬<` и `¬>`	ПЛ/Я
`string₁ OP string₂`, где `OP` может быть любым из `=, /=, <, >, <=` и `>=`	Есть
`string₁ OP string₂`, где `OP` может быть любым из `==, /=, <, >, =<` и `>=`	Эрланг
`string₁ OP string₂`, где `OP` может быть любым из `==, /=, <, >, <=` и `>=`	Хаскелл
`string₁ OP string₂`, где `OP` может быть любым из `eq, ne, lt, gt, le` и `ge`	Жемчуг , Рак
`string₁ OP string₂`, где `OP` может быть любым из `==, !=, <, >, <=` и `>=`	C++ (STL), C# , D , Go , JavaScript , Python , PHP , Ruby , Rust , ^{[ 10 ]} Быстрый
`string₁ OP string₂`, где `OP` может быть любым из `-eq, -ceq, -ne, -cne, -lt, -clt, -gt, -cgt, -le, -cle, -ge,` и `-cge` (операторы, начинающиеся с ' `c`' чувствительны к регистру)	Windows PowerShell
`string₁ OP string₂`, где `OP` может быть любым из `==, ~=, <, >, <=` и `>=`	Два
`string₁ OP string₂`, где `OP` может быть любым из `=, ~=, <, >, <=` и `>=`	Смолток
`string₁ OP string₂`, где `OP` может быть любым из `==, /=, <, >, <=` и `>=; Also: .EQ., .NE., .LT., .LE., .GT.` и `.GE.`	Фортран . ^{[ 11 ]}
`string₁ OP string₂` где `OP` может быть любым из `=, <>, <, >, <=, >=` а также словесные эквиваленты	КОБОЛ
`string₁ OP string₂` где `OP` может быть любым из `==, <>, <, >, <=` и `>=`	Кобра
`string₁ OP string₂` доступен в синтаксисе, но означает сравнение указателей, указывающих на строки, а не ее содержимого. Используйте функцию сравнения (целочисленный результат).	С , Ява
`string₁.METHOD(string₂)` где `METHOD` есть ли кто-нибудь из `eq`, `ne`, `gt`, `lt`, `ge`, `le`	Ржавчина ^{[ 10 ]}

% Example in Erlang
"hello" > "world".            % returns false

# Example in Raku
"art" gt "painting";           # returns False
"art" lt "painting";           # returns True

# Example in Windows PowerShell
"hello" -gt "world"           # returns false

;; Example in Common Lisp
(string> "art" "painting")      ; returns nil
(string< "art" "painting")      ; returns non nil

Конкатенация

Определение	`concatenate(string₁,string₂)` возвращает строку.
Описание	Объединяет (объединяет) две строки друг с другом, возвращая объединенную строку. Обратите внимание, что в некоторых языках, таких как C, есть изменяемые строки, поэтому на самом деле вторая строка добавляется к первой строке, и возвращается измененная строка.

Формат	Языки
`string₁ & string₂`	Ada , FreeBASIC , Seed7 , BASIC , VB , VB.NET , COBOL (только между литералами)
`strcat(string₁, string₂)`	С , С++ ( `char *` только) ^{[ 12 ]}
`string₁ . string₂`	Перл , PHP
`string₁ + string₂`	АЛГОЛ 68 , C++ (STL), C# , Cobra , FreeBASIC , Go , Pascal , Object Pascal ( Delphi ), Java , JavaScript , Windows PowerShell , Python , Ruby , Rust , ^{[ 13 ]} F# , Свифт , Тьюринг , ВБ
`string₁ ~ string₂`	D , Raku
`(string-append string₁ string₂)`	Схема , ИСЛИСП
`(concatenate 'string string₁ string₂)`	Общий Лисп
`(str string₁ string₂)`	Кложур
`string₁ \|\| string₂`	Рекс , SQL , PL/I
`string₁ // string₂`	Фортран
`string₁ ++ string₂`	Эрланг , Хаскелл
`string₁ ^ string₂`	OCaml , стандартное машинное обучение , F#
`[string₁ stringByAppendingString:string₂]`	Цель-C ( `NSString *` только)
`string₁ .. string₂`	Два
`string₁ , string₂`	Смоллток , APL
`string₁ string₂`	СНОБОЛ
`string₁string₂`	Баш
`string₁ <> string₂`	Математика
конкат строка ₁ строка ₂	Ткл

{ Example in Pascal }
'abc' + 'def';      // returns "abcdef"

// Example in C#
"abc" + "def";      // returns "abcdef"

' Example in Visual Basic
"abc" & "def"       '  returns "abcdef"
"abc" + "def"       '  returns "abcdef"
"abc" & Null        '  returns "abc"
"abc" + Null        '  returns Null

// Example in D
"abc" ~ "def";      // returns "abcdef"

;; Example in common lisp
(concatenate 'string "abc " "def " "ghi")  ; returns "abc def ghi"

# Example in Perl 5
"abc" . "def";      # returns "abcdef"
"Perl " . 5;        # returns "Perl 5"

# Example in Raku
"abc" ~ "def";      # returns "abcdef"
"Perl " ~ 6;        # returns "Perl 6"

Содержит

Определение	`contains(string,substring)` возвращает логическое значение
Описание	Возвращает, ли строка содержит подстроку в качестве подстроки. Это эквивалентно использованию функции «Найти» , а затем обнаружению того, что это не приводит к состоянию сбоя, указанному в третьем столбце раздела «Найти». Однако в некоторых языках существует более простой способ выражения этого теста.
Связанный	Находить

Формат	Языки
`string_in_string(string, loc int, substring)`	АЛГОЛ 68
`ContainsStr(string, substring)`	Объектный Паскаль ( Делфи )
`strstr(string, substring) != NULL`	С , С++ ( `char *` только)
`string.Contains(substring)`	C# , VB.NET , Windows PowerShell , F#
`string.contains(substring)`	Кобра , Ява (1.5+), Раку , Ржавчина , ^{[ 14 ]} С++ ( С++23 ) ^{[ 15 ]}
`string.indexOf(substring) >= 0`	JavaScript
`strpos(string, substring) !== false`	PHP
`str_contains(string, substring)`	PHP (8+)
`pos(string, substring) <> 0`	Сид7
`substring in string`	Кобра , Питон (2.3+)
`string.find(string, substring) ~= nil`	Два
`string.include?(substring)`	Руби
`Data.List.isInfixOf substring string`	Хаскелл (GHC 6.6+)
`string includesSubstring: substring`	Smalltalk ( Писк , Фаро , Smalltalk/X )
`String.isSubstring substring string`	Стандартный ML
`(search substring string)`	Общий Лисп
`(not (null (string-index substring string)))`	ИСЛИСП
`(substring? substring string)`	Кложур
`! StringFreeQ[string, substring]`	Математика
`index(string, substring, startpos)>0`	Фортран, PL/I ^{[ 16 ]}
`index(string, substring, occurrence)>0`	Выберите базовый
`strings.Contains(string, substring)`	Идти
`string.find(substring) != string::npos`	С++
`[string containsString:substring]`	Цель-C ( `NSString *` только iOS 8+/OS X 10.10+)
`string.rangeOfString(substring) != nil`	Свифт (Фонд)
`∨/substring⍷string`	АПЛ

¢ Example in ALGOL 68 ¢
string in string("e", loc int, "Hello mate");      ¢ returns true ¢
string in string("z", loc int, "word");            ¢ returns false ¢

// Example In C#
"Hello mate".Contains("e");      // returns true
"word".Contains("z");            // returns false

#  Example in Python
"e" in "Hello mate"              #  returns true
"z" in "word"                    #  returns false

#  Example in Raku
"Good morning!".contains('z')    #  returns False
"¡Buenos días!".contains('í');   #  returns True

"  Example in Smalltalk "
'Hello mate' includesSubstring: 'e'  " returns true "
'word' includesSubstring: 'z'        " returns false "

Равенство

Проверяет, равны ли две строки. См. также #Compare и #Compare . Обратите внимание, что выполнение проверок на равенство с помощью общего результата сравнения с целым числом не только сбивает с толку программиста, но зачастую является значительно более дорогостоящей операцией; это особенно актуально при использовании « до-струн ».

Формат	Языки
`string₁ == string₂`	Python , C++ (STL), C# , Cobra , Go , JavaScript (сходство), PHP (сходство), Ruby , Rust , ^{[ 10 ]} Эрланг , Хаскелл , Lua , D , Mathematica , Swift
`string₁ === string₂`	JavaScript , PHP
`string₁ == string₂` `string₁ .EQ. string₂`	Фортран
`strcmp(string₁, string₂) == 0`	С
`(string=? string₁ string₂)`	Схема
`(string= string₁ string₂)`	Общий Лисп , ISLISP
`string₁ = string₂`	ALGOL 68 , Ada , Object Pascal ( Delphi ), OCaml , Pascal , Rexx , Seed7 , Standard ML , BASIC , VB , VB .NET , F# , Smalltalk , PL/I , COBOL
`test string₁ = string₂` `[ string₁ = string₂ ]`	Борн Шелл
`string₁ eq string₂`	Жемчуг , Рак
`string₁.equals(string₂)`	Кобра , Ява
`string₁.Equals(string₂)`	С#
`string₁ -eq string₂` `[string]::Equals(string₁, string₂)`	Windows PowerShell
`[string₁ isEqualToString:string₂]` `[string₁ isEqual:string₂]`	Цель-C ( `NSString *` только)
`string₁ ≡ string₂`	АПЛ
`string₁.eq(string₂)`	Ржавчина ^{[ 10 ]}

// Example in C#
"hello" == "world"           // returns false

' Example in Visual Basic
"hello" = "world"            '  returns false

# Examples in Perl 5
'hello' eq 'world'           # returns 0
'hello' eq 'hello'           # returns 1

# Examples in Raku
'hello' eq 'world'           # returns False
'hello' eq 'hello'           # returns True

# Example in Windows PowerShell
"hello" -eq "world"          #  returns false

⍝ Example in APL
'hello' ≡ 'world'          ⍝  returns 0

Находить

Определение	`find(string,substring)` возвращает целое число
Описание	Возвращает позицию начала первого вхождения подстроки в строке . Если подстрока не найдена, большинство этих подпрограмм возвращают недопустимое значение индекса – -1, когда индексы отсчитываются от 0, 0, когда они отсчитываются от 1, – или какое-то значение, которое интерпретируется как логическое значение FALSE.
Связанный	инстррев

Формат	Языки	Если не найден
`string in string(substring, pos, string[startpos:])`	АЛГОЛ 68	возвращает BOOL: TRUE или FALSE и позицию в позиции REF INT.
`InStr(«startpos,»string,substring)`	ВБ (позиции начинаются с 1)	возвращает 0
`INSTR$(string,substring)`	БАЗОВЫЙ (позиции начинаются с 1)	возвращает 0
`index(string,substring)`	АВК	возвращает 0
`index(string,substring«,startpos»)`	Перл 5	возвращает −1
`index(string,substring«,startpos»)` `string.index(substring,«,startpos»)`	Раку	возвращает ноль
`instr(«startpos,»string,substring)`	FreeBASIC	возвращает 0
`strpos(string,substring«,startpos»)`	PHP	возвращает ЛОЖЬ
`locate(string, substring)`	Энгр	возвращает длину строки + 1
`strstr(string, substring)`	С , С++ ( `char *` только возвращает указатель на первый символ)	возвращает НУЛЬ
`std.string.indexOf(string, substring)`	Д	возвращает −1
`pos(string, substring«, startpos»)`	Сид7	возвращает 0
`strings.Index(string, substring)`	Идти	возвращает −1
`pos(substring, string)`	Паскаль , Объектный Паскаль ( Делфи )	возвращает 0
`pos(substring, string«,startpos»)`	Рекс	возвращает 0
`string.find(substring«,startpos»)`	С++ (СТЛ)	возвращает std::string::npos
`string.find(substring«,startpos«,endpos»»)`	Питон	возвращает −1
`string.index(substring«,startpos«,endpos»»)`	Питон	вызывает ValueError
`string.index(substring«,startpos»)`	Руби	возвращает ноль
`string.indexOf(substring«,startpos»)`	Ява , JavaScript	возвращает −1
`string.IndexOf(substring«,startpos«, charcount»»)`	VB.NET , C# , Windows PowerShell , F#	возвращает −1
`string:str(string, substring)`	Эрланг	возвращает 0
`(string-contains string substring)`	Схема (СРФИ 13)	возвращает #f
`(search substring string)`	Общий Лисп	возвращает НОЛЬ
`(string-index substring string)`	ИСЛИСП	возвращает `nil`
`List.findIndex (List.isPrefixOf substring) (List.tails string)`	Haskell (возвращает только индекс )	ничего не возвращает
`Str.search_forward (Str.regexp_string substring) string 0`	OCaml	поднимает Not_found
`Substring.size (#1 (Substring.position substring (Substring.full string)))`	Стандартный ML	возвращает длину строки
`[string rangeOfString:substring].location`	Цель-C ( `NSString *` только)	возвращает НСНотфаунд
`string.find(string, substring)` `(string):find(substring)`	Два	возвращает ноль
`string indexOfSubCollection: substring startingAt: startpos ifAbsent: aBlock` `string findString: substring startingAt: startpos`	Smalltalk ( Писк , Фаро )	оценить aBlock, который является замыканием блока (или любым значением понимания объекта) возвращает 0
`startpos = INDEX(string, substring «,back» «, kind»)`	Фортран	возвращает 0, если подстроки нет в строке; возвращает LEN(строка)+1, если подстрока пуста
`POSITION(substring IN string)`	SQL	возвращает 0 (позиции начинаются с 1)
`index(string, substring, startpos )`	ПЛ/Я ^{[ 16 ]}	возвращает 0 (позиции начинаются с 1)
`index(string, substring, occurrence )`	Выберите базовый	возвращает 0, если вхождение подстроки отсутствует в строке; (позиции начинаются с 1)
`string.indexOf(substring«,startpos«, charcount»»)`	Кобра	возвращает −1
`string first substring string startpos`	Ткл	возвращает −1
`(substring⍷string)⍳1`	АПЛ	возвращает 1 + последнюю позицию в строке
`string.find(substring)`	Ржавчина ^{[ 17 ]}	возвращает `None`

Примеры

Общий Лисп

(search "e" "Hello mate")             ;  returns 1
(search "z" "word")                   ;  returns NIL

С#

"Hello mate".IndexOf("e");            // returns 1
"Hello mate".IndexOf("e", 4);         // returns 9
"word".IndexOf("z");                  // returns -1

Раку

"Hello, there!".index('e')           # returns 1
"Hello, there!".index('z')           # returns Nil

Схема

(use-modules (srfi srfi-13))
(string-contains "Hello mate" "e")    ;  returns 1
(string-contains "word" "z")          ;  returns #f

Визуальный Бейсик

' Examples in
InStr("Hello mate", "e")              '  returns 2
InStr(5, "Hello mate", "e")           '  returns 10
InStr("word", "z")                    '  returns 0

Смолток

'Hello mate' indexOfSubCollection:'ate'  "returns 8"

'Hello mate' indexOfSubCollection:'late' "returns 0"

I'Hello mate'
    indexOfSubCollection:'late'
    ifAbsent:[ 99 ]                      "returns 99"

'Hello mate'
    indexOfSubCollection:'late'
    ifAbsent:[ self error ]              "raises an exception"

Найти персонажа

Определение	`find_character(string,char)` возвращает целое число
Описание	Возвращает позицию начала первого вхождения символа char в строке . Если символ не найден, большинство этих подпрограмм возвращают недопустимое значение индекса – -1, когда индексы отсчитываются от 0, 0, когда они отсчитываются от 1, – или какое-то значение, которое интерпретируется как логическое значение FALSE. Это можно сделать как особый случай #Find со строкой из одного символа; но во многих языках может оказаться проще и эффективнее найти только один символ. Кроме того, во многих языках символы и строки имеют разные типы, поэтому удобно иметь такую функцию.
Связанный	находить

Формат	Языки	Если не найден
`char in string(char, pos, string[startpos:])`	АЛГОЛ 68	возвращает БУЛ : ИСТИНА или FALSE и позиция в REF INT поз .
`instr(string, any char«,startpos»)` (char, может содержать более одного символа, в этом случае возвращается позиция первого появления любого из них.)	FreeBASIC	возвращает 0
`strchr(string,char)`	С , С++ ( `char *` только возвращает указатель на символ)	возвращает НУЛЕВОЙ
`std.string.find(string, dchar)`	Д	возвращает −1
`string.find(char«,startpos»)`	С++ (СТЛ)	возвращает станд::строка::npos
`pos(string, char«, startpos»)`	Сид7	возвращает 0
`strings.IndexRune(string,char)`	Идти	возвращает −1
`string.indexOf(char«,startpos»)`	Ява , JavaScript	возвращает −1
`string.IndexOf(char«,startpos«, charcount»»)`	VB.NET , C# , Windows PowerShell , F#	возвращает −1
`(position char string)`	Общий Лисп	возвращает НОЛЬ
`(char-index char string)`	ИСЛИСП	возвращает ноль
`List.elemIndex char string`	Хаскелл (возвращает `Just index`)	возвращает Ничего
`String.index string char`	OCaml	поднимает Не найдено
`position = SCAN (string, set «, back» «, kind»)` `position = VERIFY (string, set «, back» «, kind»)^[a]`	Фортран	возвращает ноль
`string indexOf: char ifAbsent: aBlock` `string indexOf: char` `string includes: char`	Смолток	оценивать `aBlock` который представляет собой `BlockClosure` (или любое значение понимания объекта) возвращает 0 возвращает `true` или `false`
`index(string, char, startpos )`	ПЛ/Я ^{[ 18 ]}	возвращает 0 (позиции начинаются с 1)
`string.index(?char)`	Руби	возвращает ноль
`strpos(string,char,startpos)`	PHP	возвращает ЛОЖЬ
`string.indexOf(char«,startpos«, charcount»»)`	Кобра	возвращает −1
`string⍳char`	АПЛ	возвращает 1 + последнюю позицию в строке
`string.find(substring)`	Ржавчина ^{[ 17 ]}	возвращает Никто

// Examples in C#
"Hello mate".IndexOf('e');              // returns 1
"word".IndexOf('z')                     // returns -1

; Examples in Common Lisp
(position #\e "Hello mate")             ;  returns 1
(position #\z "word")                   ;  returns NIL

^a Учитывая набор символов, SCAN возвращает позицию первого найденного символа, ^{[ 19 ]} а VERIFY возвращает позицию первого символа, который не принадлежит набору. ^{[ 20 ]}

Формат

Определение	`format(formatstring, items)` возвращает строку
Описание	Возвращает форматированное строковое представление одного или нескольких элементов.

Формат	Языки	Синтаксис строки формата
`associate(file, string); putf(file, $formatstring$, items)`	АЛГОЛ 68	АЛГОЛ
`Format(item, formatstring)`	ВБ
`sprintf(formatstring, items)`	Perl , PHP , Raku , Ruby	С
`item.fmt(formatstring)`	Раку	С
`io_lib:format(formatstring, items)`	Эрланг
`sprintf(outputstring, formatstring, items)`	С	С
`std::format(formatstring, items)`	С++ ( С++20 )	Питон
`std.string.format(formatstring, items)`	Д	С
`Format(formatstring, items)`	Объектный Паскаль ( Делфи )
`fmt.Sprintf(formatstring, items)`	Идти	С
`printf formatstring items`	Юникс	С
`formatstring % (items)`	Питон , Рубин	С
`formatstring.format(items)`	Питон	.СЕТЬ
`fformatstring`	Питон 3
`Printf.sprintf formatstring`^{[ 21 ]} `items`	OCaml , F#	С
`Text.Printf.printf formatstring items`	Хаскелл (GHC)	С
`formatstring printf: items`	Смолток	С
`String.format(formatstring, items)`	Ява	С
`String.Format(formatstring, items)`	ВБ.NET , C# , F#	.СЕТЬ
`(format formatstring items)`	Схема (СРФИ 28)	Лисп
`(format nil formatstring items)`	Общий Лисп	Лисп
`(format formatstring items)`	Кложур	Лисп
`formatstring -f items`	Windows PowerShell	.СЕТЬ
`[NSString stringWithFormat:formatstring, items]`	Цель-C ( `NSString *` только)	С
`String(format:formatstring, items)`	Свифт (Фонд)	С
`string.format(formatstring, items)` `(formatstring):format(items)`	Два	С
`WRITE (outputstring, formatstring) items`	Фортран	Фортран
`put string(string) edit(items)(format)`	ПЛ/Я	PL/I (аналог Фортрана)
`String.format(formatstring, items)`	Кобра	.СЕТЬ
`format formatstring items`	Ткл	С
`formatnumbers ⍕ items` `formatstring ⎕FMT items`	АПЛ	АПЛ
`format!(formatstring, items)`	Ржавчина ^{[ 22 ]}	Питон

// Example in C#
String.Format("My {0} costs {1:C2}", "pen", 19.99); // returns "My pen costs $19.99"

// Example in Object Pascal (Delphi)
Format('My %s costs $%2f', ['pen', 19.99]);         // returns "My pen costs $19.99"

// Example in Java
String.format("My %s costs $%2f", "pen", 19.99);    // returns "My pen costs $19.99"

# Examples in Raku
sprintf "My %s costs \$%.2f", "pen", 19.99;          # returns "My pen costs $19.99"
1.fmt("%04d");                                       # returns "0001"

# Example in Python
"My %s costs $%.2f" % ("pen", 19.99);                #  returns "My pen costs $19.99"
"My {0} costs ${1:.2f}".format("pen", 19.99);        #  returns "My pen costs $19.99"

#Example in Python 3.6+
pen = "pen"
f"My {pen} costs {19.99}"                                          #returns "My pen costs 19.99"

; Example in Scheme
(format "My ~a costs $~1,2F" "pen" 19.99)           ;  returns "My pen costs $19.99"

/* example in PL/I */
put string(some_string) edit('My ', 'pen', ' costs', 19.99)(a,a,a,p'$$$V.99')
/* returns "My pen costs $19.99" */

Неравенство

Проверяет, не равны ли две строки. См. также #Равенство .

Формат	Языки
`string₁ ne string₂` `string₁ NE string₂`	АЛГОЛ 68 – примечание: оператор « ne » выделен жирным шрифтом.
`string₁ /= string₂`	Алгол 68 , Ада , Эрланг , Фортран , Хаскелл
`string₁ <> string₂`	BASIC , VB , VB.NET , Pascal , Object Pascal ( Delphi ), OCaml , PHP , Seed7 , Standard ML , F# , COBOL , Cobra , Python 2 (устарело)
`string₁ # string₂`	БЕЙСИК (некоторые реализации)
`string₁ ne string₂`	Жемчуг , Рак
`(string<> string₁ string₂)`	Схема (СРФИ 13)
`(string/= string₁ string₂)`	Общий Лисп
`(string/= string₁ string₂)`	ИСЛИСП
`(not= string₁ string₂)`	Кложур
`string₁ != string₂`	C++ (STL), C# , Go , JavaScript (не похоже), PHP (не похоже), Python , Ruby , Rust , ^{[ 10 ]} Свифт , Д , Математика
`string₁ !== string₂`	JavaScript , PHP
`string₁ \= string₂`	Рекс
`string₁ ¬= string₂`	ПЛ/Я
`test string₁ != string₂` `[ string₁ != string₂ ]`	Борн Шелл
`string₁ -ne string₂` `-not [string]::Equals(string₁, string₂)`	Windows PowerShell
`string₁ ~= string₂`	Луа , Смолток
`string₁ ≢ string₂`	АПЛ
`string₁.ne(string₂)`	Ржавчина ^{[ 10 ]}

// Example in C#
"hello" != "world"    // returns true

' Example in Visual Basic
"hello" <> "world"    '  returns true

;; Example in Clojure
(not= "hello" "world")  ; ⇒ true

# Example in Perl 5
'hello' ne 'world'      # returns 1

# Example in Raku
'hello' ne 'world'      # returns True

# Example in Windows PowerShell
"hello" -ne "world"   #  returns true

индекс

Найти см. #

индекс

Найти см. #

инстр

Найти см. #

инстррев

см . #rfind

присоединиться

Определение	`join(separator, list_of_strings)` возвращает список строк, соединенных разделителем
Описание	Объединяет список строк в новую строку со строкой-разделителем между каждой из подстрок. Противоположность расколу .
Связанный	спринтф

Формат	Языки
`std.string.join(array_of_strings, separator)`	Д
`string:join(list_of_strings, separator)`	Эрланг
`join(separator, list_of_strings)`	Перл , PHP , Раку
`implode(separator, array_of_strings)`	PHP
`separator.join(sequence_of_strings)`	Питон , Свифт 1.x
`array_of_strings.join(separator)`	Руби , JavaScript , Раку , Руст ^{[ 23 ]}
`(string-join array_of_strings separator)`	Схема (СРФИ 13)
`(format nil "~{~a~^separator~}" array_of_strings)`	Общий Лисп
`(clojure.string/join separator list_of_strings)` `(apply str (interpose separator list_of_strings))`	Кложур
`strings.Join(array_of_strings, separator)`	Идти
`join(array_of_strings, separator)`	Сид7
`String.concat separator list_of_strings`	OCaml
`String.concatWith separator list_of_strings`	Стандартный ML
`Data.List.intercalate separator list_of_strings`	Хаскелл (GHC 6.8+)
`Join(array_of_strings, separator)`	ВБ
`String.Join(separator, array_of_strings)`	ВБ.NET , C# , F#
`String.join(separator, array_of_strings)`	Ява 8+
`&{$OFS=$separator; "$array_of_strings"}` `array_of_strings -join separator`	Windows PowerShell
`[array_of_strings componentsJoinedByString:separator]`	Цель-C ( `NSString *` только)
`table.concat(table_of_strings, separator)`	Два
`{\|String streamContents: [ :stream \| collectionOfAnything asStringOn: stream delimiter: separator ]` `collectionOfAnything joinUsing: separator`	Smalltalk ( Писк , Фаро )
`array_of_strings.join(separator«, final_separator»)`	Кобра
`sequence_of_strings.joinWithSeparator(separator)`	Свифт 2.x
`1↓∊separator,¨list_of_strings`	АПЛ

// Example in C#
String.Join("-", {"a", "b", "c"})  // "a-b-c"

" Example in Smalltalk "
#('a' 'b' 'c') joinUsing: '-'      " 'a-b-c' "

# Example in Perl 5
join( '-', ('a', 'b', 'c'));       # 'a-b-c'

# Example in Raku
<a b c>.join('-');       # 'a-b-c'

# Example in Python
"-".join(["a", "b", "c"])          #  'a-b-c'

# Example in Ruby
["a", "b", "c"].join("-")          #  'a-b-c'

; Example in Scheme
(use-modules (srfi srfi-13))
(string-join '("a" "b" "c") "-")   ;  "a-b-c"

последнийиндексоф

см . #rfind

левый

Определение	`left(string,n)` возвращает строку
Описание	Возвращает левую n часть строки. Если n больше длины строки, то большинство реализаций возвращают всю строку (существуют исключения — см. примеры кода). Обратите внимание, что для кодировок переменной длины, таких как UTF-8 , UTF-16 или Shift-JIS , может потребоваться удалить позиции строки в конце, чтобы избежать появления недопустимых строк.

Формат	Языки
`string (string'First .. string'First + n - 1)`	Есть
`substr(string, 0, n)`	AWK (изменяет строку), Perl , PHP , Raku
`LEFT$(string,n)`	БЕЙСИК , ВБ
`left(string,n)`	VB , FreeBASIC , Ingres , Pick Basic
`strncpy(string2, string, n)`	Стандартная библиотека C
`string.substr(0,n)`	C++ (STL), Рак
`[string substringToIndex:n]`	Цель-C ( `NSString *` только)
`(apply str (take n string))`	Кложур
`string[0 .. n]`	Д ^{[ 24 ]}
`string:substr(string, start, length)`	Эрланг
`(subseq string 0 n)`	Общий Лисп
`string[:n]`	Кобра , Го , Питон
`left(string,n «,padchar»)`	Рекс , Эрланг
`string[0, n]` `string[0..n - 1]`	Руби
`string[1, n]`	Выберите базовый
`string[ .. n]`	Сид7
`string.Substring(0,n)`	VB.NET , C# , Windows PowerShell , F#
`leftstr(string, n)`	Паскаль , Объектный Паскаль ( Делфи )
`copy (string,1,n)`	Турбо Паскаль
`string.substring(0,n)`	Ява , ^{[ 25 ]} JavaScript
`(string-take string n)`	Схема (СРФИ 13)
`take n string`	Хаскелл
`String.extract (string, n, NONE)`	Стандартный ML
`String.sub string 0 n`	OCaml ^{[ 26 ]}
`string.[..n]`	Ф#
`string.sub(string, 1, n)` `(string):sub(1, n)`	Два
`string first: n`	Smalltalk ( Писк , Фаро )
`string(:n)`	Фортран
`StringTake[string, n]`	Математика ^{[ 27 ]}
`string («FUNCTION» LENGTH(string) - n:n)`	КОБОЛ
`string.substring(0, n)`	Кобра
`n↑string.`	АПЛ
`string[0..n]` `string[..n]` `string.get(0..n)` `string.get(..n)`	Ржавчина ^{[ 28 ]}

# Example in Raku
"Hello, there!".substr(0, 6);  # returns "Hello,"

/* Examples in Rexx */
left("abcde", 3)         /* returns "abc"      */
left("abcde", 8)         /* returns "abcde   " */
left("abcde", 8, "*")    /* returns "abcde***" */

; Examples in Scheme
(use-modules (srfi srfi-13))
(string-take "abcde", 3) ;  returns "abc"
(string-take "abcde", 8) ;  error

' Examples in Visual Basic
Left("sandroguidi", 3)   '  returns "san"
Left("sandroguidi", 100) '  returns "sandroguidi"

только

см . #длина

длина

Определение	`length(string)` возвращает целое число
Описание	Возвращает длину строки (не считая нулевого символа-терминатора или любой другой внутренней структурной информации строки). Пустая строка возвращает длину 0.

Формат	Возврат	Языки
`string'Length`		Есть
`UPB string`		АЛГОЛ 68
`echo "${#string_param}"`		Баш
`length(string)`		Ingres , Perl 5, Паскаль , Object Pascal ( Delphi ), Rexx , Seed7 , SQL , PL/I
`len(string)`		BASIC , FreeBASIC , Python , Go , Выберите базовый
`length(string), string:len(string)`		Эрланг
`Len(string)`		ВБ , выберите базовый
`string.Length`	Количество UTF-16 кодовых единиц	VB.NET , C# , Windows PowerShell , F#
`chars(string)` `string.chars`	Количество графем (NFG)	Раку
`codes(string)` `string.codes`	Количество кодовых точек Юникода	Раку
`string.size OR string.length`	Количество байтов ^{[ 29 ]}	Руби
`strlen(string)`	Количество байтов	С , PHP
`string.length()`		С++ (СТЛ)
`string.length`		Кобра , D , JavaScript
`string.length()`	Количество UTF-16 кодовых единиц	Ява
`(string-length string)`		Схема
`(length string)`		Общий Лисп , ISLISP
`(count string)`		Кложур
`String.length string`		OCaml
`size string`		Стандартный ML
`length string`	Количество кодовых точек Юникода	Хаскелл
`string.length`	Количество UTF-16 кодовых единиц	Цель-C ( `NSString *` только)
`string.characters.count`	Количество символов	Свифт (2.x)
`count(string)`	Количество символов	Свифт (1,2)
`countElements(string)`	Количество символов	Свифт (1,0–1,1)
`string.len(string)` `(string):len()` `#string`		Два
`string size`		Смолток
`LEN(string)` `LEN_TRIM(string)`		Фортран
`StringLength[string]`		Математика
`«FUNCTION» LENGTH(string)` или `«FUNCTION» BYTE-LENGTH(string)`	количество символов и количество байтов соответственно	КОБОЛ
`string length string`	десятичная строка, указывающая количество символов	Ткл
`≢ string`		АПЛ
`string.len()`	Количество байтов	Ржавчина ^{[ 30 ]}
`string.chars().count()`	Количество кодовых точек Юникода	Ржавчина ^{[ 31 ]}

// Examples in C#
"hello".Length;      // returns 5
"".Length;           // returns 0

# Examples in Erlang
string:len("hello"). %  returns 5
string:len("").      %  returns 0

# Examples in Perl 5
length("hello");     #  returns 5
length("");          #  returns 0

# Examples in Raku
"🏳️‍🌈".chars; chars "🏳️‍🌈";      # both return 1
"🏳️‍🌈".codes; codes "🏳️‍🌈";      # both return 4
"".chars; chars "";          # both return 0
"".codes; codes "";          # both return 0

' Examples in Visual Basic
Len("hello")         '  returns 5
Len("")              '  returns 0

//Examples in Objective-C
[@"hello" Length]   //returns 5
[@"" Length]   //returns 0

-- Examples in Lua
("hello"):len() -- returns 5
#"" -- returns 0

найти

Найти см. #

строчные буквы

Определение	`lowercase(string)` возвращает строку
Описание	Возвращает строку в нижнем регистре.

Формат	Языки
`LCase(string)`	ВБ
`lcase(string)`	FreeBASIC
`lc(string)`	Жемчуг , Рак
`string.lc`	Раку
`tolower(char)`	С ^{[ 32 ]}
`std.string.toLower(string)`	Д
`transform(string.begin(), string.end(), result.begin(), ::tolower)`^{[ 33 ]}	С++ ^{[ 34 ]}
`lowercase(string)`	Объектный Паскаль ( Делфи )
`strtolower(string)`	PHP
`lower(string)`	Сид7
`${string_param,,}`	Баш
`echo "string" \| tr 'A-Z' 'a-z'`	Юникс
`string.lower()`	Питон
`downcase(string)`	Выберите базовый
`string.downcase`	Руби ^{[ 35 ]}
`strings.ToLower(string)`	Идти
`(string-downcase string)`	Схема (R6RS), Common Lisp
`(lower-case string)`	Кложур
`String.lowercase string`	OCaml
`String.map Char.toLower string`	Стандартный ML
`map Char.toLower string`	Хаскелл
`string.toLowerCase()`	Ява , JavaScript
`to_lower(string)`	Эрланг
`string.ToLower()`	VB.NET , C# , Windows PowerShell , F#
`string.lowercaseString`	Цель-C ( `NSString *` только), Свифт (Основной)
`string.lower(string)` `(string):lower()`	Два
`string asLowercase`	Смолток
`LOWER(string)`	SQL
`lowercase(string)`	ПЛ/Я ^{[ 8 ]}
`ToLowerCase[string]`	Математика
`«FUNCTION» LOWER-CASE(string)`	КОБОЛ
`string.toLower`	Кобра
`string tolower string`	Ткл
`string.to_lowercase()`	Ржавчина ^{[ 36 ]}

// Example in C#
"Wiki means fast?".ToLower();        // "wiki means fast?"

; Example in Scheme
(use-modules (srfi srfi-13))
(string-downcase "Wiki means fast?") ;  "wiki means fast?"

/* Example in C */
#include <ctype.h>
#include <stdio.h>
int main(void) {
    char string[] = "Wiki means fast?";
    int i;
    for (i = 0; i < sizeof(string) - 1; ++i) {
        /* transform characters in place, one by one */
        string[i] = tolower(string[i]);
    }
    puts(string);                       /* "wiki means fast?" */
    return 0;
}

# Example in Raku
"Wiki means fast?".lc;             # "wiki means fast?"

середина

см . #подстрока

раздел

Определение	<string>.partition( separator ) возвращает подстроку перед разделителем; сепаратор; затем подстрока после разделителя.
Описание	Разбивает заданную строку по разделителю и возвращает три подстроки, которые вместе составляют оригинал.

Формат	Языки	Комментарии
`string.partition(separator)`	Питон , Руби (1.9+)
`lists:partition(pred, string)`	Эрланг
`split /(separator)/, string, 2`	Перл 5
`split separator, string, 2` `string.split( separator, 2 )`	Раку	Разделитель не обязательно должен быть регулярным выражением.

# Examples in Python
"Spam eggs spam spam and ham".partition('spam')   # ('Spam eggs ', 'spam', ' spam and ham')
"Spam eggs spam spam and ham".partition('X')      # ('Spam eggs spam spam and ham', "", "")

# Examples in Perl 5 / Raku
split /(spam)/, 'Spam eggs spam spam and ham' ,2;   # ('Spam eggs ', 'spam', ' spam and ham');
split /(X)/, 'Spam eggs spam spam and ham' ,2;      # ('Spam eggs spam spam and ham');

заменять

Определение	`replace(string, find, replace)` возвращает строку
Описание	Возвращает строку, в которой вхождения find изменены на replace .

Формат	Языки
`changestr(find, string, replace)`	Рекс
`std.string.replace(string, find, replace)`	Д
`Replace(string, find, replace)`	ВБ
`replace(string, find, replace)`	Сид7
`change(string, find, replace)`	Выберите базовый
`string.Replace(find, replace)`	C# , F# , VB.NET
`str_replace(find, replace, string)`	PHP
`re:replace(string, find, replace, «{return, list}»)`	Эрланг
`string.replace(find, replace)`	Кобра , Java (1.5+), Python , Rust ^{[ 37 ]}
`string.replaceAll(find_regex, replace)^[38]`	Ява
`string.gsub(find, replace)`	Руби
`string =~ s/find_regex/replace/g^[38]`	Перл 5
`string.subst(find, replace, :g)`	Раку
`string.replace(find, replace, "g") ^[39]` `string.replace(/find_regex/g, replace)^[38]`	JavaScript
`echo "string" \| sed 's/find_regex/replace/g'^[38]`	Юникс
`${string_param//find_pattern/replace}`	Баш
`string.replace(find, replace)` `string -replace find_regex, replace^[38]`	Windows PowerShell
`Str.global_replace (Str.regexp_string find) replace string`	OCaml
`[string stringByReplacingOccurrencesOfString:find withString:replace]`	Цель-C ( `NSString *` только)
`string.stringByReplacingOccurrencesOfString(find, withString:replace)`	Свифт (Фонд)
`string.gsub(string, find, replace)` `(string):gsub(find, replace)`	Два
`string copyReplaceAll: find with: replace`	Smalltalk ( Писк , Фаро )
`string map {find replace} string`	Ткл
`StringReplace[string, find -> replace]`	Математика
`strings.Replace(string, find, replace, -1)`	Идти
`INSPECT string REPLACING ALL/LEADING/FIRST find BY replace`	КОБОЛ
`find_regex ⎕R replace_regex ⊢ string`	АПЛ

// Examples in C#
"effffff".Replace("f", "jump");     // returns "ejumpjumpjumpjumpjumpjump"
"blah".Replace("z", "y");           // returns "blah"

// Examples in Java
"effffff".replace("f", "jump");     // returns "ejumpjumpjumpjumpjumpjump"
"effffff".replaceAll("f*", "jump"); // returns "ejump"

// Examples in Raku
"effffff".subst("f", "jump", :g);    # returns "ejumpjumpjumpjumpjumpjump"
"blah".subst("z", "y", :g);          # returns "blah"

' Examples in Visual Basic
Replace("effffff", "f", "jump")     '  returns "ejumpjumpjumpjumpjumpjump"
Replace("blah", "z", "y")           '  returns "blah"

# Examples in Windows PowerShell
"effffff" -replace "f", "jump"      #  returns "ejumpjumpjumpjumpjumpjump"
"effffff" -replace "f*", "jump"     #  returns "ejump"

обеспечить регресс

Определение	`reverse(string)`
Описание	Меняет порядок символов в строке на обратный.

Формат	Языки
`reverse string`	Перл 5, Хаскель
`flip string` `string.flip`	Раку
`lists:reverse(string)`	Эрланг
`strrev(string)`	PHP
`string[::-1]`	Питон
`(string-reverse string)`	Схема (СРФИ 13)
`(reverse string)`	Общий Лисп
`string.reverse`	Ruby , D (изменяет строку)
`new StringBuilder(string).reverse().toString()`	Ява
`std::reverse(string.begin(), string.end());`	С++ ( `std::string` только изменяет строку)
`StrReverse(string)`	ВБ
`string.Reverse()`	ВБ.NET , С#
`implode (rev (explode string))`	Стандартный ML
`string.split("").reverse().join("")`	JavaScript
`string.reverse(string)` `(string):reverse()`	Два
`string reverse`	Смолток
`StringReverse[string]`	Математика
`reverse(string)`	ПЛ/Я
`«FUNCTION» REVERSE(string)`	КОБОЛ
`string.toCharArray.toList.reversed.join()`	Кобра
`String(string.characters.reverse())`	Свифт (2.x)
`String(reverse(string))`	Свифт (1,2)
`string reverse string`	Ткл
`⌽string`	АПЛ
`string.chars().rev().collect::<String>()`	Ржавчина ^{[ 40 ]}
`echo string \| rev`	Юникс

" Example in Smalltalk "
'hello' reversed             " returns 'olleh' "

# Example in Perl 5
reverse "hello"              # returns "olleh"

# Example in Raku
"hello".flip                 # returns "olleh"

# Example in Python
"hello"[::-1]                # returns "olleh"

; Example in Scheme
(use-modules (srfi srfi-13))
(string-reverse "hello")     ; returns "olleh"

найти

Определение	`rfind(string,substring)` возвращает целое число
Описание	Возвращает позицию начала последнего вхождения подстроки в строке . Если подстрока не найдена, большинство этих подпрограмм возвращают недопустимое значение индекса – -1, когда индексы отсчитываются от 0, 0, когда они отсчитываются от 1, – или какое-то значение, которое интерпретируется как логическое значение FALSE.
Связанный	инстр

Формат	Языки	Если не найден
`InStrRev(«startpos,» string,substring)`	ВБ	возвращает 0
`instrrev(«startpos,» string,substring)`	FreeBASIC	возвращает 0
`rindex(string,substring«,startpos»)`	Перл 5	возвращает −1
`rindex(string,substring«,startpos»)` `string.rindex(substring«,startpos»)`	Раку	возвращает ноль
`strrpos(string,substring«,startpos»)`	PHP	возвращает ЛОЖЬ
`string.rfind(substring«,startpos»)`	С++ (СТЛ)	возвращает станд::строка::npos
`std.string.rfind(string, substring)`	Д	возвращает −1
`string.rfind(substring«,startpos«, endpos»»)`	Питон	возвращает −1
`string.rindex(substring«,startpos«, endpos»»)`	Питон	поднимает ValueError
`rpos(string, substring«,startpos»)`	Сид7	возвращает 0
`string.rindex(substring«,startpos»)`	Руби	возвращает ноль
`strings.LastIndex(string, substring)`	Идти	возвращает −1
`string.lastIndexOf(substring«,startpos»)`	Ява , JavaScript	возвращает −1
`string.LastIndexOf(substring«,startpos«, charcount»»)`	VB.NET , C# , Windows PowerShell , F#	возвращает −1
`(search substring string :from-end t)`	Общий Лисп	возвращает НОЛЬ
`[string rangeOfString:substring options:NSBackwardsSearch].location`	Цель-C ( `NSString *` только)	возвращает НСНотфаунд
`Str.search_backward (Str.regexp_string substring) string (Str.length string - 1)`	OCaml	поднимает Не найдено
`string.match(string, '.()'..substring)` `string:match('.()'..substring)`	Два	возвращает ноль
`Ada.Strings.Unbounded.Index(Source => string, Pattern => substring, Going => Ada.Strings.Backward)`	Есть	возвращает 0
`string.lastIndexOf(substring«,startpos«, charcount»»)`	Кобра	возвращает −1
`string lastIndexOfString:substring`	Смолток	возвращает 0
`string last substring string startpos`	Ткл	возвращает −1
`(⌽<\⌽substring⍷'string')⍳1`	АПЛ	возвращает −1
`string.rfind(substring)`	Ржавчина ^{[ 41 ]}	возвращает Никто

; Examples in Common Lisp
(search "e" "Hello mate" :from-end t)     ;  returns 9
(search "z" "word" :from-end t)           ;  returns NIL

// Examples in C#
"Hello mate".LastIndexOf("e");           // returns 9
"Hello mate".LastIndexOf("e", 4);        // returns 1
"word".LastIndexOf("z");                 // returns -1

# Examples in Perl 5
rindex("Hello mate", "e");               # returns 9
rindex("Hello mate", "e", 4);            # returns 1
rindex("word", "z");                     # returns -1

# Examples in Raku
"Hello mate".rindex("e");                # returns 9
"Hello mate".rindex("e", 4);             # returns 1
"word".rindex('z');                      # returns Nil

' Examples in Visual Basic
InStrRev("Hello mate", "e")              '  returns 10
InStrRev(5, "Hello mate", "e")           '  returns 2
InStrRev("word", "z")                    '  returns 0

верно

Определение	`right(string,n)` возвращает строку
Описание	Возвращает правую n часть строки. Если n больше длины строки, то большинство реализаций возвращают всю строку (существуют исключения — см. примеры кода).

Формат	Языки
`string (string'Last - n + 1 .. string'Last)`	Есть
`Right(string,n)`	ВБ
`RIGHT$(string,n)`	БАЗОВЫЙ
`right(string,n)`	FreeBASIC , Ingres , выбор базового
`strcpy(string2, string+n)` (n не должно быть больше длины строки )	С
`string.Substring(string.Length()-n)`	С#
`string[len(string)-n:]`	Идти
`string.substring(string.length()-n)`	Ява
`string.slice(-n)`	JavaScript ^{[ 42 ]}
`right(string,n «,padchar»)`	Рекс , Эрланг
`substr(string,-n)`	Перл 5, PHP
`substr(string,-n)` `string.substr(-n)`	Раку
`string[-n:]`	Кобра , Питон
`${string_param: -n}` (обратите внимание на пробел после двоеточия)	Баш
`string[n]`	Выберите базовый
`(string-take-right string n)`	Схема (СРФИ 13)
`string[-n..-1]`	Руби
`string[$-n .. $]`	Д ^{[ 43 ]}
`String.sub string (String.length string - n) n`	OCaml ^{[ 26 ]}
`string.sub(string, -n)` `(string):sub(-n)`	Два
`string last: n`	Smalltalk ( Писк , Фаро )
`StringTake[string, -n]`	Математика ^{[ 27 ]}
`string (1:n)`	КОБОЛ
`¯n↑string.`	АПЛ
`string[n..]` `string.get(n..)`	Ржавчина ^{[ 28 ]}

// Examples in Java; extract rightmost 4 characters
String str = "CarDoor";
str.substring(str.length()-4); // returns 'Door'

# Examples in Raku
"abcde".substr(*-3);          # returns "cde"
"abcde".substr(*-8);          # 'out of range' error

/* Examples in Rexx */
right("abcde", 3)              /* returns "cde"      */
right("abcde", 8)              /* returns "   abcde" */
right("abcde", 8, "*")         /* returns "***abcde" */

; Examples in Scheme
(use-modules (srfi srfi-13))
(string-take-right "abcde", 3) ;  returns "cde"
(string-take-right "abcde", 8) ;  error

' Examples in Visual Basic
Right("sandroguidi", 3)        '  returns "idi"
Right("sandroguidi", 100)      '  returns "sandroguidi"

перегородка

Определение	<string>.rpartition( separator ) Ищет разделитель внутри строки справа налево, затем возвращает подстроку перед разделителем; сепаратор; затем подстрока после разделителя.
Описание	Разбивает заданную строку по крайнему правому разделителю и возвращает три подстроки, которые вместе составляют оригинал.

Формат	Языки
`string.rpartition(separator)`	Питон , Рубин

# Examples in Python
"Spam eggs spam spam and ham".rpartition('spam')  ### ('Spam eggs spam ', 'spam', ' and ham')
"Spam eggs spam spam and ham".rpartition('X')     ### ("", "", 'Spam eggs spam spam and ham')

кусочек

см . #подстрока

расколоть

Определение	<string>.split( separator [, limit ]) разделяет строку по разделителю, возможно, только до ограниченного количества подстрок.
Описание	Разбивает заданную строку по вхождениям разделителя (который сам по себе является строкой) и возвращает список (или массив) подстрок. Если предел задан «предел , после считывания разделителей – 1» остальная часть строки превращается в последнюю подстроку, независимо от того, есть ли в ней разделители. Реализации Scheme и Erlang схожи, но отличаются по нескольким параметрам. JavaScript отличается еще и тем, что он обрезает, а не помещает остальную часть строки в последний элемент. См. пример здесь . Реализация Cobra по умолчанию использует пробелы. Противоположность join .

Формат	Языки
`split(/separator/, string«, limit»)`	Перл 5
`split(separator, string«, limit»)` `string.split(separator, «limit»)`	Раку
`explode(separator, string«, limit»)`	PHP
`string.split(separator«, limit-1»)`	Питон
`string.split(separator«, limit»)`	JavaScript , Java , Руби
`string:tokens(string, sepchars)`	Эрланг
`strings.Split(string, separator)` `strings.SplitN(string, separator, limit)`	Идти
`(string-tokenize string« charset« start« end»»»)`	Схема (СРФИ 13)
`Split(string, sepchars«, limit»)`	ВБ
`string.Split(sepchars«, limit«, options»»)`	ВБ.NET , C# , F#
`string -split separator«, limit«, options»»`	Windows PowerShell
`Str.split (Str.regexp_string separator) string`	OCaml
`std.string.split(string, separator)`	Д
`[string componentsSeparatedByString:separator]`	Цель-C ( `NSString *` только)
`string.componentsSeparatedByString(separator)`	Свифт (Фонд)
`TStringList.Delimiter, TStringList.DelimitedText`	Объектный Паскаль
`StringSplit[string, separator«, limit»]`	Математика
`string.split«(sepchars«, limit«, options»»)»`	Кобра
`split string separator`	Ткл
`(separator≠string)⊂string` в АПЛ2 `separator(≠⊆⊢)string` в Диалоге APL 16.0	АПЛ
`string.split(separator)` `string.split(limit, separator)`	Ржавчина ^{[ 44 ]}

// Example in C#
"abc,defgh,ijk".Split(',');                 // {"abc", "defgh", "ijk"}
"abc,defgh;ijk".Split(',', ';');            // {"abc", "defgh", "ijk"}

% Example in Erlang
string:tokens("abc;defgh;ijk", ";").        %  ["abc", "defgh", "ijk"]

// Examples in Java
"abc,defgh,ijk".split(",");                 // {"abc", "defgh", "ijk"}
"abc,defgh;ijk".split(",|;");               // {"abc", "defgh", "ijk"}

{ Example in Pascal }
var
  lStrings: TStringList;
  lStr: string;
begin
  lStrings := TStringList.Create;
  lStrings.Delimiter := ',';
  lStrings.DelimitedText := 'abc,defgh,ijk';
  lStr := lStrings.Strings[0]; // 'abc'
  lStr := lStrings.Strings[1]; // 'defgh'
  lStr := lStrings.Strings[2]; // 'ijk'
end;

# Examples in Perl 5
split(/spam/, 'Spam eggs spam spam and ham'); # ('Spam eggs ', ' ', ' and ham')
split(/X/, 'Spam eggs spam spam and ham');    # ('Spam eggs spam spam and ham')

# Examples in Raku
'Spam eggs spam spam and ham'.split(/spam/);  # (Spam eggs     and ham)
split(/X/, 'Spam eggs spam spam and ham');    # (Spam eggs spam spam and ham)

подстрока

Определение	`substring(string, startpos, endpos)` возвращает строку `substr(string, startpos, numChars)` возвращает строку
Описание	Возвращает подстроку строки между startpos и endpos или начиная с startpos длиной numChars . Результирующая строка усекается, если находится менее numChars за начальной точкой символов. endpos представляет индекс после последнего символа подстроки. Обратите внимание, что для кодировок переменной длины, таких как UTF-8 , UTF-16 или Shift-JIS , может потребоваться удалить позиции строки в конце, чтобы избежать появления недопустимых строк.

Формат	Языки
`string[startpos:endpos]`	АЛГОЛ 68 (меняет базовый индекс)
`string (startpos .. endpos)`	Ада (меняет базовый индекс)
`Mid(string, startpos, numChars)`	ВБ
`mid(string, startpos, numChars)`	FreeBASIC
`string[startpos+(⍳numChars)-~⎕IO]`	АПЛ
`MID$(string, startpos, numChars)`	БАЗОВЫЙ
`substr(string, startpos, numChars)`	AWK (изменение строки), Perl 5, ^{[ 45 ]}^{[ 46 ]} PHP ^{[ 45 ]}^{[ 46 ]}
`substr(string, startpos, numChars)` `string.substr(startpos, numChars)`	Раку ^{[ 47 ]}^{[ 48 ]}
`substr(string, startpos «,numChars, padChar»)`	Рекс
`string[startpos:endpos]`	Кобра , Питон , ^{[ 45 ]}^{[ 49 ]} Идти
`string[startpos, numChars]`	Выберите базовый
`string[startpos, numChars]` `string[startpos .. endpos-1]` `string[startpos ... endpos]`	Руби ^{[ 45 ]}^{[ 49 ]}
`string[startpos .. endpos]` `string[startpos len numChars]`	Сид7
`string.slice(startpos«, endpos»)`	JavaScript ^{[ 45 ]}^{[ 49 ]}
`string.substr(startpos«, numChars»)`	С++ (STL), JavaScript
`string.Substring(startpos, numChars)`	VB.NET , C# , Windows PowerShell , F#
`string.substring(startpos«, endpos»)`	Ява , JavaScript
`copy(string, startpos, numChars)`	Объектный Паскаль ( Делфи )
`(substring string startpos endpos)`	Схема
`(subseq string startpos endpos)`	Общий Лисп
`(subseq string startpos endpos)`	ИСЛИСП
`String.sub string startpos numChars`	OCaml
`substring (string, startpos, numChars)`	Стандартный ML
`string:sub_string(string, startpos, endpos)` `string:substr(string, startpos, numChars)`	Эрланг
`strncpy(result, string + startpos, numChars);`	С
`string[startpos .. endpos+1]`	Д
`take numChars $ drop startpos string`	Хаскелл
`[string substringWithRange:NSMakeRange(startpos, numChars)]`	Цель-C ( `NSString *` только)
`string.[startpos..endpos]`	Ф#
`string.sub(string, startpos, endpos)` `(string):sub(startpos, endpos)`	Два ^{[ 45 ]}^{[ 49 ]}
`string copyFrom: startpos to: endpos`	Смолток
`string(startpos:endpos)`	Фортран
`SUBSTRING(string FROM startpos «FOR numChars»)`	SQL
`StringTake[string, {startpos, endpos}]`	Математика ^{[ 45 ]}^{[ 49 ]}
`string (startpos:numChars)`	КОБОЛ
`${string_param:startpos:numChars}`	Баш
диапазон строк строка startpos endpos	Ткл
`string[startpos..endpos]` `string.get(startpos..endpos)`	Ржавчина ^{[ 28 ]}

// Examples in C#
"abc".Substring(1, 1):      // returns "b"
"abc".Substring(1, 2);      // returns "bc"
"abc".Substring(1, 6);      // error

;; Examples in Common Lisp
(subseq "abc" 1 2)          ; returns "b"
(subseq "abc" 2)            ; returns "c"

% Examples in Erlang
string:substr("abc", 2, 1). %  returns "b"
string:substr("abc", 2).    %  returns "bc"

# Examples in Perl 5
substr("abc", 1, 1);       #  returns "b"
substr("abc", 1);          #  returns "bc"

# Examples in Raku
"abc".substr(1, 1);        #  returns "b"
"abc".substr(1);           #  returns "bc"

# Examples in Python
"abc"[1:2]                 #  returns "b"
"abc"[1:3]                 #  returns "bc"

/* Examples in Rexx */
substr("abc", 2, 1)         /* returns "b"      */
substr("abc", 2)            /* returns "bc"     */
substr("abc", 2, 6)         /* returns "bc    " */
substr("abc", 2, 6, "*")    /* returns "bc****" */

Прописные буквы

Определение	`uppercase(string)` возвращает строку
Описание	Возвращает строку в верхнем регистре.

Формат	Языки
`UCase(string)`	ВБ
`ucase(string)`	FreeBASIC
`toupper(string)`	AWK (изменяет строку)
`uc(string)`	Жемчуг , Рак
`string.uc`	Раку
`toupper(char)`	C (работает с одним символом)
`for(size_t i = 0, len = strlen(string); i< len; i++) string[i] = toupper(string[i]);` `for (char c = string; c != '\0'; c++) c = toupper(c);`	C (массив строк/символов)
`std.string.toUpper(string)`	Д
`transform(string.begin(), string.end(), result.begin(), toupper)^[33]`	С++ ^{[ 50 ]}
`uppercase(string)`	Объектный Паскаль ( Делфи )
`upcase(char)`	Object Pascal ( Delphi ) (работает с одним символом)
`strtoupper(string)`	PHP
`upper(string)`	Сид7
`${string_param^^}` (мнемоника: ^ направлен вверх)	Баш
`echo "string" \| tr 'a-z' 'A-Z'`	Юникс
`translate(string)` `UPPER variables` `PARSE UPPER VAR SrcVar DstVar`	Рекс
`string.upper()`	Питон
`upcase(string)`	Выберите базовый
`string.upcase`	Руби ^{[ 35 ]}
`strings.ToUpper(string)`	Идти
`(string-upcase string)`	Схема , Common Lisp
`String.uppercase string`	OCaml
`String.map Char.toUpper string`	Стандартный ML
`map Char.toUpper string`	Хаскелл
`string.toUpperCase()`	Ява , JavaScript
`to_upper(string)`	Эрланг
`string.ToUpper()`	VB.NET , C# , Windows PowerShell , F#
`string.uppercaseString`	Цель-C ( `NSString *` только), Свифт (Основной)
`string.upper(string)` `(string):upper()`	Два
`string asUppercase`	Смолток
`UPPER(string)`	SQL
`ToUpperCase[string]`	Математика
`«FUNCTION» UPPER-CASE(string)`	КОБОЛ
`string.toUpper`	Кобра
`string toupper string`	Ткл
`string.to_uppercase()`	Ржавчина ^{[ 51 ]}

// Example in C#
"Wiki means fast?".ToUpper();      // "WIKI MEANS FAST?"

# Example in Perl 5
uc("Wiki means fast?");             # "WIKI MEANS FAST?"

# Example in Raku
uc("Wiki means fast?");             # "WIKI MEANS FAST?"
"Wiki means fast?".uc;              # "WIKI MEANS FAST?"

/* Example in Rexx */
translate("Wiki means fast?")      /* "WIKI MEANS FAST?" */

/* Example #2 */
A='This is an example.'
UPPER A                            /* "THIS IS AN EXAMPLE." */

/* Example #3 */
A='upper using Translate Function.'
Translate UPPER VAR A Z            /* Z="UPPER USING TRANSLATE FUNCTION." */

; Example in Scheme
(use-modules (srfi srfi-13))
(string-upcase "Wiki means fast?") ;  "WIKI MEANS FAST?"

' Example in Visual Basic
UCase("Wiki means fast?")          '  "WIKI MEANS FAST?"

подрезать

trim или strip используется для удаления пробелов в начале, конце или в начале и в конце строки.

Пример использования	Языки
`String.Trim([chars])`	C# , VB.NET , Windows PowerShell
`string.strip();`	Д
`(.trim string)`	Кложур
`sequence [ predicate? ] trim`	Фактор
`(string-trim '(#\Space #\Tab #\Newline) string)`	Общий Лисп
`(string-trim string)`	Схема
`string.trim()`	Java , JavaScript (1.8.1+, Firefox 3.5+), Rust ^{[ 52 ]}
`Trim(String)`	Паскаль , ^{[ 53 ]} QBasic , Visual Basic , Delphi
`string.strip()`	Питон
`strings.Trim(string, chars)`	Идти
`LTRIM(RTRIM(String))`	Oracle SQL , T-SQL
`strip(string [,option, char])`	РЕКСС
`string:strip(string [,option, char])`	Эрланг
`string.strip` `string.lstrip` `string.rstrip`	Руби
`string.trim`	Раку
`trim(string)`	PHP , Раку
`[string stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]`	Objective-C с использованием какао
`string withBlanksTrimmed` `string withoutSpaces` `string withoutSeparators`	Smalltalk (Писк, Фаро) Смолток
`strip(string)`	САС
`string trim $string`	Ткл
`TRIM(string)` `TRIM(ADJUSTL(string))`	Фортран
`TRIM(string)`	SQL
`TRIM(string)` `LTrim(string)` `RTrim(String)`	КолдФьюжн
`String.trim string`	OCaml 4+

Другие языки

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

АПЛ

APL может напрямую использовать регулярные выражения:

Trim←'^ +| +$'⎕R''

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

Trim←{⍵/⍨(∨\∧∘⌽∨\∘⌽)' '≠⍵}

Или дважды поменяйте местами и удалите ведущие пробелы:

Trim←{(∨\' '≠⍵)/⍵}∘⌽⍣2

АВК

В AWK для обрезки можно использовать регулярные выражения:

 ltrim(v) = gsub(/^[ \t]+/, "", v)
 rtrim(v) = gsub(/[ \t]+$/, "", v)
 trim(v)  = ltrim(v); rtrim(v)

или:

 function ltrim(s) { sub(/^[ \t]+/, "", s); return s }
 function rtrim(s) { sub(/[ \t]+$/, "", s); return s }
 function trim(s)  { return rtrim(ltrim(s)); }

С/С++

В C или C++ нет стандартной функции обрезки. Большинство доступных строковых библиотек ^{[ 54 ]} для C содержат код, реализующий обрезку, или функции, которые значительно облегчают эффективную реализацию. Эту функцию также часто называют EatWhitespace в некоторых нестандартных библиотеках C.

В C программисты часто комбинируют ltrim и rtrim для реализации обрезки:

#include <string.h>
#include <ctype.h>

void rtrim(char *str)
{
  char *s;
  s = str + strlen(str);
  while (--s >= str) {
    if (!isspace(*s)) break;
    *s = 0;
  }
}

void ltrim(char *str)
{
  size_t n;
  n = 0;
  while (str[n] != '\0' && isspace((unsigned char) str[n])) {
    n++;
  }
  memmove(str, str + n, strlen(str) - n + 1);
}

void trim(char *str)
{
  rtrim(str);
  ltrim(str);
}

Библиотека с открытым исходным кодом C++ Boost имеет несколько вариантов отделки, включая стандартный: ^{[ 55 ]}

#include <boost/algorithm/string/trim.hpp>
trimmed = boost::algorithm::trim_copy("string");

С функцией повышения, названной просто trim входная последовательность изменяется на месте и не возвращает результата.

Другая с открытым исходным кодом библиотека C++ Qt имеет несколько вариантов отделки, включая стандартный: ^{[ 56 ]}

#include <QString>
trimmed = s.trimmed();

Ядро Linux также включает функцию полосы, strstrip(), начиная с версии 2.6.18-rc1, которая обрезает строку «на месте». Начиная с версии 2.6.33-rc1 ядро использует strim() вместо strstrip() во избежание ложных предупреждений. ^{[ 57 ]}

Хаскелл

Алгоритм обрезки в Haskell :

 import Data.Char (isSpace)
 trim      :: String -> String
 trim      = f . f
    where f = reverse . dropWhile isSpace

можно интерпретировать следующим образом: f удаляет предыдущий пробел и переворачивает строку. Затем f снова применяется к собственному выводу. Обратите внимание, что сигнатура типа (вторая строка) не является обязательной.

Дж

Алгоритм обрезки в J представляет собой функциональное описание:

     trim =. #~ [: (+./\ *. +./\.) ' '&~:

То есть: фильтр( #~) для символов, не являющихся пробелами ( ' '&~:) между ведущими ( +./\) и ( *.) конечный ( +./\.) пространства.

JavaScript

В JavaScript 1.8.1 (Firefox 3.5 и новее) и стандарте ECMAScript 5 есть встроенная функция обрезки. В более ранних версиях его можно было добавить к прототипу объекта String следующим образом:

String.prototype.trim = function() {
  return this.replace(/^\s+/g, "").replace(/\s+$/g, "");
};

Перл

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

Пример:

$string =~ s/^\s+//;            # remove leading whitespace
$string =~ s/\s+$//;            # remove trailing whitespace

или:

$string =~ s/^\s+|\s+$//g ;     # remove both leading and trailing whitespace

Эти примеры изменяют значение исходной переменной. $string.

Для Perl также доступен StripLTSpace в String::Strip из КПАН .

Однако есть две функции, которые обычно используются для удаления пробелов в конце строк: chomp и chop:

chop удаляет последний символ из строки и возвращает его.
chomp удаляет конечный символ(ы) новой строки из строки, если он присутствует. (То, что представляет собой новую строку, зависит от $INPUT_RECORD_SEPARATOR ).

В Raku , будущем родственном языке Perl, строки имеют trim метод.

Пример:

$string = $string.trim;     # remove leading and trailing whitespace
$string .= trim;            # same thing

Ткл

ТКЛ string Команда имеет три соответствующие подкоманды: trim, trimright и trimleft. Для каждой из этих команд может быть указан дополнительный аргумент: строка, представляющая набор символов, которые необходимо удалить. По умолчанию используются пробелы (пробел, табуляция, новая строка, возврат каретки).

Пример обрезки гласных:

set string onomatopoeia
set trimmed [string trim $string aeiou]         ;# result is nomatop
set r_trimmed [string trimright $string aeiou]  ;# result is onomatop
set l_trimmed [string trimleft $string aeiou]   ;# result is nomatopoeia

XSLT

XSLT включает функцию normalize-space(string) который удаляет начальные и конечные пробелы, а также заменяет любую последовательность пробелов (включая разрывы строк) одним пробелом.

Пример:

<xsl:variable name='trimmed'>
   <xsl:value-of select='normalize-space(string)'/>
</xsl:variable>

XSLT 2.0 включает регулярные выражения, предоставляя еще один механизм обрезки строк.

Другой метод XSLT для обрезки — использование XPath 2.0. substring() функция.

Ссылки

^ Jump up to: ^а ^б ^с ^д ^и индекс может быть отрицательным, что указывает на количество мест до конца строки.
^ В Rust str::chars метод выполняет итерацию по точкам кода и std::iter::Iterator::nth метод на итераторах возвращает n-е значение с нулевым индексом из итератора, или None.
^ индекс не может быть отрицательным, используйте *-N , где N указывает количество мест до конца строки.
^ В C++ перегруженный operator<=> метод для строки возвращает std::strong_ordering объект (иначе std::weak_ordering): less, equal (то же самое, что equivalent), или greater.
^ возвращает МЕНЬШЕ, РАВНО или БОЛЬШЕ
^ возвращает LT, EQ или GT
^ возвращает .TRUE. или .FALSE.. Эти функции основаны на последовательности сортировки ASCII.
^ Jump up to: ^а ^б Расширение IBM.
^ В Rust Ord::cmp метод для строки возвращает Ordering: Less, Equal, или Greater.
^ Jump up to: ^а ^б ^с ^д ^и ^ж В Rust операторы == и != и методы eq, ne реализуются PartialEq черта и операторы <, >, <=, >= и методы lt, gt, le, ge реализуются PartialOrd черта.
^ Операторы используют последовательность сортировки компилятора по умолчанию.
^ изменяет string₁, в котором должно быть достаточно места для хранения результата
^ В Rust + оператор реализуется Add черта.
^ См . str::contains метод.
^ См . std::basic_string::contains метод.
^ Jump up to: ^а ^б startpos — это расширение IBM.
^ Jump up to: ^а ^б См. str::find метод.
^ startpos это расширение IBM.
^ «сканировать в Fortran Wiki» . Фортранвики.орг. 30 апреля 2009 г. Проверено 18 августа 2013 г.
^ «проверить в Fortran Wiki» . Фортранвики.орг. 03.05.2012 . Проверено 18 августа 2013 г.
^ formatstring должен быть фиксированным литералом во время компиляции, чтобы иметь правильный тип.
^ См. std::format, который импортируется из прелюдии Rust , чтобы его можно было использовать под именем format.
^ См . slice::join метод.
^ если n больше длины строки, то в режиме отладки выдается исключение ArrayRangeException, в режиме выпуска поведение не указано .
^ если n больше длины строки, Java выдаст исключение IndexOutOfBoundsException
^ Jump up to: ^а ^б если n больше длины строки, выдается Invalid_argument
^ Jump up to: ^а ^б если n больше длины строки, выдать сообщение "StringTake::take:"
^ Jump up to: ^а ^б ^с В Rust строки индексируются с точки зрения смещения байтов, и во время выполнения возникает паника, если индекс выходит за пределы или если это приведет к недопустимому UTF-8 . А &str (строковая ссылка) может индексироваться различными типами диапазонов, включая Range ( 0..n), RangeFrom ( n..), и RangeTo ( ..n), потому что все они реализуют SliceIndex черта с str является индексируемым типом. str::get метод — это способ индексации без паники. Он возвращает None в тех случаях, когда индексация может вызвать панику.
^ В Ruby отсутствует поддержка Unicode.
^ См . str::len метод.
^ В Rust str::chars метод выполняет итерацию по точкам кода и std::iter::Iterator::count Метод для итераторов использует итератор и возвращает общее количество элементов в итераторе.
^ работает с одним символом
^ Jump up to: ^а ^б The transform функция существует в std:: пространство имен. Вы должны включить <algorithm> заголовочный файл, чтобы использовать его. tolower и toupper функции находятся в глобальном пространстве имен, полученном <ctype.h> заголовочный файл. std::tolower и std::toupper имена перегружены и не могут быть переданы std::transform без приведения для разрешения неоднозначности перегрузки функции, например std::transform(string.begin(), string.end(), result.begin(), (int (*)(int))std::tolower);
^ std::string только результат сохраняется в строке result что, по крайней мере, до тех пор, пока string, и может быть, а может и не быть string сам
^ Jump up to: ^а ^б только символы ASCII, поскольку Ruby не поддерживает Unicode
^ См . str::to_lowercase метод.
^ См . str::replace метод.
^ Jump up to: ^а ^б ^с ^д ^и Строка «найти» в этой конструкции интерпретируется как регулярное выражение . Некоторые символы имеют особое значение в регулярных выражениях. Если вы хотите найти строку буквально, вам нужно взять в кавычки специальные символы.
^ третий параметр нестандартный
^ В Rust str::chars метод выполняет итерацию по точкам кода, std::iter::Iterator::rev метод на обратимых итераторах ( std::iter::DoubleEndedIterator) создает обратный итератор, а std::iter::Iterator::collect метод использует итератор и создает коллекцию (которая здесь указана как String с синтаксисом Turbofish ) из элементов итератора.
^ См . str::rfind метод.
^ «Аннотированный ES5» . Es5.github.com. Архивировано из оригинала 28 января 2013 г. Проверено 18 августа 2013 г.
^ если n больше длины строки, то в режиме отладки выдается исключение ArrayRangeException и неопределенное поведение в режиме выпуска.
^ См . str::split и str::rsplit методы.
^ Jump up to: ^а ^б ^с ^д ^и ^ж ^г startpos может быть отрицательным, что указывает на то, что начинать нужно с указанного количества мест до конца строки.
^ Jump up to: ^а ^б numChars может быть отрицательным, что указывает на то, что нужно закончить это количество мест до конца строки.
^ startpos может не быть отрицательным, используйте * - startpos , чтобы указать, что нужно начинать с этого количества мест до конца строки.
^ numChars может не быть отрицательным, используйте * - numChars , чтобы указать, что нужно закончить это количество мест до конца строки.
^ Jump up to: ^а ^б ^с ^д ^и endpos может быть отрицательным, что указывает на то, что нужно закончить это количество мест до конца строки.
^ std::string только результат сохраняется в строке result , длина которой не менее длины строки , и может быть, а может и не быть строкой. самой
^ В Rust str::to_uppercase метод возвращает вновь выделенный String при этом любые строчные символы заменяются на прописные в соответствии с правилами Юникода.
^ В Rust str::trim метод возвращает ссылку на оригинал &str.
^ «Обрезка — Справочник по GNU Pascal» . Gnu-pascal.de . Проверено 24 августа 2013 г.
^ «Сравнение строковых библиотек» . И.орг . Проверено 24 августа 2013 г.
^ «Использование – 1.54.0» . Boost.org. 22 мая 2013 г. Проверено 24 августа 2013 г.
^ [1] Архивировано 2 августа 2009 г., в Wayback Machine.
^ данкамонгмен. «sprezzos-kernel-packaging/changelog в master · dankamongmen/sprezzos-kernel-packaging · GitHub» . Гитхаб.com . Проверено 29 мая 2016 г.

[at1-1] Jump up to: ^а ^б ^с ^д ^и индекс может быть отрицательным, что указывает на количество мест до конца строки.

[2] В Rust str::chars метод выполняет итерацию по точкам кода и std::iter::Iterator::nth метод на итераторах возвращает n-е значение с нулевым индексом из итератора, или None.

[at2-3] индекс не может быть отрицательным, используйте *-N , где N указывает количество мест до конца строки.

[4] В C++ перегруженный operator<=> метод для строки возвращает std::strong_ordering объект (иначе std::weak_ordering): less, equal (то же самое, что equivalent), или greater.

[5] возвращает МЕНЬШЕ, РАВНО или БОЛЬШЕ

[6] возвращает LT, EQ или GT

[7] возвращает .TRUE. или .FALSE.. Эти функции основаны на последовательности сортировки ASCII.

[lower1-8] Jump up to: ^а ^б Расширение IBM.

[9] В Rust Ord::cmp метод для строки возвращает Ordering: Less, Equal, или Greater.

[Rust_compare-10] Jump up to: ^а ^б ^с ^д ^и ^ж В Rust операторы == и != и методы eq, ne реализуются PartialEq черта и операторы <, >, <=, >= и методы lt, gt, le, ge реализуются PartialOrd черта.

[11] Операторы используют последовательность сортировки компилятора по умолчанию.

[12] изменяет string₁, в котором должно быть достаточно места для хранения результата

[13] В Rust + оператор реализуется Add черта.

[14] ^ См . str::contains метод.

[15] ^ См . std::basic_string::contains метод.

[contain1-16] Jump up to: ^а ^б startpos — это расширение IBM.

[Rust_find-17] Jump up to: ^а ^б См. str::find метод.

[fc1-18] startpos это расширение IBM.

[19] «сканировать в Fortran Wiki» . Фортранвики.орг. 30 апреля 2009 г. Проверено 18 августа 2013 г.

[20] «проверить в Fortran Wiki» . Фортранвики.орг. 03.05.2012 . Проверено 18 августа 2013 г.

[21] formatstring должен быть фиксированным литералом во время компиляции, чтобы иметь правильный тип.

[22] См. std::format, который импортируется из прелюдии Rust , чтобы его можно было использовать под именем format.

[23] ^ См . slice::join метод.

[24] если n больше длины строки, то в режиме отладки выдается исключение ArrayRangeException, в режиме выпуска поведение не указано .

[25] если n больше длины строки, Java выдаст исключение IndexOutOfBoundsException

[ReferenceA-26] Jump up to: ^а ^б если n больше длины строки, выдается Invalid_argument

[ReferenceB-27] Jump up to: ^а ^б если n больше длины строки, выдать сообщение "StringTake::take:"

[Rust_indexing-28] Jump up to: ^а ^б ^с В Rust строки индексируются с точки зрения смещения байтов, и во время выполнения возникает паника, если индекс выходит за пределы или если это приведет к недопустимому UTF-8 . А &str (строковая ссылка) может индексироваться различными типами диапазонов, включая Range ( 0..n), RangeFrom ( n..), и RangeTo ( ..n), потому что все они реализуют SliceIndex черта с str является индексируемым типом. str::get метод — это способ индексации без паники. Он возвращает None в тех случаях, когда индексация может вызвать панику.

[29] В Ruby отсутствует поддержка Unicode.

[30] ^ См . str::len метод.

[31] В Rust str::chars метод выполняет итерацию по точкам кода и std::iter::Iterator::count Метод для итераторов использует итератор и возвращает общее количество элементов в итераторе.

[32] работает с одним символом

[cpptransform-33] Jump up to: ^а ^б The transform функция существует в std:: пространство имен. Вы должны включить <algorithm> заголовочный файл, чтобы использовать его. tolower и toupper функции находятся в глобальном пространстве имен, полученном <ctype.h> заголовочный файл. std::tolower и std::toupper имена перегружены и не могут быть переданы std::transform без приведения для разрешения неоднозначности перегрузки функции, например std::transform(string.begin(), string.end(), result.begin(), (int (*)(int))std::tolower);

[34] std::string только результат сохраняется в строке result что, по крайней мере, до тех пор, пока string, и может быть, а может и не быть string сам

[ReferenceC-35] Jump up to: ^а ^б только символы ASCII, поскольку Ruby не поддерживает Unicode

[36] ^ См . str::to_lowercase метод.

[37] ^ См . str::replace метод.

[regex-38] Jump up to: ^а ^б ^с ^д ^и Строка «найти» в этой конструкции интерпретируется как регулярное выражение . Некоторые символы имеют особое значение в регулярных выражениях. Если вы хотите найти строку буквально, вам нужно взять в кавычки специальные символы.

[39] третий параметр нестандартный

[40] В Rust str::chars метод выполняет итерацию по точкам кода, std::iter::Iterator::rev метод на обратимых итераторах ( std::iter::DoubleEndedIterator) создает обратный итератор, а std::iter::Iterator::collect метод использует итератор и создает коллекцию (которая здесь указана как String с синтаксисом Turbofish ) из элементов итератора.

[41] ^ См . str::rfind метод.

[42] «Аннотированный ES5» . Es5.github.com. Архивировано из оригинала 28 января 2013 г. Проверено 18 августа 2013 г.

[43] если n больше длины строки, то в режиме отладки выдается исключение ArrayRangeException и неопределенное поведение в режиме выпуска.

[44] ^ См . str::split и str::rsplit методы.

[substr2-45] Jump up to: ^а ^б ^с ^д ^и ^ж ^г startpos может быть отрицательным, что указывает на то, что начинать нужно с указанного количества мест до конца строки.

[substr4-46] Jump up to: ^а ^б numChars может быть отрицательным, что указывает на то, что нужно закончить это количество мест до конца строки.

[substr5-47] startpos может не быть отрицательным, используйте * - startpos , чтобы указать, что нужно начинать с этого количества мест до конца строки.

[substr6-48] numChars может не быть отрицательным, используйте * - numChars , чтобы указать, что нужно закончить это количество мест до конца строки.

[substr3-49] Jump up to: ^а ^б ^с ^д ^и endpos может быть отрицательным, что указывает на то, что нужно закончить это количество мест до конца строки.

[50] std::string только результат сохраняется в строке result , длина которой не менее длины строки , и может быть, а может и не быть строкой. самой

[51] В Rust str::to_uppercase метод возвращает вновь выделенный String при этом любые строчные символы заменяются на прописные в соответствии с правилами Юникода.

[52] В Rust str::trim метод возвращает ссылку на оригинал &str.

[53] «Обрезка — Справочник по GNU Pascal» . Gnu-pascal.de . Проверено 24 августа 2013 г.

[54] «Сравнение строковых библиотек» . И.орг . Проверено 24 августа 2013 г.

[55] «Использование – 1.54.0» . Boost.org. 22 мая 2013 г. Проверено 24 августа 2013 г.

[56] [1] Архивировано 2 августа 2009 г., в Wayback Machine.

[57] данкамонгмен. «sprezzos-kernel-packaging/changelog в master · dankamongmen/sprezzos-kernel-packaging · GitHub» . Гитхаб.com . Проверено 29 мая 2016 г.

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

[ 5 ]

[ 6 ]

[ 7 ]

[ 8 ]

[ 9 ]

[ 10 ]

[ 11 ]

[ 12 ]

[ 13 ]

[ 14 ]

[ 15 ]

[ 16 ]

[ 17 ]

[ 18 ]

[ 19 ]

[ 20 ]

[ 21 ]

[ 22 ]

[ 23 ]

[ 24 ]

[ 25 ]

[ 26 ]

[ 27 ]

[ 28 ]

[ 29 ]

[ 30 ]

[ 31 ]

[ 32 ]

[ 33 ]

[ 34 ]

[ 35 ]

[ 36 ]

[ 37 ]

[38]

[39]

[ 40 ]

[ 41 ]

[ 42 ]

[ 43 ]

[ 44 ]

[ 45 ]

[ 46 ]

[ 47 ]

[ 48 ]

[ 49 ]

[ 50 ]

[ 51 ]

[ 52 ]

[ 53 ]

[ 54 ]

[ 55 ]

[ 56 ]

[ 57 ]

Общие строковые функции (многоязычный справочник)

ЧарАт

Сравнить (целочисленный результат)

Сравнение (реляционный оператор, логический результат)

Конкатенация

Содержит

Равенство

Находить

Найти персонажа

Формат

Неравенство

индекс

индекс

инстр

инстррев

присоединиться

последнийиндексоф

левый

только

длина

найти

строчные буквы

середина

раздел

заменять

обеспечить регресс

найти

верно

перегородка

кусочек

расколоть

спринтф

полоска

стркмп

подстрока

Прописные буквы

подрезать

АПЛ

АВК

С/С++

Хаскелл

Дж

JavaScript

Перл

Ткл

XSLT

Ссылки