Penggunaan bercampur tatasusunan js satu dimensi, tatasusunan berbilang dimensi dan kemahiran objects_javascript

Tujuan utama artikel ini adalah untuk menerangkan penggunaan bercampur tatasusunan dan objek JavaScript Disebabkan ciri semakan JS yang lemah, pelbagai jenis pembolehubah boleh disimpan dalam tatasusunan JS, contohnya, anda boleh nombor kedai, rentetan, aksara, Objek dan kandungan lain diletakkan dalam tatasusunan yang sama. Objek juga boleh melakukan perkara yang sama Perbezaannya ialah objek boleh menentukan alias untuk setiap ahli dalam objek, supaya data lebih mudah dibaca semasa pengaturcaraan, seperti:

var arr1 = ["飞鱼", 25, 172, "江苏"];
var person = {name:"飞鱼",age: 25, height:172,province: "江苏"};

Dengan cara ini, adakah person.name lebih mudah dibaca dan digunakan daripada arr1[0]? Sudah tentu, tatasusunan dan objek masing-masing mempunyai kelebihan mereka sendiri Fokus artikel ini adalah untuk menggabungkan kelebihan kedua-duanya dan menggunakannya secara menyeluruh.

Susun atur satu dimensi
Kod berikut mencipta tatasusunan bernama kereta: mula-mula buat tatasusunan, dan kemudian tetapkan nilai satu demi satu

var cars=new Array();
cars[0]="Audi";
cars[1]="BMW";
cars[2]="Volvo";

atau (tatasusunan terkondensasi): tetapkan nilai semasa mencipta objek tatasusunan

Salin kod Kod adalah seperti berikut:

var cars=new Array("Audi","BMW","Volvo");

Atau (tatasusunan literal): Jangan buat pembolehubah, bantu secara langsung, tetapi perhatikan kurungan "( )" yang digunakan semasa mencipta objek, dan kurungan segi empat sama "[ ]" digunakan apabila memberikan nilai secara langsung. Ini boleh membawa kepada kesilapan jika anda tidak berhati-hati.
Contoh

Salin kod Kod adalah seperti berikut:

var cars=["Audi","BMW","Volvo"];

Di atas ialah tiga cara untuk mencipta tatasusunan satu dimensi. Disebabkan sifat pemeriksaan JS yang lemah, anda boleh meletakkan pembolehubah pelbagai jenis dalam tatasusunan satu dimensi.

Tatasusunan dua dimensi dan berbilang dimensi:
1. Kaedah 1 mencipta tatasusunan dua dimensi: Mula-mula buat tatasusunan satu dimensi, dan kemudian buat data satu dimensi untuk semua ahli tatasusunan satu dimensi

var persons = new Array();

persons[0] = new Array();
persons[1] = new Array();
persons[2] = new Array();

persons[0][0] = "zhangsan";
persons[0][1] = 25;
persons[1][0] = "lisi";
persons[1][1] = 22;
persons[2][0] = "wangwu";
persons[2][1] = 32;
persons[0] = ["zhangsan", 25];
persons[1] = ["lisi", 21];
persons[2] = ["wangwu", 32];

Berbanding dengan kaedah sebelumnya, kaedah ini lebih ringkas dan mudah dibaca.

Salin kod Kod adalah seperti berikut:

orang.panjang = 3

​ ​ 2. Kaedah 2 untuk mencipta tatasusunan dua dimensi: Mula-mula buat tatasusunan satu dimensi, dan kemudian tetapkan nilai secara langsung kepada semua ahli tatasusunan satu dimensi

Salin kod Kod adalah seperti berikut:

var persons = new Array();

3. Kaedah 3 mencipta tatasusunan dua dimensi: tugasan langsung

Salin kod Kod adalah seperti berikut:

var persons = [["zhangsan", 25], ["lisi", 21], ["wangwu", 32]];

4. Ringkasan
Walaupun kaedah pertama dan kedua lebih menyusahkan, anda boleh mula-mula membuat tatasusunan berbilang dimensi kosong dan kemudian menetapkan nilai mengikut keperluan anda sendiri dalam gelung untuk. Kaedah ketiga agak mudah dan mudah digunakan untuk data terbilang.
Soalan terakhir mengenai tatasusunan dua dimensi ialah apakah panjang tatasusunan dua dimensi atau pelbagai dimensi? Mari uji kod berikut:

Salin kod Kod adalah seperti berikut:

document.write("orang = " + orang + "
orang.panjang = " + orang.panjang);

Hasil keluaran ialah:
           orang = zhangsan,25,lisi,21,wangwu,32
Dalam erti kata lain, sifat panjang tatasusunan berbilang dimensi mengembalikan panjang dimensi pertama tatasusunan berbilang dimensi, bukan bilangan elemen dalam tatasusunan berbilang dimensi.

5. Bagaimana untuk mengembalikan bilangan elemen tatasusunan berbilang dimensi

Tatasusunan berikut:

Salin kod Kod adalah seperti berikut:

var persons = [["zhangsan", 25], ["lisi", 21], ["wangwu", 32]];

通过维数（此处是3）乘以每维元素的个数（此处是2）就可以得出该多维数组的元素个数是6了。但是这并不是保险的做法，因为多维数组中每一个维度的元素个数是可以不一样的，如：

复制代码 代码如下:

var persons = [["zhangsan", 25], ["lisi", 21, 172], ["wangwu", 32]];

        该数组的第一维的第二个元素数组包含三个元素，其他的只有两个，这再使用length来计算还是3，因为第一维的元素个数没变嘛。但是再使用上面的方法计算该多维数组的元素个数就不对了。
        因此多维数组的length属性和一维数组一样，永远返回第一维数组的元素个数。计算多维数组的元素个数，可以自己创建一个或多个嵌套for循环来计算，如：
        在知道数组的维度的情况下，可以针对该数组写算法，如二维数组：

var persons = [["zhangsan", 25], ["lisi", 21], ["wangwu", 32]];
function getArr2ElementNum(arr) {
var eleNum = 0;
if (arr == null) {
return 0;
}
for (var i = 0; i < arr.length; i++) {
for (var j = 0; j < arr[i].length; j++) {
eleNum++;
}
}
return eleNum;
}
alert(getArr2ElementNum(persons));

      在多维数组维度过多，嵌套复杂时，通过上面的方法来写针对的算法就太累了，特别是当这个复杂的多维数组还可能随时变换维度的情况下。如下这个复杂的多重嵌套的多维数组：
var arrN = [["zhangsan", 25, [1, "wangyuchu", 54, [123, 34, 16]], 43], ["lisi", 21, 172], ["wangwu", 32, "suzhou"]];
      甚至，有些多维嵌套数组比这个还复杂，那怎么计算数组元素个数呢，我写了一个求数组元素个数的函数，不管是一维还多维，也不管是多么复杂的嵌套多维数组，都可以计算出来，算法不麻烦，主要用到了递归的理念：
//判断某个对象是不是数组

function isArray(obj) {
return obj && ( typeof obj === 'object') && (obj.constructor == Array);
}

//eleNum变量初始值为0，用来统计数组元素个数
var eleNum = 0;

//递归计算某个数组元素是不是下一维数组，如果是，则继续递归下去；如果不是，统计元素个数。
function recursion(obj) {
if (isArray(obj)) {
for (var j = 0; j < obj.length; j++) {
if (!isArray(obj[j])) {
eleNum++;
continue;
}
recursion(obj[j]);
}
} else {
eleNum++;
}
}

//arr为要计算数组元素个数的一维或多维数组，通过调用递归函数recursion返回数组元素个数
function getArrNElementNum(arr) {
if (arr == null) {
return 0;
}

recursion(arr);

return eleNum;
}

//随意定义一个复杂的多维嵌套数组
var arrN = [["zhangsan", 25, [1, "wangyuchu", 54, [123, 34, 16]], 43], ["lisi", 21, 172], ["wangwu", 32, "suzhou"]];
//打印出来数组元素个数
alert(getArrNElementNum(arrN));

对象：
对象由花括号分隔。在括号内部，对象的属性以名称和值对的形式 (name : value) 来定义。属性由逗号分隔：

复制代码 代码如下:

var person={firstname:"Bill", lastname:"Gates", id:5566};

上面例子中的对象 (person) 有三个属性：firstname、lastname 以及 id。
空格和折行无关紧要。声明可横跨多行：

var person={
firstname : "Bill",
lastname : "Gates",
id    : 5566
};

对象属性有两种寻址方式：
实例

name=person.lastname;
name=person["lastname"];

对象和多维数组的混合使用：
         想象这么一个场景，要枚举并统计清华大学（qinghua）、北京大学(beida)、浙江大学(zheda)三所大学一共有多少个系，怎么做？
         首先，建立一个数组，数组中包括着三所学校：

复制代码 代码如下:

var departments = [qinghua, beida, zheda];

        每个学校又有很多不同或相同的学院（xx），如何表示？在这里就要用到数组包含对象了：

复制代码 代码如下:

var departments = [qinghua{xx1, xx2, xx3}, beida{xx4, xx5,
 xx6, xx7}, zheda{xx8, xx9}];

每个学院又有不同的系(d)，如何表示？

复制代码 代码如下:

var departments = [qinghua{xx1:[d1, d2], xx2[d3, d5],
 xx3:[d7, d8]}, beida{xx4, xx5, xx6, xx7}, zheda{xx8,
 xx9}];
 //只是举个例子，后面两个大学我就不表示了

上述例子就是一个数组，该数组的元素是学校对象，学校对象有N个学院属性，而每个学院属性又是一个包含多个系的数组，这就是一个典型的多维数组和对象混合使用的例子，可以简单明了的说明和列表学校、学院和系之间的级别、归属和数量关系。