JSON

JSON 格式（JavaScript Object Notation 的缩写）是一种用于数据交换的文本格式，2001年由 Douglas Crockford 提出，目的是取代繁琐笨重的 XML 格式。

JSON格式基本规则

• 并列的数据之间用逗号（", "）分隔。
• 映射用冒号（": "）表示。
• 并列数据的集合（数组）用方括号("[]")表示。
• 映射的集合（对象）用大括号（"{}"）表示

另外JSON 对值的类型和格式有严格的规定

• 复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。
• 简单类型的值只有四种：字符串、数值（必须以十进制表示）、布尔值和null（不能使用NaN, Infinity, -Infinity和undefined）。
• 字符串必须使用双引号表示，不能使用单引号。
• 对象的键名必须放在双引号里面。
• 数组或对象最后一个成员的后面，不能加逗号。

JSON两个方法

JSON.parse()
解析JSON字符串并返回对应的值，可以额外传入一个转换函数，用来将生成的值和其属性, 在返回之前进行某些修改。

JSON.stringify()
返回与指定值对应的JSON字符串，可以通过额外的参数, 控制仅包含某些属性, 或者以自定义方法来替换某些key对应的属性值

function deepCopy(obj){
      let newObj = {};
      newObj = JSON.parse(JSON.stringify(obj));
      return newObj;
    } 
//可以实现简单的深拷贝函数
//JSON.stringify方法会忽略对象的不可遍历属性，如函数、正则表达式对象、日期对象等。所以这种深拷贝方法有局限性

Array

创建数组的方法：

1. 构造函数方法

var a1 = new Array(5);
console.log(a1.length);//5
console.log(a1); //[] ,数组是空的

var a2 = new Array(5,6);
console.log(a2.length); //2
console.log(a2); //[5,6]

2. 字面量

 var b = [1, 2, 'hello'];

3. Array.apply

// 这个方法也是将一个类数组对象转为数组对象。
// 在创建 undefined 值的数组时有些奇怪和繁琐，但是结果远比 Array(3) 更准确可靠。
Array.apply(null, {length: 4}) // [undefined, undefined, undefined, undefined]

4. Array.from()

// 将类数组对象转换为数组对象
Array.from({length: 4}) // [undefined, undefined, undefined, undefined]

5. 扩展运算符

[...Array(4)] // [undefined, undefined, undefined, undefined]

一般推荐字面量、of()、from()、扩展运算符

数组的常用方法：

• push：在数组最后添加一个元素， 返回值为添加元素后的数组长度，改变当前数组

var a = [1,2,3];
a.push(4);
console.log(a);//[1,2,3,4]
console.log(a.length);//[4] 

• pop：将数组的最后一个元素拿出来，返回值为拿出元素，改变当前数组

var a = [1, 2, 3, 4];
consloe.log(a.pop());//4
console.log(a);//[1, 2, 3]
console.log(a.length);//3

• shift：将数组第一个元素拿出来，返回值为拿出元素，改变当前数组

var a = [1, 2, 3, 4];
consloe.log(a.shift());//1
console.log(a);//[ 2, 3, 4]
console.log(a.length);//3

• unshift：在数组第一位添加一个元素，返回值为添加元素后的数组长度，改变当前数组

var a = [2, 3, 4];
a.unshift(1);
console.log(a);//[ 1, 2, 3, 4]
console.log(a.length);//4

• join：将数组中的值用方法内的字符串拼接成新的字符串，返回拼接的字符串，不改变当前数组

var a = [1,2,3,4,5];
console.log(a.join(',')); //1,2,3,4,5
console.log(a.join(' ')); //1 2 3 4 5

• splice：用于一次性解决数组添加、删除（这两种方法一结合就可以达到替换效果），方法有三个参数

  1. 开始索引
  2. 删除元素的位移
  3. 插入的新元素，当然也可以写多个

  splice方法返回一个由删除元素组成的新数组，没有删除则返回空数组

var a = [1, 2, 3, 4, 5];
console.log(a.splice(1,3));//[2, 3, 4]
console.log(a.length);//2
console.log(a);//[1,5]

var a = [1,2,3,4,5];
a.splice(1,0,9,99,999);
console.log(a.length); //8
console.log(a);//[1, 9, 99, 999, 2, 3, 4, 5]
a.splice(1,3,8,88,888);
console.log(a.length);//8
console.log(a);//[1, 8, 88, 888, 2, 3, 4, 5]

• sort：用于对数组进行排序，会改变原数组。

var a=[5,4,3,2,1]
a.sort()
console.log(a) //[1, 2, 3, 4, 5]

• reverse：数组中元素的位置颠倒，并返回该数组。该方法会改变原数组。

var a = [1,2,3,4,5];
a.reverse();
console.log(a); //[5, 4, 3, 2, 1]

• concat：用于拼接数组，a.concat(b)返回一个a和b共同组成的新数组，同样不会修改任何一个原始数组，也不会递归连接数组内部数组

var a = [1,2,3,4,5];
var b = [6,7,8,9];
console.log(a.concat(b));//[1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(a); //[1, 2, 3, 4, 5]
console.log(b); //[6, 7, 8, 9]

• 用splice实现push、pop、shift、unshift

//push
function push(arr){
    for(var i=1; i<arguments.length;i++){
        arr.splice(arr.length, 0, arguments[i])
    }
    return arr.length
}
function push(arr, ...args){        //ES6扩展运算符
    arr.splice(arr.length, 0, ...args)
    return arr.length
}

//pop
function pop(arr){
    return arr.splice(arr.length-1,1);
}

//shift
function shift(arr){
    return arr.splice(0,1);
}

//unshift
function unshift(arr){
     for(var i=1; i<arguments.length;i++){
        arr.splice(0, 0, arguments[i])
    }
    return arr.length
}
function unshift(arr, ...args){        //ES6扩展运算符
    arr.splice(0, 0, ...args)
    return arr.length
}

• ES5数组方法：

  1. indexOf（项元素-必须，index-可选） （从数组开头项开始向后查找，返索引位置--number）

    var a = [1,2,3,3,2,1];
    console.log(a.indexOf(2)); //1
    console.log(a.lastIndexOf(2)); //4
  

  2. forEach（element, index, array） （遍历数组，参数为一个回调函数）

    var a = new Array(1,2,3,4,5,6);
    a.forEach(function(e,i,array){
    array[i]= e + 1;
    });
    console.log(a); //[2, 3, 4, 5, 6, 7]
  

  3. map（function(element)） （与forEach类似，遍历数组，回调函数返回值组成一个新数组返回，新数组索引结构和原数组一致，原数组不变）

    var a = new Array(1,2,3,4,5,6);
  
    console.log(a.map(function(e){
    return e * e;
    })); // [1, 4, 9, 16, 25, 36]
  
    console.log(a); //[1, 2, 3, 4, 5, 6]
  

  4. every(function(element, index, array)) （every是所有函数的每个回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false）

    var a=new Array(1,2,3,4,5,6);
  
    console.log(a.every(function(e, i, arr){
    return e < 5;
    })); //false
  
    console.log(a.some(function(e,i,arr){
    return e > 4;
  
    })); //true
  

  5. some(function(element, index, array)) （ some函数是“存在”有一个回调函数返回true的时候终止执行并返回true，否则返回false，在空数组上调用every返回true，some返回false）

  6. filter(function(element))（返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加
     新数组只包含返回true的值，索引缺失的不包括，原数组保持不变）

    var a = new Array(1,2,3,4,5,6);
  
    console.log(a.filter(function(e){
    return e % 2 == 0;
    })); // [2, 4, 6]
  
    console.log(a); //[1, 2, 3, 4, 5, 6]
  

7. reduce(function(v1, v2), value) 遍历数组，调用回调函数，将数组元素组合成一个值，reduce从索引最小值开始，reduceRight反向，方法有两个参数
   • 回调函数：把两个值合为一个，返回结果
   • value，一个初始值,可选

  var a = new Array(1,2,3,4,5,6);

  console.log(a.reduce(function(v1, v2){
  return v1 + v2;
  })); // 21

  console.log(a.reduceRight(function(v1, v2){
  return v1 - v2;
  }, 100)); // 79