ES6基础

一、定义变量
let 定义变量，不存在变量提升，暂时性死区（当前作用域下不允许同名的变量，不允许重复声明）

//全局作用域
let a = 1;
//函数作用域
function foo(){
  let a = 2;
  console.log(2);
}
function test(){
  console.log(a);//如果全局定义了，值为1；如果全局没有定义，报错
  if(false){
    //当代码被执行的时候才会去定义
    let a = 2;
  }
}
test();

ES5：全局作用域、函数作用域
ES6：块作用域是伴随let

{
  //ES6 新增的代码块，这里就是快作用域
  let a = 2;
}

const 常量
和let基本一致，不允许被重复赋值，但是数组与对象可以被修改

const arr = [];//数组类型
arr.push(1);
arr.pop();
const obj = {
  a : 1
};
obj.b = 2;
console.log(obj);

二、数组的拓展
拓展运算符...
即解构，解构是一个浅拷贝而不是深拷贝，把数组转化成以逗号形式分隔的参数序列

console.log(...[1,2,3]);//ES5 callback.apply
console.log(1,2,3);
let arr1 = ["a", "b", "c"],
    arr2 = ["d", "e", "f",{
      a : 1,
      b : 2
    }];
//函数传参数
function foo(a,b,c){
  console.log(a,b,c);
}
foo(...arr1);
foo("a","b","c");
//数组合并
arr2.push(...arr1);
console.log(arr2);
let arr3 = [...arr1,...arr2];
arr3[6].c = 3;
console.log(arr2,arr3);
//字符串、数组、布尔类型、null、undefined：创建副本
//对象就是一个引用 object{}、array[]、function(){}
let obj1 = {
  a : 1,
  b : 2,
  c : 3
};
let obj2 = obj1;  //这里就是引用，浅拷贝只是引用

字符串拆分数组

let txt = [..."hello"];
console.log(txt);
foo([..."hello"]);
function foo(arr){
  console.log(arr);
}

Array.find 查找

let arrTest = [..."hello", "wo", "rd"];
let findData = arrTest.find(function(item){
  //console.log(item);
  //当return ture 就停止
  //返回满足条件的当前元素，只要条件满足就停止循环，并且把当前项返回，找不到就返回undefined
  return item.length > 1 || item == "o";
});
console.log(arrTest, findData);

Array.findIndex 查找

let arrTest = [..."hello", "wo", "rd"];
let findIndex = arrTest.findIndex((item) => {//箭头函数
  return item.length > 1 || item == "o";
});
console.log(arrTest, findIndex);

Array.of()、new Array(10).fill(0)、Array.from(box)

let newArr = new Array(10);//有歧义，会定义一个有10个空位的数组
let newArr1 = Array.of(1,2,3);
let newArr2 = Array.of(1);
console.log(newArr, newArr1, newArr2);
let arrFill = new Array(10).fill(0);//将10个空位都填充为0;
let arrFill1 = new Array(10).fill(6,1,9);//将[1,9)空位填充为10
console.log(arrFill, arrFill1);
let box = document.querySelectorAll("div");//将类数组转化为数组
console.log(Array.from(box));

三、对象的拓展

//定义对象
let obj = {
  //中括号里面的脚本会被先执行，返回的结果就是属性名
  [attrGet()] : 1,
  [1+2] : 2,
  ["a" + "b"] : 3
  //对象中方法的定义
  foo(){
    console.log(this);
  }
};
function attrGet(){
  return "hello";
}
obj.foo();
console.log(obj);

//判断
console.log(Object.is(NaN,NaN));
console.log(Object.is(-0,0));

assign对象合并

//浅拷贝
let obj1 = {
  a : 1,
  b : 2,
  c : 3
};
let obj2 = {
  d : 4
};
Object.assign(obj2, obj1,{
  e : 4,
  f : 6
},{
  f : "我把6覆盖了"
});
console.log(obj2);

function ClassA(a, b){
  //相当于this.a = a;this.b = b
  Object.assign(this, {a,b});
}
console.log(new ClassA(1,2));

let obj = {a:1, b:2};
//相当于定义了变量a还有变量b
let {a,b,c} = obj;
console.log(a,b,c);//找不到就是undefined

ES6基础

推荐阅读更多精彩内容