<script>
var obj = {
    yes: function(){
        // this == obj
        this.val = true;
    },
    no: function(){
        this.val = false;
    }
};
// We see that there is no val property in the 'obj' object
alert( obj.val == null );

// We run the yes function and it changes the val property
// associated with the 'obj' object
//当前Context是obj变量，所以this指向它，改变的是它的属性。
obj.yes();
alert( obj.val == true );

// However, we now point window.no to the obj.no method and run it
//Context变为window对象，改变的是它的属性
window.no = obj.no;
window.no();

// This results in the obj object staying the same (as the context was
// switched to the window object)
//所以obj的val属性是true
alert( obj.val == true );

// and window val property getting updated.
//window的val属性是false
alert( window.val == false );
</script>

<div id="main">sssssssssssssssss</div>
<script>
// A simple function that sets the color style of its context
function changeColor( color ) {
    this.style.backgroundColor = color;
}
// Calling it on the window object, which fails, since it doesn't
// have a style object
//当前是window对象，此句会失败，
changeColor( "white" );

// Find the element with an ID of main
var main = document.getElementById("main");
// Set its color to black, using the call method
// The call method sets the context with the first argument
// and passes all the other arguments as arguments to the function
//使用call方法，第一个参数设置Context
changeColor.call( main, "black" );

// A function that sets the color on  the body element
function setBodyColor() {
    // The apply method sets the context to the body element
    // with the first argument, the second argument is an array
    // of arguments that gets passed to the function
    //使用apply方法，第一个参数设置Context，第二个参数是参数数组
    changeColor.apply( document.body, arguments );
}
// Set the background color of the body to black
setBodyColor( "yellow" );
</script>

<script>
// Creates a new Object object and stores it in 'obj'
var obj = new Object();
// Set some properties of the object to different values
//设置属性
obj.val = 5;
obj.click = function(){
    alert( "hello" );
    };
// Here is some equivalent code, using the {…} shorthand
// along with key-value pairs for defining properties
//更简洁的声明方式
var obj = {
    // Set the property names and values use key/value pairs
        val: 5,
    click: function(){
        alert( "hello" );
    }
};
</script>

<script>
// A simple function which takes a name and saves 
// it to the current context
function User( name ) {
    this.name = name;
}
// Create a new instance of that function, with the specified name
var me = new User( "My Name" );
// We can see that its name has been set as a property of itself
//属性已经改变了
alert( me.name == "My Name" );
// And that it is an instance of the User object
alert( me.constructor == User );

// Now, since User() is just a function, what happens
// when we treat it as such?
User( "Test" );
// Since its 'this' context wasn't set, it defaults to the global 'window'
// object, meaning that window.name is equal to the name provided
//没有指定，则this指向了window对象。
alert( window.name == "Test" );
</script>

<script>
// Create a new, simple, User object
function User() {}
// Create a new User object
var me = new User();

// Also creates a new User object (from the
// constructor reference of  the first)
var you = new me.constructor();

// We can see that the constructors are, in fact, the same
alert( me.constructor == you.constructor );
</script>

<script>
// Create a new User constructor
function User( name, age ){
    this.name = name;
    this.age = age;
}
// Add a new function to the object prototype
//给prototype追加属性来给User追加方法。
User.prototype.getName = function(){
    return this.name;
};
// And add another function to the prototype
// Notice that the context is going to be within
// the instantiated object
User.prototype.getAge = function(){
    return this.age;
};
// Instantiate a new User object
var user = new User( "Bob", 44 );
// We can see that the two methods we attached are with the
// object, with proper contexts
alert( user.getName() == "Bob" );
alert( user.getAge() == 44 );
</script>

<script>
// An Object constructor that represents a classroom
function Classroom( students, teacher ) {
    // A private method used for displaying all the students in the class
    function disp() {
        alert( this.names.join(", ") );
    }
    // Store the class data as public object properties
    this.students = students;
    this.teacher = teacher;
    // Call the private method to display the error
    disp();
}
// Create a new classroom object
var class = new Classroom( [ "John", "Bob" ], "Mr. Smith" );
// Fails, as disp is not a public property of the object
//下面这句是错误的，不能访问disp方法。
class.disp();
</script>

<script language="javascript">
// Create a new User object constructor
function User( name, age ) {
    // Attempt to figure out the year that the user was born
    var year = (new Date()).getFullYear() – age;
    // Create a new Privileged method that has access to 
    // the year variable, but is still publically available
    this.getYearBorn = function(){
        return year;
    };
}
// Create a new instance of the user object
var user = new User( "Bob", 44 );

// Verify that the year returned is correct
alert( user.getYearBorn() == 1962 );
</script>
我运行怎么没反应？？

<script language="javascript">
/ Create a new user object that accepts an object of properties
function User( properties ) {
    // Iterate through the properties of the object, and make sure
    // that it's properly scoped (as discussed previously)
    //遍历所有，动态生成get方法和set方法。
    for ( var i in properties ) { 
        (function(){
            // Create a new getter for the property
            this[ "get" + i ] = function() {
                return properties[i];
            };
            // Create a new setter for the property
            this[ "set" + i ] = function(val) {
                properties[i] = val;
            };
        })(); 
    }
}
// Create a new user object instance and pass in an object of
// properties to seed it with
var user = new User({
    name: "Bob",
    age: 44
});
// Just note that the name property does not exist, as it's private
// within the properties object
//name属性是私有的，不能直接访问。
alert( user.name == null );

// However, we're able to access its value using the new getname()
// method, that was dynamically generated
//但是，我们可以通过get方法访问。
alert( user.getname() == "Bob" );

// Finally, we can see that it's possible to set and get the age using
// the newly generated functions
//还可以通过set方法设置值
user.setage( 22 );
alert( user.getage() == 22 );
</script>

// A static method attached to the User object
User.cloneUser = function( user ) {
    // Create, and return, a new user
    return new User(
        // that is a clone of the other user object
        user.getName(),
        user.getAge()
    );
};