Summary of the most commonly used knowledge points about ES6 new features

1. Keywords

The Let keyword takes effect within the code block in which the let keyword appears. Before let, the variable cannot be assigned a value.

The Const keyword is a read-only variable, so it needs to be assigned a value when it is defined.

2. Deconstruction

Destructuring of variables,

1>. The array structure uses [] to assign values ​​to the local part of the array.

For example:

Let [a,,c]=[1,,3]

Let[a,…c] Here c can be assigned as an array

2>.Object structure uses {} to deconstruct the object, which is similar to array. The difference is that there is one more attribute problem. The most important thing is that the object attributes have no order, but come in sequence.

3. Strings

1>. Use for of to traverse each character of the string.

2>. To determine whether it contains characters: include startswith endwith

3>. Padstart. . . Wait for the function to replace the completion

4>. String template, you can add variables in the string using ${variable}. You can also add html tags

5>. Most of the values ​​are for function execution, determining whether it is a number, type conversion, etc.

4. Regularization

1>. Two usages

One: Regex r = new Regex ('matching rule', 'modification')

Two: Regex r=/matching things/modification

Regex where I gy is a modifier

2>.Does the sticky property have a modifier?

Flags returns the match modifiers

3>. Support for post-assertions

5. Arrays

1>. You can use const […a2]=a1 to assign values ​​directly, and you can also swap two variables.

2>. Use [] to merge multiple arrays

3>. Combined with deconstruction

For example:

[a,…rest]=list list is an array

6. Functions

1>. The use of parameter default values ​​cannot have parameters with the same name

2>. Parameter value passing is lazy evaluation, that is, the default value will be recalculated each time

3>. You can still use deconstruction for function assignment (I think it is similar to object deconstruction)

7. Object

Objects in es6 use a similar type to the original struct in C, but the difference is that methods can be used inside objects in es6

For example:

Const person = {

  Name: wl;

Birth,

CalTime(){console.log("");}

8.Symbol

1>. It is equivalent to an extra definition keyword to prevent the defined variables from being accidentally rewritten and overwritten.

2>. The main function is to eliminate magic strings (personal understanding: a bunch of strings come out directly, change them into variables to improve code readability)

9. gather

1>. Personal understanding: It is somewhat similar to the collections in Java and C#. It’s just that due to the characteristics of es6, there are some different functions to implement complex operations. Set can be converted into an array and perform some deconstruction operations.

There is an additional collection with the prefix weak (this is a temporary storage place for things, which will disappear in an instant, so it cannot be traversed)

10.Proxy with Reflect's Observer Mode

Proxy is an interception operation, and Reflect is a reflection operation, which reads variables for modification.

Proxy monitors changes, intercepts operations, reflects changes in values, and implements the simplest observation mode

11. Promise

It is a constructor that can call back two functions. (Personal understanding: It is more useful for situations with two results, and different functions are called for different situations)

ArrayBuffer is also a constructor that uses a variety of functions to operate. I personally feel that it is for the purpose of standardizing arrays.

12. Traverser

The traversal simulates next and moves the pointer until the end. What is different from the C and C++ languages ​​I used before is that es6 will output undefined at the end instead of crashing the program directly.

  next: function() {

         return nextIndex < array.length ?

        {value: array[nextIndex++], done: false} :

        {value: undefined, done: true}; //Continuously increase nextIndex, which means the subscript is incremented.

13.Generator

The essence is to record the internal state of the function and operate asynchronously. I personally feel that it should be used more in multi-threading. Single threading does not take into account the value of the application. In essence, yield is used to suspend the operation. You can use * to turn the function into a suspended function without yield.

14.async

Essentially, it is an improved operation of Generator. Instead of using yield to suspend the operation, it uses await to perform the operation. But it is different from Generator in that it returns different things. Generator returns a traversal object, while it returns a Promise object.

15.Class

For the original js language, the class operation encapsulates many things and has certain templates. In order to facilitate reading and comprehension, inheritance also reduces the writing of repeated code. And the mode is strict mode, which is more standardized for the language. It is somewhat similar to the class in object-oriented languages.

16. Modifiers

This writing method is similar to Java annotations, but the approach is different. Personally, I understand that Java annotations are for code regulation and easy modification. But in es6, the essence of the modifier is the function executed at compile time.

17.Moudle

Modularize some statically compiled things to reduce repeated writing, just like Python introduces multiple libraries. If something is introduced into some libraries, the writing will be relatively uncomplicated.

  import { stat, exists, readFile } from 'fs'; // import export { firstName, lastName, year }; // output

Summarize

This concludes this article on the most commonly used knowledge points of ES6 new features. For more relevant ES6 new features knowledge points, please search 123WORDPRESS.COM's previous articles or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!