A detailed explanation of built-in objects in JavaScript

const arr = ["1","2","3"]

let a,b,c

// Deconstruction and assignment// Assign the first element of the array to the first variable, assign the second element to the second variable, and so on in turn
[a,b,c] = arr
(a,b,c) // 1 2 3

// Declare variables at the same timelet [a,b,c] = ["1","2","3"]
(a,b,c) // 1 2 3

// If the number of variables is greater than the number of elements, the excess variable part is assigned to undefinedconst arr = ["1","2","3"]
let [a,b,c,d] = arr
(a,b,c,d) // 1 2 3 undefined

// Default value. If the variable declares the default value and deconstructs it to undefined, the default value will be used, otherwise the corresponding element will be used.const arr = ["1","2","3"]
let [a,b,c=10,d=11] = arr
(a,b,c,d) // 1 2 3 11

// When deconstructing an array, you can use... to get the remaining elements
const arr = ["1","2","3","4","5"]
// The first element is assigned to a, the second element is assigned to b, and the rest are assigned to clet [a,b, ...c] = arr
(a) // 1
(b) // 2
(c) // ['3','4','4']

// Deconstruct multidimensional arraysconst arr = [[1,2,3],[4,5,6]]
let [[a,b,c],obj] = arr

(a,b,c) // 1 2  3
(obj) // [4,5,6]

const user = {"name":"q",age:18}
// Declare variables and deconstruct objects at the same timelet {name,age} = user

(name,age) // q  18

// Declare the variable first, then deconstruct the objectconst user = {"name":"q",age:18}

let name,age

({name,age} = user)  // {} is a code block in js, so you need to use() outside(name,age) // q 18

const user = {"name":"q",age:18}

// If the variable name does not match the attribute name, deconstructed to undefinedlet {a,b} = user
(a,b) // undefined undefined

// You can alias the variable and then deconstruct it// You can alias the variable and set the default valuelet {name:c,age:d=20} = user

(c,d) // q  18

const user = {name:"l",age:18}

// Convert an object to a json stringconst strUser = (user)
(strUser)

// Convert a json string to a js objectconst objUser = (strUser)
(objUser)

// Use json to complete deep copy, convert the object into a string, and then convert the string into a new objectconst strUser = (user)
const objUser = (strUser)

const info = new Map()

// Set key-value pairs("name","l")
({},"a")
(NaN,"b")

(info)  // Map(3) { 'name' => 'l', {} => 'a', NaN => 'b' }

// Current map size() // 3


// Get all keys of map(())  // [Map Iterator] { 'name', {}, NaN }


// Get all the values ​​of map(()) // [Map Iterator] { 'l', 'a', 'b' }


// Check whether the map contains the specified key, including true, otherwise false((NaN)) // true

// Get the specified element through key(("name"))  // l

// Delete elements("name")
(info)  // Map(2) { {} => 'a', NaN => 'b' }

// Clear map()
(info)  // Map(0) {}

const info = new Map()

("name","l")
({},"a")
(NaN,"b")

// Use Convert map to arrayconst arr = (info)
(arr)  // [ [ 'name', 'l' ], [ {}, 'a' ], [ NaN, 'b' ] ]

const arr = [["name",1],["age",2]]

// Convert a 2D array to a mapconst map = new Map(arr)
(map) // Map(2) { 'name' => 1, 'age' => 2 }

const info = new Map()

("a",1)
("b",2)


// Method 1for (const entry of info){
    const [key,value] = entry
    (key,value)
}

for (const [key,value] of info){
    (key,value)
}

// Method 2
((key,value)=>{
    (key,value)
})

// Create a collectionconst set = new Set()


// Add data, if the element to be added already exists in the collection, it will not be added("a")
("b")


// Get the size of the collection() // 2

// Check whether the set contains the specified element, including true, otherwise false(("a")) // true


// Read the specified element - you need to convert set into an array and then read through the subscriptconst arr = [...set]
(arr[0]) // a

// Delete elements("b")

// traverse the collectionfor (const v of set){
    (v)
}

// Create a collection through an array, and based on the uniqueness of the collection elements, the array will be deduplicated based on the array's uniqueness.
const arr = [1,2,3,4,4,1,1,5]

const set =  new Set(arr)
(set) // Set(5) { 1, 2, 3, 4, 5 }

// Constant Pi()  // 3.141592653589793

// Find the absolute value of a number((-123))  // 123

// Find the minimum value among multiple values((1, 2, 3))  // 1

// Find the maximum value among multiple values((1,2,3))  // 3

// Find the power of the specified value((2,3)) // 8

// Find the square root of a number((4)) // 2

// Round down((1.5)) // 1

// Round up((1.5)) // 2

// Rounding((3.5)) // 4

// Remove decimal places((3.5)) // 3

// Generate random floating point numbers between 0~1, not including 0 and 1(()) // 0.11258771607929718

// Generate random integers between 0 and 5// Range is 0~1, *5 expands the range by 5 times 0~5. The default does not include 0 and 5, and then rounds, including 0 and 5 according to rounding((() * 5))

// Generate random numbers in any range x ~ y/*
 Random number between 1 and 6
 The range is expanded by 5 times, 0~5, and then +1 is 1~6, and the random decimals are rounded, including 1 and 6
 */
((() * 5 + 1))


// Integer between 11 and 20// [0,1] -> [0,9] -> [0+11,9+11]
// Write the part after the + sign first, 11, 20-11=9((() * 9 + 11))


// Decide whether the left and right values ​​are included according to the rules of rounding, evidence collection and other methods

// Create an object of the current timelet date = new Date()
(date) // 2024-10-30T10:48:29.454Z

// Create a specified time object - year, month (starting from subscript 0), day, hour, minute, seconds, millisecondsdate = new Date(2024,9,30,13,13,13,13)
(date) // 2020-01-01T05:13:13.000Z

// Create an object for the specified time - through the time string - year - month - day Time: minute: secondsdate = new Date("2024-10-30 12:00:00")
(date) // 2024-10-30T04:00:00.000Z

// Create an object with a specified time - by time stampdate = new Date(1730265193013)
(date) // 2024-10-30T05:13:13.013Z




// Get the year of the time object(())
// Get the month of the time object - the index of the month is returned, and the index starts from 0(())
// Get the day of the time object(())
// The day object is the week (0-6) 0 represents Sunday(())
// Return the time stamp of the current date object(())

// Return the time stamp of the current time(())

let date = new Date()


// Convert date to local time format stringlet time = ()
(time)  // 10/31/2024

// Convert time to local time format stringtime = ()
(time) // 10:32:05 AM

// Convert date and time to local time format stringtime = ()
(time) // 10/31/2024, 10:32:50 AM

// Convert date and time to specified region, format string - specified country timetime = (
    "en-US", //Specify language and country    {dateStyle: "full", timeStyle: "full"}
    // dateStyle    // timeStyle Time Style    //                                 full
    //                                 long
    //                                 medium
    //                                 short
    // hour12 Whether to use a 12-hour value    //                                 true
    //                                 false
    // Weekday weekday display    //                                 long
    //                                 short
    //                                 narrow
    //
    //                             year
    //                                 numeric
    //                                 2-digit


)
(time)

// New String() can create an object of String type// New Number() can create an object of Number type// New Boolean() can create objects of Boolean type
// Note: Never do this, the object is created in this way and cannot be compared with the original value
let str = new String("hello world")
let num = new Number(10)
let bool = new Boolean(true)
 = 100 // Set properties for num objects
(str) // [String: 'hello world']
(num) // [Number: 10]
() // 100 
(bool) // [Boolean: true]

(num === 10) // false

// Original valuelet str = "hello world"

// Adding attributes to the original value will convert the original value into a one-time temporary original value object = "11111"
// Assign and read two calls are two temporary raw value objects and cannot be read through this method() // undefined



let num = 100
// There is no method for the original value number. When calling the method, the num is temporarily converted into a number object and the toString method of the number object is called.num = ()

// The essence of a string is a character array, hello-->["h","e","l","l","l","0"]
let str = "hello"

// You can manipulate strings through some methods of manipulating arrays
// Index read characters - no negative indexing(str[0]) // h
// traverse stringsfor (let char of str){
    (char)
}
// Get the string length() // 5

// Get strings based on index, and can accept negative indexes((-1)) // o

// Index read characters - no negative indexing((0)) // h

// Used to concatenate two or more strings and return a new string((" world"," !")) // hello world !


// Check whether a string contains something, return true or false(("ll")) //Detection of all strings true(("h",2)) // Start to detect false from subscript 2
// Check the first location of the specified character(("l")) // 2

// Check the last occurrence of the specified character(("l")) // 3

// Check whether the string starts with the specified content(("he")) // true

// Check whether the string ends with the specified content(("o")) // true

// Complease the string If the length of the string is not enough to specify the length, start with the beginning and return a new string without specifying the complement character, the default is empty((7,"0")) // 00hello
// Complement the string If the length of the string is not enough to specify the length, add 0 from the end and return a new string((8,"0")) // hello000

// Replace a specified content in the string with a new string and return a new string(("l","a")) // healo


// Replace all specified content with a new string and return a new string(("l","a")) // heaao

// Slice the string, close the left and open the right((1,3)) // el

// Intercept the string, close the left and open the right((1,3)) // el

// Split a string into an array, and the parameters specify the character interval to split in which character(("")) // [ 'h', 'e', 'l', 'l', 'o' ]

// Convert string to lowercase(()) // hello

// Convert string to uppercase(()) // HELLO

// Remove the beginning and end spaces(())

// Remove the start space(())

// Remove the end space(())

// Create a regular expression object through the constructor, RegExp() receives two string parameters 1. Regular expression 2. Match pattern// The reason for string escape, please pay attention to escape when writing expressionslet regObj = new RegExp("\\w","i")


// Create a regular expression object using literals, /Expression/Match pattern// No need to consider escaping issues when creating literalslet reg = /\w/i


let reg2 = new RegExp("a")
// test method: get specified string test whether there is a part that matches the regular expression re(("abc")) // The string str expression a str contains a and returns true

// Most characters can be written directly in regular expressions// | Indicate or in regular expressions
// Is there abc or bcd stringlet re = /abc|bcd/



// [] represents character set
// Whether a string contains any letters in the character set is equivalent to a | b | cre = /[abc]/

//Arbitrary lowercase lettersre = /[a-z]/

// Any capital lettersre = /[A-Z]/

//Arbitrary upper and lower case lettersre = /[a-zA-Z]/

// Any numberre = /[0-9]/


// [^] means exclusion
// Any character other than are = /[^a]/

// . Represents any character except line breaks. If you want to match, you need to escape /\./re = /./

// Other character sets
//Arbitrary word characters [A-Za-z0-9_]re = /\w/

// Exclude word characters [^A-Za-z0-9_]re = /\W/

// Any number [0-9]re = /\d/

// Exclude numbers [^0-9]re = /\D/

// Spacere = /\s/

// Exclude spacesre = /\S/

// Word boundariesre = /\b/

// Exclude word boundariesre = /\B/

// Beginning and ending, ^ represents the beginning of the string, and $ represents the end of the string
// Match the start position are = /^a/

// Match the end position are = /a$/

// Match subtitle a, exactly match, string and regular exactlyre = /^a$/

// 3 alet re = /a{3}/

// At least 3 are = /a{3,}/

// 3~6 are = /a{3,6/

// Multi-character matching: Two matches only take effect on one character in front of the quantifier. For example, /ab{3}/, it will only detect b, not ab. If you want to detect ab, you need to use ()re = /(ab){3}/


// Any lowercase letters at the beginningre = /^[a-z]{3}/


// + means more than one, equivalent to {1,}re = /a+/

// * means any numberre = /a*/

// ? means 0-1 time, equivalent to {0,1}re = /a?/

let str = "abc123bcc456cbdd"


let re = /\d+/ig


// '123' is the result of this match. Index is the matching string. The starting index position of the string in the original input string is 3. The input is the original string. The group is the group.((str)) // [ '123', index: 3, input: 'abc123bcc456cbdd', groups: undefined ]
((str)) // [ '456', index: 9, input: 'abc123bcc456cbdd', groups: undefined ]
// Each time it is called, it will only match once, and multiple calls will match backwards one after another. For null, it means that the match is over and there is no match.((str)) // null



// Use() to group
str = "abcadcacc"

// Match a*c, use() to group the middle charactersre = /a([a-z])c/

// abc is the content matched this time, b is the content in the group((str)) // [ 'abc', 'b', index: 0, input: 'abcadcacc', groups: undefined ]

let str = "llaacqqabcccaccdd"
// A string can be split according to regular expressions
((/a[a-z]c/)) // [ 'll', 'qq', 'cc', 'dd' ]

// Replace the specified content in the string according to the regular expression((/a[a-z]c/g,"@")) // ll@qq@cc@dd


// You can search for the first time the content that conforms to the regular expression appears in the string((/a[a-z]c/)) // 2

// Match all contents in the string according to the regular expression((/a/g)) // [ 'a', 'a', 'a', 'a' ]


// Match the content in the string that meets the requirements according to the regular expression (g global matching must be set), and the return is an iterator((/a/g)) // Object [RegExp String Iterator] {}

let obj = { value: 1 };
let anotherObj = obj;  // The number of references of obj is increased to 2obj = null;            // The number of references of obj is reduced to 1anotherObj = null;     // The number of references of obj is reduced to 0 and can be recycled by the garbage collector