Esta traducción está incompleta. Por favor, ayuda a traducir este artículo del inglés.

Este capítulo muestra cómo trabajar con cadenas y texto en JavaScript

Cadenas (String)

Las cadenas o String de JavaScript se utilizan para representar datos de texto. Es un conjunto de "elementos" de valores enteros de 16-bit no signados. Cada elemento en la cadena ocupa una posición en ella. El primer elemento se encuentra en el índice 0, el siguiente en el índice 1, y asi subsecuentemente. La longitud de una cadena es el número de elementos en ella. Es posible crear cadenas utilizando literales de cadena u objetos de cadena.

Literales de cadena

Es posible crear cadenas simples utilizando tanto comillas simples como dobles:

'foo'
"bar"

Cadenas más avanzadas pueden ser creadas utilizando secuencias de escape:

Secuencias de escape hexadecimal

El número despues de \x es interpretado como un número hexadecimal.

'\xA9' // "©"

Secuencias de escape Unicode

Las secuencias de escape Unicode requieren al menos cuatro dígitos hexadecimales después de  \u.

'\u00A9' // "©"

Puntos de escape de código Unicode

Nuevo en ECMAScript 6. Con los puntos de escape de código Unicode, cualquier caracter puede ser escapado usando números hexadecimales así que es posible usar puntos de código hasta 0x10FFFF. Con los escapes Unicode simples a menudo es necesario escribir las mitades separadamente para conseguir lo mismo.

Ver también String.fromCodePoint() o String.prototype.codePointAt().

'\u{2F804}'

// lo mismo con escapes Unicode simples
'\uD87E\uDC04'

Objetos cadena

El objeto String es un envoltorio alrededor del tipo de datos de cadena original.

var s = new String("foo"); // Crea un objeto String
console.log(s); // Muestra: { '0': 'f', '1': 'o', '2': 'o'}
typeof s; // Devuelve 'object'

Es posible llamar cualquiera de los métodos del objeto String en un valor literal de cadena—JavaScript automáticamente convierte el literal de cadena a un objeto String temporal, invoca el método, y luego descarta el objeto String temporal. También es posible utilizar la propiedad String.length con un literal de cadena.

Se debería utilizar literales de cadena a menos que específicamente sea necesario usar un objeto String, porque los objetos String pueden tener un comportamiento contraintuitivo. Por ejemplo:

var s1 = "2 + 2"; // Crea un valor literal de cadena
var s2 = new String("2 + 2"); // Crea un nuevo objeto de cadena
eval(s1); // Devuelve el número 4
eval(s2); // Devuelve la cadena "2 + 2"

Un objeto String tiene una propiedad, lenght, que inica el número de caracteres en la cadena. Por ejemplo, el código siguiente asigna a x el valor 13, porque "Hello, World!" tiene 13 caracteres, cada uno representado por una unidad de código UTF-16. Se puede acceder a cada unidad de código utilizando un estilo de corchetes de arreglo. No es posible cambiar caracteres debido a que las cadenas son objetos tipo arreglo inmutables: 

var mystring = "Hello, World!";
var x = mystring.length;
mystring[0] = 'L' // No produce ningún efecto 
mystring[0]; // Esto devuelve "H"

Los caracteres cuyo valor Unicode escalar sea mayor que U+FFFF (tales como algunos caracteres Chinos/Japoneses/Coreanos/Vietnamitas infrecuentes y algunos emoji) son almacenados en UTF-16 con dos unidades de código sustitutas. Por ejemplo, una cadena que contenga el caracter único U+1F600 "cara con sonrisa burlona Emoji" tendrá una longitud de 2. El acceso a las unidades de código individual utilizando corchetes puede tener consecuencias indeseables como la formación de cadenas con unidades de código sustitutas no pareadas, en violación al estándar Unicode. Ver también String.fromCodePoint()String.prototype.codePointAt().

Un objeto String tiene una variedad de métodos: por ejemplo aquellos que devuelven una modificación de la misma cadena, tales como substring y toUpperCase.

La siguiente tabla resume los métodos de los objetos String.

Métodos de String

Método Descripción
charAtcharCodeAt, codePointAt Devuelve el caracter o el código del caracter en la posición especificada en la cadena.
indexOf, lastIndexOf Devuelve la posición de la subcadena en la cadena o la última posición de una subcadena especificada respectivamente.
startsWith, endsWith, includes Devuelve si la cadena empieza, termina o contiene una cadena especificada, o no.
concat Combina el texto de dos cadenas y retorna una nueva cadena.
fromCharCode, fromCodePoint Construye una cadena desde la secuencia de valores Unicode especificada. Este es un método de la clase String, no una instancia de String.
split Splits a String object into an array of strings by separating the string into substrings.
slice Extracts a section of a string and returns a new string.
substring, substr Return the specified subset of the string, either by specifying the start and end indexes or the start index and a length.
match, replace, search Work with regular expressions.
toLowerCase, toUpperCase

Return the string in all lowercase or all uppercase, respectively.

normalize Returns the Unicode Normalization Form of the calling string value.
repeat Returns a string consisting of the elements of the object repeated the given times.
trim Trims whitespace from the beginning and end of the string.

Multi-line template strings

Template strings are string literals allowing embedded expressions. You can use multi-line strings and string interpolation features with them.

Template strings are enclosed by the back-tick (` `) (grave accent) character instead of double or single quotes. Template strings can contain place holders. These are indicated by the Dollar sign and curly braces (${expression}).

Multi-lines

Any new line characters inserted in the source are part of the template string. Using normal strings, you would have to use the following syntax in order to get multi-line strings:

console.log("string text line 1\n\
string text line 2");
// "string text line 1
// string text line 2"

To get the same effect with multi-line strings, you can now write:

console.log(`string text line 1
string text line 2`);
// "string text line 1
// string text line 2"

Embedded expressions

In order to embed expressions within normal strings, you would use the following syntax:

var a = 5;
var b = 10;
console.log("Fifteen is " + (a + b) + " and\nnot " + (2 * a + b) + ".");
// "Fifteen is 15 and
// not 20."

Now, with template strings, you are able to make use of the syntactic sugar making substitutions like this more readable:

var a = 5;
var b = 10;
console.log(`Fifteen is ${a + b} and\nnot ${2 * a + b}.`);
// "Fifteen is 15 and
// not 20."

For more information, read about Template strings in the JavaScript reference.

Internationalization

The Intl object is the namespace for the ECMAScript Internationalization API, which provides language sensitive string comparison, number formatting, and date and time formatting. The constructors for Collator, NumberFormat, and DateTimeFormat objects are properties of the Intl object.

Date and time formatting

The DateTimeFormat object is useful for formatting date and time. The following formats a date for English as used in the United States. (The result is different in another time zone.)

var msPerDay = 24 * 60 * 60 * 1000;
 
// July 17, 2014 00:00:00 UTC.
var july172014 = new Date(msPerDay * (44 * 365 + 11 + 197));

var options = { year: "2-digit", month: "2-digit", day: "2-digit",
                hour: "2-digit", minute: "2-digit", timeZoneName: "short" };
var americanDateTime = new Intl.DateTimeFormat("en-US", options).format;
 
console.log(americanDateTime(july172014)); // 07/16/14, 5:00 PM PDT

Number formatting

The NumberFormat object is useful for formatting numbers, for example currencies.

var gasPrice = new Intl.NumberFormat("en-US",
                        { style: "currency", currency: "USD",
                          minimumFractionDigits: 3 });
 
console.log(gasPrice.format(5.259)); // $5.259

var hanDecimalRMBInChina = new Intl.NumberFormat("zh-CN-u-nu-hanidec",
                        { style: "currency", currency: "CNY" });
 
console.log(hanDecimalRMBInChina.format(1314.25)); // ¥ 一,三一四.二五

Collation

The Collator object is useful for comparing and sorting strings.

For example, there are actually two different sort orders in German, phonebook and dictionary. Phonebook sort emphasizes sound, and it’s as if “ä”, “ö”, and so on were expanded to “ae”, “oe”, and so on prior to sorting.

var names = ["Hochberg", "Hönigswald", "Holzman"];
 
var germanPhonebook = new Intl.Collator("de-DE-u-co-phonebk");
 
// as if sorting ["Hochberg", "Hoenigswald", "Holzman"]:
console.log(names.sort(germanPhonebook.compare).join(", "));
// logs "Hochberg, Hönigswald, Holzman"

Some German words conjugate with extra umlauts, so in dictionaries it’s sensible to order ignoring umlauts (except when ordering words differing only by umlauts: schon before schön).

var germanDictionary = new Intl.Collator("de-DE-u-co-dict");
 
// as if sorting ["Hochberg", "Honigswald", "Holzman"]:
console.log(names.sort(germanDictionary.compare).join(", "));
// logs "Hochberg, Holzman, Hönigswald"

For more information about the Intl API, see also Introducing the JavaScript Internationalization API.

Regular expressions

Regular expressions are patterns used to match character combinations in strings. They can be powerful and complex and are described in an own chapter. Read more about regular expressions here:

Etiquetas y colaboradores del documento

 Colaboradores en esta página: Enesimus, jalmeida
 Última actualización por: Enesimus,