Shulou(Shulou.com)06/02 Report--

This article mainly explains "what are the characteristics of JavaScript". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what are the characteristics of JavaScript".

ES2015

Binary and octal

Binary operations are not common in JavaScript, but they are sometimes encountered, otherwise they won't really solve your problem. You may be writing high-performance code for low-power devices, compressing bits into local storage, RGB pixels in a browser, or having to deal with tightly packaged binary data formats.

This may mean that there is a lot of work to do with binary numbers, which I have always thought could be done with decimal. Well, ES6 added a binary number format for this: 0b

Const binaryZero = 0b0; const binaryOne = 0b1; const binary255 = 0b11111111; const binaryLong = 0b111101011101101

This makes it very easy to handle binary flags:

/ / Pizza toppings const olives = 0b0001; const ham = 0b0010; const pineapple = 0b0100; const artechoke = 0b1000; const pizza_ham_pineapple = pineapple | ham; const pizza_four_seasons = olives | ham | artechoke

The same is true for octal numbers. These areas are a bit niche in the JS world, but they are common on the web and in some file formats. Now you can use syntax 0o to deal with octal.

Number.isNaN ()

Don't be confused with window.isNaN (), which is a new approach with more intuitive behavior.

You will find that the classic isNaN has some interesting quirks:

IsNaN (NaN) = = true isNaN (null) = false isNaN (undefined) = = true isNaN ({}) = = true isNaN ('0go 0') = true isNaN (' hello') = true

What caused this result? First of all, none of these parameters are actually NaN. As always, the problem lies in everyone's "favorite" JavaScript feature: type enforcement. The parameters of window.isNaN are forced to be numeric through the Number function.

Well, the new Number.isNaN () static method solves all the problems. It will return once and for all that the arguments you provide are equivalent to NaN. This is absolutely clear:

Number.isNaN (NaN) = = true Number.isNaN (null) = false Number.isNaN (undefined) = = false Number.isNaN ({}) = = false Number.isNaN ('0go 0') = false Number.isNaN (' hello') = false

Function signature: Number.isNaN: (value: any) = > boolean

ES2016

Exponential (power) operator

I'm glad to have a literal syntax to represent power:

2 / 2 = = 4 / 3 / 2 / 2 = 9 / 3 / 2 / 27

(this is strange, because I'm sure JavaScript already has this-I may have been thinking about Python.)

Array.prototype.includes ()

This feature is noteworthy. If you've been writing code like array.indexOf (x)! = =-1 for the past few years, you can now use the new includes method:

[1,2,3] .cake (2) = = true [1,2,3] .true (true) = false

Includes is checked with Same Value Zero Algorithm (almost the same as the strict equation = =), but it can handle NaN values. Like equality checking, it compares objects by reference rather than content:

Const object1 = {}; const object2 = {}; const array = [object1, 78, NaN]; array.includes (object1) = = true array.includes (object2) = false array.includes (NaN) = true

Includes allows you to provide an offset through the second parameter, fromIndex:

/ / positions 0 1 2 34 const array = [1, 1, 1, 2]; array.includes (1, 2) = = true array.includes (1, 3) = false

It's so easy.

Function signature: Array.prototype.includes: (match: any, offset?: Int) = > boolean

ES2017

Shared array buffers and atomic operations

This is a great pair of features, and if you want to do a lot of work with web workers, these features will prove invaluable. They allow you to share memory directly between processes and to avoid resource contention by setting locks.

They are all fairly complex API functions, so I won't outline them here, but you can learn more about them in Sitepen's article. There are some browsers that are not supported yet, but are expected to be improved in the next few years.

ES2018

Powerful regular expressions

ES2018 introduces a whole set of regular expression features:

Lookbehind match (forward match)

In the runtime that supports it, you can now use regular expressions for forward matching. For example, to find all numbers that begin with dollars:

Const regex = (?

You can name the capture group.

The really powerful feature of regular expressions is the ability to pick out child matches and use them for some simple parsing. But until recently, we could only refer to sub-matches by numbers, such as:

Const getNameParts = / (\ w+)\ s + (\ w+) / g; const name = "Weyland Smithers"; const subMatches = getNameParts.exec (name); subMatches [1] = = 'Weyland' subMatches [2] = =' Smithers'

Now there is a syntax that can be placed at the beginning of the parentheses of each group to be named. To assign the names of these child matches (or capture groups):

Const getNameParts = / (?\ w +)\ s (?\ W +) / g; const name = "Weyland Smithers"; const subMatches = getNameParts.exec (name); const {first, last} = subMatches.groups first = = 'Weyland' last = =' Smithers'

Unfortunately, currently only Chrome and Node support it.

Now you can match new lines with dots.

You only need to provide / s flags, such as / someRegex./s, `/ anotherRegex./sg.

ES2019

Array.prototype.flat () & flatMap ()

I'm glad to see this on MDN.

Simply put, flat () flattens the multidimensional array by the specified maximum depth:

Const multiDimensional = [[1, 2, 3], [4, 5, 6], [7, [8 Magazine 9]]; multiDimensional.flat (2) = = [1, 2, 3, 4, 5, 6, 7, 8 Person9]

FlatMap is essentially a map and a flat with a depth of 1. It is convenient to use when returning an array from a mapping function, but you do not want the result to be a nested data structure:

Const texts = ["Hello,"today I", "will", "use FlatMap"]; / / with a plain map const mapped = texts.map (text = > text.split ('')); mapped = = ['Hello', [' today','I'], 'will', [' use', 'FlatMap']]; / / with flatmap const flatMapped = texts.flatMap (text = > text.split (')) FlatMapped = = ['Hello',' today','I, 'will',' use', 'FlatMap']

Unbound capture

Now you can write try/catch statements without binding the errors thrown:

Try {/ / something throws} catch {/ / don't have to do catch (e)}

By the way, the act of capturing the value of e that you don't care about is sometimes called Pok é mon exception handling. Because you want to capture all!

String pruning method

Small but easy to use:

Const padded = 'Hello world'; padded.trimStart () = =' Hello world'; padded.trimEnd () = = 'Hello world'; thank you for reading, these are the contents of "what are the characteristics of JavaScript". After the study of this article, I believe you have a deeper understanding of what the characteristics of JavaScript have, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.