javascript object

1、object
根据面向对象的要求， object 是非常重要的。object 是这样被解释的 “thing”包括（everyone 、everything) ,这个规定对于对于面向对象编程很有用。thing 可以是真实生活中的任何东西，你可以知道他的一些特征如：颜色，名字，体重。和知道他的一些行为（action） 如：
叫，睡觉，吃饭。在面向对象(OOP)里, 特征被称为对象的属性（properties)，行为被称为方法(method)。在口语中会存在一些类似的，一般对象（object）都是一些名词(如：人，书）方法都是一些动词（如：读，跑）属性的值一般都是形容词（adjectives)
如：地上睡（动词）了一只黑色的（形容词）猫（名词）。

2、classes
在现实生活中，根据一定规则归纳出来对象的集合。蜂鸟 和鹰是两种鸟 所以他们被分到鸟类里。在面向对象里 一个class是一个蓝图，
或者可以说是对象的一个recipe。为实例起一个别名，如 鹰 是 Birds class 的一个实例，可以用相同类创建不同的实例，那些类只是
一个模板，可以根据这些模板创建具体的实例。
javascript 的面向对象 classic 的OOP（java、c++ )有些不同。javascript 是没有classic的。任何事物都是一个object。
javascript 主张 prototype 的观念。在classic OOP 里你需要创建一个新的对象 从classic 里。但是在prototype OOP里，会得到Person 的object， 在底层重新使用prototype 来唤醒一个新的Bob对象。

3、encapsulation (封装）
封装是OOP系列的两一个重要的观念，在实际的使用中有两种封装
a）、数据封装即将数据存储到属性property中。
b)、用方法去做携带数据去做一些事情。
一起的其他组封装的一些隐藏的信息，这个在表层可能意味着不同的事情。一般被认为包含在OOP的上下文中。
假设一个MP3是一个播放器， 你做一个使用者的对象，你可以通过一些接口去使用它，如按键，屏幕等等。你用这些接口去做一些对你
有用的事情，如播放歌曲。但是它内部如何工作你是不知道的，大多数情况下我们是不关心这个的。换句话说，实现的那些接口是对
你隐藏的。在OOP中在编码中，当你使用 一个对象的方法，这个对象不是你代码中的对象，或者说他来自第三方类库，你的程序不需要
知道他内部如何工作。在编译型语言里你不能够看到他内部对象是如何工作的，但是javascript是解释形语言，你可以直接看他的原码。但是他们的原理是相同的，不需要担心对接口的实现。
其他信息的隐藏，属性和方法的可见性。在一些语言里有，object 可能有 public private protected 的方法和属性。
如：private 仅在object 内部使用，public 是everyon 的。在javascript中所有的方法和属性都是public 的，但是可以通过一些途径
来实现对象内部的私有性。
4、aggregation(聚合)
将一些对象组合成一个新的对象被称为聚合（aggregation).
聚合的理念就是聚集一些对象到一个新的对象里去，聚合的重要作用就是将以一个难题拆分成成多个易解决的模块。
一个非常复杂的问题包括的范围特别多，就可以尽能的考虑他的级别，然后将它划分成多个较小的区域去解决，再去抽象这些小模块。
比如一个私人电脑是一个非常复杂的对象，当你打开电脑的时候你不需要去关心打开电脑的所有事物。但是你可以抽象这些问题，如
监听的对象、鼠标对象、键盘对象、等等。接着你可以继续抽象你抽象的对象。
也可以用其它的东西来模拟这个过程，如书这个对象。他可能包含一个或多个作者对象，出版者对象，若干个章节对象等等。

5、继承（inheritance)
继承是一个非常好的代码重用方式，例如你可以有一个 person object 有 name,birth的属性，有walk、sleep、eat等function.
你可以继承这个对象就拥有了他的这些属性和方法。
在classical OOP中，classes 继承其他classes,但是在javascript 中没有class，所以只能从object 继承object.
一个对象继承另一个对象一般会添加一些新的methods在继承的对象里，来延伸父对象，继承的对象可以重新定义父对象的方法，即重写
（override).
6、多态（polymorphism)
如：子对象继承父对象的所有methods。假设父对象中一个method1然后我们在编码中有一个变量调用子对象的method1，子对象中没有这个method1，但是这个代码被成功执行。这种在不同的对象调用相同方法的的行为称为多态。


二 数据类型，数组，循环，条件判断
1、变量用来存储数据，对于一些复杂的数据通过变量存储比较方便操作，比如:pi = 3.1415926；但是变量会被更改，所以变量里存储的数据将是最终操作过变量的数据。
使用 variable 一般分为两步： 1、声明 variable . 2、初始化变量,赋值。
2、变量的命名 :
var a;
var thisIsVariable;
var _and_this_tow;
var max12_variable;
字母数字下划线，数字不能开头。
variable 的命名对大小敏感 。
3、运算符
包括基本的运算符（+ - × /） % ++ --
4、基本数据类型
Number、 Boolean、String、Undefined ---- 当你访问一个不存在的变量时会得到一个undefied
Null ---- 这是一个比较特殊的数据类型，它只有一个值: null 意思就是没有值。nothing,如果一个variable 的value是null，表示这个变量仍然被定义了只是他的值是null.跟undefined不同。
如果你想知道一个 variable 或者一个value的数据类型可以用typeof 去获取。
如 ：>>> typeof 1
"number"
对于16进制的数字 需要往前面添加 >>> typeof 0x00
"number"
5、指数
跟其他语言一样 可以这么写（ 1e1 1e+1 1E1 1E+1)
1e1 ==> 10
2e2 ==> 200
3e-2 ==> 0.03

6、Infinty
只是一个特殊的值 ，是一个超大的number
5e-324 < Infinty < 1.7976931348623157e+308

对这个Infinty 操作要么得到一个Infinty 要么就是 NaN
>>> Infinty - 99999999999999999999999999
Infinty
>>> Infinty - Infinty
NaN
>>> Infinty - 2e208
NaN

7、 NaN
是 number类型，尽管他叫 Not A Number.
NaN 是一个特殊的


1、function 是data

这是一个非常重要的观念，这就意味着你有两种方式去定义一个function :
function f(){ return 1;}
var f = function(){return 1;}

第二种从字面上理解就是在定义一个function.
当你用typeof 在这个 f上时，你会得到一个"function"的类型：
>>> typeof f
"function"
所以说javascript 是一个数据，他是一个特殊的数据，它有下面两个特征:
.它包含代码
.它可以被执行和应用。
执行一个function 的方式是，在他的名字之后添加一对圆括号，下面这个例子，来说明，先不用管这个fun窗体哦你是怎么定义的，
在这个例子里你可以看到这个function是被当作一个普通的变量来对待的，他可以被删除，然后被copy.
>>> var sum = function (){return 1;}
>>> var add = sum;
>>> delete sum;
true
>>>typeof sum
"undefined"
typeof add
“function"
因为function 是一个数据，所以它被分配给变量，function 跟变量有相同的命名规则。

2、匿名function
在javascript 中数据可以直接存在于你的程序中，假设你有下面的代码：
>>> "test"; [1,2,3]; undefined; null; 1;
这些代码可能会看起来有些奇怪，但是，因为它实际上么有做任何事情，但是这段代码是有效的，不会引起任何错误，你可以称它为代码
中的匿名数据，匿名数据 --- 就是数据没有被分配到变量里去，因此也不会有名字来指定。
根据我们现在知道这个function 也是没有被分配name,像其他变量一样：
>>>function (a){return a;}
这些数据将会散布在你的代码里，不能被使用，如果你想使用他们，那么下面有两种比较好的方式来使用他们。
*你可以把匿名function 当作一个参数传递给另一个function ,你可以通过另一个function 做一些你想做的事情。
*你可以定义一个匿名function 立刻执行它。(anonymous function)


3、function 的回调 （callback)
因为一个function 可以被当作一个数据被分配到一个变量里去，它可能会被定义会着被删除被copy.
下面这个例子，一个function接受两个function,然后进行计算，再return 掉。
function invoke_add_add(a,b){
return a() + b();
}
现在让我们定义两个简单的函数：
function one(){
return 1;
function two(){
return 2;
}
然后我们就可以调用那个function
>>>invoke_add_add(one, two);
3

也可以使用匿名function 来代替 one 和two
invoke_add_add(fucntion(){return 1}, function (){return 2;});

当你把A传递到B，然后在B里执行A，这种方式经常会被称为 callback function ,如果A没有name 的话，你就可以说它是匿名回调了。
什么时候回调函数比较有用了，让我们来看一些回调函数的范例，也就是：
*传递一些没有名字的function。也就意味着少一些全局变量。
*你可以用一个function 代理调用另一function, 这就意味着这里可能会有较少的代码。
*这种方式也是有利于性能。


4、回调的例子
常见的情节：你有一个function然后return 一个value,然后传递给其他的function,第一个function : multiplyByTwo(),接受三个参数
循环他们，对每个数乘以2，返回一个数组包含这些结果，第二个function ,addOne();获取它，对它进行加1，然后再返回它。
function multiplyByTwo(a, b, c) {
var i, ar = [];
for(i = 0; i < 3; i++) {
ar[i] = arguments[i] * 2;
}
return ar;
}
function addOne(a) {
return a + 1;
}

multiplyByTwo(1,2,3);
[2,4,6]

addOne(100)
101

有一个数组，包含三个数，循环这个数组的每一个元素，首先调用multiplyByTwo:
>>> var myarr = []
>>> myarr = multiplyByTwo(10, 20, 30)
[20,40,60]

现在循环，每一元素，调用addOne()
>>>for(var i = 0; i< myarr.length; i++){
myarr[i] = addOne(myarr[i]);
}
>>>myarr

[11,21,31]

这种方式是很不错的，但是也是有可以改进的地方，一个地方就是循环，里面使用了两个循环，这个花费是很昂贵的，我们可以使用
一个循环来完成这件事情。

function multiplyByTwo(a, b, c, callback){
var i, ar=[];
for (i = 0; i < 3; i++){
ar[i] = callback(arguments[i]*2);
}
return ar;
}


通过对function 的修改，现在我们可以只是用一个function 的调用，传递初始值，和回调的函数就可以了。
>>> myarr = multiplyByTwo(1,2,3,addOne);
[3,5,7]

匿名function 应该很容易被使用的：
myarr = multiplyByTwo(1,2,3,function (a) { return a+2;}）；


5、自我调用function (self-invoking functions)
迄今未至我们都是使用匿名函数来做回调函数的。让我们看看其他程序调用一个匿名function,调用这个function.下面这个例子。
(function(){
alert（'boo');
})()
这种句法第一次看到可能有一点害怕，其实上是很简单的，一个匿名函数被定义在一个圆括号里面，然后在跟一个其他的圆括号，基本
上是立刻执行的，可以在后面的括号放一些参数，你的匿名function 也是可以接受的。
（function (){
alert( "hello " + name + "!");
})("Bob");

一个好地方就是使用自己的匿名function 可以不创建全局的variable.
缺点就是不能执行相同的function 两次，除非你把它放到循环里或者其他的function.
这种匿名function 的自我引用使用于 one-off模式 或者做初始化任务。

6、内部function (inner function or private function)

在我们的思想里，一个function 看起来像是一个value，你可以在最外面定义一个function 不做任何事情，在里面定义其他的function.
如：
function a (param){
function b(theinput){
return theinput*2;
};
return " the result is " + b(param);

}

从字面上理解，可以是这样的：
var a = function (param){
var b = function (theinput){
return theinput ×2；
}
return " the result is " + b(param);
}
当你调用 全局变量a时，它是可以访问的，但是你却不能访问 b，这说明b是私有的。

使用private function 有以下好处：
***
* 你可以有比较干净全局命名空间.
* privacy(隐私性） 暴露那些部分给外部将由你决定。


7、function 里return 一个function
在前面已经提到过了，一个function总是能return 一个value 如果你没有明确的使用一个return ,那么他会悄悄的给你添加一个return
return "undefined",一个function 只能return 一个value，而且这个value 只能被一个function 代替。
如：
function A(){
alert('A');
return function (){
alert（’B');
};
}
在这个例子里，A可以打印一个A，然后再return 另一个function 做其他事情，你可以return 一个value 分配给一个变量，然后这个
变量就可以当作普通方法来用。
>>> var newFun = A();
>>>newFun()
第一个会 alert A ,第二会 alert B

如果说你想一执行就返回，不能分配它到一个新的变量，可以给它后面再添加一个新的圆括号就可以了，这个结果将是相同的。
如：
>>>a()();

8、function 自己的重写。
因为一个function 可以return 一个新的function， 因此你可以用一个function 去代替一个旧的的function, 继续用上面的例子，
你可以用通过return 的value 来调用重写真实的 a function 如：
>>>a=a()
它将会在a的上面，alert A ,但是下次你调用a时，它将会返回 alert B
这是非常有用的，当一个function 被以 one-off方式初始化，function 在第一次调用时，重写它自己以避免每次调用都做一些重复
的工作。
在上面例子的基础上，我重新定义一个外部的function----我们回去它return的value 并且分配给它返回的function,但是这个function
事实上已经在内部进行了自我重写。
如：
function a(){
alert('A');
a = function(){
alert('B');
};
}

如果你第一次调用这个function :
***
* Alert A! -----可以认为是做one-off模式调用的准备工作
* 在重新定义一个全局变量a分配一个新的function 给他。
随后这个function 被调用，它将是 Alert B

下面这个例子是联合其他的技术来讨论：
var a = function() {
function someSetup(){
var setup = 'done';
}
function actualWork() {
alert('Worky-worky');
}
someSetup();
return actualWork;
}();

在这个例子里：
***
*在这个例子里你有私有的someSetup() and actualWork()
*有一个自我应用的a function， 通过它后面添加圆括号来定义。
*这个function 被执行的时候将会调用someSetup() 然后return 一个变量的出处 actualWork,注意这个function 没有圆括号，
因为它只是一个function reference 而不是Invoke
*自己调用自己的function 将它分配个一个a中。

如果你要测试上面的例子建议你留意一下：它是如何初始化的， 你调用a()后会怎么样。
如果说这些你应用到不同的浏览器中可能会有不同的的方式去实现的。

总结：
1、范围的束缚
javascript 的作用域并不像其他的语言那样，它没有花括号域，但是它有function 的范围，一个变量定义在function 里，
在外部是不可见的，但是一个变量定义在一个for/if里面，在他外部的模块却是可见的。

2、词法作用域

3、breaking the Chain with a closure

4、循环的closure
function f() {
var a = [];
var i;
for(i = 0; i < 3; i++) {
a[i] = function(){
return i;
}
}
return a;
}
var a = f();
>>>a[0]();
3
>>>a[1]();
3
>>>a[2]();
3

不是所期望的值，那是因为i在这里这里只是一个引用，最后都把i变为3.

说应该让他每次都创建一个变量：
function f(){
var a = [];
var i;
for(var i = 0; i < 3; i ++){
a[i] = (function (x) {return function(){return x;}})(i);
}
return a;
}

var a = f();
a[0]()
0
a[1]()
1
a[2]()
2


9、getter/setter

下面这个例子创建了一个get 和set,第一次掉用你创建的get 和 set function.假设，你有一个变量，包含了一个有特殊规则的变量。
你不想输出这个变量，因为你不想其他一些代码去alert 它的value.你可以添加两个function (get|set)来保护这个变量，在set里可以
包含一些逻辑去保护这个variable.
你有两个function