Porovnání programovacích jazyků (řetězcové funkce) - Comparison of programming languages (string functions)
Řetězcové funkce se používají v počítačových programovacích jazycích k manipulaci s řetězcem nebo dotazem na informace o řetězci (některé dělají obojí).
Většina programovacích jazyků, které mají řetězec datový typ, bude mít některé funkce řetězce, i když v každém jazyce mohou existovat další způsoby nízké úrovně pro přímé zpracování řetězců. V objektově orientovaných jazycích jsou řetězcové funkce často implementovány jako vlastnosti a metody řetězcových objektů. Ve funkčních jazycích a jazycích založených na seznamu je řetězec reprezentován jako seznam (znakových kódů), proto by všechny procedury manipulace se seznamem mohly být považovány za řetězcové funkce. Tyto jazyky však mohou implementovat také podmnožinu explicitních funkcí specifických pro řetězce.
U funkcí, které manipulují s řetězci, mají moderní objektově orientované jazyky, jako C# a Java , neměnné řetězce a vracejí kopii (v nově přidělené dynamické paměti), zatímco jiné, jako C, manipulují s původním řetězcem, pokud programátor nekopíruje data do nového řetězce. Viz například níže uvedené Zřetězení .
Nejzákladnějším příkladem funkce řetězce je length(string)
funkce. Tato funkce vrací délku řetězcového literálu .
- např.
length("hello world")
vrátí 11.
Jiné jazyky mohou mít řetězcové funkce s podobnou nebo úplně stejnou syntaxí nebo parametry nebo výsledky. Například v mnoha jazycích je funkce délky obvykle reprezentována jako len (řetězec) . Níže uvedený seznam běžných funkcí má tento zmatek omezit.
Společné funkce řetězců (vícejazyčný odkaz)
Níže jsou uvedeny funkce řetězců společné mnoha jazykům, včetně různých použitých názvů. Níže uvedený seznam běžných funkcí má programátorům pomoci najít ekvivalentní funkce v jazyce. Všimněte si, že zřetězení řetězců a regulární výrazy jsou zpracovány na samostatných stránkách. Prohlášení v guillemetech («…») jsou volitelná.
CharAt
Definice |
charAt(string,integer) vrací znak.
|
---|---|
Popis | Vrací znak v indexu v řetězci. |
Ekvivalent | Viz podřetězec délky 1 znak. |
Formát | Jazyky | Základní index |
---|---|---|
string[i]
|
ALGOL 68 , APL , Julia , Pascal , Object Pascal ( Delphi ), Seed7 | 1 |
string[i]
|
C , C ++ , C# , Cobra , D , FreeBASIC , Go , Python , PHP , Ruby , Windows PowerShell , JavaScript , APL | 0 |
string{i}
|
PHP (zastaralé v 5.3) | 0 |
string(i)
|
Ada | ≥1 |
Mid(string,i,1)
|
VB | 1 |
MID$(string,i,1)
|
ZÁKLADNÍ | 1 |
string.Chars(i)
|
VB.NET | 0 |
string(i:i)
|
Fortran | 1 |
string.charAt(i)
|
Java , JavaScript | 0 |
string.[i]
|
OCaml , F# | 0 |
string.chars().nth(i)
|
Rez | 0 |
string[i,1]
|
Vyberte základní | 1 |
String.sub (string, i)
|
Standardní ML | 0 |
string !! i
|
Haskell | 0 |
(string-ref string i)
|
Systém | 0 |
(char string i)
|
Lisp | 0 |
(elt string i)
|
ISLISP | 0 |
(get string i)
|
Clojure | 0 |
substr(string, i, 1)
|
Perl 5 | 0 |
substr(string, i, 1) string.substr(i, 1)
|
Raku | 0 |
substr(string, i, 1)
|
PL/I | 1 |
string.at(i)
|
C ++ (STL) (s kontrolou mezí) | 0 |
lists:nth(i, string)
|
Erlang | 1 |
[string characterAtIndex:i]
|
Cíl-C ( NSString * pouze)
|
0 |
string.sub(string, i, i)
|
Lua | 1 |
string at: i
|
Smalltalk (s kontrolou mezí) | 1 |
string index string i
|
Tcl | 0 |
StringTake[string, {i}]
|
Mathematica , Wolfram Language | 1 |
string@i
|
Eiffelova | 1 |
string (i:1)
|
COBOL | 1 |
i⌷string
|
APL | 0 nebo 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')
Porovnat (celočíselný výsledek)
Definice |
compare(string1,string2) vrací celé číslo.
|
---|---|
Popis | Porovná dva řetězce k sobě. Pokud jsou ekvivalentní, vrátí se nula. V opačném případě, většina z těchto rutin se vrátí pozitivní nebo negativní výsledek odpovídající zda řetězec 1 je lexikograficky větší než nebo menší než, v daném pořadí, než řetězec 2 . Výjimkou jsou rutiny Scheme a Rexx, které vracejí index prvního nesouladu, a Smalltalk, které odpovídají na srovnávací kód sdělující, jak příjemce třídí relativně k řetězcovému parametru. |
Formát | Jazyky |
---|---|
IF string1<string2 THEN -1 ELSE ABS (string1>string2) FI
|
ALGOL 68 |
cmp(string1, string2)
|
Python 2 |
(string1 > string2) - (string1 < string2)
|
Krajta |
strcmp(string1, string2)
|
C , PHP |
std.string.cmp(string1, string2)
|
D |
StrComp(string1, string2)
|
VB , Object Pascal ( Delphi ) |
string1 cmp string2
|
Perl , Raku |
string1 compare: string2
|
Smalltalk ( Squeak , Pharo ) |
string1 <=> string2
|
Ruby , C ++ (STL, C ++ 20 ) |
string1.compare(string2)
|
C ++ (STL), Swift (Foundation) |
compare(string1, string2)
|
Rexx , Seed7 |
CompareStr(string1, string2)
|
Pascal , Object Pascal ( Delphi ) |
string1.compareTo(string2)
|
Cobra , Java |
string1.CompareTo(string2)
|
VB .NET , C# , F# |
(compare string1 string2)
|
Clojure |
(string= string1 string2)
|
Lisp |
(string-compare string1 string2 p< p= p>)
|
Schéma (SRFI 13) |
(string= string1 string2)
|
ISLISP |
compare string1 string2
|
OCaml |
String.compare (string1, string2)
|
Standardní ML |
compare string1 string2
|
Haskell |
[string]::Compare(string1, string2)
|
Windows PowerShell |
[string1 compare:string2]
|
Cíl-C ( NSString * pouze)
|
LLT(string1,string2)
|
Fortran |
string1.localeCompare(string2)
|
JavaScript |
bytes.Compare([]byte(string1), []byte(string2))
|
Jít |
string compare ?-nocase? ?-length int? string1 string2
|
Tcl |
compare(string1,string2,count)
|
PL/I |
string1.cmp(string2)
|
Rez |
# 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)
Porovnat (relační operátor, logický výsledek)
Definice |
string1 OP string2 NEBO vrátí logickou hodnotu.
(compare string1 string2) |
---|---|
Popis | Lexikograficky porovnává dva řetězce pomocí relačního operátoru nebo funkce. Logický výsledek se vrátil. |
Formát | Jazyky |
---|---|
string1 OP string2 , kde OP může být některý z =, <>, <, >, <= a>=
|
Pascal , Object Pascal ( Delphi ), OCaml , Seed7 , Standard ML , BASIC , VB , VB .NET , F# |
string1 OP string2 , kde OP může být některý z =, /=, ≠, <, >, <=, ≤ a ≥ ; Také: EQ, NE, LT, LE, GE aGT
|
ALGOL 68 |
(stringOP? string1 string2) , Kde OP může být některý z =, -ci=, <, -ci<, >, -ci>, <=, -ci<=, >= a -ci>= (operátory začínajících na ‚ -ci ‘, jsou velká a malá písmena)
|
Systém |
(stringOP string1 string2) , Kde OP může být některý z =, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >= a -ci>= (operátory začínajících na ‚ -ci ‘, jsou velká a malá písmena)
|
Schéma (SRFI 13) |
(stringOP string1 string2) , Kde OP může být některý z =, -equal, /=, -not-equal, <, -lessp, >, -greaterp, <=, -not-greaterp, >= a -not-lessp (slovní operátoři jsou velká a malá písmena)
|
Lisp |
(stringOP string1 string2) , kde OP může být některý z =, /=, <, >, <=, a>=
|
ISLISP |
string1 OP string2 , kde OP může být některý z =, \=, <, >, <= a>=
|
Rexx |
string1 OP string2 , kde OP může být některý z =, ¬=, <, >, <=, >=, ¬< a¬>
|
PL/I |
string1 OP string2 , kde OP může být některý z =, /=, <, >, <= a>=
|
Ada |
string1 OP string2 , kde OP může být některý z ==, /=, <, >, =< a>=
|
Erlang |
string1 OP string2 , kde OP může být některý z ==, /=, <, >, <= a>=
|
Haskell |
string1 OP string2 , kde OP může být některý z aeq, ne, lt, gt, le ge
|
Perl , Raku |
string1 OP string2 , kde OP může být některý z ==, !=, <, >, <= a>=
|
C ++ (STL), C# , D , Go , JavaScript , Python , PHP , Ruby , Rust , Swift |
string1 OP string2 , kde OP může být kterýkoli z ( -eq, -ceq, -ne, -cne, -lt, -clt, -gt, -cgt, -le, -cle, -ge, a -cge operátory začínající na ' c ' rozlišují velká a malá písmena)
|
Windows PowerShell |
string1 OP string2 , kde OP může být některý z ==, ~=, <, >, <= a>=
|
Lua |
string1 OP string2 , kde OP může být některý z =, ~=, <, >, <= a>=
|
Pokec |
string1 OP string2 , Kde OP může být jeden z ==, /=, <, >, <= a >=; Also: .EQ., .NE., .LT., .LE., .GT. a.GE.
|
Fortran . |
string1 OP string2 kde OP může být jakýkoli z =, <>, <, >, <=, >= i ekvivalentních znění
|
COBOL |
string1 OP string2 kde OP může být některý z ==, <>, <, >, <= a>=
|
Kobra |
string1 OP string2 je k dispozici v syntaxi, ale znamená srovnání ukazatelů směřujících na řetězce, nikoli obsahu řetězce. Použijte funkci Porovnat (celočíselný výsledek).
|
C , Java |
string1.METHOD(string2) kde METHOD je některý z eq , ne , gt , lt , ge ,le
|
Rez |
% 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
Zřetězení
Definice |
concatenate(string1,string2) vrací řetězec.
|
---|---|
Popis | Zřetězí (spojí) dva řetězce k sobě a vrátí kombinovaný řetězec. Všimněte si toho, že některé jazyky, jako je C, mají proměnlivé řetězce, takže ve skutečnosti je druhý řetězec připojen k prvnímu řetězci a je vrácen mutovaný řetězec. |
Formát | Jazyky |
---|---|
string1 & string2
|
Ada , FreeBASIC , Seed7 , BASIC , VB , VB .NET , COBOL (pouze mezi literály) |
strcat(string1, string2)
|
C , C ++ ( pouze)
char * |
string1 . string2
|
Perl , PHP |
string1 + string2
|
ALGOL 68 , C ++ (STL), C# , Cobra , FreeBASIC , Go , Pascal , Object Pascal ( Delphi ), Java , JavaScript , Windows PowerShell , Python , Ruby , Rust , F# , Swift , Turing , VB |
string1 ~ string2
|
D , Raku |
(string-append string1 string2)
|
Schéma , ISLISP |
(concatenate 'string string1 string2)
|
Lisp |
(str string1 string2)
|
Clojure |
string1 || string2
|
Rexx , SQL , PL/I |
string1 // string2
|
Fortran |
string1 ++ string2
|
Erlang , Haskell |
string1 ^ string2
|
OCaml , standardní ML , F# |
[string1 stringByAppendingString:string2]
|
Cíl-C ( NSString * pouze)
|
string1 .. string2
|
Lua |
string1 , string2
|
Smalltalk , APL |
string1 string2
|
SNOBOL |
string1string2
|
Bash shell |
string1 <> string2
|
Mathematica |
concat řetězec 1 řetězec 2 | Tcl |
{ 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 "Raku"
Obsahuje
Definice |
contains(string,substring) vrací boolean
|
---|---|
Popis | Vrátí, zda řetězec obsahuje podřetězec jako podřetězec. To je ekvivalentní použití funkce Najít a následnému zjištění, že to nevede ke stavu selhání uvedenému ve třetím sloupci sekce Najít. Některé jazyky však mají k vyjádření tohoto testu jednodušší způsob. |
Příbuzný | Nalézt |
Formát | Jazyky |
---|---|
string_in_string(string, loc int, substring)
|
ALGOL 68 |
ContainsStr(string, substring)
|
Object Pascal ( Delphi ) |
strstr(string, substring) != NULL
|
C , C ++ ( char * pouze)
|
string.Contains(substring)
|
C# , VB .NET , Windows PowerShell , F# |
string.contains(substring)
|
Cobra , Java (1,5+), Raku , Rust , C ++ ( C ++ 23 ) |
string.indexOf(substring) >= 0
|
JavaScript |
strpos(string, substring) !== false
|
PHP |
str_contains(string, substring)
|
PHP (8+) |
pos(string, substring) <> 0
|
Semeno 7 |
substring in string
|
Cobra , Python (2.3+) |
string.find(string, substring) ~= nil
|
Lua |
string.include?(substring)
|
Rubín |
Data.List.isInfixOf substring string
|
Haskell (GHC 6.6+) |
string includesSubstring: substring
|
Smalltalk ( Squeak , Pharo , Smalltalk/X ) |
String.isSubstring substring string
|
Standardní ML |
(search substring string)
|
Lisp |
(not (null (string-index substring string)))
|
ISLISP |
(substring? substring string)
|
Clojure |
! StringFreeQ[string, substring]
|
Mathematica |
index(string, substring, startpos)>0
|
Fortran, PL/I |
index(string, substring, occurrence)>0
|
Vyberte základní |
strings.Contains(string, substring)
|
Jít |
string.find(substring) != string::npos
|
C ++ |
[string containsString:substring]
|
Objective-C ( NSString * pouze iOS 8+/OS X 10.10+)
|
string.rangeOfString(substring) != nil
|
Swift (nadace) |
∨/substring⍷string
|
APL |
¢ 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 "
Rovnost
Testuje, zda jsou dva řetězce stejné. Viz také #Compare a #Compare . Všimněte si toho, že provádění kontrol rovnosti pomocí obecného výsledku Porovnat s celočíselným číslem je nejen matoucí pro programátora, ale často je i výrazně nákladnější operací; to platí zejména při použití „ C-řetězců “.
Formát | Jazyky |
---|---|
string1 == string2
|
Python , C ++ (STL), C# , Cobra , Go , JavaScript (podobnost), PHP (podobnost), Ruby , Rust , Erlang , Haskell , Lua , D , Mathematica , Swift |
string1 === string2
|
JavaScript , PHP |
string1 == string2 or
|
Fortran |
strcmp(string1, string2) == 0
|
C |
(string=? string1 string2)
|
Systém |
(string= string1 string2)
|
Common Lisp , ISLISP |
string1 = string2
|
ALGOL 68 , Ada , Object Pascal ( Delphi ), OCaml , Pascal , Rexx , Seed7 , Standard ML , BASIC , VB , VB .NET , F# , Smalltalk , PL/I , COBOL |
test string1 = string2, or
|
Bourne Shell |
string1 eq string2
|
Perl , Raku |
string1.equals(string2)
|
Cobra , Java |
string1.Equals(string2)
|
C# |
string1 -eq string2, or
|
Windows PowerShell |
[string1 isEqualToString:string2], or
|
Cíl-C ( NSString * pouze)
|
string1 ≡ string2
|
APL |
string1.eq(string2)
|
Rez |
// 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
Nalézt
Definice |
find(string,substring) vrací celé číslo
|
---|---|
Popis | Vrátí pozici začátku prvního výskytu podřetězce v řetězci . Pokud podřetězec není nalezen, většina těchto rutin vrací neplatnou hodnotu indexu--1, kde jsou indexy založené na 0, 0, kde jsou založeny na 1-nebo nějakou hodnotu, která má být interpretována jako logická hodnota FALSE. |
Příbuzný | instrrev |
Formát | Jazyky | Pokud nebyl nalezen |
---|---|---|
string in string(substring, pos, string[startpos:])
|
ALGOL 68 | vrátí BOOL: TRUE nebo FALSE a pozici v REF INT poz. |
InStr(«startpos,»string,substring)
|
VB (pozice začínají na 1) | vrací 0 |
INSTR$(string,substring)
|
ZÁKLADNÍ (pozice začínají na 1) | vrací 0 |
index(string,substring)
|
AWK | vrací 0 |
index(string,substring«,startpos»)
|
Perl 5 | vrací -1 |
index(string,substring«,startpos») string.index(substring,«,startpos»)
|
Raku | vrací Nil |
instr(«startpos,»string,substring)
|
ZDARMA | vrací 0 |
strpos(string,substring«,startpos»)
|
PHP | vrátí FALSE |
locate(string, substring)
|
Ingres | vrací délku řetězce + 1 |
strstr(string, substring)
|
C , C ++ ( pouze vrací ukazatel na první znak)
char * |
vrací NULL |
std.string.indexOf(string, substring)
|
D | vrací -1 |
pos(string, substring«, startpos»)
|
Semeno 7 | vrací 0 |
strings.Index(string, substring)
|
Jít | vrací -1 |
pos(substring, string)
|
Pascal , Object Pascal ( Delphi ) | vrací 0 |
pos(substring, string«,startpos»)
|
Rexx | vrací 0 |
string.find(substring«,startpos»)
|
C ++ (STL) | vrací std :: string :: npos |
string.find(substring«,startpos«,endpos»»)
|
Krajta | vrací -1 |
string.index(substring«,startpos«,endpos»»)
|
zvyšuje hodnotu ValueError | |
string.index(substring«,startpos»)
|
Rubín | vrací nula |
string.indexOf(substring«,startpos»)
|
Java , JavaScript | vrací -1 |
string.IndexOf(substring«,startpos«, charcount»»)
|
VB .NET , C# , Windows PowerShell , F# | vrací -1 |
string:str(string, substring)
|
Erlang | vrací 0 |
(string-contains string substring)
|
Schéma (SRFI 13) | vrací #f |
(search substring string)
|
Lisp | vrací NIL |
(string-index substring string)
|
ISLISP | vrací nil
|
List.findIndex (List.isPrefixOf substring) (List.tails string)
|
Haskell (vrací pouze index ) | vrací nic |
Str.search_forward (Str.regexp_string substring) string 0
|
OCaml | vyvolává Not_found |
Substring.size (#1 (Substring.position substring (Substring.full string)))
|
Standardní ML | vrací délku řetězce |
[string rangeOfString:substring].location
|
Cíl-C ( NSString * pouze)
|
vrací NSNotFound |
string.find(string, substring)
|
Lua | vrací nula |
string indexOfSubCollection: substring startingAt: startpos ifAbsent: aBlock
|
Smalltalk ( Squeak , Pharo ) | vyhodnotit aBlock, což je uzavření bloku (nebo jakákoli hodnota pro porozumění objektu), vrátí 0 |
startpos = INDEX(string, substring «,back» «, kind»)
|
Fortran | vrací 0, pokud podřetězec není v řetězci; vrací LEN (řetězec) +1, pokud je podřetězec prázdný |
POSITION(substring IN string)
|
SQL | vrací 0 (pozice začínají na 1) |
index(string, substring, startpos )
|
PL/I | vrací 0 (pozice začínají na 1) |
index(string, substring, occurrence )
|
Vyberte základní | vrací 0, pokud výskyt podřetězce není v řetězci; (pozice začínají na 1) |
string.indexOf(substring«,startpos«, charcount»»)
|
Kobra | vrací -1 |
string first substring string startpos
|
Tcl | vrací -1 |
(substring⍷string)⍳1
|
APL | vrací 1 + poslední pozici v řetězci |
string.find(substring)
|
Rez | vrací None
|
; Examples in Common Lisp
(search "e" "Hello mate") ; returns 1
(search "z" "word") ; returns NIL
// Examples in C#
"Hello mate".IndexOf("e"); // returns 1
"Hello mate".IndexOf("e", 4); // returns 9
"word".IndexOf("z"); // returns -1
# Examples in Raku
"Hello, there!".index('e') # returns 1
"Hello, there!".index('z') # returns Nil
; Examples in Scheme
(use-modules (srfi srfi-13))
(string-contains "Hello mate" "e") ; returns 1
(string-contains "word" "z") ; returns #f
' Examples in Visual Basic
InStr("Hello mate", "e") ' returns 2
InStr(5, "Hello mate", "e") ' returns 10
InStr("word", "z") ' returns 0
" Examples in Smalltalk "
'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"
Najděte postavu
Definice |
find_character(string,char) vrací celé číslo
|
---|---|
Popis | Vrátí pozici začátku prvního výskytu znaku char v řetězci . Pokud znak není nalezen, většina těchto rutin vrací neplatnou hodnotu indexu--1, kde jsou indexy založeny na 0, 0, kde jsou založeny na 1-nebo nějakou hodnotu, která má být interpretována jako logická hodnota FALSE. Toho lze dosáhnout jako speciální případ #Find s řetězcem jednoho znaku; ale v mnoha jazycích může být jednodušší nebo efektivnější najít pouze jeden znak. V mnoha jazycích jsou znaky a řetězce různých typů, takže je vhodné mít takovou funkci. |
Příbuzný | nalézt |
Formát | Jazyky | Pokud nebyl nalezen |
---|---|---|
char in string(char, pos, string[startpos:])
|
ALGOL 68 | vrátí BOOL: TRUE nebo FALSE a pozici v REF INT poz. |
instr(string, any char«,startpos») (char, může obsahovat více z nich jeden znak, v takovém případě se vrátí pozice prvního výskytu kteréhokoli z nich.)
|
ZDARMA | vrací 0 |
strchr(string,char)
|
C , C ++ ( pouze vrací ukazatel na znak)
char * |
vrací NULL |
std.string.find(string, dchar)
|
D | vrací -1 |
string.find(char«,startpos»)
|
C ++ (STL) | vrací std :: string :: npos |
pos(string, char«, startpos»)
|
Semeno 7 | vrací 0 |
strings.IndexRune(string,char)
|
Jít | vrací -1 |
string.indexOf(char«,startpos»)
|
Java , JavaScript | vrací -1 |
string.IndexOf(char«,startpos«, charcount»»)
|
VB .NET , C# , Windows PowerShell , F# | vrací -1 |
(position char string)
|
Lisp | vrací NIL |
(char-index char string)
|
ISLISP | vrací nil
|
List.elemIndex char string
|
Haskell (vrací )
Just index |
vrací Nothing
|
String.index string char
|
OCaml | vyvolává Not_found |
position = SCAN (string, set «, back» «, kind») or
|
Fortran | vrací nulu |
string indexOf: char ifAbsent: aBlock
|
Pokec | vyhodnotit, aBlock která je BlockClosure (nebo jakákoli hodnota pro porozumění objektu) vrací 0 vrací true nebofalse
|
index(string, char, startpos )
|
PL/I | vrací 0 (pozice začínají na 1) |
string.index(?char)
|
Rubín | vrací nula |
strpos(string,char,startpos)
|
PHP | vrací false
|
string.indexOf(char«,startpos«, charcount»»)
|
Kobra | vrací -1 |
string⍳char
|
APL | vrací 1 + poslední pozici v řetězci |
string.find(substring)
|
Rez | vrací None
|
// 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 Vzhledem k sadě znaků SCAN vrátí pozici prvního nalezeného znaku, zatímco VERIFY vrátí pozici prvního znaku, který do sady nepatří.
Formát
Definice |
format(formatstring, items) vrací řetězec
|
---|---|
Popis | Vrátí formátovanou řetězcovou reprezentaci jedné nebo více položek. |
Formát | Jazyky | Formát syntaxe řetězce | |
---|---|---|---|
associate(file, string); putf(file, $formatstring$, items)
|
ALGOL 68 | ALGOL | |
Format(item, formatstring)
|
VB |
|
|
sprintf(formatstring, items)
|
Perl , PHP , Raku , Ruby | C | |
item.fmt(formatstring)
|
Raku | C | |
io_lib:format(formatstring, items)
|
Erlang |
|
|
sprintf(outputstring, formatstring, items)
|
C | C | |
std::format(formatstring, items)
|
C ++ ( C ++ 20 ) | Krajta | |
std.string.format(formatstring, items)
|
D | C | |
Format(formatstring, items)
|
Object Pascal ( Delphi ) |
|
|
fmt.Sprintf(formatstring, items)
|
Jít | C | |
printf -v outputstring formatstring items
|
Bash shell | C | |
formatstring % (items)
|
Python , Ruby | C | |
formatstring.format(items)
|
Krajta | .SÍŤ | |
fformatstring
|
Python 3 | ||
Printf.sprintf formatstring items
|
OCaml , F# | C | |
Text.Printf.printf formatstring items
|
Haskell (GHC) | C | |
formatstring printf: items
|
Pokec | C | |
String.format(formatstring, items)
|
Jáva | C | |
String.Format(formatstring, items)
|
VB .NET , C# , F# | .SÍŤ | |
(format formatstring items)
|
Schéma (SRFI 28) | Lisp | |
(format nil formatstring items)
|
Lisp | Lisp | |
(format formatstring items)
|
Clojure | Lisp | |
formatstring -f items
|
Windows PowerShell | .SÍŤ | |
[NSString stringWithFormat:formatstring, items]
|
Cíl-C ( NSString * pouze)
|
C | |
String(format:formatstring, items)
|
Swift (nadace) | C | |
string.format(formatstring, items)
|
Lua | C | |
WRITE (outputstring, formatstring) items
|
Fortran | Fortran | |
put string(string) edit(items)(format)
|
PL/I | PL/I (podobně jako Fortran) | |
String.format(formatstring, items)
|
Kobra | .SÍŤ | |
format formatstring items
|
Tcl | C | |
formatnumbers ⍕ items nebo formatstring ⎕FMT items
|
APL | APL | |
format!(formatstring, items)
|
Rez | Krajta |
// 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" */
Nerovnost
Testuje, zda dva řetězce nejsou stejné. Viz také #Equality .
Formát | Jazyky |
---|---|
string1 ne string2, or string1 NE string2
|
ALGOL 68 -poznámka: operátor „ ne “ je doslova tučným písmem. |
string1 /= string2
|
ALGOL 68 , Ada , Erlang , Fortran , Haskell |
string1 <> string2
|
BASIC , VB , VB .NET , Pascal , Object Pascal ( Delphi ), OCaml , PHP , Seed7 , Standard ML , F# , COBOL , Cobra , Python 2 (zastaralé) |
string1 # string2
|
ZÁKLADNÍ (některé implementace) |
string1 ne string2
|
Perl , Raku |
(string<> string1 string2)
|
Schéma (SRFI 13) |
(string/= string1 string2)
|
Lisp |
(string/= string1 string2)
|
ISLISP |
(not= string1 string2)
|
Clojure |
string1 != string2
|
C ++ (STL), C# , Go , JavaScript (není podobné), PHP (není podobné), Python , Ruby , Rust , Swift , D , Mathematica |
string1 !== string2
|
JavaScript , PHP |
string1 \= string2
|
Rexx |
string1 ¬= string2
|
PL/I |
test string1 != string2, or
|
Bourne Shell |
string1 -ne string2, or
|
Windows PowerShell |
string1 ~= string2
|
Lua , Smalltalk |
string1 ≢ string2
|
APL |
string1.ne(string2)
|
Rez |
// 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
index
viz #Najít
indexof
viz #Najít
instr
viz #Najít
instrrev
viz #rfind
připojit
Definice |
join(separator, list_of_strings) vrátí seznam řetězců spojených s oddělovačem
|
---|---|
Popis | Spojí seznam řetězců do nového řetězce s oddělovacím řetězcem mezi každým z podřetězců. Naproti rozdělení . |
Příbuzný | sprintf |
Formát | Jazyky |
---|---|
std.string.join(array_of_strings, separator)
|
D |
string:join(list_of_strings, separator)
|
Erlang |
join(separator, list_of_strings)
|
Perl , PHP , Raku |
implode(separator, array_of_strings)
|
PHP |
separator.join(sequence_of_strings)
|
Python , Swift 1.x |
array_of_strings.join(separator)
|
Ruby , JavaScript , Raku , Rust |
(string-join array_of_strings separator)
|
Schéma (SRFI 13) |
(format nil "~{~a~^separator~}" array_of_strings)
|
Lisp |
(clojure.string/join separator list_of_strings)
|
Clojure |
strings.Join(array_of_strings, separator)
|
Jít |
join(array_of_strings, separator)
|
Semeno 7 |
String.concat separator list_of_strings
|
OCaml |
String.concatWith separator list_of_strings
|
Standardní ML |
Data.List.intercalate separator list_of_strings
|
Haskell (GHC 6.8+) |
Join(array_of_strings, separator)
|
VB |
String.Join(separator, array_of_strings)
|
VB .NET , C# , F# |
String.join(separator, array_of_strings)
|
Java 8+ |
&{$OFS=$separator; "$array_of_strings"}, or
|
Windows PowerShell |
[array_of_strings componentsJoinedByString:separator]
|
Cíl-C ( NSString * pouze)
|
table.concat(table_of_strings, separator)
|
Lua |
{|String streamContents: [ :stream | collectionOfAnything asStringOn: stream delimiter: separator ]
|
Smalltalk ( Squeak , Pharo ) |
array_of_strings.join(separator«, final_separator»)
|
Kobra |
sequence_of_strings.joinWithSeparator(separator)
|
Swift 2.x |
1↓∊separator,¨list_of_strings
|
APL |
// 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"
poslední index
viz #rfind
vlevo, odjet
Definice |
left(string,n) vrací řetězec
|
---|---|
Popis | Vrátí levou n část řetězce. Pokud je n větší než délka řetězce, pak většina implementací vrací celý řetězec (existují výjimky - viz příklady kódu). U kódování s proměnnou délkou, jako je UTF-8 , UTF-16 nebo Shift-JIS , může být nutné odstranit pozice řetězců na konci, aby se zabránilo neplatným řetězcům. |
Formát | Jazyky |
---|---|
string (string'First .. string'First + n - 1)
|
Ada |
substr(string, 0, n)
|
AWK (mění řetězec), Perl , PHP , Raku |
LEFT$(string,n)
|
ZÁKLADNÍ , VB |
left(string,n)
|
VB , FreeBASIC , Ingres , Pick Basic |
strncpy(string2, string, n)
|
Standardní knihovna C. |
string.substr(0,n)
|
C ++ (STL), Raku |
[string substringToIndex:n]
|
Cíl-C ( NSString * pouze)
|
(apply str (take n string))
|
Clojure |
string[0 .. n]
|
D |
string:substr(string, start, length)
|
Erlang |
(subseq string 0 n)
|
Lisp |
string[:n]
|
Cobro , Go , Python |
left(string,n «,padchar»)
|
Rexx , Erlang |
string[0, n]
|
Rubín |
string[1, n]
|
Vyberte základní |
string[ .. n]
|
Semeno 7 |
string.Substring(0,n)
|
VB .NET , C# , Windows PowerShell , F# |
leftstr(string, n)
|
Pascal , Object Pascal ( Delphi ) |
copy (string,1,n)
|
Turbo Pascal |
string.substring(0,n)
|
Java , JavaScript |
(string-take string n)
|
Schéma (SRFI 13) |
take n string
|
Haskell |
String.extract (string, n, NONE)
|
Standardní ML |
String.sub string 0 n
|
OCaml |
string.[..n]
|
F# |
string.sub(string, 1, n)
|
Lua |
string first: n
|
Smalltalk ( Squeak , Pharo ) |
string(:n)
|
Fortran |
StringTake[string, n]
|
Mathematica |
string («FUNCTION» LENGTH(string) - n:n)
|
COBOL |
string.substring(0, n)
|
Kobra |
n↑string.
|
APL |
string[0..n] string[..n] string.get(0..n) string.get(..n)
|
Rez |
# 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"
len
viz #délka
délka
Definice |
length(string) vrací celočíselné číslo
|
---|---|
Popis | Vrátí délku řetězce (nepočítaje nulový terminátor ani žádné jiné vnitřní strukturní informace řetězce). Prázdný řetězec vrací délku 0. |
Formát | Vrací | Jazyky |
---|---|---|
string'Length
|
|
Ada |
UPB string
|
|
ALGOL 68 |
length(string)
|
|
Ingres , Perl 5 , Pascal , Object Pascal ( Delphi ), Rexx , Seed7 , SQL , PL/I |
len(string)
|
|
BASIC , FreeBASIC , Python , Go , Pick Basic |
length(string), string:len(string)
|
|
Erlang |
Len(string)
|
|
VB , Pick Basic |
string.Length
|
Počet jednotek kódu UTF-16 | VB .NET , C# , Windows PowerShell , F# |
chars(string) string.chars
|
Počet grafémů (NFG) | Raku |
codes(string) string.codes
|
Počet bodů kódu Unicode | Raku |
string.size OR string.length
|
Počet bajtů | Rubín |
strlen(string)
|
Počet bajtů | C , PHP |
string.length()
|
|
C ++ (STL) |
string.length
|
|
Cobra , D , JavaScript |
string.length()
|
Počet jednotek kódu UTF-16 | Jáva |
(string-length string)
|
|
Systém |
(length string)
|
|
Common Lisp , ISLISP |
(count string)
|
|
Clojure |
String.length string
|
|
OCaml |
size string
|
|
Standardní ML |
length string
|
Počet bodů kódu Unicode | Haskell |
string.length
|
Počet jednotek kódu UTF-16 |
Cíl-C ( NSString * pouze)
|
string.characters.count
|
Počet znaků | Swift (2.x) |
count(string)
|
Počet znaků | Swift (1.2) |
countElements(string)
|
Počet znaků | Swift (1,0–1,1) |
string.len(string)
|
|
Lua |
string size
|
|
Pokec |
LEN(string), or LEN_TRIM(string)
|
|
Fortran |
StringLength[string]
|
|
Mathematica |
«FUNCTION» LENGTH(string) nebo
|
počet znaků a počet bajtů | COBOL |
string length string
|
desetinný řetězec udávající počet znaků | Tcl |
≢ string
|
APL | |
string.len()
|
Počet bajtů | Rez |
string.chars().count()
|
Počet bodů kódu Unicode | Rez |
// 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
lokalizovat
viz #Najít
Malá písmena
Definice |
lowercase(string) vrací řetězec
|
---|---|
Popis | Vrátí řetězec malými písmeny. |
Formát | Jazyky |
---|---|
LCase(string)
|
VB |
lcase(string)
|
ZDARMA |
lc(string)
|
Perl , Raku |
string.lc
|
Raku |
tolower(char)
|
C |
std.string.toLower(string)
|
D |
transform(string.begin(), string.end(), result.begin(), ::tolower)
|
C ++ |
lowercase(string)
|
Object Pascal ( Delphi ) |
strtolower(string)
|
PHP |
lower(string)
|
Semeno 7 |
echo "string" | tr 'A-Z' 'a-z'
|
Unix |
string.lower()
|
Krajta |
downcase(string)
|
Vyberte základní |
string.downcase
|
Rubín |
strings.ToLower(string)
|
Jít |
(string-downcase string)
|
Schéma (R6RS), Common Lisp |
(lower-case string)
|
Clojure |
String.lowercase string
|
OCaml |
String.map Char.toLower string
|
Standardní ML |
map Char.toLower string
|
Haskell |
string.toLowerCase()
|
Java , JavaScript |
to_lower(string)
|
Erlang |
string.ToLower()
|
VB .NET , C# , Windows PowerShell , F# |
string.lowercaseString
|
Objective-C ( NSString * pouze), Swift (Foundation)
|
string.lower(string)
|
Lua |
string asLowercase
|
Pokec |
LOWER(string)
|
SQL |
lowercase(string)
|
PL/I |
ToLowerCase[string]
|
Mathematica |
«FUNCTION» LOWER-CASE(string)
|
COBOL |
string.toLower
|
Kobra |
string tolower string
|
Tcl |
string.to_lowercase()
|
Rez |
// 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?"
střední
viz #substring
rozdělit
Definice | <string> .partition ( separator ) vrací podřetězec před oddělovač; oddělovač; potom dílčí řetězec za oddělovačem. |
---|---|
Popis | Rozdělí daný řetězec oddělovačem a vrátí tři podřetězce, které dohromady tvoří originál. |
Formát | Jazyky | Komentáře |
---|---|---|
string.partition(separator)
|
Python , Ruby (1,9+) | |
lists:partition(pred, string)
|
Erlang | |
split /(separator)/, string, 2
|
Perl 5 | |
split separator, string, 2 string.split( separator, 2 )
|
Raku | Oddělovač nemusí být regulární výraz |
# 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');
nahradit
Definice |
replace(string, find, replace) vrací řetězec
|
---|---|
Popis | Vrací řetězec se nálezových událostí změnily nahradit . |
Formát | Jazyky |
---|---|
changestr(find, string, replace)
|
Rexx |
std.string.replace(string, find, replace)
|
D |
Replace(string, find, replace)
|
VB |
replace(string, find, replace)
|
Semeno 7 |
change(string, find, replace)
|
Vyberte základní |
string.Replace(find, replace)
|
C# , F# , VB .NET |
str_replace(find, replace, string)
|
PHP |
re:replace(string, find, replace, «{return, list}»)
|
Erlang |
string.replace(find, replace)
|
Cobra , Java (1,5+), Python , Rust |
string.replaceAll(find_regex, replace)
|
Jáva |
string.gsub(find, replace)
|
Rubín |
string =~ s/find_regex/replace/g
|
Perl 5 |
string.subst(find, replace, :g)
|
Raku |
string.replace(find, replace, "g") or
|
JavaScript |
echo "string" | sed 's/find_regex/replace/g'
|
Unix |
string.replace(find, replace), or
|
Windows PowerShell |
Str.global_replace (Str.regexp_string find) replace string
|
OCaml |
[string stringByReplacingOccurrencesOfString:find withString:replace]
|
Cíl-C ( NSString * pouze)
|
string.stringByReplacingOccurrencesOfString(find, withString:replace)
|
Swift (nadace) |
string.gsub(string, find, replace)
|
Lua |
string copyReplaceAll: find with: replace
|
Smalltalk ( Squeak , Pharo ) |
string map {find replace} string
|
Tcl |
StringReplace[string, find -> replace]
|
Mathematica |
strings.Replace(string, find, replace, -1)
|
Jít |
INSPECT string REPLACING ALL/LEADING/FIRST find BY replace
|
COBOL |
find_regex ⎕R replace_regex ⊢ string
|
APL |
// 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"
zvrátit
Definice |
reverse(string)
|
---|---|
Popis | Obrátí pořadí znaků v řetězci. |
Formát | Jazyky |
---|---|
reverse string
|
Perl 5 , Haskell |
flip string string.flip
|
Raku |
lists:reverse(string)
|
Erlang |
strrev(string)
|
PHP |
string[::-1]
|
Krajta |
(string-reverse string)
|
Schéma (SRFI 13) |
(reverse string)
|
Lisp |
string.reverse
|
Ruby , D (upravuje řetězec) |
new StringBuilder(string).reverse().toString()
|
Jáva |
std::reverse(string.begin(), string.end());
|
C ++ ( std::string pouze, upravuje řetězec)
|
StrReverse(string)
|
VB |
string.Reverse().ToString()
|
VB .NET , C# |
implode (rev (explode string))
|
Standardní ML |
string.split("").reverse().join("")
|
JavaScript |
string.reverse(string)
|
Lua |
string reverse
|
Pokec |
StringReverse[string]
|
Mathematica |
reverse(string)
|
PL/I |
«FUNCTION» REVERSE(string)
|
COBOL |
string.toCharArray.toList.reversed.join()
|
Kobra |
String(string.characters.reverse())
|
Swift (2.x) |
String(reverse(string))
|
Swift (1.2) |
string reverse string
|
Tcl |
⌽string
|
APL |
string.chars().rev().collect::<String>()
|
Rez |
" 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
Definice |
rfind(string,substring) vrací celé číslo
|
---|---|
Popis | Vrátí pozici začátku posledního výskytu podřetězce v řetězci . Pokud podřetězec není nalezen, většina těchto rutin vrací neplatnou hodnotu indexu--1, kde jsou indexy založené na 0, 0, kde jsou založeny na 1-nebo nějakou hodnotu, která má být interpretována jako logická hodnota FALSE. |
Příbuzný | instr |
Formát | Jazyky | Pokud nebyl nalezen |
---|---|---|
InStrRev(«startpos,» string,substring)
|
VB | vrací 0 |
instrrev(«startpos,» string,substring)
|
ZDARMA | vrací 0 |
rindex(string,substring«,startpos»)
|
Perl 5 | vrací -1 |
rindex(string,substring«,startpos») string.rindex(substring«,startpos»)
|
Raku | vrací Nil |
strrpos(string,substring«,startpos»)
|
PHP | vrátí FALSE |
string.rfind(substring«,startpos»)
|
C ++ (STL) | vrací std :: string :: npos |
std.string.rfind(string, substring)
|
D | vrací -1 |
string.rfind(substring«,startpos«, endpos»»)
|
Krajta | vrací -1 |
string.rindex(substring«,startpos«, endpos»»)
|
zvyšuje hodnotu ValueError | |
rpos(string, substring«,startpos»)
|
Semeno 7 | vrací 0 |
string.rindex(substring«,startpos»)
|
Rubín | vrací nula |
strings.LastIndex(string, substring)
|
Jít | vrací -1 |
string.lastIndexOf(substring«,startpos»)
|
Java , JavaScript | vrací -1 |
string.LastIndexOf(substring«,startpos«, charcount»»)
|
VB .NET , C# , Windows PowerShell , F# | vrací -1 |
(search substring string :from-end t)
|
Lisp | vrací NIL |
[string rangeOfString:substring options:NSBackwardsSearch].location
|
Cíl-C ( NSString * pouze)
|
vrací NSNotFound |
Str.search_backward (Str.regexp_string substring) string (Str.length string - 1)
|
OCaml | vyvolává Not_found |
string.match(string, '.*()'..substring)
|
Lua | vrací nula |
Ada.Strings.Unbounded.Index(Source => string, Pattern => substring,
|
Ada | vrací 0 |
string.lastIndexOf(substring«,startpos«, charcount»»)
|
Kobra | vrací -1 |
string lastIndexOfString:substring
|
Pokec | vrací 0 |
string last substring string startpos
|
Tcl | vrací -1 |
(⌽<\⌽substring⍷'string')⍳1
|
APL | vrací -1 |
string.rfind(substring)
|
Rez | vrací None
|
; 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
že jo
Definice |
right(string,n) vrací řetězec
|
---|---|
Popis | Vrátí pravou n část řetězce. Pokud je n větší než délka řetězce, pak většina implementací vrací celý řetězec (existují výjimky - viz příklady kódu). |
Formát | Jazyky |
---|---|
string (string'Last - n + 1 .. string'Last)
|
Ada |
Right(string,n)
|
VB |
RIGHT$(string,n)
|
ZÁKLADNÍ |
right(string,n)
|
FreeBASIC , Ingres , Pick Basic |
strcpy(string2, string+n) (n nesmí být větší než délka řetězce )
|
C |
string.Substring(string.Length()-n)
|
C# |
string[len(string)-n:]
|
Jít |
string.substring(string.length()-n)
|
Jáva |
string.slice(-n)
|
JavaScript |
right(string,n «,padchar»)
|
Rexx , Erlang |
substr(string,-n)
|
Perl 5 , PHP |
substr(string,*-n) string.substr(*-n)
|
Raku |
string[-n:]
|
Cobra , Python |
string[n]
|
Vyberte základní |
(string-take-right string n)
|
Schéma (SRFI 13) |
string[-n..-1]
|
Rubín |
string[$-n .. $]
|
D |
String.sub string (String.length string - n) n
|
OCaml |
string.sub(string, -n)
|
Lua |
string last: n
|
Smalltalk ( Squeak , Pharo ) |
StringTake[string, -n]
|
Mathematica |
string (1:n)
|
COBOL |
¯n↑string.
|
APL |
string[n..] string.get(n..)
|
Rez |
// 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"
rozdělení
Definice | <string> .rpartition ( separator ) Vyhledá v řetězci oddělovač zprava doleva a poté vrátí podřetězec před oddělovač; oddělovač; potom dílčí řetězec za oddělovačem. |
---|---|
Popis | Rozdělí daný řetězec oddělovačem nejvíce vpravo a vrátí tři podřetězce, které společně vytvoří originál. |
Formát | Jazyky |
---|---|
string.rpartition(separator)
|
Python , Ruby |
# 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')
plátek
viz #substring
rozdělit
Definice | <string> .split ( separator [, limit ]) rozdělí řetězec na separátoru, volitelně pouze do omezeného počtu podřetězců |
---|---|
Popis | Rozdělí daný řetězec podle výskytů oddělovače (samotný řetězec) a vrátí seznam (nebo pole) podřetězců. Pokud je zadán limit , po přečtení limitu - 1 oddělovačů je zbytek řetězce vytvořen do posledního podřetězce, bez ohledu na to, zda v něm jsou nějaké oddělovače. Implementace Scheme a Erlang jsou podobné, ale liší se v několika ohledech. JavaScript se liší také tím, že stříhá, nevkládá zbytek řetězce do posledního prvku. Podívejte se na příklad zde . Implementace Cobra bude ve výchozím nastavení prázdná. Opak spojení . |
Formát | Jazyky |
---|---|
split(/separator/, string«, limit»)
|
Perl 5 |
split(separator, string«, limit») string.split(separator, «limit»)
|
Raku |
explode(separator, string«, limit»)
|
PHP |
string.split(separator«, limit-1»)
|
Krajta |
string.split(separator«, limit»)
|
JavaScript , Java , Ruby |
string:tokens(string, sepchars)
|
Erlang |
strings.Split(string, separator)
|
Jít |
(string-tokenize string« charset« start« end»»»)
|
Schéma (SRFI 13) |
Split(string, sepchars«, limit»)
|
VB |
string.Split(sepchars«, limit«, options»»)
|
VB .NET , C# , F# |
string -split separator«, limit«, options»»
|
Windows PowerShell |
Str.split (Str.regexp_string separator) string
|
OCaml |
std.string.split(string, separator)
|
D |
[string componentsSeparatedByString:separator]
|
Cíl-C ( NSString * pouze)
|
string.componentsSeparatedByString(separator)
|
Swift (nadace) |
TStringList.Delimiter, TStringList.DelimitedText
|
Objekt Pascal |
StringSplit[string, separator«, limit»]
|
Mathematica |
string.split«(sepchars«, limit«, options»»)»
|
Kobra |
split string separator
|
Tcl |
(separator≠string)⊂string nebo v APL2 respektive Dyalog APL 16.0
separator(≠⊆⊢)string |
APL |
string.split(separator)
|
Rez |
// 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)
sprintf
viz #Format
pás
viz #trim
strcmp
viz #Compare (celočíselný výsledek)
podřetězec
Definice |
substring(string, startpos, endpos) vrací řetězec vrací řetězec
substr(string, startpos, numChars) |
---|---|
Popis | Vrátí podřetězec řetězce mezi počínaje na startpos a endpos , nebo počínaje na startpos délky numChars . Výsledný řetězec se zkrátí, pokud je za počátečním bodem méně než numChars znaků. endpos představuje index za posledním znakem v podřetězci. U kódování s proměnnou délkou, jako je UTF-8 , UTF-16 nebo Shift-JIS , může být nutné odstranit pozice řetězců na konci, aby se zabránilo neplatným řetězcům. |
Formát | Jazyky |
---|---|
string[startpos:endpos]
|
ALGOL 68 (mění základní index) |
string (startpos .. endpos)
|
Ada (mění základní index) |
Mid(string, startpos, numChars)
|
VB |
mid(string, startpos, numChars)
|
ZDARMA |
string[startpos+(⍳numChars)-~⎕IO]
|
APL |
MID$(string, startpos, numChars)
|
ZÁKLADNÍ |
substr(string, startpos, numChars)
|
AWK (mění řetězec), Perl 5 , PHP |
substr(string, startpos, numChars) string.substr(startpos, numChars)
|
Raku |
substr(string, startpos «,numChars, padChar»)
|
Rexx |
string[startpos:endpos]
|
Cobra , Python , Go |
string[startpos, numChars]
|
Vyberte základní |
string[startpos, numChars]
|
Rubín |
string[startpos .. endpos]
|
Semeno 7 |
string.slice(startpos«, endpos»)
|
JavaScript |
string.substr(startpos«, numChars»)
|
C ++ (STL), JavaScript |
string.Substring(startpos, numChars)
|
VB .NET , C# , Windows PowerShell , F# |
string.substring(startpos«, endpos»)
|
Java , JavaScript |
copy(string, startpos, numChars)
|
Object Pascal ( Delphi ) |
(substring string startpos endpos)
|
Systém |
(subseq string startpos endpos)
|
Lisp |
(subseq string startpos endpos)
|
ISLISP |
String.sub string startpos numChars
|
OCaml |
substring (string, startpos, numChars)
|
Standardní ML |
string:sub_string(string, startpos, endpos)
|
Erlang |
strncpy(result, string + startpos, numChars);
|
C |
string[startpos .. endpos+1]
|
D |
take numChars $ drop startpos string
|
Haskell |
[string substringWithRange:NSMakeRange(startpos, numChars)]
|
Cíl-C ( NSString * pouze)
|
string.[startpos..endpos]
|
F# |
string.sub(string, startpos, endpos)
|
Lua |
string copyFrom: startpos to: endpos
|
Pokec |
string(startpos:endpos)
|
Fortran |
SUBSTRING(string FROM startpos «FOR numChars»)
|
SQL |
StringTake[string, {startpos, endpos}]
|
Mathematica |
string (startpos:numChars)
|
COBOL |
rozsah řetězců string startpos endpos | Tcl |
string[startpos..endpos] string.get(startpos..endpos)
|
Rez |
// 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****" */
Velkými písmeny
Definice |
uppercase(string) vrací řetězec
|
---|---|
Popis | Vrátí řetězec velkými písmeny. |
Formát | Jazyky |
---|---|
UCase(string)
|
VB |
ucase(string)
|
ZDARMA |
toupper(string)
|
AWK (změní řetězec) |
uc(string)
|
Perl , Raku |
string.uc
|
Raku |
toupper(char)
|
C (funguje na jednom znaku) |
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 (pole řetězec / znak) |
std.string.toUpper(string)
|
D |
transform(string.begin(), string.end(), result.begin(), toupper)
|
C ++ |
uppercase(string)
|
Object Pascal ( Delphi ) |
upcase(char)
|
Object Pascal ( Delphi ) (funguje na jednom znaku) |
strtoupper(string)
|
PHP |
upper(string)
|
Semeno 7 |
echo "string" | tr 'a-z' 'A-Z'
|
Unix |
translate(string) , nebo
|
Rexx |
string.upper()
|
Krajta |
upcase(string)
|
Vyberte základní |
string.upcase
|
Rubín |
strings.ToUpper(string)
|
Jít |
(string-upcase string)
|
Schéma , Common Lisp |
String.uppercase string
|
OCaml |
String.map Char.toUpper string
|
Standardní ML |
map Char.toUpper string
|
Haskell |
string.toUpperCase()
|
Java , JavaScript |
to_upper(string)
|
Erlang |
string.ToUpper()
|
VB .NET , C# , Windows PowerShell , F# |
string.uppercaseString
|
Objective-C ( NSString * pouze), Swift (Foundation)
|
string.upper(string)
|
Lua |
string asUppercase
|
Pokec |
UPPER(string)
|
SQL |
ToUpperCase[string]
|
Mathematica |
«FUNCTION» UPPER-CASE(string)
|
COBOL |
string.toUpper
|
Kobra |
string toupper string
|
Tcl |
string.to_uppercase()
|
Rez |
// 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?"
oříznout
trim
nebo strip
se používá k odstranění mezer od začátku, konce nebo začátku a konce řetězce.
Příklad použití | Jazyky |
---|---|
String.Trim([chars])
|
C# , VB.NET , Windows PowerShell |
string.strip();
|
D |
(.trim string)
|
Clojure |
sequence [ predicate? ] trim
|
Faktor |
(string-trim '(#\Space #\Tab #\Newline) string)
|
Lisp |
(string-trim string)
|
Systém |
string.trim()
|
Java , JavaScript (1.8.1+, Firefox 3.5+), Rust |
Trim(String)
|
Pascal , QBasic , Visual Basic , Delphi |
string.strip()
|
Krajta |
strings.Trim(string, chars)
|
Jít |
LTRIM(RTRIM(String))
|
Oracle SQL , T-SQL |
strip(string [,option, char])
|
REXX |
string:strip(string [,option, char])
|
Erlang |
string.strip or string.lstrip or string.rstrip
|
Rubín |
string.trim
|
Raku |
trim(string)
|
PHP , Raku |
[string stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]
|
Objective-C s použitím kakaa |
string withBlanksTrimmed
|
Smalltalk (Squeak, Pharo) Smalltalk |
strip(string)
|
SAS |
string trim $string
|
Tcl |
TRIM(string) or TRIM(ADJUSTL(string))
|
Fortran |
TRIM(string)
|
SQL |
TRIM(string) or LTrim(string) or RTrim(String)
|
Studená fúze |
String.trim string
|
OCaml 4+ |
Jiné jazyky
V jazycích bez integrované funkce trim je obvykle snadné vytvořit vlastní funkci, která splňuje stejný úkol.
APL
APL může používat regulární výrazy přímo:
Trim←'^ +| +$'⎕R''
Alternativně funkční přístup kombinující booleovské masky, které filtrují přední a koncové mezery:
Trim←{⍵/⍨(∨\∧∘⌽∨\∘⌽)' '≠⍵}
Nebo dvakrát otočte a odstraňte úvodní mezery:
Trim←{(∨\' '≠⍵)/⍵}∘⌽⍣2
AWK
V AWK lze k oříznutí použít regulární výrazy:
ltrim(v) = gsub(/^[ \t]+/, "", v)
rtrim(v) = gsub(/[ \t]+$/, "", v)
trim(v) = ltrim(v); rtrim(v)
nebo:
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 ++
V C nebo C ++ neexistuje žádná standardní funkce oříznutí. Většina dostupných knihoven řetězců pro C obsahuje kód, který implementuje ořezávání, nebo funkce, které výrazně usnadňují efektivní implementaci. V některých nestandardních knihovnách C byla tato funkce také často nazývána EatWhitespace .
V jazyce C programátoři často kombinují ltrim a rtrim, aby implementovali trim:
#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);
}
Open source knihovna C ++ Zvýšení má několik obložení variant, včetně standardní:
#include <boost/algorithm/string/trim.hpp>
trimmed = boost::algorithm::trim_copy("string");
Všimněte si, že s funkcí boost jednoduše pojmenovanou trim
vstupní sekvence je upravena na místě a nevrací výsledek.
Další open source C ++ knihovna Qt má několik variant výbavy, včetně standardní:
#include <QString>
trimmed = s.trimmed();
Linuxové jádro obsahuje také funkci pásu, strstrip()
protože 2.6.18-rc1, který ořízne řetězec „na místě“. Od 2.6.33-rc1 jádro používá strim()
místo toho, strstrip()
aby se vyhnul falešným varováním.
Haskell
Algoritmus úpravy v Haskellu :
import Data.Char (isSpace)
trim :: String -> String
trim = f . f
where f = reverse . dropWhile isSpace
lze interpretovat následovně: f zruší předchozí mezeru a obrátí řetězec. f se pak znovu použije na vlastní výstup. Všimněte si, že podpis typu (druhý řádek) je volitelný.
J.
Algoritmus trimování v J je funkční popis:
trim =. #~ [: (+./\ *. +./\.) ' '&~:
To znamená: filtr ( #~
) pro znaky bez mezer ( ' '&~:
) mezi úvodními ( +./\
) a ( *.
) koncovými ( +./\.
) mezerami.
JavaScript
V JavaScriptu 1.8.1 (Firefox 3.5 a novější) a standardu ECMAScript 5 je vestavěná funkce trimu. V dřívějších verzích jej lze přidat do prototypu objektu String následujícím způsobem:
String.prototype.trim = function() {
return this.replace(/^\s+/g, "").replace(/\s+$/g, "");
};
Perl
Perl 5 nemá vestavěnou funkci trimu. Funkčnosti je však běžně dosahováno pomocí regulárních výrazů .
Příklad:
$string =~ s/^\s+//; # remove leading whitespace
$string =~ s/\s+$//; # remove trailing whitespace
nebo:
$string =~ s/^\s+|\s+$//g ; # remove both leading and trailing whitespace
Tyto příklady upravují hodnotu původní proměnné $string
.
K dispozici také pro Perl je StripLTSpace v String::Strip
z CPAN .
Existují však dvě funkce, které se běžně používají k odstranění mezer z konce řetězců, chomp
a chop
:
-
chop
odebere poslední znak z řetězce a vrátí jej. -
chomp
odstraní koncové znaky nového řádku z řetězce, pokud jsou k dispozici. (Co tvoří nový řádek, závisí na $ INPUT_RECORD_SEPARATOR ).
V Raku , nadcházejícím sesterském jazyce Perlu, mají řetězce trim
metodu.
Příklad:
$string = $string.trim; # remove leading and trailing whitespace
$string .= trim; # same thing
Tcl
Tcl string
Příkaz má tři relevantní dílčí: trim
, trimright
a trimleft
. Pro každý z těchto příkazů lze zadat další argument: řetězec, který představuje sadu znaků, které je třeba odebrat - výchozí je mezera (mezera, tabulátor, nový řádek, návrat na začátek řádku).
Příklad ořezávání samohlásek:
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 obsahuje funkci, která odstraňuje úvodní a koncové mezery a navíc nahrazuje libovolnou mezeru (včetně zalomení řádků) jediným mezerou.
normalize-space(string)
Příklad:
<xsl:variable name='trimmed'>
<xsl:value-of select='normalize-space(string)'/>
</xsl:variable>
XSLT 2.0 obsahuje regulární výrazy, které poskytují další mechanismus pro provádění ořezávání řetězců.
Další technikou XSLT pro ořezávání je využití funkce XPath 2.0 substring()
.