Sabemos que los operadores para detectar el tipo de objetos en JavaScript son: typeof, instanceof y el atributo constructor del objeto: 1) typeof operator typeof es un operador unario, y el resultado devuelto es una cadena que describe el tipo del operando. Tales como: "número", "cadena", "booleano", "objeto", "función", "indefinido" (puede usarse para determinar si la variable existe). Sin embargo, la capacidad de typeof es limitada y devuelve "objeto" para los tipos Date y RegExp. Tales como:
|
1
2
3
|
typeof
{};
// "object"
typeof
[];
// "object"
typeof
new
Date();
// "object"
|
Por lo tanto, solo es útil al distinguir entre objetos y tipos primitivos. Para distinguir entre un tipo de objeto y otro tipo de objeto, se deben utilizar otros métodos. Tales como: instanciaof operador o el constructor de un objeto. 2) instancia de operador. El operador instanceof requiere que el operando a la izquierda sea un objeto, y el operando a la derecha es el nombre o el constructor de la clase de objeto. Si object es una instancia de clase o constructor, el operador instanceof devuelve verdadero. Si el objeto no es una instancia de la clase o función especificada, o si el objeto es nulo, se devuelve falso. Tales como:
|
1
2
3
4 4
|
[]
instanceof
Array;
// true
[]
instanceof
Object;
// true
[]
instanceof
RegExp;
// false
new
Date
instanceof
Date;
// true
|
Por lo tanto, puede usar el operador instanceof para determinar si el objeto es un tipo de matriz:
|
1
2
3
|
function
isArray(arr){
return
arr
instanceof
Array;
}
|
3) Atributo constructor. En JavaScript, cada objeto tiene un atributo de constructor, que se refiere al constructor que inicializa el objeto, y a menudo se usa para determinar el tipo de objeto desconocido. Si se da un valor dado, el operador typeof se usa para determinar si es el valor original o el objeto. Si es un objeto, puede usar la propiedad del constructor para determinar su tipo. Entonces, la función para juzgar la matriz también se puede escribir así:
|
1
2
3
|
function
isArray(arr){
return
typeof
arr ==
"object"
&& arr.constructor == Array;
}
|
En muchos casos, podemos usar el operador instanceof o la propiedad del constructor de un objeto para detectar si el objeto es una matriz. Por ejemplo, muchos marcos JavaScript utilizan estos dos métodos para determinar si el objeto es un tipo de matriz. Pero cuando detecta matrices en páginas de marcos cruzados, falla. La razón es que las matrices creadas en diferentes marcos (iframes) no compartirán sus propiedades prototipo entre sí. Por ejemplo:
<script>
window.onload = function () {
var iframe_arr = new window.frames [0] .Array;
alert (iframe_arr instanceof Array); //
alerta falsa (iframe_arr.constructor == Array); // falso
}
</script>
Vi un método de detección preciso en Ajaxian, llamando al método toString () en toda la cadena de prototipos: Object.prototype.toString (). Puede resolver el problema de marco cruzado anterior. Cuando se ejecuta Object.prototype.toString (o), se realizarán los siguientes pasos: 1) Obtenga el atributo de clase del objeto o. 2) Cadena de conexión: "[objeto" + resultado (1) + "]" 3) Resultado devuelto (2) Por ejemplo:
Object.prototype.toString.call ([]); // devuelve "[matriz de objetos]" Object.prototype.toString.call (/ reg / ig); // devuelve "[object RegExp]"
De esta manera, podemos escribir una función robusta para determinar si el objeto es una matriz:
function isArray (arr) {
return Object.prototype.toString.call (arr) === "[matriz de objetos]";
}
Este método ha sido reconocido por muchos maestros javaScript en el extranjero y se utilizará para detectar matrices en la próxima jQuery 1.3. Un mantenedor de prototype.js escribió la siguiente función para obtener el nombre de tipo del objeto
/ **
* Devuelve la propiedad interna [[Clase]] de un objeto
*
* Ecma-262, 15.2.4.2
* Object.prototype.toString ()
*
* Cuando se llama al método toString, se siguen los siguientes pasos:
* 1. Obtenga la propiedad [[Class]] de este objeto.
* 2. Calcule un valor de cadena concatenando las tres cadenas "[objeto", Resultado (1) y "]".
* 3. Resultado devuelto (2).
*
* __getClass (5); // => "Número"
* __getClass ({}); // => "Objeto"
* __getClass (/ foo /); // => "RegExp"
* __getClass (''); // => "Cadena"
* __getClass (verdadero); // => "Boolean"
* __getClass ([]); // => "Array"
* __getClass (indefinido); // => "Ventana"
* __getClass (Elemento); // => "Constructor"
*
* /
function __getClass (object) {
return Object.prototype.toString.call (object) .match (/ ^ \ [object \ s (. *) \] $ /) [1];
};
Expanda para detectar varios tipos de objetos:
var es = {
tipos: ["Array", "Boolean", "Date", "Number", "Object", "RegExp", "String", "Window", "HTMLDocument"]
};
for (var i = 0, c; c = is.types [i ++];) {
is [c] = (function (type) {
return function (obj) {
return Object.prototype.toString.call (obj) == "[objeto" + tipo + "]";
}
) (c);
}
alerta (es.Array ([])); //
alerta verdadera (es.Fecha (nueva fecha)); //
alerta verdadera (es.RegExp (/ reg / ig)); // cierto
： ：Código de clase del blog java javascript get int string html http cti