Statements about object-oriented programming now have the strength to learn the following about object-oriented programming, but they actually belong to the content of the previous chapter. The with statement specifies the default object for one or more statements.
Usage:
With ( <对象> ) <语句> ;
The with statement is usually used to shorten the amount of code that must be written in a specific situation. In the following example, pay attention to the reuse of Math:
X = Math. cos (3 * Math. PI) + Math. sin (Math. LN10 );
Y = Math. tan (14 * Math. E );
When the with statement is used, the Code becomes shorter and easier to read:
The Code is as follows:
With (Math ){
X = cos (3 * PI) + sin (LN10 );
Y = tan (14 * E );
}
This object returns the "current" object. In different places, this indicates different objects. If this is used in the JavaScript "main program" (not in any function, not in any event handler), it represents the window object; if this is used in the with statement block, it indicates the object specified by with. If this is used in the event handler, it indicates the object where an event occurs.
A common usage of this:
The Code is as follows:
Script
...
Function check (formObj ){
...
}
...
Script
...
...
This method is often used to immediately check the validity of form input.
We already know the User-Defined constructor. The constructor such as Array () and Image () allows us to construct a variable. In fact, we can also write our own constructor. User-Defined constructors also use functions. This is used in the function to define attributes.
The Code is as follows:
Function <构造函数名> [( <参数> )] {
...
This. <属性名> = <初始值> ;
...
}
Then, use the new constructor keyword to construct the variable:
Var <变量名> = New <构造函数名> [( <参数> )];
After the variable is constructed, <变量名> To be an object, it has its own attributes-attributes set in the function using this.
The following is an example of a custom constructor that collects browser details from the Internet:
The Code is as follows:
Function Is (){
Var agent = navigator. userAgent. toLowerCase ();
This. major = parseInt (navigator. appVersion); // main version
This. minor = parseFloat (navigator. appVersion); // full version
This. ns = (agent. indexOf ('mozilla ')! =-1 )&&
(Agent. indexOf ('spoofer ') =-1) & // whether it is Netscape
(Agent. indexOf ('compuble ') =-1 )));
This. ns= (this. ns & (this. major = 3); // whether Netscape 2
This. ns3 = (this. ns & (this. major = 3); // whether Netscape 3
This. ns4b = (this. ns & (this. minor <4.04); // check if the version is earlier than Netscape 4.
This. ns4 = (this. ns & (this. major> = 4); // whether it is a high version of Netscape 4
This. ie = (agent. indexOf ("msie ")! =-1); // whether it is IE
This. ie3 = (this. ie & (this. major = 2); // whether it is IE 3
This. ie4 = (this. ie & (this. major> = 4); // whether it is IE 4
This. op3 = (agent. indexOf ("opera ")! =-1); // whether it is Opera 3
This. win = (agent. indexOf ("win ")! =-1); // whether the Windows version is used
This. mac = (agent. indexOf ("mac ")! =-1); // indicates whether the Macintosh version is used.
This. unix = (agent. indexOf ("x11 ")! =-1); // whether the Unix version is used
}
Var is = new Is ();
This constructor collects browser information very completely. We can see that it defines many attributes for the object: major, minor, ns, ie, win, mac, and so on. Their meanings can be found in the preceding annotations. After defining the is variable as the Is () object, you can easily know the browser information in the format of if (is. ns. We can also see from this constructor that it can also use general JavaScript statements (var statements in the above example ).
Let's look at a constructor using parameters:
The Code is as follows:
Function myFriend (theName, gender, theAge, birthOn, theJob ){
This. name = theName;
This. isMale = (gender. toLowerCase = 'male ');
This. age = theAge;
This. birthday = new Date (birthOn );
This. job = theJob
}
Var Stephen = new myFriend ('Stephen ', 'male', 18, 'dec 22,198 2', 'student ');
From this constructor, we can not only see the usage of parameters, but also see that different attributes can be used with different data types (in the preceding example, the five attributes are: String, Boolean, number, date, string), you can also see the constructor can also be used to "construct" attributes. If enough "protection measures" are used to avoid infinite loops, you can also use constructors to construct your own attributes.
