摘要：數組元素甚至可以是對象或其它數組。它執行的是淺拷貝，這意味著如果數組元素是對象，兩個數組都指向相同的對象，對新數組中的對象修改，會在舊的數組的相同對象中反應出來。

JS中的數組是弱類型的，數組中可以含有不同類型的元素。數組元素甚至可以是對象或其它數組。
JS引擎一般會優化數組，按索引訪問數組常常比訪問一般對象屬性明顯迅速。
數組長度范圍 from 0 to 4,294,967,295(2^23 - 1)

JavaScript 中的數據通常由一個數組來表示, 所以當可視化或分析數據時往往也會操作數組. 常見的數組操作包括切片, 過濾, 遍歷等等. JavaScript 本身支持的數組操作可以參考 這里.

主要分為三大類：
JavaScript 中 修改數組自身 的方法:

array.pop - 移除最后一個元素.

array.push - 追加一個或多個元素.

array.reverse - 數組翻轉.

array.shift - 移除第一個元素.

array.sort - 排序.

array.splice - 添加或者移除.

array.unshift - 在數組前添加一個或多個元素.

JavaScript 中數組的 存取 方法 :

array.concat - 將數組與數組或值合并.

再看看解構方法

const arr1 = [1,2,3];
const arr2 = [4,5,6];

const result = [...arr1, ...arr2];

array.join - 只用指定的字符串將數組轉為一個字符串.

array.slice - 提取切片.

array.indexOf - 找出指定元素的索引.(搜索)

array.lastIndexOf - 找出指定元素的最后一個索引.

JavaScript 中數組的 迭代方法 :

array.filter - 過濾.

array.forEach - 對每個元素執行某個方法.

array.every - 是否每個元素都符合給定的條件.

array.map - 根據指定的操作對每個元素執行后返回一個新的數組.

array.some - 是否存在符合某個條件的元素.

array.reduce - 從左到右執行 reduce 操作并返回一個值.

array.reduceRight - 從右到左執行 reduce 操作并返回一個值.

數組在數學中也可以稱為“數列”，也就是以數字或其他類型內容為元素的有序集合。

// 整型數字數組
const intArray = [ 1, 2, 3, 4, 5 ]
// 浮點型數字數組
const floatArray = [ 1.1, 1.2, 1.3, 1.4, 1.5 ]
// 字符串數組
const strArray = [ "a", "b", "c", "d", "e" ]...

在數據科學領域中，數組可以說是承載了絕大部分數據的表達任務，無論是規整的數據表，還是隨時間排序的時間序列，或是復雜多變的非結構化數據，都可以使用數組或類數組的形式表達。

數組是對象，對象不一定是數組

都可以繼承

都可以當做對象添加刪除屬性

數組自動更新length

數組操作通常被優化

數組對象繼承Array.prototype上的大量數組操作方法

稀疏數組并不含有從0開始的連續索引。一般length屬性值比實際元素個數大。

for in 可以枚舉可枚舉屬性名，對象，數組都是可以使用的，可以把數組理解為一種特殊的對象，常用for in枚舉稀疏數組

我們前面講到數組是一個有序集合，那么就意味著它包含了若干個元素。當然了，數組可空。因為它是一個包含了若干元素的集合，所以它就肯定天然地包含了一個屬性，那便是元素的數量。

const array = [ 1, 2, 3, 4, 5 ]
console.log(array.length) //=> 5

因為在計算機中的可用內存是有限的，所以大部分程序在創建數據（比如數組）的時候，都需要先設定好該數據的所占長度。但在 JavaScript 中這并不需要，因為實際在 JavaScript 中數組就是一個特殊的對象。

所以在 JavaScript 中，對數組內容的修改會比較方便。“增查改刪”是數據庫應用領域中最常見的操作，這在數組中也是一樣的。

array.push

array.splice(start, deleteCount, element)

第二個參數deleteCount用來刪除數組中某個位置開始的若干個元素

如果設置為0，該方法第三參數以及后面的參數會被插入到start位置(array[start]開始)

    let keys = ["純新客", "品類轉化新客", "老客"]
    keys.splice(keys.indexOf("純新客"), 1)

vue源碼中就用的此方法

/**
 * Remove an item from an array
 */
function remove (arr, item) {
  if (arr.length) {
    var index = arr.indexOf(item);
    if (index > -1) {
      return arr.splice(index, 1)
    }
  }
}

數組是個有序集合,我們在對數組中的元素進行查找的時候也是一個有序進行的過程，而最常用的查找方法便是filter過濾器.

過濾器的邏輯是：定義一個過濾函數，該函數會有序地被傳入數組中當前下標的元素，而它則需返回該函數是否符合其過濾要求，即結果為true或false
在數組中找出偶數項：

常用于權限驗證

Array.isArray([]);//true
[] instanceof Array; //true
({}).toString.apply([])==="[object Array]";//true
[].constructor ===Array;//true

js實現對象-數組-字符串之間的相互轉化
對象-數組-字符串：　　

　　例如：
　　var data = {
           user:”userName”,
     　　pass:”12121”
　　};//這是一個對象
　　
　　如果要給這個data 對象追加一個屬性就比如：
 
　　new Date( ).getTime( );//獲取當前時間到那個時間的時間間隔單位是毫秒；
 
　　data.time = new Date( ).getTime( );
 
　　此時data 里面就多了一個屬性： time : “ 獲取到的那個毫秒數"      
　　即：　var data = {
　　　　　　user:”userName”,
　　　　　　pass:”12121”
　　　　　　time:"獲取的時間數值"
　　　　　};
　
　1:　對象轉化為數組：
 
　　var arr = [ ];
 　　for ( var i in data ){
         　　 var str = i + “=“ + data[ i ]// i 就代表 data 里面的 user pass 等等 而data[ i ] 就代表 userName    12121 就是 i 所對應的值；
          　　arr.push( str );
　　}
　　這樣就會得到 arr  =  [ user = userName, pass = 12121 ];
　　
　2:數組轉化為字符串:
　　
　　兩種方法：
　　　　1：arr.join( “&”)//意思是用&f符代替“ ， ”然后把數組變成字符串連接；          這時候 arr 里面的內容就是 user = tangcaiye&pass = 12121
　　　　2： 比如：
　　　　　　var arr = [1,2];
　　　　　　var str = JSON.stringify(arr);//這樣也能轉化為字符串但現在還是數組的形式不過類型已經是字符串了；
　　　　　　var arr2 = JSON.parse(str);//這樣就是把字符串解析 其實就是把外面的中括號去掉；
 
　　　　前后臺交互的：
　　　　后臺接收的時候只能接收字符串類型的；
　　　　如果前臺要傳遞一個數組就必須先把數組進行stringify( )的操作再進行傳遞；
　　　　而后臺返回給前臺的也是字符串簡稱json串；這時需要解析一下就需要 JSON.parse( );操作完了再用；
 
　3：字符串轉化為數組：
　　
　　例如：
　　有個這樣的 ： url = “login.php?user=“+user.value+”&pass=“+pass.value;
 
　　那我想要得到login.php就是這樣寫：var urlArr = url.split(“?”);
 
　　上面那個意思就是以？為分割點把這個字符串劈開變成一個數組的兩部分；
 
　　那么 aa = urlArr[0];此時 aa 就等于 login.php;
　　bb = urlArr[1];此時bb 就等于 后面那一坨

　　　　

js怎么實現類似python的range函數

Array.apply(null, {length: N}).map(Number.call, Number)為range的hack；

Array.from()ES6為Array增加了from函數用來將其他對象轉換成數組。

當然，其他對象也是有要求，也不是所有的，可以將兩種對象轉換成數組。

1.部署了Iterator接口的對象，比如：Set，Map，Array。

2.類數組對象，什么叫類數組對象，就是一個對象必須有length屬性，沒有length，轉出來的就是空數組。

比如：

arguments對象不是數組，而是一個類似數組的對象。所以為了使用數組的方法，必須使用Array.prototype.slice.call先將其轉為數組。rest 參數就不存在這個問題，它就是一個真正的數組，數組特有的方法都可以使用。

// arguments變量的寫法
function sortNumbers() {
  return Array.prototype.slice.call(arguments).sort();
}

// rest參數的寫法
const sortNumbers = (...numbers) => numbers.sort();

這里用到的 rest參數

注意這里加了鍵值 0

使用Array對象的　concat()　方法，將多維數組合并為一個單維數組：

使用Array的indexOf()和splice()方法，找到并刪除/替換數組元素　

使用Array對象的slice()方法，來提取已有數組的一部分的一個淺拷貝(shallow copy)

注意slice()方法復制一個已有的數組的一部分，返回一個新數組。
它執行的是淺拷貝，這意味著：

如果數組元素是對象，兩個數組都指向相同的對象，對新數組中的對象修改，會在舊的數組的相同對象中反應出來。

如果數組元素是基本數據類型，例如，字符串或數字，它們將按照值(by value）來復制（值是按照引用來復制的）,也就是說，對新數組的修改，不會在舊數組中反映出來（如最上面的例子）

注意：　不要從傳遞給forEach的函數返回一個值，因為該值會被丟棄
但是用map就需要
因為：map()的結果是一個新的數組，而不是像forEach()一樣修改最初的數組

可以將forEach()強制地和一個NodeList(querySelectorAll()返回的集合)一起使用

//使用querySelector找到第二列中的所有單元格
var cells = document.querySelectorAll("td+td");
[].forEach.call(cells, function(cell) {
  sum += parseFloat(cell.firstChild.data);
});

var arr = [1, 2, 3, 1, 2, 3, 4, 5, 5];
var resultArr = [];
//使用數組的sort()方法對arr進行排序,也可以使用冒泡排序
arr.sort(function (a, b) {
    return a - b;
});
//排序后,arr變成了[1, 1, 2, 2, 3, 3, 4, 5, 5]

//使用for循環,從上面的數組可以看出,如果數組元素arr[i]和arr[i+1]不相等,則表示arr[i]之后不再有與arr[i]相等的重復元素
for (i = 0; i < arr.length; i++) {
    if (arr[i] != arr[i + 1]) {
        //將arr[i]賦值給resultArr數組.
        resultArr[resultArr.length] = arr[i];
    }
}
console.log(resultArr); //1,2,3,4,5

[...new Set([2,"12",2,12,1,2,1,6,12,13,6])]
    
    // [2, "12", 12, 1, 6, 13]

在這我們可以看見，重復的項目已經被去掉了，包括NaN。正常情況下，NaN === NaN 返回的是false，但是在set里，一樣能夠幫你去重

但是這里大家可以看到，set返回的是一個對象，但是我們想要的是數組啊。

這回，就該輪到Array.from出場了，它的作用，就是可以把類數組對象、可迭代對象轉化為數組。

移除一個數組中的重復元素, 這些元素可能是多種不同數據類型
Lodash如何從數組中刪除重復項？

找出數組中的最小值

找出數組中的最大值

var arr = [1,2,3,4,5,6,7,8,9,10];
    arr.sort(function(){
        return Math.random() - 0.5;
    })
    console.log(arr);

首先： 當return 的值

    小于 0 ，那么 a 會被排列到 b 之前；
    等于 0 ， a 和 b 的相對位置不變；
    大于 0 ， b 會被排列到 a 之前；

這里你會 發現起始 的時候數組是正序排列，每當進行一次排列的時候， 都會先隨機一個隨機數 
（注意這里的每一次排列 指 每一個紅框指一次排列， 共9次排列 ， 一次排列中可能存在多次比較）；

當一次排列的 隨機數大于0.5 時 將會進行第二次比較， 當第二次隨機數 仍然大于0.5 時 ，
    將會再 進行一次比較， 直到 隨機數大于0.5 或者排列到第一位；

當一次排列的 隨機數 小于0.5時 當前比較的兩項 索引將不會改變 ，繼續下一次 的排列；

注意和下面的區別

更多查看Array.prototype.reduce()
這是reduce實現過程:

Array.prototype.reduce=function(callback){
    var total=0;
    this.forEach(function(e){ total=callback(total,parseInt(e));});
   return total;

 };

let arr = [2, 5, 8, 1, 4, 17, 89]

// filter 實現
let result = arr.filter(item => {
    return item > 9
}).length > 0


// find 實現
let result = arr.find(item => {
    return item > 9
})  !== undefined


// some 實現
let result =  arr.some(item => {
    return item > 9
})

下面是d3-array中涉及的一些數組操作

d3.min(array[, accessor]) <源碼>

對指定的 array 進行自然排序返回最小值. 如果數組為空則返回 undefined. 可選的參數 accessor 可以用來自定義如何訪問數組中的元素. accessor 將會被傳遞給 map 以在數組的每個元素上進行調用, 返回值將會被作為對比依據.

與內置的 Math.min 不同, 這個方法可以忽略 undefined, null 和 NaN 等特殊值. 在可視化中用來忽略缺失數據是很有用的. 需要注意的是, 對比是以自然排序進行的, 而非數值對比. 比如對字符串 ["20", "3"] 進行 min 操作返回 20, 而對數值 [20, 3] 進行 min 操作則返回 3.

d3.cross

d3.variance(array[, accessor])：　準確的說它返回的是總體方差無偏估計量

let a = [ { name:"1", status:"1" }, { name:"2", status:"1" }, { name:"3", status:"2" }, { name:"4", status:"2" }, { name:"5", status:"3" }, { name:"6", status:"bbb" } ]
     
{ "1":[{ name:"1", status:"1" }, { name:"2", status:"1" }], "2":[{ name:"3", status:"2" }, { name:"4", status:"2" } ], "3":[ { name:"5", status:"3" }],"bbb":[{ name:"6", status:"bbb" }] }

用ES6如何把上面的變成下面這種結構.
不用一個一個 push，對每一個 status 直接 filter 一下就行了

let result = a.reduce((acc, {status}) => (
  acc[status] ? acc: {
    ...acc,
    [status]: a.filter(item => item.status === status)
  }
), {})

export function delFromArr (val, arr) {
  if (arr && arr.indexOf(val) !== -1) {
    arr.splice(arr.indexOf(val), 1)
  }
}

export function clearArr (...arrs) {
  arrs && arrs.forEach(arr => arr.splice(0, arr.length))
}

/**
 * key: "val"
 * arr: [{val: 1}, {val: 2}]
 * return [1, 2]
 */
export function getKeyMap (key, arr) {
  return arr.map(i => {
    return i[key]
  })
}

/**
 * key: "val"
 * arr: [{val: 1}, {val: 2}]
 * return 2
 */
export function getMax (key, arr) {
  let result = arr.reduce((pre, next) => {
    return parseInt(pre[key]) > parseInt(next[key]) ? pre : next
  })

  return result[key]
}

export function arrDelObj (arr, key, val) {
  if (!(arr && key && val)) {
    console.error("arrDelObj error: arr, key or val is undefined")
  }
  return arr.filter(item => {
    return item[key] !== val
  })
}

每個菜鳥前端都會遇到一個菜鳥后端督促你學習數據處理，下面羅列一些遇到過的數據處理.

歸一化下面數據，變成想要的格式

接口數據：

前端想要的數據:

實現：

降維、去重、排序

給出：let arr = [[1, 2, 3], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10, 0];
需求：降維、去重、排序
做法：Array.from(new Set(arr.flat(Infinity).sort((a, b) => a - b)))


解析如下：
0. arr.flat(Infinity)  //直接降維值一維數組。
1. sort     //排序就不說了。
2. new Set()  //達到去重效果
3. Array.from(上一步輸出的結果)  //將上一步結果轉換為數組

Array.prototype.concat.apply([], arr)為啥這個方法會把數組的深度降 1 呢？

arr=[[1,2],3,4]。arr是一個二維數組，通過apply方法，apply方法第二個參數是arguments，即參數數組，前面的公式就變成了[].concat([1,2],[3,4],[5]),concat方法的參數是一個元素，該元素會被直接插入到新數組中；如果參數是一個數組，該數組的各個元素將被插入到新數組中；于是最后的結果就是[1,2,3,4,5]相當于把原來的二維數組拉成了一緯數組

JS數組學習筆記
Array MDN
《數據結構與算法javascript描述》
JavaScript30-Challenge/04 - Array Cardio Day 1/
ES6，Array.from()函數的用法
《javascript經典實例》
Array.prototype.slice()
Array.prototype.forEach()
Array.prototype.map()
ES6的新方法實現數組去重
d3-array
lodash
d3-array 解釋
https://segmentfault.com/q/10...
d3array 測試
JavaScript數組方法速查手冊極簡版