Basic reference types of JavaScript advanced programming

Preface:

Reference values ​​(objects) are instance objects of a specific reference type, such as Date type, Function type, RegExp regular expression type, and so on. JavaScript has some built-in common reference types for developers to use.

1. Date

The following three methods return timestamps in milliseconds.

let t1 = Date.UTC(2020, 11, 7, 22,14)
let t2 = Date.parse("5/23/2020")
let t3 = Date.now()

The parameter format received by parse can be:

Date() constructor can accept a variety of parameters. It can accept no parameters, a timestamp, or the parameters accepted by UTC function and the parse function.

let t4 = new Date()
let t5 = new Date(2020, 11, 7) // Month starts at 0 let t6 = new Date("5/23/2020")

The Date type provides equivalent functions, you can refer to the relevant API yourself.

2. RegExp

In JavaScript , regular expressions are expressed as follows

let express = /pattern/flags;

• g: Global mode, which means searching the entire content of the string instead of ending at the first matching content.
• i : Case-insensitive, meaning that the case of pattern and string is ignored when searching for matches.
• m: Multi-line mode, which means that the search will continue when the end of a line of text is reached.
• u : Unicode mode, enables Unicode matching.
• s : dotAll mode, indicating that the metacharacter . matches any character (including \n or \r).

In addition to expressing regular expressions in literal form, you can also create them using the RegExp constructor.

let p1 = /[cb]at/i

let p2 = new RegExp("[cb]at", "i")

The two are equivalent.

The RegExp object has two important methods, namely exec and test methods.

let p1 = /[cb]at/i
let text = "hello cat bat nihao"

matches = p1.exec(text)

console.log(matches.index)
console.log(matches.input)
console.log(matches[0]) //cat

If the regular expression matches, the returned matches is an Array array object, if it does not match, it returns null. In addition, matches has two additional attributes index and input . index is the actual position of the match. input is the string to be searched. The elements in the array are actually the capture groups in the regular expression. If there is no grouping, the 0th element is the matching string.

let p1 = /([cb]a(t))/i
console.log(matches[0]) //cat
console.log(matches[1]) //cat
console.log(matches[2]) //t

The test method returns a Boolean value that determines whether the string matches the regular expression.

let matched = /\d+/g.test("13")
console.log(matched) //true

Here we need to explain the function of the g in flag . It seems useless now, but you can understand it by looking at the following example

let p1 = /[cb]at/gi
let text = "hello cat bat nihao"
console.log(p1.exec(text)) // ["cat", index: 6, input: "hello cat bat nihao", groups: undefined]
console.log(p1.exec(text)) //["bat", index: 10, input: "hello cat bat nihao", groups: undefined]

In the string text, there are actually two places that match the regular expression, but when we call exec , the element in matches array is cat, not bat. When I execute exec for the second time, what is returned is bat. If there is no g, cat will be returned no matter how many times it is called. The process ends when the first match is found.

In addition, strings provide many methods that accept regular expressions as parameters, which can be used for regular expression matching, string replacement, searching for specified strings, or grouping.

3. Original packaging type

The three reference types Boolean , Number , and String are the wrapper types corresponding to the primitive types. When certain methods are used on the primitive values, the primitive values ​​will be automatically wrapped into the corresponding reference types. For example, the methods provided by the string above are not available in the original value, but String type does. This mechanism allows primitive values ​​to have the behavior of objects.

The original packaging type has the following characteristics, which can be noted:

let s1 = "hello"
s1.name = "sex"
console.log(s1.name) //undefined

Why is s1.name undefined ? When the second line of code is executed, s1 will be converted to a packaging type. When this line of code is executed, the object of this type is actually recycled. Then in the third line, another wrapper type object is created, but this time there is no name attribute, so it is undefined . Unless a String object is created explicitly.

let s1 = "hello"
s1 = new String(s1)
s1.name = "sex"
console.log(s1.name) 

For Number , the difference between using new and not using new

let value = 25
let number = Number(value)
obj = new Number(value)

console.log(typeof number) //number
console.log(typeof obj) //object

console.log(number instanceof Number) //false The original value is not an instance object of any type console.log(obj instanceof Number) //true

number is a primitive value, obj is an object of type Number .

Number object has a toFxied method that is used to format the value as a string, which is used to retain the specified decimal places.

let num = 10.007
console.log(num.toFixed(2)) //10.01  

For String, a lot of methods for operating strings are provided, and you can type them all manually according to the examples.

4. Other built-in objects

Variables under the global scope, some commonly used individual functions such as evel , parseInt , isNaN , and constructors of primitive reference types String , Boolean , Number Function , and Array are all Global properties. But we can't access Global object explicitly. In addition, encodeURI and encodeURIComponent are very useful in processing URLs.

url = "http://www.baidu.com/vue.js"
console.log(encodeURI(url)) //http://www.baidu.com/vue.%20js
console.log(encodeURIComponent(url)) // http%3A%2F%2Fwww.baidu.com%2Fvue.%20js

The corresponding decoding functions are decodeURI and decodeURIComponent .

In the browser, window object acts as a proxy object for Global, and variables in the global scope can be accessed through window object.

var name = "zhang"
console.log(window.name)
Math objectconsole.log(Math.max(1,2,3,4)) // maximum valueconsole.log(Math.min(3,3,4)) // minimum valueconsole.log(Math.ceil("1.2")) // round upconsole.log(Math.floor(3.3)) // round downconsole.log(Math.round(3.6)) // round up

This is the end of this article about basic reference types in JavaScript advanced programming. For more relevant content about basic reference types in JavaScript, please search previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!