Detailed explanation of object creation in JavaScript

We know that javscript is an object-oriented language, and of course it cannot do without object operations. This article explains how to create objects in javascript.

　In essence, the idea of ​​creating an object is just to create a simple entity that contains many properties and methods.
　The following is an example of an object constructor:
　function Person(name, age, colour) {
　this.name = name;
　this.age = age;
　this.colour = colour;
　}
　Then, it can be done like this Call the Person constructor:
var somebody = new Person("Patrick", 22, "red");
Or get the input value from the user: var pName = prompt("What is your name?"); var pAge = prompt("How old are you this year?");
　var pColour = prompt("What is your favorite color?");
　var somebody = new Person(pName, pAge, pColour);
　All in javascript Constructors, just like in Java, can be called using the new keyword. When a person is created (or constructed) using its attributes {"Patrick", 22, "red"}, these values ​​can be accessed, such as:
　somebody.name, or somebody["name"] "Patrick"
　somebody.age, or somebody["age"] 22
　somebody.colour, or somebody["colour"] "red"
　Because we use name to add Person attributes, they must be referenced by name , which can be seen in the code below. If we use numbers, then we must use numbers to reference, such as someone[0] instead of someone.name.
　Javascript arrays and objects (such as forms, images, frames,...) allow these two methods.
In addition, both arrays and objects have an essential attribute, which is length. When we are programming, we can use it like this: objectName.length, which returns the number of elements or attributes contained in the object.
　Attributes can also be created from functions. In this way, you only need to add one line to the Person function to create attributes:
　function Person(name, age, colour)
　{
　this.name = name;
　this. age = age;
　this.colour = colour;
　this.birthYear = (new Date()).getYear() - this.age;
　}
　The above Person function defines the fourth attribute: birthYear, which represents each A Person's year of birth. Note here that this added line calls a built-in Date constructor, which returns a Date object containing the current date and time.
　This is a very lazy way to access a Date variable. So using the following code will be more accurate and more readable:
　var today = new Date();
　this.birthYear = today.getYear() - this.age;
　 Of course, there are many ways to do this with javascript The program performs "compression". By inserting objects into your code, you can handle most variables.
　This Date object is more complex than the Person object we defined above, because it includes access methods (accessor/get) and operation methods (manipulator/set). At the same time, it is possible to add simple object methods to JavaScript. The following is a detailed example code:
　
　 By overloading the Person.toString() method for the Person object, we can use the Person object as The string is displayed. Whenever a Person object is referenced as a string, the value returned by springPerson determines what should be displayed.
The output of the above script is as follows:
Patrick was born in 76
　and is 22 years old.
　Betty was born in 77
　and is 21 years old.
　Patrick is older than Betty
　From the output results, we can see that the year is represented by two digits, such as In 1976, it was only represented by 76. So you might want to add "19" to the front of the two digits. Unfortunately, the Y2K problem makes it a little tricky to deal with. Different browsers handle the getYear() method of Date objects differently.
Year (year)
Navigator browser
IE 3.x browser
IE 4.x browser
You can find from the above table that the latest browser supports four-digit year format after 1999 (such as 2000, 2001) . Unfortunately, the way older browsers handle year formats causes endless confusion for programmers. The specific solution I often use is as follows and I would like to share it with you:
　var thisYear = (new Date()).getYear();
　thisYear = 1900 + (thisYear % 1900);
　The function of (thisYear % 1900) here is Convert the year to IE 3.x format and add 1900 to get the real year (for example, 2002 is converted to IE 3.x format with 102 via this Year%1900, then 102 plus 1900 gets 2002). The above two statements can be applied to processing from 1900 to 3799. Now it seems that such a long time is enough. However, in order to avoid problems similar to the "Y2K" problem, we should find a better solution, which is not given in this tutorial. In addition, the new ECMA standard includes a function called getFullYear(), which returns the complete year format, but this function is only supported by Navigator 4 and cannot be used in IE.
　Finally, to make some improvements to the program, we can modify the People constructor to convert the year to YYYY format. The specific code is as follows:
　this.birthYear = 1900 + (((new Date()).getYear() - this.age) % 1900);
　The ability to use objects in JavaScript is often overlooked by many programmers. But from this tutorial, you should be able to see that using objects allows programmers to design more powerful applications.

For more related articles, please pay attention to the PHP Chinese website (www.php.cn)!