Knowledge points sorting: ES6

ES6 New characteristics  

1. let Variable ,const Constant , There are block-level scopes ,let,const You cannot declare a declared variable repeatedly , No matter what declaration is used （let,const,var）,let Declared variables can be reassigned ,const Reassignment is not allowed , therefore ,let It can be declared first and then assigned , however const Must be declared and assigned . One more thing to note ：
   const What's blocked is the modification of variable binding , Instead of Prevent modification of member values .const a = 1; Right now a An error will be reported if the value is assigned again ;const person = {name:'1'},person.name='2' No mistake. , however person={name:'2'} You're going to report a mistake
2. -  Arrow function , Inside and outside the function this The direction is consistent
3. -  Template string , The quotation marks  **` **  identification , There can be spaces （let age=10;let str=` Hello , I have already ${age} Year old `）
4. -  Deconstruct assignment , Arrays can be nested , Can have null value , There can be residual operators

   let node = { type: "Identifier", name: "foo" }; 
   let { type, name } = node; 
   console.log(type); // "Identifier" 
   console.log(name); // "foo"

   let colors = [ "red", "green", "blue" ];
    let [ firstColor, secondColor ] = colors;
    console.log(firstColor); // "red" 
   console.log(secondColor); // "green"

    

5. - import Introduction and export Export of
6. - ... Unfold , You can expand the values in the array or object , You can also collect multiple values into one variable
7. - async,await Synchronous and asynchronous methods
8. - promiss grammar
9. - set Array weight removal

let arr=[12,43,23,43,68,12];
let item=[...new Set(arr)];
console.log(item);//[12,43,23,68]

special promise encapsulation axios,promise,setTimeout,fn, Macro task and micro task ,

Back to hell

First use ES6 Medium Promise, Promise , It means to promise to return data to you at a certain point in the future .

But if there's a lot of data , Multi dependent case , It will still produce the sense of seeing back to hell , Then it's used es7 Of async,await 了

promise

principle ：

• stay Promise Internal , There is a state manager , There are three states ：pending、fulfilled、rejected.　　　　
• (1) promise Object initialization state is pending.　　　　
• (2) When calling resolve( success ), Will be pending => fulfilled.　　　　
• (3) When calling reject( Failure ), Will be pending => rejected.　　
• The thing to remember is to pay attention to promsie state Only by pending => fulfilled/rejected, Once modified, it can't be changed again .

Link to the original text ：https://blog.csdn.net/HannaLh/article/details/106151149

characteristic ：

• promise It's an object , The difference between object and function is that object can save state , Function can't （ Except closures ） Once the status changes , It won't change , You can get that at any time
• The state of the object is not affected by the outside world , Only pending,fulfilled,rejected Three states
• Code style. , Easy to understand , Easy to maintain
• Multiple asynchronous wait merges for easy resolution

shortcoming ：

• Can't cancel Promise, Once it's created, it's executed immediately , Unable to cancel
• If you do not set the callback function ,Promise An error thrown internally , It doesn't react to the outside
• When in pending In the state of , It is impossible to know at what stage （ Just started or almost finished ）.

Promise There are three states ：pending/reslove/reject .pending It's just pending ,resolve It can be understood as success ,reject It can be understood as a refusal .
meanwhile Promise Three common methods

1. then Indicates that the data status after successful asynchronous execution changes to reslove
2. catch Indicates that the data status of execution after asynchronous failure changes to reject
3. all It means putting multiple unrelated Promise Encapsulate into a Promise Object use then Returns an array of data .
4. resolve Successful callback
5. reject Failed callback

Promise.all() Batch execution

Promise.all([p1, p2, p3]) Used to transfer multiple promise example , Pack into a new one Promise example , The returned instance is normal promise
It takes an array as an argument
The array can be Promise object , It could be something else , Only Promise Will wait for the state to change
When all the children Promise It's all done , The Promise complete , The return value is an array of all values
There is any failure , The Promise Failure , The return value is the first failed child Promise result

Promse.race

Promse.race That's what running means , That is to say ,Promise.race([p1, p2, p3]) Which of the results is fast , Just go back to that result , Whether the result itself is a success state or a failure state .

Promise.allSettled()

When Promise We can get each one after all the processing Promise The state of , Whether it's handled successfully or not .

Quoted above ：https://segmentfault.com/a/1190000020034361

Mr. Ruan Yifeng ：https://es6.ruanyifeng.com/#docs/promise

Event cycle mechanism ,promise Use ,