es6的核心语法

在学习低代码时，经常有粉丝会问，低代码需要什么基础，es6就是基础中的一项。我们本篇是做一个扫盲，可以让你对基础有一个概要性的了解，具体的每个知识点可以深入进行了解，再结合官方模板就会有一个不错的掌握。

1 let和const

let：声明变量，具有块级作用域。
const：声明常量，值不能改变

let x = 5;
{
  let y = 10;
}
console.log(x);  // 输出 5
console.log(y);  // 报错：y is not defined
const PI = 3.14;
PI = 3.15;  // 报错：Assignment to constant variable.
1
2
3
4
5
6
7
8

2 模板字符串

使用反引号表示，方便字符串拼接和格式化

const name = 'Alice';
const age = 25;
const message = `Hello, ${name}. You are ${age} years old.`;
console.log(message);  // 输出：Hello, Alice. You are 25 years old.
1
2
3
4

3 函数的默认值

可以为函数的参数提供默认值

function greet(name = 'Guest') {
   return `Hello, ${name}!`;
}
console.log(greet());  // 输出：Hello, Guest!
1
2
3
4

4 剩余参数

允许接收不定数量的参数

function sum(...args) {
    let sum = 0;
    for (const num of args) {
       sum += num;
    }
    return sum;
}
console.log(sum(1, 2, 3, 4, 5));  // 输出：15
1
2
3
4
5
6
7
8

5 扩展运算符

扩展运算符（spread operator）用于将一个数组或对象的所有元素或属性展开。

let arr1 = [1, 2, 3];  
let arr2 = [...arr1, 4, 5]; // [1, 2, 3, 4, 5]  
  
let obj1 = { a: 1, b: 2 };  
let obj2 = { ...obj1, c: 3 }; // { a: 1, b: 2, c: 3 }
1
2
3
4
5

6 箭头函数

箭头函数提供了一种更加简洁的函数书写方式，它没有自己的this、arguments、super或new.target。箭头函数内的this值继承自外围作用域。

let numbers = [1, 2, 3];  
numbers.forEach((num) => console.log(num)); // 输出每个数字  
  
let obj = {  
  value: 10,  
  getValue: () => console.log(this.value)  
};  
obj.getValue(); // 输出 undefined，因为箭头函数不绑定自己的this，这里的this指向全局对象
1
2
3
4
5
6
7
8

7 箭头函数的this指向

箭头函数不会创建自己的this上下文，所以this引用的是定义箭头函数时的上下文。

function Outer() {  
  this.value = 1;  
  this.inner = () => {  
    console.log(this.value); // 输出 1，这里的this指向Outer的实例  
  };  
}  
  
let outer = new Outer();  
outer.inner(); // 输出 1
1
2
3
4
5
6
7
8
9

8 解构赋值

解构赋值是一种JavaScript表达式，它可以将值从数组或对象中提取到不同的变量中。

let [a, b, ...rest] = [1, 2, 3, 4, 5]; // a = 1, b = 2, rest = [3, 4,5]
let { name, age } = { name: "Alice", age: 30 }; // name = "Alice", age = 30
1
2

9 对象字面量的属性简写

在ES6中，如果对象字面量的属性名和变量名相同，可以直接使用变量名作为属性名。

let name = "Alice";  
let age = 30;  
  
let person = {  
  name, // 等同于 name: name  
  age, // 等同于 age: age  
};  
  
console.log(person); // 输出 { name: "Alice", age: 30 }
1
2
3
4
5
6
7
8
9

10 对象字面量的方法简写

在ES6中，对象字面量中的方法可以直接使用函数名作为方法名，而不需要使用冒号和函数关键字。

let person = {  
  name: "Alice",  
  greet() {  
    console.log(`Hello, my name is ${this.name}.`);  
  }  
};  
  
person.greet(); // 输出 "Hello, my name is Alice."
1
2
3
4
5
6
7
8

11 Symbol类型

Symbol是一种新的原始数据类型，表示一个唯一的、不可变的值。

let sym1 = Symbol("key1");  
let sym2 = Symbol("key1");  
  
console.log(sym1 === sym2); // 输出 false，因为sym1和sym2是不同的Symbol值  
  
let obj = {};  
obj[sym1] = "value1";  
console.log(obj[sym2]); // 输出 undefined，因为sym1和sym2是不同的Symbol值
1
2
3
4
5
6
7
8

12 Set和Map

Set和Map是ES6中引入的两种新的集合类型。

Set是一种值的集合，它类似于数组，但成员的值都是唯一的，没有重复的值。

let set = new Set([1, 2, 2, 3, 4, 4, 5]);  
console.log(set); // Set { 1, 2, 3, 4, 5 }
1
2

Map是一种键值对的集合，任何值（对象或者基本类型）都可以作为一个键或一个值。

let map = new Map();  
map.set('key', 'value');  
console.log(map.get('key')); // 输出 "value"
1
2
3

13 数组的扩展方法

提供了许多方便的方法，如filter()、map()、reduce()等

const array = [1, 2, 3, 4, 5];
const evenNumbers = array.filter(num => num % 2 === 0);
const doubledNumbers = array.map(num => num * 2);
const sumOfNumbers = array.reduce((accumulator, current) => accumulator + current, 0);
1
2
3
4

14 迭代器

迭代器（Iterator）是一个对象，它定义了一个序列，并且有一定的访问规则。任何具有Symbol.iterator属性的对象都是可迭代的。

let arr = [1, 2, 3];  
let iterator = arr[Symbol.iterator]();  
iterator.next(); // { value: 1, done: false }
1
2
3

15 生成器

生成器（Generator）是一种特殊的迭代器，可以暂停执行和恢复执行。它使用function*语法定义，并使用yield表达式输出。

function* generator() {  
  yield 1;  
  yield 2;  
  yield 3;  
}  
  
let gen = generator();  
gen.next(); // { value: 1, done: false }  
gen.next(); // { value: 2, done: false }
1
2
3
4
5
6
7
8
9

16 Promise

Promise是处理异步操作的一种对象，它代表了可能现在、将来或永远不会完成的操作及其结果值。

let promise = new Promise((resolve, reject) => {  
  // 异步操作  
  setTimeout(() => resolve('Success!'), 1000);  
});  
  
promise.then(result => console.log(result)); // 输出 "Success!"
1
2
3
4
5
6

17 async/await

async/await是建立在Promise上，用于处理异步操作的新语法，使得异步代码看起来和同步代码一样。

async function asyncFunc() {  
  return new Promise(resolve => setTimeout(resolve, 1000, 'Async result!'));  
}  
  
async function main() {  
  let result = await asyncFunc();  
  console.log(result); // 输出 "Async result!"  
}  
main();
1
2
3
4
5
6
7
8
9

18 类

ES6引入了类的概念，用于对象的原型式继承。类提供了一种更加清晰、面向对象的方式来组织代码。

class Person {  
  constructor(name) {  
    this.name = name;  
  }  
  greet() {  
    console.log(`Hello, my name is ${this.name}.`);  
  }  
}  
  
let alice = new Person('Alice');  
alice.greet(); // 输出 "Hello, my name is Alice."
1
2
3
4
5
6
7
8
9
10
11

19 模块

ES6引入了模块的概念，允许将代码分割成独立的文件，然后在其他文件中引入使用。
moduleA.js

export function greet() {  
  console.log('Hello from module A!');  
}
1
2
3

moduleB.js

import { greet } from './moduleA.js';  
greet(); // 输出 "Hello from module A!"
1
2