JSON.stringify
我们平时经常会用到 JSON 对象，比如当我们要实现对象的深拷贝时，我们可以用 JSON 对象的 JSON.stringify和 JSON.parse 来拷贝一个完全一样的对象，而不会对原对象产生任何引用关系。在使用 localStorage 时，也会用到它，因为 localStorage 只能存储字符串格式的内容，所以，我们在存之前，将数值转换成 JSON字符串，取出来用的时候，再转成对象或数组。
对于 JSON.stringify 方法，它可以帮我们把一个对象或数组转换成一个 JSON字符串。我们通常只会用到它的第一个参数，其实它还有另外两个参数，可以让它实现一些非常好用的功能。
语法：
JSON.stringify(value[, replacer [, space]])
过程解析：
value：将要被序列化的变量的值
replacer：替代器。可以是函数或者是数组，如果是一个函数，则 value 每个属性都要经过这个函数的处理，该函数的返回值就是最后被序列化后的值。如果是一个数组，则要求该数组的元素是字符串，且这些元素会被当做 value 的键（key）进行匹配，最后序列化的结果，是只包含该数组每个元素为 key 的值。
space：指定输出数值的代码缩进，美化格式之用，可以是数字或者字符串。如果是数字（最大为10）的话，代表每行代码的缩进是多少个空格。如果是字符串的话，该字符串（最多前十个字符）将作显示在每行代码之前。
ps: JSON.stringify 来做序列化时的过滤，相当于我们可以自定义 JSON.stringify的解析逻辑
2
用 Set 来实现数组去重
Set 和 ...（拓展运算符）可以很简单的进行数组去重
const removeDuplicateItems = arr => [...new Set(arr)];
removeDuplicateItems([42, 'foo', 42, 'foo', true, true]);
//=> [42, "foo", true]
3
用块级作用域避免命名冲突
在开发的过程中，通常会遇到命名冲突的问题，就是需要根据场景不同来定义不同的值来赋值给同一个变量。下面介绍一个使用 ES6 中的 块级作用域 来解决这个问题的方法。
比如，在使用 switch case 时，我们可以这样做
switch (record.type) {
case 'added': {
const li = document.createElement('li');
li.textContent = record.name;
li.id = record.id;
fragment.appendChild(li);
break;
}
case 'modified': {
const li = document.getElementById(record.id);
li.textContent = record.name;
break;
}
}
函数参数值校验
我们知道，在 ES6 中，为函数增加了参数默认值的特性，可以为参数设定一些默认值，可以让代码更简洁，可维护。
其实，我们可以通过这个特性来做函数参数值的校验。
首先，函数的参数可以是任意类型的值，也可以是函数，比如下面这个：
function fix(a = getA()) {
console.log('a', a)
}
function getA() {
console.log('get a')
return 2
}
fix(1);
// a 1
fix();
// get a
// a 2
这时候，我们可以利用这一特性，为参数 a 添加一个必传的校验，代码如下：
function fix(a = require()) {
console.log('a', a)
}
function require() {
throw new Error('缺少了参数 a')
}
fix(1);
// a 1
fix();
// Uncaught Error: 缺少了参数 a
用解构赋值过滤对象属性
在前面我们介绍了使用 JSON.stringify 来过滤对象的属性的方法。这里，我们介绍另外一种使用 ES6 中的 解构赋值 和 拓展运算符 的特性来过滤属性的方法。
// 我们想过滤掉对象 types 中的 inner 和 outer 属性
const { inner, outer, ...restProps } = {
inner: 'This is inner',
outer: 'This is outer',
v1: '1',
v2: '2',
v4: '3'
};
console.log(restProps);
// {v1: "1", v2: "2", v4: "3"}
用解构赋值获取嵌套对象的属性
解构赋值 的特性很强大，它可以帮我们从一堆嵌套很深的对象属性中，很方便地拿到我们想要的那一个。比如下面这段代码：
// 通过解构赋值获取嵌套对象的值
const car = {
model: 'bmw 2018',
engine: {
v6: true,
turbo: true,
vin: 12345
}
};
// 这里使用 ES6 中的简单写法，使用 { vin } 替代 { vin: vin }
const modalAndVIN = ({ model, engine: { vin }}) => {
console.log(`model: ${model}, vin: ${vin}`);
}
modalAndVIN(car);
// "model: bmw 2018, vin: 12345"
/ 通过解构赋值获取嵌套对象的值
const car = {
model: 'bmw 2018',
engine: {
v6: true,
turbo: true,
vin: 12345
}
};
// 这里使用 ES6 中的简单写法，使用 { vin } 替代 { vin: vin }
const modalAndVIN = ({ model, engine: { vin }}) => {
console.log(`model: ${model}, vin: ${vin}`);
}
modalAndVIN(car);
// "model: bmw 2018, vin: 12345"
合并对象
ES6 中新增的 拓展运算符，可以用来解构数组，也可以用来解构对象，它可以将对象中的所有属性展开。
// 使用拓展运算符合并对象，在后面的属性会重写前面相同属性的值
const obj1 = { a: 1, b: 2, c: 3 };
const obj2 = { c: 5, d: 9 };
const merged = { ...obj1, ...obj2 };
console.log(merged);
// {a: 1, b: 2, c: 5, d: 9}
const obj3 = { a: 1, b: 2 };
const obj4 = { c: 3, d: { e: 4, ...obj3 } };
console.log(obj4);
// {c: 3, d: {a: 1, b: 2, e: 4} }
使用 === 代替 ==
在 JavaScript 中，=== 和 == 是有很大的不同的，== 会将两边的变量进行转义，然后将转义后的值进行比较，而 === 是严格比较，要求两边的变量不仅值要相同，它们自身的类型也要相同。
JavaScript 经常被调侃成一个神奇的语言，就是因为它的转义的特性，而用 == 可能会引入一些深埋的bug。远离 bug，还是要用 ===：
ES6 中提供了一个新的方法：Object.is()，它具有 === 的一些特点，而且更好、更准确，在一些特殊场景下变现的更好：
来源 摘自： https://juejin.im/entry/5b7d68b6e51d4538b35c016d?utm_source=gold_browser_extension
总结javaScript https://juejin.im/post/5b7e1f81f265da436a075db4?utm_source=gold_browser_extension
//对列实现
//定义队列functionQueue(){this.dataStore = [];this.enqueue = enqueue;//入队this.dequeue = dequeue;//出队this.front = front;//查看队首元素this.back = back;//查看队尾元素this.toString = toString;//显示队列所有元素this.clear = clear;//清空当前队列this.empty = empty;//判断当前队列是否为空}
js的算法与数据结构 https://juejin.im/entry/59eb3405f265da43231a1e2d
1.排序算法（Sort）
2.选择排序（SelctionSort）
3.插入排序（insertionSort）
4.希尔排序（Shell Sort）
5.归并排序（Merge Sort）
6.快速排序（Quicksort）
5.1 数组新方法
Array.from(); //将类数组转化成数组
Array.of(); //创建数组
Array.fill();//填充数组
Array.reduce();//传入回调适合处理 临近数组元素
Array.filter();//数组过滤
Array.find();//查找返回值
Array.includes();//判断数组是否有某值
作者：Meteor
链接：https://juejin.im/post/5abf531d6fb9a028dc412419
React不可变属性
this.props是一个不可变对象
React具有浓重的函数式编程的思想。
提到函数式编程就要提一个概念：纯函数。
纯函数有几个特点：
给定相同的输入，总是返回相同的输出。
过程没有副作用。
不依赖外部状态。
functiondoSomething(a, b){
return a + b;
}
值之间的传递
父组件给子组件传值
最直观传达方式
import Reactfrom'react';
import Childfrom'./Child';
constApp =()=>{return();}export default App;
子组件给父组件传值
其实就是利用回调函数的参数传递值。
父组件定义一个方法，将该方法通过props传给子组件，子组件需要给父组件传值时，便传参执行该方法。由于方法定义在父组件里，父组件可以接收到该值。
import React, { Component } from 'react';
import Child from './Child';class App extends Component { state = { value: '' };
render() { return ( );
}
handleSomething = (e) => {
this.setState({ value: e.target.value });
}
}
export default App;
//
import
Reactfrom'react';
constChild =(props) =>{
return();}export default Child;
兄弟组件之间传值
推荐 属性之间的值传递：https://juejin.im/post/5b7c359f6fb9a019c372c8ab#heading-3
可变状态
可以有不是状态的状态
如果你需要存储某种状态，但是不希望在状态更新的时候触发render生命周期钩子，那么完全可以直接存储到实例的属性上，只要不是this.state的属性。使用起来还是很自由的。
setState is currently synchronous outside of event handlers. That will likely change in the future.
可变状态的参考链接 https://juejin.im/post/5b7ae2c351882542f82454b2