JavaScript
Instrumentos de cuerda

Sintaxis

• "cadena literal"
• 'cadena literal'
• "cadena literal con 'comillas que no coinciden'" // sin errores; las cotizaciones son diferentes
• "cadena literal con" comillas escapadas "" // sin errores; se escapan las cotizaciones.
• `plantilla cadena $ {expresión}`
• String ("ab c") // devuelve una cadena cuando se llama en un contexto que no es de constructor
• new String ("ab c") // el objeto String, no la primitiva string

Información básica y concatenación de cuerdas

Las cadenas en JavaScript se pueden incluir en las comillas simples 'hello' , las comillas dobles "Hello" y (a partir de ES2015, ES6) en Template Literals ( backticks ) `hello` .

var hello  = "Hello";
var world  = 'world';
var helloW = `Hello World`;              // ES2015 / ES6

Las cadenas se pueden crear desde otros tipos utilizando la función String() .

var intString = String(32); // "32"
var booleanString = String(true); // "true"
var nullString = String(null); // "null" 

O, toString() se puede utilizar para convertir números, valores booleanos u objetos en cadenas.

var intString = (5232).toString(); // "5232"
var booleanString = (false).toString(); // "false"
var objString = ({}).toString(); // "[object Object]"

Las cadenas también se pueden crear utilizando el método String.fromCharCode .

String.fromCharCode(104,101,108,108,111) //"hello"

Se permite crear un objeto String usando una new palabra clave, pero no se recomienda ya que se comporta como Objetos a diferencia de las cadenas primitivas.

var objectString = new String("Yes, I am a String object");
typeof objectString;//"object"
typeof objectString.valueOf();//"string"

Cuerdas de concatenacion

La concatenación de cadenas se puede hacer con el operador de concatenación + o con el método concat() incorporado en el prototipo del objeto String.

var foo = "Foo";
var bar = "Bar";
console.log(foo + bar);        // => "FooBar"
console.log(foo + " " + bar);  // => "Foo Bar"

foo.concat(bar)            // => "FooBar"
"a".concat("b", " ", "d")  // => "ab d"

Las cadenas pueden concatenarse con variables que no son de cadena, pero convertirán las variables que no sean de cadena en cadenas.

var string = "string";
var number = 32;
var boolean = true;

console.log(string + number + boolean); // "string32true"

Plantillas de cadena

var greeting = `Hello`;

var place = `World`;
var greet = `Hello ${place}!`

console.log(greet); // "Hello World!"

`a\\b` // =  a\b
String.raw`a\\b` // = a\\b

Citas de escape

Si su cadena está encerrada (es decir) entre comillas simples, necesita escapar de la comilla literal interna con una barra invertida \

var text = 'L\'albero means tree in Italian';
console.log( text ); \\ "L'albero means tree in Italian"

Lo mismo ocurre con las comillas dobles:

var text = "I feel \"high\"";

Se debe prestar especial atención a las citas que se escapan si está almacenando representaciones HTML dentro de una Cadena, ya que las cadenas HTML hacen un gran uso de las citas, es decir, en los atributos:

var content = "<p class=\"special\">Hello World!</p>";        // valid String
var hello   = '<p class="special">I\'d like to say "Hi"</p>'; // valid String

Las citas en cadenas HTML también se pueden representar utilizando ' (o ' ) como una comilla simple y " (o " ) como comillas dobles.

var hi    = "<p class='special'>I'd like to say &quot;Hi&quot;</p>"; // valid String
var hello = '<p class="special">I&apos;d like to say "Hi"</p>';      // valid String

Nota: El uso de ' y " no sobrescribirá las comillas dobles que los navegadores pueden colocar automáticamente en las citas de atributos. Por ejemplo, <p class=special> está realizando en <p class="special"> , usando " puede llevar a <p class=""special""> donde \" será <p class="special"> .

var x = `"Escaping " and ' can become very annoying`;

Cadena inversa

La forma más "popular" de invertir una cadena en JavaScript es el siguiente fragmento de código, que es bastante común:

function reverseString(str) {
    return str.split('').reverse().join('');
}

reverseString('string');    // "gnirts"

Sin embargo, esto funcionará solo mientras la cadena que se está invirtiendo no contenga pares sustitutos. Los símbolos astrales, es decir, los caracteres que se encuentran fuera del plano multilingüe básico, pueden representarse mediante dos unidades de código, y conducirán a esta ingenua técnica a producir resultados erróneos. Además, los caracteres con marcas de combinación (p. Ej., Diéresis) aparecerán en el "siguiente" carácter lógico en lugar del original con el que se combinó.

'𝌆■.'.split('').reverse().join(''); //fails

Si bien el método funcionará bien para la mayoría de los idiomas, un algoritmo que respeta la codificación realmente precisa para la inversión de cadenas es un poco más complicado. Una de estas implementaciones es una pequeña biblioteca llamada Esrever , que utiliza expresiones regulares para hacer coincidir marcas combinadas y pares sustitutos para realizar la inversión a la perfección.

Explicación

Usando operador de propagación

function reverseString(str) {
    return [...String(str)].reverse().join('');    
}

console.log(reverseString('stackoverflow'));  // "wolfrevokcats"
console.log(reverseString(1337));             // "7331"
console.log(reverseString([1, 2, 3]));        // "3,2,1"

Función reverse() personalizada reverse()

function reverse(string) {
    var strRev = "";
    for (var i = string.length - 1; i >= 0; i--) {
        strRev += string[i];
    }
    return strRev; 
}

reverse("zebra");  // "arbez"

Recortar espacios en blanco

Para recortar espacios en blanco de los bordes de una cadena, use String.prototype.trim :

"    some whitespaced string  ".trim();  // "some whitespaced string"

Muchos motores de JavaScript, pero no Internet Explorer , han implementado métodos trimLeft y trimRight no estándar. Hay una propuesta , actualmente en la Etapa 1 del proceso, para los trimStart estandarizados trimStart y trimEnd , con alias para trimLeft y trimRight para compatibilidad.

// Stage 1 proposal
"    this is me    ".trimStart();  // "this is me    "
"    this is me    ".trimEnd();  // "    this is me"

// Non-standard methods, but currently implemented by most engines
"    this is me    ".trimLeft();  // "this is me    "
"    this is me    ".trimRight();  // "    this is me"

Subcadenas con rodaja

Utilice .slice() para extraer las subcadenas dadas dos índices:

var s = "0123456789abcdefg";
s.slice(0, 5);  // "01234"
s.slice(5, 6);  // "5"

Dado un índice, tomará de ese índice al final de la cadena:

s.slice(10);    // "abcdefg"

Dividir una cadena en una matriz

Use .split para pasar de cadenas a una matriz de las subcadenas divididas:

var s = "one, two, three, four, five"
s.split(", ");  // ["one", "two", "three", "four", "five"]

Use el método de matriz .join para volver a una cadena:

s.split(", ").join("--");  // "one--two--three--four--five"

Las cuerdas son unicode

Todas las cadenas de JavaScript son Unicode!

var s = "some ∆≈ƒ unicode ¡™£¢¢¢";
s.charCodeAt(5);  // 8710

No hay bytes en bruto o cadenas binarias en JavaScript. Para manejar efectivamente los datos binarios, use matrices tipadas .

Detectando una cuerda

Para detectar si un parámetro es una cadena primitiva , use typeof :

var aString = "my string";
var anInt = 5;
var anObj = {};
typeof aString === "string";   // true
typeof anInt === "string";     // false
typeof anObj === "string";     // false

Si alguna vez tiene un objeto String , a través de un new String("somestr") , lo anterior no funcionará. En este caso, podemos usar instanceof :

var aStringObj = new String("my string");
aStringObj instanceof String;    // true

Para cubrir ambas instancias, podemos escribir una función auxiliar simple:

var isString = function(value) {
    return typeof value === "string" || value instanceof String;
};

var aString = "Primitive String";
var aStringObj = new String("String Object");
isString(aString); // true
isString(aStringObj); // true
isString({}); // false
isString(5); // false

O podemos hacer uso de la función toString de Object . Esto puede ser útil si tenemos que buscar otros tipos y decir en una declaración de cambio, ya que este método admite otros tipos de datos, así como typeof .

var pString = "Primitive String";
var oString = new String("Object Form of String");
Object.prototype.toString.call(pString);//"[object String]"
Object.prototype.toString.call(oString);//"[object String]"    

Una solución más robusta es no detectar una cadena, sino solo verificar qué funcionalidad se requiere. Por ejemplo:

var aString = "Primitive String";
// Generic check for a substring method
if(aString.substring) {

}
// Explicit check for the String substring prototype method
if(aString.substring === String.prototype.substring) {
    aString.substring(0, );
}

Comparando cuerdas lexicográficamente

Para comparar cadenas alfabéticamente, use localeCompare() . Esto devuelve un valor negativo si la cadena de referencia es lexicográficamente (alfabéticamente) antes de la cadena comparada (el parámetro), un valor positivo si viene después, y un valor de 0 si son iguales.

var a = "hello";
var b = "world";

console.log(a.localeCompare(b)); // -1

Los operadores > y < también se pueden usar para comparar cadenas lexicográficamente, pero no pueden devolver un valor de cero (esto se puede probar con el operador de igualdad == ). Como resultado, una forma de la función localeCompare() puede escribirse así:

function strcmp(a, b) {
    if(a === b) {
        return 0;
    }

    if (a > b) {
        return 1;
    }

    return -1;
}

console.log(strcmp("hello", "world")); // -1
console.log(strcmp("hello", "hello")); //  0
console.log(strcmp("world", "hello")); //  1

Esto es especialmente útil cuando se utiliza una función de clasificación que se compara en función del signo del valor de retorno (como la sort ).

var arr = ["bananas", "cranberries", "apples"];
arr.sort(function(a, b) {
    return a.localeCompare(b);
});
console.log(arr); // [ "apples", "bananas", "cranberries" ]

Cadena a mayúsculas

String.prototype.toUpperCase ():

console.log('qwerty'.toUpperCase()); // 'QWERTY'

Cadena a minúscula

String.prototype.toLowerCase ()

console.log('QWERTY'.toLowerCase()); // 'qwerty'

Contador de palabras

Digamos que tiene un <textarea> y desea recuperar información sobre el número de:

• Personajes (total)
• Personajes (sin espacios)
• Palabras
• Líneas

function wordCount( val ){
    var wom = val.match(/\S+/g);
    return {
        charactersNoSpaces : val.replace(/\s+/g, '').length,
        characters         : val.length,
        words              : wom ? wom.length : 0,
        lines              : val.split(/\r*\n/).length
    };
}


// Use like:
wordCount( someMultilineText ).words;   // (Number of words)

Ejemplo de jsFiddle

Carácter de acceso en el índice en cadena

Use charAt() para obtener un carácter en el índice especificado en la cadena.

var string = "Hello, World!";
console.log( string.charAt(4) ); // "o"

Alternativamente, como las cadenas pueden tratarse como matrices, use el índice mediante notación de corchetes .

var string = "Hello, World!";
console.log( string[4] ); // "o"

Para obtener el código de carácter del carácter en un índice específico, use charCodeAt() .

var string = "Hello, World!";
console.log( string.charCodeAt(4) ); // 111

Tenga en cuenta que estos métodos son todos métodos getter (devuelven un valor). Las cadenas en JavaScript son inmutables. En otras palabras, ninguno de ellos puede usarse para establecer un carácter en una posición en la cadena.

Funciones de búsqueda y reemplazo de cadenas

Para buscar una cadena dentro de una cadena, hay varias funciones:

indexOf( searchString ) y lastIndexOf( searchString )

indexOf() devolverá el índice de la primera aparición de searchString en la cadena. Si no se encuentra searchString , entonces se devuelve -1 .

var string = "Hello, World!";
console.log( string.indexOf("o") ); // 4
console.log( string.indexOf("foo") ); // -1

De manera similar, lastIndexOf() devolverá el índice de la última aparición de searchstring o -1 si no se encuentra.

var string = "Hello, World!";
console.log( string.lastIndexOf("o") );   // 8
console.log( string.lastIndexOf("foo") ); // -1

includes( searchString, start )

includes() devolverá un booleano que indica si searchString existe en la cadena, a partir del índice de start (por defecto 0). Esto es mejor que indexOf() si simplemente necesita probar la existencia de una subcadena.

var string = "Hello, World!";
console.log( string.includes("Hello") ); // true
console.log( string.includes("foo") );   // false

replace( regexp|substring, replacement|replaceFunction )

replace() devolverá una cadena que tiene todas las apariciones de subcadenas que coincidan con la expresión regular regexp o una cadena substring con una cadena replacement o el valor devuelto de replaceFunction .

Tenga en cuenta que esto no modifica la cadena en su lugar, pero devuelve la cadena con reemplazos.

var string = "Hello, World!";
string = string.replace( "Hello", "Bye" );
console.log( string ); // "Bye, World!"

string = string.replace( /W.{3}d/g, "Universe" );
console.log( string ); // "Bye, Universe!"

replaceFunction se puede usar para reemplazos condicionales para objetos de expresiones regulares (es decir, con uso con regexp ). Los parámetros están en el siguiente orden:

Tenga en cuenta que todos los parámetros son opcionales.

var string = "heLlo, woRlD!";
string = string.replace( /([a-zA-Z])([a-zA-Z]+)/g, function(match, g1, g2) {
    return g1.toUpperCase() + g2.toLowerCase();
}); 
console.log( string ); // "Hello, World!"

Encuentra el índice de una subcadena dentro de una cadena

El método .indexOf devuelve el índice de una subcadena dentro de otra cadena (si existe, o -1 si es contrario)

'Hellow World'.indexOf('Wor');    // 7

.indexOf también acepta un argumento numérico adicional que indica en qué índice debe comenzar a buscar la función

"harr dee harr dee harr".indexOf("dee", 10); // 14

Debe tener en cuenta que .indexOf mayúsculas y minúsculas

 'Hellow World'.indexOf('WOR');    // -1

Representaciones de cuerdas de números

JavaScript tiene conversión nativa de Número a su representación de Cadena para cualquier base de 2 a 36 .

La representación más común después del decimal (base 10) es hexadecimal (base 16) , pero el contenido de esta sección funciona para todas las bases en el rango.

Para convertir un Número de decimal (base 10) a su representación hexadecimal (base 16) Cadena, el método toString se puede usar con la raíz 16 .

// base 10 Number
var b10 = 12;

// base 16 String representation
var b16 = b10.toString(16); // "c"

Si el número representado es un entero, la operación inversa para esto se puede hacer con parseInt y la raíz 16 nuevamente

// base 16 String representation
var b16 = 'c';

// base 10 Number
var b10 = parseInt(b16, 16); // 12

Para convertir un número arbitrario (es decir, no entero) de su representación de cadena en un número , la operación debe dividirse en dos partes; La parte entera y la parte fraccionaria.

let b16 = '3.243f3e0370cdc';
// Split into integer and fraction parts
let [i16, f16] = b16.split('.');

// Calculate base 10 integer part
let i10 = parseInt(i16, 16); // 3

// Calculate the base 10 fraction part
let f10 = parseInt(f16, 16) / Math.pow(16, f16.length); // 0.14158999999999988

// Put the base 10 parts together to find the Number
let b10 = i10 + f10; // 3.14159

Nota 1: Tenga cuidado ya que pueden aparecer pequeños errores en el resultado debido a las diferencias en lo que se puede representar en diferentes bases. Puede ser deseable realizar algún tipo de redondeo después.
Nota 2: Las representaciones de números muy largas también pueden dar como resultado errores debido a la precisión y los valores máximos de los Números del entorno en el que se producen las conversiones.

Repetir una cadena

"abc".repeat(3);  // Returns "abcabcabc"
"abc".repeat(0);  // Returns ""
"abc".repeat(-1); // Throws a RangeError

var myString = "abc";
var n = 3;

new Array(n + 1).join(myString);  // Returns "abcabcabc"

Codigo de caracter

El método charCodeAt recupera el código de carácter Unicode de un solo carácter:

var charCode = "µ".charCodeAt(); // The character code of the letter µ is 181

Para obtener el código de carácter de un carácter en una cadena, la posición basada en 0 del carácter se pasa como un parámetro a charCodeAt :

var charCode = "ABCDE".charCodeAt(3); // The character code of "D" is 68

// The Grinning Face Emoji has code point 128512 or 0x1F600
var codePoint = "😀".codePointAt();