JavaScript no representa un solo carácter, solo un tipo de cadena de cadena, y el tipo de caracteres es equivalente a una cadena que contiene solo un carácter.
String String es un tipo de datos básico de JavaScript. Al mismo tiempo, JavaScript también admite objetos de cadena, que es un objeto de envoltura con valores originales. JavaScript se convierte automáticamente entre el formulario original y el formulario de objeto cuando sea necesario. Este artículo introducirá el tipo de cadena original y el objeto de envoltura de cadenas
definición
El tipo de cadena es una secuencia de caracteres que consisten en caracteres unicode de 16 bits encerrados en citas.
Los tipos de cadenas a menudo se usan para representar datos de texto, y en este momento cada elemento en la cadena se considera un punto de código. Se considera que cada elemento ocupa una posición en esta secuencia, indexando estas posiciones con valores no negativos. El primer personaje comienza en la posición 0, el segundo personaje está en la posición 1, y así sucesivamente
La longitud de la cadena es el número de elementos (por ejemplo, un valor de 16 bits). La cadena vacía tiene longitud cero, por lo que no contiene ningún elemento
Codificación unicode
Todos los caracteres se pueden escribir en forma de '/uxxxx', donde xxxx representa la codificación unicode del personaje. Por ejemplo, /U00A9 representa el símbolo de los derechos de autor
var s = '/u00a9'; s // "©"
Si una cadena contiene datos de texto reales, cada elemento se considera una unidad UTF-16 separada. Cada personaje se almacena en formato UTF-16 de 16 bits (es decir, 2 bytes) dentro de JavaScript
Pero UTF-16 tiene dos longitudes: para caracteres entre U+0000 y U+FFFF, la longitud es de 16 bits (es decir, 2 bytes); Para los caracteres entre U+10000 y U+10ffff, la longitud es de 32 bits (es decir, 4 bytes), y los dos primeros bytes están entre 0xd800 y 0xdbff, y los dos últimos bytes están entre 0xdc00 y 0xdffffff, y los dos últimos bytes están entre 0xdc00 y 0xdffff.
Por ejemplo, el personaje "?" correspondiente a U+1D306 se escribe como UTF-16, que es 0xd834 0xdf06. El navegador reconocerá correctamente estos cuatro bytes como un solo carácter, pero la longitud del personaje dentro de JavaScript siempre se fija a 16 bits, y estos cuatro bytes serán tratados como dos caracteres.
var s = '/UD834/UDF06'; S // "?" S.Length // 2
Para caracteres unicode de 4 bytes de U+10000 a U+10ffff, JavaScript siempre se trata como dos caracteres (el atributo de longitud del personaje es 2)
comillas
La cadena de cadena se declara mediante cotizaciones dobles (") o cotizaciones individuales ('). Java declara cadenas con citas dobles y caracteres con citas individuales. Dado que EcMascript no tiene un tipo de caracteres, ninguna de estas dos anotaciones se pueden usar, pero las citas izquierda y derecha deben coincidir.
// Correcto var scolor1 = "rojo"; var scolor2 = 'rojo'; // error var scolor1 = "rojo '; var scolor2 =' rojo";
Una cadena delimitada por cotizaciones individuales puede contener cotizaciones dobles, y una cadena delimitada por citas dobles también puede contener cotizaciones individuales.
'Key = "Value"' "Es un largo viaje"
El código JavaScript se puede mezclar con cadenas de código HTML, y el código HTML también se mezclará con el código JavaScript. Por lo tanto, es mejor usar estilos de cotización separados en JavaScript y Código HTML cada uno
Las citas individuales se utilizan para representar cadenas en JavaScript, las citas dobles se utilizan para representar cadenas en los controladores de eventos HTML
<Button onClick = "alerta ('gracias')"> Haga clic en mí </botón>Bartosa
Si desea usar comillas individuales en una sola cadena delimitada de cotización, o cotizaciones dobles en una cadena delimitada de doble cita, debe usar una barra insegura (/)
Las situaciones comunes son que el apóstrofe y las citas individuales de la abreviatura inglesa y la escritura posesiva son el mismo carácter, por lo que debe usar una barra inalcadora (/) para escapar del apóstrofe.
'¿No preferiría este libro?' // "¿No preferirías este libro?" '¿Ella dice/' Hola/'?' // "¿Ella dice 'hola'?" "¿Dice ella/" Hola/"?" // "¿Ella dice" hola "?"
Personajes múltiples
Por defecto, las cadenas solo se pueden escribir en una línea, y si se dividen en múltiples líneas, informarán un error.
// Un error no capturado sintaxerror: token inválido o inesperado
'a
b
do';
En ECMAScript3, las cadenas deben escribirse en una línea
En ECMAScript5, las cadenas se pueden dividir en líneas, cada línea debe terminar con una barra inalcadora (/)
Si desea iniciar una nueva línea en una cantidad directa de cadena, puede usar caracteres de escape /n
// "onelongline" 'one/long/line'/*"twolines"*/'two/nlines'
Personajes de escape
En las cadenas de JavaScript, las versas de fondo (/) tienen usos especiales. Agregar un personaje después del símbolo de barra de invernadero no representa sus significados literal. Se utilizan para representar algunos caracteres especiales, llamados personajes de escape
/0 bytes vacíos
/norte
/ttable
/B espacio
/r entrar
/f de alimentación
// corte
/'Citas individuales
/"Cotizaciones dobles
/xnn representa un personaje en hexadecimal nn (n es 0-f), como /x41 representa 'a'
/unnnn en hexadecimal nnnn representa un carácter unicode (n es 0-f), como /u03a3 representa el carácter griego ε
Si se usa una barra insegura antes de un carácter no especial, se omite la barra insegura
'/a' // "A"
Si la cadena necesita contener una barra de inactividad, entonces se debe agregar otra barra insegura antes de la barra insegura para escapar a sí misma
"Prev // Next" // "anterior / Next"
Características
Las cadenas en JavaScript son inmutables. Una vez que se crea una cadena, nunca se puede cambiar. Para cambiar la cadena guardada por una variable, primero destruya la cadena original y luego llene la variable con otra cadena que contiene el nuevo valor
Se puede crear una nueva cadena concatenando otras cadenas a través del operador +.
var lang = "java"; lang = lang + "script"; // 'JavaScript'
El proceso real del código anterior es: primero crear una nueva cadena que pueda contener 10 caracteres y luego completar esta cadena con 'Java' y 'Script'. El último paso es destruir las cadenas originales 'Java' y 'script', porque estas dos cuerdas son inútiles
Este proceso ocurre en segundo plano y también es la razón por la cual las cadenas de fragmento son lentas en algunos navegadores antiguos (IE6), pero las versiones posteriores del navegador han resuelto este problema de ineficiencia
Turn String
Hay dos formas de convertir un valor en una cadena, toString () y string ()
[Nota] Puede usar una cadena vacía "" + un valor para convertir el valor en una cadena
toString ()
El primero es usar el método ToString () que tiene casi todos los valores. Este método devuelve la representación de cadena del valor correspondiente
[Nota] Undefinado y NULL no tienen este método
Undefined.ToString (); // Error null.ToString (); // error true.ToString (); // 'true'false.ToString (); //' falso'Abc'.ToString (); // 'ABC'1.23.ToString (); //' 1.23 '(}). Objeto] [1,2,3,4] .ToString (); // '1,2,3,4' (nueva fecha ()). ToString (); // "Sol 05 de junio de 2016 10:04:53 GMT+0800 (Tiempo estándar de China)"/AB/I.ToString (); // '/AB/I'
Cadena()
Puede usar la función de transformación String () cuando no sabe si el valor que desea convertir está indefinido o nulo.
La función de transformación String () sigue las siguientes reglas:
【1】 Si el valor es nulo, devuelve 'nulo'; Si el valor está indefinido, devuelva 'indefinido'
【2】 Si el valor no es nulo o indefinido, llame al método toString () y devuelva el valor de tipo original
【3】 Si el objeto devuelto por el método toString (), llame al método valueOf () para devolver el valor de tipo original. Si se devuelve el objeto devuelto por el método valueOf (), se informará un error
// "3" String ({toString: function () {return 3;}}) // "[Object Object]" String ({valueOf: function () {return 2;}}) // "3" String ({valueF: function () {return 2;}, toString: function () {return 3;})Atributo de longitud
Cada instancia del tipo de cadena tiene un atributo de longitud, lo que indica el número de caracteres en la cadena. Dado que las cadenas son inmutables, la longitud de las cuerdas también es inmutable.
El atributo de longitud de una cadena no se enumera en el bucle for/in, ni se puede eliminar a través del operador de eliminación.
[Nota] Para las cadenas S, el índice del último carácter es S.Length - 1
var str = "test"; console.log (str.length); // 4str.length = 6; console.log (str, str.length); // "test", 4
Método de ejemplo
Método común de objetos
El tipo de cadena es un tipo de envoltorio correspondiente a una cadena, heredando los tres métodos de los métodos generales del objeto ToString (), tolocaleString () y valueOf ().
【ToString ()】
El método toString () devuelve el valor de cadena original de la cadena
【TolocalEstring ()】
El método tolocaleString () devuelve el valor de cadena original de la cadena
【Valor de ()】
El método valueOf () devuelve el valor de cadena original de la cadena
console.log ("test" .valueOf ()); // "test" console.log ("test" .ToString ()); // "test" console.log ("test" .tolocaleString ()); // "test"Acceder a los métodos de caracteres
Hay cuatro métodos para acceder a los caracteres en cadenas: Chartat (), Brackets [], Charcodeat () y FromCharCode ().
【Chartat ()】
El método Charat () recibe un parámetro basado en la posición del carácter de 0 y devuelve el carácter en la posición especificada. Cuando el parámetro está vacío o NAN, el parámetro predeterminado es 0; Cuando el parámetro está fuera de rango, se devuelve una cadena vacía
var str = "hello"; console.log (str.charat (1)); // econsole.log (str.charat (-1)); // '' console.log (str.charat (10)); // '' console.log (str.charat ()); // h console.log (str.charat (nan)); //
El método Charat () implica la conversión de tipo implícita de la función número (). Si se convierte a un valor numérico, la cadena se emitirá de acuerdo con las reglas anteriores; Si se convierte en NAN, el personaje 0 se emitirá.
var str = "hola"; console.log (str.charat (true)); // 'e'console.log (str.charat (false)); //' h'console.log (str.charat ('abc')); // 'h'console.log (str.charat ({})); //' h'console.log (str.log ([2];[Nota] Los resultados de X.Charat (pos) y X.Substring (pos, pos+1), x.substr (pos, 1), x.slice (pos, pos+1) son iguales entre sí.
var str = "hello"; console.log (str.charat (1)); // 'e'console.log (str.substring (1,2)); //' e'console.log (str.slice (1,2)); // 'e'console.log (str.substr (1,1)); //' e 'e'
【Ramas】
ECMAScript5 define otra forma de acceder a los caracteres, utilizando soportes cuadrados más índices numéricos para acceder a caracteres específicos en una cadena. Si el parámetro está fuera de rango o NAN, la salida no está definida; Si no hay parámetro, se informará un error; Este método no tiene la conversión de tipo implícito de la función de transformación numérica (), pero el parámetro se puede convertir a un valor numérico cuando es una matriz de valores singulares.
[Nota] IE7-Browser no admite
var estr = "hola"; console.log (str [0]); // hconsole.log (str [[1]]); // econsole.log (str [falso]); // undefinedconsole.log (str [-1]); // undefinedconsole.log (str [nan]); // undefinedconsole
【Charcodeat ()】
El método Charcodeat () es similar al método Charat (), que recibe un parámetro basado en la posición del carácter de 0, pero devuelve una codificación unicode de 16 bits del carácter especificado. El valor de retorno es un entero de 16 bits, entre 0-65535, es decir, entre 0x0000-0xffff
Cuando el parámetro está vacío o NAN, el parámetro predeterminado es 0; Cuando el parámetro está fuera de rango, se devuelve NAN.
var str = "Hola"; console.log (str.charcodeat ()); // 104console.log (str.charcodeat (0)); // 104console.log (str.charcodeat (1)); // 1 01console.log (str.charcodeat (-1)); // nanconsole.log (str.charcodeat (10)); // nanconsole.log (str.charcodeat (nan)); // 104
Del mismo modo, el método Charcodeat () implica la conversión de tipo implícita de la función número (). Si se convierte a un valor numérico, el valor correspondiente se emitirá de acuerdo con las reglas anteriores; Si se convierte en NAN, se emitirá la codificación de carácter del personaje 0.
var str = "hola"; console.log (str.charcodeat (true)); // 101console.log (str.charcodeat (falso)); // 104console.log (st R.CharCodeat ('ABC')); // 104console.log (str.charcodeat ({})); // 104console.log (str.charcodeat ([2])); // l08【Fromcharcode ()】
El constructor de cadenas en sí tiene un método estático: fromCharCode (). La tarea de este método es recibir una o más codificaciones de caracteres y luego convertirlas en una cadena. Esencialmente, este método realiza la operación opuesta a partir del método de instancia Charcodeat (). Si el parámetro está vacío y nan, se devuelve una cadena vacía; Si el parámetro excede el rango de 0-65535, los caracteres de salida son incontrolables.
console.log (String.FromCharCode (104,101,108,108,111)); // 'hello'console.log (String.FromCharcode (0x6211,0x662f, 0x5c0f, 0x706b, 0x67f4)); // estoy un poco un poco Match'Console.log (String.FromCharCode ()); // '' Console.log (String.FromCharCode (Nan)); // '' Console.Log (String.FromCharCode (-1)); Console.Log (String.fromCharCode (65560));
Si un personaje toma cuatro bytes, debe dividirse en dos caracteres.
console.log (String.FromCharCode (0xd842, 0xdfb7)); // "�line"
Costura de cuerdas
Hay dos métodos para coser de cadena: concat () y más signo +
【Concat ()】
El método concat () se usa para empalmar una o más cadenas y devolver la nueva cadena obtenida por empalme, mientras que la cadena original no cambia. Si el parámetro (excepto el primer parámetro) no es una cadena, se convierte implícitamente en una cadena a través del método String (), y luego se realiza el empalme de cadena.
var stringValue = 'Hello'; var result = StringValue.concat ('World', '!'); console.log (resultado); // 'Hello World!' Console.log (StringValue); // 'Hello'[Nota] El primer parámetro solo puede ser una cadena. Si es de otros tipos (excepto matrices), se informará un error.
(1) .concat ('2'); // Informar un error
(verdadero) .concat ('falso'); // Informe un error
({}). Concat ('ABC'); // Informar un error
[Nota] Dado que la matriz también tiene un método concat (), los parámetros determinarán cómo convertir de acuerdo con si el parámetro que aparece primero es una matriz o una cadena.
'1,2,3,'. Concat ([4,5]); // '1,2,3,4,5'
[1,2,3] .concat (', 4,5'); // [1, 2, 3, ", 4,5"]]
【Operador más (+)】
Aunque concat () es un método utilizado específicamente para empalmar las cadenas, más uso del operador más (+) en la práctica. El uso del operador más es a menudo más simple que concat ()
var stringValue = 'hello'; console.log (stringValue.concat ('World', '!')); // '¡Hello World!' Console.log (StringValue + 'World' + '!'); // '¡Hola World!'[Nota] Las costuras de cadena se realizan cuando uno de los operandos es una cadena, o si el objeto se convierte en una cadena
1 + 2; // 3'1 ' + 2; //' 12'var o = {valueOf: function () {return '1';}}; o + 2; // '12'var o = {valueOf: function () {return 1;}}; o + 2; // 3;Crear subcadenas
Existen tres métodos para crear subcadenas: slice (), substr () y sustring ().
【rebanada()】
El método Slice (Start, End) requiere dos parámetros Inicio y FIN, que devuelve una subcadena en esta cadena desde la posición de inicio en la posición de inicio (pero no contiene) el carácter en la posición final; Si el final está indefinido o no existe, devuelve todos los caracteres desde la posición de inicio hasta el final de la cadena
Si el inicio es un número negativo, inicio = max (longitud + inicio, 0)
Si el final es un número negativo, end = max (longitud + final, 0)
Start and Fin no puede intercambiar posiciones
var stringValue = 'Hello World'; console.log (stringValue.slice ()); // 'Hello World'Console.log (stringValue (2)); //' llo world'console.log (stringValue.slice (2, invedefined)); // 'llo world'console.log (stringvalue.slice (2, -2);//' 'console.log (stringValue.slice (2, -20)); //' 'console.log (stringValue.slice (20)); //' 'console.log (stringValue.slice (-2,2)); //' 'console.log (stringValue.slice (-2, -20)); //' ' console.log (stringValue.slice (-2,20)); // 'ld'console.log (stringValue.slice (-20,2)); //' he'console.log (stringValue.slice (-20, -2)); // 'Hola' '
El método SLICE () implica la conversión de tipo implícita de la función de transformación de número (). Cuando el inicio se convierte en NAN, es equivalente a comenzar = 0; Cuando el extremo se convierte en nan (excepto que el final está indefinido), se emite una cadena vacía
var stringValue = 'Hello World'; console.log (stringValue.slice (nan)); // 'hello world'console.log (stringValue.slice ({})); // 'Hello World'Console.log (stringValue.slice (' 2 ', [5])); //' llo '【Subcandring ()】
El método de subcadena (inicio, final) requiere dos parámetros Inicio y FIN, que devuelve una subcadena en esta cadena desde la posición de inicio en la posición de inicio (pero no contiene) el carácter en la posición final; Si el final está indefinido o no existe, devuelve todos los caracteres desde la posición de inicio hasta el final de la cadena
Si cualquiera de los parámetros es nan o negativo, se reemplaza por 0
Si algún parámetro es mayor que la longitud de la cadena, se reemplaza por la longitud de la cadena
Si el inicio es mayor que el final, entonces se cambian sus valores
var stringValue = 'Hello World'; console.log (stringValue.substring ())); // 'Hello World'Console.log (stringValue.substring (2)); //' llo world'console.log (stringValue.substring (2, indefinido)); // 'llo world'console.log (stringValue.substring (20)); // '' console.log (stringValue.substring (-2,2)); // 'he'console.log (stringValue.s Ubstring (nan, 2)); // 'he'console.log (stringValue.substring (-2,20)); //' he'Console.log (stringValue.substring (-2,20)); // world'console.log (stringValue.substring (3,2)); // 'l'console.log (stringValue.substring (3, nan)); //' hel 'console.log (stringValue.substring (-20,2)); //' he'console.log (stringValue.substring (-20, -2)); // '' '' ''
Del mismo modo, el método substring () también implica la conversión de tipo implícita de la función de transformación numérica ()
var stringValue = 'Hello World'; console.log (stringValue.subString (verdadero, [3])); // 'el'console.log (stringValue.substring (null, undefined)); //' hola world'console.log (stringvalue.substring (null, sinfinado)); // 'Hola World'Console.log (stringValue.substring ({}))); // 'Hello World'console.log (stringValue.substring (' 2 ', [5])); //' llo '【SubStr ()】
El método SubStr (Start, End) requiere dos parámetros Inicio y FIN. End representa el número de caracteres en la subcadena devuelta; Este método devuelve una subcadena de caracteres finales que comienzan desde el personaje en la posición de inicio en esta cadena; Si el final está indefinido o no existe, devuelve todos los caracteres desde la posición de inicio hasta el final de la cadena
Si el inicio es un número negativo, inicio = max (longitud + inicio, 0)
Si el inicio es nan, es equivalente a iniciar = 0
Si el final es un número negativo o nan, end = 0, por lo tanto, se devuelve una cadena vacía
Start and Fin no puede intercambiar posiciones
[Nota] Este método no es el estándar de ECMAScript y se ha desaprobado
[Nota] IE8-El navegador tiene un problema con el manejo de la situación en la que se pasan los valores negativos a substr (), devuelve la cadena original
var stringValue = 'Hello World'; console.log (stringValue.substr ()); // 'Hello World'Console.log (stringValue.substr (2)); //' llo world'console.log (stringValue.substr (2, invasado)); // 'llo World'Console.log (stringValue.substr (2, nan)); // '' console.log (stringValue.substr (nan, 2)); // 'he'console.log (stringValue.substr (20)); //' 'console.log alue.substr (-2,3)); // 'ld'console.log (stringValue.substr (-2,20)); //' ld'console.log (stringvalue.substr (-20,2)); // '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' sess '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' Sets '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' '' console.log (stringValue.substr (2,5)); // llo w
Del mismo modo, el método subStr () también implica la conversión de tipo implícita de la función de transformación numérica ()
var stringValue = 'Hello World'; console.log (stringValue.substr (true, [3])); // 'el'console.log (stringValue.substr (null, undefined)); //' hola world'console.log (stringValue.substr ({})); // 'Hola world'console.log (stringValue.substr ('2', [5]))); // 'llo w'Posición de cadena
Hay dos formas de encontrar la ubicación de las subcadenas de las cadenas: indexOf () y lastindexof ()
【IndexOf ()】
IndexOf (SearchString, START) El método recibe dos parámetros: SearchString e Inicio, devolviendo la ubicación donde aparece por primera vez el SearchString, y si no se encuentra, devuelve -1
Este método llama implícitamente la función de transformación String () para convertir el valor de búsqueda de SearchString en cadena; Llama implícitamente a la función de transformación número () para convertir el valor de inicio no numérico (excepto indefinido) al valor numérico al valor numérico
SearchString representa la subcadena a buscar; El inicio representa la posición inicial de la búsqueda. Si se ignora el parámetro o el parámetro está indefinido, nan o negativo, inicio = 0
var string = 'Hola mundo world';console.log(string.indexOf('ld'));//9console.log(string.indexOf('ld',undefined));//9console.log(string.indexOf('ld',NaN));//9console.log(string.indexOf('ld',-1));//9console.log(st ring.indexof ('ld',-1)); // 9console.log (string.indexof ('ld',-1)); // 9console.log (string.indexof ( 'ld',-1)); // 9console.log (string.indexof ('ld',-1)); // 9console.log (string.indexof ('ld',-1)); // 9 console.log (string.indexof ('ld', 10)); // 15console.log (string.indexof ('ld', [10])); // 15console.log (string.index De ('verdadero', [10])); //-1console.log (string.indexof (false, [10])); //-1console.log (string.indexof (false, [10])); //-1【Lastindexof ()】
El método LastIndexof (SearchString, Start) recibe dos parámetros: SearchString e Inicio, y devuelve la última vez que aparece SearchString. Si no se encuentra, devuelve -1
Del mismo modo, este método llama implícitamente la función de transformación String () para convertir los valores de no cadena de búsqueda en cadenas; Llama implícitamente a la función de transformación número () para convertir los valores de inicio no numéricos (excepto indefinidos) a valores numéricos.
SearchString representa la subcadena a buscar; El inicio representa la posición inicial de la búsqueda. Si se ignora el parámetro o el parámetro está indefinido o nan, iniciar = longitud - 1
[Nota] A diferencia del método indexOf (), si el inicio es negativo, el método devuelve -1
var string = 'Hello World World'; console.log (string.indexof ('ld')); // 9console.log (string.indexof ('ld', undefined)); // 9console.log (string.indexof ('ld', nan); // 9console.log (string.indexof ('ld',-1); console.log (string.indexof ('ld', 10)); // 15console.log (string.indexof ('ld', [10])); // 15console.log (string.index De ('verdadero', [10])); //-1console.log (string.indexof (false, [10])); //-1console.log (string.indexof (false, [10])); //-1【Consejos】 Descubra todas las subcadenas que cumplan con los criterios de la cadena
Todas las subcadenas coincidentes se pueden encontrar mediante bucle para llamar a IndexOf () o LastIndexOf ()
function allindexof (str, value) {var result = []; var pos = str.indexof (valor); while (pos> -1) {result.push (pos); pos = str.indexof (value, pos+value.length);} return resultado;} console.log (allindexof ('hellhellhell', 'll')); // [2,7,12]【recortar()】
ECMAScript5 define el método TRIM () para todas las cadenas. Este método crea una copia de la cadena, elimina todos los caracteres en blanco en el prefijo y el sufijo, y devuelve el resultado
Dado que el método trim () devuelve una copia de la cadena, los espacios de prefijo y sufijo en la cadena original permanecerán sin cambios
[Nota] El navegador IE8 no es compatible
var string = 'Hello World'; console.log (string.trim ()); // 'Hello World'Console.log (String); //' Hello World '
Los caracteres en blanco incluyen no solo espacios, sino también caracteres de pestaña (/t), descansos de línea (/n) y caracteres de retorno de carro (/r)
'/r/nabc /t'.trim () //' ABC '
Además, Firefox, Safari y WebKit también admiten Trimright no estándar () para eliminar los personajes de espacios blancos al final de las cuerdas
var string = 'Hello World'; console.log (string.trimright ()); // 'Hello World';
【Consejos】 Use Trim () para determinar si el carácter ingresado está vacío
if (usame.trim (). longitud) {alert ('correcto');} else {alerta ('error');}【Consejos】 Simular trim () con expresión regular
función fntrim (str) {return str.replace (/^/s+|/s+$/, '')} console.log (fntrim ('Hello World')); // 'Hello World'Conversión de casos
Hay cuatro métodos involucrados en la conversión de casos de cadena en EcMascript: TOLOWERCASE (), TOLOCALELOWERCATER (), TOUPPERCASE () y TOLOCALEUPPERCASE ()
tolowercase () y toupperCase () son dos métodos clásicos, tomados del mismo método de nombre en java.lang.string. Los métodos TolocalElowerCase () y TolocaleUpperCase () se implementan para regiones específicas. Para algunas regiones, el método para las regiones es el mismo que los resultados obtenidos por sus métodos generales. Sin embargo, algunos idiomas (como el turco) aplicarán reglas especiales para la conversión de casos de Unicode. En este momento, el método para las regiones debe usarse para garantizar que se logre la conversión correcta.
【Touppercase ()】
El método touppercase () convierte la cadena en mayúsculas
【Tolowercase ()】
El método tolowercase () convierte la cadena en minúsculas
【TolocaleUpperCase ()】
El método tolocaleUpperCase () convierte la cadena en mayúsculas (para la región)
【Tolocalelowercase ()】
El método TolocalElowerCase () convierte la cadena en minúsculas (para la región)
[Nota] Es más seguro usar un método específico de la región sin saber en qué lugar se ejecutará su código.
var string = 'Hello World'; console.log (string.tolowerCase ()); // hola worldconsole.log (string.tolocalElowerCase ()); // hola worldconsole.log (string.toUpperperCase ()); // hello worldconsole.log (string.tolocaleuppercase ()); // hello world
Estos 4 métodos no admiten String () Conversión de tipo implícito, solo admiten tipos de cadenas
(verdadero) .tolowercase (); // Informar un error
(2) .tolocalelowercase (); // Informe un error
({}). TOUPPERCASE (); // Informar un error
([]). TOLOCALUPPERCASE (); // Informar un error
[Nota] El método de conversión de casos se puede usar continuamente
var string = 'Hello World'; console.log ((String.ToUpperCase ()). TolowerCase ()); // Hello World
【Localecompare ()】
El método LocalEcompare () se utiliza para comparar dos cadenas, siguiendo las siguientes reglas
[1] Si la cadena debe clasificarse antes del parámetro de cadena en el alfabeto, se devuelve un número negativo (principalmente -1)
【2】 Si la cadena es igual al parámetro de cadena, return 0
【3】 Si la cadena debe colocarse después del parámetro de cadena en el alfabeto, se devolverá un número positivo (en la mayoría de los casos 1)
var stringValue = 'Yellow'; console.log (stringValue.localecompare ('ladrillo')); // 1 'y'> 'b'console.log (stringValue.localecompare (' Yellow ')); // 0' Yellow '==' Yellow'console[Nota] Aunque las letras mayúsculas en el alfabeto están frente a letras minúsculas, por lo que letras mayúsculas <letras minúsculas. Pero el método LocalEcompare () tendrá en cuenta la situación de clasificación del lenguaje natural y el rango de 'B' frente a 'A'
console.log ('b'.localecompare (' a ')); // 1console.log (' b '>' a '); // falseconsole.log (' b'.localecompare ('a')); // 1console.log ('b'> 'a'); // true verdaderoLo anterior es el conocimiento relevante sobre la explicación detallada del tipo de cadena de cadena del sistema de tipo JavaScript introducido por el editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!