Data types

(1) the typeof

Used to detect the typeof a variable. Note that for null and array variables, typeof returns object

In addition, typeof returns object for almost any typeof object, meaning that typeof cannot be used to determine exactly what type an object is

let a = 0
let b = 'hello'
let c = true
let d = null
let e = undefined
let f = {}
let g = []
let h = function(){}

console.log('a: ' + typeof a)
console.log('b: ' + typeof b)
console.log('c: ' + typeof c)
console.log('d: ' + typeof d)
console.log('e: ' + typeof e)
console.log('f: ' + typeof f)
console.log('g: ' + typeof g)
console.log('h: ' + typeof h)

* a: number * b: string * C: Boolean * d: object * e: undefined * f: object * g: object * h: function **/
Copy the code

(2) the Object. The prototype. ToString. Call ()

Used to detect the typeof a variable. Typeof cannot detect null and array

let a = 0
let b = 'hello'
let c = true
let d = null
let e = undefined
let f = {}
let g = []
let h = function(){}

function typeOf(value) {
    return Object.prototype.toString.call(value).slice(8, -1)}console.log('a: ' + typeOf(a))
console.log('b: ' + typeOf(b))
console.log('c: ' + typeOf(c))
console.log('d: ' + typeOf(d))
console.log('e: ' + typeOf(e))
console.log('f: ' + typeOf(f))
console.log('g: ' + typeOf(g))
console.log('h: ' + typeOf(h))

/* * Result: * a: Number * b: String * C: Boolean * D: Null * E: Undefined * f: Object * G: Array * h: Function **/
Copy the code

(3) instanceof

It is used to determine whether an instance belongs to a certain type and can solve the problem that Typeof cannot accurately determine object types

var Message = function(descrition) { // constructor
    this.detail = descrition
}

let message = new Message('Hello')
let object = new Object(a)console.log(message instanceof Message)
console.log(message instanceof Object)
console.log(object instanceof Message)
console.log(object instanceof Object)
console.log(Message instanceof Object)

/* * Result: * true * true * false * true * true **/
Copy the code

Instanceof works by determining whether the prototype of the right object exists in the prototype chain of the left object

Once we understand how this works, we can implement an Instanceof ourselves

function myInstanceOf(left, right) {
    let lValue = left.__proto__
    let rValue = right.prototype
    while (true) {
        if (lValue === null) return false
        if (lValue === rValue) return true
        lValue = lValue.__proto__
    }
}
Copy the code

For primitive types, assignment, shallow copy, and deep copy copy the value of the old variable to the new variable

let number = 159
let string = 'hello'

let number_copy = number
let string_copy = string

number_copy = 258
string_copy = 'hi'

console.log('number: ' + number) // The value of the original variable does not change
console.log('string: ' + string) // The value of the original variable does not change
console.log('number_copy: ' + number_copy)
console.log('string_copy: ' + string_copy)

/* * Result: * number: 159 * string: hello * number_copy: 258 * string_copy: hi **/
Copy the code

For reference types:

• After the assignment, the old and new variables point to the same memory address. Changing the new variable will affect the value of the old variable

let object = { first_name: 'Steve'.last_name: 'Jobs' }
let array = [1.3.5]

let object_copy = object
let array_copy = array

object_copy['first_name'] = 'Steven'
array_copy[0] = 2

console.log('object["first_name"]: ' + object['first_name']) // The value of the original variable has changed
console.log('array[0]: ' + array[0]) // The value of the original variable has changed
console.log('object_copy["first_name"]: ' + object_copy['first_name'])
console.log('array_copy[0]: ' + array_copy[0])

/* * Result: * object["first_name"]: Steven * array[0]: 2 * object_copy["first_name"]: Steven * array_copy[0]: 2 **/
Copy the code

• A shallow copy of a new variable assigns the first layer of data from the old variable to the new variable

// Common shallow copy methods for objects are object.assign
// Common shallow copy methods for arrays are array. from, slice, concat

let object = {
    name: {
        first_name: 'Steve'.last_name: 'Jobs'
    },
    age: 18
}
let array = [[1.3].5.7]

let object_shallow_copy = Object.assign({}, object)
let array_shallow_copy = Array.from(array)

object_shallow_copy['name'] ['first_name'] = 'Steven'
object_shallow_copy['age'] = 20
array_shallow_copy[0] [0] = 2
array_shallow_copy[2] = 11

console.log('object["name"]["first_name"]: ' + object['name'] ['first_name'])
console.log('object["age"]: ' + object['age'])
console.log('array[0][0]: ' + array[0] [0])
console.log('array[2]: ' + array[2])

console.log('object_shallow_copy["name"]["first_name"]: ' + object_shallow_copy['name'] ['first_name'])
console.log('object_shallow_copy["age"]: ' + object_shallow_copy['age'])
console.log('array_shallow_copy[0][0]: ' + array_shallow_copy[0] [0])
console.log('array_shallow_copy[2]: ' + array_shallow_copy[2])

/ execution results: * * * object (" name "] [" first_name "] : Steven * object [] "age" : 18 * array [0] [0] : 2 * array [2] : 7 * object_shallow_copy["name"]["first_name"]: Steven * object_shallow_copy["age"]: 20 * array_shallow_copy[0][0]: 2 * array_shallow_copy[2]: 11 **/
Copy the code

Implement a shallow copy function yourself:

function shallowCopy(object) {
    if (typeofobject ! = ='object') return
    let newObject = object instanceof Array ? [] : {}
    for (let key in object) {
        if (object.hasOwnProperty(key)) {
            newObject[key] = object[key]
        }
    }
    return newObject
}
Copy the code

• All data of the old variable (no matter how deeply nested) is copied to the new variable. The old and new variables do not affect each other

Parse (json.stringify ())) is the easiest way to do this, but it has some drawbacks
// If the attribute has undefined, NaN, Infinity, function, then it will be converted to null
// If there are RegExp or Error objects in the property, they will be converted to empty objects

let object = {
    name: {
        first_name: 'Steve'.last_name: 'Jobs'
    },
    age: 18
}
let array = [[1.3].5.7]

let object_deep_copy = JSON.parse(JSON.stringify(object))
let array_deep_copy = JSON.parse(JSON.stringify(array))

object_deep_copy['name'] ['first_name'] = 'Steven'
object_deep_copy['age'] = 20
array_deep_copy[0] [0] = 2
array_deep_copy[2] = 11

console.log('object["name"]["first_name"]: ' + object['name'] ['first_name'])
console.log('object["age"]: ' + object['age'])
console.log('array[0][0]: ' + array[0] [0])
console.log('array[2]: ' + array[2])

console.log('object_deep_copy["name"]["first_name"]: ' + object_deep_copy['name'] ['first_name'])
console.log('object_deep_copy["age"]: ' + object_deep_copy['age'])
console.log('array_deep_copy[0][0]: ' + array_deep_copy[0] [0])
console.log('array_deep_copy[2]: ' + array_deep_copy[2])

/ execution results: * * * object (" name "] [" first_name "] : Steve * object [] "age" : 18 * array [0] [0] : 1 * array [2] : 7 * object_deep_copy["name"]["first_name"]: Steven * object_deep_copy["age"]: 20 * array_deep_copy[0][0]: 2 * array_deep_copy[2]: 11 **/
Copy the code

Implement a deep-copy function yourself:

Note that this simple implementation still has some drawbacks

function deepCopy(object) {
    if (typeofobject ! = ='object') return
    let newObject = object instanceof Array ? [] : {}
    for (let key in object) {
        if (object.hasOwnProperty(key)) {
            let item = object[key]
            newObject[key] = typeof item === 'object' ? deepCopy(item) : item
        }
    }
    return newObject
}
Copy the code