O JavaScript não representa um único caractere, apenas um tipo de sequência de string, e o tipo de caractere é equivalente a uma string que contém apenas um caractere.
String String é um tipo de dados básico de JavaScript. Ao mesmo tempo, o JavaScript também suporta objetos de string, que é um objeto de wrapper com valores originais. O JavaScript converte automaticamente entre o formulário original e a forma de objeto quando necessário. Este artigo apresentará o tipo de string original e o objeto Wrapper
definição
O tipo de string é uma sequência de caracteres que consistem em caracteres unicode de 16 bits entre aspas.
Os tipos de string são frequentemente usados para representar dados de texto e, neste momento, cada elemento na string é considerado um ponto de código. Cada elemento é considerado para ocupar uma posição nessa sequência, indexando essas posições com valores não negativos. O primeiro personagem começa na posição 0, o segundo caractere está na posição 1 e assim por diante
O comprimento da string é o número de elementos (por exemplo, um valor de 16 bits). A corda vazia tem comprimento zero, por isso não contém nenhum elemento
Codificação unicode
Todos os caracteres podem ser gravados na forma de '/uxxxx', onde xxxx representa a codificação unicode do caractere. Por exemplo, /U00A9 representa o símbolo de direitos autorais
var s = '/u00a9'; s // "©"
Se uma string contiver dados de texto reais, cada elemento será considerado uma unidade UTF-16 separada. Cada caractere é armazenado em formato UTF-16 de 16 bits (ou seja, 2 bytes)
Mas o UTF-16 tem dois comprimentos: para caracteres entre U+0000 e U+FFFF, o comprimento é de 16 bits (ou seja, 2 bytes); Para os caracteres entre U+10000 e U+10ffff, o comprimento é de 32 bits (ou seja, 4 bytes) e os dois primeiros bytes estão entre 0xd800 e 0xdbff, e os dois últimos bytes estão entre 0xdc00 e 0xdfff e os dois últimos bytes estão entre 0xdc00 e 0.
Por exemplo, o caractere "?" correspondente a U+1d306 é escrito como UTF-16, que é 0xd834 0xdf06. O navegador reconhecerá corretamente esses quatro bytes como um caractere, mas o comprimento do personagem dentro do JavaScript é sempre fixado em 16 bits, e esses quatro bytes serão tratados como dois caracteres.
var s = '/ud834/udf06'; s // "?" s.length // 2
Para caracteres unicode de 4 bytes de U+10000 a U+10ffff, JavaScript é sempre tratado como dois caracteres (o atributo de comprimento do personagem é 2)
aspas
String String é declarada por citações duplas (") ou citações únicas ('). Java declara strings com citações e caracteres duplos com citações únicas. Como o Ecmascript não possui um tipo de caractere, qualquer uma dessas duas notações pode ser usada, mas as cotações esquerda e direita devem corresponder.
// correto var scolor1 = "vermelho"; var scolor2 = 'vermelho'; // erro var scolor1 = "vermelho '; var scolor2 =' vermelho";
Uma string delimitada por citações únicas pode conter cotações duplas, e uma string delimitada por citações duplas também pode conter citações únicas.
'key = "value"' "é uma longa jornada"
O código JavaScript pode ser misturado com seqüências de caracteres do código HTML, e o código HTML também será misturado com o código JavaScript. Portanto, é melhor usar estilos de cotação separados em JavaScript e código HTML cada
Citações únicas são usadas para representar strings em javascript, citações duplas são usadas para representar strings nos manipuladores de eventos HTML
<button onclick = "alert ('obrigado')"> clique em mim </botão>Barragem
Se você deseja usar citações únicas em uma única string delimitada por citações, ou citações duplas em uma string delimitada por cotação dupla, você precisa usar uma barra de barragem (/)
Situações comuns são que o apóstrofo e as citações únicas da abreviação inglesa e da escrita possessiva são o mesmo personagem; portanto, você deve usar uma barra de barragem (/) para escapar do apóstrofo.
'Você não preferiria este livro?' // "Você não prefere este livro?" 'Ela disse/' Olá/'?' // "Ela disse 'Olá'?" "Ela diz/" Olá/"?" // "Ela disse" Olá "?"
Caracteres multi-line
Por padrão, as strings só podem ser escritas em uma linha e, se forem divididas em várias linhas, elas relatarão um erro.
// Um erro de sintaxe não capturado: Token inválido ou inesperado
'um
b
c ';
No ECMAScript3, as strings devem ser escritas em uma linha
No ECMAScript5, as strings podem ser divididas em linhas, cada linha deve terminar com uma barra de barragem (/)
Se você quiser iniciar uma nova linha em uma quantidade direta de string, você pode usar caracteres de escape /n
// "OneLongline" 'One/Long/Line'/*"Twolines"*/'Two/nlines'
Escapar de personagens
Nas cordas JavaScript, as barras (/) têm usos especiais. Adicionar um personagem após o símbolo da barra de barragem não representa seus significados literais. Eles são usados para representar alguns caracteres especiais, chamados personagens de escape
/0 bytes vazios
/n
/ttable
/B Espaço
/r Digite
/f papel de alimentação
// Slash
/'Citações únicas
/"Citações duplas
/xnn representa um personagem em nn hexadecimal (n é 0-f), como /x41 representa 'a'
/unnnn em nnnn hexadecimal representa um caractere unicode (n é 0-f), como /u03a3 representa o caractere grego ε
Se uma barra de barriga for usada antes de um caractere não especial, a barra de barriga é omitida
'/a' // "a"
Se a string precisar conter uma barra de barra
"Prev // Next" // "Prev / Next"
Características
As cordas em JavaScript são imutáveis. Depois que uma string é criada, ela nunca pode ser alterada. Para alterar a string salva por uma variável, primeiro destrua a string original e depois preencha a variável com outra string contendo o novo valor
Uma nova string pode ser criada concatenando outras strings através do operador +.
var lang = "java"; lang = lang + "script"; // 'JavaScript'
O processo real do código acima é: primeiro crie uma nova string que possa conter 10 caracteres e depois preencha essa string com 'java' e 'script'. O último passo é destruir as cordas originais 'java' e 'script', porque essas duas cordas são inúteis
Esse processo ocorre em segundo plano e também é a razão pela qual as cordas do trecho são lentas em alguns navegadores antigos (IE6), mas as versões posteriores do navegador resolveram esse problema de ineficiência
Gire a corda
Existem duas maneiras de converter um valor em uma string, tostring () e string ()
[Nota] Você pode usar uma string vazia "" + um valor para converter o valor em uma string
ToString ()
O primeiro é usar o método ToString () que quase todo valor tem. Este método retorna a representação da string do valor correspondente
[Nota] indefinido e nulo não tem esse método
Undefined.ToString (); // Erro null.toString (); // Erro true.toString (); // 'true'false.tostring (); //' false''abc'.toString (); // 'abc'1.23.tostring (); //' 1.23 '({{{{{{{{}); Objeto] [1,2,3,4] .ToString (); // '1,2,3,4' (new Date ()).Corda()
Você pode usar a função de transformação String () quando não sabe se o valor que deseja converter é indefinido ou nulo.
A função de transformação string () segue as seguintes regras:
【1】 Se o valor for nulo, retorne 'nulo'; Se o valor for indefinido, retorne 'indefinido'
【2】 Se o valor não for nulo ou indefinido, ligue para o método ToString () e retorne o valor do tipo original
【3】 Se o objeto retornado pelo método tostring (), ligue para o método ValueOf () para retornar o valor do tipo original. Se o objeto retornado pelo método valueof () for retornado, um erro será relatado
// "3" string ({tostring: function () {return 3;}}) // "[objeto objeto]" string ({valueof: function () {return 2;}}) // "3" string ({valueof: function () {return 2;}, tostring: function () {return 3;Atributo de comprimento
Cada instância do tipo de string possui um atributo de comprimento, indicando o número de caracteres na string. Como as cordas são imutáveis, o comprimento das cordas também é imutável.
O atributo de comprimento de uma string não é enumerado no loop for/in, nem pode ser excluído através do operador de exclusão.
[Nota] Para strings, o índice do último caractere é S. Length - 1
var str = "test"; console.log (str.length); // 4str.length = 6; console.log (str, str.length); // "teste", 4
Método de exemplo
Método comum do objeto
O tipo de string é um tipo de wrapper correspondente a uma string, herdando os três métodos dos métodos gerais do objeto do objeto ToString (), tolocalestring () e valueof ().
【ToString ()】
O método tostring () retorna o valor original da string da string
【Tolocalestring ()】
O método tolocalestring () retorna o valor original da string da string
【Valueof ()】
O método valueof () retorna o valor original da string da string
console.log ("teste" .Valueof ()); // "test" console.log ("test" .toString ()); // "teste" console.log ("test" .tolocalestring ()); // "teste"Acesse métodos de caracteres
Existem quatro métodos para acessar caracteres em Strings: Chartat (), Suportes [], Charcodeat () e FromCharCode ().
【Chartat ()】
O método Charat () recebe um parâmetro com base na posição do caractere de 0 e retorna o caractere na posição especificada. Quando o parâmetro está vazio ou NAN, o parâmetro padrão é 0; Quando o parâmetro está fora de alcance, uma string vazia é retornada
var str = "hello"; console.log (str.charat (1)); // econSole.log (str.charat (-1)); // '' console.log (str.charat (10)); // '' '' '' ');
O método charat () envolve a conversão de tipo implícito da função número (). Se convertido em um valor numérico, a string será emitida de acordo com as regras acima; Se convertido em NAN, o 0º caractere será emitido.
var str = "Hello"; console.log (str.charat (true)); // 'e'console.log (str.charat (false)); //' h'console.log (str.charat ('abc'); // 'h'console.log (str.char ({});[Nota] Os resultados de X.Charat (POS) e X.Substring (POS, POS+1), X.SUBSTR (POS, 1), X.SLICE (POS, POS+1) são iguais um ao outro.
var str = "hello"; console.log (str.charat (1)); // 'e'console.log (str.substring (1,2)); //' e'console.log (str.slice (1,2)); // 'e'cole.log (str.substr (1,1);
【Ramos】
O ECMAScript5 define outra maneira de acessar caracteres, usando colchetes quadrados e índices numéricos para acessar caracteres específicos em uma string. Se o parâmetro estiver fora de intervalo ou NAN, a saída será indefinida; Se não houver parâmetro, será relatado um erro; Este método não possui a conversão de tipo implícito da função de transformação número (), mas o parâmetro pode ser convertido em um valor numérico quando é uma matriz de valores singulares.
[Nota] O navegador IE7 não suporta
var str = "hello"; console.log (str [0]); // hconsole.log (str [[1]]); // econSole.log (str [false]); // undefinedconsole.log (str [-1]); undefinedconsole.log (str [nan];
【Charcodeat ()】
O método Charcodeat () é semelhante ao método Charat (), que recebe um parâmetro baseado na posição do caractere de 0, mas retorna uma codificação de unicode de 16 bits do caractere especificado. O valor de retorno é um número inteiro de 16 bits, entre 0-65535, ou seja, entre 0x0000-0xffff
Quando o parâmetro está vazio ou NAN, o parâmetro padrão é 0; Quando o parâmetro está fora de intervalo, a NAN é retornada.
var str = "Olá"; 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
Da mesma forma, o método Charcodeat () envolve a conversão de tipo implícito da função número (). Se convertido em um valor numérico, o valor correspondente será emitido de acordo com as regras acima; Se convertido em NAN, a codificação do caractere do 0º caractere será emitida.
var str = "Olá"; console.log (str.charcodeat (true)); // 101console.log (str.charcodeat (false)); // 104console.log (st r.charcodeat ('abc')); // 104console.log (str.charcodeat ({})); // 104console.log (str.charcodeat ([2])); // l08【FromCharCode ()】
O próprio construtor de string possui um método estático: FromCharCode (). A tarefa desse método é receber uma ou mais codificações de caracteres e depois convertê -las em uma string. Essencialmente, esse método executa a operação oposta do método de instância Charcodeat (). Se o parâmetro estiver vazio e nan, uma string vazia será retornada; Se o parâmetro exceder o intervalo de 0-65535, os caracteres de saída serão incontroláveis.
Console.log (String.FromCharcode (104,101,108,108,111)); // 'hello'console.log (string.fromcharcode (0x6211,0x662f, 0x5c0f, 0x706b, 0x67f4) //' i ã match'console.log (string.fromCharcode ()); // '' console.log (string.fromcharcode (nan)); // '' console.log (string.fromCharcode (-1)); console.log (string.fromCharcode (65560));
Se um personagem ocupar quatro bytes, ele precisa ser dividido em dois caracteres.
console.log (String.FromCharcode (0xd842, 0xdfb7)); // "�Line"
Costura de cordas
Existem dois métodos para costura de cordas: concat () e mais sinal +
【Concat ()】
O método concat () é usado para unir uma ou mais cordas e retornar a nova string obtida por splicing, enquanto a string original não muda. Se o parâmetro (exceto o primeiro parâmetro) não for uma string, ele será implicitamente convertido em uma string através do método String () e, em seguida, a string de splicing será executada.
var stringValue = 'hello'; var resultado = stringValue.Concat ('World', '!'); Console.log (resultado); // 'Hello World!' Console.log (StringValue); // 'Hello'[Nota] O primeiro parâmetro pode ser apenas uma string. Se for de outros tipos (exceto matrizes), será relatado um erro.
(1) .CONCAT ('2'); // Relate um erro
(verdadeiro) .CONCAT ('false'); // Relate um erro
({}). Concat ('ABC'); // Relate um erro
[Nota] Como a matriz também possui um método concat (), os parâmetros determinarão como converter de acordo com o parâmetro que aparece primeiro é uma matriz ou uma string.
'1,2,3,'. Concat ([4,5]); // '1,2,3,4,5'
[1,2,3] .CONCAT (', 4,5'); // [1, 2, 3, ", 4,5"]
【Plus Operator (+)】
Embora o concat () seja um método usado especificamente para unir seqüências de caracteres, mais uso do operador mais (+) na prática. Usando o operador Plus geralmente é mais simples que concat ()
var stringValue = 'hello'; console.log (StringValue.Concat ('World', '!')); // 'Hello World!' Console.log (StringValue + 'World' + '!'); // 'Hello World!'[Nota] A costura de string é realizada quando um dos operandos é uma string ou se o objeto for convertido em uma string
1 + 2; // 3'1 ' + 2; //' 12'var o = {valueof: function () {return '1';}}; o + 2; // '12'var o = {valueof: function () {return 1;}}; o + 2; // 3Criar substringas
Existem três métodos de criação de substringas: Slice (), Substr () e Substring ().
【fatiar()】
O método Slice (Start, End) requer dois parâmetros iniciais e finais, que retornam uma substring nessa sequência do caractere na posição inicial para (mas não contém) o caractere na posição final; Se o fim for indefinido ou não existir, ele retornará todos os personagens da posição inicial ao final da string
Se o início for um número negativo, start = max (comprimento + start, 0)
Se o fim for um número negativo, end = max (comprimento + final, 0)
Iniciar e final não podem trocar posições
var stringValue = 'Hello world'; console.log (stringValue.slice ()); // 'hello world'console.log (stringValue.slice (2)); //' llO World'Console.log (stringValue.slice (2, 2, undefin); // 'Llo World'; 'Console.log (StringValue.slice (2, -20)); //' 'Console.log (StringValue.slice (20)); //' 'Console.log (StringValue.slice (-2,2)); //' 'Console.log (String.slice (-2, -20)); //' '' ' console.log (stringValue.slice (-2,20)); // 'ld'console.log (stringValue.slice (-20,2)); //' he'console.log (stringValue.slice (-20, -2)); // 'hello wor'
O método Slice () envolve o tipo implícito de conversão da função de transformação número (). Quando o início é convertido em nan, é equivalente a iniciar = 0; Quando o fim é convertido em nan (exceto que final é indefinido), uma string vazia é saída
var stringValue = 'Hello World'; console.log (stringValue.slice (nan)); // 'hello world'console.log (stringValue.slice (0, nan)); //' 'console.gog (stringValue.slice (true, [3])); //' eL'Consol.Log (StringValue.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice.Slice. (3)); World'Console.log (StringValue.slice ({})); // 'Hello World'console.log (StringValue.slice (' 2 ', [5])); //' llO '【Substring ()】
O método da substring (start, end) requer dois parâmetros iniciais e finais, que retornam uma substring nessa sequência do caractere na posição inicial para (mas não contém) o caractere na posição final; Se o fim for indefinido ou não existir, ele retornará todos os personagens da posição inicial ao final da string
Se um parâmetro for nan ou negativo, ele será substituído por 0
Se algum parâmetro for maior que o comprimento da string, ele será substituído pelo comprimento da string
Se o início for maior que o fim, seus valores serão trocados
var stringValue = 'Hello World'; console.log (stringValue.substring ()); // 'hello world'console.log (stringValue.substring (2)); //' llo World'Console.log (StringValue.Substring (2, indeciso); // '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)); // 'Olá World'Console.log (StringValue.substring (3,2)); // 'l'l' Console.log (stringValue.substring (3, nan)); //' hel'console.log (stringValue.substring (-20,2);
Da mesma forma, o método substring () também envolve a conversão de tipo implícito da função de transformação do número ()
var stringValue = 'Hello World'; console.log (StringValue.substring (true, [3])); // 'el'console.log (stringValue.substring (null, indefinido); //' hello world'console.log (string.substring (null, underfined); World'Console.log (StringValue.substring ({})); // 'hello world'console.log (stringValue.substring (' 2 ', [5])); //' llO '【Substr ()】
O método Substr (Start, End) requer dois parâmetros iniciais e finais. O final representa o número de caracteres na substring retornada; Este método retorna uma substring de caracteres finais, começando pelo personagem na posição inicial nesta string; Se o fim for indefinido ou não existir, ele retornará todos os personagens da posição inicial ao final da string
Se o início for um número negativo, start = max (comprimento + start, 0)
Se o início for nan, é equivalente a iniciar = 0
Se o fim for um número negativo ou nan, end = 0, assim uma sequência vazia é retornada
Iniciar e final não podem trocar posições
[Nota] Este método não é o padrão ECMAScript e foi preterido
[Nota] IE8-O navegador tem um problema em lidar com a situação em que os valores negativos são passados para o substr (), ele retorna a string original
var stringValue = 'Hello World'; console.log (StringValue.substr ()); // 'hello world'console.log (stringValue.substr (2)); //' llO World'console.log (stringValue.substr (2, indefinido); // 'llO World'console.log (StringValue.substr (2, nan)); // '' console.log (stringValue.substr (nan, 2)); // 'he'console.log (stringValue.substr (20)); //' 'console.log (stringv alue.substr(-2,3));//'ld'console.log(stringValue.substr(-2,20));//'ld'console.log(stringValue.substr(-20,2));//''''''''''''''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' console.log (stringValue.substr (2,5)); // llO w
Da mesma forma, o método substr () também envolve o tipo implícito de conversão da função de transformação do número ()
var stringValue = 'Hello World'; console.log (StringValue.substr (true, [3])); // 'el'console.log (stringValue.substr (null, indefinido)); //' hello world'console.log (string.substr ({}); // 'Hello World'console.log (StringValue.substr ('2', [5])); // 'llO W'Posição da string
Existem duas maneiras de encontrar a localização das substringas de Strings: indexOf () e LastIndexOF ()
【IndexOf ()】
O método IndexOF (SearchString, Start) recebe dois parâmetros: SearchString e Start, retornando o local onde a Pesquisa aparece primeiro e, se não for encontrada, retorna -1
Este método chama implicitamente a função de transformação de string () para converter o valor não string de pesquisa em string em string; chama implicitamente a função de transformação número () para converter o valor não numérico (exceto indefinido) em valor numérico em valor numérico
O SearchString representa a substring a ser pesquisada; Iniciar representa a posição inicial da pesquisa. Se o parâmetro for ignorado ou o parâmetro for indefinido, nan ou negativo, start = 0
var string = 'Hello World mundo '; console.log (string.indexof (' ld '))); // 9console.log (string.indexOf (' ld ', indefinido)); // 9console.log (string.indexof (' ld ', nan)); // 9console.log (string.indexof (' ld ',,::-1); 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 ('true', [10])); //-1console.log (string.indexof (false, [10]); //-1console.log (string.indexof (false, [10])); //-1【LastIndexOf ()】
O método LastIndexOF (SearchString, Start) recebe dois parâmetros: SearchString e Start e retorna na última vez em que o SearchString aparece. Se não for encontrado, retorna -1
Da mesma forma, esse método chama implicitamente a função de transformação String () para converter valores de não string de pesquisa em seqüências de cordas; Chama implicitamente a função de transformação número () para converter valores não numéricos (exceto indefinidos) em valores numéricos.
O SearchString representa a substring a ser pesquisada; Iniciar representa a posição inicial da pesquisa. Se o parâmetro for ignorado ou o parâmetro for indefinido ou nan, start = comprimento - 1
[Nota] Ao contrário do método indexOf (), se o início for negativo, o método retorna -1
var string = 'Hello World World'; console.log (string.indexOf ('ld')); // 9console.log (string.indexof ('ld', indefinido); // 9console.log (string.indexOf ('ld', nan)); console.log (string.indexof ('ld', 10)); // 15console.log (string.indexOf ('ld', [10])); // 15console.log (string.index De ('true', [10])); //-1console.log (string.indexof (false, [10]); //-1console.log (string.indexof (false, [10])); //-1【Dicas】 Descubra todas as substringas que atendem aos critérios da corda
Todas as substringas correspondentes podem ser encontradas em loop para chamar indexof () ou lastIndexof ()
função allIndexOf (str, value) {var resultado = []; var pos = str.indexOf (value); enquanto (pos> -1) {resultado.push (pos); pos = str.indexOf (valor, pos+valor.length);} resultado de retorno;} console.log (allIndexOF ('hellhellhell', 'll')); // [2,7,12]【aparar()】
O ECMAScript5 define o método TRIM () para todas as cordas. Este método cria uma cópia da string, exclui todos os caracteres em branco no prefixo e sufixo e retorna o resultado
Como o método TRIM () retorna uma cópia da string, o prefixo e os espaços de sufixo na string original permanecerão inalterados
[Nota] IE8-navegador não suporta
var string = 'hello world'; console.log (string.trim ()); // 'hello world'console.log (string); //' hello world '
Os caracteres de espaço em branco incluem não apenas espaços, mas também caracteres de guia (/t), quebras de linha (/n) e caracteres de retorno de carro (/r)
'/r/nabc /t'.trim () //' abc '
Além disso, Firefox, Safari e Webkit também suportam Trimright não-padrão () para excluir caracteres de espaço em branco no final de Strings
var string = 'hello world'; console.log (string.trimright ()); // 'hello world';
【Dicas】 Use Trim () para determinar se o caractere inserido está vazio
if (usename.trim (). length) {alert ('correto');} else {alert ('erro');}【Dicas】 Simule Trim () com expressão regular
função fntrim (str) {return str.replace (/^/s+|/s+$/, '')} console.log (fntrim ('hello world'); // 'hello world'Conversão de casos
Existem quatro métodos envolvidos na conversão de casos de cordas no ecmascript: tolowercase (), tolocalelowercase (), touppercase () e tolocaleupcase ()
TolowerCase () e ToupPercase () são dois métodos clássicos, emprestados do mesmo método de nome em java.lang.string. Os métodos TolocalelowerCase () e Tolocaleupcase () são implementados para regiões específicas. Para algumas regiões, o método para regiões é o mesmo que os resultados obtidos por seus métodos gerais. No entanto, alguns idiomas (como turcos) aplicarão regras especiais para a conversão de casos Unicode. No momento, o método para regiões deve ser usado para garantir que a conversão correta seja alcançada.
【Touppercase ()】
O método touppercase () converte a string em maiúsculas
【TolowerCase ()】
Método TolowerCase () converte string em minúsculas
【Tolocaleupcase ()】
O método Tolocaleupcase () converte a string em maiúsculas (para região)
【TolocalelowerCase ()】
TOLOCALELOWERCase () Método converte a string em minúsculas (para região)
[Nota] É mais seguro usar um método específico da região sem saber em qual local seu código será executado.
var string = 'hello world'; console.log (string.tolowercase ()); // hello worldconsole.log (string.tolocaleLowerCase ()); // hello worldconsole.log (string.touppercase ()); hello worldconsole.log (string.tolocaleupcase ();
Esses 4 métodos não suportam String () Tipo implícito de conversão, suportam apenas tipos de string
(true) .tolowerCase (); // Relate um erro
(2) .TolocAlelowerCase (); // Relate um erro
({}). touppercase (); // Relate um erro
([]). Tolocaleupcase (); // Relate um erro
[Nota] O método de conversão do caso pode ser usado continuamente
var string = 'Hello World'; console.log ((String.ToupPercase ()). TolowerCase ()); // Hello World
【LOCALECOMPARE ()】
O método localECompare () é usado para comparar duas strings, seguindo as seguintes regras
[1] Se a string deve ser classificada antes do parâmetro String no alfabeto, um número negativo será retornado (principalmente -1)
【2】 Se a string for igual ao parâmetro da string, retorne 0
【3】 Se a string for colocada após o parâmetro da string no alfabeto, um número positivo será retornado (na maioria dos casos 1)
var stringValue = 'amarelo'; console.log (stringValue.localecompare ('tijolo')); // 1 'y'> 'b'console.log (stringValue.localecompare (' amarelo '); // 0' amarelo =='console.log (stringValue.localecare (0 '==''console.Log.l);[Nota] Embora as letras maiúsculas do alfabeto estejam em frente às letras minúsculas, então letras maiúsculas <letras minúsculas. Mas o método localCompare () levará em consideração a situação de classificação da linguagem natural e a classificação 'B' na frente de 'a'
console.log ('b'.localecompare (' a ')); // 1console.log (' b '>' a '); // Falseconsole.log (' b'.localecompare ('a')); // 1console.log ('b'> 'a'); // verdadeiroO exposto acima é o conhecimento relevante sobre a explicação detalhada do tipo de sequência do sistema de tipo JavaScript introduzido pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!