Comparaison des langages de programmation (fonctions de chaînes de caractères)

Les fonctions de chaînes de caractères sont utilisées dans les langages de programmation informatique pour manipuler une chaîne de caractères ou interroger des informations sur une chaîne de caractères (certaines font les deux).

La plupart des langages de programmation disposant d'un type de données chaîne de caractères possèdent des fonctions de manipulation de chaînes, bien qu'il existe d'autres méthodes de bas niveau, propres à chaque langage, pour manipuler directement les chaînes. Dans les langages orientés objet, ces fonctions sont souvent implémentées comme des propriétés et des méthodes d'objets chaînes. Dans les langages fonctionnels et les langages basés sur les listes, une chaîne est représentée par une liste (de codes de caractères) ; par conséquent, toutes les procédures de manipulation de listes peuvent être considérées comme des fonctions de chaînes. Cependant, ces langages peuvent également implémenter un sous-ensemble de fonctions spécifiques aux chaînes.

Pour les fonctions manipulant des chaînes de caractères, les langages orientés objet modernes, comme C# et Java, utilisent des chaînes immuables et renvoient une copie (dans une nouvelle zone mémoire dynamique allouée), tandis que d'autres, comme C, modifient la chaîne originale à moins que le programmeur ne copie les données dans une nouvelle chaîne. Voir par exemple la concaténation ci-dessous.

L'exemple le plus simple de fonction de chaîne de caractères est la length(string)fonction `length`. Cette fonction renvoie la longueur d'une chaîne littérale .

par exemple, length("hello world")renverrait 11.

D'autres langages peuvent posséder des fonctions de manipulation de chaînes de caractères présentant une syntaxe, des paramètres ou des résultats similaires, voire identiques. Par exemple, dans de nombreux langages, la fonction longueur est généralement représentée par `len(chaîne)` . La liste ci-dessous des fonctions courantes vise à limiter cette confusion.

La concaténation de chaînes et les expressions régulières sont traitées sur des pages séparées. Les guillemets (« … ») sont facultatifs.

CharAt

Définition	`charAt(string,integer)`renvoie un caractère.
Description	Renvoie le caractère à l'index spécifié dans la chaîne.
Équivalent	Voir la sous-chaîne de longueur 1 caractère.

FormatLanguesIndice de basestring[i]ALGOL 68 , APL , Julia , Pascal , Object Pascal ( Delphi ), Seed71string[i]C , ++ , C , Cobra , D , FreeBASIC , Go , Python , PHP , Ruby Windows JavaScript , 0string{i}PHP (obsolète dans la version 5.3)0string(i)Ada≥1Mid(string,i,1)VB1MID$(string,i,1)BASIQUE1string.Chars(i)VB.NET0string(i:i)Fortran1string.charAt(i)Java , JavaScript0string.[i]OCaml , F#0string.chars().nth(i)Rouille 0string[i,1]Choisissez Basique1String.sub (string, i)ML standard0string!! iHaskell0(string-ref stringi)Schème0(char stringi)Common Lisp0(elt stringi)ISLISP0(get stringi)Clojure0substr(string, i, 1)Perl 5 0substr(string, i, 1)string.substr(i, 1)Raku 0substr(string, i, 1)PL/I1substr(string, i, 1)REXX1string.at(i)C++ (STL) (avec vérification des limites)0lists:nth(i, string)Erlang1[string characterAtIndex:i]Objectif-C ( NSString *uniquement)0string.sub(string, i, i)(string):sub(i, i)Lua 1string at: iSmalltalk (avec vérification des limites)1string index string iTcl0StringTake[string, {i}]Mathematica , langage Wolfram 1string@iEiffel1string (i:1)COBOL1${string_param:i:1}Frapper0i⌷stringAPL0 ou 1

; printf ( "%c" , * ( myStr1 + 1 )); // 'e' printf ( "%c" , * ( myStr1 + 7 )); // 'W' printf ( "%c" , myStr1 [ 11 ]); // 'd' printf ( "%s" , myStr1 ); // 'Hello, World' printf ( "%s" , "Hello(2), World(2)" ); // 'Hello(2), World(2)'

; string myStr2 = "Hello(2), World(2)" ; std :: println ( "Hello(3), World(3)" ); // 'Hello(3 ) , World(3)' std :: println ( " {}" , myStr2 [ 6 ]); // '2' std :: println ( "{}" , myStr1.substr ( 5 , 3 )); // '(1)'

[ 2 ]; // 'l'

, 1 , 1 ); # 'e'

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

.substr ( 1 , 1 ); # 'e '

, 2 , 1 )

. Chars ( 2 ) ' "l"c

'Hello, World' à : 2 . "$e"

.chars ( ). nth ( 2 ); // Some('l')

Comparer (résultat entier)

Définitioncompare(string₁,string₂)renvoie un entier.DescriptionCompare deux chaînes de caractères. Si elles sont équivalentes, la fonction renvoie zéro. Sinon, la plupart de ces routines renvoient un résultat positif ou négatif selon que la chaîne ₁ est respectivement supérieure ou inférieure lexicographiquement à la chaîne _2. Font exception les routines Scheme et Rexx, qui renvoient l'indice de la première différence, et les routines Smalltalk, qui renvoient un code de comparaison indiquant le mode de tri du récepteur par rapport à la chaîne passée en paramètre.

Format	Langues
`IF string₁<string₂ THEN -1 ELSE ABS (string₁>string₂) FI`	ALGOL 68
`cmp(string₁, string₂)`	Python 2
`(string₁ > string₂) - (string₁ < string₂)`	Python
`strcmp(string₁, string₂)`	C , PHP
`std.string.cmp(string₁, string₂)`	D
`StrComp(string₁, string₂)`	VB , Object Pascal ( Delphi )
`string₁ cmp string₂`	Perl , Raku
`string₁ compare: string₂`	Conversation informelle ( Squeak , Pharo )
`string₁ <=> string₂`	Ruby , C++ (STL, C++20 )
`string₁.compare(string₂)`	C++ (STL), Swift (Foundation)
`compare(string₁, string₂)`	Rexx , Seed7
`compare(string₁, string₂, pad)`	Rexx
`CompareStr(string₁, string₂)`	Pascal , Objet Pascal ( Delphi )
`string₁.compareTo(string₂)`	Cobra , Java
`string₁.CompareTo(string₂)`	VB .NET , C# , F#
`(compare string₁string₂)`	Clojure
`(string= string₁string₂)`	Common Lisp
`(string-compare string₁string₂p<p=p>)`	Schéma (SRFI 13)
`(string= string₁string₂)`	ISLISP
`compare string₁string₂`	OCaml
`String.compare (string₁, string₂)`	ML standard
`compare string₁string₂`	Haskell
`[string]::Compare(string₁, string₂)`	Windows PowerShell
`[string₁ compare:string₂]`	Objectif-C ( `NSString *`uniquement)
`LLT(string₁,string₂)LLE(string₁,string₂)LGT(string₁,string₂)LGE(string₁,string₂)`	Fortran
`string₁.localeCompare(string₂)`	JavaScript
`Aller`
`string compare string₁string₂`	Tcl
`compare(string₁,string₂,count)`	PL/I
`string₁.cmp(string₂)`	Rouille

cmp "world" ; # renvoie -1

, "world" ) # renvoie -1

cmp "world" ; # renvoie Moins "world" cmp "hello" ; # renvoie Plus "hello" cmp "hello" ; # renvoie Même

, "world" ) /* renvoie l'indice de la différence : 1 */

"world" values values values )

Comparer (opérateur relationnel, résultat booléen)

Définition	`string₁ OP string₂`OU renvoie une valeur booléenne.`(compare string₁ string₂)`
Description	Compare lexicographiquement deux chaînes de caractères à l'aide d'un opérateur ou d'une fonction relationnelle. Renvoie un résultat booléen.

Format	Langues
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles =, <>, <, >, <= et >=="}},"i":0}}]	Pascal , Object Pascal ( Delphi ), OCaml , Seed7 , Standard ML , BASIC , VB , VB.NET , F#
`string₁ OP string₂`, où `OP`peut prendre n'importe quelle valeur parmi =, /=, ≠, <, >, <=, ≤ et ≥ ; également : EQ, NE, LT, LE, GE et GTALGOL 68
`(stringOP? string₁string₂)`, où `OP`peut être n'importe lequel des opérateurs suivants : =, -ci=, <, -ci<, >, -ci>, <=, -ci<=, >= et -ci>= (les opérateurs commençant par ' ' ne sont pas sensibles à la casse)Schème
`(stringOP string₁string₂)`, où `OP`peut être n'importe lequel des opérateurs suivants : =, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >= et -ci>= (les opérateurs commençant par ' -ci ' ne sont pas sensibles à la casse)Schéma (SRFI 13)
`(stringOP string₁string₂)`, où `OP`peut être n'importe lequel des opérateurs suivants : =, -égal, /=, -différent de, <, -inférieur, >, -supérieur, <=, -inférieur, >= et -inférieur (les opérateurs verbaux ne sont pas sensibles à la casse)Common Lisp
`(stringOP string₁string₂)`, où `OP`peut être n'importe lequel des symboles =, /=, <, >, <= et >=ISLISP
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles =, \=, <, >, <= et >= Rexx
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles suivants : =, ¬=, <, >, <=, >=, ¬< et ¬> PL/I
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles =, /=, <, >, <= et >=Ada
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles ==, /=, <, >, =< et >=Erlang
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles ==, /=, <, >, <= et >=Haskell
`string₁ OP string₂`, où `OP`peut être n'importe lequel des éléments suivants : eq , ne , lt , gt , le et gePerl , Raku
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles ==, !=, <, >, <= et >=C++ (STL), C# , D , Go , JavaScript , Python , PHP , Ruby , Rust , Swift
`string₁ OP string₂`, où `OP`peut être n'importe lequel des opérateurs suivants : -eq, -ceq, -ne, -cne, -lt, -clt, -gt, -cgt, -le, -cle, -ge et -cge (les opérateurs commençant par ' c ' sont sensibles à la casse)Windows PowerShell
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles ==, ~=, <, >, <= et >=Lua
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles =, ~=, <, >, <= et >=Conversation
`string₁ OP string₂`, où `OP`peut être n'importe lequel des symboles ==, /=, <, >, <= et >=; De plus : .EQ., .NE., .LT., .LE., .GT. et .GE.Fortran
`string₁ OP string₂`où `OP`peut être n'importe lequel des symboles =, <>, <, >, <=, >= ainsi que leurs équivalents formulésCOBOL
`string₁ OP string₂`où `OP`peut être n'importe lequel des symboles ==, <>, <, >, <= et >=Cobra
`string₁ OP string₂`Cette syntaxe est disponible, mais elle compare les pointeurs vers les chaînes, et non leur contenu. Utilisez la fonction Compare(entier).	C , Java
`string₁.METHOD(string₂)`où `METHOD`se trouve l'un des éléments suivants `eq`: , `ne`, `gt`, `lt`, `ge`,`le`	Rouille

\"world\". % returns false "

% Exemple en Erlang "hello" > "world" . % renvoie faux

-gt "world" # renvoie faux

\"art\" \"painting\") ; returns nil (string< \"art\" \"painting\") ; returns non nil "

Exemple en Common Lisp : `( string< art" "painting" ) ` renvoie `nil` ; `( string< art" "painting" ) ` renvoie une valeur non nulle

Enchaînement

Définitionconcatenate(string₁,string₂)renvoie une chaîne de caractères.DescriptionConcaténer (joindre) deux chaînes de caractères et renvoyer la chaîne résultante. Dans certains langages, comme le C, les chaînes de caractères sont modifiables ; la seconde chaîne est alors ajoutée à la première et la chaîne ainsi modifiée est renvoyée.

Format	Langues
`string₁adjacent_tostring₂`	Rexx (culant, équivalent à )`string₁\|\|string₂`
`string₁whitespacestring₂`	Rexx (équivalent à )`string₁\|\| ' ' \|\|string₂`
`string₁ & string₂`	Ada , FreeBASIC , Seed7 , BASIC , VB , VB.NET , COBOL (entre littéraux uniquement)
`strcat(string₁, string₂)`	C , C++ ( uniquement) `char*`
`string₁ . string₂`	Perl , PHP
`string₁ + string₂`	ALGOL 68 , C++ (STL), C# , Cobra , FreeBASIC , Go , Pascal , Object Pascal ( Delphi ), Java , JavaScript , Windows PowerShell , Python , Ruby , Rust , F# , Swift , Turing , VB
`string₁ ~ string₂`	D , Raku
`(string-append string₁string₂)`	Schéma , ISLISP
`(concatenate 'string string₁string₂)`	Common Lisp
`(str string₁string₂)`	Clojure
`string₁\|\|string₂`	Rexx , SQL , PL/I
`string₁ // string₂`	Fortran
`string₁ ++ string₂`	Erlang , Haskell
`string₁ ^ string₂`	OCaml , Standard ML , F#
`[string₁ stringByAppendingString:string₂]`	Objectif-C ( `NSString *`uniquement)
`string₁ .. string₂`	Lua
`string₁ , string₂`	Smalltalk , APL
`string₁string₂`	SNOBOL
`string₁string₂`	Frapper
`string₁ <> string₂`	Mathematica
concaténer la chaîne ₁ et la chaîne ₂	Tcl

+ "def" ; // renvoie "abcdef"

~ "def" ; // renvoie "abcdef"

"def " "ghi" ) ; renvoie "abc def ghi"

. "def" ; # renvoie "abcdef" "Perl " . 5 ; # renvoie "Perl 5"

|| "def" /* renvoie "abcdef" */

~ "def" ; # renvoie "abcdef" "Perl " ~ 6 ; # renvoie "Perl 6"

2 /* renvoie "Strike2" */ "Strike" 2 /* renvoie "Strike 2" */

Contient

Définition	`contains(string,substring)`renvoie une valeur booléenne
Description	Indique si la chaîne contient la sous- chaîne recherchée. Cela revient à utiliser la fonction Rechercher et à vérifier qu'elle ne génère pas l'erreur mentionnée dans la troisième colonne de la section Rechercher. Cependant, certains langages proposent une méthode plus simple pour exprimer ce test.
En rapport	Trouver

Format	Langues
`string_in_string(string, loc int, substring)`	ALGOL 68
`ContainsStr(string, substring)`	Objet Pascal ( Delphi )
`strstr(string, substring)!= NULL`	C , C++ ( `char *`uniquement)
`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`	Graine 7
`substring in string`	Cobra , Python (2.3+)
`string.find(string, substring) ~= nil`	Lua
`string.include?(substring)`	Rubis
`Data.List.isInfixOf substringstring`	Haskell ( GHC 6.6+)
`string includesSubstring: substring`	Smalltalk ( Squeak , Pharo , Smalltalk/X )
`String.isSubstring substringstring`	ML standard
`(search substringstring)`	Common Lisp
`ISLISP`
`(substring? substringstring)`	Clojure
`! StringFreeQ[string, substring]`	Mathematica
`index(string, substring, startpos)>0`	Choisissez Basique
`strings.Contains(string, substring)`	Aller
`string.find(substring)!= string::npos`	C++
`[string containsString:substring]`	Objective-C ( `NSString *`uniquement, iOS 8+/OS X 10.10+)
`string.rangeOfString(substring)!= nil`	Swift (Fondation)
`∨/substring⍷string`	APL

¢ Exemple en ALGOL 68 ¢ chaîne dans chaîne("e", loc int , "Salut mon pote"); ¢ renvoie vrai ¢ chaîne dans chaîne("z", loc int , "mot"); ¢ renvoie faux ¢

.Contains ( "e" ); // renvoie vrai " word" .Contains ( "z" ); // renvoie faux

. contains ( 'z' ) # renvoie False "¡Buenos días!" . contains ( 'í' ); # renvoie True

'Hello mate' includesSubstring: 'e' " renvoie vrai " ' word ' includesSubstring: 'z' " renvoie faux "

Égalité

Vérifie si deux chaînes de caractères sont égales. Voir aussi `#Compare` et `#Compare` . Effectuer des tests d'égalité via une comparaison générique avec un résultat entier est non seulement source de confusion pour le programmeur, mais s'avère souvent beaucoup plus coûteux ; c'est particulièrement vrai lors de l'utilisation de chaînes de caractères C.

Format	Langues
`string₁ == string₂`	Python , C++ (STL), C# , Cobra , Go , JavaScript (similitude), PHP (similitude), Ruby , Rust , Erlang , Haskell , Lua , D , Mathematica , Swift
`string₁ === string₂`	JavaScript , PHP
`string₁ == string₂string₁ .EQ. string₂`	Fortran
`strcmp(string₁, string₂) == 0`	C
`(string=? string₁string₂)`	Schème
`(string= string₁string₂)`	Common Lisp , 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₂ ]`	Bourne Shell
`string₁ eq string₂`	Perl , Raku , Tcl
`string₁.equals(string₂)`	Cobra , Java
`string₁.Equals(string₂)`	C#
`string₁ -eq string₂[string]::Equals(string₁, string₂)`	Windows PowerShell
`[string₁ isEqualToString:string₂][string₁ isEqual:string₂]`	Objectif-C ( `NSString *`uniquement)
`string₁ ≡ string₂`	APL
`string₁.eq(string₂)`	Rouille

== "world" // renvoie faux

-eq "world" # renvoie faux

Définitionfind(string,substring)renvoie un entierDescriptionRenvoie la position du début de la première occurrence de la sous-chaîne dans la chaîne . Si la sous-chaîne est introuvable, la plupart de ces routines renvoient une valeur d'index invalide – -1 lorsque les index commencent à 0, 0 lorsqu'ils commencent à 1 – ou une valeur à interpréter comme FAUX (booléen).En rapportinstrrev

Format	Langues	Si introuvable
`string in string(substring, pos, string[startpos:])`	ALGOL 68	renvoie BOOL : TRUE ou FALSE, et la position dans REF INT pos.
`InStr(«startpos,»string,substring)`	VB (les positions commencent à 1)	renvoie 0
`INSTR$(string,substring)`	BASIQUE (les positions commencent à 1)	renvoie 0
`index(string,substring)`	AWK	renvoie 0
`index(string,substring«,startpos»)`	Perl 5	renvoie −1
`index(string,substring«,startpos»)string.index(substring,«,startpos»)`	Raku	renvoie Nul
`instr(«startpos,»string,substring)`	FreeBASIC	renvoie 0
`strpos(string,substring«,startpos»)`	PHP	renvoie FAUX
`locate(string, substring)`	Ingres	renvoie la longueur de la chaîne + 1
`strstr(string, substring)`	C , C++ ( uniquement, renvoie un pointeur vers le premier caractère)`char*`	renvoie NULL
`std.string.indexOf(string, substring)`	D	renvoie −1
`pos(string, substring«, startpos»)`	Graine 7	renvoie 0
`strings.Index(string, substring)`	Aller	renvoie −1
`pos(substring, string)`	Pascal , Objet Pascal ( Delphi )	renvoie 0
`pos(substring, string«,startpos»)`	Rexx	renvoie 0
`string.find(substring«,startpos»)`	C++ (STL)	renvoie std::string::npos
`string.find(substring«,startpos«,endpos»»)`	Python	renvoie −1
`string.index(substring«,startpos«,endpos»»)`	Python	génère une erreur de valeur
`string.index(substring«,startpos»)`	Rubis	renvoie nul
`string.indexOf(substring«,startpos»)`	Java , JavaScript	renvoie −1
`string.IndexOf(substring«,startpos«, charcount»»)`	VB .NET , C# , Windows PowerShell , F#	renvoie −1
`string:str(string, substring)`	Erlang	renvoie 0
`(string-contains stringsubstring)`	Schéma (SRFI 13)	renvoie #f
`(search substringstring)`	Common Lisp	renvoie NIL
`(string-index substringstring)`	ISLISP	retours`nil`
`List.findIndex (List.isPrefixOf substring) (List.tails string)`	Haskell (renvoie uniquement l'index )	ne renvoie rien
`Str.search_forward (Str.regexp_string substring) string 0`	OCaml	Lève une exception Not_found
`Substring.size (#1 (Substring.position substring (Substring.full string)))`	ML standard	renvoie la longueur de la chaîne
`[string rangeOfString:substring].location`	Objectif-C ( `NSString *`uniquement)	Renvoie NSNotFound
`string.find(string, substring)(string):find(substring)`	Lua	renvoie nul
`string indexOfSubCollection: substring startingAt: startpos ifAbsent: aBlockstring findString: substring startingAt: startpos`	Conversation informelle ( Squeak , Pharo )	L'évaluation de aBlock, qui est une fermeture de bloc (ou tout objet comprenant une valeur), renvoie 0.
`startpos = INDEX(string, substring «,back» «, kind»)`	Fortran	Renvoie 0 si la sous-chaîne n'est pas présente dans la chaîne ; renvoie LEN(chaîne)+1 si la sous-chaîne est vide.
`POSITION(substring IN string)`	SQL	renvoie 0 (les positions commencent à 1)
`index(string, substring, startpos )`	PL/I	renvoie 0 (les positions commencent à 1)
`index(string, substring, occurrence )`	Choisissez Basique	Renvoie 0 si la sous-chaîne n'est pas présente dans la chaîne ; (les positions commencent à 1)
`string.indexOf(substring«,startpos«, charcount»»)`	Cobra	renvoie −1
`string first substring string startpos`	Tcl	renvoie −1
`(substring⍷string)⍳1`	APL	renvoie 1 + la dernière position dans la chaîne
`string.find(substring)`	Rouille	retours`None`

Exemples

Common Lisp
"Salut mon pote" ) ; renvoie 1 ( recherche "z" "mot" ) ; renvoie NIL
C#
.IndexOf ( "e" ) ; // renvoie 1 "Hello mate" .IndexOf ( " e" , 4 ); // renvoie 9 "word" .IndexOf ( " z" ); // renvoie -1
Raku
. index ( 'e' ) # renvoie 1 "Bonjour !" . index ( 'z' ) # renvoie Nil
Schème
"e" ) ; renvoie 1 ( string-contains "word" "z" ) ; renvoie #f
Visual Basic
, "e" ) ' renvoie 2 InStr ( 5 , "Hello mate" , "e" ) ' renvoie 10 InStr ( "word" , "z" ) ' renvoie 0
Conversation

Trouver le personnage

Définition	`find_character(string,char)`renvoie un entier
Description	Renvoie la position de la première occurrence du caractère `char` dans la chaîne `string` . Si le caractère est introuvable, la plupart de ces fonctions renvoient un index invalide (-1 pour les index commençant à 0, 0 pour les index commençant à 1) ou une valeur booléenne `FALSE`. Ceci peut être réalisé comme un cas particulier de `#Find` , avec une chaîne d'un seul caractère ; cependant, dans de nombreux langages, il peut être plus simple ou plus efficace de localiser directement un seul caractère. De plus, dans de nombreux langages, les caractères et les chaînes de caractères sont considérés comme des types différents, ce qui rend cette fonction utile.
En rapport	trouver

Format	Langues	Si introuvable
`char in string(char, pos, string[startpos:])`	ALGOL 68	renvoie BOOL : TRUE ou FALSE , et position dans REF INT pos .FreeBASIC	renvoie 0
`strchr(string,char)`	C , C++ ( uniquement, renvoie un pointeur vers un caractère)`char*`	renvoie NULLD	renvoie −1
`string.find(char«,startpos»)`	C++ (STL)	renvoie std::string::nposGraine 7	renvoie 0
`strings.IndexRune(string,char)`	Aller	renvoie −1
`string.indexOf(char«,startpos»)`	Java , JavaScript	renvoie −1
`string.IndexOf(char«,startpos«, charcount»»)`	VB .NET , C# , Windows PowerShell , F#	renvoie −1
`(position charstring)`	Common Lisp	renvoie NILISLISP	renvoie nulHaskell (retourne )`Just index`	ne renvoie rienOCaml	Lève une exception Not_found[a]	Fortran	renvoie zéro
`string indexOf: char ifAbsent: aBlockstring indexOf: charstring includes: char`	Conversation	évaluer `aBlock`qui est un `BlockClosure`(ou tout objet comprenant la valeur) renvoie 0 renvoie `true`ou`false`
`index(string, char, startpos )`	PL/I	renvoie 0 (les positions commencent à 1)
`string.index(?char)`	Rubis	renvoie nulPHP	renvoie fauxCobra	renvoie −1
`string⍳char`	APL	renvoie 1 + la dernière position dans la chaîne
`string.find(substring)`	Rouille	renvoie Aucun .IndexOf ( 'e' ); // renvoie 1 "word" .IndexOf ( ' z' ) // renvoie -1 ) ; renvoie 1 ( position #\z "word" ) ; renvoie NIL ^a Étant donné un ensemble de caractères, SCAN renvoie la position du premier caractère trouvé, tandis que VERIFY renvoie la position du premier caractère qui n'appartient pas à l'ensemble. Format
Définition	`format(formatstring, items)`renvoie une chaîne de caractères
Description	Renvoie la représentation sous forme de chaîne formatée d'un ou plusieurs éléments.

Format	Langues	Syntaxe de la chaîne de formatage
`associate(file, string); 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 )	Python
`std.string.format(formatstring, items)`	D	C
`Format(formatstring, items)`	Objet Pascal ( Delphi )
`fmt.Sprintf(formatstring, items)`	Aller	C
`printfformatstringitems`	Unix	C
`formatstring% (items)`	Python , Ruby	C
`formatstring.format(items)`	Python	.FILET
`fformatstring`	Python 3
`Printf.sprintf formatstringitems`	OCaml , F#	C
`Text.Printf.printf formatstringitems`	Haskell ( GHC )	C
`formatstring printf: items`	Conversation	C
`String.format(formatstring, items)`	Java	C
`String.Format(formatstring, items)`	VB .NET , C# , F#	.FILET
`(format formatstringitems)`	Schéma (SRFI 28)	Zézayer
`(format nil formatstringitems)`	Common Lisp	Zézayer
`(format formatstringitems)`	Clojure	Zézayer
`formatstring -f items`	Windows PowerShell	.FILET
`[NSString stringWithFormat:formatstring, items]`	Objectif-C ( `NSString *`uniquement)	C
`String(format:formatstring, items)`	Swift (Fondation)	C
`string.format(formatstring, items)(formatstring):format(items)`	Lua	C
`WRITE (outputstring, formatstring) items`	Fortran	Fortran
`put string(string) edit(items)(format)`	PL/I	PL/I (similaire à Fortran)
`String.format(formatstring, items)`	Cobra	.FILET
`format formatstring items`	Tcl	C
`formatnumbers ⍕ itemsformatstring ⎕FMT items`	APL	APL
`format!(formatstring, items)`	Rouille	Python

Mon {0} coûte {1:C2}" , "stylo" , 19.99 ); // renvoie "Mon stylo coûte 19,99 $"

, " stylo" , 19.99 ); // renvoie "Mon stylo coûte 19,99 $"

, "stylo", 19.99 ; # renvoie "Mon stylo coûte 19,99 $" 1.fmt ( " % 04d " ) ; # renvoie " 0001 "

%s coûte %.2f $ " % ( "stylo" , 19.99 ); # renvoie "Mon stylo coûte 19,99 $" "Mon {0} coûte {1:.2f} $ " . format ( "stylo" , 19.99 ); # renvoie "Mon stylo coûte 19,99 $"

f "Mon { pen } coûte { 19.99 } " #renvoie "Mon stylo coûte 19.99"

"stylo" 19,99 ) ; renvoie "Mon stylo coûte 19,99 $"

Inégalité

Vérifie si deux chaînes de caractères sont différentes. Voir aussi #Égalité .

Format	Langues
`string₁nestring₂string₁ NE string₂`	ALGOL 68 – L’opérateur « ne » apparaît en caractères gras .
`string₁ /= string₂`	ALGOL 68 , Ada , Erlang , Fortran , Haskell
`string₁ <> string₂`	BASIC , VB , VB.NET , Pascal , Object Pascal ( Delphi ), OCaml , PHP , Seed7 , Standard ML , F# , COBOL , Cobra , Python 2 (obsolète)
`string₁ # string₂`	BASIC (certaines implémentations)
`string₁ ne string₂`	Perl , Raku
`(string<> string₁string₂)`	Schéma (SRFI 13)
`(string/= string₁string₂)`	Common Lisp
`(string/= string₁string₂)`	ISLISP
`(not= string₁string₂)`	Clojure
`string₁!= string₂`	C++ (STL), C# , Go , JavaScript (non similaire), PHP (non similaire), Python , Ruby , Rust , Swift , D , Mathematica
`string₁!== string₂`	JavaScript , PHP
`string₁ \= string₂`	Rexx
`string₁ ¬= string₂`	PL/I
`test string₁!= string₂[ string₁!= string₂ ]`	Bourne Shell
`string₁ -ne string₂Windows PowerShell`
`string₁ ~= string₂`	Lua , Smalltalk
`string₁ ≢ string₂`	APL
`string₁.ne(string₂)`	Rouille

!= "world" // renvoie vrai

"world" ) ; ⇒ vrai

#Trouver

index de

voir #Trouver

instr

voir #Trouver

instrrev

voir #rfind

rejoindre

Définition	`join(separator, list_of_strings)`renvoie une liste de chaînes de caractères reliées par un séparateur.
Description	Concatène la liste de chaînes de caractères en une nouvelle chaîne, en insérant la chaîne de séparation entre chaque sous-chaîne. Contraire de split .
En rapport	sprintf

Format	Langues
`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_stringsseparator)`	Schéma (SRFI 13)
`(format nil "~{~a~^separator~}" array_of_strings)`	Common Lisp
`(clojure.string/join separatorlist_of_strings)(apply str (interpose separatorlist_of_strings))`	Clojure
`strings.Join(array_of_strings, separator)`	Aller
`join(array_of_strings, separator)`	Graine 7
`String.concat separatorlist_of_strings`	OCaml
`String.concatWith separatorlist_of_strings`	ML standard
`Data.List.intercalate separatorlist_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"}array_of_strings -join separator`	Windows PowerShell
`[array_of_strings componentsJoinedByString:separator]`	Objectif-C ( `NSString *`uniquement)
`table.concat(table_of_strings, separator)`	Lua
`Conversation informelle ( Squeak , Pharo )`
`array_of_strings.join(separator«, final_separator»)`	Cobra
`sequence_of_strings.joinWithSeparator(separator)`	Swift 2.x
`1↓∊separator,¨list_of_strings`	APL

, { "a" , " b" , "c" }) // "abc"

#( 'a' 'b' 'c' ) joinUsing: '-' " 'abc' "

. join ([ "a" , "b" , "c" ]) # 'abc'

, "b" , "c" ] .join ( "-" ) # 'abc'

"b" "c" ) "-" ) ; "abc"

dernier index de

voir #rfind

gauche

Définition	`left(string,n)`renvoie une chaîne de caractères
Description	Renvoie les n premiers caractères d'une chaîne. Si n est supérieur à la longueur de la chaîne, la plupart des implémentations renvoient la chaîne entière (des exceptions existent – voir les exemples de code). Pour les encodages à longueur variable tels que UTF-8 , UTF-16 ou Shift-JIS , il peut être nécessaire de supprimer les caractères à la fin de la chaîne afin d'éviter les chaînes invalides.

Format	Langues
`Ada`
`substr(string, 0, n)`	AWK (modifie les chaînes de caractères), Perl , PHP , Raku
`LEFT$(string,n)`	BASIC , VB
`left(string,n)`	VB , FreeBASIC , Ingres , Pick Basic
`strncpy(string2, string, n)`	bibliothèque standard C
`string.substr(0,n)`	C++ (STL), Raku
`[string substringToIndex:n]`	Objectif-C ( `NSString *`uniquement)
`Clojure`
`string[0 .. n]`	D
`string:substr(string, start, length)`	Erlang
`(subseq string 0 n)`	Common Lisp
`string[:n]`	Cobra , Go , Python
`left(string,n «,padchar»)`	Rexx , Erlang
`string[0, n]string[0..n - 1]`	Rubis
`string[1, n]`	Choisissez Basique
`string[ .. n]`	Graine 7
`string.Substring(0,n)`	VB .NET , C# , Windows PowerShell , F#
`leftstr(string, n)`	Pascal , Objet Pascal ( Delphi )
`copy (string,1,n)`	Turbo Pascal
`string.substring(0,n)`	Java , JavaScript
`(string-take stringn)`	Schéma (SRFI 13)
`take nstring`	Haskell
`String.extract (string, n, NONE)`	ML standard
`String.sub string 0 n`	OCaml
`string.[..n]`	Fa#
`string.sub(string, 1, n)(string):sub(1, n)`	Lua
`string first: n`	Conversation informelle ( Squeak , Pharo )
`string(:n)`	Fortran
`StringTake[string, n]`	Mathematica
`string («FUNCTION» LENGTH(string) - n:n)`	COBOL
`string.substring(0, n)`	Cobra
`n↑string.`	APL
`string[0..n]string[..n]string.get(0..n)string.get(..n)`	Rouille

. substr ( 0 , 6 ); # renvoie "Bonjour,"

, 3 ) /* renvoie "abc" */ left ( "abcde" , 8 ) /* renvoie "abcde" */ left ( "abcde" , 8 , "*" ) /* renvoie "abcde***" */

, 3 ) ; retourne "abc" ( string-take "abcde" , 8 ) ; erreur

, 3 ) ' renvoie "san" Left ( "sandroguidi" , 100 ) ' renvoie "sandroguidi"

len

voir #longueur

longueur

Définition	`length(string)`renvoie un nombre entier
Description	Renvoie la longueur d'une chaîne (sans compter le caractère nul de fin de chaîne ni aucune autre information structurelle interne). Une chaîne vide renvoie une longueur de 0.

Format	Retours	Langues
`string'Length`		Ada
`UPB string`		ALGOL 68
`echo "${#string_param}"`		Frapper
`length(string)`		Ingres , Perl 5, Pascal , Object Pascal ( Delphi ), Rexx , Seed7 , SQL , PL/I
`len(string)`		BASIC , FreeBASIC , Python , Go , Choisir Basic
`length(string), string:len(string)`		Erlang
`Len(string)`		VB , Choisissez Basique
`string.Length`	Nombre d' unités de code UTF-16	VB .NET , C# , Windows PowerShell , F#
`chars(string)string.chars`	Nombre de graphèmes (NFG)	Raku
`codes(string)string.codes`	Nombre de points de code Unicode	Raku
`string.size OR string.length`	Nombre d'octets	Rubis
`strlen(string)`	Nombre d'octets	C , PHP
`string.length()`		C++ (STL)
`string.length`		Cobra , D , JavaScript
`string.length()`	Nombre d' unités de code UTF-16	Java
`(string-length string)`		Schème
`(length string)`		Common Lisp , ISLISP
`(count string)`		Clojure
`String.length string`		OCaml
`size string`		ML standard
`length string`	Nombre de points de code Unicode	Haskell
`string.length`	Nombre d' unités de code UTF-16	Objectif-C ( `NSString *`uniquement)
`string.characters.count`	Nombre de caractères	Swift (2.x)
`count(string)`	Nombre de caractères	Swift (1.2)
`countElements(string)`	Nombre de caractères	Swift (1.0–1.1)
`string.len(string)(string):len()#string`		Lua
`string size`		Conversation
`LEN(string)LEN_TRIM(string)`		Fortran
`StringLength[string]`		Mathematica
`«FUNCTION» LENGTH(string)`ou `«FUNCTION» BYTE-LENGTH(string)`	nombre de caractères et nombre d'octets, respectivement	COBOL
`string length string`	une chaîne décimale indiquant le nombre de caractères	Tcl
`≢ string`		APL
`string.len()`	Nombre d'octets	Rouille
`string.chars().count()`	Nombre de points de code Unicode	Rouille

.Length ; // renvoie 5 " " .Length ; // renvoie 0

). % renvoie 5 chaîne : len ( ). % renvoie 0

); # renvoie 5 longueur ( ); # renvoie 0

) ' renvoie 5 Len ( ) ' renvoie 0

Longueur ] //renvoie 5 [ @"" Longueur ] //renvoie 0

#Trouver

Minuscule

Définition	`lowercase(string)`renvoie une chaîne de caractères
Description	Renvoie la chaîne en minuscules.

Format	Langues
`LCase(string)`	VB
`lcase(string)`	FreeBASIC
`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)`	Objet Pascal ( Delphi )
`strtolower(string)`	PHP
`lower(string)`	Graine 7
`${string_param,,}`	Frapper
`echo "string" \|tr 'A-Z' 'a-z'`	Unix
`string.lower()`	Python
`downcase(string)`	Choisissez Basique
`string.downcase`	Rubis
`strings.ToLower(string)`	Aller
`(string-downcase string)`	Schéma (R6RS), Common Lisp
`(lower-case string)`	Clojure
`String.lowercase string`	OCaml
`String.map Char.toLower string`	ML standard
`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 *`uniquement), Swift (Foundation)
`string.lower(string)(string):lower()`	Lua
`string asLowercase`	Conversation
`LOWER(string)`	SQL
`lowercase(string)`	PL/I
`ToLowerCase[string]`	Mathematica
`«FUNCTION» LOWER-CASE(string)`	COBOL
`string.toLower`	Cobra
`string tolower string`	Tcl
`string.to_lowercase()`	Rouille

. ToLower (); // "wiki signifie rapide ?"

) ; "wiki signifie rapide ?"

; for ( int i = 0 ; i < sizeof ( s ) - 1 ; ++ i ) { // transformer les caractères sur place, un par un s [ i ] = tolower ( s [ i ]); } printf ( string ); // "wiki signifie rapide ?" return 0 ; }

#substring

partition

Définition	<string>.partition( separator ) renvoie la sous-chaîne avant le séparateur ; le séparateur ; puis la sous-chaîne après le séparateur.
Description	Divise la chaîne donnée en fonction du séparateur et renvoie les trois sous-chaînes qui, ensemble, constituent la chaîne originale.

Format	Langues	Commentaires
`string.partition(separator)`	Python , Ruby (1.9+)
`lists:partition(pred, string)`	Erlang
`split /(separator)/, string, 2`	Perl 5
`split separator, string, 2string.split( separator, 2 )`	Raku	Le séparateur ne doit pas nécessairement être une expression régulière.

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

Définitionreplace(string, find, replace)renvoie une chaîne de caractèresDescriptionRenvoie une chaîne de caractères où les occurrences de recherche ont été modifiées pour remplacer .

Format	Langues
`changestr(find, string, replace)`	Rexx
`std.string.replace(string, find, replace)`	D
`Replace(string, find, replace)`	VB
`replace(string, find, replace)`	Graine 7
`change(string, find, replace)`	Choisissez Basique
`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)`	Java
`string.gsub(find, replace)`	Rubis
`string =~ s/find_regex/replace/g`	Perl 5
`string.subst(find, replace, :g)`	Raku
`string.replace(find, replace, "g")` `string.replace(/find_regex/g, replace)`	JavaScript
`echo "string" \|sed 's/find_regex/replace/g'`	Unix
`${string_param//find_pattern/replace}`	Frapper
`string.replace(find, replace)string -replace find_regex, replace`	Windows PowerShell
`Str.global_replace (Str.regexp_string find) replacestring`	OCaml
`[string stringByReplacingOccurrencesOfString:find withString:replace]`	Objectif-C ( `NSString *`uniquement)
`string.stringByReplacingOccurrencesOfString(find, withString:replace)`	Swift (Fondation)
`string.gsub(string, find, replace)(string):gsub(find, replace)`	Lua
`string copyReplaceAll: find with: replace`	Conversation informelle ( Squeak , Pharo )
`string map {findreplace} string`	Tcl
`StringReplace[string, find -> replace]`	Mathematica
`strings.Replace(string, find, replace, -1)`	Aller
`INSPECT string REPLACING ALL/LEADING/FIRST find BY replace`	COBOL
`find_regex ⎕R replace_regex ⊢ string`	APL

.Replace ( " f" , "jump" ); // renvoie "ejumpjumpjumpjumpjumpjump" "blah" .Replace ( " z" , "y" ); // renvoie "blah"

.replace ( " f" , "jump" ); // renvoie "ejumpjumpjumpjumpjumpjump" "effffff" .replaceAll ( "f*" , " jump" ); // renvoie "ejump"

.subst ( "f" , "jump" , : g ); # renvoie "ejumpjumpjumpjumpjumpjump" "blah" .subst ( " z" , "y" , : g ) ; # renvoie "blah"

, "f" , "jump" ) ' renvoie "ejumpjumpjumpjumpjump" Replace ( "blah" , "z" , "y" ) ' renvoie "blah"

-replace "f" , "jump" # renvoie "ejumpjumpjumpjumpjump" "effffff -replace "f*" , "jump" # renvoie "ejump"

inverse

Définition	`reverse(string)`
Description	Inverse l'ordre des caractères dans la chaîne.

Format	Langues
`reverse string`	Perl 5, Haskell
`flip stringstring.flip`	Raku
`lists:reverse(string)`	Erlang
`strrev(string)`	PHP
`string[::-1]`	Python
`(string-reverse string)`	Schéma (SRFI 13)
`(reverse string)`	Common Lisp
`string.reverse`	Ruby , D (modifie la chaîne)
`new StringBuilder(string).reverse().toString()`	Java
`std::reverse(string.begin(), string.end());`	C++ ( `std::string`modifie uniquement la chaîne)
`StrReverse(string)`	VB
`string.Reverse()`	VB .NET , C#
`implode (rev (explode string))`	ML standard
`stringJavaScript`
`string.reverse(string)(string):reverse()`	Lua
`string reverse`	Conversation
`StringReverse[string]`	Mathematica
`reverse(string)`	PL/I
`COBOL`
`string.toCharArray.toList.reversed.join()`	Cobra
`String(string.characters.reverse())`	Swift (2.x)
`String(reverse(string))`	Swift (1.2)
`string reverse string`	Tcl
`⌽string`	APL
`stringRouille`
`echo string\| rev`	Unix

'hello' inversé " renvoie 'oleh' "

# renvoie "olleh"

[:: - 1 ] # renvoie "olleh"

) ; renvoie "olleh"

rfind

Définition	`rfind(string,substring)`renvoie un entier
Description	Renvoie la position du début de la dernière occurrence de la sous-chaîne dans la chaîne . Si la sous-chaîne est introuvable, la plupart de ces routines renvoient une valeur d'index invalide – -1 lorsque les index commencent à 0, 0 lorsqu'ils commencent à 1 – ou une valeur à interpréter comme FAUX.
En rapport	instr

Format Langues Si introuvable

InStrRev(«startpos,» string,substring) VB renvoie 0

instrrev(«startpos,» string,substring) FreeBASIC renvoie 0

rindex(string,substring«,startpos») Perl 5 renvoie −1

rindex(string,substring«,startpos»)string.rindex(substring«,startpos») Raku renvoie NulPHP renvoie FAUXC++ (STL) renvoie std::string::nposD renvoie −1

string.rfind(substring«,startpos«, endpos»») Python renvoie −1

string.rindex(substring«,startpos«, endpos»») génère une erreur de valeurGraine 7 renvoie 0

string.rindex(substring«,startpos») Rubis renvoie nulAller renvoie −1

string.lastIndexOf(substring«,startpos») Java , JavaScript renvoie −1

string.LastIndexOf(substring«,startpos«, charcount»») VB .NET , C# , Windows PowerShell , F# renvoie −1

(search substringstring :from-end t) Common Lisp returns Objective-C (NSString * only) returns OCaml raises Lua returns Ada returns 0

string.lastIndexOf(substring«,startpos«, charcount»») Cobra returns −1

string lastIndexOfString:substring Smalltalk returns 0

string last substring string startpos Tcl returns −1

APL returns −1

string.rfind(substring)

Rust

returns "Hello mate":from-endt); returns 9(search"z""word":from-endt); returns NIL

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

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

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

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

right

Definition	`right(string,n)` returns string
Description	Returns the right n part of a string. If n is greater than the length of the string then most implementations return the whole string (exceptions exist – see code examples).

Format	Languages
`Ada`
`Right(string,n)`	VB
`RIGHT$(string,n)`	BASIC
`right(string,n)`	FreeBASIC, Ingres, Pick Basic
`strcpy(string2, string+n)` (C
`string.Substring(string.Length()-n)`	C#
`string[len(string)-n:]`	Go
`string.substring(string.length()-n)`	Java
`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_param: -n}` (a space occurs after the colon)	Bash
`string[n]`	Pick Basic
`(string-take-right stringn)`	Scheme (SRFI 13)
`string[-n..-1]`	Ruby
`string[$-n .. $]`	D
`String.sub string (String.length string - n) n`	OCaml
`string.sub(string, -n)(string):sub(-n)`	Lua
`string last: n`	Smalltalk (Squeak, Pharo)
`StringTake[string, -n]`	Mathematica
`string (1:n)`	COBOL
`¯n↑string.`	APL
`string[n..]string.get(n..)`	Rust

;str.substring(str.length()-4);// returns 'Door'

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

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

,3); returns "cde"(string-take-right"abcde",8); error

,3)' returns "idi"Right("sandroguidi",100)' returns "sandroguidi"

rpartition

Definition	<string>.rpartition(separator) Searches for the separator from right-to-left within the string then returns the sub-string before the separator; the separator; then the sub-string after the separator.
Description	Splits the given string by the right-most separator and returns the three substrings that together make the original.

Format	Languages
`string.rpartition(separator)`	Python, Ruby

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

slice

see#substring

split

Definition	<string>.split(separator[, limit]) splits a string on separator, optionally only up to a limited number of substrings
Description	Splits the given string by occurrences of the separator (itself a string) and returns a list (or array) of the substrings. If limit is given, after limit – 1 separators have been read, the rest of the string is made into the last substring, regardless of whether it has any separators in it. The Scheme and Erlang implementations are similar but differ in several ways. JavaScript differs also in that it cuts, it does not put the rest of the string into the last element. See the example here. The Cobra implementation will default to whitespace. Opposite of join.

Format	Languages
`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»)`	Python
`string.split(separator«, limit»)`	JavaScript, Java, Ruby
`string:tokens(string, sepchars)`	Erlang
`strings.Split(string, separator)strings.SplitN(string, separator, limit)`	Go
`(string-tokenize string«charset«start«end»»»)`	Scheme (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]`	Objective-C (`NSString *` only)
`string.componentsSeparatedByString(separator)`	Swift (Foundation)
`TStringList.Delimiter, TStringList.DelimitedText`	Object Pascal
`StringSplit[string, separator«, limit»]`	Mathematica
`string.split«(sepchars«, limit«, options»»)»`	Cobra
`split string separator`	Tcl
`(separator≠string)⊂string` in APL2`separator(≠⊆⊢)string` in Dyalog APL 16.0	APL
`string.split(separator)` `string.split(limit, separator)`	Rust

.Split(',');// {"abc", "defgh", "ijk"}"abc,defgh;ijk".Split(',',';');// {"abc", "defgh", "ijk"}

,";").% ["abc", "defgh", "ijk"]

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

#Format

strip

see#trim

strcmp

see#Compare (integer result)

substring

Definition substring(string, startpos, endpos) returns stringsubstr(string, startpos, numChars) returns string

Description Returns a substring of string between starting at startpos and endpos, or starting at startpos of length numChars. The resulting string is truncated if there are fewer than numChars characters beyond the starting point. endpos represents the index after the last character in the substring. For variable-length encodings such as UTF-8, UTF-16 or Shift-JIS, it can be necessary to remove string positions at the end, to avoid invalid strings.

Format	Languages
`string[startpos:endpos]`	ALGOL 68 (changes base index)
`string (startpos .. endpos)`	Ada (changes base index)
`Mid(string, startpos, numChars)`	VB
`mid(string, startpos, numChars)`	FreeBASIC
`string[startpos+(⍳numChars)-~⎕IO]`	APL
`MID$(string, startpos, numChars)`	BASIC
`substr(string, startpos, numChars)`	AWK (changes string), Perl 5,PHP
`substr(string, startpos, numChars)string.substr(startpos, numChars)`	Raku
`substr(string, startpos «,numChars, padChar»)`	PL/I
`substr(string, startpos «,numChars, padChar»)`	Rexx
`string[startpos:endpos]`	Cobra, Python,Go
`string[startpos, numChars]`	Pick Basic
`string[startpos, numChars]string[startpos .. endpos-1]string[startpos ... endpos]`	Ruby
`string[startpos .. endpos]string[startpos len numChars]`	Seed7
`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 stringstartposendpos)`	Scheme
`(subseq stringstartposendpos)`	Common Lisp
`(subseq stringstartposendpos)`	ISLISP
`String.sub stringstartposnumChars`	OCaml
`substring (string, startpos, numChars)`	Standard ML
`string:sub_string(string, startpos, endpos)string:substr(string, startpos, numChars)`	Erlang
`strncpy(result, string + startpos, numChars);`	C
`string[startpos .. endpos+1]`	D
`take numChars $ drop startposstring`	Haskell
`[string substringWithRange:NSMakeRange(startpos, numChars)]`	Objective-C (`NSString *` only)
`string.[startpos..endpos]`	F#
`string.sub(string, startpos, endpos)(string):sub(startpos, endpos)`	Lua
`string copyFrom: startpos to: endpos`	Smalltalk
`string(startpos:endpos)`	Fortran
`SUBSTRING(string FROM startpos «FOR numChars»)`	SQL
`StringTake[string, {startpos, endpos}]`	Mathematica
`string (startpos:numChars)`	COBOL
`${string_param:startpos:numChars}`	Bash
`string range string startpos endpos`	Tcl
`string[startpos..endpos]string.get(startpos..endpos)`	Rust

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

12); returns "b"(subseq"abc"2); returns "c"

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

,1,1);# returns "b"substr("abc",1);# returns "bc"

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

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

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

Uppercase

Definition	`uppercase(string)` returns string
Description	Returns the string in upper case.

Format	Languages
`UCase(string)`	VB
`ucase(string)`	FreeBASIC
`toupper(string)`	AWK (changes string)
`uc(string)`	Perl, Raku
`string.uc`	Raku
`toupper(char)`	C (operates on one character)
`C (string / char array)`
`std.string.toUpper(string)`	D
`transform(string.begin(), string.end(), result.begin(), toupper)`	C++
`uppercase(string)`	Object Pascal (Delphi)
`upcase(char)`	Object Pascal (Delphi) (operates on one character)
`strtoupper(string)`	PHP
`upper(string)`	Seed7
`${string_param^^}` (mnemonic: ^ is pointing up)	Bash
`echo "string" \|tr 'a-z' 'A-Z'`	Unix
`translate(string)UPPER variablesRexx`
`string.upper()`	Python
`upcase(string)`	Pick Basic
`string.upcase`	Ruby
`strings.ToUpper(string)`	Go
`(string-upcase string)`	Scheme, Common Lisp
`String.uppercase string`	OCaml
`String.map Char.toUpper string`	Standard ML
`map Char.toUpper string`	Haskell
`string.toUpperCase()`	Java, JavaScript
`string.uppercase()`	Kotlin
`to_upper(string)`	Erlang
`string.ToUpper()`	VB .NET, C#, Windows PowerShell, F#
`string.uppercaseString`	Objective-C (`NSString *` only), Swift (Foundation)
`string.upper(string)(string):upper()`	Lua
`string asUppercase`	Smalltalk
`UPPER(string)`	SQL
`ToUpperCase[string]`	Mathematica
`COBOL`
`string.toUpper`	Cobra
`string toupper string`	Tcl
`string.to_uppercase()`	Rust

.ToUpper();// "WIKI MEANS FAST?"

);# "WIKI MEANS FAST?"

); # "WIKI MEANS FAST?""Wiki means fast?".uc; # "WIKI MEANS FAST?"

)/* "WIKI MEANS FAST?" *//* Example #2 */ A='This is an example.' UPPERA/* "THIS IS AN EXAMPLE." *//* Example #3 */ A='upper using Translate Function.' TranslateUPPERVARAZ/* Z="UPPER USING TRANSLATE FUNCTION." */

); "WIKI MEANS FAST?"

)' "WIKI MEANS FAST?"

trim

Example usageLanguagesString.Trim([chars])C#, VB.NET, Windows PowerShellstring.strip();D(.trim string)Clojuresequence [ predicate? ] trimFactor

Common Lisp(string-trim string)Schemestring.trim()Java, JavaScript (1.8.1+, Firefox 3.5+), RustTrim(String)Pascal,QBasic, Visual Basic, Delphistring.strip()Pythonstrings.Trim(string, chars)GoLTRIM(RTRIM(String))OracleSQL, T-SQLstrip(string [,option, char])REXXstring:strip(string [,option, char])Erlangstring.stripstring.lstripstring.rstripRubystring.trimRakutrim(string)PHP, Raku[stringObjective-C using Cocoastring withBlanksTrimmedstring withoutSpacesstring withoutSeparatorsSmalltalk (Squeak, Pharo)Smalltalkstrip(string)SASstring trim $stringTclTRIM(string)TRIM(ADJUSTL(string))FortranTRIM(string)SQLTRIM(string)LTrim(string)RTrim(String)ColdFusionString.trim stringOCaml 4+Other languages
In languages without a built-in trim function, it is usually simple to create a custom function which accomplishes the same task.
APL
APL can use regular expressions directly:
AWK, one can use regular expressions to trim:
open source C++ library Boost has several trim variants, including a standard one:
);
With boost's function named simply trim the input sequence is modified in-place, and returns no result.
Another open source C++ library Qt, has several trim variants, including a standard one:
Linux kernel also includes a strip function, strstrip(), since 2.6.18-rc1, which trims the string "in place". Since 2.6.33-rc1, the kernel uses strim() instead of strstrip() to avoid false warnings.
Haskell
A trim algorithm in Haskell:
 String trim = f . f where f = reverse . dropWhile isSpace " importData.Char(isSpace)trim::String->Stringtrim=f.fwheref=reverse.dropWhileisSpace
may be interpreted as follows: f drops the preceding whitespace, and reverses the string. f is then again applied to its own output. The type signature (the second line) is optional.
J
The trim algorithm in J is a functional description:
regular expressions.
Example:
CPAN.
There are, however, two functions that are commonly used to strip whitespace from the end of strings, chomp and chop:
chop removes the last character from a string and returns it.
chomp removes the trailing newline character(s) from a string if present. (What constitutes a newline is $INPUT_RECORD_SEPARATOR dependent).
In Raku, the upcoming sister language of Perl, strings have a trim method.
Example:
Tclstring command has three relevant subcommands: trim, trimright and trimleft. For each of those commands, an additional argument may be specified: a string that represents a set of characters to remove—the default is whitespace (space, tab, newline, carriage return).
Example of trimming vowels:
XSLT includes the function normalize-space(string) which strips leading and trailing whitespace, in addition to replacing any whitespace sequence (including line breaks) with one space.
Example:

      Plus d articles de Worldlex Wiki
      Revenez a l index pour explorer davantage de pages sur l histoire, la science, la culture, la geographie et la societe en francais.
      Explorer l index