JavaScript(六) 2018-07-26

本篇，我们讲一讲 JavaScript 中的重要对象以及常用方法。

Function 类型概述

---

ECMAScript 中的函数实际上是对象，每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。函数通常是使用函数声明语法定义的，如下:

function sum (num1, num2) {
    return num1 + num2;
}

这与下面使用函数表达式定义函数的方式几乎相差无几:

var sum = function (num1, num2) {
    return num1 + num2;
};

以上代码定义了变量 sum 并将其初始化为一个函数。
注意: function 关键字后面没有函数名，这是因为在使用函数表达式定义函数时，没有必要使用函数名，我们是通过变量 sum 来引用该函数。另外，还要注意函数末尾有一个分号，就像声明其他变量时一样。
最后一种定义函数的方式是使用 Function 构造函数。Function 构造函数可以接收任意数量的参数，但最后一个参数始终都被看成是函数体，而前面的参数则枚举出了新函数的参数。如下:

var sum = new Function("num1", "num2", "return num1 + num2");  // 不推荐

这种语法会导致解析两次代码(第一次是解析常规 ECMAScript 代码，第二次是解析传入构造函数中的字符串)，从而影响性能。

由于函数名仅仅是指向函数的指针，因此函数名与包含对象指针的其他变量没有什么不同。换句话说，一个函数可能会有多个名字，如下:

function sum (num1, num2) {
    return num1 + num2;
}
alert(sum(10, 10));        //20

var anotherSum = sum;
alert(anotherSum(10, 10)); //20

sum = null;
alert(anotherSum(10, 10)); //20

没有重载

---

之前我们说过 ECMAScript 没有重载，因为函数也是对象。

function addSomeNumber(num) {
    return num + 100;
}

function addSomeNumber(num) {
    return num + 200;
}

var result = addSomeNumber(100); //300

这个例子中声明了两个同名函数，而结果则是后面的函数覆盖了前面的函数。以上代码实际上与下面的代码没有什么区别。

var addSomeNumber = function (num) {
    return num + 100;
};

addSomeNumber = function (num) {
    return num + 200;
};

var result = addSomeNumber(100); //300

函数声明与函数表达式

---

实际上，解析器在向执行环境中加载数据时，对函数声明和函数表达式是区别对待的。解析器会率先读取函数声明，并使其在执行任何代码之前可用(可以访问); 至于函数表达式，则必须等到解析器执行到它所在的代码行，才会真正被解释执行。

alert(sum(10, 10));
function sum (num1, num2) {
    return num1 + num2;
}

以上代码完全可以正常运行。在代码开始执行之前，解析器就已经通过一个名为函数声明提升(function declaration hoisting)的过程，读取并将函数声明添加到执行环境中。对代码求值时，JavaScript 引擎在第一遍会声明函数并将它们放到源代码树的顶部。所以，即使声明函数的代码在调用它的代码后面，JavaScript 引擎也能把函数声明提升到顶部。
把上面的函数声明改为等价的函数表达式，就会在执行期间导致错误。

alert(sum(10, 10));
var sum = function (num1, num2) {
    return num1 + num2;
};

原因在于函数位于一个初始化语句中，而不是一个函数声明。换句话说，在执行到函数所在的语句之前，变量 sum 中不会保存有对函数的引用。

作为值的函数

---

因为 ECMAScript 中的函数名本身就是变量，所以函数也可以作为值来使用。也就是说，不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。

function callSomeFunction(someFunction, someArgument) {
    return someFunction(someArgument);
}
function add10(num) {
    return num + 10;
}

var result1 = callSomeFunction(add10, 10);
alert(result1);   //20

函数内部属性

---

在函数内部，有两个特殊的对象: arguments 和 this。其中，arguments 之前说过，它是一个类数组对象，包含着传入函数中的所有参数。这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。

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

我们可以使用 callee 消除与函数名的耦合。

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

这样，无论引用函数时使用的是什么名字，都可以保证正常完成递归调用。例如:

var trueFactorial = factorial;

factorial = function() {
    return 0;
};

alert(trueFactorial(5));     //120
alert(factorial(5));         //0

函数内部的另一个特殊对象是 this，其行为与 Java 和 C# 中的 this 大致类似。换句话说，this 引用的是函数据以执行的环境对象——或者也可以说是 this 值(当在网页的全局作用域中调用函数时，this 对象引用的就是 window)。

window.color = "red";
var o = { color: "blue" };

function sayColor() {
    alert(this.color);
}

sayColor();     //"red"

o.sayColor = sayColor;
o.sayColor();   //"blue"

上面这个函数 sayColor() 是在全局作用域中定义的，它引用了 this 对象。由于在调用函数之前，this 的值并不确定，因此 this 可能会在代码执行过程中引用不同的对象。当在全局作用域中调用 sayColor() 时，this 引用的是全局对象 window，换句话说，对 this.color 求值会转换成对 window.color 求值，于是结果就返回了 “red”。而当把这个函数赋给对象 o 并调用 o.sayColor() 时，this 引用的是对象 o，因此对 this.color 求值会转换成对 o.color 求值，结果就返回了 “blue”。
注意: 函数的名字仅仅是一个包含指针的变量而已。因此，即使是在不同的环境中执行，全局的 sayColor() 函数与 o.sayColor() 指向的仍然是同一个函数。

ECMAScript 5 也规范化了另一个函数对象的属性: caller。这个属性中保存着调用当前函数的函数的引用，如果是在全局作用域中调用当前函数，它的值为 null。

function outer() {
    inner(); 
}

function inner() {
    alert(inner.caller);
}

outer();

以上代码会导致警告框中显示 outer() 函数的源代码。因为 outer() 调用了 inter()，所以 inner.caller 就指向 outer()。
当函数在严格模式下运行时，访问 arguments.callee 会导致错误。ECMAScript 5 还定义了 arguments.caller 属性，但在严格模式下访问它也会导致错误，而在非严格模式下这个属性始终是 undefined。定义这个属性是为了分清 arguments.caller 和函数的 caller 属性。

函数属性和方法

---

ECMAScript 中的函数是对象，因此函数也有属性和方法。每个函数都包含两个属性: length 和 prototype。其中，length 属性表示函数希望接收的命名参数的个数:

function sayName(name) {
    alert(name);
}      

function sum(num1, num2) {
    return num1 + num2;
}

function sayHi() {
    alert("hi");
}

alert(sayName.length);      //1
alert(sum.length);          //2
alert(sayHi.length);        //0

对于 ECMAScript 中的引用类型而言，prototype 是保存它们所有实例方法的真正所在。换句话说，诸如 toString() 和 valueOf() 等方法实际上都保存在 prototype 名下，只不过是通过各自对象的实例访问罢了。在创建自定义引用类型以及实现继承时，prototype 属性的作用是极为重要的。在 ECMAScript 5中， prototype 属性是不可枚举的，因此使用 for-in 无法发现。
每个函数都包含两个非继承而来的方法: apply() 和 call()。这两个方法的用途都是在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。
首先，apply() 方法接收两个参数: 一个是在其中运行函数的作用域，另一个是参数数组。其中，第二个参数可以是 Array 的实例，也可以是 arguments 对象。

function sum(num1, num2) {
    return num1 + num2;
}

function callSum1(num1, num2) {
    return sum.apply(this, arguments);        // 传入arguments对象
}

function callSum2(num1, num2) {
    return sum.apply(this, [num1, num2]);    // 传入数组
}

alert(callSum1(10, 10));   //20
alert(callSum2(10, 10));   //20

在严格模式下，未指定环境对象而调用函数，则 this 值不会转型为 window。除非明确把函数添加到某个对象或者调用 apply() 或 call()，否则 this 值将是 undefined。
call() 方法与 apply() 方法的作用相同，它们的区别仅在于接收参数的方式不同。对于 call() 方法而言，第一个参数是 this 值没有变化，变化的是其余参数都直接传递给函数。换句话说，在使用 call() 方法时，传递给函数的参数必须逐个列举出来:

function sum(num1, num2) {
    return num1 + num2;
}

function callSum(num1, num2) {
    return sum.call(this, num1, num2);
}

alert(callSum(10, 10));   //20

决定使用 apply() 还是 call()，完全取决于你采取哪种给函数传递参数的方式最方便。如果你打算直接传入 arguments 对象，或者包含函数中先接收到的也是一个数组，那么使用 apply() 肯定更方便，否则，选择 call() 可能更合适。

事实上，传递参数并非 apply() 和 call() 真正的用武之地，它们真正强大的地方是能够扩充函数赖以运行的作用域。

window.color = "red";
var o = { color: "blue" };

function sayColor(){
    alert(this.color);
}

sayColor();                //red

sayColor.call(this);       //red
sayColor.call(window);     //red
sayColor.call(o);          //blue

使用 call()(或 apply())来扩充作用域的最大好处，就是对象不需要与方法有任何耦合关系。在前面例子的第一个版本中，我们是先将 sayColor() 函数放到了对象 o 中，然后再通过 o 来调用它的，而在这里重写的例子中，就不需要先前那个多余的步骤了。
ECMAScript 5 还定义了一个方法: bind()。这个方法会创建一个函数的实例，其 this 值会被绑定到传给 bind() 函数的值。

window.color = "red";
var o = { color: "blue" };

function sayColor(){
    alert(this.color);
} 
var objectSayColor = sayColor.bind(o);
objectSayColor();    //blue

每个函数继承的 toLocaleString()、toString() 和 valueOf() 方法始终都返回函数的代码，返回代码的格式则因浏览器而异。

基本包装类型概述

---

为了便于操作基本类型值，ECMAScript 还提供了3个特殊的引用类型: Boolean、Number 和 String。
实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，从而让我们能够调用一些方法来操作这些数据。如:

var s1 = "some text";
var s2 = s1.substring(2);

这个例子中的变量 s1 包含一个字符串，字符串当然是基本类型值。而下一行调用了 s1 的 substring() 方法，并将返回的结果保存在了 s2 中。我们知道，基本类型值不是对象，因而从逻辑上讲它们不应该有方法。
其实，为了让我们实现这种直观的操作，后台已经自动完成了一系列的处理。当第二行代码访问 s1 时，访问过程处于一种读取模式，也就是要从内存中读取这个字符串的值。而在读取模式中访问字符串时，后台都会自动完成下列处理。

1. 创建 String 类型的一个实例
2. 在实例上调用指定的方法
3. 销毁这个实例

可以将以上三个步骤想象成是执行了下列 ECMAScript 代码:

var s1 = new String("some text");
var s2 = s1.substring(2);
s1 = null;

上面这三个步骤也分别适用于 Boolean 和 Number 类型对应的布尔值和数字值。
引用类型与基本包装类型的主要区别就是对象的生存期。

• 使用 new 操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中
• 自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁

这意味着我们不能在运行时为基本类型值添加属性和方法。

可以显式地调用 Boolean、Number 和 String 来创建基本包装类型的对象。但一般不这么做。
对基本包装类型的实例调用 typeof 会返回 “object”，而且所有基本包装类型的对象都会被转换为布尔值 true。

Object 构造函数也会像工厂方法一样，根据传入值的类型返回相应基本包装类型的实例。

var obj = new Object("some text");
alert(obj instanceof String);   //true

要注意的是，使用 new 调用基本包装类型的构造函数，与直接调用同名的转型函数是不一样的:

var value = "25";
var number = Number(value);  //转型函数
alert(typeof number);        //"number"

var obj = new Number(value); //构造函数
alert(typeof obj);           //"object"

Boolean 类型

Boolean 类型是与布尔值对应的引用类型。要创建 Boolean 对象，可以像下面这样调用 Boolean 构造函数并传入 true 或 false 值。

var booleanObject = new Boolean(true);

Boolean 类型的实例重写了 valueOf() 方法，返回基本类型值 true 或 false，重写了 toString() 方法，返回字符串 “true” 和 “false”。
注意: 布尔表达式中的所有对象都会被转换为 true。

基本类型与引用类型的布尔值还有两个区别:

• typeof 操作符对基本类型返回 “boolean”，而对引用类型返回 “object”。
• 由于 Boolean 对象是 Boolean 类型的实例，所以使用 instanceof 操作符测试 Boolean 对象会返回 true，而测试基本类型的布尔值则返回 false。

建议: 永远不要使用 Boolean 对象。

Number 类型

Number 是与数字值对应的引用类型。要创建 Number 对象，可以在调用 Number 构造函数时向其中传递相应的数值。

var numberObject = new Number(10);

Number 类型也重写了 valueOf()、toLocaleString() 和 toString() 方法。重写后的 valueOf() 方法返回对象表示的基本类型的数值，另外两个方法则返回字符串形式的数值，并且，toString() 方法可以传递一个表示基数的参数，告诉它返回几进制数值的字符串形式:

var num = 10;
alert(num.toString());      //"10"
alert(num.toString(2));     //"1010"
alert(num.toString(8));     //"12"
alert(num.toString(10));    //"10"
alert(num.toString(16));    //"a"

Number 类型还提供了一些用于将数值格式化为字符串的方法。

• toFixed() 方法会按照指定的小数位返回数值的字符串表示:

var num = 10;
alert(num.toFixed(2));     //"10.00"

如果数值本身包含的小数位比指定的还多，那么接近指定的最大小数位的值 4 舍 5 入:

var num1 = 10.005;
alert(num1.toFixed(2));     //"10.01"

var num2 = 10.004;
alert(num2.toFixed(2));    //"10.00"

• toExponential() 方法返回以指数表示法表示的数值的字符串形式，toExponential() 也接收一个参数，用于指定输出结果中的小数位数:

var num = 10;
alert(num.toExponential(1));     //"1.0e+1"

• toPrecision() 方法可能会返回固定大小(fixed)格式，也可能返回指数(exponential)格式，具体规则是看哪种格式最合适。这个方法接收一个参数，即表示数值的所有数字的位数:

var num = 99;
alert(num.toPrecision(1));     //"1e+2"
alert(num.toPrecision(2));     //"99"
alert(num.toPrecision(3));     //"99.0"

以上代码首先完成的任务是以一位数来表示 99，结果是 “1e+2”，即 100。因为一位数无法准确地表示 99，因此 toPrecision() 就将它向上舍入为 100，这样就可以使用一位数来表示它了。而接下来的用两位数表示 99，当然还是 “99”。最后，在想以三位数表示 99 时，toPrecision() 方法返回了 “99.0”。实际上，toPrecision() 会根据要处理的数值决定到底是调用 toFixed() 还是调用 toExponential()。

String 类型

---

String 类型是字符串的对象包装类型，可以像下面这样使用 String 构造函数来创建:

var stringObject = new String("hello world");

String 对象的方法也可以在所有基本的字符串值中访问到。其中，继承的 valueOf()、toLocaleString() 和 toString() 方法，都返回对象所表示的基本字符串值。
String 类型的每个实例都有一个 length 属性，表示字符串中包含字符个数。
注意: 使字符串中包含双字节字符(不是占一个字节的 ASCII 字符)，每个字符也仍然算一个字符。

String 类型提供了很多方法，用于辅助完成对 ECMAScript 中字符串的解析和操作。

字符方法

两个用于访问字符串中特定字符的方法是:

• charAt()
• charCodeAt()

这两个方法都接收一个参数，即基于 0 的字符位置。
其中，charAt() 方法以单字符字符串的形式返回给定位置的那个字符(ECMAScript 中没有字符类型):

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

如果你想得到的不是字符而是字符编码，那么就要使用 charCodeAt():

var stringValue = "hello world";
alert(stringValue.charCodeAt(1));   //输出"101"

ECMAScript 5还定义了另一个访问个别字符的方法，使用方括号加数字索引来访问字符串中的特定字符:

var stringValue = "hello world";
alert(stringValue[1]);   //"e"

字符串操作方法

• concat() 用于将一或多个字符串拼接起来，返回拼接得到的新字符串:

var stringValue = "hello ";
var result = stringValue.concat("world");
alert(result);             //"hello world"
alert(stringValue);        //"hello"

concat() 方法可以接受任意多个参数，也就是说可以通过它拼接任意多个字符串。
虽然 concat() 是专门用来拼接字符串的方法，但实践中使用更多的还是加号操作符。

• slice() 方法会返回被操作字符串的一个子字符串，接受一或两个参数。第一个参数指定子字符串的开始位置，第二个参数(在指定的情况下)表示子字符串到哪里结束。第二个参数指定的是子字符串最后一个字符后面的位置:

var stringValue = "hello world";
alert(stringValue.slice(3));            //"lo world"
alert(stringValue.slice(3, 7));         //"lo w"

• substring() 方法与 slice() 方法一样:

var stringValue = "hello world";
alert(stringValue.substring(3));        //"lo world"
alert(stringValue.substring(3, 7));      //"lo w"

• substr() 方法会返回被操作字符串的一个子字符串，接受一或两个参数。第一个参数指定子字符串的开始位置，第二个参数指定的则是返回的字符个数:

var stringValue = "hello world";
alert(stringValue.substr(3));           //"lo world"
alert(stringValue.substr(3, 7));        //"lo worl"

字符串位置方法

有两个可以从字符串中查找子字符串的方法: indexOf() 和 lastIndexOf()。这两个方法都是从一个字符串中搜索给定的子字符串，然后返子字符串的位置(如果没有找到该子字符串，则返回 -1)。
这两个方法的区别在于: indexOf() 方法从字符串的开头向后搜索子字符串，而 lastIndexOf() 方法是从字符串的末尾向前搜索子字符串:

var stringValue = "hello world";
alert(stringValue.indexOf("o"));             //4
alert(stringValue.lastIndexOf("o"));         //7

这两个方法都可以接收可选的第二个参数，表示从字符串中的哪个位置开始搜索。

trim() 方法

ECMAScript 5 为所有字符串定义了 trim() 方法。这个方法会创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果:

var stringValue = "   hello world   ";
var trimmedStringValue = stringValue.trim();
alert(stringValue);            //"   hello world   "
alert(trimmedStringValue);     //"hello world" 

字符串大小写转换方法

ECMAScript 中涉及字符串大小写转换的方法有 4 个:

• toLowerCase()
• toLocaleLowerCase()
• toUpperCase()
• toLocaleUpperCase()

其中，toLowerCase() 和 toUpperCase() 是两个经典的方法，借鉴自 java.lang.String 中的同名方法。而 toLocaleLowerCase() 和 toLocaleUpperCase() 方法则是针对特定地区的实现。

var stringValue = "hello world";
alert(stringValue.toLocaleUpperCase());  //"HELLO WORLD"
alert(stringValue.toUpperCase());        //"HELLO WORLD"
alert(stringValue.toLocaleLowerCase());  //"hello world"
alert(stringValue.toLowerCase());        //"hello world"

localeCompare() 方法

这个方法比较两个字符串，并返回下列值中的一个:

• 如果字符串在字母表中应该排在字符串参数之前，则返回一个负数(大多数情况下是 -1，具体的值要视实现而定)
• 如果字符串等于字符串参数，则返回 0
• 如果字符串在字母表中应该排在字符串参数之后，则返回一个正数(大多数情况下是 1，具体的值同样要视实现而定)

var stringValue = "yellow";       
alert(stringValue.localeCompare("brick"));         //1
alert(stringValue.localeCompare("yellow"));        //0
alert(stringValue.localeCompare("zoo"));           //-1

单体内置对象

---

单体内置对象是由 ECMAScript 实现提供的、不依赖于宿主环境的对象，这些对象在 ECMAScript 程序执行之前就已经存在了。
意思就是说，开发人员不必显式地实例化内置对象，因为它们已经实例化了。
前面我们说的 Object、Array 和 String 都是内置对象。
ECMA-262 还定义了两个单体内置对象: Global 和 Math。

Global 对象

---

Global(全局)对象可以说是 ECMAScript 中最特别的一个对象了。不属于任何其他对象的属性和方法，最终都是它的属性和方法。事实上，没有全局变量或全局函数，所有在全局作用域中定义的属性和函数，都是 Global 对象的属性。本书前面介绍过的那些函数，诸如 isNaN()、isFinite()、parseInt() 以及 parseFloat()，实际上全都是 Global 对象的方法。

URI 编码方法

Global 对象的 encodeURI() 和 encodeURIComponent() 方法可以对 URI 进行编码，以便发送给浏览器。
这两个 URI 编码方法可以对 URI 进行编码，它们用特殊的 UTF-8 编码替换所有无效的字符，从而让浏览器能够接受和理解。

• encodeURI() 主要用于整个 URI
• encodeURIComponent() 主要用于对 URI 中的某一段

它们的主要区别在于:

• encodeURI() 不会对本身属于 URI 的特殊字符进行编码，例如冒号、正斜杠、问号和井字号
• encodeURIComponent() 则会对它发现的任何非标准字符进行编码

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));

一般来说，我们使用 encodeURIComponent() 方法的时候要比使用 encodeURI() 更多，因为在实践中更常见的是对查询字符串参数而不是对基础URI进行编码。

与 encodeURI() 和 encodeURIComponent() 方法对应的两个方法分别是 decodeURI() 和 decodeURIComponent():

var uri = "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start";

//http%3A%2F%2Fwww.wrox.com%2Fillegal value.htm%23start
alert(decodeURI(uri));

//http://www.wrox.com/illegal value.htm#start
alert(decodeURIComponent(uri));

eval() 方法

eval() 方法就像是一个完整的 ECMAScript 解析器，它只接受一个参数，即要执行的 ECMAScript(或 JavaScript)字符串:

eval("alert('hi')");
//等价于
alert("hi");

当解析器发现代码中调用 eval() 方法时，它会将传入的参数当作实际的 ECMAScript 语句来解析，然后把执行结果插入到原位置。

Global 对象的属性

Global 对象还包含一些属性，例如，特殊的值 undefined、NaN 以及 Infinity 都是 Global 对象的属性。此外，所有原生引用类型的构造函数，像 Object 和 Function，也都是Global对象的属性。
ECMAScript 5 明确禁止给 undefined、NaN 和 Infinity 赋值，这样做即使在非严格模式下也会导致错误。

window 对象

---

ECMAScript 虽然没有指出如何直接访问 Global 对象，但 Web 浏览器都是将这个全局对象作为 window 对象的一部分加以实现的。因此，在全局作用域中声明的所有变量和函数，就都成为了 window 对象的属性:

var color = "red";

function sayColor(){
    alert(window.color);
}

window.sayColor();  //"red"

另一种取得 Global 对象的方法是使用以下代码:

var global = function(){
    return this; 
}();

在没有给函数明确指定 this 值的情况下(无论是通过将函数添加为对象的方法，还是通过调用 call() 或 apply())，this 值等于 Global 对象。

Math 对象

---

ECMAScript 还为保存数学公式和信息提供了一个公共位置，即 Math 对象。

min() 和 max() 方法

min() 和 max() 方法用于确定一组数值中的最小值和最大值。这两个方法都可以接收任意多个数值参数:

var max = Math.max(3, 54, 32, 16);
alert(max);    //54

var min = Math.min(3, 54, 32, 16);
alert(min);    //3

要找到数组中的最大或最小值，可以像下面这样使用 apply() 方法:

var values = [1, 2, 3, 4, 5, 6, 7, 8];
var max = Math.max.apply(Math, values);

舍入方法

Math.ceil()、Math.floor() 和 Math.round()。这三个方法分别遵循下列舍入规则:

• Math.ceil() 执行向上舍入，即它总是将数值向上舍入为最接近的整数
• Math.floor() 执行向下舍入，即它总是将数值向下舍入为最接近的整数
• Math.round() 执行标准舍入，即它总是将数值四舍五入为最接近的整数

alert(Math.ceil(25.9));     //26
alert(Math.ceil(25.5));     //26
alert(Math.ceil(25.1));     //26

alert(Math.round(25.9));    //26
alert(Math.round(25.5));    //26
alert(Math.round(25.1));    //25

alert(Math.floor(25.9));    //25
alert(Math.floor(25.5));    //25
alert(Math.floor(25.1));    //25

random() 方法

Math.random() 方法返回介于 0 和 1 之间一个随机数，不包括 0 和 1。
套用下面的公式，就可以利用 Math.random() 从某个整数范围内随机选择一个值:

值 = Math.floor(Math.random() * 可能值的总数 + 第一个可能的值)

如果你想选择一个 1 到 10 之间的数值，可以像下面这样编写代码:

var num = Math.floor(Math.random() * 10 + 1);