Para los tipos de JavaScript, se puede resumir simplemente como: en comparación con los idiomas fuertemente tipados, es un lenguaje de tipo débil (suelto); Hay tipos básicos y tipos de referencia, y son la diferencia es que existe un espacio fijo en la memoria de la pila, y un puntero a la ubicación de implementación se almacena en la memoria de la pila sin espacio fijo y un puntero a la ubicación de implementación se almacena en la memoria de la pila.
Muchos libros en el mercado tienen mucho espacio para hablar. Este artículo hablará sobre varios aspectos, lo que puede requerir que tenga una comprensión simple de JavaScript, especialmente los tipos de JavaScript. Si aún no lo entiende, puede recoger un libro sobre JavaScript y leerlo nuevamente.
1. Tipos básicos y tipos de referencia
1. Tipo básico: Undefined/Null/Boolean/Number/String
2. Tipo de referencia: objeto/array/function/date/regexp/error/map/set ...
¿Por qué no se enumeran los tipos de referencia? Debido a que solo sabes mucho al respecto, al menos en el artículo del que hablé son suficientes. Otros pueden usarse rara vez, e incluso aquellos como MAP y SET no son compatibles con todos los navegadores.
2. Juicio del tipo de JavaScript
Hay dos operadores en JavaScript que pueden usarse para determinar los tipos. Son tipo de instancia, pero el círculo es muy pequeño, y no son tan buenos en eso, y son notoriamente poco confiables. Algunas situaciones también son correctas, pero en muchos casos no son confiables. Solo míralo y sabrás:
La copia del código es la siguiente:
// Cuando es confiable:
Typeof 'Sofish' // String
Nueva string ('Sofish') instancia de cadena // true
// Cuando no es confiable:
typeof [] // objeto
typeof null // objeto
instancia 'Sofish' de String // False
Uh ~ Muchos programadores de JavaScript para principiantes pueden jurar. La mayoría de las personas ya tienen bibliotecas como jQuery cuando necesitan usar JS. Todos los han encapsulado para que pueda detectar fácilmente tipos. Por supuesto, de hecho, no es problemático detectar, porque la oración "en JavaScript, todo es un objeto", por supuesto, como se menciona en muchos documentos, indefinido es en realidad solo un atributo global con Nan e Infinity. Probablemente lo sepas. Pero "objeto" puede ayudarnos:
La copia del código es la siguiente:
/* Detectar el tipo de objeto
* @param: obj {objeto javascript}
* @param: type {string} JS Type Name Comenzando con UpperCase
* @return: {boolean}
*/
la función es (obj, type) {
return object.prototype.ToString.call (obj) .slice (8, -1) === Tipo;
}
De esta manera, podemos usar la función IS para ayudarnos a resolver el juicio de tipo, y esta función simple tiene una buena compatibilidad y puede usarse en su proyecto. La situación es como:
La copia del código es la siguiente:
es ('Sofish', 'String') // True
es (nulo, 'nulo') // verdadero
es (nuevo set (), 'set') // verdadero
3. Conversión de tipo JavaScript
En JavaScript, se puede cambiar el tipo de variable (propiedades). Lo más común que ves es la conversión entre cadena y número. ¿Cómo convertir 1 + '2' en 12? Es necesario comprender el operador + aquí, que es un operador matemático y también un guión de cadena en JavaScript. Por lo tanto, los novatos a menudo verán un fenómeno interesante. Cuando se usa el signo +, a veces el cálculo no es lo que quieren, pero usar el signo siempre puede obtener la respuesta "correcta".
La copia del código es la siguiente:
1 + '2' // '12'
1 + ( + '2') // 3
1 - '2' // -1
Esto en realidad es causado por el doble papel de +. En el código anterior, puede notar que la segunda expresión usa un signo + frente a la cadena, lo que obliga a su clase a convertirse en número. En cuanto a la comprensión de conversión de tipo JavaScript, en la mayoría de los casos, es suficiente comprender + tiene un doble papel. Otras clases comprensibles, las similares se pueden modificar con asignación/sobrecarga e incluso incluir error:
La copia del código es la siguiente:
var err = new Error ();
console.log (Err instancia de error); // verdadero
err = 'Sofish';
console.log (err); // 'Sofish'
4. Tipos de referencia de JavaScript
Este es un punto difícil en este artículo. En comparación con los tipos básicos, las referencias pueden agregarles propiedades y métodos; Las referencias son valores similares que son una referencia, asignando el valor de un tipo de referencia a una variable, y apuntan al mismo valor almacenado en la memoria de Heap. Las variables (propiedades) se pueden sobrecargar, pero la copia será algo muy interesante, hablaremos de ello en detalle más adelante.
1. Agregar propiedades y métodos
Veremos en el siguiente código que suponiendo que no informaremos un error a una tarea similar básica, pero no será válido al obtener:
La copia del código es la siguiente:
var arr = [1,2,3];
arr.hello = 'mundo';
console.log (arr.hello); // 'mundo'
var str = 'Sofish';
str.hello = 'mundo';
console.log (str.hello); // indefinido
2. Operación de referirse a valores de tipo
Dado que el tipo de referencia se almacena en la memoria de la pila es una referencia, cuando señalamos el mismo valor original, la operación en el valor afectará todas las referencias; Un ejemplo aquí es que la reasignación (no una operación directa en el valor) recreará un objeto y no cambiará el valor original. Por ejemplo:
La copia del código es la siguiente:
var arr = [1,2,3], sofish = arr;
Sofish.push ('Hello World');
console.log (arr); // [1, 2, 3, 'Hola mundo']
// Tipo no de lugar
Sofish = ['no un pez']; // Cuando Sofish cambia de manera similar, el valor original no se cambiará
console.log (arr); // [1, 2, 3, 'hola mundo']
3. Copia de valores de tipo de referencia
Las operaciones en el valor original afectarán todas las referencias, que no es necesariamente lo que queremos. A veces necesitamos copiar un objeto nuevo sin afectar otras referencias cuando operamos. En general, hay pocas operaciones específicas como fecha / función / regexp ..., principalmente porque la matriz y el objeto tienen elementos adicionales, atributos, etc. Entonces, lo que debemos entender es cómo copiar objetos de matriz y objetos.
3.1 Copia de matrices
En el objeto de matriz, el método de corte existe para devolver una matriz interceptada, y en el filtro ES5, etc. también devuelve una nueva matriz, por lo que podemos usar este método para copiar.
La copia del código es la siguiente:
var arr = [1, 2, 3];
var sofish = arr.slice ();
// La operación en nuevas matrices no afectará la matriz original
Sofish.push ('Hello World');
console.log (arr); // [1, 2, 3]
3.2 Copia de objetos
En la copia de matriz, usamos el método Slice. De hecho, para la matriz y el objeto, podemos usar el bucle for ... en el bucle para atravesar y asignar valores para copiar.
La copia del código es la siguiente:
var obj = {nombre: 'Sofish'}, Sofish = {}, P;
para (p en obj) sofish [p] = obj [p];
// La operación en nuevos objetos no afectará el valor original
Sofish.say = function () {};
console.log (obj); // {nombre: 'Sofish'}
3.3 Copia de sombra/profunda
Al igual que la operación anterior, es lo que a menudo llamamos copia de sombra. Sin embargo, tanto la matriz como el objeto pueden tener múltiples capas (dimensionalidad). Copiar así solo tiene en cuenta el valor de la capa superior. La matriz y el objeto en posibles valores aún apuntan al objeto original. Por ejemplo:
La copia del código es la siguiente:
var arr = [1, {bio: 'no un pescado'}], sofish = [], p;
para (p en arr) {
Sofish [p] = arr [p];
}
// Las operaciones en objetos `Cat` contenidos en` Sofish` afectan el valor original
Sofish [1] .bio = 'Hackable';
console.log (arr); // [1, gato: {bio: 'hackable'}]
Entonces, ¿cómo hacerlo? Usemos una función Copy () para resolver este problema:
La copia del código es la siguiente:
/* Copia el objeto
* @param: obj {objeto javascript} objeto original
* @param: isDeep {boolean} es una copia profunda
* @return: {objeto javascript} Devuelve un nuevo objeto
*/
function Copy (obj, isDeep) {
var retir = obj.slice? []: {}, p, prop;
// use con la función IS
if (! isDeep && is (obj, 'array')) return obj.slice ();
para (p en obj) {
if (! obj.hasownproperty (p)) continuar;
prop = obj [p];
Ret [p] = (es (prop, 'objeto') || es (prop, 'array'))?
copia (prop, isDeep): prop;
}
regreso de regreso;
}
De esta manera, podemos copiar una matriz u objeto a través de la función COPY (OBJ, ISDEEP). Puedes probarlo:
La copia del código es la siguiente:
var arr = [1, {bio: 'no un pez'}];
var sofish = copy (arr);
// La copia poco profunda no afecta el valor original para la operación de la primera capa, pero afecta la segunda capa
SOFISH.PUSH ('CAT');
console.log (arr); // [1, {bio: 'no un pez'}]
Sofish [1] .bio = 'Hello World';
console.log (arr) // [1, {bio: 'hola mundo'}]
// La copia profunda no afectará el valor original
Sofish = Copy (arr, 1);
Sofish [1] .bio = 'foo o bar';
console.log (arr); // [1, {bio: 'Hola mundo'}]
Eso es todo. Básicamente, debe comprender los puntos más difíciles sobre los tipos. Por supuesto, la replicación es el punto más problemático. Además de la matriz y el objeto que a menudo requieren operación, también hay replicación de fecha/función/regexp.