数组api & 类数组

数组api

• 创建数组 new Array() 构造方法

arr = [] 数组自变量 相当于new Array 所有方法都是 Array.prototype
js里的数组基于对象，当访问没有的属性时返回undefined 不报错

	var arr = [,] // [empty] 	 length 1
	var arr = [, , ] // [empty*2] // length 3
	var arr = [ 1, ,1 ] // [1, empty ,1] // length 3
	
  var arr =	new Array(1,2,3,4,5) // [1,2,3,4,5]
  var arr =	new Array(10) 
  // [empty*10] 当newArray只有一个参数，参数为length
  var arr =	new Array(10.3)  // 报错 数组长度不能为小数
  Array() // []   

• Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
  Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组

Array.of(7);       // [7] 
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

• 将数组转换为字符串

String(arr) 返回一个与数组视觉上一样的字符串

var arr = [1, 2, 3, 4]
var str = String(arr)
str // "1, 2, 3, 4"

• 将数组拼成字符串

arr. join(“分隔符”) 如果分隔符""则无缝拼接，如果括号里不写，则等同于 String()

	 var arr = [1, 2, 3, 4]
    console.log(arr.join(""));    // 1234
    console.log(arr.join());    // "1,2,3,4"
    console.log(arr.join("~"));    //1~2~3~4

• 数组连接

arr.concat() 将两个数组合并成一个数组，concat的参数中包含数组，则打散数组，以单个元素拼接

	// 字符串拼数组
	var arr1 = [1, 2, 3], arr2 = [4, 5, 6]
    console.log(arr1.concat(1, 2));  //[1, 2, 3, 1, 2]
    // 数组拼数组
    var arr1 = [1, 2, 3], arr2 = [4, 5, 6]
    console.log(arr1.concat(arr2));  //[1, 2, 3, 4, 5, 6]

• 数组截取

arr.slice(start,end+1) 含头不含尾
获得arr中starti位置开始，到endi位置的所有元素组成的新数组
省略第二个参数：表示从starti一直取到结尾
可支持负数参数：-n表示倒数第n个元素，相当于length-n

	var arr = [1, 2, 3, 4]
    arr.slice(0)//[1, 2, 3, 4]
    arr.slice(0, 2)//[1, 2]
    arr.slice(-3)//[2, 3, 4]
    arr.slice(-3, -1)//[2, 3]
    arr.slice(0, 2)//[1, 2]
    arr//[1, 2, 3, 4]

• 删除，插入，替换数组元素 直接修改原数组

arr.splice(start,n) 删除从start开始的n个元素 返回被删除的元素组成的临时新数组
arr.splice(start,0,1,2,3) 从start开始删除0个元素，添加1,2,3
arr.splice(start,3,1,2,3) 从start开始删除n个，添加1，2，3

// 删除
  	var arr = [1, 2, 3, 4]
    arr.splice(0)//[1, 2, 3, 4]

    var arr = [1, 2, 3, 4]
    arr.splice(-1)//[4]

    var arr = [1, 2, 3, 4]
    arr.splice(0, 3)//[1, 2, 3]
    arr // [4]

// 添加
    var arr = [1, 2, 3, 4]
    arr.splice(2, 0, 22, 33)
    arr//[1, 2, 22, 33, 3, 4]  在 2 的位置上删除0个 添22,33

// 替换
	var arr = [1, 2, 3, 4]
    arr.splice(2, 2, 5, 6)
    arr//[1, 2, 5, 6]

• 数组排序 改变原数组

arr.sort() 默认升序
sort()括号里是一个接口，可以通过回调函数按照想要的方式排序
要求： 必须写两个形参 ； 排序根据返回值
当为负数升序 前面的数在前，正数降序 后面的数在前， 0不动

arr=[1,5,3,2]
arr.sort()//[1, 2, 3, 5]

arr=[1,5,32,2]
arr.sort()//[1, 2, 32, 5]
arr//[1, 2, 32, 5] 这里有个bug 因为排序是按照Unicode码来排序 3在5之前

var arr = [1, 4, 3, 10,  42]
arr.sort(function (a, b){
	if(a > b){      // 可以直接写成 return a-b  升序
		return 1;	//  return b-a 降序
	}else {
		return -1;
	}
})
// [1, 3, 4, 10, 42]  降序只需要把判断改掉

// 对象也可以排序
    var a = {
      age: 21
    }
    var b = {
      age: 51
    }
    var c = {
      age: 17
    }
    var d = {
      age: 24
    }

    var arr = [a, b, c, d]

    arr.sort(function (a, b) {
        return a.age - b.age
    })
(4) [{…}, {…}, {…}, {…}]
/*
0:{age: 17}
1:{age: 21}
2:{age: 24}
3:{age: 51} 
*/

// 根据字节长度排序
    String.prototype.bytes = function retBytes() {
      var num = this.length
      for (var i = 0; i < this.length; i++) {
        if (this.charCodeAt(i) > 255) {
          num++
        }
      }
      return num
    }

    var arr = ["dfafd", "sfdfffdsss", "cd", "sdfdfss"]

    arr.sort(function (a, b) {
      return a.bytes() - b.bytes()
    })
    console.log(arr);  //["cd", "dfafd", "sdfdfss", "sfdfffdsss"]

• 数组反转 修改原数组

arr.reverse() 将数组里的数值反转，并修改原数组
自己封装思路 就是将原数组逆向循环，然后push新数组里，最后重新赋值给原数组

var arr = [1, 2, 3]
    arr.reverse()
    arr // [3,2,1]
    // 原理
    
    var arr = [1, 2, 3]
    var index=[]
    for (let i = arr.length; i  ; i--) {
      index.push(i)
    }
    console.log(index); //  [3,2,1]

• 结尾出入栈

结尾入栈 arr.push() 返回新数组的length
结尾出栈arr.pop()

// 入栈
var arr=[1,2,3,4]
arr2=arr.push(1)//5
//返回新数组的长度
arr//[1, 2, 3, 4, 1]

//  push 原理
    Array.prototype.push = function (target) {
      this[this.length] = target;
      this.length++
    }

// 出栈
var arr=[1,2,3,4]
arr.pop()//4
//返回弹出的元素
arr//[1,2,3]

• 开头出入栈 修改原数组

入栈 arr.unshift()
出栈arr.shift() 返回取出的元素

//  入栈 
var arr=[1,2,3,4]
arr.unshift(22)//5
arr//[22, 1, 2, 3, 4]
// 原理 新建一个数组，然后再拼接

// 出栈
var arr=[1,2,3,4]
arr.shift()//1
arr//[2, 3, 4]

• 直接修改原数组

1.arr.splice();
2.arr.reverse();
3.arr.sort();
4.arr.push(值);arr.pop();
5.arr.unshift(值);arr.shift();

• 不修改原数组：

1.String(arr);
2.arr.join(“自定义分隔符”);
3.arr1.concat(值1,值2,arr2,…);
4.arr.slice(starti,endi+1);

• Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例。

console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]

• Array.isArray() 用于确定传递的值是否是一个 Array。

Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false

• arr.copyWithin(target[, start[, end]]) 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小
  target:必需。复制到指定目标索引位置。
  start: 可选。元素复制的起始位置。
  end:可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数

var array1 = [1, 2, 3, 4, 5];
// place at position 0 the element between position 3 and 4
console.log(array1.copyWithin(0, 3, 4));
// expected output: Array [4, 2, 3, 4, 5]

// place at position 1 the elements after position 3
console.log(array1.copyWithin(1, 3));
// expected output: Array [4, 4, 5, 4, 5]

• arr.entries() //没卵用的方法
  entries构造出一个对象，有next方法构造出一个对象

var array1 = ['a', 'b', 'c'];

var iterator1 = array1.entries();

console.log(iterator1.next().value);
// expected output: Array [0, "a"]

console.log(iterator1.next().value);
// expected output: Array [1, "b"]
{
value:[0:index,1:'value'],
done:false
}
//结束时value:undefine, done: true

• arr.every(callback[, thisArg]) // 用来测试此数组的元素是否满足某个条件
  callback
  用来测试每个元素的函数。
  thisArg
  执行 callback 时使用的 this 值。

function isBelowThreshold(currentValue) {
  return currentValue < 40;
}

var array1 = [1, 30, 39, 29, 10, 13];

console.log(array1.every(isBelowThreshold));
// expected output: true

• arr.fill(value[, start[, end]]) 用来填充/替换数组，把一些固定值放进数组的某个位置
  value:用来填充的值 若只有一个值则替换所有数组
  start: 开始位置 可不写
  end: 结束位置 可不写 不写则到数组结束

var array1 = [1, 2, 3, 4];

// fill with 0 from position 2 until position 4
console.log(array1.fill(0, 1, 3));
// expected output: [1, 0, 0, 4]

// fill with 5 from position 1
console.log(array1.fill(5, 1));
// expected output: [1, 5, 5, 5]

console.log(array1.fill(6));
// expected output: [6, 6, 6, 6]

• var new_array = arr.filter(callback(element[, index[, array]])[, thisArg]) 过滤满足条件的值

callback
用来测试数组的每个元素的函数。调用时使用参数 (element, index, array)。
返回true表示保留该元素（通过测试），false则不保留。它接受三个参数：

element
当前在数组中处理的元素。

array可选
调用了filter的数组。

thisArg可选
可选。执行 callback 时的用于 this 的值。

var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

• arr.find(callback[, thisArg])返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
  callback
  在数组每一项上执行的函数，接收 3 个参数：
  element
  当前遍历到的元素。
  index
  当前遍历到的索引。
  array
  数组本身。
  thisArg 可选
  可选，指定 callback 的 this 参数。

function findCherries(fruit) { 
    return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }

类数组

相当于一个以数字为索引的对象
属性为索引
有length属性
最好有push方法

 var obj = {
  '0': 'a',
  '1': 'b',
  '2': 'c',
  "length": 3,
  "push": Array.prototype.push,  // push方法为人为添加
  "splice": Array.prototype.splice // 加了splice方法后，打印出来就和数组一样
}
// alibaba 面试题：
	var obj = {
      '2': 'a',
      '3': 'b',
      "length": 2,
      "push": Array.prototype.push
    }
    obj.push("c")
    obj.push("d")
    console.log(obj); // {'2':"c",'3':"d",'length':4}
	
	typeof (arguments) // Object  
	// 类数组也是对象  即使是数组返回也是Object