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' ]...

在数据科学领域中，数组可以说是承载了绝大部分数据的表达使命，无论是规整的数据表，照样随时刻排序的时刻序列，或是复杂多变的非构造化数据，都可以运用数组或类数组的情势表达。

数组建立

数组读写

数组 VS. 平常对象

雷同点

• 数组是对象，对象不一定是数组
• 都可以继承
• 都可以当作对象增加删除属性

差别点

• 数组自动更新length
• 数组操纵一般被优化
• 数组对象继承Array.prototype上的大批数组操纵要领

希罕数组

希罕数组并不含有从0最先的一连索引。平常length属性值比现实元素个数大。

for in 可以排列可排列属性名，对象，数组都是可以运用的，可以把数组理解为一种特别的对象，经常使用for in排列希罕数组

数组的length属性

我们前面讲到数组是一个有序鸠合，那末就意味着它包含了多少个元素。固然了，数组可空。由于它是一个包含了多少元素的鸠合，所以它就一定天然地包含了一个属性，那就是元素的数目。

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

增编削查

由于在计算机中的可用内存是有限的，所以大部分顺序在建立数据（比方数组）的时刻，都须要先设定好该数据的所占长度。但在 JavaScript 中这并不须要，由于现实在 JavaScript 中数组就是一个特别的对象。

所以在 JavaScript 中，对数组内容的修正会比较轻易。“增查改删”是数据库运用领域中最罕见的操纵，这在数组中也是一样的。

增加到末尾append

• array.push

增加首端prepend

增加到中心insert

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 就即是 背面那一坨

　　　　

怎样完成range函数

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

用concat()和apply()将一个两维数组扁平化

运用Array对象的　concat()　要领，将多维数组兼并为一个单维数组：

删除或替代数组元素

运用Array的indexOf()和splice()要领，找到并删除/替代数组元素　

提取一个数组的一部分

运用Array对象的slice()要领，来提取已有数组的一部分的一个浅拷贝(shallow copy)

注重slice()要领复制一个已有的数组的一部分，返回一个新数组。
它实行的是浅拷贝，这意味着：

• 假如数组元素是对象，两个数组都指向雷同的对象，对新数组中的对象修正，会在旧的数组的雷同对象中回响反应出来。

• 假如数组元素是基础数据范例，比方，字符串或数字，它们将根据值(by value）来复制（值是根据援用来复制的）,也就是说，对新数组的修正，不会在旧数组中反应出来（如最上面的例子）

对每一个数组元素运用一个函数

注重：　不要从通报给forEach的函数返回一个值，由于该值会被抛弃
然则用map就须要
由于：map()的结果是一个新的数组，而不是像forEach()一样修正最初的数组

运用forEach() and call() 遍历querySelectAll()的结果

可以将forEach()强迫地和一个NodeList(querySelectorAll()返回的鸠合)一同运用

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

数组去重

sort()要领排序后比较

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

set要领

[...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进场了，它的作用，就是可以把类数组对象、可迭代对象转化为数组。

filter要领

缓存要领

lodash完成

移除一个数组中的反复元素, 这些元素多是多种差别数据范例

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-array中触及的一些数组操纵

统计类要领 Statistics

• 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])：　正确的说它返回的是整体方差无偏估计量

将数组中相邻的两个元素两两连系

数组元素最大值

数组元素占最大值比例（数据归一化）

lodash

罕见数组操纵题目

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)
  }
), {})

ramda

罕见数组utils

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数组要领速查手册极简版