x = {a: 10};

y = {b: 20};

y.Prototype = x

z = {c: 30};

z.Prototype = y;

z.a; //

x.a = 100;

z.a; //

/*

    基于原型的基本概念

    1. 基本概念是对象

    2. 对象动态可变，完全可以从一个类型转换成另一个类型

    3. 对象不需要类

    4. 对象可以有原型，当对象没法响应对应属性，则可以委托给原型

*/

//  一、 多态

//一个函数应用于不同对象

function test() {

}

test.call({ a: 10, b: 20 });

test.call({ a: 100, b: 200 });

var a = 1;

var b = 2;

test(); //1,2

//Date.prototype.getTime()例外，必须对应日期对象 new Date()===> Date.prototype.getTime.call(new Date());

//  二、封装

(function () {

    //初始化上下文

}());

//  三、不支持多重继承：一个对象可以用来做直接原型

//  四、AOP特性

//  装饰者例子:新增一个判断条件，AOP切入报错

function Decorator(oldFunction) {

    //匿名封装原有函数的执行，新增装饰的过程

    return function () {

        //新增装饰的业务

        if (fooBar !='test') {

            alert("wrong");

            return false;

        }

        //执行原有函数

        return oldFunction();

    }

}

function test() {

    alert("right");

}

var checkTest = new Decorator(test);

var fooBar = false;

checkTest();

/*

    ECMAScript：基于原型的委托式继承的面向对象语言

*/

/*

    一、数据类型

    1. 原始值

    Undefined, Null, Boolean, String, Number, Object

    Reference:  解释delete、typeof、this

    List：      描述参数列表行为

    Completion  解释break、continue、return、throw

*/

var a = undefined;

var b = null;

var c = true;

var d = 'test';

var e = 10;

//  2. Object类型

var x = {

    a: 10,//原始值

    b: { z: 100 },//对象

    c: function () { }//函数

}

//  3. 动态性：程序执行时可随意增删改对象属性

var foo = { x: 20 };

foo.y = 30;//新增

foo.x = function () { }//修改

delete foo.x;

//静态对象不能修改

Object.freeze(foo);//此时属性不能进行任何操作

//设置属性只读、不可配置

Object.defineProperty(foo, "y", {

    value: 20,

    writable: false, //不可写

    configurable: false //不可配置

});

//  4. Boolean、String、Number对象：由内置构造函数创建

var c = new Boolean(true);

var d = new String('test');

var e = new Number(10);

// 转换成原始值

// 使用不带new关键字的函数

c = Boolean(c);

d = String(d);

e = Number(e);

// 重新转换成对象

c = Object(c);

d = Object(d);

e = Object(e);

//其他内置构造函数创建：Function、Array、RexExp、Math、Date

/*

    二、构造函数

*/

function A(x) { }//构造函数

var a = new A();

/*

    三、原型

*/

function A() {

    this.x = 10;

}

var a = new A();

A.prototype.y = 20;

a.y;//undefined

var b = new A();

b.y = 20;

/*

    四、读写特性

*/

//Get方法

(function () {

    if (O.hasOwnProperty(P)) {

        return O.P;

    }

}());

//Set方法

(function () {

    var foo = {};

    foo.y = 30;//设置

}());

//属性访问器，针对对象

var foo = { a: 10 };

foo.a;

foo["a"]

//原始值报错:对原始值进行属性取值，先对对象包装，访问属性，然后删除属性

var a = 10;

a.toString(); //"10"

a.x = 4;

a.x //undefined

var a = new Number(10);

a.toString();

a.x = 4;

delete a;//所以无法访问

//一

if (!("a" in window))

{

    var a = 1;

}

alert(a);

//答案：undefined

//因为JavaScript引擎首先会扫描所有的变量声明，然后将这些变量声明移动到顶部

var a;

if (!("a" in window)) {

    a = 1;

}

alert(a);

//

var a = 1,

    b = function a(x) { x && b(--x); };

alert(a);//永远是1

//填充VO的顺序是: 函数的形参 -> 函数申明 -> 变量申明 ->函数表达式

function a(x)

{

    return x * 2;

}

var a;

alert(a); //function

//

function b(x, y, a) {

    arguments[2] = 10; //活动对象，是当进入上下文时才创建，所以 a为Undefined

    alert(a);

}

b(1, 2);

//

function a() {

    alert(this);

}

a.call(null);//[object window]

//如果第一个参数传入的对象调用者是null或者undefined的话，call方法将把全局对象（也就是window）作为this的值