function SuperType() {
    this.property = true;
}

SuperType.prototype.getSuperValue = function() {
    return this.property;
}

function SubType() {
    this.subproperty = false;
}

// 这里是关键，创建SuperType的实例，并将该实例赋值给SubType.prototype
SubType.prototype = new SuperType(); 

SubType.prototype.getSubValue = function() {
    return this.subproperty;
}

var instance = new SubType();
console.log(instance.getSuperValue()); // true

var SingletonTester = (function () {

    // 参数：传递给单例的一个参数集合
    function Singleton(args) {

        // 设置args变量为接收的参数或者为空（如果没有提供的话）
        // 只有在使用的时候才初始化
        var args = args || {};
        // 设置name参数
        this.name = 'SingletonTester';
        // 设置pointX的值
        this.pointX = args.pointX || 6; // 从接收的参数里获取，或者设置为默认值
        // 设置pointY的值
        this.pointY = args.pointY || 10;

    }

    // 实例容器
    var instance;

    var _static = {
        name: 'SingletonTester',

        // 获取实例的方法
        // 返回Singleton的实例
        getInstance: function (args) {
            if (instance === undefined) {
                instance = new Singleton(args);
            }
            return instance;
        }
    };
    return _static;
})();

var singletonTest = SingletonTester.getInstance({ pointX: 5 });
console.log(singletonTest.pointX); // 输出 5

// 非常简单的mixin(..)例子：
function mixin( sourceObj, targetObj ) {
    for(var key in sourceObj) {
        // 只会在不存在的情况下复制
        if(!(key in targetObj)) {
            targetObj[key] = sourceObj[key];
        }
    }
    return targetObj;
}

var Vehicle = {
    engines: 1,
    
    ignition: function() {
        console.log( "Turning on my engine." );
    },
    
    drive: function() {
        this.ignition();
        console.log( "Steering and moving forward!" );
    }
};

var Car = mixin( Vehicle, {
    wheels: 4,
    
    drive: function() {
        Vehicle.drive.call( this ); // 显示多态(伪多态)调用，因为Vehicle和Car中都有drive
        console.log(
        	"Rolling on all" + this.wheels + "wheels!"
        );
    }
} );

// 使用this，提供一种优雅的方式隐式“传递”一个对象引用。API设计更加简洁并且易于复用。
function identify() {
    return this.name.toUpperCase();
}

function speak() {
    var greeting = "Hello, I'm " + identify.call( this );
    console.log( greeting );
}

var me = {
    name: "Kyle"
};

var you = {
    name: "Reader"
};

identify.call( me ); // KYLE
identify.call( you ); // READER

speak.call( me ); // Hello, I'm KYLE
speak.call( you ); // Hello, I'm READER

// -----------------------------------------------
// 词法作用域方案，显式传递上下文对象方式，会让代码变得越来越混乱
function identify(context) {
    return context.name.toUpperCase();
}

function speak(context) {
    var greeting = "Hello, I'm " + identify( context );
    console.log( greeting );
}

identify( you ); // READER
speak.call( me ); // Hello, I'm KYLE

function foo() {
    var a = 2;
    
    function bar() {
		console.log( a );
    }
    
    return bar;
}

var baz = foo();

baz(); // 2 ---- 这就是闭包的效果

// 对函数类型的值进行传递
function foo() {
    var a = 2;
    
    function baz() {
		console.log( a ); // 2
    }
    
    bar( baz );
}

function bar(fn) {
    fn(); // 这就是闭包
}

foo();

a = 2;

var a;

console.log( a ); // 2

---------------------------------------
// 实际按如下形式进行处理
var a; // 编译阶段

a = 2; // 执行阶段

console.log( a ); // 2