数组整理随手笔记

数组

数组类型是 object （typeof [] == object）

创建数组

1. var arr = new Array();

// new Array();一般用来创建长度很长的空数组。

var arr = new Array(100);   // 长度为100的空数组
var arr = new Array(100,100);     // 等价于 [100 ,100]

2. var arr = [];

数组的属性

1. arr.length

数组的方法

1. arr.forEach( function ); // 数组有多少，就执行多少遍

2. arr.sort() // 对数组进行排序

3. arr.push() // 数组进行加项，

4. arr.toString() // 把数组改成数组值

const arr = ["red","green","blue"];
console.log(arr.toString());
// 相当于结构
// red,green,blue

5. arr.join( - ); // 将数组值变成一个连起来的字符串

const arr = ["red","green","blue"];
arr.join( "*" );
//  red*green*blue

6. arr.pop(); // 删除数组最后一个数据，返回最后一个数据。

7. arr.push(‘red’); // 在数组最后加入一个数据，返回加入后数组长度length

      // 把数据加到第一项
      // push的话加到最后一项，这样是加到第一项
      result = [obj].concat(showGoodsList);

8. arr.shift(); // shift() 方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引。返回删除的数据

9. arr.unshift(‘red’); // 在数组最前面加入数据，返回新数组长度length

10. arr.splice(beginIndex, number, “Lemon”,“Kiwi”);

arr.splice(2,1,"KIWI");
// 从索引为2的数据开始，包含索引为2，开始，1是截取1个数据，然后替换

第一个参数（2）定义了应添加新元素的位置（拼接）。
第二个参数（0）定义应删除多少元素。

其余参数（“Lemon”，“Kiwi”）定义要添加的新元素。
splice() 方法返回一个包含已删除项的数组：

11. arr1.concat(arr2) // 两个数组进行拼接

var myGirls = ["Cecilie", "Lone"];
var myBoys = ["Emil", "Tobias", "Linus"];
var myChildren = myGirls.concat(myBoys);   // 连接 myGirls 和 myBoys

12. arr.slice(1); // 把一个数组截取返回一个截取到的新数组，不会改变原来的数组

arr.slice(1);
// 一个参数的话，从index到最后   包含1，begin

arr.slice(1,3);
// 两个参数的话，从begin到end。   不包含end [begin,end)

数组排序的方法

1. arr.sort() // 对数组按照字母的unicode编码进行顺序排序,只看首字符。所以这样会导致 20 大于 100

// 默认地，sort() 函数按照字符串顺序对值进行排序。
// 该函数很适合字符串（"Apple" 会排在 "Banana" 之前）。
// 不过，如果数字按照字符串来排序，则 "25" 大于 "100"，因为 "2" 大于 "1"。

所以我们用比值法解决这个数字排序问题

const arr = [1,2,3];
arr.sort((a ,b)=>{
  return a - b;
});

// 传的参数为负数就不换位置，正值就需要换位置。
// 所以A - B为从小到大排列
//     B - A为从大到小排列

// 根据类型进行排列

var obj = [
  {name : "xiaowang", age : 18},
  {name : "xiaochen", age : 19},
  {name : "xiaolin", age : 20}
];

function compare ( type ) {
  //  这里为什么会想到返回一个函数呢，因为sort里面需要写一个函数
  return function (a, b) {
    var value1 = a[type];
    var value2 = b[type];
    return value1 - value2;
  }
}

arr.sort( compare( "name" ) );
V8 引擎 sort 函数只给出了两种排序 InsertionSort 和 QuickSort，数量小于10的数组使用 InsertionSort，比10大的数组则使用 QuickSort。

2. arr.reverse(); // 颠倒数组的排序

数组迭代（数组遍历）

1. arr.forEach(function (value, index, arr){ }); // 三个参数， value，index， arr本身

2. arr.map(function (value, index, arr) {}); // 通过对每个数组元素执行函数来创建新数组。返回一个新数组，不会改变原来的数组。

// 一般用来操作数组
const arr = [1,2,3];
arr = arr.map(function (value ) {
  return value * 2;
});
// 每个元素都乘以2

3. arr.filter(function (value ,index , arr){ }); // 一般用来筛选，产生一个新数组。

const arr = [1,1,2,3,98,0,13,4];
arr = arr.filter(function (value){
  return value > 10;
});

4. arr.reduce(function (total , value, index, arr){ }, InitialValue); // 4个参数，第一参数是数组的第一项，这个函数，只遍历arr.length - 1次，一般用来算一个数组的数据的总和。从左（开头）开始累加

// total ( 初始值/先前返回的值 )
//  index 从1开始，value从第二项开始，  total没有初始值时，为第一项。后来都是return返回的值，返回undefined，total就是undefined。 不会改变原数组
const arr = [10,9,8,31,3,57,0,1,3,87,4];
arr.reduce(function (total , value, index, arr){
  total = total + value;
  return total;
});

// 注意：
//  还可以添加一个初始值，初始值会赋值给total
//  当添加初始值时，index就从0开始遍历，遍历arr.length 次了。

5. arr.reduceRight(function (total, value , index, arr){ },initialValue); // 与reduce的区别就是，他是从右边（末尾）开始累加的。

// 系统自带的函数消耗的性能比较少。遍历1000个时，比white与for省性能
// 可以用console.time("123");    console.timeEnd("123"); 测试一下时间

6. arr.every(function ( value , index, arr){}); // 一般用于测试一个数组是否都满足条件。一个不符合就返回false

arr.every(function (value){
  return value > 18;
  // 一旦有一个不满足条件，就返回false，不会再测试后的数值。
});

7. arr.some(function (value, index, arr) {}); // 一般用于检测数组是否有一个符合条件。，有一个就足够了

arr.some(function (value){
  return value > 18;
})

8. indexOf(searchvalue,fromindex)
   fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。

//  查找到searchvalue时就返回searchvalue的index，找不到时，返回 -1

9. arr.lastIndexOf(); // 与indexOf的区别就是，它是从最后开始查找的。

10. arr.find(); // 查找第一个满足条件的值，返回这个值。

arr.find(function (value , index, arr){
  return value >18;
});

11. arr.findIndex(function (value, index, arr){}); // 查找第一个满足条件的值的索引。

判断是不是数组

1000. Array.isArray( arr ); // 判断是不是数组，ECMAScript 5 定义的新方法 老的浏览器不能用。需要自己包装一个。

// 判断是不是数组
// 方法1 .
function isArray(x) {
    return x.constructor.toString().indexOf("Array") > -1;
}

// 方法2 .
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits instanceof Array     // 返回 true

注意点

具有命名索引的数组被称为关联数组（或散列）。

js不支持命名索引

var person = [];
person["firstName"] = "Bill";
person["lastName"] = "Gates";
person["age"] = 62;
var x = person.length;         // person.length 将返回 0
var y = person[0];              // person[0] 将返回 undefined

补充

1. instanceof

instanceof 运算符用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
const auto = new Car('Honda', 'Accord', 1998);

console.log(auto instanceof Car);
// expected output: true

console.log(auto instanceof Object);
// expected output: true

2. delete

var fruits = ["Banana", "Orange", "Apple", "Mango"];
delete fruits[0];           // 把 fruits 中的首个元素改为 undefined

// 使用 delete 会在数组留下未定义的空洞。请使用 pop() 或 shift() 取而代之。

3. toString()
   // 所有的对象都要这个方法

4. Math.min() || Math.max()

 // 寻找最大最小值，直接用这个函数就可以了。不需要进行排序再找出来来。
  这个函数一般这样使用，Math.min(1,2,3,4,5,6);

  查找数组时。所以需要加个apply

  Math.min.apply(null, arr);

  // 手写Math.max
function myArrayMax(arr) {
    var len = arr.length
    var max = -Infinity;
    while (len--) {
        if (arr[len] > max) {
            max = arr[len];
        }
    }
    return max;
}