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:
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
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:
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:
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:
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:
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:
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:
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:
//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:
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"
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
