As palavras anteriores
Cordas e matrizes têm muitas semelhanças. Eles têm muitos métodos e são muito semelhantes; Mas eles têm diferenças. Strings são valores imutáveis, para que possam ser considerados matrizes somente leitura. Este artigo compara métodos semelhantes de strings e matrizes
Indexível
O ECMAScript5 define um método para acessar caracteres, usando suportes quadrados e índices numéricos para acessar caracteres específicos em uma string
O maior benefício das cordas indexáveis é que elas são simples, substituindo as chamadas Charat () por colchetes, que são mais concisos, legíveis e possivelmente mais eficientes. Não apenas isso, o fato de as cordas se comportarem como matrizes tornam os métodos de matriz comuns aplicáveis a strings
Se o parâmetro estiver fora de intervalo ou NAN, saída indefinida
var str = "hello"; console.log (str [0]); // hconsole.log (str [[1]]); // econSole.log (str [false]); // undefinedconsole.log (str [-1]); undefinedconsole.log (str [nan];
var arr = ['h', 'e', 'l', 'l', 'o']; console.log (arr [0]); // hconsole.log (arr [[1]]); // econSole.log (arr [false]); // un DefinedConsole.log (arr [-1]); // undefinedconsole.log (arr [nan]); // undefinedconsole.log (arr []); // relatório erro
Converter
As cadeias podem ser convertidas em matrizes usando o método split (); Matrizes podem ser convertidas em strings usando o método junção ()
【dividir()】
O método split () divide uma string em várias seqüências baseadas no separador especificado e coloca o resultado em uma matriz. O separador pode ser uma corda ou uma expressão regular
Este método pode aceitar (opcional) um segundo parâmetro para especificar o tamanho da matriz. Se o segundo parâmetro for um valor no intervalo de 0-array.length, a saída de acordo com o parâmetro especificado e a saída resultará em outros casos.
Se o delimitador especificado não aparecer na sequência, o valor da string original será retornado como uma matriz.
var colorText = 'red,blue,green,yellow';console.log(colorText.split(''));//["r", "e", "d", ",", "b", "l", "u", "e", "e", "e", ",", "g", "r", "e", "e", "e", "e", "n", ",", "y", "E", "L", "L", "L", "O", "W"] Console.log (ColortExt.Split (',', ')); // ["vermelho", "azul", "verde", "amarelo"] console.log (colortExt.split (', 2); "Blue"] console.log (colortExt.split (',', 6)); // ["vermelho", "azul", "verde", "amarelo"] console.log (colortExt.split ('-')); // ["vermelho, verde, verde,"] console.log (colortExt.split (// [", verde, verde, verde"] "amarelo"] console.log (colortExt.split (/e/)); // ["r", "d, azul", ", gr", "", "n, y", "llow"] console.log (colortExt.split (/[^,]+/); reconhecerá como [",", ",", ",", ""]【juntar()】
O método junção () pode usar delimitadores diferentes para criar essa string. O método junção () recebe apenas um parâmetro, usado como delimitador, e depois retorna uma string contendo todos os itens da matriz.
Se nenhum valor for passado para o método junção (), use uma vírgula como o separador
var a = [1,2,3]; console.log (A.Join ()); // '1,2,3'Console.log (A.Join (' ')); //' 1 2 3'Console.log (A.Join (''); // '123'Var B = novo Array (10); B.Join ('-'); // '-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Se o valor de um item na matriz for nulo ou indefinido, o valor será representado como uma string vazia no resultado retornado pelo método junção ()
var colors = [1, indefinido, 2, nulo, 3]; console.log (colors.join ()); // '1 ,, 2 ,, 3'
Como as strings são objetos de matriz, você também pode usar o método junção ()
console.log (Array.prototype.join.call ('hello', '-')); // "hello" var str = 'teste'; var arr = str.split ('') // ["t", "e", "s", "t"] console.log (arr.join ('-'); // 'tes-t'Splicing
Cordas e matrizes compartilham o método de emenda concat ()
var value = 'hello'; console.log (value.Concat ('World')); // 'helloworld'console.log (value.concat ([' mundo ')); //' helloworld'console.log (value.Concat (['mundo']); // 'helloworld' var value = ['hello']; console.log (value.Concat ('World')); // ["hello", "World"] console.log (value.Concat (['World'])); // ["hello", "World"] console.log (valuencat (['mundial'])); ["World"] console.log (value.concat ([['mundo']])); // ["hello", ["World"]]]criar
Ambas as cordas e matrizes têm o método de criação Slice (), usado para criar substringas e subarraias, respectivamente.
O método slice () cria uma nova matriz (ou string) com base em um ou mais itens na matriz atual (ou string), aceita um ou dois parâmetros, ou seja, para retornar as posições de início e final do item e, finalmente, retornar a nova matriz (ou string)
O método Slice (Start, End) requer dois parâmetros iniciais e finais, que retornam um subarray (ou string) da posição inicial para (mas não contém) posição final nesta matriz (ou string). Se o fim for indefinido ou não existir, ele retornará todos os itens da posição inicial ao final da matriz (ou 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 as posições
VAR números = [1,2,3,4,5]; console.log (número.slice (2)); // [3,4,5] console.log (número.slice (2, indefinido)); // [3,4,5] consol e.log (números.slice (2,3)); // [3] console.log (número.slice (2,1)); // [] console.log (número.slice (-3)); //-3+5 = 2 -> [3,4,5] console.log (número.slice (-8)); // max (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (número.slice (0, -3)); // -3 + 5 = 2 -> [1,2] console.log (número.slice (-2, -1)); //-2+5 = 3; -1+5 = 4; -> [4]
var stringValue = 'Hello World'; console.log (stringValue.slice ()); // 'hello world'console.log (stringValue.slice (2)); //' llO World'Console.log (StringValue.slice (20)); // '' '''lOn) (StringValue.Finent (20); World'Console.log (StringValue.slice (2, -5)); // 'llo' console.log (stringValue.slice (2, -20)); // '' console.log (stringvalue.slice (-20)); // '' 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)); // 'hello wor'
Localização
Ambas as cordas e matrizes têm dois métodos para encontrar posições: indexOf () e LastIndexOf (). O método de posição é exatamente o oposto do método de leitura dos colchetes []. Um é encontrar o índice através do item, e o outro é encontrar o item através do índice.
【IndexOf ()】
O método IndexOF (Pesquisar, Iniciar) recebe dois parâmetros pesquisar e iniciar, retornando o local onde a pesquisa aparece primeiro e, se não for encontrada, retorna -1
O parâmetro de pesquisa em uma string chamará a função de transformação String () para converter o valor não string do parâmetro em uma string; Enquanto o parâmetro de pesquisa na matriz será comparado usando o operador estrito de igualdade (===)
Seja uma matriz ou uma string, o segundo parâmetro inicial chamará implicitamente a função de transformação número (), convertendo o valor não numérico (exceto indefinido) em valores numéricos; Se este parâmetro for ignorado ou o parâmetro for indefinido ou nan, start = 0
Se o parâmetro inicial for um número negativo, o processamento da string será iniciar = 0; Enquanto o processamento da matriz é iniciar = max (0, start+comprimento)
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 var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.indexof ('a', indefinido)); // 0console.log (arr.indexOf ('a', nan)); // 0consol e.log (arr.indexOf ('a', 1)); // 5console.log (arr.indexOf ('a', true)); // 5console.log (arr.indexOF ('a',-1)); // max (0, -1+7) = 6; -1console.log (arr.indexof ('a',-5)); // max (0, -5+7) = 2; 5console.log (arr.indexof ('a',-50)); // max (0, -50+7) = 0; 0【LastIndexOf ()】
Em contraste com o método indexOf (), o método LastIndexOF () deve procurar da direita para a esquerda.
O método LastIndexOF (pesquisa, start) recebe dois parâmetros pesquisando e iniciando, retornando o local onde a pesquisa de pesquisa aparece primeiro e, se não for encontrada, retorna -1
Da mesma forma, o parâmetro de pesquisa em uma string chama a função de transformação string () para converter o valor não string do parâmetro em uma string; Enquanto o parâmetro de pesquisa na matriz é comparado usando o operador estrito de igualdade (===)
Seja uma matriz ou uma string, o segundo parâmetro inicial chamará implicitamente a função de transformação número (), convertendo valores não numéricos (exceto indefinidos) em valores numéricos.
Se este parâmetro for ignorado ou o parâmetro for indefinido ou NAN, o processamento da string será start = comprimento - 1; Enquanto o processamento da matriz é iniciado = 0
Se o parâmetro inicial for um número negativo, o processamento da string será iniciar = 0; Enquanto o processamento da matriz é iniciar = max (0, start+comprimento)
var string = 'Hello World mundial '; console.log (string.lastindexOf (' ld ')); // 15console.log (string.lastindexof (' ld ', indefinido); // 15console.log (strin G.LastIndexOf ('ld', nan)); // 15console.log (String.LastIndexOf ('ld',-1)); //-1console.log (String.LastIndexOf ('H',-1); // 0c Onsole.log (String.LastIndexOF ('W', indefinido)); // 12console.log (String.LastIndexOF ('LD', 10)); // 9console.log (String.last Indexof ('ld', [10])); // 9console.log (string.LastIndexOF ('ld', [10])); //-1console.log (string.lastindexof (false, [10])); //-1 var arr = [1,2,3, '1', '2', '3']; console.log (arr.LastIndexOf ('2')); // 4console.log (arr.LastIndexOf (3)); // 2console.Log (Arr.LastIndexOf (0); ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (ar.LastIndexOf ('b')); // 6console.log (ar.LastIndexOf ('b', indefinido); ndefined)); // 0console.log (Arr.LastIndexOf ('B', NAN)); //-1console.log (arr.LastIndexOf ('B', 1)); // 1Console.log (Arr.LastIndexof ('B',-1)); 6console.log (arr.LastIndexOF ('B',-5)); // max (0, -5+7) = 2; 1console.log (arr.LastIndexOF ('b',-50)); // max (0, -50+7) = 0; -1A comparação acima de matrizes e métodos de string no JavaScript é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.