Diskussion zum Erstellen und Verwenden von Array-Arrays in JavaScript

Ein Array ist eine Reihe von Werten, die der Reihe nach angeordnet sind. Im Gegensatz dazu sind die Eigenschaftsnamen von Objekten ungeordnet. Im Wesentlichen verwenden Arrays Zahlen als Suchschlüssel, während Objekte benutzerdefinierte Eigenschaftsnamen haben. JavaScript verfügt nicht über ein echtes assoziatives Array, aber Objekte können verwendet werden, um zugehörige Funktionen zu implementieren.

Array() ist nur ein spezieller Typ von Object(), das heißt, eine Array()-Instanz verfügt im Grunde über Object()-Instanz mit einigen zusätzlichen Funktionen. Arrays können Werte jeder Art speichern, die jederzeit aktualisiert oder gelöscht werden können, und die Größe des Arrays wird dynamisch angepasst

Neben Objekten ist der Array-Typ möglicherweise der am häufigsten verwendete Typ in JavaScript. Darüber hinaus unterscheiden sich Arrays in JavaScript erheblich von Arrays in den meisten anderen Sprachen. In diesem Artikel wird der Array-Array-Typ in Javascript vorgestellt

Erstellen eines Arrays

Es gibt zwei Möglichkeiten, ein Array zu erstellen: die Verwendung einer literalen Syntax und die Verwendung des Array()-Konstruktors

【Literal】

Verwendung eines Arrays Literal Quantity ist die einfachste Möglichkeit, ein Array zu erstellen. Trennen Sie einfach die Array-Elemente durch Kommas in eckigen Klammern

var empty = []; //没有元素的数组
var primes = [2,3,5,7,11]; //有5个数值的数组

Obwohl sich Javascript-Arrays von denen in unterscheiden Andere Sprachen Arrays sind geordnete Listen von Daten, aber im Gegensatz zu anderen Sprachen kann jedes Element eines JavaScript-Arrays jede Art von Daten speichern

var misc = [1.1,true, "a"]; //3个不同类型的元素

Die Werte ​​in Array-Literalen müssen keine Konstanten sein, sie können beliebige Ausdrücke sein

var base = 1024;
var table = [base,base+1,base+2,base+3];

Es kann Objektliterale oder andere Array-Literale enthalten. Menge

var b = [ [1,{x:1,y:2}],[2,{x:3,y:4}] ];

Sind die Elemente des Arrays noch Arrays, entsteht ein mehrdimensionales Array

var a = [[1, 2], [3, 4]];

[Hinweis] Bei Verwendung einer numerischen Literaldarstellung wird der Array-Konstruktor

[Konstruktor]

dort nicht aufgerufen Es gibt drei Möglichkeiten, den Konstruktor aufzurufen

　【1】Erstellen Sie ohne Parameter ein leeres Array

//该方法创建一个没有任何元素的空数组，等同于数组直接量[]
var a = new Array();

　【2】 Ja Ein numerischer Parameter, der die Länge des Arrays angibt

var a = new Array(10);
console.log(a);//[]
console.log(a[0],a.length);//undefined 10

　[Hinweis] Wenn es einen Parameter anderen Typs gibt, wird er erstellt, der diesen enthält Wert Ein Array mit nur einem Element

var a = new Array('10');
console.log(a);//['10']
console.log(a[0],a.length);//10 1

[3] Wenn mehrere Parameter vorhanden sind, werden die Parameter als spezifische Elemente des Arrays
dargestellt

var a = new Array(1,2,3);
console.log(a);//[1,2,3]
console.log(a[0],a[1],a[2]);//1 2 3

Bei Verwendung des Array()-Konstruktors können Sie den neuen Operator

var a1 = Array();
var a2 = Array(10);
var a3 = Array(1,2,3);
console.log(a1,a2,a3);//[] [] [1,2,3]

weglassen

Das Wesen eines Arrays

Ein Array ist eine Reihe von Werten, die in der richtigen Reihenfolge angeordnet sind. Im Wesentlichen ist ein Array etwas Besonderes Objekt

typeof [1, 2, 3] // "object"

Die Besonderheit des Arrays besteht darin, dass sein Schlüsselname eine Reihe von Ganzzahlen (0, 1, 2...) ist, die in der richtigen Reihenfolge angeordnet sind . Da die Schlüsselnamen der Array-Mitglieder festgelegt sind, muss das Array nicht für jedes Element einen Schlüsselnamen angeben, sondern jedes Mitglied des Objekts muss einen Schlüsselnamen angeben

var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr));// ["0", "1", "2"]
var obj = {
name1: 'a',
name2: 'b',
name3: 'c'
};

Arrays sind eine Sonderform von Objekten. Die Verwendung von eckigen Klammern für den Zugriff auf Array-Elemente entspricht genau der Verwendung von eckigen Klammern für den Zugriff auf die Eigenschaften eines Objekts.

Die JavaScript-Sprache schreibt vor, dass die Schlüsselnamen von Objekten sind immer Zeichenfolgen, daher sind die Schlüssel des Arrays Der Name ist eigentlich eine Zeichenfolge. Der Grund, warum es mit numerischen Werten gelesen werden kann, besteht darin, dass Schlüsselnamen, die keine Zeichenfolgen sind, in Zeichenfolgen konvertiert und dann als Attributnamen

o={}; //创建一个普通的对象
o[1]="one"; //用一个整数来索引它
//数值键名被自动转成字符串
var arr = ['a', 'b', 'c'];
arr['0'] // 'a'
arr[0] // 'a'

< 🎜 verwendet werden > Sie müssen jedoch zwischen Array-Indizes und Objektattributnamen unterscheiden: Alle Indizes sind Attributnamen, aber nur ganzzahlige Attributnamen zwischen 0~232-2 (4294967294) sind Indizes

var a = [];
//索引
a['1000'] = 'abc';
a[1000] // 'abc'
//索引
a[1.00] = 6;
a[1] // 6

　

[Hinweis] Ein einzelner Wert kann nicht als Bezeichner verwendet werden. Daher können Array-Mitglieder nur durch eckige Klammern dargestellt werden

var arr = [1, 2, 3];
arr[0];//1
arr.0;//SyntaxError

Sie können negative Zahlen oder Nicht-Ganzzahlen verwenden, um das Array zu indizieren. Da es jedoch nicht im Bereich von 0 bis 2 hoch 32 -2 liegt, handelt es sich nur um den Attributnamen des Arrays, nicht um den Index des Arrays. Das offensichtliche Merkmal ist, dass es die Länge des Arrays nicht ändert Array

var a = [1,2,3];
//属性名
a[-1.23]=true;
console.log(a.length);//3
//索引
a[10] = 5;
console.log(a.length);//11
//属性名
a['abc']='testing';
console.log(a.length);//11

Array-Länge

Jedes Array hat eine Länge Attribut, wodurch es sich von regulären JavaScript-Objekten unterscheidet. Bei dichten (d. h. nicht spärlichen) Arrays stellt der Längenattributwert die Anzahl der Elemente im Array dar und sein Wert ist um 1 größer als der größte Index im Array

[].length //=>0:数组没有元素
['a','b','c'].length //=>3:最大的索引为2，length为3

Wenn das Array ein spärliches Array ist, ist der Wert des Längenattributs größer als die Anzahl der Elemente. Ebenso ist sein Wert um 1 größer als der größte Index im Array

[,,,].length; //3
(Array(10)).length;//10
var a = [1,2,3];
console.log(a.length);//3
delete a[1];
console.log(a.length);//3

Die Besonderheit von Arrays spiegelt sich vor allem darin wider, dass die Länge des Arrays dynamisch angepasst werden kann:

[1] Wenn Sie zuweisen Ein Wert für ein Array-Element und der Index i ist größer oder gleich der Länge des vorhandenen Arrays, das Längenattribut. Der Wert wird auf i+1

gesetzt

var arr = ['a', 'b'];
arr.length // 2
arr[2] = 'c';
arr.length // 3
arr[9] = 'd';
arr.length // 10
arr[1000] = 'e';
arr.length // 1001

　　【2】设置length属性为小于当前长度的非负整数n时，当前数组索引值大于等于n的元素将从中删除

a=[1,2,3,4,5]; //从5个元素的数组开始
a.length = 3; //现在a为[1,2,3]
a.length = 0; //删除所有的元素。a为[]
a.length = 5; //长度为5，但是没有元素，就像new

　　【3】将数组的length属性值设置为大于其当前的长度。实际上这不会向数组中添加新的元素，它只是在数组尾部创建一个空的区域

var a = ['a'];
a.length = 3;
console.log(a[1]);//undefined
console.log(1 in a);//false

　　如果人为设置length为不合法的值(即0——232-2范围以外的值)，javascript会报错

// 设置负值
[].length = -1// RangeError: Invalid array length
// 数组元素个数大于等于2的32次方
[].length = Math.pow(2,32)// RangeError: Invalid array length
// 设置字符串
[].length = 'abc'// RangeError: Invalid array length

　　由于数组本质上是对象，所以可以为数组添加属性，但是这不影响length属性的值

var a = [];
a['p'] = 'abc';
console.log(a.length);// 0
a[2.1] = 'abc';
console.log(a.length);// 0

数组遍历

　　使用for循环遍历数组元素最常见的方法

var a = [1, 2, 3];
for(var i = 0; i < a.length; i++) {
console.log(a[i]);
}

　　当然，也可以使用while循环

var a = [1, 2, 3];
var i = 0;
while (i < a.length) {
console.log(a[i]);
i++;
}
var l = a.length;
while (l--) {
console.log(a[l]);
}

　　但如果数组是稀疏数组时，使用for循环，就需要添加一些条件

//跳过不存在的元素
var a = [1,,,2];
for(var i = 0; i < a.length; i++){
if(!(i in a)) continue;
console.log(a[i]);
}

　　还可以使用for/in循环处理稀疏数组。循环每次将一个可枚举的属性名（包括数组索引）赋值给循环变量。不存在的索引将不会遍历到

var a = [1,,,2];
for(var i in a){
console.log(a[i]);
}

　　由于for/in循环能够枚举继承的属性名，如添加到Array.prototype中的方法。由于这个原因，在数组上不应该使用for/in循环，除非使用额外的检测方法来过滤不想要的属性

var a = [1,,,2];
a.b = 'b';
for(var i in a){
console.log(a[i]);//1 2 'b'
} 
//跳过不是非负整数的i
var a = [1,,,2];
a.b = 'b';
for(var i in a){
if(String(Math.floor(Math.abs(Number(i)))) !== i) continue;
console.log(a[i]);//1 2
}

　　javascript规范允许for/in循环以不同的顺序遍历对象的属性。通常数组元素的遍历实现是升序的，但不能保证一定是这样的。特别地，如果数组同时拥有对象属性和数组元素，返回的属性名很可能是按照创建的顺序而非数值的大小顺序。如果算法依赖于遍历的顺序，那么最好不要使用for/in而用常规的for循环

　　有三个常见的类数组对象：

　　【1】arguments对象

// arguments对象
function args() { return arguments }
var arrayLike = args('a', 'b');
arrayLike[0] // 'a'
arrayLike.length // 2
arrayLike instanceof Array // false

　　【2】DOM方法(如document.getElementsByTagName()方法)返回的对象

// DOM元素
var elts = document.getElementsByTagName('h3');
elts.length // 3
elts instanceof Array // false

　　【3】字符串

// 字符串
'abc'[1] // 'b'
'abc'.length // 3
'abc' instanceof Array // false

　　[注意]字符串是不可变值，故当把它们作为数组看待时，它们是只读的。如push()、sort()、reverse()、splice()等数组方法会修改数组，它们在字符串上是无效的，且会报错

var str = 'abc';
Array.prototype.forEach.call(str, function(chr) {
console.log(chr);//a b c
});
Array.prototype.splice.call(str,1);
console.log(str);//TypeError: Cannot delete property '2' of [object String]

　　数组的slice方法将类数组对象变成真正的数组

var arr = Array.prototype.slice.call(arrayLike);

　　javascript数组方法是特意定义为通用的，因此它们不仅应用在真正的数组而且在类数组对象上都能正确工作。在ECMAScript5中，所有的数组方法都是通用的。在ECMAScript3中，除了toString()和toLocaleString()以外的所有方法也是通用的

var a = {'0':'a','1':'b','2':'c',length:3};
Array.prototype.join.call(a,'+');//'a+b+c'
Array.prototype.slice.call(a,0);//['a','b','c']
Array.prototype.map.call(a,function(x){return x.toUpperCase();});//['A','B','C']

Das obige ist der detaillierte Inhalt vonDiskussion zum Erstellen und Verwenden von Array-Arrays in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!