Introduction to object-oriented in JavaScript_js object-oriented

Object
Create
Object
Constructor
Public, private, privileged, static members
this, call and apply
Exception handling
Inherit
Prototype
Object
In JavaScript, it can be said that everything is object, so what is an object? An object is a collection of variables and functions. In other object-oriented languages, objects are instantiated from classes. JavaScript is a prototype-based object-oriented language. There is no concept of classes. Objects are derived from copies of existing objects. Objects in JavaScript can be divided into two categories: Function and Object.

Creating objects

In order to improve efficiency, JavaScript comes with built-in objects, such as Object, Function, Array, etc. All built-in objects can be created through new. Function objects are divided into two categories: instances and constructors. For example, alert('my name is X') is an instance of Function; as a constructor, Function must be instantiated through new. The syntax of the created object is divided into the following types:

Copy the code The code is as follows:

var obj= new Object();var obj={};(Array and similar)
var myFunction=new Function(){//code};function myFunction(){//code}

It should be noted that the first type of Function declaration must be before use, while the second type can be after use.

Constructor

Function is the starting point of the constructor. Creating a constructor is similar to creating an object Function above

Copy code The code is as follows:

var myFunction=new Function('a',/*code*/)
function myFunction(a){
/*Code*/
}

However, since the first one has performance issues, it is recommended to use the second one; the characteristic of the Function object is that its instances can also be used as constructors.

Static member

The following code:

Copy code Code As follows:

var myObj= new Object();
//Add name attribute
myObj.name='LD';
//Add alertName method
myObj .alertName=function(){
alert(this.name);
}
//Execute alertName
myObj.alertName();

name and alertName are just Exists in the myObj instance, not in the constructor. This is easy to understand, but it is not so easy to understand for Function that can be both a constructor and an instance, as follows:

Copy code The code is as follows:

var myConstructor=new function(){
//Add static attribute
myConstructor.name='LD';
//Add Static method
myConstructor.alertName=function(){
alert(this.nam);
}
}
myConstructor.alertName();

Code This works fine because myConstructor can be an instance, but name and alertName will not be applied to any new instance of myConstructor.

Public members

Members that can follow the instantiation of an object are called public members. To become a public member, you need to modify the prototype of the function, that is, prototype. Public methods can be inherited along with the constructor, as follows:

Copy code The code is as follows:

function myConstructor(){
}
//Add public properties
myConstructor.prototype.myName='LD';
//Instantiate
var myObj=new myConstructor();
alert(myObj.myName);

Objects instantiated by myConstructor can use myName, but myConstructor itself cannot, because we added public members to the underlying definition of myConstructor instead of the myConstructor instance itself.
Private members
Private members refer to variables and methods defined in the constructor, which are similar to private definitions in classes in other languages, for example:

Copy code The code is as follows:

function myConstructor(){
//Add private attribute
var myName='Ld'l
//Add private method
var alertName=function(){
alert('LD');
}
alertName();

Privileged members

Privileged methods refer to those that can be accessed publicly and can access private members. The method defined by this is always used in the constructor scope. Similar to public methods in other languages, as follows:

Copy code The code is as follows:

function myConstructor (){
//Private attribute
var sex='male';
// Privileged method
this.alertSex=function(){
alert(sex);
}
}

Object literal

The creation we used previously used dots, for example, myConstructor.name=x;myConstructor .sex=x. We can also use object literals to achieve the same purpose, for example:

Copy code The code is as follows:

function myConstructor(){
}
//Add public members
myConstructor.prototype={
name:'LD',
sex:'male',
method :function(){}
}

Note that the delimiter in the object literal is a comma, and the last property or method does not have a comma at the end to prevent parsing errors.
this, call and apply
this is a keyword that depends on the execution environment and has nothing to do with the creation location. The this keyword points to the object that uses the function containing it. I have learned C and other languages ​​​​to Said, this is not difficult to understand.
call and apply force the method to be attached to an object, for example:

Copy code Code As follows:

//alertName is a function that has been created
//alertName does not require parameters
alertName.call('object')
//alertName requires parameters
alertName.call('object','parameter1','parameter2')
//When alertName uses parameter array
alertName.appplay('object','parameter array arguments')

Exception handling

is similar to c#, consisting of try and catch, as follows:

Copy code The code is as follows:

function myFunction(){
window.style.color='red';
}
try {
myFunction();
}
catch{
alert('Exception message:' exception.name exception.message)
}

Inheritance and prototype There are more, I will put them in the next blog "Inheritance and Prototype in JavaScript"