JavaScript detecta valores originales, valores de referencia y atributos

En JavaScript, a menudo vemos un código así: una comparación de variables con NULL (este uso es muy problemático), utilizado para determinar si una variable tiene un valor razonable. Por ejemplo:

 var controlador = {proceso: function (elementos) {if (elementos! == null) {// bad writing método items.sort (); items.forEach (function (item) {// Ejecutar algo de lógica});}}}

En este código, el método de proceso () obviamente espera que los elementos sean una matriz, porque vemos que los elementos tienen sort () y foreach (). La intención de este código es muy obvia: si los elementos del parámetro no son un número de grupo, entonces se detendrá la siguiente operación. El problema con este método de escritura es que la comparación con NULL realmente no puede evitar errores. El valor de los elementos puede ser 1, una cadena o incluso cualquier objeto. Estos valores no son iguales a NULL, lo que a su vez causará un error cuando el método Process () se ejecute a Sort ().

Compararse con NULL solo no proporciona suficiente información para determinar si la ejecución posterior del código es realmente segura. Afortunadamente, JavaScript nos proporciona muchas formas de detectar el verdadero valor de una variable.

Detectar el valor original

Hay 5 tipos primitivos (también conocidos como tipos de datos simples) en JavaScript: cadena, número, booleano, indefinido y nulo. Si desea que un valor sea cadena, número, booleano o indefinido, la mejor opción es usar el operador typeOf, que devuelve una cadena que representa el tipo.

Para cadenas, TypeOF devuelve "cadena".

Para los números, TypeOF devuelve "número".

Para Boolean, TypeOf Devuelve "Boolean".

Para indefinido, TypeOf devuelve "Undefined".

La sintaxis básica de TypeoF es: TypeOf Variable, también puede usar TypeOf (Variable), aunque esta es la sintaxis legal de JavaScript, que hace que TypeOF parezca una función en lugar de un operador. En vista de esto, recomendamos escribir sin corchetes.

Usar typeOf para detectar estos 4 tipos primitivos es muy seguro. Echemos un vistazo a los siguientes ejemplos.

 // Detectar "String" if (typeOf name === "String") {otroName = name.substring (3);} // detectar "número" if (typeOf count ==== "number") {updateCount (cuenta);} // (typeof myApp === "Undefined") {myApp = {// otro código};}

El operador TypeOf es único en el sentido de que no informará un error cuando se use con una variable no declarada. Variables y variables indefinidas con valor indefinido devolverán "indefinidos" a través de typeof.

El último tipo primitivo NULL, a través de TypeOf, devolverá el "objeto", que se ve extraño y se considera un error grave en la especificación estándar, por lo que al programar, debe evitar el uso de typeof para detectar tipos nulos.

 console.log (typeOf null); // "objeto"

Simplemente comparar con NULL generalmente no contiene suficiente información para determinar si el tipo de valor es legal, por lo que NULL generalmente no se usa en las declaraciones de detección.

Pero hay una excepción, si el valor esperado es realmente nulo, puede compararse directamente con NULL. Por ejemplo:

 // Si necesita detectar NULL, use este método var elemento = document.getElementById ("my-div"); if (element! == null) {element.classname = "encontrado";}

Si el elemento DOM no existe, el valor obtenido por document.getElementById () es nulo. Este método devuelve un nodo o devuelve nulo. Dado que NULL es una salida previsible en este momento, el resultado de retorno se puede detectar utilizando el operador de identidad === o el operador no identidad! ==.

Además de la cadena, número, booleano, indefinido y objeto mencionado anteriormente, el valor de retorno del operador typeof también tiene función. Desde un punto de vista técnico, las funciones también son objetos en JavaScript, no en los tipos de datos. Sin embargo, las funciones tienen algunas propiedades especiales, por lo que es necesario distinguir las funciones de otros objetos por parte del operador TypeOf. Esta característica se utilizará en la función de detección más adelante.

Detectar valores de referencia

En JavaScript, a excepción de los valores originales, todos los valores de referencia (también llamados objetos). Los tipos de referencia de uso común son: objeto, matriz, fecha y regexp. Estos tipos de referencia son objetos incorporados en JavaScript. El operador de typeOf devuelve "objeto" al juzgar estos tipos de referencia.

 console.log (typeof {}); // "Object" console.log (typeof []); // "Object" Console.log (typeof new Date ()); // "Object" console.log (typeof new regexp ()); // "Object" console.log (typeof new regexp ()); // "objeto"

La mejor manera de detectar un tipo de valor referenciado es usar el operador de instancia de instancia. La sintaxis básica de instancia es:

 Valor instanceOf constructor // detectar fecha if (valor instanceof date) {console.log (value.getblyear);} // Detect Errorif (value instancef error) {value de lanzamiento;} // detectar expresión regular if (value of regexp) {if (value.test (otrovalue)) {console.log ("coincide");}}}}}}}}}}}}}}}}}}

Una característica interesante de instanciaf es que no solo detecta el constructor que construye este objeto, sino que también detecta la cadena prototipo. La cadena prototipo contiene mucha información, incluido el patrón de herencia utilizado para definir el objeto. Por ejemplo, de forma predeterminada, cada objeto hereda del objeto, por lo que la instancia de valor de el objeto de cada objeto devuelve ture. Por ejemplo:

 var ahora = new Date (); console.log (ahora instancia de objeto); // The Natureconsole.log (ahora instancia de fecha); // El operador NatureInstanceOf también puede detectar tipos personalizados, como: Function Person (nombre) {this.name = name;} var me = new Person ("nicholas"); console.log (me inst instanciaf objeto); // The Natureconsole.log (instancia de la persona); // La naturaleza

El tipo de persona se crea en este código de muestra. La variable yo es una instancia de persona, por lo que la instancia de la persona es verdadera. Como se mencionó anteriormente, todos los objetos se consideran instancias de objeto, por lo que la instancia del objeto también es una tura.

Al detectar tipos incorporados y personalizados en JavaScript, la mejor manera de hacerlo es usar la instancia de operador, que es la única forma de hacerlo.

Pero hay una seria limitación. Suponiendo que ambos marcos del navegador (cuadros) tengan una persona constructor, y la instancia de la persona frameapersoninstance en el marco A se pasa al marco B, los siguientes resultados serán:

console.log (FrameapersonInstance instancia de Frameaperson) // ture

console.log (FramePersonInstance instanceo de FrameBperson) // Falso

Aunque las definiciones de las dos personas son exactamente las mismas, se consideran diferentes tipos en diferentes cuadros. Hay dos tipos incorporados muy importantes que también tienen este problema: la matriz y la función, por lo que detectarlos generalmente no usa instancia.

Función de detección

Técnicamente hablando, las funciones en JavaScript son tipos de referencia, y también hay un constructor de funciones. Cada función es un ejemplo, por ejemplo:

 function myFunc () {} // Método de escritura incorrecta console.log (myFunc instanceOf function); // verdadero

Sin embargo, este método no se puede usar en los cuadros, porque cada cuadro tiene su propio constructor de funciones. Afortunadamente, el operador de typeOf también se puede utilizar para funciones, devolviendo "función".

 function myFunc () {} // buen método de escritura console.log (typeof myfunc === "función"); // verdadero

La mejor manera de detectar una función es usar typeOf porque se puede usar en los cuadros.

Existe una limitación al usar typeOf para detectar funciones. En los navegadores IE 8 y IE anteriores, TypeOF se usa para detectar que las funciones en los nodos DOM devuelven "objeto" en lugar de "función". Por ejemplo:

 // ieconsole.log (typeof document.createElement); // "Object" console.log (typeof document.getElementById); // "Object" console.log (typeof document.getElementBytagName); // "Object" console.log (typeof document.getElementBytagName); // "objeto"

Este extraño fenómeno ocurre porque los navegadores tienen diferencias en la implementación de DOM. En resumen, estas versiones anteriores de IE no implementaron el DOM como un método de JavaScript incorporado, lo que resulta en el operador de typing incorporado que identifica estas funciones como objetos. Debido a que el DOM está claramente definido, sabiendo que existe un miembro del objeto significa que es un método, los desarrolladores a menudo usan el operador en el operador para detectar los métodos DOM, como:

 // Detectar el método DOM if ("QuerySelectorAll" en el documento) {var imágenes = document.querySelectorAll ("img");}

Este código verifica si QuerySelectorAll se define en el documento y, de ser así, use este método. Aunque no es el método ideal, es la forma más segura de detectar si el método DOM existe en los navegadores IE 8 y anteriores. En todos los demás casos, el operador de typeOf es la mejor opción para detectar funciones de JavaScript.

Detectar matriz

Uno de los problemas de dominio cruzado más antiguos en JavaScript es pasar matrices de ida y vuelta entre cuadros. El desarrollador pronto descubrió que la instancia de la matriz no puede devolver el resultado correcto en este escenario. Como se mencionó anteriormente, cada cuadro tiene su propio constructor de matriz, por lo que las instancias en un cuadro no serán reconocidas en otro cuadro.

Ha habido mucha investigación sobre cómo detectar los tipos de matriz en JavaScript, y finalmente Kangax dio una solución elegante:

 función isarray (valor) {return object.prototype.ToString.call (valor) === "[Array de objetos]";}

Kangax descubrió que llamar al método ToString () incorporado de un valor devuelve los resultados de cadena estándar en todos los navegadores. Para las matrices, la cadena devuelta es "[matriz de objetos]", y no es necesario considerar qué marco está construida la instancia de la matriz. Este método a menudo es muy útil al identificar objetos incorporados, pero no use este método para objetos personalizados.

ECMAScript5 presenta oficialmente Array.IsArray () en JavaScript. El único propósito es detectar con precisión si un valor es una matriz. Al igual que las funciones de Kangax, Array.IsArray () también puede detectar valores pasados ​​a través de cuadros, por lo que muchas bibliotecas de clase JavaScript actualmente implementan este método de manera similar.

 función isarray (valor) {if (typeof array.isArray === "función") {return array.isArray (valor);} else {return object.prototype.ToString.call (valor) === "[Array de objetos]";}}

IE 9+, Firefox 4+, Safari 5+, Opera 10.5+ y Chrome implementan el método Array.IsArray ().

Detectar propiedades

Otro escenario en el que nulo (y indefinido) es cuando se detecta si existe un atributo en un objeto, como:

 // escritura mala: detectar valores falsos if (object [PropertyName]) {// algún código} // Escritura incorrecta: Compare con null if (object [PropertyName]! = Null) {// algún código} // escritura incorrecta: Compare con if indefinido (object [propiedad]! = Inventoso) {// algún código}

Cada juicio en el código anterior realmente verifica el valor del atributo por el nombre de pila, en lugar de juzgar si existe el atributo mencionado por el nombre de pila. En el primer juicio, el resultado se errará cuando el valor de la propiedad es un valor falso, como: 0, "" (cadena vacía), falso, nulo y indefinido, después de todo, estos son los valores legales de la propiedad.

La mejor manera de determinar si existe un atributo es usar el operador en. El operador en el operador simplemente juzga si la propiedad existe sin leer el valor de la propiedad. Si la propiedad del objeto de instancia existe o hereda del prototipo del objeto, el operador in devolverá verdadero. Por ejemplo:

 var objeto = {Count: 0, Relacionado: NULL}; // Good Writing if ("Count" en Object) {// El código aquí se ejecutará} // Bad Writing: Detecte False Values ​​if (Object ["Count"]) {// El código aquí no se ejecutará} // buena escritura si ("Relacionado" en el objeto) {// El código aquí no se ejecutará}

Si solo desea verificar si existe una determinada propiedad del objeto de instancia, use el método de iSownProperty (). Todos los objetos JavaScript heredados de Object tienen este método. Si esta propiedad existe en la instancia, devuelve verdadero (si esta propiedad existe solo en el prototipo, devuelve falso). Cabe señalar que en IE 8 y versiones anteriores de IE, los objetos DOM no heredan del objeto, por lo que este método no incluye. Es decir, debe verificar si existe el método de DOM ObjectS ObjectSproperty () antes de llamarlo.

 // Esta es una buena manera de escribir if (object.hasownproperty ("relacionado"))) {// Ejecutar el código aquí} // Si no está seguro de si es un objeto DOM, luego escriba if ("ASOWNProperty" en Object && Object.HasownProperty ("Relacionado")) {// Ejecute el código aquí}

Debido a que hay IE 8 y versiones anteriores de IE, al juzgar si existen los atributos del objeto de instancia, prefiero usar el operador In. HasnownProperty () solo se usará al juzgar las propiedades de la instancia.

Independientemente de cuándo necesite detectar la existencia de una propiedad, use el operador o haownproperty (). Hacer esto puede evitar muchos errores.

Lo anterior es la detección de JavaScript de valores originales, valores de referencia y atributos introducidos por el editor. Espero que sea útil para todos. Si tiene alguna pregunta, déjame un mensaje y el editor responderá a todos a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!