數(shù)組題引起對數(shù)組方法的思考

今天看到了某位大神的博客，里面有一道題目是關(guān)于數(shù)組的，見下面的代碼：

var str = 'john';
var str2 = 'angus';

var arr1 = str.split('');
var arr2 = arr1.reverse();
var arr = str2.split('');
var arr3 = arr2.push(arr);

console.log(arr1.length, arr1.slice(-1));
console.log(arr3.length, arr3.slice(-1));

答案：第一次打印，5,[ Array[5] ]；第二次不僅沒有結(jié)果，還報錯了。

JS 中沒有指針，只有傳值（value)與傳址（reference引用）的區(qū)別。

var a = [1,2,3,4] // a 不僅是數(shù)組，還是個對象，實際上 a 就是對 [1,2,3,4] 的引用 。

var b = a var c = a // 以上兩條賦值語句建立了 b 與 c 對 a 即 [1,2,3,4] 的引用 

無論改變 a 還是 b 抑或 c 都是對 [1,2,3,4] 的操作 // 這就是傳址(堆中操作) 

把 a[1] 的值"1"傳遞給 d // 對 d 的改變則不會影響 a[1] 

即所謂的傳值(棧中操作) var d = a[1]。

Array.of() 返回由所有參數(shù)值組成的數(shù)組

在這之前，我們只能通過new Array (n)，傳入具體n的值設(shè)置數(shù)組的長度。例如：

let a = Array(3); // [ , , ] 長度為 3 的空數(shù)組

let a = Array(3,11,8); // [ 3,11,8 ]

定義：返回由所有參數(shù)值組成的數(shù)組，如果沒有參數(shù)，就返回一個空數(shù)組。

目的：Array.of()出現(xiàn)的目的是為了解決上述構(gòu)造器因參數(shù)個數(shù)不同，導(dǎo)致的行為有差異的問題。

let a = Array.of(3, 6, 8) // [3, 6, 8]

let a = Array.of(3) // [3]

Arrary.from() 將兩類對象轉(zhuǎn)為真正的數(shù)組

定義：用于將兩類對象轉(zhuǎn)為真正的數(shù)組（不改變原對象，返回新的數(shù)組）。

參數(shù)：

  • 第一個參數(shù)(必需): 要轉(zhuǎn)化為真正數(shù)組的對象；
  • 第二個參數(shù)(可選): 類似數(shù)組的map方法，對每個元素進行處理，將處理后的值放入返回的數(shù)組；
  • 第三個參數(shù)(可選): 用來綁定this。
// 1 對象擁有l(wèi)ength屬性

let obj = {0: 'a', 1: 'b', 2:'c', length: 3};

let arr = Array.from(obj);

// ['a','b','c'];

// 2. 部署了 Iterator 接口的數(shù)據(jù)結(jié)構(gòu) 比如:字符串、Set、NodeList對象

let arr = Array.from('hello');

// ['h','e','l','l','o']

let arr = Array.from(new Set(['a','b']));

// ['a','b']

改變數(shù)組的方法

let a = [1,2,3];

// ES5:

a.splice();

a.sort();

a.pop();

a.shift();

a.push();

a.unshift();

a.reverse();

// ES6:

a.copyWithin();

a.fill();

splice() 添加/刪除數(shù)組元素

對于這些能夠改變原數(shù)組的方法，要注意避免在循環(huán)遍歷中改變原數(shù)組的選項，比如: 改變數(shù)組的長度，導(dǎo)致遍歷的長度出現(xiàn)問題。

定義： splice() 方法向/從數(shù)組中添加/刪除項目，然后返回被刪除的項目 語法： array.splice(index,howmany,item1,.....,itemX)

參數(shù):

  • index：必需。整數(shù)，規(guī)定添加/刪除項目的位置，使用負數(shù)可從數(shù)組結(jié)尾處規(guī)定位置；
  • howmany：可選。要刪除的項目數(shù)量。如果設(shè)置為 0，則不會刪除項目；
  • item1, ..., itemX： 可選。向數(shù)組添加的新項目。
栗子1： 刪除元素
let a = [1, 2, 3, 4, 5, 6, 7];

let item = a.splice(0, 3); // [1,2,3]

console.log(a); // [4,5,6,7]

// 從數(shù)組下標(biāo)0開始，刪除3個元素

let item = a.splice(-1, 3); // [7]

// 從最后一個元素開始刪除3個元素，因為最后一個元素，所以只刪除了7
栗子2：刪除并且添加
let a = [1, 2, 3, 4, 5, 6, 7];

let item = a.splice(0,3,'添加'); // [1,2,3]

console.log(a); // ['添加',4,5,6,7]

// 從數(shù)組下標(biāo)0開始，刪除3個元素，并添加元素'添加'

let b = [1, 2, 3, 4, 5, 6, 7];

let item = b.splice(-2,3,'添加1','添加2'); // [6,7]

console.log(b); // [1,2,3,4,5,'添加1','添加2']

// 從數(shù)組最后第二個元素開始，刪除3個元素，并添加兩個元素'添加1'、'添加2'
栗子3：不刪除只添加
let a = [1, 2, 3, 4, 5, 6, 7];

let item = a.splice(0,0,'添加1','添加2'); // [] 沒有刪除元素，返回空數(shù)組

console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]

let b = [1, 2, 3, 4, 5, 6, 7];

let item = b.splice(-1,0,'添加1','添加2'); // [] 沒有刪除元素，返回空數(shù)組

console.log(b); // [1,2,3,4,5,6,'添加1','添加2',7] 在最后一個元素的前面添加兩個元素

從上述三個栗子可以得出:

數(shù)組如果元素不夠，會刪除到最后一個元素為止

操作的元素，包括開始的那個元素

可以添加很多個元素

添加是在開始的元素前面添加的

sort()

定義: sort()方法對數(shù)組元素進行排序，并返回這個數(shù)組。

參數(shù)可選: 規(guī)定排序順序的比較函數(shù)。

默認(rèn)情況下sort()方法沒有傳比較函數(shù)的話，默認(rèn)按字母升序，如果不是元素不是字符串的話，會調(diào)用toString()方法將元素轉(zhuǎn)化為字符串的Unicode位點，然后再比較字符。

// 字符串排列 看起來很正常

var a = ["Banana", "Orange", "Apple", "Mango"];

a.sort(); // ["Apple","Banana","Mango","Orange"]

// 數(shù)字排序的時候 因為轉(zhuǎn)換成Unicode字符串之后，有些數(shù)字會比較大會排在后面 這顯然不是我們想要的

var a = [10, 1, 3, 20,25,8];

console.log(a.sort()) // [1,10,20,25,3,8];

sort()的比較函數(shù)有兩個默認(rèn)參數(shù)，要在函數(shù)中接收這兩個參數(shù)，這兩個參數(shù)是數(shù)組中兩個要比較的元素，通常我們用a和b 接收兩個將要比較的元素：

若比較函數(shù)返回值 < 0，那么 a 將排到 b 的前面;

若比較函數(shù)返回值 = 0，那么 a 和 b 相對位置不變；

若比較函數(shù)返回值 > 0，那么 b 排在 a 將的前面；
栗子1：數(shù)組元素為數(shù)字的升序、降序
var array = [10, 1, 3, 4,20,4,25,8];

// 升序 a-b < 0 a將排到b的前面，按照a的大小來排序的

// 比如被減數(shù)a是10，減數(shù)是20 10-20 < 0 被減數(shù)a(10)在減數(shù)b(20)前面

array.sort(function(a,b){ return a-b; });

console.log(array); // [1,3,4,4,8,10,20,25];

// 降序 被減數(shù)和減數(shù)調(diào)換了 20-10>0 被減數(shù)b(20)在減數(shù)a(10)的前面

array.sort(function(a,b){ return b-a; });

console.log(array); // [25,20,10,8,4,4,3,1];
栗子2：數(shù)組多條件排序
var array = [
  { id: 10, age: 2 },
  { id: 5, age: 4 },
  { id: 6, age: 10 },
  { id: 9, age: 6 },
  { id: 2, age: 8 },
  { id: 10, age: 9 },
]

array.sort(function(a, b) {
  if (a.id === b.id) {
    // 如果id的值相等，按照age的值降序
    return b.age - a.age
  } else {
    // 如果id的值不相等，按照id的值升序
    return a.id - b.id
  }
})

// [{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}]

shift() 刪除數(shù)組的第一個元素

定義: shift()方法刪除數(shù)組的第一個元素，并返回這個元素。

參數(shù): 無。

let a = [1,2,3];

let item = a.shift(); // 1

console.log(a); // [2,3]

push() 向數(shù)組的末尾添加元素

定義: push() 方法可向數(shù)組的末尾添加一個或多個元素，并返回新的長度。

參數(shù): item1, item2, ..., itemX,要添加到數(shù)組末尾的元素。

let a = [1,2,3];

let item = a.push('末尾'); // 4

console.log(a); // [1,2,3,'末尾']

unshift()

定義：unshift() 方法可向數(shù)組的開頭添加一個或更多元素，并返回新的長度。

參數(shù):item1, item2, ..., itemX ,要添加到數(shù)組開頭的元素。

let a = [1,2,3];

let item = a.unshift('開頭'); // 4

console.log(a); // ['開頭',1,2,3]

reverse() 顛倒數(shù)組中元素的順序

定義: reverse()方法用于顛倒數(shù)組中元素的順序。

參數(shù): 無

let a = [1,2,3];

a.reverse();

console.log(a); // [3,2,1]

copyWithin()

ES6: copyWithin()指定位置的成員復(fù)制到其他位置 ， 在當(dāng)前數(shù)組內(nèi)部，將指定位置的成員復(fù)制到其他位置,并返回這個數(shù)組。

array.copyWithin(target, start = 0, end = this.length)

參數(shù): 三個參數(shù)都是數(shù)值，如果不是，會自動轉(zhuǎn)為數(shù)值。

  • target（必需）：從該位置開始替換數(shù)據(jù)。如果為負值，表示倒數(shù)；
  • start（可選）：從該位置開始讀取數(shù)據(jù)，默認(rèn)為0。如果為負值，表示倒數(shù)；
  • end（可選）：到該位置前停止讀取數(shù)據(jù)，默認(rèn)等于數(shù)組長度。使用負數(shù)可從數(shù)組結(jié)尾處規(guī)定位置。

瀏覽器兼容(MDN):chrome 45、Edge 12、Firefox32、Opera 32、Safari 9、IE不支持。

// -2相當(dāng)于3號位，-1相當(dāng)于4號位

[1, 2, 3, 4, 5].copyWithin(0, -2, -1) // [4, 2, 3, 4, 5]

var a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']

// 2位置開始被替換,3位置開始讀取要替換的 5位置前面停止替換

a.copyWithin(2,3,5)

// ["OB1","Koro1","Koro2","OB3","OB3","Koro3","OB4","Koro4","OB5","Koro5"]

從上述栗子得知:

1 第一個參數(shù)是開始被替換的元素位置

2 要替換數(shù)據(jù)的位置范圍:從第二個參數(shù)是開始讀取的元素，在第三個參數(shù)前面一個元素停止讀取

3 數(shù)組的長度不會改變

4 讀了幾個元素就從開始被替換的地方替換幾個元素

ES6: fill() 填充數(shù)組

定義: 使用給定值，填充一個數(shù)組。

參數(shù):

  • 第一個元素(必須): 要填充數(shù)組的值 ；
  • 第二個元素(可選): 填充的開始位置，默認(rèn)值為0；
  • 第三個元素(可選): 填充的結(jié)束位置，默認(rèn)是為this.length。
['a', 'b', 'c'].fill(7) // [7, 7, 7]

['a', 'b', 'c'].fill(7, 1, 2) // ['a', 7, 'c']

不改變原數(shù)組的方法(8個):

// ES5： slice、join、toLocateString、toString、concat、indexOf、lastIndexOf

// ES7： includes

slice() 淺拷貝數(shù)組的元素

定義： 方法返回一個從開始到結(jié)束（不包括結(jié)束）選擇的數(shù)組的一部分淺拷貝到一個新數(shù)組對象，且原數(shù)組不會被修改。

注意：字符串也有一個slice()方法是用來提取字符串的，不要弄混了。

語法:

array.slice(begin, end);

參數(shù):

  • begin(可選)： 索引數(shù)值,接受負值，從該索引處開始提取原數(shù)組中的元素,默認(rèn)值為0；
  • end(可選)：索引數(shù)值(不包括)，接受負值，在該索引處前結(jié)束提取原數(shù)組元素，默認(rèn)值為數(shù)組末尾(包括最后一個元素)。
let a = ['hello','world'];

let b = a.slice(0,1);

// ['hello'] 
a[0]= '改變原數(shù)組';

console.log(a, b); // ['改變原數(shù)組','world'] ['hello']

b[0]='改變拷貝的數(shù)組';

console.log(a,b); // ['改變原數(shù)組','world'] ['改變拷貝的數(shù)組']

如上：新數(shù)組是淺拷貝的，元素是簡單數(shù)據(jù)類型，改變之后不會互相干擾。 如果是復(fù)雜數(shù)據(jù)類型(對象,數(shù)組)的話，改變其中一個，另外一個也會改變。

let a= [{name:'OBKoro1'}];

let b=a.slice();

console.log(b,a); // [{"name":"OBKoro1"}] [{"name":"OBKoro1"}]

// a[0].name='改變原數(shù)組';

// console.log(b,a);

// [{"name":"改變原數(shù)組"}] [{"name":"改變原數(shù)組"}]

// b[0].name='改變拷貝數(shù)組',b[0].koro='改變拷貝數(shù)組';

// [{"name":"改變拷貝數(shù)組","koro":"改變拷貝數(shù)組"}] [{"name":"改變拷貝數(shù)組","koro":"改變拷貝數(shù)組"}]

原因在定義上面說過了的：slice()是淺拷貝，對于復(fù)雜的數(shù)據(jù)類型淺拷貝，拷貝的只是指向原數(shù)組的指針，所以無論改變原數(shù)組，還是淺拷貝的數(shù)組，都是改變原數(shù)組的數(shù)據(jù)。

join() 數(shù)組轉(zhuǎn)字符串

定義:join()方法用于把數(shù)組中的所有元素通過指定的分隔符進行分隔放入一個字符串，返回生成的字符串。

語法:

array.join(str);

參數(shù):

  • str(可選): 指定要使用的分隔符，默認(rèn)使用逗號作為分隔符。
let a= ['hello','world'];

let str=a.join(); // 'hello,world'

let str2=a.join('+'); // 'hello+world'

使用join方法或者下文說到的toString方法時，當(dāng)數(shù)組中的元素也是數(shù)組或者是對象時會出現(xiàn)什么情況？

let a= [['OBKoro1','23'],'test'];

let str1=a.join(); // OBKoro1,23,test

let b= [{name:'OBKoro1',age:'23'},'test'];

let str2 = b.join(); // [object Object],test

// 對象轉(zhuǎn)字符串推薦JSON.stringify(obj);

所以，join()/toString()方法在數(shù)組元素是數(shù)組的時候，會將里面的數(shù)組也調(diào)用join()/toString(),如果是對象的話，對象會被轉(zhuǎn)為[object Object]字符串。

toLocaleString() 數(shù)組轉(zhuǎn)字符串

定義: 返回一個表示數(shù)組元素的字符串。該字符串由數(shù)組中的每個元素的toLocaleString()返回值經(jīng)調(diào)用 join()方法連接（由逗號隔開）組成。

語法:

array.toLocaleString();

參數(shù)：無。

let a=[{name:'OBKoro1'},23,'abcd',new Date()];

let str=a.toLocaleString(); // [object Object],23,abcd,2018/5/28 下午1:52:20

如上述栗子：調(diào)用數(shù)組的toLocaleString方法，數(shù)組中的每個元素都會調(diào)用自身的toLocaleString方法，對象調(diào)用對象的toLocaleString,Date調(diào)用Date的toLocaleString。

concat

定義： 方法用于合并兩個或多個數(shù)組，返回一個新數(shù)組。 語法：

var newArr = oldArray.concat(...arrayX);

參數(shù): arrayX（必須）：該參數(shù)可以是具體的值，也可以是數(shù)組對象?？梢允侨我舛鄠€。

let a = [1, 2, 3];

let b = [4, 5, 6];

//連接兩個數(shù)組

let newVal=a.concat(b); // [1,2,3,4,5,6]

// 連接三個數(shù)組

let c = [7, 8, 9];

let newVal2 = a.concat(b, c); // [1,2,3,4,5,6,7,8,9]

// 添加元素

let newVal3 = a.concat('添加元素',b, c,'再加一個');

// [1,2,3,"添加元素",4,5,6,7,8,9,"再加一個"]

// 合并嵌套數(shù)組 會淺拷貝嵌套數(shù)組

let d = [1,2 ];

let f = [3,[4]];

let newVal4 = d.concat(f); // [1,2,3,[4]]

ES6擴展運算符...合并數(shù)組：

因為ES6的語法更簡潔易懂，所以現(xiàn)在合并數(shù)組我大部分采用...來處理，...運算符可以實現(xiàn)concat的每個栗子，且更簡潔和具有高度自定義數(shù)組元素位置的效果。

let a = [2, 3, 4, 5];

let b = [ 4,...a, 4, 4];

console.log(a,b); // [2, 3, 4, 5] [4,2,3,4,5,4,4]

indexOf() 查找數(shù)組是否存在某個元素，返回下標(biāo)

定義: 返回在數(shù)組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1。

語法:

array.indexOf(searchElement,fromIndex);

參數(shù):

  • searchElement(必須):被查找的元素；
  • fromIndex(可選):開始查找的位置(不能大于等于數(shù)組的長度，返回-1)，接受負值，默認(rèn)值為0。

嚴(yán)格相等的搜索: 數(shù)組的indexOf搜索跟字符串的indexOf不一樣,數(shù)組的indexOf使用嚴(yán)格相等===搜索元素，即數(shù)組元素要完全匹配才能搜索成功。indexOf不能識別NaN。

let a=['啦啦',2,4,24,NaN]

console.log(a.indexOf('啦')); // -1

console.log(a.indexOf('NaN')); // -1

console.log(a.indexOf('啦啦')); // 0

使用場景：數(shù)組去重

  • 根據(jù)獲取的數(shù)組下標(biāo)執(zhí)行操作，改變數(shù)組中的值等；
  • 判斷是否存在，執(zhí)行操作。

定義: 方法返回指定元素,在數(shù)組中的最后一個的索引，如果不存在則返回 -1（從數(shù)組后面往前查找）。

語法:

arr.lastIndexOf(searchElement,fromIndex);

參數(shù):

  • searchElement(必須): 被查找的元素；
  • fromIndex(可選): 逆向查找開始位置，默認(rèn)值數(shù)組的長度-1，即查找整個數(shù)組。

關(guān)于fromIndex有三個規(guī)則:

  • 正值：如果該值大于或等于數(shù)組的長度，則整個數(shù)組會被查找。
  • 負值：將其視為從數(shù)組末尾向前的偏移。(比如-2，從數(shù)組最后第二個元素開始往前查找)
  • 負值：其絕對值大于數(shù)組長度，則方法返回 -1，即數(shù)組不會被查找。
let a=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1'];

// 數(shù)組長度為10

// let b=a.lastIndexOf('Koro1',4);

// 從下標(biāo)4開始往前找 返回下標(biāo)2

// let b=a.lastIndexOf('Koro1',100);

// 大于或數(shù)組的長度 查找整個數(shù)組 返回9

// let b=a.lastIndexOf('Koro1',-11);

// -1 數(shù)組不會被查找 let b=a.lastIndexOf('Koro1',-9);

// 從第二個元素4往前查找，沒有找到 返回-1

ES7 includes() 查找數(shù)組是否包含某個元素

定義： 返回一個布爾值，表示某個數(shù)組是否包含給定的值

語法：array.includes(searchElement,fromIndex=0);

參數(shù)：

  • searchElement(必須):被查找的元素；
  • fromIndex(可選):默認(rèn)值為0，參數(shù)表示搜索的起始位置，接受負值。正值超過數(shù)組長度，數(shù)組不會被搜索，返回false。負值絕對值超過長數(shù)組度，重置從0開始搜索。

includes方法是為了彌補indexOf方法的缺陷而出現(xiàn)的，indexOf方法不能識別NaN；indexOf方法檢查是否包含某個值不夠語義化，需要判斷是否不等于-1，表達不夠直觀。

let a=['OB','Koro1',1,NaN];

// let b=a.includes(NaN);

// true 識別NaN

// let b=a.includes('Koro1',100);

// false 超過數(shù)組長度 不搜索

// let b=a.includes('Koro1',-3);

// true 從倒數(shù)第三個元素開始搜索

// let b=a.includes('Koro1',-100);

// true 負值絕對值超過數(shù)組長度，搜索整個數(shù)組

chrome47,Firefox 43,Edge 14,Opera 34, Safari 9,IE 未實現(xiàn)。

參考文章

某度 2014 年秋招前端筆試
js 數(shù)組詳細操作方法及解析合集

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

友情鏈接更多精彩內(nèi)容