Introducción
Las cadenas son útiles para almacenar datos que se pueden representar como texto. Algunas de las operaciones más comunes con cadenas son comprobar su longitud, construirlas y concatenarlas mediante los operadores de cadena + y +=, comprobar la existencia o ubicación de subcadenas con el método indexOf() o extraerlas con el método substring().
Creando cadenas
Las cadenas se pueden crear de forma primitiva, a partir del literal de cadena, o como objetos utilizando el constructor String():
const string1 = "A string primitive";
const string2 = 'Also a string primitive';
const string3 = `Yet another string primitive`;const string4 = new String("A String object");
Las primitivas de cadena y los objetos de cadena comparten muchos comportamientos comunes, pero también presentan otras diferencias y advertencias importantes. Consulte "Primitivas de cadena y objetos de cadena" a continuación.
Los literales de cadena se pueden especificar mediante comillas simples o dobles, que se tratan de la misma manera, o mediante el carácter de comillas invertidas `. Esta última forma especifica un patrón real: se pueden interpolar expresiones con esta forma. Para obtener más información sobre la sintaxis de los literales de cadena, consulte Sintaxis léxica.
Acceso a personajes
Hay dos maneras de acceder a un carácter en una cadena. La primera es el método charAt():
"cat".charAt(1); // gives value "a"
Otra forma es pensar en la cadena como un objeto similar a una matriz, donde los caracteres individuales corresponden a un índice numérico:
"cat"[1]; // gives value "a"
Al usar la notación de corchetes para acceder al carácter, los intentos de eliminar o asignar un valor a estas propiedades fallarán. Estas propiedades no son modificables ni configurables. (Consulte Object.defineProperty() para más información).
Comparación de cadenas
Utilice los operadores menor que y mayor que para comparar cadenas:
const a = "a";
const b = "b";
if (a < b) {
// true
console.log(`${a} is less than ${b}`);
} else if (a > b) {
console.log(`${a} is greater than ${b}`);
} else {
console.log(`${a} and ${b} are equal.`);
}Tenga en cuenta que todos los operadores de comparación, incluidos === y ==, comparan cadenas con mayúsculas y minúsculas. Una forma común de comparar cadenas con mayúsculas y minúsculas es convertir ambas a la misma letra (mayúscula o minúscula) antes de compararlas.
function areEqualCaseInsensitive(str1, str2) {
return str1.toUpperCase() === str2.toUpperCase();
}La elección de la conversión con toUpperCase() o toLowerCase() es en gran medida arbitraria, y ninguna es completamente robusta al expandirse más allá del alfabeto latino. Por ejemplo, toUpperCase() convierte las letras minúsculas alemanas ß y ss a SS, mientras que toLowerCase() informa incorrectamente que la letra turca ı no es igual a I, a menos que se use específicamente toLocaleLowerCase (“tr”).
const areEqualInUpperCase = (str1, str2) =>
str1.toUpperCase() === str2.toUpperCase();
const areEqualInLowerCase = (str1, str2) =>
str1.toLowerCase() === str2.toLowerCase();
areEqualInUpperCase("ß", "ss"); // true; should be false
areEqualInLowerCase("ı", "I"); // false; should be trueUna solución lógica y robusta para probar la igualdad sin distinción entre mayúsculas y minúsculas es utilizar la API Intl.Collator o el método de cadena localeCompare() (tienen la misma interfaz) con la opción de sensibilidad establecida en “accent” o “base”.
const areEqual = (str1, str2, locale = "en-US") =>
str1.localeCompare(str2, locale, { sensitivity: "accent" }) === 0;
areEqual("ß", "ss", "de"); // false
areEqual("ı", "I", "tr"); // trueEl método localeCompare() permite comparar cadenas de una manera similar a strcmp() – esto permite ordenar cadenas de una manera que tiene en cuenta la configuración regional.
Cadenas primitivas y objetos de cadena
Tenga en cuenta que JavaScript distingue entre objetos de cadena y valores de cadena primitivos. (Esto también aplica a valores booleanos y numéricos).
Las cadenas literales (delimitadas por comillas dobles o simples) y las cadenas devueltas por llamadas a cadenas en un contexto no constructivo (es decir, llamadas sin usar la palabra clave "new") son cadenas primitivas. En contextos donde se debe llamar a un método en una cadena primitiva o se realiza una búsqueda de propiedades, JavaScript encapsula automáticamente la cadena primitiva y, en su lugar, llama al método o realiza la búsqueda de propiedades en el objeto contenedor.
const strPrim = "foo"; // A literal is a string primitive
const strPrim2 = String(1); // Coerced into the string primitive "1"
const strPrim3 = String(true); // Coerced into the string primitive "true"
const strObj = new String(strPrim); // String with new returns a string wrapper object.
console.log(typeof strPrim); // "string"
console.log(typeof strPrim2); // "string"
console.log(typeof strPrim3); // "string"
console.log(typeof strObj); // "objectLas cadenas primitivas y los objetos de cadena también dan resultados diferentes al usar eval(). La primitiva pasada a eval se trata como código fuente. Al devolver un objeto, los objetos de cadena se tratan como cualquier otro objeto. Por ejemplo:
const s1 = "2 + 2"; // creates a string primitive
const s2 = new String("2 + 2"); // creates a String object
console.log(eval(s1)); // returns the number 4
console.log(eval(s2)); // returns the string "2 + 2"Por estas razones, el código puede fallar cuando encuentra objetos de cadena cuando espera una cadena primitiva en su lugar, aunque en general los autores no necesitan preocuparse por la distinción.
Un objeto String siempre se puede convertir a su contraparte original con el método valueOf().
console.log(eval(s2.valueOf())); // returns the number 4
Coerción de cuerdas
Muchas operaciones integradas que esperan cadenas primero convierten sus argumentos en cadenas (razón por la cual los objetos String se comportan como cadenas primitivas). Estas operaciones se pueden resumir de la siguiente manera:
- Las cadenas se devuelven tal como están.
- Lo indefinido se convierte en "indefinido".
- null se convierte en "vacío".
- Lo verdadero se convierte en "verdadero". Lo falso se convierte en "falso".
- Los números se convierten con el mismo algoritmo que toString(10).
- Los BigInts se convierten con el mismo algoritmo que toString(10).
- Los símbolos generan un TypeError.
- Los objetos se convierten primero en una primitiva mediante la llamada a los métodos [Symbol.toPrimitive]() (con "string" como pista), toString() y valueOf(), respectivamente. La primitiva resultante se convierte entonces en una cadena.
Hay diferentes formas de lograr aproximadamente el mismo efecto en JavaScript.
- Literalmente: `${x}` realiza exactamente los pasos de vinculación de cadenas descritos anteriormente para la expresión incorporada.
- La función String(): String(x) utiliza el mismo algoritmo para convertir x, excepto que Symbols no genera un TypeError, sino que devuelve “Symbol(description)”, donde description es la descripción del símbolo.
- Usando el operador +: “” + x convierte su operando a una primitiva en lugar de a una cadena, y para algunos objetos, su comportamiento es completamente diferente al de la conversión de cadenas normal. Consulte su página de referencia para más detalles.
Dependiendo de su caso de uso, es posible que desee utilizar `${x}` (para imitar el comportamiento incorporado) o String(x) (para manejar valores de símbolos sin causar errores), pero no debe utilizar “” + x. .
Caracteres UTF-16, puntos de código Unicode y grupos de grafemas
Las cadenas se representan esencialmente como una secuencia de unidades de código UTF-16. En la codificación UTF-16, cada unidad de código tiene exactamente 16 bits. Esto significa que hay un máximo de 216 o 65.536 caracteres posibles como una sola unidad de código UTF-16. Este conjunto de caracteres se denomina Página Multilingüe Básica (BMP) e incluye los caracteres más comunes, como el latino, el griego, el cirílico y muchos caracteres de Asia Oriental. Cada unidad de código puede escribirse en una cadena con \u seguido de exactamente cuatro dígitos hexadecimales.
Sin embargo, el conjunto completo de caracteres Unicode es mucho mayor que 65536. Los caracteres adicionales en UTF-16 se almacenan como pares sustitutos, que son pares de unidades de código de 16 bits que representan un solo carácter. Para evitar ambigüedades, las dos partes del par deben estar entre 0xD800 y 0xDFFF, y estas unidades de código no se utilizan para codificar caracteres de un solo código. (Más precisamente, los sustitutos iniciales, también llamados unidades de código sustituto superior, tienen valores entre 0xD800 y 0xDBFF, mientras que los sustitutos finales, también llamados unidades de código sustituto inferior, tienen valores entre 0xDC00 y 0xDFFF, incluido el carácter Unicode). Un carácter que consta de una o dos unidades de código UTF-16 también se denomina punto de código Unicode. Cualquier punto de código Unicode se puede escribir en una cadena con \u{xxxxxx}, donde xxxxxx representa de 1 a 6 dígitos hexadecimales.
Un “sustituto único” es una unidad de código de 16 bits que cumple una de las siguientes descripciones:
- En el rango 0xD800–0xDBFF, inclusive (es decir, es un sustituto principal), pero es la última unidad de código en la cadena, o la siguiente unidad de código no es un último sustituto.
- En el rango 0xDC00–0xDFFF, inclusive (es decir, un último sustituto), pero la primera unidad de código en la cadena, o la unidad de código anterior, no es el sustituto original.
Los sustitutos individuales no representan caracteres Unicode. Aunque la mayoría de los métodos internos de JavaScript los gestionan correctamente, ya que todos operan en unidades de código UTF-16, los sustitutos individuales no suelen ser valores válidos al interactuar con otros sistemas. Por ejemplo, encodeURI() genera un error URIE para los sustitutos individuales, ya que la codificación URI utiliza codificación UTF-8, que no tiene codificación para sustitutos individuales. Las cadenas que no contienen ningún sustituto individual se denominan cadenas bien formadas y se pueden usar de forma segura con funciones que no procesan UTF-16 (como encodeURI() o TextEncoder). Puede comprobar si una cadena está bien formada con el método isWellFormed() o limpiar los sustitutos individuales con el método toWellFormed().
Por encima de los caracteres Unicode, existe una secuencia específica de caracteres Unicode que debe considerarse como una unidad visual, conocida como grupo gráfico. El caso más común son los emoticonos: muchos de ellos, con una amplia gama de variaciones, están formados por varios emojis, generalmente con el carácter (U+200D) unirse.
Debe tener cuidado con el nivel de caracteres que itera. Por ejemplo, split(“”) divide por unidades de código UTF-16 y separa los pares alternativos. Los índices de cadena también se refieren al índice de cada unidad de código UTF-16. Por otro lado, [Symbol.iterator]() itera por puntos de código Unicode. La iteración a través de clústeres de grafemas requiere código personalizado.
"😄".split(""); // ['\ud83d', '\ude04']; splits into two lone surrogates
// "Backhand Index Pointing Right: Dark Skin Tone"
[..."👉🏿"]; // ['👉', '🏿']
// splits into the basic "Backhand Index Pointing Right" emoji and
// the "Dark skin tone" emoji
// "Family: Man, Boy"
[..."👨👦"]; // [ '👨', '', '👦' ]
// splits into the "Man" and "Boy" emoji, joined by a ZWJ
// The United Nations flag
[..."🇺🇳"]; // [ '🇺', '🇳' ]
// splits into two "region indicator" letters "U" and "N".
// All flag emojis are formed by joining two region indicator lettersConstructor
Cadena()
Crea objetos de cadena. Al llamarse como función, devuelve valores iniciales de tipo cadena.
Métodos estáticos
Cadena.fromCharCode()
Devuelve una cadena creada utilizando la secuencia especificada de valores Unicode.
Cadena.fromCodePoint()
Devuelve una cadena creada utilizando la secuencia especificada de puntos de código.
Cadena.raw()
Devuelve una cadena creada a partir de una cadena de patrón sin procesar.
Propiedades de muestra
Estas propiedades se definen en String.prototype y son compartidas por todas las instancias de String.
Cadena.prototipo.constructor
La función constructora que crea el objeto de instancia. Para instancias de cadena, el valor inicial es el constructor de cadena.
Estas características son específicas de cada instancia de cadena.
longitud
Refleja la longitud de la cadena. Solo lectura.
Métodos de muestra
Cadena.prototype.at()
Devuelve el carácter (exactamente una unidad de código UTF-16) en el índice especificado. Acepta enteros negativos contando hacia atrás desde el último carácter de la cadena.
Cadena.prototype.charAt()
Devuelve el carácter (exactamente una unidad de código UTF-16) en el índice especificado.
Cadena.prototipo.charCodeAt()
Devuelve un número que es el valor de la unidad de código UTF-16 en el índice dado.
Cadena.prototype.codePointAt()
Devuelve un entero no negativo que es el valor del punto de código codificado en UTF-16 que comienza en la posición especificada.
Cadena.prototype.concat()
El texto combina dos (o más) cadenas y devuelve una nueva cadena.
Cadena.prototipo.terminaCon()
Determina si una cadena termina con los caracteres de la cadena searchString.
Cadena.prototipo.incluye()
Determina si la cadena de llamada contiene una SearchString.
Cadena.prototipo.indexOf()
Devuelve el índice en esta cadena de la primera aparición de searchValue, o -1 si no se encuentra.
Cadena.prototype.isWellFormed()
Devuelve un valor booleano que indica si esta cadena tiene reemplazos individuales.
Cadena.prototipo.lastIndexOf()
Devuelve el índice en esta cadena de la última aparición de searchValue, o -1 si no se encuentra.
Cadena.prototype.localeCompare()
Devuelve un número que indica si la cadena a la que hace referencia compareString es anterior, posterior o equivalente a la cadena dada en el orden de clasificación.
Cadena.prototipo.coincidencia()
Se utiliza para hacer coincidir una expresión regular (regexp) con una cadena.
Cadena.prototipo.matchAll()
Devuelve un iterador de todas las coincidencias de expresiones regulares.
Cadena.prototipo.normalizar()
La forma normalizada Unicode devuelve el valor de la cadena de llamada.
Cadena.prototype.padEnd()
Concatena la cadena actual desde el final con una cadena y devuelve una nueva cadena de longitud targetLength.
Cadena.prototype.padStart()
Rellena la cadena actual desde el principio con una cadena dada y devuelve una nueva cadena de longitud targetLength.
Cadena.prototipo.repetir()
Devuelve una cadena que consta de los elementos del objeto contados veces.
Cadena.prototipo.reemplazar()
SearchFor se utiliza para reemplazar elementos usando replaceWith. searchFor puede ser una cadena o una expresión regular, y replaceWith puede ser una cadena o una función.
Cadena.prototipo.reemplazarTodo()
SearchFor se utiliza para reemplazar todas las apariciones de replaceWith. searchFor puede ser una cadena o una expresión regular, y replaceWith puede ser una cadena o una función.
Cadena.prototipo.búsqueda()
Busca una coincidencia entre una expresión regular regexp y la cadena de llamada.
Cadena.prototipo.slice()
Extrae parte de una cadena y devuelve una nueva cadena.
Cadena.prototipo.split()
Devuelve una matriz de cadenas que se completa dividiendo la cadena de llamada en subcadenas de la cadena sep.
Cadena.prototipo.iniciaCon()
Determina si la cadena de llamada comienza con los caracteres de la cadena searchString.
String.prototype.substr() está obsoleto
Devuelve una parte de una cadena que comienza en el índice especificado y se extiende por una cantidad específica de caracteres.
Cadena.prototipo.subcadena()
Devuelve una nueva cadena que contiene los caracteres de la cadena de llamada desde (o entre) el índice (o índices) especificado (s).
Cadena.prototype.toLocaleLowerCase()
Los caracteres dentro de una cadena se convierten a minúsculas respetando la configuración regional actual.
Para la mayoría de los idiomas, esto devuelve el mismo estado que toLowerCase().
Cadena.prototype.toLocaleUpperCase()
Los caracteres dentro de una cadena se convierten a mayúsculas respetando la configuración regional actual.
Para la mayoría de los idiomas, esto devuelve el mismo estado que toUpperCase().
Cadena.prototype.toLowerCase()
Devuelve el valor de la cadena de llamada convertida a minúsculas.
Cadena.prototype.toString()
Devuelve una cadena que representa el objeto especificado. Anula el método Object.prototype.toString().
Cadena.prototype.toUpperCase()
Devuelve el valor de la cadena de llamada convertida a mayúsculas.
Cadena.prototype.toWellFormed()
Devuelve una cadena en la que todas las apariciones individuales de esta cadena se reemplazan con el carácter de reemplazo Unicode U+FFFD.
Cadena.prototype.trim()
Recorta los espacios en blanco del principio y del final de la cadena.
Cadena.prototype.trimEnd()
Recorta el final de la cadena con espacios en blanco.
Cadena.prototype.trimStart()
Recorta los espacios en blanco desde el comienzo de la cadena.
Cadena.prototipo.valorDe()
Devuelve el valor inicial del objeto especificado. Anula el método Object.prototype.valueOf().
Cadena.prototipo[Símbolo.iterador]()
Devuelve un nuevo objeto iterador que itera sobre los puntos de código de un valor de cadena y devuelve cada punto de código como un valor de cadena.
