Apakah kegunaan tatasusunan javascript-Soal Jawab bahagian hadapan-php.cn

Dalam JavaScript, tatasusunan ialah koleksi data tersusun, digunakan untuk menyimpan sejumlah besar data boleh disimpan pada satu masa dan panjang tatasusunan boleh dilaraskan secara dinamik; ia boleh memendekkan dan memudahkan kod program pada tahap yang besar, dengan itu meningkatkan kecekapan aplikasi.

Apakah kegunaan tatasusunan javascript

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi JavaScript 1.8.5, komputer Dell G3.

Tatasusunan JavaScript (Array) ialah koleksi data tersusun Setiap ahli dalam tatasusunan dipanggil elemen (Elemen), dan nama (kunci) setiap elemen dipanggil indeks tatasusunan (Indeks). Panjang tatasusunan adalah fleksibel dan boleh dibaca dan boleh ditulis, iaitu, panjang tatasusunan boleh dilaraskan secara dinamik.

Peranan tatasusunan: Menyimpan sejumlah besar data, berbilang data boleh disimpan pada satu masa. Dengan menggunakan tatasusunan, kod program boleh dipendekkan dan dipermudahkan pada tahap yang besar, sekali gus meningkatkan kecekapan aplikasi.

Dalam JavaScript, anda boleh menggunakan objek Array untuk menentukan tatasusunan Selain itu, objek Array juga menyediakan pelbagai sifat dan kaedah yang berkaitan dengan tatasusunan.

Definisi tatasusunan: Singkatan tatasusunan: arr

Tasusunan ialah bekas data dalam JS. Ia adalah salah satu jenis rujukan.

Fungsinya sangat mudah, ia digunakan untuk menyimpan berbilang data dan panjang tatasusunan boleh dilaraskan secara dinamik.

Cara membuat tatasusunan:

Literal
Pembina

Sintaks literal: nama tatasusunan var = [ahli 1, ahli 2, ahli 3, ...] ; >
Elemen tatasusunan dipisahkan dengan koma;

Sintaks pembina:

nama tatasusunan var = Array baharu(ahli 1, ahli 2, ahli 3, ...) (Sekurang-kurangnya mesti ada dua atau lebih elemen tatasusunan;)
Pepijat kecil: Apabila parameter Apabila hanya ada satu dan jenis parameter ialah nombor, ia akan dianggap sebagai panjang tatasusunan ;var arr = new Arry(5 ); console.log(arr); Hasil keluaran ialah:

nama tatasusunan var = Tatasusunan baharu();
var arr = Tatasusunan baharu ();//Buat tatasusunan kosong baharu

Perhatikan bahawa Tatasusunan 0, A mesti menggunakan huruf besar

Tatasusunan terdiri daripada dua bahagian:

1: Indeks (juga dipanggil subskrip ),

Subskrip bermula dari 0; 2 Ahli (elemen tatasusunan):

ahli tidak mempunyai sekatan dan boleh menjadi sebarang jenis. data; boleh menjadi rentetan, nombor, nilai Boolean, tidak ditentukan, nol atau tatasusunan;

Nilai tatasusunan:

Apakah kegunaan tatasusunan javascript nama tatasusunan [subskrip] ; Format: Nama tatasusunan [subskrip] Subskrip juga dipanggil indeks

/ Fungsi: Dapatkan nilai yang sepadan dengan subskrip tatasusunan Jika subskrip tidak wujud, undefined dikembalikan.

var arr = ['merah',, 'hijau', 'biru'];

0 1 1 2

console.log(
arr[0]); // merah console.log(
arr[2]
); // biru
aconsole.log(arr[3]
); // Subskrip maksimum tatasusunan ini ialah 2. Tiada unsur tatasusunan sedemikian, jadi hasil output tidak ditentukan ;
Tambah ahli/ubah suai ahli melalui indeks:
Kes khas: Menetapkan berbilang ahli melalui indeks, akan ada Terputus, kosong; dilarang!var arr = ["a", "b"];
arr[5] = "baik";

console .log(arr); //

遍历数组:

数组的属性length,就是数组成员的个数;

数组名.length

var  arr = [1, 2, 3, 4, 5, 6, 7, 8];

length表示数组的长度它会跟着数组实时发生变化(动态监测数组元素的个数)

console.log(arr.length)   //数组成员的个数: 8

length属性可读可写  它也会影响数组的成员个数但是我们一般不会主动修改该属性;

var arr = [1, 2, 3, 4, 5, 6, 7, 8];

arr.length = 3;

console.log(arr.length);

console.log(arr);

数组元素求和,求平均值:

求数组元素的最大值:

数组元素转字符串,并分割开:    推荐: 数组名.join("连接符")

求数组中大于10的成员,并挑选出来:

数组元素的倒叙:

数组元素的增删改查;

unshift   头增       数组名.unshift("value")

作用：头部增加 (可以增加多个)

参数:添加的成员,可以是多个;

返回值：数组的新长度

var arr = ['张三', '李四', '王五', '赵六']; var result = arr.unshift('王二',刘一) console.log(result); // 6 console.log(arr); // ["王二", "刘一","张三", "李四", "王五", "赵六"]
Salin selepas log masuk

push   尾增   数组名.push("value")

作用：尾部增加 (可以增加多个)

参数:添加的成员,可以是多个;

返回值：数组的新长度

var arr = ['张三', '李四', '王五', '赵六']; var result = arr.push('王二',"刘一") console.log(result); // 6 console.log(arr); // ["张三", "李四", "王五", "赵六", "王二","刘一"]
Salin selepas log masuk

shift   头删    数组名.shift()   只删除第一个,()括号内为空;

作用：删除数组的头部第一项

参数:无;

返回值：被删除的那一项

var arr = ['张三', '李四', '王五', '赵六']; var result = arr.shift() console.log(result); // 张三 console.log(arr) //  ['李四', '王五', '赵六'];
Salin selepas log masuk

pop 尾删    数组名.pop()   只删除最后一个,()括号内为空;

作用：删除数组最后一项;

参数:无;

返回值：被删除的那一项

var arr = ['张三', '李四', '王五', '赵六']; var result = arr.pop(); console.log(result); // 赵六 console.log(arr) //["张三", "李四", "王五"]
Salin selepas log masuk

concat      拼接,合并;   数组名.concat("value")

作用：合并

参数：任意个、任意类型

返回值：一个新的合并后的数组

特点：没有改变原来的数组

var arr1 = [1, 2, 3];

var arr2 = [4, 5, 6];

var newArr = arr1.concat(arr2, "good", true, 1);

console.log(arr1); // 1,2,3

console.log(arr2); //4,5,6

console.log(newArr); //1, 2, 3, 4, 5, 6, "good", true, 1

slice 截取     数组名.slice(start,end)   参数是下标; 包括开头,不包括结尾;

slice的本质是复制(浅复制)

作用：截取

参数：

没有参数截取全部

一个参数从指定位置截取到最后(包括最后)

两个参数从指定开始位置截取到指定的结束位置 1. 这两个参数都是下标 2. 开始位置(包含) 3. 结束位置(不包含) 4. 第二个参数要比第一个大;

参数可以是负数,负数是从后面开始,最后一个是-1;

特点：不改变原数组

没有参数 (截取全部的)
var arr = ['张三', '李四', '王五', '赵六'];
var arr1 = arr.slice();
console.log(arr1) // ["张三", "李四", "王五", "赵六"]

一个参数 (从指定位置截取到最后(包括最后))
var arr = ['张三', '李四', '王五', '赵六'];
var arr2 = arr.slice(1);
console.log(arr2) // ["李四", "王五", "赵六"]

两个参数 (包括开始,不包括结尾)
var arr = ['张三', '李四', '王五', '赵六'];
var arr3 = arr.slice(1, 3);
console.log(arr3) // ["李四", "王五"]

参数为负数; (还是第二个参数要比第一个大)

var arr = ['张三', '李四', '王五', '赵六','刘一'];
var arr3 = arr.slice(-3, -1);
console.log(arr3) // ["王五","赵六"]

PS: 如果参数是负数那么表示从后往前数最后一个值是-1

splice    操作数组     数组名.splice(参数1,参数2,参数3)

作用：用于操作数组成员

参数：

参数1:操作开始位置; (从第几个索引号后开始, 可以看成直接从顺序的第几个后开始的)

参数2:删除的成员个数; (为0,是添加)

参数3:从第三个参数开始是添加的成员;

返回值：被删除的那些成员组成的数组

特点：会改变原数组

// 删除 var arr = ['张三', '李四', '王五', '赵六']; var result = arr.splice(1, 2) console.log(result); // ["李四", "王五"] console.log(arr); // ["张三", "赵六"]    ---------------------------------------------------------------------- // 插入   第二个参数为0; var arr = ['张三', '李四', '王五', '赵六']; var  result = arr.splice(2, 0, '小绵羊'); console.log(result); // [] console.log(arr) // ["张三", "李四", "小绵羊", "王五", "赵六"] ------------------------------------------------------------------------ // 替换   第一个参数从哪里开始, 第二个参数删除几个,第三个参数...添加的新成员; var arr =['张三', '李四', '王五', '赵六']; var result = arr.splice(2, 1, '小绵羊', '大绵羊'); console.log(result); // ["王五"] console.log(arr) // ["张三", "李四", "小绵羊", "大绵羊","赵六"]
Salin selepas log masuk

-----------------------------------------------------------------------------------------------

如果只有一个参数则第二个参数默认为删除所有;

var arr = ['张三', '李四', '王五', '赵六'];

var result = arr.splice(2);

console.log(result); // ["王五","赵六"]

console.log(arr) // ["张三", "李四"]

indexOf      数组名.indexOf("数组元素")

作用：查找

参数：被查找的成员;

返回值：下标(索引);      若有该成员返回该索引; 若没有就返回-1

var arr = ["a", "b", "c", "d", "e", "f"];

var idx = arr.indexOf("d"); //3

var idx = arr.indexOf("aa"); //-1

console.log(idx);

join    数组名.join("连接符")

作用：转字符串

返回值：数组元素变成字符串类型,链接符相连;

参数：拼接符号(可选)

数组名.join() 不写内容,默认是逗号, ;

数组名.join(''), '' 没有空格隔开, 数组直接相连;

数组名.join('   ') 空格隔开, 空格

数组名.join('*')

var arr =['张三', '李四', '王五', '赵六']; var str = arr.join(); console.log(str); // 张三,李四,王五,赵六 var str1 = arr.join('+'); console.log(str1); // 张三+李四+王五+赵六 var str2 = arr.join('❤'); console.log(str2); // 张三❤李四❤王五❤赵六
Salin selepas log masuk

//返回值是数组元素变成字符串,并连接符相连;

reverse 数组倒叙    数组名.reverse()   括号内不跟参数;

作用：将数组的成员倒序

返回值：倒叙的原数组

参数：无

特点：会改变原数组

var arr =['张三', '李四', '王五', '赵六']; console.log(arr) // ["张三", "李四", "王五", "赵六"] var arr1 = arr.reverse(); console.log(arr1) // ["赵六", "王五", "李四", "张三"] console.log(arr === arr1) // true
Salin selepas log masuk

console.log(arr) // ["赵六", "王五", "李四", "张三"]     //会改变原数组;

其他方法:

sort      排序        数组名.sort(函数) 升序或降序

作用：将数组成员按照指定规则排序

返回值：排序后原数组

参数：规则函数; 不跟参数(//不跟参数,会先转为字符串,然后按照ascii码排序首字母排;)

特点：会改变原数组

var arr = [89, 96, 45, 66, 78, 3, 100, 1];

arr.sort(function(a, b) {

return a - b;     // 升序

        });

console.log(arr); // [1, 3, 45, 66, 78, 89, 96, 100];

-------------------------------------------------------------------------

var arr = [89, 96, 45, 66, 78, 3, 100, 1];

arr.sort(function(a, b) {

return b - a;     // 降序

        });

console.log(arr); // [100, 96, 89, 78, 66, 45, 3, 1];

--------------------------------------------------------------

var arr = [89, 96, 45, 66, 78, 3, 100, 1];

arr.sort();                //不跟参数,会先转为字符串,然后按照ascii码排序首字母排;

console.log(arr);    //[1, 100, 3, 45, 66, 78, 89, 96]

交换两个变量的值

var a = 4; var b = 5; // 交换两个变量的值要借助第三个变量 var c = b; b = a; a = c; console.log(a); // 5 console.log(b); // 4
Salin selepas log masuk

数组的冒泡排序

for (var j = 0; j
for (var i = 0; i
    if (arr[i] > arr[i + 1]) {
      var temp = arr[i];
      arr[i] = arr[i + 1];
      arr[i + 1] = temp;
    }
}
}

----------------------------------------------------------

要排序就要比较大小

Pertama ambil nombor pertama dan bandingkan dengan nombor kedua Jika yang pertama lebih besar, tukar kedudukan Selepas perbandingan, nombor dalam kedudukan kedua dalam tatasusunan mesti lebih besar daripada yang pertama >
Kemudian ambil nombor ketiga Selepas membandingkan nombor kedua dan ketiga, nombor ketiga dalam tatasusunan mestilah lebih besar daripada nombor di kedudukan kedua
Dan seterusnya, selepas pusingan perbandingan, nombor akhir mestilah yang terbesar
Pusingan kedua meneruskan perbandingan dari awal Selepas pusingan kedua, nombor kedua terbesar boleh ditentukan
Pusingan ketiga...
hingga tamat. // // Gelung luar menentukan pelaksanaan masa gelung dalam

untuk (var j = 0; j

// Perbandingan berpasangan gelung dalam                                                          (var i = 0; i
if (arr[i ] > arr[i 1]) {
var temp = arr[i];
arr[i] = arr[i 1];

arr[i 1] = t
em

p
;
} }}

Tatasusunan dua dimensi

Setiap ahli tatasusunan juga merupakan tatasusunan, yang dipanggil tatasusunan dua dimensi.

Tatasusunan satu dimensi: [1, 2, 3, 4, 5, 6]
Tatasusunan dua dimensi:

[

[1 , 2 , 3, 4, 5, 6],

[1, 2, 3, 4, 5, 6],

[1, 2, 3, 4, 5, 6 ]

...

]

Kaedah untuk mengosongkan tatasusunan:

// Kaedah 1 disyorkanarr = [ ];

// Kaedah 2arr.length = 0;
// Kaedah 3 arr.splice(0, arr.length); 🎜>]

Atas ialah kandungan terperinci Apakah kegunaan tatasusunan javascript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!