JavaScript高级特性详解-优快云博客

JS高级

1、与Java 不同的还有变量可以存放不同类型的值。

2、变量声明不是必须的，在用到的地方使用就可以

3、 5 种原始类型（primitivetype），即Undefined、Null、Boolean、Number和 String。

4、arguments 对象

arguments 对象

在函数代码中，使用特殊对象 arguments，开发者无需明确指出参数名，就能访问它们。

例如，在函数 sayHi() 中，第一个参数是 message。用 arguments[0] 也可以访问这个值，即第一个参数的值（第一个参数位于位置 0，第二个参数位于位置 1，依此类推）。

因此，无需明确命名参数，就可以重写函数：

function sayHi() {

 if (arguments[0] == "bye") {

 return;

 alert(arguments[0]);

检测参数个数

还可以用 arguments 对象检测函数的参数个数，引用属性arguments.length 即可。

下面的代码将输出每次调用函数使用的参数个数：

function howManyArgs() {

 alert(arguments.length);

howManyArgs("string", 45);

howManyArgs();

howManyArgs(12);

上面这段代码将依次显示 "2"、"0"和 "1"。

注释：与其他程序设计语言不同，ECMAScript 不会验证传递给函数的参数个数是否等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数（根据 Netscape 的文档，最多可接受 25 个），而不会引发任何错误。任何遗漏的参数都会以 undefined 传递给函数，多余的函数将忽略。

模拟函数重载

用 arguments 对象判断传递给函数的参数个数，即可模拟函数重载：

function doAdd() {

 if(arguments.length == 1) {

 alert(arguments[0] + 5);

 } else if(arguments.length == 2) {

 alert(arguments[0] + arguments[1]);

doAdd(10); //输出 "15"

doAdd(40, 20); //输出 "60"

当只有一个参数时，doAdd() 函数给参数加 5。如果有两个参数，则会把两个参数相加，返回它们的和。所以，doAdd(10) 输出的是 "15"，而 doAdd(40,20) 输出的是 "60"。

虽然不如重载那么好，不过已足以避开 ECMAScript 的这种限制。

4、闭包，指的是词法表示包括不被计算的变量的函数，也就是说，函数可以使用函数之外定义的变量。

简单的闭包实例

在 ECMAScript 中使用全局变量是一个简单的闭包实例。请思考下面这段代码：

var sMessage = "hello world";

function sayHelloWorld() {

 alert(sMessage);

sayHelloWorld();

5、使用预定义对象只是面向对象语言的能力的一部分，它真正强大之处在于能够创建自己专用的类和对象。

ECMAScript 拥有很多创建对象或类的方法。

工厂方式

原始的方式

因为对象的属性可以在对象创建后动态定义，所有许多开发者都在 JavaScript 最初引入时编写类似下面的代码：

var oCar = new Object;

oCar.color = "blue";

oCar.doors = 4;

oCar.mpg = 25;

oCar.showColor = function() {

 alert(this.color);

};

TIY

在上面的代码中，创建对象 car。然后给它设置几个属性：它的颜色是蓝色，有四个门，每加仑油可以跑 25 英里。最后一个属性实际上是指向函数的指针，意味着该属性是个方法。执行这段代码后，就可以使用对象 car。

不过这里有一个问题，就是可能需要创建多个 car 的实例。

解决方案：工厂方式

要解决该问题，开发者创造了能创建并返回特定类型的对象的工厂函数（factory function）。

例如，函数 createCar() 可用于封装前面列出的创建 car 对象的操作：

function createCar() {

 var oTempCar = new Object;

 oTempCar.color = "blue";

 oTempCar.doors = 4;

 oTempCar.mpg = 25;

 oTempCar.showColor = function() {

 alert(this.color);

};

 return oTempCar;

var oCar1 = createCar();

var oCar2 = createCar();

TIY

在这里，第一个例子中的所有代码都包含在 createCar() 函数中。此外，还有一行额外的代码，返回 car 对象（oTempCar）作为函数值。调用此函数，将创建新对象，并赋予它所有必要的属性，复制出一个我们在前面说明过的 car 对象。因此，通过这种方法，我们可以很容易地创建 car 对象的两个版本（oCar1 和 oCar2），它们的属性完全一样。

为函数传递参数

我们还可以修改 createCar() 函数，给它传递各个属性的默认值，而不是简单地赋予属性默认值：

function createCar(sColor,iDoors,iMpg) {

 var oTempCar = new Object;

 oTempCar.color = sColor;

 oTempCar.doors = iDoors;

 oTempCar.mpg = iMpg;

 oTempCar.showColor = function() {

 alert(this.color);

};

 return oTempCar;

var oCar1 = createCar("red",4,23);

var oCar2 = createCar("blue",3,25);

oCar1.showColor(); //输出 "red"

oCar2.showColor(); //输出 "blue"

TIY

给 createCar() 函数加上参数，即可为要创建的 car 对象的 color、doors 和 mpg 属性赋值。这使两个对象具有相同的属性，却有不同的属性值。

在工厂函数外定义对象的方法

虽然 ECMAScript 越来越正式化，但创建对象的方法却被置之不理，且其规范化至今还遭人反对。一部分是语义上的原因（它看起来不像使用带有构造函数 new 运算符那么正规），一部分是功能上的原因。功能原因在于用这种方式必须创建对象的方法。前面的例子中，每次调用函数 createCar()，都要创建新函数 showColor()，意味着每个对象都有自己的 showColor()版本。而事实上，每个对象都共享同一个函数。

有些开发者在工厂函数外定义对象的方法，然后通过属性指向该方法，从而避免这个问题：

function showColor() {

 alert(this.color);

function createCar(sColor,iDoors,iMpg) {

 var oTempCar = new Object;

 oTempCar.color = sColor;

 oTempCar.doors = iDoors;

 oTempCar.mpg = iMpg;

 oTempCar.showColor = showColor;

 return oTempCar;

var oCar1 = createCar("red",4,23);

var oCar2 = createCar("blue",3,25);

oCar1.showColor(); //输出 "red"

oCar2.showColor(); //输出 "blue"

TIY

在上面这段重写的代码中，在函数 createCar() 之前定义了函数 showColor()。在 createCar()内部，赋予对象一个指向已经存在的 showColor() 函数的指针。从功能上讲，这样解决了重复创建函数对象的问题；但是从语义上讲，该函数不太像是对象的方法。