javascript數(shù)組的作用是什么

本文小編為大家詳細介紹“javascript數(shù)組的作用是什么”，內容詳細，步驟清晰，細節(jié)處理妥當，希望這篇“javascript數(shù)組的作用是什么”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

在javascript中，數(shù)組是有序數(shù)據(jù)的集合，用于對大量數(shù)據(jù)進行存儲，可以一次性存儲多個數(shù)據(jù)，并且數(shù)組的長度可以動態(tài)的調整；通過使用數(shù)組，可以在很大程度上縮短和簡化程序代碼，從而提高應用程序的效率。

本教程操作環(huán)境：windows7系統(tǒng)、javascript1.8.5版、Dell G3電腦。

JavaScript 數(shù)組（Array）是有序數(shù)據(jù)的集合，數(shù)組中的每個成員被稱為元素（Element），每個元素的名稱（鍵）被稱為數(shù)組下標（Index）。數(shù)組的長度是彈性的、可讀寫的；即數(shù)組的長度可以動態(tài)的調整。

數(shù)組的作用：對大量數(shù)據(jù)進行存儲，可以一次性存儲多個數(shù)據(jù)。通過使用數(shù)組，可以在很大程度上縮短和簡化程序代碼，從而提高應用程序的效率。

在 JavaScript 中，您可以使用 Array 對象定義數(shù)組，此外，Array 對象中還提供了各種有關數(shù)組的屬性和方法。

數(shù)組的定義: Array 簡寫: arr

數(shù)組是JS中的一個數(shù)據(jù)容器。它是引用類型之一。

它的作用非常簡單，就是用來裝多個數(shù)據(jù),并且數(shù)組的長度可以動態(tài)的調整。

數(shù)組創(chuàng)建的方式:

• 字面量

• 構造函數(shù)

字面量語法：var 數(shù)組名 = [成員1, 成員2, 成員3, ...] ;  

數(shù)組元素之間,逗號隔開;

構造函數(shù)語法： var 數(shù)組名 = new Array(成員1, 成員2, 成員3, ...)  (至少要是有兩個或兩個以上的數(shù)組元素;)  小bug:當參數(shù)只有一個且參數(shù)的類型是數(shù)字時 ,會被當做數(shù)組的長度 ;

var arr = new Arry(5);   console.log(arr);  輸出結果是:  

var數(shù)組名= new Array() ;
var arr = new Array ();//創(chuàng)建一個新的空數(shù)組
注意Array 0 ，A要大寫

數(shù)組由兩部分組成：

1:索引(也叫下標) ,下標從0開始;

2.成員(數(shù)組元素): 成員沒有任何限制,可以是任意類型的數(shù)據(jù);可以是字符串 可以是數(shù)字 可以是布爾值 可以是 undefined 可以是null 還可以是數(shù)組;

獲取數(shù)組元素:

數(shù)組的取值:   數(shù)組名[下標] ;       下標從零開始的;

// 格式：數(shù)組名[下標]    下標又稱索引
// 功能：獲取數(shù)組對應下標的那個值，如果下標不存在，則返回undefined。
var arr = ['red',, 'green', 'blue'];

            0         1            2
console.log(arr[0]);    // red
console.log(arr[2]); // blue
aconsole.log(arr[3]); // 這個數(shù)組的最大下標為2,沒有這個數(shù)組元素所以輸出的結果是undefined;

通過索引 添加成員/修改成員:

// 構造函數(shù)定義一個數(shù)組
var arr = new Array('張三', '李四', '王五', '趙六')

// 添加成員
arr[4] = '龔七'
console.log(arr)  //張三', '李四', '王五', '趙六','龔七'
// 修改成員
arr[0] = '王老五'
console.log(arr)  //'王老五', '李四', '王五', '趙六'

特殊情況:  通過索引 多設置成員, 中間會有斷開,為空; 禁止!

var arr = ["a", "b"];

arr[5] = "good";

console.log(arr); //  

遍歷數(shù)組:

數(shù)組的屬性length,就是數(shù)組成員的個數(shù);

數(shù)組名.length

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

length表示數(shù)組的長度 它會跟著數(shù)組實時發(fā)生變化(動態(tài)監(jiān)測數(shù)組元素的個數(shù))

console.log(arr.length)   //數(shù)組成員的個數(shù): 8

length屬性可讀可寫  它也會影響數(shù)組的成員個數(shù) 但是我們一般不會主動修改該屬性;

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

arr.length = 3;

console.log(arr.length);    

console.log(arr);

數(shù)組元素求和,求平均值:

求數(shù)組元素的最大值:

數(shù)組元素轉字符串,并分割開:    推薦: 數(shù)組名.join("連接符")

求數(shù)組中大于10的成員,并挑選出來:

數(shù)組元素的倒敘:

數(shù)組元素的增刪改查;

unshift   頭增       數(shù)組名.unshift("value")

作用：頭部增加 (可以增加多個)

參數(shù):添加的成員,可以是多個;

返回值：數(shù)組的新長度

var arr = ['張三', '李四', '王五', '趙六'];
var result = arr.unshift('王二',劉一)
console.log(result); // 6
console.log(arr); 
// ["王二", "劉一","張三", "李四", "王五", "趙六"]

push   尾增   數(shù)組名.push("value")

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

參數(shù):添加的成員,可以是多個;

返回值：數(shù)組的新長度

var arr = ['張三', '李四', '王五', '趙六'];
var result = arr.push('王二',"劉一")
console.log(result); // 6
console.log(arr); // ["張三", "李四", "王五", "趙六", "王二","劉一"]

shift   頭刪    數(shù)組名.shift()   只刪除第一個,()括號內為空;

作用：刪除數(shù)組的頭部第一項

參數(shù):無;

返回值：被刪除的那一項

var arr = ['張三', '李四', '王五', '趙六'];
var result = arr.shift()
console.log(result); // 張三
console.log(arr) //  ['李四', '王五', '趙六'];

pop   尾刪    數(shù)組名.pop()   只刪除最后一個,()括號內為空;

作用：刪除數(shù)組最后一項;

參數(shù):無;

返回值：被刪除的那一項

var arr = ['張三', '李四', '王五', '趙六'];
var result = arr.pop();
console.log(result); // 趙六
console.log(arr) //["張三", "李四", "王五"]

concat      拼接,合并;   數(shù)組名.concat("value")

作用：合并

參數(shù)：任意個、任意類型

返回值：一個新的合并后的數(shù)組

特點：沒有改變原來的數(shù)組

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  截取     數(shù)組名.slice(start,end)   參數(shù)是下標; 包括開頭,不包括結尾;

slice的本質是復制(淺復制)

作用：截取

參數(shù)：

1. 沒有參數(shù) 截取全部

2. 一個參數(shù) 從指定位置截取到最后(包括最后)

3. 兩個參數(shù) 從指定開始位置截取到指定的結束位置 1. 這兩個參數(shù)都是下標 2. 開始位置(包含) 3. 結束位置(不包含) 4. 第二個參數(shù)要比第一個大;

4. 參數(shù)可以是負數(shù),負數(shù)是從后面開始,最后一個是-1;

特點：不改變原數(shù)組

沒有參數(shù) (截取全部的)
var arr = ['張三', '李四', '王五', '趙六'];
var arr1 = arr.slice();
console.log(arr1)  //  ["張三", "李四", "王五", "趙六"]

一個參數(shù) (從指定位置截取到最后(包括最后))
var arr = ['張三', '李四', '王五', '趙六'];
var arr2 = arr.slice(1);
console.log(arr2) // ["李四", "王五", "趙六"]

兩個參數(shù) (包括開始,不包括結尾)
var arr = ['張三', '李四', '王五', '趙六'];
var arr3 = arr.slice(1, 3);
console.log(arr3) // ["李四", "王五"]

參數(shù)為負數(shù); (還是第二個參數(shù)要比第一個大)

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

PS: 如果參數(shù)是負數(shù) 那么表示從后往前數(shù) 最后一個值是-1

splice    操作數(shù)組     數(shù)組名.splice(參數(shù)1,參數(shù)2,參數(shù)3)

作用：用于操作數(shù)組成員

參數(shù)：

• 參數(shù)1:操作開始位置; (從第幾個索引號后開始, 可以看成直接從順序的第幾個后開始的)

• 參數(shù)2:刪除的成員個數(shù); (為0,是添加)

• 參數(shù)3:從第三個參數(shù)開始是添加的成員;

返回值：被刪除的那些成員組成的數(shù)組

特點：會改變原數(shù)組

// 刪除

var arr = ['張三', '李四', '王五', '趙六'];
var result = arr.splice(1, 2)
console.log(result); // ["李四", "王五"]
console.log(arr); // ["張三", "趙六"]   
----------------------------------------------------------------------
// 插入   第二個參數(shù)為0;

var arr = ['張三', '李四', '王五', '趙六'];
var  result = arr.splice(2, 0, '小綿羊');
console.log(result); // []
console.log(arr) // ["張三", "李四", "小綿羊", "王五", "趙六"]
------------------------------------------------------------------------
// 替換   第一個參數(shù)從哪里開始, 第二個參數(shù)刪除幾個,第三個參數(shù)...添加的新成員;

var arr =['張三', '李四', '王五', '趙六'];
var result = arr.splice(2, 1, '小綿羊', '大綿羊');
console.log(result); // ["王五"]
console.log(arr) // ["張三", "李四", "小綿羊", "大綿羊","趙六"]

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

如果只有一個參數(shù) 則第二個參數(shù)默認為刪除所有;

var arr = ['張三', '李四', '王五', '趙六'];

var result = arr.splice(2);

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

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

indexOf      數(shù)組名.indexOf("數(shù)組元素")

作用： 查找

參數(shù)：被查找的成員;

返回值：下標(索引);      若有該成員返回該索引; 若沒有就返回-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    數(shù)組名.join("連接符")

作用：轉字符串

返回值：數(shù)組元素變成字符串類型,鏈接符相連;

參數(shù)： 拼接符號(可選)

數(shù)組名.join()  不寫內容,默認是逗號,  ;

數(shù)組名.join(''), '' 沒有空格隔開, 數(shù)組直接相連;

數(shù)組名.join('   ')  空格隔開, 空格

數(shù)組名.join('*')

var arr =['張三', '李四', '王五', '趙六'];
var str = arr.join();
console.log(str); // 張三,李四,王五,趙六

var str1 = arr.join('+');
console.log(str1); // 張三+李四+王五+趙六 

var str2 = arr.join('?');
console.log(str2); // 張三?李四?王五?趙六

//返回值是數(shù)組元素變成字符串,并連接符相連;

reverse  數(shù)組倒敘     數(shù)組名.reverse()   括號內不跟參數(shù);

作用：將數(shù)組的成員倒序

返回值：倒敘的原數(shù)組

參數(shù)：無

特點：會改變原數(shù)組

var arr =['張三', '李四', '王五', '趙六'];
console.log(arr) // ["張三", "李四", "王五", "趙六"]

var arr1 = arr.reverse();
console.log(arr1) // ["趙六", "王五", "李四", "張三"]
console.log(arr === arr1) // true

console.log(arr)  // ["趙六", "王五", "李四", "張三"]     //會改變原數(shù)組;

其他方法:

sort      排序         數(shù)組名.sort(函數(shù))  升序或降序

作用：將數(shù)組成員按照指定規(guī)則排序

返回值：排序后原數(shù)組

參數(shù)：規(guī)則函數(shù); 不跟參數(shù)(//不跟參數(shù),會先轉為字符串,然后按照ascii碼排序首字母排;)

特點：會改變原數(shù)組

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();                //不跟參數(shù),會先轉為字符串,然后按照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

數(shù)組的冒泡排序

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

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

要排序 就要比較大小

先拿著第一個數(shù)字與第二個比 如果第一個大 則交換位置  比完之后 數(shù)組的第二個位置的數(shù)字一定比第一個大

再拿著第二個與第三個比 比完之后 數(shù)組的第三個肯定比第二個位置的數(shù)要大

以此類推 一輪比完之后 最后的數(shù)字一定是最大的

第二輪從頭繼續(xù)比較 第二輪結束之后 可以確定第二個最大的數(shù)字

第三輪...

至最后.

// // 外層循環(huán) 決定了內層循環(huán)的執(zhí)行次數(shù)

for (var j = 0; j < arr.length - 1; j++) {

// 內層循環(huán) 兩兩比較

for (var i = 0; i < arr.length - 1 - j; i++) {

/ / 判定 如果前面大 后面小 則交換

if (arr[i] > arr[i + 1]) {

var temp = arr[i];

arr[i] = arr[i + 1];

  arr[i + 1] = temp;

}

}

}

二維數(shù)組

一個數(shù)組的每一個成員也是數(shù)組，這就叫做二維數(shù)組。

一維數(shù)組： [1, 2, 3, 4, 5, 6]

二維數(shù)組：

[

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

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

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

...

]

清空數(shù)組的方法:

// 方式1 推薦
arr = [ ];
// 方式2
arr.length = 0;
// 方式3
arr.splice(0, arr.length)。

讀到這里，這篇“javascript數(shù)組的作用是什么”文章已經(jīng)介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業(yè)資訊頻道。