ES6 - numerical extension and object extension

Number

（1）Number.EPSILON Indicates the minimum accuracy ,2.2204.......

            console.log(0.1 + 0.2 === 0.3) // false

            function equal(a, b) {
                if (Math.abs(a - b) < Number.EPSILON) {
                    return true
                }
                return false
            }

            console.log(equal(0.1 + 0.2, 0.3)) // true

notes ：

JavaScript There are no integers at all at the bottom of the language , All numbers are decimal （64 Bit floating point ）, When calculating integers, you can implement, for example ,console.log(3/1) // 3, But the floating-point calculation is wrong console.log(0.3 / 0.1) //2.9999999999999996, When decimal precision is greater than 53 Or the data length is greater than 53 When a , The data may be incorrect .

JavaScript Floating point number comparison problem _ Lord squirrel's blog -CSDN Blog _js Floating point comparison

（2）Number.isFinite() Determine whether a number is finite

            console.log(Number.isFinite(0.3 / 0.1)) // true
            console.log(Number.isFinite(0.3)) // true
            console.log(Number.isFinite(100 / 0)) // false
            console.log(Number.isFinite(Infinity)) // false

（3）Number.isNaN  Check whether a value is NaN

（4）Number.parseInt()  Number.parseFloat() Will automatically intercept the number at the beginning of the given string

            console.log(Number.parseInt('521hhh')) // 521
            console.log(Number.parseFloat('0.521hhh')) // 0.521

（5）Number.isInteger（） Judge whether a number is an integer , Only values can be judged

            console.log(Number.parseInt('521hhh')) // 521
            console.log(Number.parseFloat('0.521hhh')) // 0.521

（6）Math.trunc（） Erase the decimal of a number

console.log(Math.trunc(5.21)) //5

（7）Math.sign（） Judge whether a number is negative 、 Positive numbers 、0

object

(1)Object.is()  Determine whether the two values are exactly equal

            console.log(Object.is(120, 121)) // false
            console.log(Object.is(120, 120)) // true
            console.log(Object.is(NaN, NaN)) // true
            console.log(NaN === NaN) // false

Object.is() Used to determine whether two values are the same , There are several cases where the two values are the same ：

1. All are  undefined

2. All are  null

3. All are  true  or  false

4. Are two strings of the same length , And the characters corresponding to each serial number are the same

5. The same two objects （ Two objects have the same reference address ）

6. Two identical numbers ：

   • All are  +0

   • All are  -0

   • All are  NaN

   • Are not 0 It's not NaN, And it's worth the same

　　Object.is And  == Operators get different results .== The values on both sides of the symbol are cast before comparison （ When they are of different types ）.

　　Object.is And  === The result of the operator is also different .- 0 === + 0  yes  true, and Number.NaN === NaN  yes  false.

Determine if the two values are the same ——Object.is( ) - Let's have a look

（2） Object to merge   --  The combination of configuration files is very useful

            const CONFIG1 = {
                host: '127.0.0.1',
                port: '3306',
	            active:true
            }
            const CONFIG2 = {
                host: '192.168.8.102',
                port: '3309',
                passeord: '123456',
                username: 'hhh'
            }

            console.log(Object.assign(CONFIG1, CONFIG2))

（3） Set prototype object

What is a prototype

Every JavaScript object （null With the exception of ） Another object will be associated during creation , This object is what we call prototype , Every object inherits properties from the prototype .  Ruan Yifeng javascript_JavaScript The core concept - Prototype 、 Prototype chain _weixin_39998541 The blog of -CSDN Blog

Fast grasp JS Interview questions 『 Prototypes and prototype chains 』_ Bili, Bili _bilibili

  Implicit prototype --  By default, the object will have a __proto__, Point to the prototype of the class when the object is created ; The class itself has prototype, When you can't find a way , Will look up , That is, find in the prototype

  Prototype chain   --  Layer by layer inheritance , Prototypes form chains

teachet.hasOwnProperty（） //  The inspection method is own , Or the prototype  

instanceof()  When referencing a type , Can't use typeof See what the object is , Such as arrays and Object, Use instanceof It's viewable ,instanceof What you are looking at is that all on the prototype chain are true, If it doesn't exist in the prototype chain , All are false

Obeject.setPrototypeOf(school,cities) //  Support all , That is, support objects , Also supports arrays , Theoretically, reference types can be used .

notes ： It is not recommended to set the prototype later