Résumé de la distinction entre les méthodes Object et Aarry dans JS

1. Problèmes fréquemment rencontrés :

Lors du jugement du type d'un objet en JS, typeof est généralement utilisé. À ce stade, le problème se pose, car typeof() revient lors de l'identification d'un tableau. ., donc juger si un objet est un tableau en JS

nécessite des méthodes de traitement spéciales. Ce qui suit présentera six méthodes de traitement que j'ai résumées.

2. Droit au but

Pour déterminer si un objet est un tableau lors du développement, il est recommandé d'utiliser la fonction suivante :

function isArray(obj){
  if(Array.isArray){
    return Array.isArray(obj);
  }else{
   return Object.prototype.toString.call(obj)==="[object Array]";
  }
}

La fonction ci-dessus est pratique pour les personnes désireuses de résoudre des problèmes. Je décrirai les six méthodes en détail ci-dessous, car l'examinateur peut avoir besoin d'une connaissance approfondie. de vous lors de l'entretien ;

Explication détaillée des trois et six solutions :

(1) Méthode 1 : Utilisez la méthode toString

pour essayer de convertir la variable en une chaîne représentant son type en appelant la méthode toString(). Cette méthode est réalisable pour les tableaux réels ; lorsque l'objet paramètre est converti en chaîne

renvoie [Arguments de l'objet], la conversion échouera de plus, la conversion échouera également pour les classes d'objets contenant des attributs de longueur numérique.

La méthode est la suivante :

nbsp;html>

 
 <title>Array的判断方法</title>
 <meta>
 <script>
	function isArrayOne(arr){
		return <span style="color:#cc0000;">Object.prototype.toString.call(arr) === "[object Array]";
	}
	var obj = {"k1":"v1"};
	var arr = [1,2];
	console.log("对象的结果："+isArrayOne(obj));
	console.log("数组的结果："+isArrayOne(arr));
 </script>
 
 
 
 

Le résultat est tel qu'indiqué :

Remarque : Il est recommandé d'utiliser "===" égal à égal au lieu de "==" égal à égal, car c'est plus efficace !

(2) Méthode 2 : via isArray :

En utilisant Javascript 1.8.5 (ECMAScript 5), le nom de variable .isArray() peut atteindre cet objectif, à condition que cette fonction soit prise en charge. En fait, isArray est l'encapsulation de la première méthode

.

L'utilisation est très simple :

Array.isArray(obj); //obj est l'objet à détecter

Renvoie vrai ou faux, si vrai, c'est an array

(3) Méthode 3 : Juger par l'opérateur instanceof,

Remarque : Le côté gauche de l'opérateur instanceof est l'objet enfant (l'objet à tester), et le côté droit est le constructeur parent (voici Array),

C'est-à-dire : objet enfant instance du constructeur parent

instance : instance : tout objet créé avec le nouveau constructeur () est appelé une instance du constructeur

Je suis confus depuis longtemps, il vaut donc mieux regarder le code directement :

nbsp;html>

 
 <meta>
 <meta>
 <meta>
 <meta>
 <meta>
 <title>Document</title>
 <script>
	var obj = {"k1":"v1"};
	var arr = [1,2];
	console.log("Instanceof处理对象的结果："+(obj instanceof Array));
	console.log("Instanceof处理数组的结果："+(arr instanceof Array));
 </script>
 
 
 
 

Les résultats en cours d'exécution sont les suivants :

(4) Utiliser la fonction isPrototypeOf()

Principe : Détecter si un objet est le prototype de Array (ou est dans le chaîne de prototypes. Il peut non seulement détecter l'objet parent direct, mais également détecter tous les parents sur l'ensemble de la chaîne de prototypes. Object)

Méthode d'utilisation : parent.isPrototypeOf(child) pour détecter si le parent est le prototype de l'enfant. ;

Il est à noter que la fonction implémentée par la fonction isPrototypeOf() est très similaire à l'opérateur instancof

Code spécifique :

Array.prototype.isPrototypeOf( arr) //true signifie un tableau, false n'est pas un tableau

(5) Utiliser le constructeur constructeur

Code spécifique :

nbsp;html>

 
 <meta>
 <meta>
 <meta>
 <meta>
 <meta>
 <title>Document</title>
 <script>
	var obj = {&#39;k&#39;:&#39;v&#39;};
	var t1 = new Array(1);
	var t2 = t1;
	console.log(obj.constructor == Array);
	console.log(t1.constructor == Array);
	console.log(t2.constructor == Array);
 </script>
 
 
	
 

Le résultat est tel qu'indiqué dans la figure

(6) Utilisez typeof (objet) pour juger en combinant les noms de types :

Le code est le suivant :

nbsp;html>

 
 <meta>
 <meta>
 <meta>
 <meta>
 <meta>
 <title>Document</title>
 <script>
	function isArrayFour(arr){
		if(typeof(arr)==="object"){
			if(arr.concat){
				return "This is Array";
			}else{
				return "This Not Array";
			}
		}
	}
	var arr = [1];
	var obj = {&#39;k&#39;:&#39;v&#39;};
	console.log(typeof(arr));
	console.log(typeof(obj));
	console.log(isArrayFour(arr));
	console.log(isArrayFour(obj));
 </script>
 
 
 
 

Le résultat est le suivant :

Cette méthode a effectivement des limites, et certains étudiants pourront peut-être le déchiffrer d'un seul coup, c'est-à-dire

Et si cet attribut est accidentellement défini dans l'objet

var obj = {'concat':'Teast me?'};

Le résumé ci-dessus des six façons de distinguer Object et Aarry dans JS est tout le contenu partagé par l'éditeur. J'espère qu'il pourra vous donner une référence, et j'espère que tout le monde soutiendra Duoduo. Site Web chinois PHP.

Pour plus d'articles liés au résumé de la méthode JS de distinction d'Object et d'Aarry, veuillez faire attention au site Web PHP chinois !