Comparación de lenguajes de programación (funciones de cadena)

Las funciones de cadena se utilizan en lenguajes de programación informática para manipular una cadena o consultar información sobre una cadena (algunas hacen ambas cosas).

La mayoría de los lenguajes de programación que tienen un tipo de datos de cadena tendrán algunas funciones de cadena, aunque puede haber otras formas de bajo nivel dentro de cada lenguaje para manejar cadenas directamente. En los lenguajes orientados a objetos, las funciones de cadena se implementan a menudo como propiedades y métodos de objetos de cadena. En los lenguajes funcionales y basados en listas, una cadena se representa como una lista (de códigos de caracteres), por lo tanto, todos los procedimientos de manipulación de listas podrían considerarse funciones de cadena. Sin embargo, dichos lenguajes también pueden implementar un subconjunto de funciones explícitas específicas de cadenas.

En el caso de las funciones que manipulan cadenas, los lenguajes modernos orientados a objetos, como C# y Java , tienen cadenas inmutables y devuelven una copia (en la memoria dinámica recién asignada), mientras que otros, como C, manipulan la cadena original a menos que el programador copie los datos en una nueva cadena. Véase, por ejemplo, la concatenación a continuación.

El ejemplo más básico de una función de cadena es la length(string)función . Esta función devuelve la longitud de un literal de cadena .

Por ejemplo length("hello world")devolvería 11.

Otros lenguajes pueden tener funciones de cadena con sintaxis, parámetros o resultados similares o exactamente iguales. Por ejemplo, en muchos lenguajes la función length suele representarse como len(string) . La siguiente lista de funciones comunes tiene como objetivo ayudar a limitar esta confusión.

Funciones de cadena comunes (referencia en varios idiomas)

A continuación se enumeran las funciones de cadena comunes a muchos lenguajes, incluidos los diferentes nombres utilizados. La siguiente lista de funciones comunes tiene como objetivo ayudar a los programadores a encontrar la función equivalente en un lenguaje. Tenga en cuenta que la concatenación de cadenas y las expresiones regulares se manejan en páginas separadas. Las declaraciones entre guillemets (« … ») son opcionales.

Carácter

Definición	`charAt(string,integer)`devuelve el caracter.
Descripción	Devuelve el carácter en el índice de la cadena.
Equivalente	Ver subcadena de longitud 1 carácter.

Formato	Idiomas	Índice base
`string[i]`	ALGOL 68 , APL , Julia , Pascal , Object Pascal ( Delphi ), Seed7	1
`string[i]`	C , C++ , C# , Cobra , D , FreeBASIC , Go , Python , ^[1] PHP , Ruby , ^[1] Windows PowerShell , JavaScript , APL	0
`string{i}`	PHP (obsoleto en 5.3)	0
`string(i)`	Ada	≥1
`Mid(string,i,1)`	Vb	1
`MID$(string,i,1)`	BÁSICO	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)`	Óxido ^[2]	0
`string[i,1]`	Seleccione Básico	1
`String.sub (string, i)`	ML estándar	0
`string !! i`	Haskell	0
`(string-ref string i)`	Esquema	0
`(char string i)`	Ceceo común	0
`(elt string i)`	ISLISP	0
`(get string i)`	Clojure	0
`substr(string, i, 1)`	Perl 5 ^[1]	0
`substr(string, i, 1)` `string.substr(i, 1)`	Raku ^[3]	0
`substr(string, i, 1)`	PL/Yo	1
`string.at(i)`	C++ (STL) (con comprobación de límites)	0
`lists:nth(i, string)`	Erlang	1
`[string characterAtIndex:i]`	Objective-C ( `NSString *`solamente)	0
`string.sub(string, i, i)` `(string):sub(i, i)`	Luna ^[1]	1
`string at: i`	Smalltalk (con comprobación de límites)	1
`string index string i`	Tcl	0
`StringTake[string, {i}]`	Mathematica , lenguaje Wolfram ^[1]	1
`string@i`	Torre Eiffel	1
`string (i:1)`	COBOL	1
`${string_param:i:1}`	Intento	0
`i⌷string`	APL	0 o 1

{ Ejemplo en Pascal } var MyStr : string = 'Hola, mundo' ; MyChar : Char ; begin MyChar := MyStr [ 2 ] ; // 'e'

# Ejemplo en ALGOL 68 #"Hola, mundo"[2]; // 'e'

// Ejemplo en C #include <stdio.h>  // para printf char MyStr [] = "Hola, mundo" ; printf ( "%c" , * ( MyStr + 1 )); // 'e' printf ( "%c" , * ( MyStr + 7 )); // 'W' printf ( "%c" , MyStr [ 11 ]); // 'd' printf ( "%s" , MyStr ); // 'Hola, mundo' printf ( "%s" , "Hola(2), Mundo(2)" ); // 'Hola(2), Mundo(2)'

// Ejemplo en C++ #include <iostream>  // para "cout" #include <string.h>  // para el tipo de datos "string" que utiliza el espacio de nombres std ; char MyStr1 [] = "Hola(1), Mundo(1)" ; string MyStr2 = "Hola(2), Mundo(2)" ; cout << "Hola(3), Mundo(3)" ; // 'Hola(3), Mundo(3)' cout << MyStr2 [ 6 ]; // '2' cout << MyStr1 . substr ( 5 , 3 ); // '(1)'

// Ejemplo en C# "Hola, mundo" [ 2 ]; // 'l'

# Ejemplo en Perl 5 substr ( "Hola, Mundo" , 1 , 1 ); # 'e'

# Ejemplos en Python "Hola, mundo" [ 2 ]  # 'l' "Hola, mundo" [ - 3 ]  # 'r'

# Ejemplo en Raku "Hola, mundo" . substr ( 1 , 1 ); # 'e'

' Ejemplo en Visual Basic Mid ( "Hola, mundo" , 2 , 1 )

' Ejemplo en Visual Basic .NET "Hola, mundo" . Caracteres ( 2 ) ' "l"c

" Ejemplo en Smalltalk " 'Hola, mundo'  en:  2 .  "$e"

//Ejemplo en Rust "Hola, mundo" . chars (). nth ( 2 ); // Some('l')

Comparar (resultado entero)

Definición	`compare(string₁,string₂)`devuelve un entero.
Descripción	Compara dos cadenas entre sí. Si son equivalentes, se devuelve un cero. De lo contrario, la mayoría de estas rutinas devolverán un resultado positivo o negativo que corresponde a si la cadena ₁ es lexicográficamente mayor o menor que, respectivamente, que la cadena _2. Las excepciones son las rutinas Scheme y Rexx que devuelven el índice de la primera discrepancia, y Smalltalk que responde a un código de comparación que indica cómo ordena el receptor en relación con el parámetro de cadena.

Formato	Idiomas
`IF string₁<string₂ THEN -1 ELSE ABS (string₁>string₂) FI`	ALGOL 68
`cmp(string₁, string₂)`	Python 2
`(string₁ > string₂) - (string₁ < string₂)`	Pitón
`strcmp(string₁, string₂)`	C , PHP
`std.string.cmp(string₁, string₂)`	D
`StrComp(string₁, string₂)`	VB , Objeto Pascal ( Delphi )
`string₁ cmp string₂`	Perl , Raku
`string₁ compare: string₂`	Charla informal ( Squeak , Pharo )
`string₁ <=> string₂`	Ruby , C++ (STL, C++20 ) ^[4]
`string₁.compare(string₂)`	C++ (STL), Swift (Fundación)
`compare(string₁, string₂)`	Rexx , Semilla7
`CompareStr(string₁, string₂)`	Pascal , Objeto Pascal ( Delphi )
`string₁.compareTo(string₂)`	Cobra , Java
`string₁.CompareTo(string₂)`	VB.NET , C# , F#
`(compare string₁ string₂)`	Clojure
`(string= string₁ string₂)`	Ceceo común
`(string-compare string₁ string₂ p< p= p>)`	Esquema (SRFI 13)
`(string= string₁ string₂)`	ISLISP
`compare string₁ string₂`	OCaml
`String.compare (string₁, string₂)`	ML estándar ^[5]
`compare string₁ string₂`	Haskell ^[6]
`[string]::Compare(string₁, string₂)`	Windows PowerShell
`[string₁ compare:string₂]`	Objective-C ( `NSString *`solamente)
`LLT(string₁,string₂)` `LLE(string₁,string₂)` `LGT(string₁,string₂)` `LGE(string₁,string₂)`	Fortran ^[7]
`string₁.localeCompare(string₂)`	JavaScript
`bytes.Compare([]byte(string₁), []byte(string₂))`	Ir
`string compare string₁ string₂`	Tcl
`compare(string₁,string₂,count)`	PL/I ^[8]
`string₁.cmp(string₂)`	Óxido ^[9]

# Ejemplo en Perl 5 "hola" cmp "mundo" ; # devuelve -1

# Ejemplo en Python cmp ( "hola" ,  "mundo" )  # devuelve -1

# Ejemplos en Raku "hola"  cmp  "mundo" ; # devuelve Menos "mundo"  cmp  "hola" ; # devuelve Más "hola"  cmp  "hola" ; # devuelve Igual

/** Ejemplo en Rexx */ compare ( "hola" , "mundo" ) /* devuelve el índice de desajuste: 1 */

; Ejemplo en Scheme ( use-modules ( srfi srfi-13 )) ; devuelve el índice de desajuste: 0 ( string-compare "hello" "world" values values values )

Comparar (operador relacional basado en resultado booleano)

Definición	`string₁ OP string₂`OR devuelve un valor booleano.`(compare string₁ string₂)`
Descripción	Compara lexicográficamente dos cadenas mediante un operador o función relacional. Se devuelve un resultado booleano.

Formato	Idiomas
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `=, <>, <, >, <=`y`>=`	Pascal , Object Pascal ( Delphi ), OCaml , Seed7 , ML estándar , BASIC , VB , VB .NET , F#
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `=, /=, ≠, <, >, <=, ≤`y `≥`; También: `EQ, NE, LT, LE, GE`y`GT`	ALGOL 68
`(stringOP? string₁ string₂)`, donde `OP`puede ser cualquiera de `=, -ci=, <, -ci<, >, -ci>, <=, -ci<=, >=`y `-ci>=`(los operadores que comienzan con ' `-ci`' no distinguen entre mayúsculas y minúsculas)	Esquema
`(stringOP string₁ string₂)`, donde `OP`puede ser cualquiera de `=, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >=`y `-ci>=`(los operadores que comienzan con ' `-ci`' no distinguen entre mayúsculas y minúsculas)	Esquema (SRFI 13)
`(stringOP string₁ string₂)`, donde `OP`puede ser cualquiera de `=, -equal, /=, -not-equal, <, -lessp, >, -greaterp, <=, -not-greaterp, >=`y `-not-lessp`(los operadores verbales no distinguen entre mayúsculas y minúsculas)	Ceceo común
`(stringOP string₁ string₂)`, donde `OP`puede ser cualquiera de `=, /=, <, >, <=,`y`>=`	ISLISP
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `=, \=, <, >, <=`y`>=`	Rexx
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `=, ¬=, <, >, <=, >=, ¬<`y`¬>`	PL/Yo
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `=, /=, <, >, <=`y`>=`	Ada
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `==, /=, <, >, =<`y`>=`	Erlang
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `==, /=, <, >, <=`y`>=`	Haskell
`string₁ OP string₂`, donde `OP`puede ser cualquiera de y`eq, ne, lt, gt, lege`	Perl , Raku
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `==, !=, <, >, <=`y`>=`	C++ (STL), C# , D , Go , JavaScript , Python , PHP , Ruby , Rust , ^[10] Swift
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `-eq, -ceq, -ne, -cne, -lt, -clt, -gt, -cgt, -le, -cle, -ge,`y `-cge` (los operadores que comienzan con ' `c`' distinguen entre mayúsculas y minúsculas)	Windows PowerShell
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `==, ~=, <, >, <=`y`>=`	Lua
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `=, ~=, <, >, <=`y`>=`	Charla informal
`string₁ OP string₂`, donde `OP`puede ser cualquiera de `==, /=, <, >, <=`y `>=; Also: .EQ., .NE., .LT., .LE., .GT.`y`.GE.`	Fortran . ^[11]
`string₁ OP string₂`donde `OP`puede ser cualquiera de `=, <>, <, >, <=, >=`así como equivalentes redactados	COBOL
`string₁ OP string₂`donde `OP`puede estar cualquiera de `==, <>, <, >, <=`y`>=`	Cobra
`string₁ OP string₂`está disponible en la sintaxis, pero significa la comparación de los punteros que apuntan a las cadenas, no del contenido de las cadenas. Utilice la función Comparar (resultado entero).	C , Java
`string₁.METHOD(string₂)`¿Dónde `METHOD`está alguno de `eq`, `ne`, `gt`, `lt`, `ge`,`le`	Óxido ^[10]

% Ejemplo en Erlang "hola" > "mundo" . % devuelve falso

# Ejemplo en Raku "arte"  gt  "pintura" ; # devuelve Falso "arte"  lt  "pintura" ; # devuelve Verdadero

# Ejemplo en Windows PowerShell "hello"  -gt  "world"  # devuelve falso

;; Ejemplo en Common Lisp ( cadena> "arte" "pintura" ) ; devuelve nil ( cadena< "arte" "pintura" ) ; devuelve un valor distinto de nil

Concatenación

Definición	`concatenate(string₁,string₂)`devuelve una cadena.
Descripción	Concatena (une) dos cadenas entre sí y devuelve la cadena combinada. Tenga en cuenta que algunos lenguajes como C tienen cadenas mutables, por lo que en realidad la segunda cadena se agrega a la primera y se devuelve la cadena mutada.

Formato	Idiomas
`string₁ & string₂`	Ada , FreeBASIC , Seed7 , BASIC , VB , VB .NET , COBOL (solo entre literales)
`strcat(string₁, string₂)`	C , C++ ( solamente) ^[12]`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 , ^[13] F# , Swift , Turing , VB
`string₁ ~ string₂`	D , Raku
`(string-append string₁ string₂)`	Esquema , ISLISP
`(concatenate 'string string₁ string₂)`	Ceceo común
`(str string₁ string₂)`	Clojure
`string₁ \|\| string₂`	Rexx , SQL , PL/I
`string₁ // string₂`	Fortran
`string₁ ++ string₂`	Erlang , Haskell
`string₁ ^ string₂`	OCaml , ML estándar , F#
`[string₁ stringByAppendingString:string₂]`	Objective-C ( `NSString *`solamente)
`string₁ .. string₂`	Lua
`string₁ , string₂`	Smalltalk , APL
`string₁ string₂`	SNOBOL
`string₁string₂`	Intento
`string₁ <> string₂`	Matemática
concat cadena ₁ cadena ₂	Tcl

{ Ejemplo en Pascal } 'abc' + 'def' ; // devuelve "abcdef"

// Ejemplo en C# "abc" + "def" ; // devuelve "abcdef"

' Ejemplo en Visual Basic "abc" & "def" ' devuelve "abcdef" "abc" + "def" ' devuelve "abcdef" "abc" & Null ' devuelve "abc" "abc" + Null ' devuelve Null

// Ejemplo en D "abc" ~ "def" ; // devuelve "abcdef"

;; Ejemplo en Common Lisp ( concatenar 'string "abc " "def " "ghi" ) ; devuelve "abc def ghi"

# Ejemplo en Perl 5 "abc" . "def" ; # devuelve "abcdef" "Perl " . 5 ; # devuelve "Perl 5"

# Ejemplo en Raku "abc" ~ "def" ; # devuelve "abcdef" "Perl " ~ 6 ; # devuelve "Perl 6"

Contiene

Definición	`contains(string,substring)`devuelve un valor booleano
Descripción	Devuelve si la cadena contiene una subcadena como subcadena. Esto es equivalente a usar Find y luego detectar que no da como resultado la condición de falla que se indica en la tercera columna de la sección Find. Sin embargo, algunos lenguajes tienen una forma más simple de expresar esta prueba.
Relacionado	Encontrar

Formato	Idiomas
`string_in_string(string, loc int, substring)`	ALGOL 68
`ContainsStr(string, substring)`	Objeto Pascal ( Delphi )
`strstr(string, substring) != NULL`	C , C++ ( `char *`solamente)
`string.Contains(substring)`	C# , VB.NET , Windows PowerShell , F#
`string.contains(substring)`	Cobra , Java (1.5+), Raku , Rust , ^[14] C++ ( C++23 ) ^[15]
`string.indexOf(substring) >= 0`	JavaScript
`strpos(string, substring) !== false`	PHP
`str_contains(string, substring)`	PHP (8+)
`pos(string, substring) <> 0`	Semilla7
`substring in string`	Cobra , Pitón (2.3+)
`string.find(string, substring) ~= nil`	Lua
`string.include?(substring)`	Rubí
`Data.List.isInfixOf substring string`	Haskell (GHC 6.6+)
`string includesSubstring: substring`	Smalltalk ( Squeak , Pharo , Smalltalk/X)
`String.isSubstring substring string`	ML estándar
`(search substring string)`	Ceceo común
`(not (null (string-index substring string)))`	ISLISP
`(substring? substring string)`	Clojure
`! StringFreeQ[string, substring]`	Matemática
`index(string, substring, startpos)>0`	Fortran, PL/I ^[16]
`index(string, substring, occurrence)>0`	Seleccione Básico
`strings.Contains(string, substring)`	Ir
`string.find(substring) != string::npos`	C++
`[string containsString:substring]`	Objective-C ( `NSString *`solo iOS 8+/OS X 10.10+)
`string.rangeOfString(substring) != nil`	Swift (Fundación)
`∨/substring⍷string`	APL

¢ Ejemplo en ALGOL 68 ¢cadena en cadena ("e", loc int , "Hola amigo"); ¢ devuelve verdadero ¢cadena en cadena ("z", loc int , "palabra"); ¢ devuelve falso ¢

// Ejemplo En C# "Hola amigo" . Contiene ( "e" ); // devuelve verdadero "palabra" . Contiene ( "z" ); // devuelve falso

# Ejemplo en Python "e"  en  "Hola amigo"  # devuelve verdadero "z"  en  "palabra"  # devuelve falso

# Ejemplo en Raku "¡Buenos días!" . contiene ( 'z' ) # devuelve Falso "¡Buenos días!" . contiene ( 'í' ); # devuelve Verdadero

" Ejemplo en Smalltalk " 'Hola amigo'  incluye Substring:  'e'  " devuelve verdadero " ' palabra '  incluye Substring:  'z'  " devuelve falso "

Igualdad

Comprueba si dos cadenas son iguales. Consulte también #Compare y #Compare. Tenga en cuenta que realizar comprobaciones de igualdad mediante una comparación genérica con un resultado entero no solo es confuso para el programador, sino que a menudo es una operación significativamente más costosa; esto es especialmente cierto cuando se utilizan " cadenas C ".

Formato	Idiomas
`string₁ == string₂`	Python , C++ (STL), C# , Cobra , Go , JavaScript (similitud), PHP (similitud), Ruby , Rust , ^[10] Erlang , Haskell , Lua , D , Mathematica , Swift
`string₁ === string₂`	JavaScript , PHP
`string₁ == string₂` `string₁ .EQ. string₂`	Fortran
`strcmp(string₁, string₂) == 0`	do
`(string=? string₁ string₂)`	Esquema
`(string= string₁ string₂)`	Lisp común , ISLISP
`string₁ = string₂`	ALGOL 68 , Ada , Object Pascal ( Delphi ), OCaml , Pascal , Rexx , Seed7 , ML estándar , BASIC , VB , VB .NET , F# , Smalltalk , PL/I , COBOL
`test string₁ = string₂` `[ string₁ = string₂ ]`	Concha Bourne
`string₁ eq string₂`	Perl , Raku , Tcl
`string₁.equals(string₂)`	Cobra , Java
`string₁.Equals(string₂)`	DO#
`string₁ -eq string₂` `[string]::Equals(string₁, string₂)`	Windows PowerShell
`[string₁ isEqualToString:string₂]` `[string₁ isEqual:string₂]`	Objective-C ( `NSString *`solamente)
`string₁ ≡ string₂`	APL
`string₁.eq(string₂)`	Óxido ^[10]

// Ejemplo en C# "hola" == "mundo" // devuelve falso

' Ejemplo en Visual Basic "hola" = "mundo" ' devuelve falso

# Ejemplos en Perl 5 'hola' eq 'mundo' # devuelve 0 'hola' eq 'hola' # devuelve 1

# Ejemplos en Raku 'hola'  eq  'mundo'  # devuelve Falso 'hola'  eq  'hola'  # devuelve Verdadero

# Ejemplo en Windows PowerShell "hello"  -eq  "world"  # devuelve falso

⍝ Ejemplo en APL 'hola' ≡ 'mundo' ⍝ devuelve 0

Encontrar

Definición	`find(string,substring)`devuelve un entero
Descripción	Devuelve la posición del inicio de la primera aparición de la subcadena en la cadena . Si no se encuentra la subcadena , la mayoría de estas rutinas devuelven un valor de índice no válido (-1 cuando los índices están basados en 0, 0 cuando están basados en 1) o algún valor que se debe interpretar como booleano FALSO.
Relacionado	Instrrev

Formato	Idiomas	Si no se encuentra
`string in string(substring, pos, string[startpos:])`	ALGOL 68	devuelve BOOL: VERDADERO o FALSO, y la posición en REF INT pos.
`InStr(«startpos,»string,substring)`	VB (las posiciones comienzan en 1)	devuelve 0
`INSTR$(string,substring)`	BÁSICO (las posiciones comienzan en 1)	devuelve 0
`index(string,substring)`	AWK	devuelve 0
`index(string,substring«,startpos»)`	Perl 5	devuelve −1
`index(string,substring«,startpos»)` `string.index(substring,«,startpos»)`	Raku	devuelve cero
`instr(«startpos,»string,substring)`	LibreBASIC	devuelve 0
`strpos(string,substring«,startpos»)`	PHP	devuelve FALSO
`locate(string, substring)`	Ingreso	devuelve la longitud de la cadena + 1
`strstr(string, substring)`	C , C++ ( solamente, devuelve el puntero al primer carácter)`char *`	devuelve NULL
`std.string.indexOf(string, substring)`	D	devuelve −1
`pos(string, substring«, startpos»)`	Semilla7	devuelve 0
`strings.Index(string, substring)`	Ir	devuelve −1
`pos(substring, string)`	Pascal , Objeto Pascal ( Delphi )	devuelve 0
`pos(substring, string«,startpos»)`	Rexx	devuelve 0
`string.find(substring«,startpos»)`	C++ (STL)	devuelve std::string::npos
`string.find(substring«,startpos«,endpos»»)`	Pitón	devuelve −1
`string.index(substring«,startpos«,endpos»»)`	Pitón	genera ValueError
`string.index(substring«,startpos»)`	Rubí	devuelve cero
`string.indexOf(substring«,startpos»)`	Java , JavaScript	devuelve −1
`string.IndexOf(substring«,startpos«, charcount»»)`	VB .NET , C# , Windows PowerShell , F#	devuelve −1
`string:str(string, substring)`	Erlang	devuelve 0
`(string-contains string substring)`	Esquema (SRFI 13)	devuelve #f
`(search substring string)`	Ceceo común	devuelve NIL
`(string-index substring string)`	ISLISP	devoluciones`nil`
`List.findIndex (List.isPrefixOf substring) (List.tails string)`	Haskell (devuelve solo el índice )	No devuelve nada
`Str.search_forward (Str.regexp_string substring) string 0`	OCaml	genera Not_found
`Substring.size (#1 (Substring.position substring (Substring.full string)))`	ML estándar	devuelve la longitud de la cadena
`[string rangeOfString:substring].location`	Objective-C ( `NSString *`solamente)	devuelve NSNotFound
`string.find(string, substring)` `(string):find(substring)`	Lua	devuelve cero
`string indexOfSubCollection: substring startingAt: startpos ifAbsent: aBlock` `string findString: substring startingAt: startpos`	Charla informal ( Squeak , Pharo )	evaluar aBlock que es un cierre de bloque (o cualquier valor de comprensión de objeto) devuelve 0
`startpos = INDEX(string, substring «,back» «, kind»)`	Fortran	devuelve 0 si la subcadena no está en la cadena; devuelve LEN(cadena)+1 si la subcadena está vacía
`POSITION(substring IN string)`	SQL	devuelve 0 (las posiciones comienzan en 1)
`index(string, substring, startpos )`	PL/I ^[16]	devuelve 0 (las posiciones comienzan en 1)
`index(string, substring, occurrence )`	Seleccione Básico	devuelve 0 si la ocurrencia de la subcadena no está en la cadena; (las posiciones comienzan en 1)
`string.indexOf(substring«,startpos«, charcount»»)`	Cobra	devuelve −1
`string first substring string startpos`	Tcl	devuelve −1
`(substring⍷string)⍳1`	APL	devuelve 1 + la última posición en la cadena
`string.find(substring)`	Óxido ^[17]	devoluciones`None`

Ejemplos

Ceceo común

( buscar "e" "Hola amigo" ) ; devuelve 1 ( buscar "z" "palabra" ) ; devuelve NIL

DO#

"Hola amigo" . IndexOf ( "e" ); // devuelve 1 "Hola amigo" . IndexOf ( "e" , 4 ); // devuelve 9 "palabra" . IndexOf ( "z" ); // devuelve -1

Raku

"¡Hola!" . index ( 'e' ) # devuelve 1 "¡Hola!" . index ( 'z' ) # devuelve Nil

Esquema

( use-modules ( srfi srfi-13 )) ( string-contains "Hola amigo" "e" ) ; devuelve 1 ( string-contains "word" "z" ) ; devuelve #f

Visual Basic

' Ejemplos en InStr ( "Hola amigo" , "e" ) ' devuelve 2 InStr ( 5 , "Hola amigo" , "e" ) ' devuelve 10 InStr ( "palabra" , "z" ) ' devuelve 0

Charla informal

'Hola amigo'  indexOfSubCollection: 'ate'  "devuelve 8"

"Hola amigo"  indexOfSubCollection: "tarde"  "devuelve 0"

Hola amigo indexOfSubCollection : 'tarde' ifAbsent: [ 99 ] " devuelve 99 "

'Hola amigo'  indexOfSubCollection: 'tarde'  ifAbsent: [ error propio ] "genera una excepción"

Encuentra el personaje

Definición	`find_character(string,char)`devuelve un entero
Descripción	Devuelve la posición del inicio de la primera aparición del carácter char en string . Si no se encuentra el carácter, la mayoría de estas rutinas devuelven un valor de índice no válido (-1 donde los índices están basados en 0, 0 donde están basados en 1) o algún valor que se debe interpretar como booleano FALSO. Esto se puede lograr como un caso especial de #Find, con una cadena de un carácter; pero puede ser más simple o más eficiente en muchos idiomas localizar solo un carácter. Además, en muchos idiomas, los caracteres y las cadenas son de tipos diferentes, por lo que es conveniente tener una función de este tipo.
Relacionado	encontrar

Formato	Idiomas	Si no se encuentra
`char in string(char, pos, string[startpos:])`	ALGOL 68	devuelve BOOL : VERDADERO o FALSO , y la posición en REF INT pos .
`instr(string, any char«,startpos»)`(char, puede contener más de un char, en cuyo caso se devuelve la posición de la primera aparición de cualquiera de ellos).	LibreBASIC	devuelve 0
`strchr(string,char)`	C , C++ ( solamente, devuelve un puntero al carácter)`char *`	devuelve NULL
`std.string.find(string, dchar)`	D	devuelve −1
`string.find(char«,startpos»)`	C++ (STL)	devuelve std::string::npos
`pos(string, char«, startpos»)`	Semilla7	devuelve 0
`strings.IndexRune(string,char)`	Ir	devuelve −1
`string.indexOf(char«,startpos»)`	Java , JavaScript	devuelve −1
`string.IndexOf(char«,startpos«, charcount»»)`	VB .NET , C# , Windows PowerShell , F#	devuelve −1
`(position char string)`	Ceceo común	devuelve NIL
`(char-index char string)`	ISLISP	devuelve cero
`List.elemIndex char string`	Haskell (devuelve )`Just index`	No devuelve nada
`String.index string char`	OCaml	genera Not_found
`position = SCAN (string, set «, back» «, kind»)` `position = VERIFY (string, set «, back» «, kind»)^[a]`	Fortran	devuelve cero
`string indexOf: char ifAbsent: aBlock` `string indexOf: char` `string includes: char`	Charla informal	evaluar `aBlock`cual es un `BlockClosure`(o cualquier objeto que comprenda valor) devuelve 0 devuelve `true`o`false`
`index(string, char, startpos )`	PL/I ^[18]	devuelve 0 (las posiciones comienzan en 1)
`string.index(?char)`	Rubí	devuelve cero
`strpos(string,char,startpos)`	PHP	devuelve falso
`string.indexOf(char«,startpos«, charcount»»)`	Cobra	devuelve −1
`string⍳char`	APL	devuelve 1 + la última posición en la cadena
`string.find(substring)`	Óxido ^[17]	devuelve Ninguno

// Ejemplos en C# "Hola amigo" . IndexOf ( 'e' ); // devuelve 1 "palabra" . IndexOf ( 'z' ) // devuelve -1

; Ejemplos en Common Lisp ( posición #\e "Hola amigo" ) ; devuelve 1 ( posición #\z "palabra" ) ; devuelve NIL

^a Dado un conjunto de caracteres, SCAN devuelve la posición del primer carácter encontrado,^[19] mientras que VERIFY devuelve la posición del primer carácter que no pertenece al conjunto.^[20]

Formato

Definición	`format(formatstring, items)`devuelve cadena
Descripción	Devuelve la representación de cadena formateada de uno o más elementos.

Formato	Idiomas	Sintaxis de formato de cadena
`associate(file, string); putf(file, $formatstring$, items)`	ALGOL 68	ALGOL
`Format(item, formatstring)`	Vb
`sprintf(formatstring, items)`	Perl , PHP , Raku , Ruby	do
`item.fmt(formatstring)`	Raku	do
`io_lib:format(formatstring, items)`	Erlang
`sprintf(outputstring, formatstring, items)`	do	do
`std::format(formatstring, items)`	C++ ( C++20 )	Pitón
`std.string.format(formatstring, items)`	D	do
`Format(formatstring, items)`	Objeto Pascal ( Delphi )
`fmt.Sprintf(formatstring, items)`	Ir	do
`printf formatstring items`	Unix	do
`formatstring % (items)`	Pitón , Ruby	do
`formatstring.format(items)`	Pitón	.NETO
`fformatstring`	Python 3
`Printf.sprintf formatstring`^[21] `items`	OCaml , F#	do
`Text.Printf.printf formatstring items`	Haskell (GHC)	do
`formatstring printf: items`	Charla informal	do
`String.format(formatstring, items)`	Java	do
`String.Format(formatstring, items)`	VB.NET , C# , F#	.NETO
`(format formatstring items)`	Esquema (SRFI 28)	Ceceo
`(format nil formatstring items)`	Ceceo común	Ceceo
`(format formatstring items)`	Clojure	Ceceo
`formatstring -f items`	Windows PowerShell	.NETO
`[NSString stringWithFormat:formatstring, items]`	Objective-C ( `NSString *`solamente)	do
`String(format:formatstring, items)`	Swift (Fundación)	do
`string.format(formatstring, items)` `(formatstring):format(items)`	Lua	do
`WRITE (outputstring, formatstring) items`	Fortran	Fortran
`put string(string) edit(items)(format)`	PL/Yo	PL/I (similar a Fortran)
`String.format(formatstring, items)`	Cobra	.NETO
`format formatstring items`	Tcl	do
`formatnumbers ⍕ items` `formatstring ⎕FMT items`	APL	APL
`format!(formatstring, items)`	Óxido ^[22]	Pitón

// Ejemplo en C# String . Format ( "Mi {0} cuesta {1:C2}" , "bolígrafo" , 19,99 ); // devuelve "Mi bolígrafo cuesta $19,99"

// Ejemplo en formato Object Pascal (Delphi) ( 'Mi %s cuesta $%2f' , [ 'bolígrafo' , 1 9,99 ]) ; // devuelve "Mi bolígrafo cuesta $19,99"

// Ejemplo en Java String . format ( "Mi %s cuesta $%2f" , "bolígrafo" , 19,99 ); // devuelve "Mi bolígrafo cuesta $19,99"

# Ejemplos en Raku sprintf  "Mi %s cuesta \$%.2f" , "bolígrafo" , 19.99 ; # devuelve "Mi bolígrafo cuesta $19.99" 1 . fmt ( "%04d" ); # devuelve "0001"

# Ejemplo en Python "Mi %s cuesta $ %.2f "  %  ( "bolígrafo" ,  19.99 );  # devuelve "Mi bolígrafo cuesta $19.99" "Mi {0} cuesta $ {1:.2f} " . format ( "bolígrafo" ,  19.99 );  # devuelve "Mi bolígrafo cuesta $19.99"

#Ejemplo en Python 3.6+ pen  =  "pen" f "Mi { pen } cuesta { 19,99 } "  #devuelve "Mi bolígrafo cuesta 19,99"

; Ejemplo en Scheme ( formato "Mi ~a cuesta $~1,2F" "pluma" 19,99 ) ; devuelve "Mi pluma cuesta $19,99"

/* ejemplo en PL/I */ put string ( some_string ) edit ( ' Mi ' , ' bolígrafo ' , ' cuesta ' , 19.99 )( a , a , a , p ' $$$V .99 ' ) /* devuelve "Mi bolígrafo cuesta $19.99" */

Desigualdad

Comprueba si dos cadenas no son iguales. Véase también #Igualdad.

Formato	Idiomas
`string₁ ne string₂` `string₁ NE string₂`	ALGOL 68 – nota: el operador “ ne ” está literalmente en negrita .
`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 (obsoleto)
`string₁ # string₂`	BASIC (algunas implementaciones)
`string₁ ne string₂`	Perl , Raku
`(string<> string₁ string₂)`	Esquema (SRFI 13)
`(string/= string₁ string₂)`	Ceceo común
`(string/= string₁ string₂)`	ISLISP
`(not= string₁ string₂)`	Clojure
`string₁ != string₂`	C++ (STL), C# , Go , JavaScript (no similar), PHP (no similar), Python , Ruby , Rust , ^[10] Swift , D , Mathematica
`string₁ !== string₂`	JavaScript , PHP
`string₁ \= string₂`	Rexx
`string₁ ¬= string₂`	PL/Yo
`test string₁ != string₂` `[ string₁ != string₂ ]`	Concha Bourne
`string₁ -ne string₂` `-not [string]::Equals(string₁, string₂)`	Windows PowerShell
`string₁ ~= string₂`	Lua , Smalltalk
`string₁ ≢ string₂`	APL
`string₁.ne(string₂)`	Óxido ^[10]

// Ejemplo en C# "hola" != "mundo" // devuelve verdadero

' Ejemplo en Visual Basic "hola" <> "mundo" ' devuelve verdadero

;; Ejemplo en Clojure ( not= "hola" "mundo" ) ; ⇒ verdadero

# Ejemplo en Perl 5 'hola' ne 'mundo' # devuelve 1

# Ejemplo en Raku 'hola'  y  'mundo'  # devuelve Verdadero

# Ejemplo en Windows PowerShell "hola"  -ne  "mundo"  # devuelve verdadero

índice

ver #Encontrar

índice de

ver #Encontrar

instrucción

ver #Encontrar

Instrrev

ver #rfind

unirse

Definición	`join(separator, list_of_strings)`devuelve una lista de cadenas unidas con un separador
Descripción	Une la lista de cadenas en una nueva cadena, con la cadena separadora entre cada una de las subcadenas. Lo opuesto de split .
Relacionado	sprintf

Formato	Idiomas
`std.string.join(array_of_strings, separator)`	D
`string:join(list_of_strings, separator)`	Erlang
`join(separator, list_of_strings)`	Perl , PHP y 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 ^[23]
`(string-join array_of_strings separator)`	Esquema (SRFI 13)
`(format nil "~{~a~^separator~}" array_of_strings)`	Ceceo común
`(clojure.string/join separator list_of_strings)` `(apply str (interpose separator list_of_strings))`	Clojure
`strings.Join(array_of_strings, separator)`	Ir
`join(array_of_strings, separator)`	Semilla7
`String.concat separator list_of_strings`	OCaml
`String.concatWith separator list_of_strings`	ML estándar
`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"}` `array_of_strings -join separator`	Windows PowerShell
`[array_of_strings componentsJoinedByString:separator]`	Objective-C ( `NSString *`solamente)
`table.concat(table_of_strings, separator)`	Lua
`{\|String streamContents: [ :stream \| collectionOfAnything asStringOn: stream delimiter: separator ]` `collectionOfAnything joinUsing: separator`	Charla informal ( Squeak , Pharo )
`array_of_strings.join(separator«, final_separator»)`	Cobra
`sequence_of_strings.joinWithSeparator(separator)`	Swift 2.x
`1↓∊separator,¨list_of_strings`	APL

// Ejemplo en C# String . Join ( "-" , { "a" , "b" , "c" }) // "abc"

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

# Ejemplo en Perl 5 join ( '-' , ( 'a' , 'b' , 'c' )); # 'abc'

# Ejemplo en Raku <ab c> . join ( '-' ); # 'abc'

# Ejemplo en Python "-" . join ([ "a" ,  "b" ,  "c" ])  # 'abc'

# Ejemplo en Ruby [ "a" , "b" , "c" ]. join ( "-" ) # 'abc'

; Ejemplo en Scheme ( use-modules ( srfi srfi-13 )) ( string-join ' ( "a" "b" "c" ) "-" ) ; "abc"

último índice de

ver #rfind

izquierda

Definición	`left(string,n)`devuelve cadena
Descripción	Devuelve la parte izquierda n de una cadena. Si n es mayor que la longitud de la cadena, la mayoría de las implementaciones devuelven la cadena completa (existen excepciones; consulte los ejemplos de código). Tenga en cuenta que para las codificaciones de longitud variable, como UTF-8 , UTF-16 o Shift-JIS , puede ser necesario eliminar las posiciones de la cadena al final para evitar cadenas no válidas.

Formato	Idiomas
`string (string'First .. string'First + n - 1)`	Ada
`substr(string, 0, n)`	AWK (cambia cadena), Perl , PHP , Raku
`LEFT$(string,n)`	BÁSICO , VB
`left(string,n)`	VB , FreeBASIC , Ingres , Selección básica
`strncpy(string2, string, n)`	Biblioteca estándar de C
`string.substr(0,n)`	C++ (STL), Raku
`[string substringToIndex:n]`	Objective-C ( `NSString *`solamente)
`(apply str (take n string))`	Clojure
`string[0 .. n]`	D ^[24]
`string:substr(string, start, length)`	Erlang
`(subseq string 0 n)`	Ceceo común
`string[:n]`	Cobra , Go , Python
`left(string,n «,padchar»)`	Rexx , Erlang
`string[0, n]` `string[0..n - 1]`	Rubí
`string[1, n]`	Seleccione Básico
`string[ .. n]`	Semilla7
`string.Substring(0,n)`	VB .NET , C# , Windows PowerShell , F#
`leftstr(string, n)`	Pascal , Objeto Pascal ( Delphi )
`copy (string,1,n)`	Turbo Pascal
`string.substring(0,n)`	Java , ^[25] JavaScript
`(string-take string n)`	Esquema (SRFI 13)
`take n string`	Haskell
`String.extract (string, n, NONE)`	ML estándar
`String.sub string 0 n`	OCaml ^[26]
`string.[..n]`	F#
`string.sub(string, 1, n)` `(string):sub(1, n)`	Lua
`string first: n`	Charla informal ( Squeak , Pharo )
`string(:n)`	Fortran
`StringTake[string, n]`	Matemática ^[27]
`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)`	Óxido ^[28]

# Ejemplo en Raku "¡Hola!" . substr ( 0 , 6 ); # devuelve "Hola".

/* Ejemplos en Rexx */ izquierda ( "abcde" , 3 ) /* devuelve "abc" */ izquierda ( "abcde" , 8 ) /* devuelve "abcde " */ izquierda ( "abcde" , 8 , "*" ) /* devuelve "abcde***" */

; Ejemplos en Scheme ( use-modules ( srfi srfi-13 )) ( string-take "abcde" , 3 ) ; devuelve "abc" ( string-take "abcde" , 8 ) ; error

' Ejemplos en Visual Basic Izquierda ( "sandroguidi" , 3 ) ' devuelve "san" Izquierda ( "sandroguidi" , 100 ) ' devuelve "sandroguidi"

lente

ver #longitud

longitud

Definición	`length(string)`devuelve un número entero
Descripción	Devuelve la longitud de una cadena (sin contar el terminador nulo ni ninguna otra información estructural interna de la cadena). Una cadena vacía devuelve una longitud de 0.

Formato	Devoluciones	Idiomas
`string'Length`		Ada
`UPB string`		ALGOL 68
`echo "${#string_param}"`		Intento
`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 , Selección básica
`string.Length`	Número de unidades de código UTF-16	VB .NET , C# , Windows PowerShell , F#
`chars(string)` `string.chars`	Número de grafemas (NFG)	Raku
`codes(string)` `string.codes`	Número de puntos de código Unicode	Raku
`string.size OR string.length`	Número de bytes ^[29]	Rubí
`strlen(string)`	Número de bytes	C , PHP
`string.length()`		C++ (STL)
`string.length`		Cobra , D , JavaScript
`string.length()`	Número de unidades de código UTF-16	Java
`(string-length string)`		Esquema
`(length string)`		Lisp común , ISLISP
`(count string)`		Clojure
`String.length string`		OCaml
`size string`		ML estándar
`length string`	Número de puntos de código Unicode	Haskell
`string.length`	Número de unidades de código UTF-16	Objective-C ( `NSString *`solamente)
`string.characters.count`	Número de caracteres	Rápido (2.x)
`count(string)`	Número de caracteres	Rápido (1.2)
`countElements(string)`	Número de caracteres	Veloz (1.0–1.1)
`string.len(string)` `(string):len()` `#string`		Lua
`string size`		Charla informal
`LEN(string)` `LEN_TRIM(string)`		Fortran
`StringLength[string]`		Matemática
`«FUNCTION» LENGTH(string)`o `«FUNCTION» BYTE-LENGTH(string)`	número de caracteres y número de bytes, respectivamente	COBOL
`string length string`	una cadena decimal que indica el número de caracteres	Tcl
`≢ string`		APL
`string.len()`	Número de bytes	Óxido ^[30]
`string.chars().count()`	Número de puntos de código Unicode	Óxido ^[31]

// Ejemplos en C# "hola" . Longitud ; // devuelve 5 "" . Longitud ; // devuelve 0

# Ejemplos en Erlang string : len ( "hola" ). % devuelve 5 string : len ( "" ). % devuelve 0

# Ejemplos en Perl 5 length ( "hola" ); # devuelve 5 length ( "" ); # devuelve 0

# Ejemplos en Raku "🏳️‍🌈" . chars ; chars  "🏳️‍🌈" ; # ambos devuelven 1 "🏳️‍🌈" . codes ; codes  "🏳️‍🌈" ; # ambos devuelven 4 "" . chars ; chars  "" ; # ambos devuelven 0 "" . codes ; codes  "" ; # ambos devuelven 0

' Ejemplos en Visual Basic Len ( "hola" ) ' devuelve 5 Len ( "" ) ' devuelve 0

//Ejemplos en Objective-C [ @"hello" Length ] //devuelve 5 [ @"" Length ] //devuelve 0

-- Ejemplos en Lua ( "hola" ): len ()  -- devuelve 5 # ""  -- devuelve 0

localizar

ver #Encontrar

Minúsculas

Definición	`lowercase(string)`devuelve cadena
Descripción	Devuelve la cadena en minúsculas.

Formato	Idiomas
`LCase(string)`	Vb
`lcase(string)`	LibreBASIC
`lc(string)`	Perl , Raku
`string.lc`	Raku
`tolower(char)`	C ^[32]
`std.string.toLower(string)`	D
`transform(string.begin(), string.end(), result.begin(), ::tolower)`^[33]	C++ ^[34]
`lowercase(string)`	Objeto Pascal ( Delphi )
`strtolower(string)`	PHP
`lower(string)`	Semilla7
`${string_param,,}`	Intento
`echo "string" \| tr 'A-Z' 'a-z'`	Unix
`string.lower()`	Pitón
`downcase(string)`	Seleccione Básico
`string.downcase`	Rubí ^[35]
`strings.ToLower(string)`	Ir
`(string-downcase string)`	Esquema (R6RS), Common Lisp
`(lower-case string)`	Clojure
`String.lowercase string`	OCaml
`String.map Char.toLower string`	ML estándar
`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 *`solo), Swift (Foundation)
`string.lower(string)` `(string):lower()`	Lua
`string asLowercase`	Charla informal
`LOWER(string)`	SQL
`lowercase(string)`	PL/I ^[8]
`ToLowerCase[string]`	Matemática
`«FUNCTION» LOWER-CASE(string)`	COBOL
`string.toLower`	Cobra
`string tolower string`	Tcl
`string.to_lowercase()`	Óxido ^[36]

// Ejemplo en C# "¿Wiki significa rápido?" . ToLower (); // "¿wiki significa rápido?"

; Ejemplo en Scheme ( use-modules ( srfi srfi-13 )) ( string-downcase "Wiki significa rápido?" ) ; "¿wiki significa rápido?"

/* Ejemplo en C */ #include <ctype.h> #include <stdio.h> int main ( void ) { char string [] = "¿Wiki significa rápido?" ; int i ; for ( i = 0 ; i < sizeof ( string ) - 1 ; ++ i ) { /* transformar caracteres en su lugar, uno por uno */ string [ i ] = tolower ( string [ i ]); } puts ( string ); /* "¿Wiki significa rápido?" */ return 0 ; }

# Ejemplo en Raku "¿Wiki significa rápido?" . lc ; # "¿wiki significa rápido?"

medio

ver #substring

dividir

Definición	<string>.partition( separator ) devuelve la subcadena antes del separador; el separador; luego, la subcadena después del separador.
Descripción	Divide la cadena dada por el separador y devuelve las tres subcadenas que juntas forman el original.

Formato	Idiomas	Comentarios
`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	El separador no tiene por qué ser una expresión regular

# Ejemplos en Python "Huevos de spam, spam, spam y jamón" .partition ( 'spam' ) #('Huevos de spam', 'spam', 'spam y jamón') " Huevos de spam, spam, spam y jamón" .partition ( ' X' ) #('Huevos de spam, spam, spam y jamón', "", "")

# Ejemplos en Perl 5 / Raku split /(spam)/ , 'Huevos de spam, spam, spam y jamón' , 2 ; # ('Huevos de spam ', 'spam', ' spam y jamón'); split /(X)/ , 'Huevos de spam, spam, spam y jamón' , 2 ; # ('Huevos de spam, spam, spam y jamón');

reemplazar

Definición	`replace(string, find, replace)`devuelve cadena
Descripción	Devuelve una cadena con las ocurrencias de búsqueda cambiadas para reemplazar .

Formato	Idiomas
`changestr(find, string, replace)`	Rexx
`std.string.replace(string, find, replace)`	D
`Replace(string, find, replace)`	Vb
`replace(string, find, replace)`	Semilla7
`change(string, find, replace)`	Seleccione Básico
`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 ^[37]
`string.replaceAll(find_regex, replace)^[38]`	Java
`string.gsub(find, replace)`	Rubí
`string =~ s/find_regex/replace/g^[38]`	Perl 5
`string.subst(find, replace, :g)`	Raku
`string.replace(find, replace, "g") ^[39]` `string.replace(/find_regex/g, replace)^[38]`	JavaScript
`echo "string" \| sed 's/find_regex/replace/g'^[38]`	Unix
`${string_param//find_pattern/replace}`	Intento
`string.replace(find, replace)` `string -replace find_regex, replace^[38]`	Windows PowerShell
`Str.global_replace (Str.regexp_string find) replace string`	OCaml
`[string stringByReplacingOccurrencesOfString:find withString:replace]`	Objective-C ( `NSString *`solamente)
`string.stringByReplacingOccurrencesOfString(find, withString:replace)`	Swift (Fundación)
`string.gsub(string, find, replace)` `(string):gsub(find, replace)`	Lua
`string copyReplaceAll: find with: replace`	Charla informal ( Squeak , Pharo )
`string map {find replace} string`	Tcl
`StringReplace[string, find -> replace]`	Matemática
`strings.Replace(string, find, replace, -1)`	Ir
`INSPECT string REPLACING ALL/LEADING/FIRST find BY replace`	COBOL
`find_regex ⎕R replace_regex ⊢ string`	APL

// Ejemplos en C# "effffff" . Reemplazar ( "f" , "jump" ); // devuelve "ejumpjumpjumpjumpjumpjump" "blah" . Reemplazar ( "z" , "y" ); // devuelve "blah"

// Ejemplos en Java "effffff" . replace ( "f" , "jump" ); // devuelve "ejumpjumpjumpjumpjumpjump" "effffff" . replaceAll ( "f*" , "jump" ); // devuelve "ejump"

// Ejemplos  en  Raku "effffff" . subst ( "f" , "jump" , : g ); # devuelve "ejumpjumpjumpjumpjumpjump" "blah" . subst ( "z" , "y" , : g ); # devuelve "blah"

' Ejemplos en Visual Basic Reemplazar ( "effffff" , "f" , "jump" ) ' devuelve "ejumpjumpjumpjumpjumpjump" Reemplazar ( "blah" , "z" , "y" ) ' devuelve "blah"

# Ejemplos en Windows PowerShell "effffff"  -replace  "f" ,  "jump"  # devuelve "ejumpjumpjumpjumpjumpjump" "effffff"  -replace  "f*" ,  "jump"  # devuelve "ejump"

contrarrestar

Definición	`reverse(string)`
Descripción	Invierte el orden de los caracteres en la cadena.

Formato	Idiomas
`reverse string`	Perl 5, Haskell
`flip string` `string.flip`	Raku
`lists:reverse(string)`	Erlang
`strrev(string)`	PHP
`string[::-1]`	Pitón
`(string-reverse string)`	Esquema (SRFI 13)
`(reverse string)`	Ceceo común
`string.reverse`	Ruby , D (modifica cadena)
`new StringBuilder(string).reverse().toString()`	Java
`std::reverse(string.begin(), string.end());`	C++ ( `std::string`solo modifica cadena)
`StrReverse(string)`	Vb
`string.Reverse()`	Visual Basic .NET , C#
`implode (rev (explode string))`	ML estándar
`string.split("").reverse().join("")`	JavaScript
`string.reverse(string)` `(string):reverse()`	Lua
`string reverse`	Charla informal
`StringReverse[string]`	Matemática
`reverse(string)`	PL/Yo
`«FUNCTION» REVERSE(string)`	COBOL
`string.toCharArray.toList.reversed.join()`	Cobra
`String(string.characters.reverse())`	Rápido (2.x)
`String(reverse(string))`	Rápido (1.2)
`string reverse string`	Tcl
`⌽string`	APL
`string.chars().rev().collect::<String>()`	Óxido ^[40]
`echo string \| rev`	Unix

" Ejemplo en Smalltalk " 'hola'  invertido  " devuelve 'olleh' "

# Ejemplo en Perl 5 que invierte "hola" # devuelve "olleh"

# Ejemplo en Raku "hola" . flip  # devuelve "olleh"

# Ejemplo en Python "hola" [:: - 1 ]  # devuelve "olleh"

; Ejemplo en Scheme ( use-modules ( srfi srfi-13 )) ( string-reverse "hola" ) ; devuelve "olleh"

encontrar

Definición	`rfind(string,substring)`devuelve un entero
Descripción	Devuelve la posición del inicio de la última aparición de la subcadena en la cadena . Si no se encuentra la subcadena , la mayoría de estas rutinas devuelven un valor de índice no válido (-1 cuando los índices están basados en 0, 0 cuando están basados en 1) o algún valor que se debe interpretar como booleano FALSO.
Relacionado	instrucción

Formato	Idiomas	Si no se encuentra
`InStrRev(«startpos,» string,substring)`	Vb	devuelve 0
`instrrev(«startpos,» string,substring)`	LibreBASIC	devuelve 0
`rindex(string,substring«,startpos»)`	Perl 5	devuelve −1
`rindex(string,substring«,startpos»)` `string.rindex(substring«,startpos»)`	Raku	devuelve cero
`strrpos(string,substring«,startpos»)`	PHP	devuelve FALSO
`string.rfind(substring«,startpos»)`	C++ (STL)	devuelve std::string::npos
`std.string.rfind(string, substring)`	D	devuelve −1
`string.rfind(substring«,startpos«, endpos»»)`	Pitón	devuelve −1
`string.rindex(substring«,startpos«, endpos»»)`	Pitón	genera ValueError
`rpos(string, substring«,startpos»)`	Semilla7	devuelve 0
`string.rindex(substring«,startpos»)`	Rubí	devuelve cero
`strings.LastIndex(string, substring)`	Ir	devuelve −1
`string.lastIndexOf(substring«,startpos»)`	Java , JavaScript	devuelve −1
`string.LastIndexOf(substring«,startpos«, charcount»»)`	VB .NET , C# , Windows PowerShell , F#	devuelve −1
`(search substring string :from-end t)`	Ceceo común	devuelve NIL
`[string rangeOfString:substring options:NSBackwardsSearch].location`	Objective-C ( `NSString *`solamente)	devuelve NSNotFound
`Str.search_backward (Str.regexp_string substring) string (Str.length string - 1)`	OCaml	genera Not_found
`string.match(string, '.()'..substring)` `string:match('.()'..substring)`	Lua	devuelve cero
`Ada.Strings.Unbounded.Index(Source => string, Pattern => substring, Going => Ada.Strings.Backward)`	Ada	devuelve 0
`string.lastIndexOf(substring«,startpos«, charcount»»)`	Cobra	devuelve −1
`string lastIndexOfString:substring`	Charla informal	devuelve 0
`string last substring string startpos`	Tcl	devuelve −1
`(⌽<\⌽substring⍷'string')⍳1`	APL	devuelve −1
`string.rfind(substring)`	Óxido ^[41]	devuelve Ninguno

; Ejemplos en Common Lisp ( buscar "e" "Hola amigo" :from-end t ) ; devuelve 9 ( buscar "z" "palabra" :from-end t ) ; devuelve NIL

// Ejemplos en C# "Hola amigo" . LastIndexOf ( "e" ); // devuelve 9 "Hola amigo" . LastIndexOf ( "e" , 4 ); // devuelve 1 "palabra" . LastIndexOf ( "z" ); // devuelve -1

# Ejemplos en Perl 5 rindex ( "Hola amigo" , "e" ); # devuelve 9 rindex ( "Hola amigo" , "e" , 4 ); # devuelve 1 rindex ( "palabra" , "z" ); # devuelve -1

# Ejemplos en Raku "Hola amigo" . rindex ( "e" ); # devuelve 9 "Hola amigo" . rindex ( "e" , 4 ); # devuelve 1 "palabra" . rindex ( 'z' ); # devuelve Nil

' Ejemplos en Visual Basic InStrRev ( "Hola amigo" , "e" ) ' devuelve 10 InStrRev ( 5 , "Hola amigo" , "e" ) ' devuelve 2 InStrRev ( "word" , "z" ) ' devuelve 0

bien

Definición	`right(string,n)`devuelve cadena
Descripción	Devuelve la parte n derecha de una cadena. Si n es mayor que la longitud de la cadena, la mayoría de las implementaciones devuelven la cadena completa (existen excepciones; consulte los ejemplos de código).

Formato	Idiomas
`string (string'Last - n + 1 .. string'Last)`	Ada
`Right(string,n)`	Vb
`RIGHT$(string,n)`	BÁSICO
`right(string,n)`	FreeBASIC , Ingres , Selección básica
`strcpy(string2, string+n)`(n no debe ser mayor que la longitud de la cadena )	do
`string.Substring(string.Length()-n)`	DO#
`string[len(string)-n:]`	Ir
`string.substring(string.length()-n)`	Java
`string.slice(-n)`	JavaScript ^[42]
`right(string,n «,padchar»)`	Rexx , Erlang
`substr(string,-n)`	Perl 5, PHP
`substr(string,-n)` `string.substr(-n)`	Raku
`string[-n:]`	Cobra , pitón
`${string_param: -n}`(tenga en cuenta el espacio después de los dos puntos)	Intento
`string[n]`	Seleccione Básico
`(string-take-right string n)`	Esquema (SRFI 13)
`string[-n..-1]`	Rubí
`string[$-n .. $]`	D ^[43]
`String.sub string (String.length string - n) n`	OCaml ^[26]
`string.sub(string, -n)` `(string):sub(-n)`	Lua
`string last: n`	Charla informal ( Squeak , Pharo )
`StringTake[string, -n]`	Matemática ^[27]
`string (1:n)`	COBOL
`¯n↑string.`	APL
`string[n..]` `string.get(n..)`	Óxido ^[28]

// Ejemplos en Java; extrae los 4 caracteres más a la derecha String str = "CarDoor" ; str . substring ( str . length () - 4 ); // devuelve 'Door'

# Ejemplos en Raku "abcde" . substr (*- 3 ); # devuelve "cde" "abcde" . substr (*- 8 ); # error 'fuera de rango'

/* Ejemplos en Rexx */ derecha ( "abcde" , 3 ) /* devuelve "cde" */ derecha ( "abcde" , 8 ) /* devuelve " abcde" */ derecha ( "abcde" , 8 , "*" ) /* devuelve "***abcde" */

; Ejemplos en Scheme ( use-modules ( srfi srfi-13 )) ( string-take-right "abcde" , 3 ) ; devuelve "cde" ( string-take-right "abcde" , 8 ) ; error

' Ejemplos en Visual Basic Derecha ( "sandroguidi" , 3 ) ' devuelve "idi" Derecha ( "sandroguidi" , 100 ) ' devuelve "sandroguidi"

partición

Definición	<string>.rpartition( separator ) Busca el separador de derecha a izquierda dentro de la cadena y luego devuelve la subcadena antes del separador; el separador; luego, la subcadena después del separador.
Descripción	Divide la cadena dada por el separador más a la derecha y devuelve las tres subcadenas que juntas forman el original.

Formato	Idiomas
`string.rpartition(separator)`	Pitón , Ruby

# Ejemplos en Python "Huevos de spam, spam, spam y jamón" . rpartition ( 'spam' )  ### ('Huevos de spam, spam ', 'spam', ' y jamón') "Huevos de spam, spam, spam y jamón" . rpartition ( 'X' )  ### ("", "", 'Huevos de spam, spam, spam y jamón')

rebanada

ver #substring

dividir

Definición	<string>.split( separator [, limit ]) divide una cadena en el separador, opcionalmente solo hasta un número limitado de subcadenas
Descripción	Divide la cadena dada por las ocurrencias del separador (que es una cadena en sí misma) y devuelve una lista (o matriz) de las subcadenas. Si se proporciona un límite , después de que se hayan leído los separadores limit – 1, el resto de la cadena se convierte en la última subcadena, independientemente de si tiene algún separador en ella. Las implementaciones de Scheme y Erlang son similares, pero difieren en varios aspectos. JavaScript también se diferencia en que corta, no coloca el resto de la cadena en el último elemento. Vea el ejemplo aquí. La implementación de Cobra utilizará espacios en blanco de forma predeterminada. Lo opuesto de join .

Formato	Idiomas
`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»)`	Pitón
`string.split(separator«, limit»)`	JavaScript , Java , Ruby
`string:tokens(string, sepchars)`	Erlang
`strings.Split(string, separator)` `strings.SplitN(string, separator, limit)`	Ir
`(string-tokenize string« charset« start« end»»»)`	Esquema (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 *`solamente)
`string.componentsSeparatedByString(separator)`	Swift (Fundación)
`TStringList.Delimiter, TStringList.DelimitedText`	Objeto Pascal
`StringSplit[string, separator«, limit»]`	Matemática
`string.split«(sepchars«, limit«, options»»)»`	Cobra
`split string separator`	Tcl
`(separator≠string)⊂string`en APL2 en Dyalog APL 16.0 `separator(≠⊆⊢)string`	APL
`string.split(separator)` `string.split(limit, separator)`	Óxido ^[44]

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

% Ejemplo en cadena Erlang : tokens ( "abc;defgh;ijk" , ";" ). % ["abc", "defgh", "ijk"]

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

{ Ejemplo en Pascal } var lStrings : TStringList ; lStr : cadena ; 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 ;

# Ejemplos en Perl 5 split ( /spam/ , 'Huevos de spam, spam, spam y jamón' ); # ('Huevos de spam ', ' ', ' y jamón') split ( /X/ , 'Huevos de spam, spam, spam y jamón' ); # ('Huevos de spam, spam, spam y jamón')

# Ejemplos en Raku 'Huevos de spam, spam, spam y jamón' . split ( /spam/ ); # (Huevos de spam y jamón) split ( /X/ , 'Huevos de spam, spam, spam y jamón' ); # (Huevos de spam, spam, spam y jamón)

sprintf

ver #Formato

banda

ver #recortar

cadena

ver #Comparar (resultado entero)

subcadena

Definición	`substring(string, startpos, endpos)`devuelve cadena devuelve cadena `substr(string, startpos, numChars)`
Descripción	Devuelve una subcadena de cadena que comienza en startpos y endpos , o comienza en startpos con una longitud de numChars . La cadena resultante se trunca si hay menos de numChars caracteres más allá del punto de inicio. endpos representa el índice después del último carácter en la subcadena. Tenga en cuenta que para codificaciones de longitud variable como UTF-8 , UTF-16 o Shift-JIS , puede ser necesario eliminar posiciones de cadena al final, para evitar cadenas no válidas.

Formato	Idiomas
`string[startpos:endpos]`	ALGOL 68 (cambia el índice base)
`string (startpos .. endpos)`	Ada (cambia el índice base)
`Mid(string, startpos, numChars)`	Vb
`mid(string, startpos, numChars)`	LibreBASIC
`string[startpos+(⍳numChars)-~⎕IO]`	APL
`MID$(string, startpos, numChars)`	BÁSICO
`substr(string, startpos, numChars)`	AWK (cambia cadena), Perl 5, ^[45]^[46] PHP ^[45]^[46]
`substr(string, startpos, numChars)` `string.substr(startpos, numChars)`	Raku ^[47]^[48]
`substr(string, startpos «,numChars, padChar»)`	Rexx
`string[startpos:endpos]`	Cobra , Python , ^[45]^[49] Ir
`string[startpos, numChars]`	Seleccione Básico
`string[startpos, numChars]` `string[startpos .. endpos-1]` `string[startpos ... endpos]`	Rubí ^[45]^[49]
`string[startpos .. endpos]` `string[startpos len numChars]`	Semilla7
`string.slice(startpos«, endpos»)`	JavaScript ^[45]^[49]
`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)`	Objeto Pascal ( Delphi )
`(substring string startpos endpos)`	Esquema
`(subseq string startpos endpos)`	Ceceo común
`(subseq string startpos endpos)`	ISLISP
`String.sub string startpos numChars`	OCaml
`substring (string, startpos, numChars)`	ML estándar
`string:sub_string(string, startpos, endpos)` `string:substr(string, startpos, numChars)`	Erlang
`strncpy(result, string + startpos, numChars);`	do
`string[startpos .. endpos+1]`	D
`take numChars $ drop startpos string`	Haskell
`[string substringWithRange:NSMakeRange(startpos, numChars)]`	Objective-C ( `NSString *`solamente)
`string.[startpos..endpos]`	F#
`string.sub(string, startpos, endpos)` `(string):sub(startpos, endpos)`	Luna ^[45]^[49]
`string copyFrom: startpos to: endpos`	Charla informal
`string(startpos:endpos)`	Fortran
`SUBSTRING(string FROM startpos «FOR numChars»)`	SQL
`StringTake[string, {startpos, endpos}]`	Matemática ^[45]^[49]
`string (startpos:numChars)`	COBOL
`${string_param:startpos:numChars}`	Intento
rango de cadena cadena pos.inicio pos.final	Tcl
`string[startpos..endpos]` `string.get(startpos..endpos)`	Óxido ^[28]

// Ejemplos en C# "abc" . Substring ( 1 , 1 ): // devuelve "b" "abc" . Substring ( 1 , 2 ); // devuelve "bc" "abc" . Substring ( 1 , 6 ); // error

;; Ejemplos en Common Lisp ( subseq "abc" 1 2 ) ; devuelve "b" ( subseq "abc" 2 ) ; devuelve "c"

% Ejemplos en Erlang cadena : substr ( "abc" , 2 , 1 ). % devuelve "b" cadena : substr ( "abc" , 2 ). % devuelve "bc"

# Ejemplos en Perl 5 substr ( "abc" , 1 , 1 ); # devuelve "b" substr ( "abc" , 1 ); # devuelve "bc"

# Ejemplos en Raku "abc" . substr ( 1 , 1 ); # devuelve "b" "abc" . substr ( 1 ); # devuelve "bc"

# Ejemplos en Python "abc" [ 1 : 2 ]  # devuelve "b" "abc" [ 1 : 3 ]  # devuelve "bc"

/* Ejemplos en Rexx */ substr ( "abc" , 2 , 1 ) /* devuelve "b" */ substr ( "abc" , 2 ) /* devuelve "bc" */ substr ( "abc" , 2 , 6 ) /* devuelve "bc " */ substr ( "abc" , 2 , 6 , "*" ) /* devuelve "bc****" */

Mayúsculas

Definición	`uppercase(string)`devuelve cadena
Descripción	Devuelve la cadena en mayúsculas.

Formato	Idiomas
`UCase(string)`	Vb
`ucase(string)`	LibreBASIC
`toupper(string)`	AWK (cambia la cadena)
`uc(string)`	Perl , Raku
`string.uc`	Raku
`toupper(char)`	C (opera sobre un caracter)
`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 (matriz de cadenas/caracteres)
`std.string.toUpper(string)`	D
`transform(string.begin(), string.end(), result.begin(), toupper)^[33]`	C++ ^[50]
`uppercase(string)`	Objeto Pascal ( Delphi )
`upcase(char)`	Objeto Pascal ( Delphi ) (opera sobre un carácter)
`strtoupper(string)`	PHP
`upper(string)`	Semilla7
`${string_param^^}`(mnemónico: ^ apunta hacia arriba)	Intento
`echo "string" \| tr 'a-z' 'A-Z'`	Unix
`translate(string)` `UPPER variables` `PARSE UPPER VAR SrcVar DstVar`	Rexx
`string.upper()`	Pitón
`upcase(string)`	Seleccione Básico
`string.upcase`	Rubí ^[35]
`strings.ToUpper(string)`	Ir
`(string-upcase string)`	Esquema , Common Lisp
`String.uppercase string`	OCaml
`String.map Char.toUpper string`	ML estándar
`map Char.toUpper string`	Haskell
`string.toUpperCase()`	Java , JavaScript
`string.uppercase()`	Kotlin ^[51]
`to_upper(string)`	Erlang
`string.ToUpper()`	VB .NET , C# , Windows PowerShell , F#
`string.uppercaseString`	Objective-C ( `NSString *`solo), Swift (Foundation)
`string.upper(string)` `(string):upper()`	Lua
`string asUppercase`	Charla informal
`UPPER(string)`	SQL
`ToUpperCase[string]`	Matemática
`«FUNCTION» UPPER-CASE(string)`	COBOL
`string.toUpper`	Cobra
`string toupper string`	Tcl
`string.to_uppercase()`	Óxido ^[52]

// Ejemplo en C# "¿Wiki significa rápido?" . ToUpper (); // "¿WIKI SIGNIFICA RÁPIDO?"

# Ejemplo en Perl 5 uc ( "¿Wiki significa rápido?" ); # "¿WIKI SIGNIFICA RÁPIDO?"

# Ejemplo en Raku uc ( "¿Wiki significa rápido?" ); # "¿WIKI SIGNIFICA RÁPIDO?" "¿Wiki significa rápido?" . uc ; # "¿WIKI SIGNIFICA RÁPIDO?"

/* Ejemplo en Rexx */ translate ( "¿Wiki significa rápido?" ) /* "¿WIKI SIGNIFICA RÁPIDO?" */ /* Ejemplo n.° 2 */
A = 'Este es un ejemplo'.  A
MAYÚSCULA /* "ESTE ES UN EJEMPLO." */ /* Ejemplo n.° 3 */
A = 'upper usando la función de traducción'.
Traducir  UPPER  VAR  A  Z /* Z="UPPER USANDO LA FUNCIÓN DE TRADUCCIÓN". */

; Ejemplo en Scheme ( use-modules ( srfi srfi-13 )) ( string-upcase "¿Wiki significa rápido?" ) ; "¿WIKI SIGNIFICA RÁPIDO?"

' Ejemplo en Visual Basic UCase ( "¿Wiki significa rápido?" ) ' "¿WIKI SIGNIFICA RÁPIDO?"

recortar

trimo stripse utiliza para eliminar espacios en blanco del principio, del final o de ambos, de una cadena.

Ejemplo de uso	Idiomas
`String.Trim([chars])`	C# , VB.NET , Windows PowerShell
`string.strip();`	D
`(.trim string)`	Clojure
`sequence [ predicate? ] trim`	Factor
`(string-trim '(#\Space #\Tab #\Newline) string)`	Ceceo común
`(string-trim string)`	Esquema
`string.trim()`	Java , JavaScript (1.8.1+, Firefox 3.5+), Rust ^[53]
`Trim(String)`	Pascal , ^[54] QBasic , Visual Basic , Delphi
`string.strip()`	Pitón
`strings.Trim(string, chars)`	Ir
`LTRIM(RTRIM(String))`	Oracle SQL , T-SQL
`strip(string [,option, char])`	Rexxo
`string:strip(string [,option, char])`	Erlang
`string.strip` `string.lstrip` `string.rstrip`	Rubí
`string.trim`	Raku
`trim(string)`	PHP , Raku
`[string stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]`	Objective-C usando Cocoa
`string withBlanksTrimmed` `string withoutSpaces` `string withoutSeparators`	Charla informal (Squeak, Pharo) Charla informal
`strip(string)`	SAS
`string trim $string`	Tcl
`TRIM(string)` `TRIM(ADJUSTL(string))`	Fortran
`TRIM(string)`	SQL
`TRIM(string)` `LTrim(string)` `RTrim(String)`	Fusión fría
`String.trim string`	OCaml 4+

Otros idiomas

En los idiomas que no tienen una función de recorte incorporada, suele ser sencillo crear una función personalizada que realice la misma tarea.

APL

APL puede utilizar expresiones regulares directamente:

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

Como alternativa, un enfoque funcional que combina máscaras booleanas que filtran los espacios iniciales y finales:

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

O invertir y eliminar los espacios iniciales, dos veces:

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

AWK

En AWK , se pueden usar expresiones regulares para recortar:

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

o:

 función  ltrim ( s )  {  sub ( /^[\t]+/ ,  "" ,  s );  devuelve  s  }  función  rtrim ( s )  {  sub ( /[\t]+$/ ,  "" ,  s );  devuelve  s  }  función  trim ( s )  {  devuelve  rtrim ( ltrim ( s ));  }

C/C++

No existe una función de recorte estándar en C o C++. La mayoría de las bibliotecas de cadenas disponibles ^[55] para C contienen código que implementa el recorte o funciones que facilitan significativamente una implementación eficiente. La función también se ha denominado EatWhitespace en algunas bibliotecas de C no estándar.

En C, los programadores a menudo combinan ltrim y rtrim para implementar trim:

#include <cadena.h> #include <ctype.h>  void rtrim ( char * str ) { char * s ; s = str + strlen ( str ); mientras ( --s >= str ) { si ( ! isspace ( * s ) ) romper ; * s = 0 ; } }                     void ltrim ( char * str ) { tamaño_t n ; n = 0 ; mientras ( 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 ); }

La biblioteca C++ de código abierto Boost tiene varias variantes de ajuste, incluida una estándar: ^[56]

#include <boost/algoritmo/cadena/trim.hpp> recortado = boost :: algoritmo :: trim_copy ( "cadena" );

Con la función boost nombrada simplemente, trimla secuencia de entrada se modifica en el lugar y no devuelve ningún resultado.

Otra biblioteca C++ de código abierto , Qt , tiene varias variantes de ajuste, incluida una estándar: ^[57]

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

El núcleo Linux también incluye una función strip, strstrip()desde la versión 2.6.18-rc1, que recorta la cadena "en su lugar". Desde la versión 2.6.33-rc1, el núcleo utiliza strim()en lugar de strstrip()para evitar falsas advertencias. ^[58]

Haskell

Un algoritmo de recorte en Haskell :

 importar Data.Char ( isSpace ) trim :: String - > String trim = f.f donde f = reverse.dropWhile isSpace

Puede interpretarse de la siguiente manera: f elimina el espacio en blanco anterior e invierte la cadena. Luego, f se aplica nuevamente a su propia salida. Tenga en cuenta que la firma de tipo (la segunda línea) es opcional.

Yo

El algoritmo de recorte en J es una descripción funcional :

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

Es decir: filtrar ( #~) para caracteres que no sean espacios ( ' '&~:) entre espacios iniciales ( +./\) y ( *.) finales ( +./\.).

JavaScript

Hay una función de recorte incorporada en JavaScript 1.8.1 (Firefox 3.5 y posteriores) y en el estándar ECMAScript 5. En versiones anteriores, se puede agregar al prototipo del objeto String de la siguiente manera:

Cadena . prototipo . trim = función () { devolver esto . reemplazar ( /^\s+/g , "" ). reemplazar ( /\s+$/g , "" ); };

Perl

Perl 5 no tiene una función de recorte incorporada. Sin embargo, la funcionalidad se logra comúnmente mediante expresiones regulares .

Ejemplo:

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

or:

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

These examples modify the value of the original variable $string.

Also available for Perl is StripLTSpace in String::Strip from 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:

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

Tcl

The Tcl string 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:

set string onomatopoeiaset trimmed [string trim $string aeiou] ;# result is nomatopset r_trimmed [string trimright $string aeiou] ;# result is onomatopset l_trimmed [string trimleft $string aeiou] ;# result is nomatopoeia

XSLT

XSLT includes the function normalize-space(string) which strips leading and trailing whitespace, in addition to replacing any whitespace sequence (including line breaks) with a single space.

Example:

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

XSLT 2.0 includes regular expressions, providing another mechanism to perform string trimming.

Another XSLT technique for trimming is to utilize the XPath 2.0 substring() function.

References

^ a b c d e the index can be negative, which then indicates the number of places before the end of the string.
^ In Rust, the str::chars method iterates over code points and the std::iter::Iterator::nth method on iterators returns the zero-indexed nth value from the iterator, or None.
^ the index can not be negative, use *-N where N indicate the number of places before the end of the string.
^ In C++, the overloaded operator<=> method on a string returns a std::strong_ordering object (otherwise std::weak_ordering): less, equal (same as equivalent), or greater.
^ returns LESS, EQUAL, or GREATER
^ returns LT, EQ, or GT
^ returns .TRUE. or .FALSE.. These functions are based on the ASCII collating sequence.
^ a b IBM extension.
^ In Rust, the Ord::cmp method on a string returns an Ordering: Less, Equal, or Greater.
^ a b c d e f In Rust, the operators == and != and the methods eq, ne are implemented by the PartialEq trait, and the operators <, >, <=, >= and the methods lt, gt, le, ge are implemented by the PartialOrd trait.
^ The operators use the compiler's default collating sequence.
^ modifies string₁, which must have enough space to store the result
^ In Rust, the + operator is implemented by the Add trait.
^ See the str::contains method.
^ See the std::basic_string::contains method.
^ a b startpos is IBM extension.
^ a b See the str::find method.
^ startpos is IBM extension.
^ "scan in Fortran Wiki". Fortranwiki.org. 2009-04-30. Retrieved 2013-08-18.
^ "verify in Fortran Wiki". Fortranwiki.org. 2012-05-03. Retrieved 2013-08-18.
^ formatstring must be a fixed literal at compile time for it to have the correct type.
^ See std::format, which is imported by the Rust prelude so that it can be used under the name format.
^ See the slice::join method.
^ if n is larger than the length of the string, then in Debug mode ArrayRangeException is thrown, in Release mode, the behaviour is unspecified.
^ if n is larger than the length of the string, Java will throw an IndexOutOfBoundsException
^ a b if n is larger than length of string, raises Invalid_argument
^ a b if n is larger than length of string, throw the message "StringTake::take:"
^ a b c In Rust, strings are indexed in terms of byte offsets and there is a runtime panic if the index is out of bounds or if it would result in invalid UTF-8. A &str (string reference) can be indexed by various types of ranges, including Range (0..n), RangeFrom (n..), and RangeTo (..n) because they all implement the SliceIndex trait with str being the type being indexed. The str::get method is the non-panicking way to index. It returns None in the cases in which indexing would panic.
^ Ruby lacks Unicode support
^ See the str::len method.
^ In Rust, the str::chars method iterates over code points and the std::iter::Iterator::count method on iterators consumes the iterator and returns the total number of elements in the iterator.
^ operates on one character
^ a b The transform function exists in the std:: namespace. You must include the <algorithm> header file to use it. The tolower and toupper functions are in the global namespace, obtained by the <ctype.h> header file. The std::tolower and std::toupper names are overloaded and cannot be passed to std::transform without a cast to resolve a function overloading ambiguity, e.g. std::transform(string.begin(), string.end(), result.begin(), (int (*)(int))std::tolower);
^ std::string only, result is stored in string result which is at least as long as string, and may or may not be string itself
^ a b only ASCII characters as Ruby lacks Unicode support
^ See the str::to_lowercase method.
^ See the str::replace method.
^ a b c d e The "find" string in this construct is interpreted as a regular expression. Certain characters have special meaning in regular expressions. If you want to find a string literally, you need to quote the special characters.
^ third parameter is non-standard
^ In Rust, the str::chars method iterates over code points, the std::iter::Iterator::rev method on reversible iterators (std::iter::DoubleEndedIterator) creates a reversed iterator, and the std::iter::Iterator::collect method consumes the iterator and creates a collection (which here is specified as a String with the turbofish syntax) from the iterator's elements.
^ See the str::rfind method.
^ "Annotated ES5". Es5.github.com. Archived from the original on 2013-01-28. Retrieved 2013-08-18.
^ if n is larger than length of string, then in Debug mode ArrayRangeException is thrown, and unspecified behaviour in Release mode
^ See the str::split and str::rsplit methods.
^ a b c d e f g startpos can be negative, which indicates to start that number of places before the end of the string.
^ ab numCharspuede ser negativo, lo que indica que debe terminar ese número de lugares antes del final de la cadena.
^ nostartpos puede ser negativo, utilice * - startpos para indicar que se debe iniciar ese número de lugares antes del final de la cadena.
^ nonumChars puede ser negativo, utilice * - numChars para indicar que debe terminar ese número de lugares antes del final de la cadena.
^ abcde endpospuede ser negativo, lo que indica que debe terminar ese número de lugares antes del final de la cadena.
^ std::string solamente, el resultado se almacena en la cadena resultado que es al menos tan larga como la cadena y puede o no ser la cadena misma
^ "mayúsculas - Lenguaje de programación Kotlin". Kotlin . Consultado el 9 de noviembre de 2024 .
^ En Rust, el método str::to_uppercase devuelve una cadena recién asignada con todos los caracteres en minúscula cambiados a mayúsculas siguiendo las reglas Unicode.
^ En Rust, el método str::trim devuelve una referencia al original &str.
^ "Recortar - GNU Pascal priručnik". Gnu-pascal.de . Consultado el 24 de agosto de 2013 .
^ "Comparación de bibliotecas de cadenas". And.org . Consultado el 24 de agosto de 2013 .
^ "Uso – 1.54.0". Boost.org. 22 de mayo de 2013. Consultado el 24 de agosto de 2013 .
^ [1] Archivado el 2 de agosto de 2009 en Wayback Machine.
^ dankamongmen. "sprezzos-kernel-packaging/changelog en master · dankamongmen/sprezzos-kernel-packaging · GitHub". Github.com . Consultado el 29 de mayo de 2016 .

[at1-1] the index can be negative, which then indicates the number of places before the end of the string.

[2] In Rust, the str::chars method iterates over code points and the std::iter::Iterator::nth method on iterators returns the zero-indexed nth value from the iterator, or None.

[at2-3] the index can not be negative, use *-N where N indicate the number of places before the end of the string.

[4] In C++, the overloaded operator<=> method on a string returns a std::strong_ordering object (otherwise std::weak_ordering): less, equal (same as equivalent), or greater.

[5] returns LESS, EQUAL, or GREATER

[6] returns LT, EQ, or GT

[7] returns .TRUE. or .FALSE.. These functions are based on the ASCII collating sequence.

[lower1-8] IBM extension.

[9] In Rust, the Ord::cmp method on a string returns an Ordering: Less, Equal, or Greater.

[Rust_compare-10] In Rust, the operators == and != and the methods eq, ne are implemented by the PartialEq trait, and the operators <, >, <=, >= and the methods lt, gt, le, ge are implemented by the PartialOrd trait.

[11] The operators use the compiler's default collating sequence.

[12] s string₁, which must have enough space to store the result

[13] In Rust, the + operator is implemented by the Add trait.

[14] See the str::contains method.

[15] See the std::basic_string::contains method.

[contain1-16] startpos is IBM extension.

[Rust_find-17] See the str::find method.

[fc1-18] startpos is IBM extension.

[19] "scan in Fortran Wiki". Fortranwiki.org. 2009-04-30. Retrieved 2013-08-18.

[20] "verify in Fortran Wiki". Fortranwiki.org. 2012-05-03. Retrieved 2013-08-18.

[21] formatstring must be a fixed literal at compile time for it to have the correct type.

[22] See std::format, which is imported by the Rust prelude so that it can be used under the name format.

[23] See the slice::join method.

[24] s larger than the length of the string, then in Debug mode ArrayRangeException is thrown, in Release mode, the behaviour is unspecified.

[25] s larger than the length of the string, Java will throw an IndexOutOfBoundsException

[ReferenceA-26] s larger than length of string, raises Invalid_argument

[ReferenceB-27] s larger than length of string, throw the message "StringTake::take:"

[Rust_indexing-28] In Rust, strings are indexed in terms of byte offsets and there is a runtime panic if the index is out of bounds or if it would result in invalid UTF-8. A &str (string reference) can be indexed by various types of ranges, including Range (0..n), RangeFrom (n..), and RangeTo (..n) because they all implement the SliceIndex trait with str being the type being indexed. The str::get method is the non-panicking way to index. It returns None in the cases in which indexing would panic.

[29] Ruby lacks Unicode support

[30] See the str::len method.

[31] In Rust, the str::chars method iterates over code points and the std::iter::Iterator::count method on iterators consumes the iterator and returns the total number of elements in the iterator.

[32] rates on one character

[cpptransform-33] The transform function exists in the std:: namespace. You must include the <algorithm> header file to use it. The tolower and toupper functions are in the global namespace, obtained by the <ctype.h> header file. The std::tolower and std::toupper names are overloaded and cannot be passed to std::transform without a cast to resolve a function overloading ambiguity, e.g. std::transform(string.begin(), string.end(), result.begin(), (int (*)(int))std::tolower);

[34] std::string only, result is stored in string result which is at least as long as string, and may or may not be string itself

[ReferenceC-35] y ASCII characters as Ruby lacks Unicode support

[36] See the str::to_lowercase method.

[37] See the str::replace method.

[regex-38] The "find" string in this construct is interpreted as a regular expression. Certain characters have special meaning in regular expressions. If you want to find a string literally, you need to quote the special characters.

[39] third parameter is non-standard

[40] In Rust, the str::chars method iterates over code points, the std::iter::Iterator::rev method on reversible iterators (std::iter::DoubleEndedIterator) creates a reversed iterator, and the std::iter::Iterator::collect method consumes the iterator and creates a collection (which here is specified as a String with the turbofish syntax) from the iterator's elements.

[41] See the str::rfind method.

[42] "Annotated ES5". Es5.github.com. Archived from the original on 2013-01-28. Retrieved 2013-08-18.

[43] s larger than length of string, then in Debug mode ArrayRangeException is thrown, and unspecified behaviour in Release mode

[44] See the str::split and str::rsplit methods.

[substr2-45] startpos can be negative, which indicates to start that number of places before the end of the string.

[substr4-46] numCharspuede ser negativo, lo que indica que debe terminar ese número de lugares antes del final de la cadena.

[substr5-47] startpos puede ser negativo, utilice * - startpos para indicar que se debe iniciar ese número de lugares antes del final de la cadena.

[substr6-48] numChars puede ser negativo, utilice * - numChars para indicar que debe terminar ese número de lugares antes del final de la cadena.

[substr3-49] endpospuede ser negativo, lo que indica que debe terminar ese número de lugares antes del final de la cadena.

[50] std::string solamente, el resultado se almacena en la cadena resultado que es al menos tan larga como la cadena y puede o no ser la cadena misma

[51] "mayúsculas - Lenguaje de programación Kotlin". Kotlin . Consultado el 9 de noviembre de 2024 .

[52] En Rust, el método str::to_uppercase devuelve una cadena recién asignada con todos los caracteres en minúscula cambiados a mayúsculas siguiendo las reglas Unicode.

[53] En Rust, el método str::trim devuelve una referencia al original &str.

[54] "Recortar - GNU Pascal priručnik". Gnu-pascal.de . Consultado el 24 de agosto de 2013 .

[55] "Comparación de bibliotecas de cadenas". And.org . Consultado el 24 de agosto de 2013 .

[56] "Uso – 1.54.0". Boost.org. 22 de mayo de 2013. Consultado el 24 de agosto de 2013 .

[57] [1] Archivado el 2 de agosto de 2009 en Wayback Machine.

[58] . "sprezzos-kernel-packaging/changelog en master · dankamongmen/sprezzos-kernel-packaging · GitHub". Github.com . Consultado el 29 de mayo de 2016 .