Una introducción detallada a los métodos básicos comunes de cadenas de JavaScript.

[Recomendaciones relacionadas: tutoriales en vídeo de JavaScript, interfaz web]

No importa qué lenguaje de programación utilice, las cadenas son un tipo de datos importante. ¡Sígueme para obtener más información sobre las cadenas JavaScript !

Prefacio

Una cadena es una cadena compuesta de caracteres. Si has estudiado C y Java , debes saber que los propios caracteres también pueden convertirse en un tipo independiente. Sin embargo, JavaScript no tiene un solo tipo de carácter, solo cadenas de longitud 1 .

Las cadenas JavaScript usan codificación UTF-16 fija, no importa qué codificación usemos al escribir el programa, no se verá afectada.

de escribir

cadenas: comillas simples, comillas dobles y comillas invertidas.

let single = 'abcdefg';//Comillas simples let double = "asdfghj";//Comillas dobles let backti = `zxcvbnm`;//Las

comillas simples y dobles tienen el mismo estado, no hacemos distinción.

de formato de cadena

nos permiten formatear cadenas elegantemente usando ${...} en lugar de usar la adición de cadenas.

let str = `Tengo ${Math.round(18.5)} años.`;console.log(str);

Resultado de la ejecución del código:

de cadenas de varias líneas

también permiten que la cadena abarque líneas, lo cual es muy útil cuando escribimos cadenas de varias líneas.

let ques = `¿Es guapo el autor?
R. Muy guapo;
B. Qué guapo;
C. Súper atractivo;`;console.log(ques);

Resultados de la ejecución del código:

¿No parece que no tiene nada de malo? Pero esto no se puede lograr usando comillas simples y dobles. Si desea obtener el mismo resultado, puede escribir así:

let ques = '¿Es guapo el autor?nA.Muy guapo;nB. Super guapo;'; console.log(ques);

El código anterior contiene un carácter especial n , que es el carácter especial más común en nuestro proceso de programación.

especial

n también conocido como "carácter de nueva línea", admite comillas simples y dobles para generar cadenas de varias líneas. Cuando el motor genera una cadena, si encuentra n , continuará generando en otra línea, generando así una cadena de varias líneas.

Aunque n parece tener dos caracteres, solo ocupa una posición de carácter. Esto se debe a que es un carácter de escape en la cadena y los caracteres modificados por el carácter de escape se convierten en caracteres especiales.

Lista de caracteres especiales

Por ejemplo:

console.log('Soy un estudiante.');// 'console.log(""Te amo. "");/ / "console.log("\n es un carácter de nueva línea.");// nconsole.log('u00A9')// ©console.log('u{1F60D} ');//

Código resultados de ejecución:

Con la existencia del carácter de escape , teóricamente podemos generar cualquier carácter, siempre que encontremos su codificación correspondiente.

Evite el uso de ' y "

para comillas simples y dobles en cadenas. Podemos usar inteligentemente comillas dobles dentro de comillas simples, usar comillas simples dentro de comillas dobles o usar directamente comillas simples y dobles entre comillas invertidas. Evite el uso de caracteres de escape, por ejemplo:

console.log("Soy estudiante.");
//Usar comillas simples dentro de comillas dobles console.log('"" se utiliza.');
//Usar comillas dobles dentro de comillas simples console.log(se utiliza `' ".`);
// Los resultados de la ejecución del código utilizando comillas simples y dobles entre comillas invertidas

son los siguientes:

.length

A través de la propiedad .length de la cadena, podemos obtener la longitud de la cadena:

console.log("HelloWorldn".length);//11

n aquí solo ocupa un carácter.

En el capítulo "Métodos de tipos básicos", exploramos por qué los tipos básicos en JavaScript tienen propiedades y métodos.

Accediendo a caracteres, charAt(), para... de

cadena es una cadena de caracteres. Podemos acceder a un solo carácter a través de [字符下标] . El subíndice de carácter comienza desde 0 :

let str = "El autor es guapo.";

;

//aconsole.log(str[str.length-1]);//.

También podemos usar la función charAt(post) para obtener caracteres:

let str = "El autor es guapo.";console.log(str.charAt(0));
//Tconsole.log(str.charAt(4));
//aconsole.log(str.charAt(str.length-1));//.El

efecto de ejecución de los dos es exactamente el mismo, la única diferencia es cuando se accede a caracteres fuera de límites:

let str = "01234"; console.log(str[ 9]);//undefinidoconsole.log(str.charAt(9));//"" (cadena vacía)

También podemos usar for ..of para recorrer la cadena:

for(let c of '01234'){
    console.log(c);}

Inmutabilidad de cadenas

Una cadena en JavaScript no se puede cambiar una vez definida. Por ejemplo:

let str = "Const";str[0] = 'c' ;console.log(str)

; resultados:

Si desea obtener una cadena diferente, solo puede crear una nueva:

console.log

(str);

Hemos cambiado los caracteres String, de hecho la cadena original no ha sido cambiada, lo que obtenemos es la nueva cadena devuelta por el método replace .

.toLowerCase(), .toUpperCase()

convierte el caso de una cadena o convierte el caso de un solo carácter en una cadena.

Los métodos para estas dos cadenas son relativamente simples, como se muestra en el ejemplo:

console.log('Good Boy'.toLowerCase());//good 
boyconsole.log('Buen chico'.toUpperCase());//BUENO 
BOYconsole.log('Good Boy'[5].toLowerCase());//b

resultado de la ejecución del código:

.indexOf(), .lastIndexOf() busca subcadenas.

La función .indexOf(substr,idx) comienza desde la posición idx de la cadena, busca la posición de la subcadena substr y devuelve el subíndice del primer carácter de la. subcadena si tiene éxito, o -1 si falla.

let str = "google google";console.log(str.indexOf('google'));
//0 idx por defecto es 0console.log(str.indexOf('google',1));
//7 Buscar console.log(str.indexOf('xxx'));
//-1 no encontrado devuelve -1

resultado de ejecución de código:

Si queremos consultar las posiciones de todas las subcadenas en la cadena, podemos usar un bucle:

let str = "I love love love love u.";let sub = "love";let pos = -1; while((pos = cadena.indexOf (sub,pos+1)) != -1)
    console.log(pos);

Los resultados de la ejecución del código son los siguientes:

.lastIndexOf(substr,idx) busca subcadenas al revés, primero encuentra la última cadena coincidente:

let str = "google google";console.log(str.lastIndexOf('google'));//7 idx por defecto es 0

Negación bit a bit técnica (no recomendada, pero debes conocerla)

porque indexOf() y lastIndexOf() devolverán -1 cuando la consulta no tenga éxito, y ~-1 === 0 . Es decir, usar ~ solo es verdadero cuando el resultado de la consulta no es -1 , por lo que podemos:

let str = "google google";if(~indexOf('google',str)){
    ...}

Normalmente, no recomendamos utilizar una sintaxis cuyas características sintácticas no puedan reflejarse claramente, ya que esto tendrá un impacto en la legibilidad. Afortunadamente, el código anterior solo aparece en la versión anterior del código. Se menciona aquí para que no todos se confundan al leer el código anterior.

Suplemento:

~ es el operador de negación bit a bit. Por ejemplo: la forma binaria del número decimal 2 es 0010 y la forma binaria de ~2 es 1101 (complemento), que es -3 .

Una forma sencilla de entenderlo, ~n es equivalente a -(n+1) , por ejemplo: ~2 === -(2+1) === -3

.includes(), .startsWith(), .endsWith( )

1. .includes(substr,idx) se utiliza para determinar si substr está en la cadena. idx es la posición inicial de la consulta

   console.log('Google Google'.includes('Google'));//trueconsole.log( 'Google Google' incluye('xxxxxx'));//falseconsole.log('9966'.includes('99',1));//

   resultados de ejecución de código falso:

   

2. .startsWith('substr') y .endsWith('substr') determinan respectivamente si la cadena comienza o termina con substr

   console.log("google".startsWith('go'));//trueconsole.log('google' .endsWith('le'));//trueconsole.log('google'.endsWith('ie'));//

   resultado de ejecución de código falso:

   

.substr(), .substring(), .slice()

.substr() , .substring() , .slice() se utilizan para obtener subcadenas de cadenas, pero su uso es diferente.

1. .substr(start,len)

   devuelve una cadena que consta de caracteres len comenzando desde start . Si se omite len , se interceptará hasta el final de la cadena original. start puede ser un número negativo, que indica el carácter start de atrás hacia adelante.

   let str = "0123456789";console.log(str.substr(1))//123456789, desde 1 hasta el final console.log(str.substr(3,2))//34, 2 desde 3 Carácter console.log(str.substr(-3,2))//78, el penúltimo

   resultado de la ejecución del código de inicio:

   

2. .slice(start,end)

   devuelve la cadena que comienza desde start y termina al end (exclusivo). start y end pueden ser números negativos, que indican los penúltimos caracteres start/end .

   let str = '0123456789';console.log(str.slice(1,5));//1234, caracteres entre el intervalo [1,5) console.log(str.slice(1));//123456789, del 1 al final console.log(str.slice(-4,-1));//678, el cuarto al último

   resultado de la ejecución del código:

   

3. La función de

   .substring(start,end)

   es casi la misma que .slice() . La diferencia está en dos lugares:

   • end > start
   • no están permitidos y los números negativos se consideran 0 ,

   por ejemplo:

   let str = '0123456789'; console.log(str .substring(1,3));//12console.log(str.substring(3,1));//12console.log(str.substring(-1, 3));//012, -1 se trata como resultado de la ejecución del código Make 0

   :

   

Compare las diferencias entre los tres:

métodos de subcadena negativa para len, por lo que, naturalmente, es difícil elegir. Se recomienda recordar .slice() , que es más flexible que los otros dos.

.codePointAt(), String.fromCodePoint()

Ya mencionamos la comparación de cadenas en el artículo anterior. Las cadenas están ordenadas en el orden del diccionario. Detrás de cada carácter hay un código, y el código ASCII es una referencia importante.

Por ejemplo:

console.log('a'>'Z');//

La comparación entre caracteres verdaderos es esencialmente una comparación entre codificaciones que representan caracteres. JavaScript usa UTF-16 para codificar cadenas. Cada carácter es un código de 16 bits. Si desea conocer la naturaleza de la comparación, debe usar .codePointAt(idx) para obtener la codificación de caracteres:

console.log('a. '.codePointAt( 0));//97console.log('Z'.codePointAt(0));//90

resultados de ejecución del código:

Utilice String.fromCodePoint(code) para convertir la codificación en caracteres:

console.log(String.fromCodePoint(97));console.log(String.fromCodePoint(90));

Los resultados de la ejecución del código son los siguientes:

Este proceso se puede lograr usando el carácter de escape u , de la siguiente manera:

console.log('u005a');//Z, 005a es la notación hexadecimal de 90 console.log('u0061');//a, 0061 Es la notación hexadecimal de 97.

Exploremos los caracteres codificados en el rango [65,220] :

let str = '';for(let i = 65; i<=220; i++){
    str+=String.fromCodePoint(i);}console.log(str);

Los resultados de la parte de ejecución del código son los siguientes:

La imagen de arriba no muestra todos los resultados, así que pruébalo.

.localeCompare()

se basa en el estándar internacional ECMA-402 . JavaScript ha implementado un método especial ( .localeCompare() ) para comparar varias cadenas, usando str1.localeCompare(str2) :

1. si
2. str1 < str2 , devuelve un número negativo;
3. str1 > str2 , devuelve un número positivo;
4. si str1 == str2 , devuelve 0;

por ejemplo:

console.log("abc".localeCompare('def'));//-1

¿Por qué no utilizar operadores de comparación directamente?

Esto se debe a que los caracteres en inglés tienen algunas formas especiales de escribir. Por ejemplo, á es una variante de a :

console.log('á' < 'z');//

Aunque false también es a , es más grande que z . !

En este momento, debe utilizar .localeCompare() :

console.log('á'.localeCompare('z'));//-1

El método comúnmente utilizado

1. str.trim() elimina los espacios en blanco antes y después del string, str.trimStart() , str.trimEnd() elimina los espacios al principio y al final;

   let str = " 999 "

2. str.repeat(n) la cadena n veces;

   let str = ' 6';console.log(str.repeat(3));//666

3. str.replace(substr,newstr) reemplaza la primera subcadena, str.replaceAll() se usa para reemplazar todas subcadenas;

   let str = '9 +9';console.log(str.replace('9','6'));//6+9console.log(str.replaceAll('9','6')) ;//6+6

todavía hay muchos otros métodos y podemos visitar el manual para obtener más conocimientos.

Contenido avanzado:

palabras raras, emoji y símbolos especiales.

JavaScript usa UTF-16 para codificar cadenas, es decir, se usan dos bytes ( 16 bits) para representar un carácter. Sin embargo, los datos 16 bits solo pueden representar 65536 caracteres. Naturalmente, los caracteres comunes no están incluidos. Es fácil de entender, pero no es suficiente para caracteres raros (chinos), emoji , símbolos matemáticos raros, etc.

En este caso, necesita expandir y usar dígitos más largos ( 32 bits) para representar caracteres especiales, por ejemplo:

console.log(''.length);//2console.log('?'.length);//2

Resultado de la ejecución del código:

El resultado de esto es que no podemos procesarlos usando métodos convencionales. ¿Qué sucede si generamos cada byte individualmente?

console.log(''[0]);console.log(''[1]);

resultados de la ejecución del código:

Como puede ver, los bytes de salida individuales no se reconocen.

Afortunadamente, String.fromCodePoint() y .codePointAt() pueden manejar esta situación porque se agregaron recientemente. En versiones anteriores de JavaScript , solo puedes usar String.fromCharCode() y .charCodeAt() para convertir codificaciones y caracteres, pero no son adecuados para caracteres especiales.

Podemos manejar caracteres especiales juzgando el rango de codificación de un carácter para determinar si es un carácter especial. Si el código de un carácter está entre 0xd800~0xdbff , entonces es la primera parte del carácter de 32 bits y su segunda parte debe estar entre 0xdc00~0xdfff .

Por ejemplo:

console.log(''.charCodeAt(0).toString(16));//d83
dconsole.log('?'.charCodeAt(1).toString(16));//

resultado de la ejecución del código de02:

Normalización

En inglés, existen muchas variantes basadas en letras, por ejemplo: la letra a puede ser el carácter básico de àáâäãåā . No todos estos símbolos variantes se almacenan en codificación UTF-16 porque hay demasiadas combinaciones de variaciones.

Para admitir todas las combinaciones de variantes, también se utilizan varios caracteres Unicode para representar un único carácter variante. Durante el proceso de programación, podemos usar caracteres básicos más "símbolos decorativos" para expresar caracteres especiales:

console.log('au0307 '. );//ȧ
console.log('au0308');//ȧ
console.log('au0309');//ȧ
console.log('Eu0307');//Ė
console.log('Eu0308');//E
console.log('Eu0309');//ẺResultados

de la ejecución del código:

Una letra básica también puede tener múltiples decoraciones, por ejemplo:

console.log('Eu0307u0323');//Ẹ̇
console.log('Eu0323u0307');//

Ẹ̇Resultados de la ejecución del código:

Aquí hay un problema. En el caso de varias decoraciones, las decoraciones se ordenan de manera diferente, pero los personajes que se muestran son los mismos.

Si comparamos estas dos representaciones directamente, obtenemos un resultado incorrecto:

sea e1 = 'Eu0307u0323';
sea ​​e2 = 'Eu0323u0307';
console.log(`${e1}==${e2} es ${e1 == e2}`)

resultados de la ejecución del código:

Para resolver esta situación, existe un algoritmo de normalización ** Unicode que puede convertir la cadena a un formato universal **, implementado por str.normalize() :

let e1 = 'Eu0307u0323';
 sea ​​e2 = 'Eu0323u0307';
 console.log(`${e1}==${e2} es ${e1.normalize() == e2.normalize()}`)

Resultados de la ejecución del código:

[Recomendaciones relacionadas: tutoriales en vídeo de JavaScript, interfaz web]

Lo anterior es el contenido detallado de los métodos básicos comunes de cadenas de JavaScript. Para obtener más información, preste atención a otros artículos relacionados en el sitio web chino de PHP.