typeof NaN //number
isNaN("blue")   //true 会先隐式转换为Number("blue")为NaN
isNaN("true")   //false
isNaN("10")     //false
console.log(isNaN(['x']));    // true  比较特殊
console.log(isNaN({}));       // true  比较特殊

var lang = 'hel';
var lang = lang + 'low';   //前边的lang会被销毁

function foo(num1,num2){}
foo(10)      //此时num2就是undefined

function setName(obj){
    obj.name = 'Nicholas';
    obj = new Object();    //重点在这里，参数，参数，参数被重写在这里是一个局部变量(如果不是重写参数就不一样了)，是局部变量，所以在执行完毕的时候，这个局部变量就会自动销毁，不影响外边的obj
    obj.name = 'Greg';
}
var person = new Object();
setName(person);
alert(person.name);    //'Nicholas'

var element = document.getElementById("hehe");
var myObject = new Object();
myObject.element = element;
element.someObject = myObject

//上边两句循环引用，无法回收，下边进行清除
myObject.element = null;
element.someObject = null;

displayInfo(
    {
        name:'pengzhang',
        age:29
    }
)

function compare(a,b){
    if(a<b){
        return -1;
    }else if(a>b){
        return 1;
    }else{
        return 0;
    }
}

function compare(a,b){
    return a - b ;
}

//every
var numbers = [1,2,3,4,3]
var everyResult = numbers.every(function(item,index,array){
    return (item>2)
})
alert(everyResutl)    //false  因为不是所有的项都大于2

//filter
var filterResult = numbers.filter(function(item,index,array){
    return (itme>2)
})
alert(filterResult)   //[3,4,3]

//map
var mapResult = numbers.map(function(item,index,array){
    return (item*2*)
})
alert(mapRsult)    //[2,4,6,8,6]

//forEach
numbers.forEach(function(item,index,array){
    //执行某些操作
})

var values = [1,2,3,4,5];
var sum = values.reduce(function(prev,cur,index,array){
    return prev+cur
})
alert(sum);    //15

// 最简单数组去重法
function unique1(array){
  var n = []; //一个新的临时数组
  //遍历当前数组
  for(var i = 0; i < array.length; i++){
    //如果当前数组的第i已经保存进了临时数组，那么跳过，
    //否则把当前项push到临时数组里面
    if (n.indexOf(array[i]) == -1) n.push(array[i]);
  }
  return n;
}

// 判断浏览器是否支持indexOf ，indexOf 为ecmaScript5新方法 IE8以下（包括IE8， IE8只支持部分ecma5）不支持
if (!Array.prototype.indexOf){
  // 新增indexOf方法
  Array.prototype.indexOf = function(item){
    var result = -1, a_item = null;
    if (this.length == 0){
      return result;
    }
    for(var i = 0, len = this.length; i < len; i++){
      a_item = this[i];
      if (a_item === item){
        result = i;
        break;
      }  
    }
    return result;
  }
}

// 速度最快， 占空间最多（空间换时间）
function unique2(array){
  var n = {}, r = [], len = array.length, val, type;
    for (var i = 0; i < array.length; i++) {
        val = array[i];
        type = typeof val;
        if (!n[val]) {
            n[val] = [type];
            r.push(val);
        } else if (n[val].indexOf(type) < 0) {
            n[val].push(type);
            r.push(val);
        }
    }
    return r;
}

function unique3(array){
  var n = [array[0]]; //结果数组
  //从第二项开始遍历
  for(var i = 1; i < array.length; i++) {
    //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
    //那么表示第i项是重复的，忽略掉。否则存入结果数组
    if (array.indexOf(array[i]) == i) n.push(array[i]);
  }
  return n;
}

// 将相同的值相邻，然后遍历去除重复值
function unique4(array){
  array.sort(); 
  var re=[array[0]];
  for(var i = 1; i < array.length; i++){
    if( array[i] !== re[re.length-1])
    {
      re.push(array[i]);
    }
  }
  return re;
}

// 思路：获取没重复的最右一值放入新数组
function unique5(array){
    var r = [];
    for(var i = 0, l = array.length; i < l; i++) {
        for(var j = i + 1; j < l; j++){
            if (array[i] === array[j]){
                ++i;                   //这里++i中断了for循环，让顶层的for循环从1开始
            }
        }
        r.push(array[i]);
    }
    return r;
}

var start = Date.now();
doSomething();
var stop = Date.now();
result = stop-star;

var BaseClass = function() {}; // var BaseClass=new Function();  
BaseClass.f1 = function(){//定义静态方法  
     alert(' This is a static method ');  
}  
BaseClass.f1();//This is a static method  
var instance1 = new BaseClass();  
instance1.f1();//instance1.f1 is not a function

//方法一：字面量
var BaseClass = {
    f1:function(){
        alert(' This is a static method ');  
    }
}
var instance1 = new BaseClass();  
instance1.f1();//This is a static method
//方法二：this
var BaseClass = function() {  
 this.method1 = function(){  
   alert(' Defined by the "this" instance method');  
 }  
};  
var instance1 = new BaseClass();  
instance1.method1();//Defined by the "this" instance method 
//方法三：prototype
var BaseClass = function() {};  
BaseClass.prototype.method1 = function(){  
      alert(' This is a instance method ');  
}  
var instance1 = new BaseClass();  
instance1.method1();//This is a instance method

var s1 = "text"
s1.color = "red"
alert(s1.red)   //undefined

var value = '25'
var number = Number(value);   //转型函数    保存的是数值25
alert(typeof number)    //number

var obj = new Number(value);  //构造函数    保存的是实例对象
alert(typeof obj)       //object
alert(obj instanceof Number)   //true
alert(obj instanceof Object)   //true

var booleanObject = new Boolean(true)

var falseObject = new Boolean(false);       //将false重写了，相当于true
var result = falseObject && true;
alert(result)                              //true

var num = 10;
alert(num.toString(2))   //1010  转换为二进制

var num = 10.005;
alert(num.toFixed(2))   //10.00  转换为二进制

var num = 99;
alert(num.toPrecision(1))   //1e+2  以一位来表示99，因为一位无法准确的表达99，所以进行舍入
alert(num.toPrecision(2))   //99

var stringValue = 'hello';
alert(stringValue.charAt(1));   //"e"

var stringValue = 'hello';
alert(stringValut.charCodeAt(1));   //"101"

var stringValue = 'hello world'  
stringValue.slice(-3)    //rld     -3+11
stringValue.substring(-3)   //hello world    0
stringValue.substr(-3)   //rld     -3+11
stringValue.slice(3,-4)   //lo w    3,-3+11
stringValue.substring(3,-4)  //hel    3,0
stringValue.substr(3,-4)     //""     3,0

var stringValue = "lsdjklasjdflajpjwpejkgljlsjflsajweiotu"
var positions = [];
var pos = stringValue.indexOf("e");
while(pos>-1){
    positions.push(pos);
    pos = stringValue.indeOf("e",pos+1)    //向下继续找
}
alert(positions);;

var pattern = /.at/;
var matches = text.match(pattern);    //得到的是一个数组

var text = 'cat,bat,sat'
var pos = text.search(/at/);    //1

result = text.replace(/at/g, 'ond')   //'cond,bond,sond,fond'

var stringValue = 'yellow';
stringVaule.localCompare("brick")   //1   yellow在字母表中排在brick之后

String.fromCharCode(104,101,108,111); //'hello'

var uri = "http://www.wrox.com/illegal value.htm#start";
        
//"http://www.wrox.com/illegal%20value.htm#start"
alert(encodeURI(uri));
        
//"http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"
alert(encodeURIComponent(uri));

eval("alert('hehe')")    //hehe

var a = 'haha'
eval(alert(a))

Math.ceil(25.9)   //26
Math.floor(25.9)  //25

var person = {
    name: "Nicholas";
}
//Configurable\Enumerable\Writable 都是默认值为true，Value被设置为Nicholas

var person = {};
Object.defineProperty(person, "name", {
    writable: false,        //只读的，非严格模式下，赋值被忽略，严格模式下报错
    value: "Nicholas"
});

alert(person.name);
person.name = "Michael";
alert(person.name);

var book = {
    _year: 2004,
    edition: 1
};
  
Object.defineProperty(book, "year", {
    get: function(){
        return this._year;
    },
    set: function(newValue){
    
        if (newValue > 2004) {
            this._year = newValue;
            this.edition += newValue - 2004;
        
        }
    }
});

book.year = 2005;
alert(book.edition);   //2

var book = {};
        
Object.defineProperties(book, {
    _year: {                //数据属性
        value: 2004           
    },
    
    edition: {              //数据属性
        value: 1
    },
    
    year: {            
        get: function(){        //访问器属性
            return this._year;
        },
        
        set: function(newValue){        //访问器属性
            if (newValue > 2004) {
                this._year = newValue;
                this.edition += newValue - 2004;
            }                  
        }            
    }        
});
   
book.year = 2005;
alert(book.edition);   //2

var book = {};
        
Object.defineProperties(book, {
    _year: {
        value: 2004
    },
    
    edition: {
        value: 1
    },
    
    year: {            
        get: function(){
            return this._year;
        },
        
        set: function(newValue){
            if (newValue > 2004) {
                this._year = newValue;
                this.edition += newValue - 2004;
            }                  
        }            
    }        
});
   
var descriptor = Object.getOwnPropertyDescriptor(book, "_year");   //★主要是通过这个属性来访问的
alert(descriptor.value);          //2004
alert(descriptor.configurable);   //false
alert(typeof descriptor.get);     //"undefined"

var descriptor = Object.getOwnPropertyDescriptor(book, "year");
alert(descriptor.value);          //undefined
alert(descriptor.enumerable);     //false
alert(typeof descriptor.get);     //"function"

function createPerson(name, age, job){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function(){
        alert(this.name);
    };    
    return o;        //★ return
}

var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

person1.sayName();   //"Nicholas"
person2.sayName();   //"Greg"

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
        alert(this.name);
    };    
}

var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

person1.sayName();   //"Nicholas"
person2.sayName();   //"Greg"

alert(person1 instanceof Object);  //true
alert(person1 instanceof Person);  //true
alert(person2 instanceof Object);  //true
alert(person2 instanceof Person);  //true

alert(person1.constructor == Person);  //true
alert(person2.constructor == Person);  //true

alert(person1.sayName == person2.sayName);  //false

function Person(){
        }
        
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();
person1.sayName();   //"Nicholas"

var person2 = new Person();
person2.sayName();   //"Nicholas"

alert(person1.sayName == person2.sayName);  //true

alert(Person.prototype.isPrototypeOf(person1));  //true
alert(Person.prototype.isPrototypeOf(person2));  //true

//only works if Object.getPrototypeOf() is available
if (Object.getPrototypeOf){
    alert(Object.getPrototypeOf(person1) == Person.prototype);  //true
    alert(Object.getPrototypeOf(person1).name);  //"Nicholas"
}

alert(Object.getPrototypeOf(person1) == Person.prototype); //true
alert(Object.getPrototypeOf(person1).name);         //"Nicholas"

delete person1.name;

"name" in person1  //true

function hasPrototypeProperty(object, name){
            return !object.hasOwnProperty(name) && (name in object);
        }

function Person(){
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
    alert(this.name);
};

var keys = Object.keys(Person.prototype);
alert(keys);   //"name,age,job,sayName"

var p1 = new Person();
p1.name = 'Rob';
p1.age = 31;
var p1keys = Object.key('p1');   //查看的是实例的属性
alert(p1keys);      //"name,age"

var keys = Object.getOwnPropertyNames(Person.prototype);
alert(keys);   //"constructor,name,age,job,sayName"

function Person(){
}

Person.prototype = {  //这个是创建的新对象，所以它重新定义了constructor，不再指向Person，而是（Object构造函数）
    constructor : Person,    //因为上边注释的原因，所以在这里重新定义一下，就可以将constructor重新定义回Person了
    name : "Nicholas",
    age : 29,
    job: "Software Engineer",
    sayName : function () {
        alert(this.name);
    }
};

var friend = new Person();

alert(friend instanceof Object);  //true
alert(friend instanceof Person);  //true
alert(friend.constructor == Person);  //true    //如果上边没有重新定义的话，这里是false
alert(friend.constructor == Object);  //false   //如果上边没有重新定义的话，这里是true

Object.defineProperty(Person.prototype,"constructor",{
    enumerable:false,
    value: Person
})

function Person(){
}

var friend = new Person();
        
Person.prototype = {
    constructor: Person,
    name : "Nicholas",
    age : 29,
    job : "Software Engineer",
    sayName : function () {
        alert(this.name);
    }
};

//如果var friend = new Person();写在这里，下边就不会报错了，因为按顺序执行，上边重定义后，这里访问的就是新的对象了
friend.sayName();   //error   ★这里报错是因为Person.prototype被重写了，所以friend已经调不到属性了

String.prototype.startsWith = function (text) {   //进行重写
    return this.indexOf(text) == 0;
};

var msg = "Hello world!";
alert(msg.startsWith("Hello"));   //true

function Person(name, age, job){                   //构造函数模式
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["Shelby", "Court"];
}

Person.prototype = {                               //原型模式         
    constructor: Person,
    sayName : function () {
        alert(this.name);
    }
};

var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

person1.friends.push("Van");

alert(person1.friends);    //"Shelby,Court,Van"
alert(person2.friends);    //"Shelby,Court"
alert(person1.friends === person2.friends);  //false
alert(person1.sayName === person2.sayName);  //true

function Person(name, age, job){
        
//properties
this.name = name;
this.age = age;
this.job = job;

//methods
if (typeof this.sayName != "function"){      //只在sayName这个方法不存在的情况下，才会将它添加到原型中

    Person.prototype.sayName = function(){
        alert(this.name);
    };
    
}
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();   //弹出Nicholas

function SpecialArray(){       
 
    //create the array
    var values = new Array();
    
    //add the values
    values.push.apply(values, arguments);
    
    //assign the method
    values.toPipedString = function(){
        return this.join("|");
    };
    
    //return it
    return values;        
}

var colors = new SpecialArray("red", "blue", "green");     //唯一和工厂模式的区别是，多了一个new！！！
alert(colors.toPipedString()); //"red|blue|green"

alert(colors instanceof SpecialArray);    //不能通过instanceof确定类型

function Person(name, age, job){
    //添加方法
    o.sayName = function(){
        alert(this.name);
    };    
    return o;        //★ return
}

var friend = Person("Nicholas", 29, "Software Engineer");
friend.sayName();  //Nicholas

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

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

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

//inherit from SuperType
SubType.prototype = new SuperType();     //这里非常非常非常重要，这里重写了SubType的原型，所以之前的原型就断掉了，以后也不要查找了。

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

var instance = new SubType();
alert(instance.getSuperValue());   //true    查找顺序：1：实例 2：SubType.prototype(已变更) 3：SuperType.prototype

alert(instance instanceof Object);      //true
alert(instance instanceof SuperType);   //true
alert(instance instanceof SubType);     //true

alert(Object.prototype.isPrototypeOf(instance));    //true
alert(SuperType.prototype.isPrototypeOf(instance)); //true
alert(SubType.prototype.isPrototypeOf(instance));   //true

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

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

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

//inherit from SuperType
SubType.prototype = new SuperType();

//new method 添加新方法
SubType.prototype.getSubValue = function (){
    return this.subproperty;
};

//override existing method   重写超类
SubType.prototype.getSuperValue = function (){
    return false;
};


//try to add new methods � this nullifies the previous line
SubType.prototype = {           //重写原型
    getSubValue : function (){
        return this.subproperty;
    },

    someOtherMethod : function (){
        return false;
    }
};

var instance = new SubType();
alert(instance.getSuperValue());   //error!  //SubType.prototype已经被重写了，getSuperValue方法已经丢失了

function SuperType(name){
    this.name = name;
}

function SubType(){  
    //inherit from SuperType passing in an argument
    SuperType.call(this, "Nicholas");      
    
    //instance property
    this.age = 29;
}

var instance = new SubType();
alert(instance.name);    //"Nicholas";
alert(instance.age);     //29

            
function SuperType(name){                     //构造函数-创建对象
    this.name = name;
    this.colors = ["red", "blue", "green"];                    
}

SuperType.prototype.sayName = function(){    //原型模式-创建对象
    alert(this.name);
};

function SubType(name, age){  
    SuperType.call(this, name);              //借用构造函数-继承  第二次调用SuperType()
    
    this.age = age;
}

SubType.prototype = new SuperType();         //原型链-继承   第一次调用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    alert(this.age);
};

var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors);  //"red,blue,green,black"       
instance1.sayName();      //"Nicholas";
instance1.sayAge();       //29


var instance2 = new SubType("Greg", 27);
alert(instance2.colors);  //"red,blue,green"
instance2.sayName();      //"Greg";
instance2.sayAge();       //27

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}
//上边那几句就是浅复制的原理
var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = object(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = object(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");

alert(person.friends);   //"Shelby,Court,Van,Rob,Barbie"

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};

var anotherPerson = Object.create(person);      //用法
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");

alert(person.friends);   //"Shelby,Court,Van,Rob,Barbie"

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
                   
var anotherPerson = Object.create(person, {
    name: {
        value: "Greg"
    }
});

alert(anotherPerson.name);  //"Greg"

function createAnother(original){
    var clone = object(original);    //创建一个新对象-不一定用原型式
    clone.sayHi = function(){        //增强这个对象
        alert("hi");
    };
    return clone;                   //返回这个对象
}
var person = {
    name:"Nicholas",
    friends: ["Shelby", "Court", "Van"]
}
var anotherPerson = createAnother(person);
anotherPerson.sayHi();  //"hi"

//原型式继承--浅复制 可以用Object.create()代替
function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}
//原型链继承--下边这个和（组合技成中的）SubType.prototype = new SuperType();的作用相同，但是下边这么写的意思是为了避免多次创建SuperType()的实例
function inheritPrototype(subType, superType){
    var prototype = object(superType.prototype);   //prototype.prototype == superType.prototype
    prototype.constructor = subType;               //augment object
    subType.prototype = prototype;                 //subType.prototype.prototype == superType.prototype
}
//父对象/父类/超类-的属性
function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
//超类的方法写在原型上
SuperType.prototype.sayName = function(){
    alert(this.name);
};
//借用构造函数-SubType本身指向Super,拥有了colors属性。SubType原型也指向了SuperType的原型，但后边会被重写
function SubType(name, age){
    SuperType.call(this, name);
    this.age = age;
}
//让SubType的prototype继承SuperType，使得之前SubType的prototype被覆盖
inheritPrototype(SubType, SuperType);
//一定要在上边重写SubType的prototype被重写之后再定义方法，否则会被覆盖
SubType.prototype.sayAge = function(){
    alert(this.age);
};
//运用
//先创建一个实例副本，是副本副本副本（副本会复制本身，但是不会复制原型链）
var instance1 = new SubType("Nicholas", 29);
//这样修改的就是副本本身，而不是原型链了
instance1.colors.push("black");
alert(instance1.colors);  //"red,blue,green,black"
//再创建一个新副本，新副本是从SubType本身复制过来的，不是从其他副本复制过来的
var instance2 = new SubType("Greg", 27);
alert(instance2.colors);  //"red,blue,green"

function extendCopy(p) {
　　　　var c = {};
　　　　for (var i in p) { 
　　　　　　c[i] = p[i];
　　　　}
　　　　c.uber = p;
　　　　return c;
　　}

//调用
var Doctor = extendCopy(Chinese);

//p是
function deepCopy(p, c) {
    var c = c || {};
    for (var i in p) {
        if (p.hasOwnProperty(i)) {
            if (typeof p[i] === 'object') {
                c[i] = (p[i].constructor === Array) ? [] : {};
                deepCopy(p[i], c[i]);
            } else {
                c[i] = p[i];
            }
        }
    }
    return c;
}
//调用
var Doctor = deepCopy(Chinese);

function factorial(num){
    if (num <= 1){
        return 1;
    } else {
        return num * factorial(num-1);
    }
}

var anotherFactorial = factorial;           //指针指向factorial
factorial = null;                          //指针被指向了null
alert(anotherFactorial(4));  //error!

 function factorial(num){
    if (num <= 1){
        return 1;
    } else {
        return num * arguments.callee(num-1);    //★ argument.callee总比使用函数名更保险
    }
}

var anotherFactorial = factorial;     //★ 赋值其实就是创建了一个副本
factorial = null;
alert(anotherFactorial(4));  //24    因为上边是副本，所以anotherFactorial = factorial还是存在的。但是修改anotherFactorial属性会反映到facotrial

var factorial = (function f(num){
    if(num<=1){
        return 1；
    }else{
        return num*f(num-1);
    }
})

function createFunctions(){
    var result = new Array();
    
    for (var i=0; i < 10; i++){
        result[i] = (function(num){
            return function(){      //★★★★★匿名函数形成闭包，访问的是外层函数传过来的i，这个i每次传进来都是最后一个值
                return num;
            };
        })(i);          //给自执行函数传入值
    }
    
    return result;
}

var funcs = createFunctions();

//every function outputs 10
for (var i=0; i < funcs.length; i++){
    document.write(funcs[i]() + "<br />");
}

var a = (function () {          //必须自执行，要不然返回的是一个函数
    var name = 'zhang';
    return (function (){        //必须自执行，要不然返回的是一个函数
        var name = 'peng';
        return name;
    })();
})();
console.log(a);

var name = "The Window";
            
var object = {
    name : "My Object",

    getNameFunc : function(){
        var that = this;             //如果这里不把this传给that，那么下边的return this.name中的this就是指向的window，结果将是The Window
        return function(){
            return that.name;
        };
    }
};

alert(object.getNameFunc()());  //"MyObject"

var name = "The Window";
            
var object = {
    name : "My Object",

    getName: function(){
        return this.name;
    }
};

alert(object.getName());     //"My Object"
alert((object.getName)());   //"My Object"
alert((object.getName = object.getName)());   //"The Window" in non-strict mode    因为被重新赋值了

function outputNumbers(count){
    for (var i=0; i < count; i++){
        alert(i);                       //0,1,2,3,4
    }
//因为没有作用域，所以下边可以取到for中的i
    alert(i);   //count                //5
}

outputNumbers(5);

function outputNumbers(count){
    for (var i=0; i < count; i++){
        alert(i);                //0,1,2,3,4
    }

    var i;    //variable re-declared   这里只是声明的话，不影响结果，赋值的话，会影响下边取到的值
    alert(i);   //count          //5
}

outputNumbers(5);

function outputNumbers(count){
            
    (function () {                               //创建私有作用域
        for (var i=0; i < count; i++){
            alert(i);
        }
    })();
    
    alert(i);   //causes an error
}

outputNumbers(5);

function MyObject(){
    //私有变量和私有函数
    var privateVariable = 10;
    function privateFunction(){
        return false;
    }
    
    //特权方法   重点就是this
    this.publicMethod = function(){
        privateVariable++;
        return privateFunction();
    }
}

function Person(name){     
    this.getName = function(){
        return name;
    };
    this.setName = function (value) {
        name = value;
    };
}
var person = new Person("Nicholas");
alert(person.getName());   //"Nicholas"
person.setName("Greg");
alert(person.getName());   //"Greg"

(function(){
            
    var name = "";
    
    Person = function(value){                //没有var是全局的
        name = value;                
    };
    
    Person.prototype.getName = function(){
        return name;
    };
    
    Person.prototype.setName = function (value){
        name = value;
    };
})();

var person1 = new Person("Nicholas");
alert(person1.getName());   //"Nicholas"
person1.setName("Greg");
alert(person1.getName());   //"Greg"
                   
var person2 = new Person("Michael");
alert(person1.getName());   //"Michael"    //原型链上name被改变
alert(person2.getName());   //"Michael"

function BaseComponent(){
}
function OtherComponent(){
}
var application = function(){
    //private variables and functions
    var components = new Array();
    //initialization
    components.push(new BaseComponent());
    //public interface
    return {                            //return  这个要返回到外部
        getComponentCount : function(){
            return components.length;
        },
        registerComponent : function(component){
            if (typeof component == "object"){
                components.push(component);
            }
        }
    };
}();                                    //★这个()很重要
application.registerComponent(new OtherComponent());
alert(application.getComponentCount());  //2

function BaseComponent(){
}

function OtherComponent(){
}

var application = function(){

    //private variables and functions
    var components = new Array();

    //initialization
    components.push(new BaseComponent());

    //create a local copy of application
    var app = new BaseComponent();            //★唯一的区别

    //public interface
    app.getComponentCount = function(){
        return components.length;
    };

    app.registerComponent = function(component){
        if (typeof component == "object"){
            components.push(component);
        }
    };

    //return it
    return app;
}();

alert(application instanceof BaseComponent);
application.registerComponent(new OtherComponent());
alert(application.getComponentCount());  //2