Plusieurs façons de déterminer si un objet est un tableau en JavaScript (résumé)

Cet article partagera avec vous plusieurs méthodes JavaScript pour déterminer si un objet est un tableau. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

L'utilisation de tableaux en JS est une opération courante. Parfois, pendant le développement, nous obtenons une variable qui doit être un tableau, mais nous ne savons pas s'il s'agit d'un tableau. Que devons-nous faire ? Comment déterminer s'il s'agit d'un tableau ?

Les types de données non primitifs en JS sont des objets (les fonctions ont leurs propres types, mais ce sont aussi des objets). Par conséquent, il ne suffit pas d'utiliser simplement l'opérateur typeof pour dire :

let result = { subject: 'Science', marks: 97 };
let numbers = [1, 2, 3, 4, 5];

console.log(typeof result); // Object
console.log(typeof numbers); // Object

Dans cet article, voyons comment vérifier si une variable ou une valeur donnée est un tableau en JS. [Tutoriels associés recommandés : Tutoriel vidéo JavaScript]

Utilisez la méthode Array.isArray()

Comme son nom l'indique, cette méthode peut être utilisé pour identifier les paramètres donnés du tableau ou non, il renvoie un booléen (true/false) et le résultat.

Par exemple, avec les variables suivantes, la méthode Array.isArray() peut déterminer correctement s'il s'agit d'un tableau :

let result = { subject: "Science", marks: 97 }; // Object
let numbers = [1, 2, 3, 4, 5]; // Array
let name = "Mark"; // String
let names = new Array("Jill", "Jane", "Jacqueline");

console.log(Array.isArray(result)); // false
console.log(Array.isArray(numbers)); // true
console.log(Array.isArray(name)); // false
console.log(Array.isArray(names)); // true

Utiliser l'attribut constructeur de l'objet

chaque Objet a tous un attribut constructor (sauf pour les objets créés avec object.create(null), ce qui est peu probable). Nous pouvons comparer directement l'attribut constructor avec le constructeur de JS. Donc si nous le comparons au constructeur de tableau, nous saurons s'il s'agit d'un tableau.

Remarque : Le constructeur est une fonction utilisée pour initialiser un objet. Si un objet est créé à l'aide du mot-clé new, le constructeur est utilisé. Par exemple, dans let myArray = new Array(1,2), le constructeur utilisé est Array().

Vous pouvez utiliser l'attribut constructor pour déterminer si une variable est un tableau :

let result = { subject: "Science", marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = "Mark";
let names = new Array("小智", "小力", "小吴");

console.log(result.constructor === Array); // false
console.log(numbers.constructor === Array); // true
console.log(name.constructor === Array); // false
console.log(names.constructor === Array); // true

Utilisez l'opérateur instanceof

instanceof opérateur pour vérifier si c'est le cas. Le constructeur se trouve dans la chaîne de prototypes de l'objet.

Comme l'opérateur typeof, il renvoie une valeur booléenne. Pour déterminer si une variable est un tableau, vous pouvez utiliser instanceof comme ceci :

let result = { subject: "Science", marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = "Mark";
let names = new Array("小智", "小力", "小吴");

console.log(result instanceof Array); // false
console.log(numbers instanceof Array); // true
console.log(name instanceof Array); // false
console.log(names instanceof Array); // true

Utilisez la méthode Object.prototype.call()

Tous les objets dans JS Les deux héritent des propriétés de l'objet prototype principal, nommé Object.prototype. La méthode Object.prototype existe dans toString(), c'est pourquoi chaque objet a sa propre méthode toString(), la méthode Object.prototype de toString() montre le type d'objet. La méthode

d'un objet

exécute une fonction mais modifie la valeur call() en l'objet transmis en argument, par exemple, elle permet à un objet d'utiliser les méthodes d'un autre objet. this

Ainsi, nous pouvons utiliser

pour imprimer le type, puis utiliser Object.prototype.toString() pour gérer un autre objet, puis comparer cette valeur de chaîne pour déterminer s'il s'agit d'un tableau. call()

let result = { subject: "Science", marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = "Mark";
let names = new Array("小智", "小力", "小吴");

console.log(Object.prototype.toString.call(result)); // [object Object]
console.log(Object.prototype.toString.call(numbers)); // [object Array]
console.log(Object.prototype.toString.call(name)); // [object String]
console.log(Object.prototype.toString.call(names)); // [object Array]

console.log(Object.prototype.toString.call(result) === "[object Array]"); // false
console.log(Object.prototype.toString.call(numbers) === "[object Array]"); // true
console.log(Object.prototype.toString.call(name) === "[object Array]"); // false
console.log(Object.prototype.toString.call(names) === "[object Array]"); // true

Il est peu probable que nous utilisions cette méthode, mais cela ne fait jamais de mal d'en savoir plus sur les objets JS

Résumé

Dans cet article, nous a examiné plusieurs façons dans JS pour déterminer si un objet est un tableau. La méthode la plus simple est la méthode

, et la plupart des amis l'utiliseront probablement à l'avenir. Array.isArray()

Cependant, nous pouvons également utiliser l'opérateur

et d'autres propriétés d'objet pour déterminer s'il s'agit d'un tableau. instanceof

Adresse originale : https://stackabuse.com/javascript-check-if-object-is-array/

Auteur : Contributeur invité

Adresse de traduction : https://segmentfault.com/a/1190000038661505

Pour plus de connaissances liées à la programmation, veuillez visiter :

Vidéo de programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!