Para os tipos de JavaScript, ele pode ser simplesmente resumido como: comparado a idiomas fortemente digitados, é uma linguagem do tipo fraca (solta); Existem tipos básicos e tipos de referência, e eles são a diferença é que existe um espaço fixo na memória da pilha, e um ponteiro para o local da implementação é armazenado na memória da pilha sem espaço fixo e um ponteiro para o local da implementação é armazenado na memória da pilha.
Muitos livros sobre o mercado têm muito espaço para falar. Este artigo falará sobre vários aspectos, o que pode exigir que você tenha algum entendimento simples do JavaScript, especialmente os tipos de JavaScript. Se você ainda não entende, poderá pegar um livro sobre JavaScript e lê -lo novamente.
1. Tipos básicos e tipos de referência
1. Tipo básico: indefinido/nulo/booleano/número/string
2. Tipo de referência: objeto/array/function/date/regexp/error/map/set…
Por que os tipos de referência não são enumerados? Porque você só sabe muito sobre isso, pelo menos no artigo que eu falei sobre isso são suficientes. Outros podem ser usados raramente, e mesmo aqueles como mapa e conjunto não são suportados por todos os navegadores.
2. Julgamento do tipo JavaScript
Existem dois operadores em JavaScript que podem ser usados para determinar os tipos. Eles são tipos e instância, mas o círculo é muito pequeno e não é tão bom nisso, e são notoriamente não confiáveis. Algumas situações também estão corretas, mas em muitos casos não são confiáveis. Basta olhar para ele e você saberá:
A cópia do código é a seguinte:
// Quando é confiável:
typeof 'sofish' // string
new String ('Sofish') Instância de String // true
// Quando não é confiável:
typeof [] // objeto
tipo de objeto nulo //
`` Sofish '' instância de string // false
Uh ~ Muitos programadores de JavaScript iniciantes podem jurar. A maioria das pessoas já possui bibliotecas como o JQuery quando precisam usar o JS. Todos eles os encapsularam para que você possa detectar facilmente tipos. Obviamente, de fato, não é problemático detectar, porque a frase "em JavaScript, tudo é um objeto", é claro, como mencionado em muitos documentos, indefinido é na verdade apenas um atributo global com Nan e Infinity. Você provavelmente sabe. Mas "objeto" pode nos ajudar:
A cópia do código é a seguinte:
/* Detectar o tipo de objeto
* @param: obj {objeto javascript}
* @param: type {string} JS Nome do tipo começando com maiúsculas
* @return: {boolean}
*/
função é (obj, tipo) {
retornar object.prototype.toString.Call (obj) .Slice (8, -1) === Type;
}
Dessa forma, podemos usar a função IS para nos ajudar a resolver o julgamento do tipo, e essa função simples tem boa compatibilidade e pode ser usada em seu projeto. Situação é como:
A cópia do código é a seguinte:
é ('sofish', 'string') // true
é (nulo, 'null') // true
é (new set (), 'set') // true
3. Conversão do tipo JavaScript
No JavaScript, o tipo de variável (propriedades) pode ser alterado. A coisa mais comum que você vê é a conversão entre string e número. Como transformar 1 + '2' em 12? É necessário entender o operador + aqui, que é um operador matemático e também um hífen de string em JavaScript. Portanto, os novatos costumam ver um fenômeno interessante. Ao usar o sinal +, às vezes o cálculo não é o que eles querem, mas o uso do sinal - sempre pode obter a resposta "correta".
A cópia do código é a seguinte:
1 + '2' // '12'
1 + ( + '2') // 3
1 - '2' // -1
Isso é realmente causado pelo duplo papel de +. No código acima, você pode observar que a segunda expressão usa um sinal A + na frente da string, forçando sua classe a ser convertida em número. Quanto ao entendimento de conversão do tipo JavaScript, na maioria dos casos, basta entender que + tem um papel duplo. Outras classes compreensíveis, semelhantes podem ser modificadas com atribuição/sobrecarga e até incluir erro:
A cópia do código é a seguinte:
var err = novo erro ();
console.log (erro de erro de erro); // verdadeiro
err = 'Sofish';
console.log (err); // 'Sofish'
4. Tipos de referência de JavaScript
Este é um ponto difícil neste artigo. Comparado aos tipos básicos, as referências podem adicionar propriedades e métodos a eles; As referências são valores semelhantes que são uma referência, atribuindo o valor de um tipo de referência a uma variável e apontam para o mesmo valor armazenado na memória da heap. As variáveis (propriedades) podem ser sobrecarregadas, mas a cópia será uma coisa muito interessante, falaremos sobre isso em detalhes posteriormente.
1. Adicione propriedades e métodos
Veremos no código a seguir que assumindo que não relataremos um erro a uma atribuição semelhante básica, mas será inválido ao buscar:
A cópia do código é a seguinte:
var arr = [1,2,3];
Arr.Hello = 'World';
console.log (arr.hello); // 'mundo'
var str = 'Sofish';
str.hello = 'mundo';
console.log (str.hello); // indefinido
2. Operação de referência a valores de tipo
Como o tipo de referência é armazenado na memória da pilha é uma referência, quando apontamos para o mesmo valor original, a operação no valor afetará todas as referências; Um exemplo aqui é que a reatribuição (não uma operação direta no valor) recriará um objeto e não alterará o valor original. por exemplo:
A cópia do código é a seguinte:
var arr = [1,2,3], Sofish = arr;
Sofish.push ('Hello World');
console.log (arr); // [1, 2, 3, 'Hello World']
// tipo de não same
Sofish = ['não um peixe']; // Quando o Sofish muda de maneira semelhante, o valor original não será alterado
console.log (arr); // [1, 2, 3, 'Hello World']
3. Copiar dos valores do tipo de referência
As operações no valor original afetarão todas as referências, o que não é necessariamente o que queremos. Às vezes, precisamos copiar um novo objeto sem afetar outras referências ao operar. Em geral, existem poucas operações específicas como data / função / regexp ..., principalmente porque a matriz e o objeto têm itens, atributos adicionais etc. Portanto, o que precisamos entender é como copiar objetos de matriz e objetos.
3.1 Cópia de matrizes
No objeto da matriz, o método da fatia existe para retornar uma matriz interceptada e, no filtro ES5, etc. também retornam uma nova matriz, para que possamos usar esse método para copiar.
A cópia do código é a seguinte:
var arr = [1, 2, 3];
var sofish = arr.slice ();
// operação em novas matrizes não afetará a matriz original
Sofish.push ('Hello World');
console.log (arr); // [1, 2, 3]
3.2 Cópia de objetos
Na cópia da matriz, usamos o método de fatia. De fato, para matriz e objeto, podemos usar o para ... em loop para atravessar e atribuir valores para copiar.
A cópia do código é a seguinte:
var obj = {name: 'Sofish'}, Sofish = {}, p;
para (P em obj) Sofish [p] = obj [p];
// operação em novos objetos não afetará o valor original
sofish.say = function () {};
console.log (obj); // {Nome: 'Sofish'}
3.3 Sombra/cópia profunda
Como a operação acima, é o que geralmente chamamos de cópia de sombra. No entanto, a matriz e o objeto podem ter várias camadas (dimensionalidade). Cópia como essa só leva em consideração o valor da camada superior. Matriz e objeto em possíveis valores ainda apontam para o objeto original. por exemplo:
A cópia do código é a seguinte:
var arr = [1, {bio: 'não é um peixe'}], Sofish = [], p;
para (p em arr) {
Sofish [p] = arr [p];
}
// operações em objetos `gat` contidos em` sofish` afetam o valor original
Sofish [1] .bio = 'hackable';
console.log (arr); // [1, gato: {bio: 'hackable'}]
Então, como fazer isso? Vamos usar uma função copy () para resolver este problema:
A cópia do código é a seguinte:
/* Copie o objeto
* @param: obj {objeto javascript} objeto original
* @param: Isdeep {boolean} é uma cópia profunda
* @return: {objeto javascript} retorna um novo objeto
*/
cópia da função (obj, isdeep) {
var ret = obj.slice? []: {}, p, prop;
// Use com a função IS
if (! Isdeep && is (obj, 'Array')) retorna obj.slice ();
para (p em obj) {
if (! Obj.HasownProperty (p)) continuar;
prop = obj [p];
ret [p] = (is (prop, 'objeto') || é (prop, 'array'))?
cópia (prop, isdeep): prop;
}
retornar retorno;
}
Dessa forma, podemos copiar uma matriz ou objeto através da função Cópia (OBJ, ISDEEP). Você pode testá -lo:
A cópia do código é a seguinte:
var arr = [1, {bio: 'não é um peixe'}];
var sofish = cópia (arr);
// cópia rasa não afeta o valor original para a operação da primeira camada, mas afeta a segunda camada
Sofish.push ('gato');
console.log (arr); // [1, {bio: 'não um peixe'}]
Sofish [1] .bio = 'Hello World';
console.log (arr) // [1, {bio: 'Hello World'}]
// cópia profunda não afetará o valor original
Sofish = cópia (arr, 1);
Sofish [1] .bio = 'foo ou bar';
console.log (arr); // [1, {bio: 'Hello World'}]
É isso. Você deve basicamente entender os pontos mais difíceis sobre os tipos. Obviamente, a replicação é o ponto mais problemático. Além de matriz e objeto que geralmente requerem operação, também há replicação de data/função/regexp.