Java Script 学习笔记

JS编程习惯类：

　　1. 命名

　　　　

著名的变量命名规则

只是由于变量名的语法正确，并不意味着就该使用它们。变量还应遵照如下某条著名的命名规则：

Camel 标记法

首字母是小写的，接下来的字母都以大写字符开头。例如：

var myTestValue = 0, mySecondValue = "hi";

Pascal 标记法

首字母是大写的，接下来的字母都以大写字符开头。例如：

var MyTestValue = 0, MySecondValue = "hi";

匈牙利类型标记法

在以 Pascal 标记法命名的变量前附加一个小写字母（或小写字母序列），说明该变量的类型。例如，i 表示整数，s 表示字符串，以下所示“

var iMyTestValue = 0, sMySecondValue = "hi";

本教程采用了这些前缀，以使示例代码更易阅读：

类型	前缀	示例
数组	a	aValues
布尔型	b	bFound
浮点型（数字）	f	fValue
函数	fn	fnMethod
整型（数字）	i	iValue
对象	o	oType
正则表达式	re	rePattern
字符串	s	sValue
变型（能够是任何类型）	v	vValue

 

2. 语言的关键字

break
case
catch
continue
default
delete
do
else
finally
for
function
if
in
instanceof
new
return
switch
this
throw
try
typeof
var
void
while
with

3. 语言的保留字

保留字在某种意思上是为未来的关键字而保留的单词。所以保留字不能被用做变量名或函数名。

ECMA-262 第三版中保留字的完整列表以下：

abstract
boolean
byte
char
class
const
debugger
double
enum
export
extends
final
float
goto
implements
import
int
interface
long
native
package
private
protected
public
short
static
super
synchronized
throws
transient
volatile

4. 字符字面量：

下面列出了 ECMAScript 的字符字面量：

字面量	含义
\n	换行
\t	制表符
\b	空格
\r	回车
\f	换页符
\\	反斜杠
\'	单引号
\"	双引号
\0nnn	八进制代码 nnn 表示的字符（n 是 0 到 7 中的一个八进制数字）
\xnn	十六进制代码 nn 表示的字符（n 是 0 到 F 中的一个十六进制数字）
\unnnn	十六进制代码 nnnn 表示的 Unicode 字符（n 是 0 到 F 中的一个十六进制数字）

5. Java script中推荐的构造对象的方式.

　　

混合的构造函数/原型方式（最流行之一）

联合使用构造函数和原型方式，就可像用其余程序设计语言同样建立对象。这种概念很是简单，即用构造函数定义对象的全部非函数属性，用原型方式定义对象的函数属性（方法）。结果是，全部函数都只建立一次，而每一个对象都具备本身的对象属性实例。

咱们重写了前面的例子，代码以下：

   //构造函数内部只声明属性。

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");
}

//外部经过成员函数复制给原型。
Car.prototype.showColor = function() {
  alert(this.color);
};

var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);

oCar1.drivers.push("Bill");

alert(oCar1.drivers);	//输出 "Mike,John,Bill"
alert(oCar2.drivers);	//输出 "Mike,John"

    针对5的构造方式进行的改良，目的仅是让代码好看点：

   动态原型方法 （第二流行的方法）

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");
  
  if () {
    Car.prototype.showColor = function() {
      alert(this.color);
    };
	
    
  }
}

6. Java Script 类的继承几种流行方式typeof Car._initialized == "undefined"Car._initialized = true;

    对象冒充

function ClassB(sColor, sName) {
    this.newMethod = ClassA;
    this.newMethod(sColor);
    delete this.newMethod;

    this.name = sName;
    this.sayName = function () {
        alert(this.name);
    };
}

对象冒充能够实现多重继承

function ClassZ() {
    this.newMethod = ClassX;
    this.newMethod();
    delete this.newMethod;

    this.newMethod = ClassY;
    this.newMethod();
    delete this.newMethod;
}

这里存在一个弊端，若是存在两个类 ClassX 和 ClassY 具备同名的属性或方法，ClassY 具备高优先级。由于它从后面的类继承。除这点小问题以外，用对象冒充实现多重继承机制垂手可得。

因为这种继承方法的流行，ECMAScript 的第三版为 Function 对象加入了两个方法，即 call() 和 apply()。

//用 call
function ClassB(sColor, sName) {
    //this.newMethod = ClassA;
    //this.newMethod(color);
    //delete this.newMethod;
    ClassA.call(this, sColor);

    this.name = sName;
    this.sayName = function () {
        alert(this.name);
    };
}

//用apply()

function sayColor(sPrefix,sSuffix) {
    alert(sPrefix + this.color + sSuffix);
};

var obj = new Object();
obj.color = "blue";

sayColor.apply(obj, new Array("The color is ", "a very nice color indeed."));

原型链（prototype chaining）

原型链（prototype chaining）

继承这种形式在 ECMAScript 中本来是用于原型链的。上一章介绍了定义类的原型方式。原型链扩展了这种方式，以一种有趣的方式实现继承机制。

在上一章学过，prototype 对象是个模板，要实例化的对象都以这个模板为基础。总而言之，prototype 对象的任何属性和方法都被传递给那个类的全部实例。原型链利用这种功能来实现继承机制。

若是用原型方式重定义前面例子中的类，它们将变为下列形式：

function ClassA() {
}

ClassA.prototype.color = "blue";
ClassA.prototype.sayColor = function () {
    alert(this.color);
};

function ClassB() {
}


ClassB.prototype = new ClassA();

原型方式的神奇之处在于突出显示的蓝色代码行。这里，把 ClassB 的 prototype 属性设置成 ClassA 的实例。这颇有意思，由于想要 ClassA 的全部属性和方法，但又不想逐个将它们 ClassB 的 prototype 属性。还有比把 ClassA 的实例赋予 prototype 属性更好的方法吗？

注意：调用 ClassA 的构造函数，没有给它传递参数。这在原型链中是标准作法。要确保构造函数没有任何参数。

与对象冒充类似，子类的全部属性和方法都必须出如今 prototype 属性被赋值后，由于在它以前赋值的全部方法都会被删除。为何？由于 prototype 属性被替换成了新对象，添加了新方法的原始对象将被销毁。因此，为 ClassB 类添加 name 属性和 sayName() 方法的代码以下：

function ClassB() {
}

ClassB.prototype = new ClassA();

ClassB.prototype.name = "";
ClassB.prototype.sayName = function () {
    alert(this.name);
};

可经过运行下面的例子测试这段代码：

var objA = new ClassA();
var objB = new ClassB();
objA.color = "blue";
objB.color = "red";
objB.name = "John";
objA.sayColor();
objB.sayColor();
objB.sayName();

TIY

此外，在原型链中，instanceof 运算符的运行方式也很独特。对 ClassB 的全部实例，instanceof 为 ClassA 和 ClassB 都返回 true。例如：

var objB = new ClassB();
alert(objB instanceof ClassA);	//输出 "true"
alert(objB instanceof ClassB);	//输出 "true"

在 ECMAScript 的弱类型世界中，这是极其有用的工具，不过使用对象冒充时不能使用它。

原型链的弊端是不支持多重继承。记住，原型链会用另外一类型的对象重写类的 prototype 属性。

混合方式

这种继承方式使用构造函数定义类，并不是使用任何原型。对象冒充的主要问题是必须使用构造函数方式，这不是最好的选择。不过若是使用原型链，就没法使用带参数的构造函数了。开发者如何选择呢？答案很简单，二者都用。

在前一章，咱们曾经讲解过建立类的最好方式是用构造函数定义属性，用原型定义方法。这种方式一样适用于继承机制，用对象冒充继承构造函数的属性，用原型链继承 prototype 对象的方法。用这两种方式重写前面的例子，代码以下：

function ClassA(sColor) {
    this.color = sColor;
}

ClassA.prototype.sayColor = function () {
    alert(this.color);
};

function ClassB(sColor, sName) {
    
    this.name = sName;
}



ClassB.prototype.sayName = function () {
    alert(this.name);
};
ClassA.call(this, sColor);ClassB.prototype = new ClassA();

在此例子中，继承机制由两行突出显示的蓝色代码实现。在第一行突出显示的代码中，在 ClassB 构造函数中，用对象冒充继承 ClassA 类的 sColor 属性。在第二行突出显示的代码中，用原型链继承 ClassA 类的方法。因为这种混合方式使用了原型链，因此 instanceof 运算符仍能正确运行。

下面的例子测试了这段代码：

var objA = new ClassA("blue");
var objB = new ClassB("red", "John");
objA.sayColor();	//输出 "blue"
objB.sayColor();	//输出 "red"
objB.sayName();	//输出 "John"