查看数据类型

值类型(基本数据类型)：字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol。
引用数据类型：对象(Object)、数组(Array)、函数(Function)。

1、typeof--基本数据类型

JavaScript 有六种原始（不可变）数据类型：Boolean、Null、Undefined、Number、String 和 Symbol（ES6 中新增的），和一种可变的数据类型：Object。注意：在 JavaScript 中，数组在本质上是一种对象。

typeof '3' // string
typeof 3 // number
typeof(true) // boolean
// 
typeof(Null) // undefined
typeof(undefined) // undefined
typeof(Symbol) // function

2、instanceof -- 引用数据类型

const a = []
a instanceof Array // true
const b = {}
b instanceof Object // true
function c() {}
c instanceof Function // true

3、Object.prototype.toString.call() -- 通用

const a = []
Object.prototype.toString.call(a) // '[object Array]'

1、合并数组

    let arr1 = [1]
    const arr2 = [2]
    arr1 = arr1.concat(arr2) // (2) [1, 2] ES5
    arr1 = [...arr1, ...arr2] // (2) [1, 2] ES6

2、数组去重

注释：俩种方法实现的效果是一样的

    let arr1 = [1, 1, 2]
    // 第一种
    const set = [...new Set(arr1)] // [1, 2]
    // 第二种
    // const set = Array.from(new Set(arr1)) // [1, 2]
    console.log(set);

3、消除字符串空格

注释：trim()，trimStart()，str.trimEnd()

    let str = '   asd    '
    str = str.trim()
    str = str.trimStart()
    str = str.trimEnd()
    console.log(str);

4、replace替换

    const str = 'aabcd'
    // console.log(str.replace('a', '')); // 'abcd' 单个
    // console.log(str.replace(/a/g, '')); // 'bcd' 多个
    console.log(str.replaceAll('a', '')); // 'bcd'  多个

5、数值(俩位小数四舍五入/保留原本俩位)

1、parseInt

    console.log(parseInt(1234512)); // 1234512
    console.log(parseInt(12345.12)); // 12345

2、俩位小数

参考文章：www.cnblogs.com/le220/p/975…

    // 四舍五入 toFixed(2) Math.round
    console.log(12345.126.toFixed(2)); // 12345.13 string
    console.log(Math.round(12345.126 * 100) / 100); // 12345.13
    // 最后一位为0
    console.log(12345.10.toFixed(2)); // 12345.10
    console.log(Math.round(12345.10 * 100) / 100); // 12345.1
    // 位数不够
    console.log(12345.1.toFixed(2)); // 12345.10
    console.log(Math.round(12345.1 * 100) / 100); // 12345.1
    // toFixed(2)

    // 没有四舍五入 Math.floor 正则
    console.log(Math.floor(12345.126 * 100) / 100); // 12345.12 number
    console.log(Number(12345.126.toString().match(/^\d+(?:\.\d{0,2})?/))); // 12345.12 number
    // 最后一位为0
    console.log(Math.floor(12345.10 * 100) / 100); // 12345.1 
    console.log(Number(12345.10.toString().match(/^\d+(?:\.\d{0,2})?/))); // 12345.1 
    // 位数不够
    console.log(Math.floor(12345.1 * 100) / 100); // 12345.1 
    console.log(Number(12345.1.toString().match(/^\d+(?:\.\d{0,2})?/))); // 12345.1 
    // Math.floor

    // 俩位小数，不够补0
    function toDecimal2(x) {
        const num = Math.floor(x * 100) / 100
        let num1 = num.toString();
        let num2 = num1.indexOf(".")
        if (num2 < 0) {
            num2 = num1.length;
            num1 += '.';
        }
        while (num1.length <= num2 + 2) {
            num1 += '0';
        }
        console.log(num1);
    }
    toDecimal2(12345) // 12345.00
    toDecimal2(12345.1) // 12345.10

6、es5对象转数组（不常用）

注释：Array方法：Array.of(1) [1]

    const obj = {
        0: 0,
        1: 1,
        2: 2,
        length: 3
    };
    var arr1 = [].slice.call(obj) // [0, 1, 2] es5
    console.log(arr1);
    let arr2 = Array.from(obj); // [0, 1, 2] es6
    console.log(arr2);

7、对象合并，浅拷贝

    const obj = {
        a: 1
    }
    const objb = {
        b: 2
    }
    const objc = {
        c: 3
    }

    // 对象合并
    const objAll = Object.assign(obj, objb, objc) // {a: 1, b: 2, c: 3}
    // 浅拷贝
    const obj1 = Object.assign(obj) // {a: 1}

8、对象原型

参考文章：www.jianshu.com/p/ddaa5179c…

注释：对象原型：prototype，隐式原型：proto
每一个函数都有一个属性——prototype
每一个对象都有一个隐藏属性__proto__

    function person() { } // 构造函数
    const p1 = new person() // 实例化

9、proxy

注释：Proxy用于修改某些操作的默认行为，proxy在目标对象的外层搭建了一层拦截，外界对目标对象的某些操作，必须通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。

var proxy = new Proxy(target, handler)

new proxy()表示生成一个Proxy实例，target参数表示所要拦截的目标对象，handler参数也是一个对象，用来定制拦截行为。

10、sort排序

注释：sort() 方法用于对数组的元素进行排序，并返回数组。默认排序顺序是根据字符串UniCode码。因为排序是按照字符串UniCode码的顺序进行排序的，所以首先应该把数组元素都转化成字符串（如有必要），以便进行比较。

1、数值排序--正常（按照升序排序）

        const arr = [5, 2, 3, 4, 1];
        console.log(arr.sort(), "arr.sort()"); // [1, 2, 3, 4, 5]

2、字符串排序--按照字母顺序排序

        const arr = ["523", "22", "3", "4", "1"];
        console.log(arr.sort(), "arr.sort()"); // ['1', '22', '3', '4', '523']

3、升序、降序

如果要得到自己想要的结果，不管是升序还是降序，就需要提供比较函数了。该函数比较两个值的大小，然后返回一个用于说明这两个值的相对顺序的数字。
比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，即 a - b 小于零，则返回一个小于零的值，数组将按照升序排列。
若 a 等于 b，则返回 0。
若 a 大于 b, 即 a - b 大于零，则返回一个大于零的值，数组将按照降序排列 3.1 简单sort比较


        // a-b -- 升序 b - a -- 降序
        const arr = ["523", "22", "3", "4", "1"];
        const result = arr.sort((a, b) => {
          return a - b;
        });
        console.log(result, "arr.sort()"); // ['1', '3', '4', '22', '523']

3.2 sort比较函数


        // property -- 需要根据什么排序 -- id   
        // a、b 是数组里面的每一个对象，进行遍历比较
        // a[property] === id
        function compare(property) {
          return function (a, b) {
            var value1 = a[property];
            var value2 = b[property];
            return value1 - value2;
          };
        }
        
       // arr--数组，根据id排序
       arr.sort(compare("id")

3.3 比较例子

property -- 需要根据什么排序 -- id
a、b 是数组里面的每一个对象，进行遍历比较
a[property] === id（11）

        const arr = [
          { id: "11", name: "浪味仙-1" },
          { id: "22", name: "浪味仙-2" },
          { id: "51", name: "浪味仙-3" },
          { id: "21", name: "浪味仙-4" },
          { id: "52", name: "浪味仙-5" },
        ];
        // eslint-disable-next-line no-inner-declarations
        function compare(property) {
          return function (a, b) {
            var value1 = a[property];
            var value2 = b[property];
            return value1 - value2;
          };
        }
        const result = arr.sort(compare("id"));
        console.log(result, "arr.sort()");

11、数组倒序

1、reserve数组倒序

    const arr = ['1', '2', '3', '4', '5']
    const result = arr.reverse()
    console.log('result', result); // ['5', '4', '3', '2', '1']

2、for循环遍历（arr[i]从5开始赋值，5,4,3,2,1）

    let arr = ['1', '2', '3', '4', '5']
    let result;
    for (let i = 0; i < arr.length / 2; i++) {
        result = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = result;
    }
    console.log('result', arr); // ['5', '4', '3', '2', '1']

12、字符串倒序

1、split -- 将字符串分割数组 2、reserve -- 倒序函数 3、join -- 数字转为字符串

    let str = "abc"
    let result = str.split("").reverse().join("")
    console.log(result, 'result'); // cba

13、通过索引修改数组中的数据

与字符串不同，数组的条目是可变的并且可以自由更改，即使数组是用 const 声明的。

const ourArray = [50, 40, 30];
ourArray[0] = 15;
// ourArray = [15, 40, 30]

const定义的数据可以push

const myArray = [["John", 23], ["cat", 2]];
myArray.push(["dog", 3])
console.log(myArray) // [ [ 'John', 23 ], [ 'cat', 2 ], [ 'dog', 3 ] ]

14、使用 pop() 操作数组

.pop() 函数用来弹出一个数组末尾的值

const myArray = [["John", 23], ["cat", 2]];
let removedFromMyArray = myArray.pop()
console.log(removedFromMyArray) // [ 'cat', 2 ]
console.log(myArray) // [ [ 'John', 23 ] ]

15、使用 shift() 操作数组

.shift() 函数用来移除的是第一个元素

const myArray = [["John", 23], ["dog", 3]];
const removedFromMyArray  = myArray.shift()
console.log(removedFromMyArray) // [ 'John', 23 ]
console.log(myArray) // [ [ 'dog', 3 ] ]

16、使用 unshift() 操作数组

unshift() 在数组的头部添加元素。

const myArray = [["John", 23], ["dog", 3]];
myArray.shift();
myArray.unshift(["Paul", 35])
console.log(myArray) // [ [ 'Paul', 35 ], [ 'dog', 3 ] ]

17、局部函数作用域

function myLocalScope() {
  // 只修改这一行下面的代码
  let myVar = 10
  console.log('inside myLocalScope', myVar); // inside myLocalScope 10
}
myLocalScope();
console.log('outside myLocalScope', myVar); // ReferenceError: myVar is not defined

18、局部变量将会优先于全局变量

一个程序中有可能具有相同名称的局部变量和全局变量。在这种情况下，局部变量将会优先于全局变量。

const outerWear = "T-Shirt";

function myOutfit() {
  // 只修改这一行下面的代码
  const outerWear = 'sweater'
  // 只修改这一行上面的代码
  console.log(outerWear) // sweater
  return outerWear;
}

myOutfit();
console.log(outerWear) // T-Shirt

19、= --- 赋值含义

等号右侧的所有操作都会在赋值之前完成，右边可以调用函数，计算表达式。

20、==和===区别

==：相等运算符，在 JavaScript 中，为了让两个不同的数据类型（例如 numbers 和 strings）的值可以作比较，它必须把一种类型转换为另一种类型。这叫作 “类型强制转换”。

3 == '3'
// 返回true

===：严格相等运算符与相等操作符转换数据两类型不同，严格相等运算符不会做类型转换。

3 === '3'
// 返回false

21、!=和!==

!=:不等运算符,不相等运算符在比较的时候也会转换值的数据类型。

// 设置
3 !=  3 // false
3 != '3' // false

!==:严格不等运算符,严格不相等运算符不会转换值的数据类型。

3 !==  3 // false
3 !== '3' // true

22、>=和<=和<

">=:大于或等于运算符,与相等运算符相似，大于等于运算符在比较的时候会转换值的数据类型。"
<=:大于或等于运算符,与相等运算符相似，小于等于运算符在比较的时候会转换值的数据类型。
<:小于运算符,与相等运算符类似，小于运算符在做比较的时候会转换值的数据类型。
">:大于运算符,与相等运算符类似，大于运算符在做比较的时候会转换值的数据类型。"

23、使用 Switch 语句从许多选项中进行选择

如果你有非常多的选项需要选择，可以使用 switch 语句。 switch 评估一个表达式，将表达式的值与 case 子句匹配。从第一个匹配的 case 值执行语句，直到遇到 break。
测试 case 值使用严格相等（===）运算符进行比较。 break 告诉 JavaScript 停止执行 switch 语句。如果遗漏了 break ，下一个语句将会被执行。
在 switch 语句中，你可能无法用 case 枚举出所有可能的值。相反，你可以添加 default 语句，它会在找不到相匹配的 case 语句之后执行。你可以把它看作是 if/else 链中最后的那个 else 语句。

function caseInSwitch(val) {
  let answer = "";
  // 只修改这一行下面的代码
  switch(val) {
    case 1:
    answer = "alpha";
    break;
    case 2:
    answer = "beta";
    break;
    case 3:
    answer = "gamma";
    break;
    case 4:
    answer = "delta";
    break;
    default:
    answer = 'stuff'
    break;
  }


  // 只修改这一行上面的代码
  return answer;
}

caseInSwitch(1); // alpha
caseInSwitch(a); // stuff

24、在 Switch 语句添加多个相同选项

如果你忘了给 switch 的每一条 case 添加 break，那么后续的 case 会一直执行，直到遇见 break 为止。如果你想为 switch 中的多个不同的输入设置相同的结果，可以这样写：

function sequentialSizes(val) {
  let answer = "";
  // 只修改这一行下面的代码
  switch(val) {
    case 1:
    case 2:
    case 3:
    answer = 'Low';
    break;
    case 4:
    case 5:
    case 6:
    answer = 'Mid';
    break;
    case 7:
    case 8:
    case 9:
    answer = 'High';
    break;
  }


  // 只修改这一行上面的代码
  return answer;
}

sequentialSizes(1); // 1,2,3都是Low

25、函数执行到 return 语句就结束

当代码执行到 return 语句时，函数返回一个结果就结束运行了，return 后面的语句不会执行。

26、创建 JavaScript 对象

对象和 arrays 类似，区别在于数组使用索引来访问和修改数据，而对象中的数据是通过 properties 访问的。
对象非常适合用来存储结构化数据，可以表示真实世界中的物体，比如一只猫。

27、通过点号和[]表示法访问对象属性

[] 取对象值

// 设置
const testObj = {
  "an entree": "hamburger",
  "my side": "veggies",
  "the drink": "water"
};

// 只修改这一行下面的代码
const entreeValue = testObj["an entree"];   // hamburger
const drinkValue = testObj["the drink"];    // water

28、删除对象属性(delete)

const myDog = {
  "name": "Happy Coder",
  "legs": 4,
  "tails": 1,
  "friends": ["freeCodeCamp Campers"],
  "bark": "woof"
};

// 只修改这一行下面的代码
delete myDog.name
console.log(myDog)

29、测试检查对象的属性`.hasOwnProperty()`或`in`

有时检查一个对象属性是否存在是非常有用的。我们可以用对象的 .hasOwnProperty(propname) 方法来检查对象是否有指定的属性。 .hasOwnProperty() 找到该属性时返回 true，找不到该属性时返回 false。
动态返回对象里面的属性值得时候，使用[]取值

const myObj = {
  top: "hat",
  bottom: "pants"
};

myObj.hasOwnProperty("top"); // true
myObj.hasOwnProperty("middle"); // false
'top' in myObj // true
'Hello' in myObj // false

30、数组循环嵌套取值

function multiplyAll(arr) {
  let product = 1;
  // 只修改这一行下面的代码
  for(let i = 0;i < arr.length; i++) {
    for(let j = 0;j < arr[i].length; j++) {
      product *= arr[i][j]
    }
  }
  // 只修改这一行上面的代码
  return product; // 乘绩
}

multiplyAll([[1, 2], [3, 4], [5, 6, 7]]);

31、do...while 循环

它被称为 do...while 循环，是因为不论什么情况，它都会首先 do（运行）循环里的第一部分代码，然后 while（当）规定的条件被评估为 true（真）的时候，它会继续运行循环。

do {
  i++;
} while (i < 5) {};

32、使用递归代替循环

写一个递归函数，sum(arr, n)，返回递归调用数组 arr 从前 n 个元素和。

function sum(arr, n) {
  // 只修改这一行下面的代码
  if(n <= 0) {
    return 0;
  } else {
    return sum(arr, n - 1) + arr[n - 1]
  }
  // 只修改这一行上面的代码
}

33、随机数

1、随机小数Math.random()

在 JavaScript 中，可以用 Math.random() 生成一个在0（包括 0）到 1（不包括 1）之间的随机小数。因此 Math.random() 可能返回 0，但绝不会返回 1。

2、随机整数Math.floor(Math.random() * 10)

生成随机小数很棒，但随机数更有用的地方在于生成随机整数。
1. 用 Math.random() 生成一个随机小数。
1. 把这个随机小数乘以 10。
1. 用 Math.floor() 向下取整，获得它最近的整数。
记住 Math.random() 永远不会返回 1。同时因为我们是在向下取整，所以最终我们获得的结果不可能有 20。这确保了我们获得了一个在 0 到 9 之间的整数。

const num = Math.floor(Math.random() * 10)

3、生成某个范围内的随机整数

// 生成0-10的整数
function randomRange(myMin, myMax) {
  // 只修改这一行下面的代码
  const num = Math.floor(Math.random() * (myMax - myMin + 1) + myMin)
  return num;
  // 只修改这一行上面的代码
}
randomRange(0,10)

34、使用`[]`分割字符串

1、查找字符串中的第n个字符

const lastName = "Lovelace";
firstLetterOfLastName = lastName[0]; // L

2、查找字符串中的倒数第n个字符

const firstName = "Ada";
const lastLetter = firstName[firstName.length - 1]; // a

35、计算数组最大值

var arr = [6, 89, 3, 45];
var maximus = Math.max.apply(null, arr); // 89

36、数组的every() some() find()

every() 一假都假

    const arr = [1, 2, 3]
    const result = arr.every(num => {
      return num > 0 // true
      return num > 2 //  false
    })

some() 一真都真

    const arr = [1, 2, 3]
    const result = arr.some(num => {
      return num > 2 // true
      return num > 3 //  false
    })

find() 该方法主要应用于查找第一个符合条件的数组元素

    const arr = [1, 2, 3]
    const result = arr.find(num => {
      return num > 1 // 2
    })

37、数组循环`in` `of`

in：key值，下标值

      const arr = ["小绿", "小黄", "小紫"];
      for (let i in arr) {
        console.log(i); // 0,1,2
      }

of：键值，数组里面的值，如果数组里面是对象，循环出来即是对象

      const arr = ["小绿", "小黄", "小紫"];
      for (let i of arr) {
        console.log(i); // 小绿,小黄,小紫
      }
// 对象循环
      const arr = [{ name: 1 }, { name: 2 }];
      for (let i of arr) {
        console.log(i); // { name: 1 },{ name: 2 }
      }

38、对象遍历`for...in` `Object.keys()` `Object.values()`

for...in：遍历

    const obj = {
      name: '小绿',
      name1: '小黄',
      name2: '小紫'
    }
    for (let i in obj) {
      console.log(i); // name,name1,name2
      console.log(obj[i]); // 小绿,小黄,小紫
    }

Object.keys()

    const obj = {
      name: '小绿',
      name1: '小黄',
      name2: '小紫'
    }
    console.log(Object.keys(obj)); // ['name', 'name1', 'name2']
    Object.keys(obj).forEach(key => {
      console.log(obj[key]); // 小绿,小黄,小紫
    })

Object.values()

    const obj = {
      name: '小绿',
      name1: '小黄',
      name2: '小紫'
    }
    console.log(Object.values(obj)); // ['小绿', '小黄', '小紫']

39、反转字符串

const str = 'abc'
str.split('').reverse().join(''); // cba

40、判断开始`startsWith()`和结尾的字符串`endsWith()`

判断开始的字符串,string.startsWith(searchvalue, start)
必需，要查找的字符串。
start,可选，查找的开始位置，默认为 0.

'abc'.startsWith('a',0) // true
'abc'.startsWith('a',0) // true
'abc'.startsWith('a',1) // false

判断结束的字符串，string.endsWith(searchvalue, length)
设置字符串的长度。默认值为原始字符串长度 string.length。

'abc'.endsWith('bc',3) // true

41、重复输出字符串`repeat()`

可以使用循环，+=，函数等方式

function repeatStringNumTimes(str, num) {
  if(num < 1) {
    return ''
  } else {
    return str += repeatStringNumTimes(str, num - 1)
  }
}

repeatStringNumTimes("abc", 3);

repeat()方法

let str = 'abc'
str.repeat(2) // 'abcabc'

42、字符串首字母`charAt()`

const str = 'abc'
str.charAt() // a
str.charAt(str.length - 1) // c

43、字母大小写转换方法，大小`toLowerCase()`，小大`toUpperCase`

44、数组插入数组`splice()`

    let arr = [1, 2]
    let arr1 = [4, 5]
    arr.splice(1, 0, ...arr1) // [1, 4, 5, 2]

45、JavaScript 中的假值有`false`、`null`、`0`、`""`、`undefined`、`NaN`

数组中移除所有假值提示：可以考虑将每个值都转换为布尔值（boolean）

// 通过if的判断条件是否true，false判断
function bouncer(arr) { 
    let newArray = []; 
    for (let i = 0; i < arr.length; i++) { 
        if (arr[i]) {
        newArray.push(arr[i])
        }; 
    } 
    return newArray;
}

function bouncer(arr) {
  return arr.filter(Boolean);
}

bouncer([false, null, 0, NaN, undefined, ""]); // []

46、定义构造函数

构造函数函数名的首字母大写，这是为了方便我们区分构造函数（ constructors）和其他非构造函数。
构造函数使用 this 关键字来给它将创建的这个对象设置新的属性。在构造函数里面，this 指向的就是它新创建的这个对象。
注意： 构造函数内的 this 总是指被创建的对象。
构造函数定义了属性和行为就可创建对象，而不是像其他函数一样需要设置返回值。
注意：通过构造函数创建对象的时候要使用 new 操作符。因为只有这样，JavaScript 才知道要给 Bird 这个构造函数创建一个新的实例：blueBird。如果不使用 new 操作符来新建对象，那么构造函数里面的 this 就无法指向新创建的这个对象实例，从而产生不可预见的错误。
凡是通过构造函数创建出的新对象，这个对象都叫做这个构造函数的 instance。

function Dog(name,color) {
  this.name= name
  this.color= color
  this.numLegs= 0
}
const hound = new Dog('小绿','red')
hound instaceof Dog; // true

47、

ES6

1、防止对象改变`Object.freeze`

    let obj = {
      name: "小黄",
      review: "小绿"
    };
    Object.freeze(obj);
    obj.review = "小坏";
    obj.newProp = "小牛";
    console.log(obj); // {name: '小黄', review: '小绿'}

2、rest 操作符(扩展运算操作符)...

数字相加

const sum = (...args) => {
  return args.reduce((a, b) => a + b, 0);
}
sum(1,2,3,4) // 10
sum() // 0

...arr 返回一个解压的数组。也就是说，它展开数组。然而，展开操作符只能够在函数的参数中或者数组中使用。下面的代码将会报错：

和上面的35对比

const arr = [6, 89, 3, 45];
const maximus = Math.max(...arr);

3、解构赋值

对象结构赋值
基本用法

const HIGH_TEMPERATURES = {
  yesterday: 75,
  today: 77,
  tomorrow: 80
};

const {today} = HIGH_TEMPERATURES; // 77
const {tomorrow} = HIGH_TEMPERATURES; // 80

替换名字

const HIGH_TEMPERATURES = {
  yesterday: 75,
  today: 77,
  tomorrow: 80
};

const { today: highToday } = HIGH_TEMPERATURES; // highToday=77，无today
const { tomorrow: highTomorrow } = HIGH_TEMPERATURES;  // highTomorrow = 80

嵌套解构赋值将两个赋值语句替换成等价的解构赋值。 lowToday 和 highToday 应该为 LOCAL_FORECAST 中 today.low 和 today.high 的值。

const LOCAL_FORECAST = {
  yesterday: { low: 61, high: 75 },
  today: { low: 64, high: 77 },
  tomorrow: { low: 68, high: 80 }
};

const {today:{ low:lowToday }} = LOCAL_FORECAST;
const {today: { high:highToday }} = LOCAL_FORECAST;

数组解构赋值
基本使用

const [a, b,,, c] = [1, 2, 3, 4, 5, 6];
console.log(a, b, c); // 1,2,5

删除几项

const source = [1,2,3,4,5,6,7,8,9,10];
const [ a, b, ...arr] = list;
// 定义arr = [3,4,5,6,7,8,9,10]

4、使用模板字面量``

const a = 666;
`${a}`

5、使用 class 语法定义构造函数

class Vegetable {
  constructor(Vegetable) {
    return Vegetable = {
      name : Vegetable
    }
  }
}

const carrot = new Vegetable('carrot');
console.log(carrot.name); // 'carrot'

6、export default使用

export default 用于为模块或文件声明一个返回值，在每个文件或者模块中应当只默认导出一个值。此外，你不能将 export default 与 var、let 或 const 同时使用。 default 导入的时候，自己可以起任何名字

import subtract from './math_functions.js'

7、创建一个promise对象

const makeServerRequest = new Promise((resolve, reject) => {
  // responseFromServer 设置为 false，表示从服务器获得无效响应
  let responseFromServer = false;

  if(responseFromServer) {
    resolve("We got the data");
  } else {  
    reject("Data not received");
  }
});

makeServerRequest.then(result => {
  console.log(result);
}).catch(error => {
  console.log(error)
});

8、数字的几次幂

Math.pow(b, e);
Math.pow(2, 3); // 2的3次幂

9、使用splice添加元素

修改原本的数组

1：索引，第一个元素，从0开始
2：删除几个元素
3：需要添加的元素

const arr = [0,1,2]
arr.splice(1,1,'添加') // 删除的元素，1
arr // [0, '添加', 2]

10、使用 slice() 复制数组元素(也可以叫做提取)

function forecast(arr) {
  // 只修改这一行下面的代码
  arr = arr.slice(2,4)
  return arr;
}

// 只修改这一行上面的代码
console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool' ])); // [ 'warm', 'sunny' ]

11、展开运算符 ---- `...`

合并数组

const arr = [1,2]
const arr1 = [0,...arr,3,4] // [0,1,2,3,4]

JS基础