What are the three types of objects in JavaScript?

Three types of objects in JavaScript: 1. Internal (set) objects, such as Array, Boolean, Data, Math, Number, Object, RegExp, String objects, etc.; 2. Host object, which executes JS scripts Objects provided by the environment; 3. Custom objects.

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer

JS three objects

In JS, objects can be divided into three types: "internal objects", "host objects" and "custom objects".

As shown in the figure:

Internal object

⑴Number object

##⑵Math: Built-in object

Math object properties

Math object method

⑶Boolean object

Boolean object attribute

Boolean object method

⑷String object

String object attribute

String Object method

⑸RegExp object

RegExp object method

Methods of String objects that support regular expressions

RegExp Object Properties

⑹Global: Built-in object

JavaScript global property

JavaScript global function

⑺Date object

Date object properties

Date object method

var today = new Date();var UTCstring = today.toUTCString();

⑻Object object

⑼Array object

⑽Function object

Various error class objects:

⑴Error

⑵EvalError

⑶RangeError

⑷ReferenceError

⑸SyntaxError

⑹TypeError

JS Host Object

⑴ Definition: The host object is to execute JS script Objects provided by the environment.

⑵ Browser object: For JS embedded in a web page, its host object is the object provided by the browser, so it is also called a browser object, such as the objects provided by browsers such as IE and Firefox.

⑶ Note: The host objects provided by different browsers may be different. Even if the objects provided are the same, their implementation methods are also very different! This will cause browser compatibility issues and increase development difficulty.

⑷ Examples of host objects: window, navigator, document, etc.

⑸ Browser extension objects: Active, XML, Debug, Script, VBArray, etc.

JS custom objects

⑴Object literal method (creating objects through JSON)

Disadvantages: Using the same interface to create many objects will generate a large number of of duplicate code.

⑵Factory mode.

①Factory pattern is to put the statement of creating an object in a function, create a specific object by passing in parameters, and finally return the created object.

The function createPerson() can construct a Person object containing all necessary information based on the parameters received.

This function can be called countless times, and each time it will return an object containing 2 properties and a method.

②Disadvantages: Although the factory pattern can create multiple similar objects, it cannot solve the problem of object identification, that is, how to know the type of an object.

⑶Constructor pattern

①Disadvantages: The main problem with using constructors is that each method must be created on each instance.

②In ECMAScript, functions are objects, so every time a function is defined, an object is instantiated.

③In other words, the methods of multiple objects instantiated through the constructor are multiple different methods, but their internal codes and implemented functions are the same, which results in a certain waste of resources. .

⑷Prototype pattern

①In js, each function has a prototype attribute, which is a pointer pointing to an object, called a prototype object.

②Using the prototype pattern allows all instances to share the properties and methods in the prototype object, that is, there is no need to define the information of the object instance in the constructor.

③Disadvantage: The link of passing initialization parameters to the constructor is omitted. As a result, all instances will obtain the same attribute value by default.

The biggest problem with the prototype pattern is caused by its shared nature. All properties in the prototype are shared by many instances

This kind of sharing is very suitable for functions. For properties containing reference types, the problem is more prominent.

④ Therefore, the prototype pattern is rarely used alone.

⑸ Use the constructor pattern and prototype pattern in combination

① Use the constructor pattern and prototype pattern in combination, which is the most common way to create a custom type.

②Constructor pattern is used to define instance properties, while prototype pattern is used to define methods and shared properties.

③ As a result, each instance will have its own copy of the instance attributes, but at the same time it will share references to methods, saving memory to the maximum extent.

⑹Other modes

①Dynamic prototype mode: Only when the constructor is called for the first time, assign the method to the corresponding attribute of the prototype object, processing of other examples The method is the same as the constructor pattern

②Parasite constructor pattern: only encapsulates the code that creates the object, and then returns the newly created object, still using the new operator to call

③Safe constructor pattern: There are no public properties, only private variables and methods, and some get/set methods to deal with private variables.

For more programming-related knowledge, please visit:Introduction to Programming! !

The above is the detailed content of What are the three types of objects in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!