Mehrere Möglichkeiten, um in JavaScript festzustellen, ob ein Objekt ein Array ist (Zusammenfassung)

In diesem Artikel stellen wir Ihnen verschiedene JavaScript-Methoden vor, mit denen Sie feststellen können, ob ein Objekt ein Array ist. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Die Verwendung von Arrays in JS ist eine häufige Operation. Manchmal erhalten wir während der Entwicklung eine Variable, die ein Array sein muss, sind uns aber nicht sicher, ob es sich um ein Array handelt. Wie können wir also beurteilen, ob es sich um ein Array handelt? ?

Nicht-primitive Datentypen in JS sind Objekte (Funktionen haben ihren eigenen Typ, sind aber auch Objekte). Daher reicht es nicht aus, nur den Operator typeof zur Prüfung zu verwenden: typeof运算符来判断是不够的：

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

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

在本文中，我们来研究如何在 JS 中检查给定变量或值是否为数组。【相关教程推荐：JavaScript视频教程】

使用 Array.isArray() 方法

顾名思义，此方法可用于识别给定参数是否为数组，它返回一个布尔值（true/false）和结果。

例如，使用以下变量，Array.isArray()方法可以正确判断是否为数组：

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

使用对象的构造函数属性

每个对象都有一个constructor 属性(除了使用object.create(null)创建的对象，这种情况不太可能出现)。我们可以直接将constructor 属性与 JS 的构造函数进行比较。因此，如果我们将它与数组构造函数进行比较，就会知道它是否是数组。

注意:构造函数是用来初始化对象的函数。如果使用new关键字创建了一个对象，那么使用的是构造函数。例如，在let myArray = new Array(1,2)中，使用的构造函数是Array()。

可以使用constructor 属性来确定变量是否是数组:

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

使用 instanceof 运算符

instanceof运算符检查是否在对象的原型链中找到构造函数。

像typeof运算符一样，它返回布尔值。 要确定变量是否为数组，可以使用instanceof，如下所示：

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

使用 Object.prototype.call() 方法

JS 中的所有对象均从主原型对象继承属性，该对象命名为Object.prototype。 Object.prototype中存在toString()方法，这是每个对象都有自己的toString()方法的原因， Object.prototype的 toString()方法显示对象的类型。

对象的call()方法执行一个函数，但将this 值更改为传入参数的对象，例如，它允许一个对象使用另一个对象的方法。

因此，我们可以使用Object.prototype.toString()来打印类型，然后使用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

我们不太可能使用这个方法，但是了解更多关于 JS 对象的知识是没有坏处的

总结

在本文中，我们研究了 JS 中确定对象是否是数组的几种方法。最简单的方法是Array.isArray()方法，以后大部小伙伴可能就是用它了。

但是，我们还可以利用instanceofrrreee

In diesem Artikel schauen wir uns an, wie man prüft, ob eine bestimmte Variable oder ein gegebener Wert ein Array in JS ist. [Empfohlene verwandte Tutorials: JavaScript-Video-Tutorial

]

Verwenden Sie Array.isArray ()-Methode

Wie der Name schon sagt, kann diese Methode verwendet werden, um zu identifizieren, ob der angegebene Parameter ein Array ist, einen booleschen Wert zurückgibt (true/false) und das Ergebnis.

Zum Beispiel kann die Methode Array.isArray() mithilfe der folgenden Variablen korrekt bestimmen, ob es sich um ein Array handelt:

rrreee

Verwenden Sie das Konstruktorattribut des Objekts

Jedes Objekt hat eine constructor-Eigenschaft (mit Ausnahme von Objekten, die mit object.create(null) erstellt wurden, was unwahrscheinlich ist). Wir können das Attribut constructor direkt mit dem JS-Konstruktor vergleichen. Wenn wir es also mit dem Array-Konstruktor vergleichen, wissen wir, ob es sich um ein Array handelt.

Hinweis: Der Konstruktor ist eine Funktion, die zum Initialisieren eines Objekts verwendet wird. Wenn ein Objekt mit dem Schlüsselwort new erstellt wird, wird der Konstruktor verwendet. Beispielsweise ist in let myArray = new Array(1,2) der verwendete Konstruktor Array(). Sie können das Attribut constructor verwenden, um zu bestimmen, ob eine Variable ein Array ist:

rrreee

Verwenden Sie den Operator „instanceof“

🎜instanceof-Operation Prüft, ob der Konstruktor in der Prototypenkette des Objekts gefunden wird. 🎜🎜Wie der <code>typeof-Operator gibt er einen booleschen Wert zurück. Um festzustellen, ob eine Variable ein Array ist, können Sie instanceof wie folgt verwenden: 🎜rrreee

Verwenden Sie die Methode Object.prototype.call()

🎜 In JS erben alle Objekte Eigenschaften vom Hauptprototypobjekt, das Object.prototype heißt. Es gibt eine toString()-Methode in Object.prototype, weshalb jedes Objekt seine eigene toString()-Methode hat, Die Die <code>toString()-Methode von Object.prototype zeigt den Typ des Objekts an. 🎜🎜Die call()-Methode eines Objekts führt eine Funktion aus, ändert jedoch den this-Wert in das als Parameter übergebene Objekt. Sie ermöglicht beispielsweise die Verwendung eines Objekts die Methoden eines anderen Objekts. 🎜🎜Wir können also Object.prototype.toString() verwenden, um den Typ zu drucken, dann call() verwenden, um ein anderes Objekt zu verarbeiten, und dann diesen String-Wert mit vergleichen Stellen Sie fest, ob es sich um ein Array handelt. 🎜rrreee🎜Wir werden diese Methode wahrscheinlich nicht verwenden, aber es schadet nie, mehr über JS-Objekte zu erfahren 🎜

Zusammenfassung

🎜In diesem Artikel haben wir uns angesehen, was in JS passiert Mehrere Möglichkeiten, um festzustellen, ob ein Objekt ein Array ist. Die einfachste Methode ist die Methode Array.isArray(), und die meisten Freunde werden sie wahrscheinlich in Zukunft verwenden. 🎜🎜Wir können jedoch auch den instanceof-Operator und andere Objekteigenschaften verwenden, um festzustellen, ob es sich um ein Array handelt. 🎜🎜🎜Originaladresse: https://stackabuse.com/javascript-check-if-object-is-array/🎜🎜Autor: Gastautor🎜🎜Übersetzungsadresse: https://segmentfault.com/a/1190000038661505🎜🎜 🎜Weitere Kenntnisse zum Thema Programmierung finden Sie unter: 🎜Programmiervideos🎜! ! 🎜

Das obige ist der detaillierte Inhalt vonMehrere Möglichkeiten, um in JavaScript festzustellen, ob ein Objekt ein Array ist (Zusammenfassung). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!