javascript 面向对象编程（object oriented programing)

一 、面向对象编程 ----通过抽象创建一个真实世界的模型的一种编程规范。他的一些技术来源于以前的一些规范。包含 模块、多太、封装 现在好多语言都支持面向对象编程。
面向对象编程 是一些有关对象的聚集形成的软件，它对立与函数集 或者 计算机的指令集。
在OOP中，能够能接收消息，处理数据，将消息发送到其它的目的。
每个对象都可以被看作是一个独立的小机器带有明显的作用或责任。面向对象编程期望促进程序的灵活性和可维护性并且广泛的应用在大型软件工程中。
    凭借其强大的模块化，面向对象编码被期望能更简单的开发和容易理解，再通过它自己来分析编码 理解更复杂的情况 和较少模块化编程的方法。
二、
Variables
variables 被用来存储数据，用它来代替一些代码中出现的数据，会非常方便。如用 PI 来代替 3.14159253589793。存储数据的变量后面会摆改变，因此获取到的值一般是最终操作过的结果。
在使用变量时一般需要两步：
1、声明变量。
2、初始它，然后其他，获取它的值。
你可以像这样声明：
var a;
var thisIsAVariable;
var _and_this_too;
var mix2three;
你可以使用任意字母、数字、和下划线但是数字不能开头。 如：var 2_three4five； //this is a invalid.
对于变量的初始化有两种途径：
1、在定义时，就初始化.如 var a = 1;
2、可以先声明一些变量，用逗号隔开，如： var a1 , a2, a3 = 3, a4 = 4, a5;

variables 区分大小写
如:
   var case_matters = 'lower';
   var CASE_MATTERS = 'upper';
是两个不一样的变量。

三、运算符 operators
运算符操作一个或两个值（变量），执行一次运算，返回一个值。
例如：
1 + 2
+ 是运算符。

>>> var a = 1;
>>> var b = 2;
>>> a + 1
2
>>> b + 2
4
>>> var c = a + b;
>>> c;
基本的运算符包括 （ +  - * / %  ++ --)

var a = 1;
也是一次运算，赋值运算， = 本身也是一个运算符。
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 是一个特殊的
当你再试图做一次运算时，假设是数值运算，但是运算失败就会得到一个NuN，如：用数字 10 × "f" 会得到一个NaN，显然 "f" 不是一个有效的乘数。
NaN 具有传染性，所以在一次算术运算中如果出现了一个NaN那么整个运算就是会变成一种浪费，会得到一个NaN。
8、Strings
string 是一段连续的字符被当作文本使用。任何一处于单引号或者双引号之间的值都是一个string
如 var s = "String";
>>> typeof s
"string"

一个数在如果在string的上下文里的话，那么它的基本类型将是”string“
>>> var s = "12";
>>> typeof s;
"string"
如果在引号里没有任何东西的的话，那么它的类型也会是一个”string"
>>>var s = "";
typeof s
"string"
如果两个string 在做加法运算时，他是对两个字符做了链接操作。
如：
>>>var s1 = "one", s2 = "two",var s = s1 + s2;
"onetwo"
>> typeof s
"string"
9、string  转换
当你使用数字字符串进行一次算术运算时，会被转换成数字类型进行运算，除了加法。因为Java在运算时会有歧义。如：
>>> var s1 = "1"; var s2 = "4"; var s = s1*s2;
>>> s
4
>>> typeof s
"number"
可以通过乘法这种懒办法将一个数字型字符串转换成数字number 类型。
如 >>>var num = "100";
>>>var num2 = num*1;
100
typeof num2
"number"

也可以通过加法把number 类型转换成字符串类型。通过加一个空字符串。var num1 = 100;  typeof num1; "number" var num = "" +num1; typeof num1; "string"
如果说转换是失败的那么你将会得到一个NaN
如:>>> var d = '101 dalmatians';
>>>d*1
NaN

10、 特殊的strings
\ 是一个转义符
\' ------------------- '
\" ------------------- "
\\ ------------------- \
\n -------------------行结束符
\r -------------------换行符
\t -------------------表示一个tab
\u ------------------- 紧跟着的字符可以使用 unicode 编码


11、Boolean

Boolean 有两个值 ture 和 false，不在引号（quote)之间来使用。
>>> var b = true;
>>> typeof b
"boolean"
>>> var b = "true";
>>> typeof "string"


12、逻辑预算符 (Logical operators)
有三种运算符，返回结果是Boolean型。
a) !  逻辑非（negation)
b) && 逻辑与
c) || 逻辑或
在某些场景里面，如果一件事情不是false 那么他就是true 的话，就可以使用 ! (逻辑非）
logical ! operator
>>> var a = !true;
>>> a
false
如果是两次非运算,将得到最初的值
如: var a = ！！true;   输出结果为 true

如果你对一个 non-boolean 的值进行逻辑非运算将会得到一个boolean的　false
如： >>> var b = "one";
>>> ！b
false

在上面例子的基础上 "one" 会被转换成 boolean 的true ,然后再求非,所以结果的方面应该是true。

大多数值会把转换成true 来理解，exception时会把转换成false 来理解。
a) 空字符串 ""
b) null
c) undefined
d) 0
e) NaN
f) false
这六个值有时会当作falsy 来参考然而剩下的其他值会被当作truthy 来参考。包括例子中的 ”0”  “ ” “false"

逻辑与和逻辑或
当两个操作数进 and 时返回true时，那么两个操作数必须都是true ,当进行逻辑 or 时 ，return true 时，两个操作数至少有一个是true
>>> var b1 = true; var b2 = false;
>>> b1 || b2
true
>>> b1 && b2
false

13、逻辑操作符的优先级（logical operators precedence)

在逻辑运算中
！（highest precedence）的运算优先级是最高级的优先级。
&& （higher precedence ）接下来是与运算符
|| (high precedence) ||是最低的运算等级

14、懒散赋值 （lazy eveluation)
有一些逻辑运算，它后面还有其他的逻辑运算，但是根据前面的逻辑运算得到的结果已经非常清晰明了，最后的运算将不会被执行，因为他不能影响到最终的
结果。如：
>>> true || true || false || false || true
result: true

所有的逻辑或运算的运算优先级都是一样的，所以如果至少有一个操作数是true 的话，那么最终结果将是true。根据第一个操作数的值，可以很容易得到
最终结果是true。javascript engine 通过对代码的评估，来决定懒运算，从而提高效率，摒弃掉不必要的计算。
你可以进行核实，在console 下
如：>>> var b = 5;
>>> true || ( b = 6)
true
>>>b
5
>>> true && ( b = 6)
>>>b
6

这个测试得到一个有趣的行为。如果javascript 在进行逻辑运算时，如果碰到一个非boolean 型的表达式时，如果这个表达式被执行的话
那么这个时候这个非boolean 型表达式的结果将会被做结果返回。

你应该提防或者避免这些东西，因为它会使代码在理解上增加一些难度。当你在不知道一个variable被定义的情况下，你可以使用它去定义variable。
在下面的例子里，如果这个变量被定义的话，那么他的值将会被保存，如果没有被定义那么它的值将会被初始化为 10.
>>> var myNumber = myNumber || 10;
这个看上去很简单和优雅，但是这个并不是很十分的安全，如果我们的myNumber 在之前被定义了刚好被初始化为 0 (或者是任意的6个falsty值之一），那么这个
代码将不能完成它实际上要完成的任务。


15、comparison 比较
== 比较两个操作数的值是否相等 
1 == 1 true
1 == 2 false
1 == '1' true

===  进行值比较和类型比较
1 === ‘1’ false
1 === 1 true

!= 两个操作数是否相等与类型无关。
!== 两个操作数是否相等与类型有关关。

> 左边的操作数大于右边的 操作数
>= 左边的操作数大于等于右边的 操作数

>

>=
跟上面相反的操作
*但是有一个有趣的比较,NaN 不能与任何事物，包括自己
>>> NaN == NaN
false

16、Undefined 、 null
如果你要获得一个未定义的变量或者未分配值变量的话那么就会得到一个undefined,如果你声明一个变量，没有初始化它的话，javascript 会初始化一个
undefined 的值给它。如果你尝试获得一个未定义的变量的话就会得到一个错误的信息。
>>> foo
foo is not defined.
如果你typeof 一个未定义的变量的话，你会得到一个"undefined"
null 是一个值，有其他的的用途在javascript的后台被分配，它仅仅只能在你代码里使用。
>>> var somevar = null;
>>>somevar
null
>>>typeof somevar
"object"
尽管 null 和 undefined 有一点不同，但是有时后也是非常重要的。如：你试图再进行一次算术运算的话，你可能会有不同的结果。
：>>> var i = 1 + undefined; i;
NaN
>>> var i = 1 + null; i;
1
这是因为根据null 和 undefined 的使用方式不同他们将会被转换成相应的原始数据类型如下面的例子
>>> 1 × undefined
NaN
>>> 1* null
0
>>>!!undefined
false
>>> !!null
false

>>>"" + null
"null"
>>> "" + undefined
"undefined"


17、数组 （Arrays)
定义一个空的数组变量，可以使用不在方括号内放任何东西来定义。如： var a = []; typeof a ; "object"
typeof 后return 了一个object 虽然看起来更接近Object
定义 一个 有三个元素的数组 如 ： var a = [1, 2, 3];
>>> a
[1, 2, 3]
所以数组就是一个简单数值列表，可以用一个variable 来存储一个value ，用一个array 来存储一些value作为元素的数组，那我们如何访问数组中的element了。
element 被包含在array 里将会被一些从0开始连续的数字索引起来。第一个element 的索引是 0 第二个是1,以此类推。
可以通过方括号内写索引的方式访问数组内部的元素。如 a[0]可以获得第一个元素
>>> a[0]
1
18、添加和更新数组的元素。
使用索引可以更新数组中的元素。如可以>>> a[2] = "three"; >>>a           输出：[1, 2, "three"]
>>> a[3] = "four"
>>>a
[1, 2, "three", "four"]
如果添加的新元素，是离数组索引的位置比较远的话，中间空出的元素将会以“undefined"来填充。如：
>>> var a= [1,2,3]
>>> var [4] = "new";
>>>a
[1,2,3,"undefined",4]

19、数组的数组
一个数组可以包含任意的数据类型
>>> var a = [1, "two", false, null, undefined]
>>>a
[1, "two", false, null, undefined]
>>>a[5] = [1,2,3]
>>>a
[1, "two", false, null, undefined,[1,2,3]]

一个数组里面有两个元素，每个元素都是一个数组的话：
>>> var a = [[1,2,3],[4,5,6]];
>>>a
[[1,2,3],[4,5,6]]
>>>a[0]
[1,2,3]
访问嵌套数组中的元素，只需要在提及到的数组中再使用索引就可以访问到了,如：

>>>a[0][0]
1

可以使用数组的来划分string ，通过标号来访问string 内部的字符.
如： var s = "one";
>>>s[0]
"o"
>>>s[1]
"n"
>>>s[2]
”e"

注意*******
1）数组可以存储数据，
2） 数组可以包含索引和元素
3）索引从0开始循环索引的元素。
4）可以通过索引访问数组的元素
5）一个数组可以包含任意数据类型也可以包含数组


20 conditions and loop  条件和 循环

if 条件
switch 语句
wilhe, do-while, for, for-in 循环。


21、模块
但我们进行一次条件的选择或者循环时就会形成模块。
一个阻塞的代码，由0或多个表达式组成再附加上花括号（curly brackets)。
{
var a = 0;
var b = 3;
}

你可以用这种嵌套来包含一些不太确定的地方

建议：
1)每行结尾一个分号，尽管当每一行一个表达式时，分号是可选的，最好还是养成写上的习惯，
2）在花括号里使用缩进，有的人使用一个tab有的人使用4个空格，这些都不重要，只要你在使用时一致就行了，例如在外层你使用的是两个空格，
在第一次嵌套里 你使用的是4个空格缩进，在最里层你使用的是6个空格缩进。
3）花括号的使用，虽然在一个模块里如果只有一个表达式，可以不使用花括号，但是为了代码的可读性和可维护性，应该养成写他的习惯。


22、if condition

var result = '';
if （a>2){
result = "a is gerater than 2";
}
一个if 语句比较的条件在圆括号里，满足if 条件的模块代码,在圆括号里的条件，总是返回一个BooLean型的值,肯能会包含如下:
1)一个逻辑运算 ！&& or ||
2)比较表达式 === !=  >  and so on.
3)任何一个变量或者值都会被转成一个boolean 型。

可能会有一个else 作为If的一部分，这个else语句是跟在if执行模块的后面，当if 条件执行为false时会执行。
if (a>2){
result = 'a is greater than 2';
}else{
result = 'a is not greater than 2';
}
在if 和else 之间如果还有其他可能可以这样：
if ( a < -2 || a > 2){
result = 'a is not between -2 and 2';
}else if (a == 0 && b == 0){
result = 'both a and b are zero';
}else if( a === b){
result = 'a and b is equal';
}else{
result = 'I give up';
}
你可以嵌入任意的条件判断到新的条件模块里去。


23、检查一个变量是否被定义

检查一个变量是否被定义我们一般会放在if 里去判断，这是一个最省事的方法，如: if (somevar){...},但是这不是最好的方法。
我们来测试一下这个方法。当我们调用一个变量如果他存在，我们会得到一个"yes"
如：var result = '';
if (somevar) { result = 'yes';}
会有一个警告:'somevar is undefined';
>>>result
""
这段代码显然是正确的，因为result 的值没有变成yes，但是首先这段代码生成了警告：’somevar is undefined' javascript 不知道你这段代码要干什么，
第二不能仅仅因为得到一个false就证明somevar 是未定义的，它可能是被定义但是包含falsy 或 0;
比较好的办法用typeof 检查 variable 的是不是 undefined
>>> if (typeof somevar !== "undefined") { result = 'yes';}
>>> result;
""
>>>var somevar = undefined;
>>> if (typeof somevar !== "undefined") { result = 'yes';}
>>> result;
""

如果一个变量定义并且初始化一个除了undefined 的任意vlue ，那么它的typeof 将不在是undefined.
如：
>>> somevar = 123;
>>> if (typeof somevar !== "undefined"){result = 'yes';}
>>> result;
"yes"

24、两者则一的if句法（alternative if syntax)(
当你有一个简单的if条件我们就可以考虑这种两者则一的表达式。如：
var a = 1;
var result = '';
if (a === 1) {
result = "a is one";
} else {
result = "a is not one";
}

这个if 条件可以被表达为这样：
var reuslt = (a === 1？ 'a is one' : 'a is not one");
你可以用这个句法去替代一些简单条件判断，要小心不要滥用这个句法，因为它会使你的代码比较难读懂。

25 switch
如果发现你使用if条件时，有大量else if parts 你就该考虑用 switch 了。
var a = '1';
var result = '';
switch (a) {
case 1:
result = 'Number 1';
break;
case '1':
result = 'String 1';
break;
default:
result = 'I don\'t know';
break;
}
result;

1）一个switch 语句
2)一些表达试在圆括号里，最常见的是一个variable,但是可以是任意的一个value
3)一个case和数字再附加一个花括号.
4)每一个case语句后面都跟了一个数,switch 语句得到的结果将会和这些数进行比较，如果是true 的话那么就会执行case语句冒号后面的模块。
5）在case模块的最后的break语句是可选的，如果case中的break没有被设置，那么将会进入下一个case 继续执行
6）default 语句是可选的，如果整个模块都没有被执行，那么才会执行default.
换句话说switch在程序里是一步一部执行的，
如下：
1）预测一个switch可以分析圆括号里面的表达式，并记录它，
2）然后再看第一个case,比较那个被分析出来的值和它进行比较。
3）如果比较后得到一个true，就执行case 模块的代码
4）如果执行了case模块的代码后有break,那么就结束，推出switch。
5）如果没有break或者第二步返回了一个false,那么就进入下一个case语句
6）如果都没有推出switch ,那么最后就进入default 语句。
   *注意*
   * case 行的缩进，和紧跟着的代码缩进。
   *不要忘记break,有时候你可能会故意省略掉break,但是那时比较罕见的，这种一般要说明一下，因为看起来像是，偶然遗忘的。从另一方面说，
      你想遗忘的case的编码和另外的case的编码是相同的。只是很好的，但是不要改变了规则，这个紧跟着的case后面的break不要忘记。
   *使用default 他可能会让你在没有匹配的case的情况下，确保你会有一个有意义的结果。


26 循环 （loop）
if-else、switch 允许你的代码选择不同的路经，作为你在一个交叉路口的决定，依靠条件。循环则从另一方面说，让你的代码重复执行，最后在在合并结果，
依靠对条件的检测来进行迭代。
程序的执行从A - B，在这些点之间，的一个延伸，通过对条件C的检测，C的检测告诉你，如果进入一个循环，就可以进行迭代了，然后可以再次进行，
看是否需要其他的迭代，最终按照这种方式到B。
无线循环，当条件始终是true时，你的代码将永远循环，当然这是一个错误的逻辑。
在javascript 中有四种循环.
1)while loop
2)do-while loop
3) for loop
4)for-in loop

while loop:
while loop是最简单的一个循环像这样的 :
var i = 0;
while ( i < 10){
i++;
}
while 循环的条件在圆括号里，在花括号里是模块代码。条件是true的话，那么这个模块的代码将会被反复执行。

do-while loop:

do-while loop是while loop的一个微小的变种，
var i = 0;
do{
i++;
}while ( i < 10)

do 后面跟着模块代码，和条件。这就是说，模块里的代码至少被执行一次。
在上上个例子里，如果 i 被初始化为 11 那么他将一次都不执行，但是do-while 将执行一次。

for loops

for 循环是用的最广泛的循环，添加一个条件C在条件模块里：
1）initalization  一些代码被执行你刚好进入循环。
2）increment --- 递增

for loop 被用的最广泛的原因：
1）在初始化部分定义了变量 ，最常用的是i ,var i = 0;
2)在条件部分你可以跟操作数的值进行比较， i < 100
3)在递增部分，你可以增加一个1 ，i++
如：
var punisment = '';
for (var i = 0; i < 10; i++){
punisment += 'I will never do this again';
}

这三个可能包含几乎所有的表达式，你可以重写上面的例子
for (var i = 0, punisment = ''; i < 10; i++){
punisment += 'I will never do this again';
}

也可以移除掉花括号内部的代码放到递增的部分位置如：
for (var i = 0, punishment = '';
i < 100;
i++, punishment += 'I will never do this again, ')
{
// nothing.
}

这三个部分都是可选的
如：for(;;){}

for loop 可以被嵌套进其他的循环里，让我们来打印一个10行10列的矩阵。
用i来表示行，j表示列
var res = '\n';
for(var i = 0; i < 10; i++) {
for(var j = 0; j < 10; j++) {
res += '* ';
}
res+= '\n';
}
让我们考虑，打印一个雪花的样子。
var res = '\n', i, j;
for(i = 1; i <= 7; i++) {
for(j = 1; j <= 15; j++) {
res += (i * j) % 8 ? ' ' : '*';
}
res+= '\n';
}
"      *      
   *   *   *  
       *      
* * * * * * *
       *      
   *   *   *  
       *      
"

for-in loop

for-in 循环被用来迭代一个数组里的元素，
var a = [? ? ? ? ? ? 'a', 'b', 'c', 'x', 'y', 'z'];
var result = '\n';
for (var i in a) {
result += 'index: ' + i + ', value: ' + a[i] + '\n';
}

27.注释 comments
写在代码中，这些将会被javascript 引擎给忽略掉，不会影响程序。但是他可能是无价，当你一个月后看你的代码。
有两种注释：
//标记这一行为注释
/*   .... */ 以 /* 开始 以 */ 结束，在这之间的代码都是注释。
这些甚至在项目中可以被抽取取出来（JSDoc)在你的代码中成为有用的文档。

三 function
1、




variable 的范围

一个非常重要的知识点，如果在function 里定义变量如果没有使用var 生命variable,那么这个变量将会自动被转换成全局变量，如
>>>function f(){ local = 2;}
>>>f();
>>>local
2

发生了什么了？这个function f 包含了一个变量 local, 在f()被调用之前，variable 是不存在的，当你第一次调用的时候，local 被创建为全局变量，然后
你就可以在外部访问它了。

********Tips×××××××××××××××××
1）减少全局数值变量，假设有俩个人工作在不同的function 但在同一个script 中，他们俩要是决定用同一个名字作为全局变量，那么就可能得到未知
的结果，这种bug 是 hard-to-find bugs.
2)定义变量时总是使用var 语句。

一个很有趣的例子,局部变量影响全局变量的例子
var a = 123;
function f() {
alert(a);
var a = 1;
alert(a);
}
f（）；
你可能期望第一个alert() 弹出123，第二个是 1 但是不对的，第一个将是 “undefined"，这是因为内部定义的变量比外部定义的全局变量级别高。所以
内部的a重写外部任意相同名字的变量，同时第一个alert的a是没有定义，但是它仍然存在当前内存中。

4、function 是 Data