javascript高级程序设计学习笔记第五章下

5.5.5 函数属性和方法

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

function sayName(name){
    alert(name);
}
function sum(num1, num2){
    return num1 + num2;
}
function sayHi(){
    alert("hi");
}
console.log(sayName.length);      //1
console.log(sum.length);          //2
console.log(sayHi.length);        //0

对于 ECMAScript中的引用类型而言,prototype是保存它们所有实例方法的真正所在。换句话说,诸如toString()和valueOf()等方法实际上都保存在prototype名下,只不过是通过各自对象的实例访问罢了。在创建自定义引用类型以及实现继承时,prototype属性的作用是极为重要的。在ECMAScript5中,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);
}
function callSum2(num1, num2){
    return sum.apply(this, [num1, num2]);
}
console.log(callSum1(10,10));   //20
console.log(callSum2(10,10));   //20

分析：

在上面这个例子中,callSum1()在执行 sum()函数时传入了 this 作为 this值(因为是在全局作用域中调用的,所以传入的就是window对象)和arguments对象。

而callSum2同样也调用了sum()函数,但它传入的则是this和一个参数数组。这两个函数都会正常执行并返回正确的结果。

在严格模式下,未指定环境对象而调用函数,则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);
}
console.log(callSum(10,10));   //20

在使用 call()方法的情况下,callSum()必须明确地传入每一个参数。如果你打算直接传入 arguments 对象,或者包含函数中先接收到的也是一个数组,那么使用 apply() 肯定更方便;否则,选择 call()可能更合适。(在不给函数传递参数的情况下,使用哪个方法都无所谓。)

事实上,传递参数并非 apply()和 call()真正的用武之地;它们真正强大的地方是能够扩充函数赖以运行的作用域。下面来看一个例子。

window.color = "red";
var o = { color: "blue" };
function sayColor(){
    console.log(this.color);
}
sayColor();//red
sayColor.call(this);//red
sayColor.call(window);//red
sayColor.call(o);//blue

分析：

sayColor()也是作为全局函数定义的,而且当在全局作用域中调用它时,它确实会显示"red"。

而 sayColor.call(this)和 sayColor.call(window),则是两种显式地在全局作用域中调用函数的方式,结果当然都会显示"red"。

当运行 sayColor.call(o) 时,函数的执行环境就不一样了,因为此时函数体内的 this 对象指向了 o,于是结果显示的是"blue"。

使用 call()(或 apply())来扩充作用域的最大好处,就是对象不需要与方法有任何耦合关系。

ECMAScript 5 还定义了一个方法:bind()。这个方法会创建一个函数的实例,其 this 值会被绑定到传给 bind()函数的值。例如:

window.color = "red";
var o = { color: "blue" };
function sayColor(){
    console.log(this.color);
}
var objectSayColor = sayColor.bind(o);
objectSayColor();    //blue

分析：

object- SayColor()函数的 this 值等于 o,因此即使是在全局作用域中调用这个函数,也会看到"blue"。

支持 bind()方法的浏览器有 IE9+、Firefox 4+、Safari 5.1+、Opera 12+和 Chrome。

每个函数继承的 toLocaleString()和 toString()方法始终都返回函数的代码。返回代码的格式则因浏览器而异。另外一个继承的valueOf()方法同样也只返回函数代码。

5.6 基本包装类型

ECMAScript 还提供了 3 个特殊的引用类型:Boolean、Number 和 String。

实际上,每当读取一个基本类型值的时候,后台就会创建一个对应的基本包装类型的对象,从而让我们能够调用一些方法来操作这些数据。

var s1 = "some text";
var s2 = s1.substring(2);
console.log(s1); //some text
console.log(s2); //me text

分析：

变量 s1 包含一个字符串,字符串当然是基本类型值。而下一行调用了s1的substring()方法,并将返回的结果保存在了 s2 中。

基本类型值不是对象,因而从逻辑上讲它们不应该有方法。

后台已经自动完成了一系列的处理。

(1) 创建 String 类型的一个实例;

(2) 在实例上调用指定的方法;

(3) 销毁这个实例。

上面这三个步骤也分别适用于 Boolean 和 Number 类型对应的布尔值和数字值。

引用类型与基本包装类型的主要区别就是对象的生存期。使用 new 操作符创建的引用类型的实例, 在执行流离开当前作用域之前都一直保存在内存中。而自动创建的基本包装类型的对象,则只存在于一行代码的执行瞬间,然后立即被销毁。这意味着我们不能在运行时为基本类型值添加属性和方法。

eg:

var s1 = "some text";
    s1.color = "red";
    console.log(s1.color);   //undefined

分析：

第二行创建的 String 对象在执行第三行代码时已经被销毁了。

第三行代码又创建自己的 String 对象,而该对象没有 color 属性。

可以显式地调用 Boolean、Number 和 String 来创建基本包装类型的对象。对基本包装类型的实例调用 typeof 会返回"object",而且所有基本包装类型的对象都会被转换为布尔值 true。

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

var obj = new Object("some text");
console.log(obj instanceof String);   //true

var obj2 = new Object(23);
console.log(obj2 instanceof Number);   //true

var obj3 = new Object(false);
console.log(obj3 instanceof Boolean);   //true

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

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

var obj = new Number(value); //构造函数 
console.log(typeof obj);     //object

5.6.1 Boolean类型

Boolean 类型是与布尔值对应的引用类型。

创建 Boolean 对象:

var booleanObject = new Boolean(true);

Boolean 类型的实例重写了 valueOf()方法,返回基本类型值 true 或 false;重写了 toString() 方法,返回字符串"true"和"false"。

var falseObject = new Boolean(false);
var result = falseObject && true;

console.log(falseObject);//Boolean{}
console.log(result);  //true

var falseValue = false;
result = falseValue && true;
console.log(result);  //false

console.log(typeof falseObject); //object 
console.log(typeof falseValue); //boolean 
console.log(typeof Boolean);//function
console.log(falseObject instanceof Boolean); //true 
console.log(falseValue instanceof Boolean); //false

分析：

使用 false 值创建了一个 Boolean 对象。

示例中的这行代码是对 falseObject 而不是对它的值(false)进行求值。

布尔表达式中的所有对象都会被转换为 true,因此 falseObject 对象在布尔表达式中代表的是 true。

建议是不要使用 Boolean 对象。

5.6.2 Number类型

Number 是与数字值对应的引用类型。创建 Number 对象:

var numberObject = new Number(10);

与 Boolean 类型一样,Number 类型也重写了 valueOf()、toLocaleString()和 toString() 方法。重写后的 valueOf()方法返回对象表示的基本类型的数值,另外两个方法则返回字符串形式的数值。

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

Number 类型的数值格式化为字符串方法:

（1）toFixed()方法会按照指定的小数位返回数值的字符串表示,例如:

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

如果数值本身包含的小数位比指定的还多,那么接近指定的最大小数位的值就会舍入,如下面的例子所示。

var num = 10.005;
console.log(num.toFixed(2));     //"10.01"

能够自动舍入的特性,使得 toFixed()方法很适合处理货币值。

在给 toFixed()传入 0 的情况下,IE8 及之前版本不能正确舍入范围在{(0.94,0.5],[0.5,0.94)}之间的值。IE9 修复了这个问题。

toFixed()方法可以表示带有 0 到 20 个小数位的数值。但这只是标准实现的范围,有些浏览器也可能支持更多位数。

（2）toExponential(),该方法返回以指数表示法(也称 e 表示法) 表示的数值的字符串形式。

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

（3）toPrecision()方法可能会返回固定大小(fixed)格式,也可能返回指数 (exponential)格式;具体规则是看哪种格式最合适。这个方法接收一个参数,即表示数值的所有数字的位数(不包括指数部分)。

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

分析：

因为一位数无法准确地表示 99,因此 toPrecision()就将它向上舍入为 100,这样就可以使用一位数来表示它了。

两位数表示 99,当然还是"99"。

三位数表示 99 时,toPrecision()方法返回了"99.0"。

实际上,toPrecision()会根据要处理的数值决定到底是调用 toFixed()还是调用 toExponential()。而这三个方法都可以通过向上或向下舍入,做到以最准确的形式来表示带有正确小数位的值。

与 Boolean 对象类似,Number 对象也以后台方式为数值提供了重要的功能。不建议直接实例化 Number 类型。

var numberObject = new Number(10);
var numberValue = 10;
console.log(typeof numberObject);   //object
console.log(typeof numberValue);    //number
console.log(numberObject instanceof Number);  //true
console.log(numberValue instanceof Number);   //false

5.6.3 String类型

String 类型是字符串的对象包装类型。使用 String 构造函数来创建：

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

String 对象的方法也可以在所有基本的字符串值中访问到。其中,继承的 valueOf()、toLocale- String()和 toString()方法,都返回对象所表示的基本字符串值。

String 类型的每个实例都有一个 length 属性,表示字符串中包含多个字符。来看下面的例子。

var stringValue = "你好 world";
console.log(stringValue.length);     //8

应该注意的是,即使字符串中包含双字节字符(不是占一个字节的 ASCII 字符),每个字符也仍然算一个字符。

String 类型方法

1. 字符方法

两个用于访问字符串中特定字符的方法是:charAt()和 charCodeAt()。这两个方法都接收一个参数,即基于 0 的字符位置。

（1）charAt()方法以单字符字符串的形式返回给定位置的那个字符(ECMAScript 中没有字符类型)。例如:

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

（2）如果你想得到的不是字符而是字符编码,那么就要像下面这样使用 charCodeAt()了。

var stringValue = "hello world";
console.log(stringValue.charCodeAt(1));   //101

（3）ECMAScript 5 还定义了另一个访问个别字符的方法。在支持此方法的浏览器中,可以使用方括号加数字索引来访问字符串中的特定字符,如下面的例子所示。

var stringValue = "hello world";
console.log(stringValue[1]);   //e

使用方括号表示法访问个别字符的语法得到了 IE8 及 Firefox、Safari、Chrome 和 Opera 所有版本的支持。如果是在 IE7 及更早版本中使用这种语法,会返回 undefined 值(尽管根本不是特殊的 6 undefined 值)。

2. 字符串操作方法

（1） concat(),用于将一或多个字符串拼接起来, 返回拼接得到的新字符串。

var stringValue = "hello ";
var result = stringValue.concat("world", "!");
console.log(result); //"hello world!" 
console.log(stringValue); //"hello"

concat()方法可以接受任意多个参数,也就是说可以通过它 9 拼接任意多个字符串。实践中使用更多的还是加号操作符(+)。而且,使用加号操作符在大多数情况下都比使用 concat() 方法要简便易行(特别是在拼接多个字符串的情况下)。

（2）slice()、substr()和 substring()。

ECMAScript 还提供了三个基于子字符串创建新字符串的方法：slice()、substr()和 substring()。这三个方法都会返回被操作字符串的一个子字符串,而且也都接受一或两个参数。第一个参数指定子字符串的开始位置,第二个参数(在指定的情况下)表示子字符串到哪里结束（不包含结束位置）。具体来说,slice()和 substring()的第二个参数指定的是子字符串最后一个字符后面的位置。而 substr()的第二个参数指定的则是返回的字符个数。如果没有给这些方法传递第二个参数,则将字符串的长度作为结束位置。与 concat()方法一样,slice()、substr()和 substring()也不会修改字符串本身的值——它们只是返回一个基本类型的字符串值,对原始字符串没有任何影响。

var stringValue = "hello world";
console.log(stringValue.slice(3));       //"lo world"
console.log(stringValue.substring(3));   //"lo world"
console.log(stringValue.substr(3));      //"lo world"
console.log(stringValue.slice(3, 7));    //"lo w"
console.log(stringValue.substring(3,7)); //"lo w"
console.log(stringValue.substr(3, 7));   //"lo worl"

传递给这些方法的参数是负值的情况下,它们的行为就不尽相同了。其中,slice()方法会将传入的负值与字符串的长度相加,substr()方法将负的第一个参数加上字符串的长度,而将负的第二个参数转换为 0。最后,substring()方法会把所有负值参数都转换为 0。

var stringValue = "hello world";
console.log(stringValue.slice(-3));       //"rld"
console.log(stringValue.substring(-3));   //"hello world"
console.log(stringValue.substr(-3));      //"rld"
console.log(stringValue.slice(3, -4));    //"lo w"
console.log(stringValue.substring(3, -4));//"hel"
console.log(stringValue.substr(3, -4));   //""(空字符串)

IE 的 JavaScript 实现在处理向 substr()方法传递负值的情况时存在问题,它会返回原始的字符串。IE9 修复了这个问题。

3. 字符串位置方法

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

这两个方法都可以接收可选的第二个参数，表示从字符串中的哪个位置开始搜索。换句话说， indexOf()会从该参数指定的位置向后搜索，忽略该位置之前的所有字符；而 lastIndexOf()则会从指定的位置向前搜索，忽略该位置之后的所有字符。

var stringValue = "hello world";
console.log(stringValue.indexOf("o", 6)); //7
console.log(stringValue.lastIndexOf("o", 6)); //4

在将第二个参数 6 传递给这两个方法之后，得到了与前面例子相反的结果。这一次，由于 indexOf()是从位置 6（字母"w"）开始向后搜索，结果在位置 7 找到了"o"，因此它返回 7。而 lastIndexOf()是从位置 6 开始向前搜索。结果找到了"hello"中的"o"，因此它返回 4。

4. trim()方法

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

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

5. 字符串大小写转换方法

ECMAScript 中涉及字符串大小写转换的方法有 4 个： toLowerCase()、 toLocaleLowerCase()、 toUpperCase()和 toLocaleUpperCase()。

其中， toLowerCase()和 toUpperCase()是两个经典的方法，借鉴自 java.lang.String 中的同名方法。而 toLocaleLowerCase()和toLocaleUpperCase()方法则是针对特定地区的实现。对有些地区来说，针对地区的方法与其通用方法得到的结果相同，但少数语言（如土耳其语）会为 Unicode 大小写转换应用特殊的规则，这时候就必须使用针对地区的方法来保证实现正确的转换。

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

6. 字符串的模式匹配方法

（1） match()

match()，在字符串上调用这个方法，本质上与调用RegExp的exec()方法相同。match()方法只接受一个参数，要么是一个正则表达式，要么是一个 RegExp 对象。

var text = "cat, bat, sat, fat";
var pattern = /.at/;
//与 pattern.exec(text)相同
var matches = text.match(pattern);
console.log(matches); //
console.log(matches.index); //0
console.log(matches[0]); //"cat"
console.log(pattern.lastIndex); //0

（2） search()

search()方法的唯一参数与match()方法的参数相同：由字符串或RegExp对象指定的一个正则表达式。search()方法返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回-1。而且， search()方法始终是从字符串开头向后查找模式。

var text = "cat, bat, sat, fat";
var pos = text.search(/at/);
console.log(pos); //1

（3） replace()

replace()方法接受两个参数：第一个参数可以是一个RegExp对象或者一个字符串（这个字符串不会被转换成正则表达式），第二个参数可以是一个字符串或者一个函数。如果第一个参数是字符串，那么只会替换第一个子字符串。要想替换所有子字符串，唯一的办法就是提供一个正则表达式，而且要指定全局（g）标志。

ECMAScript 提供的这些特殊的字符序列

字符序列	替换文本
$$	$
$&	匹配整个模式的子字符串。与RegExp.lastMatch的值相同
$'	匹配的子字符串之前的子字符串。与RegExp.leftContext的值相同
$`	匹配的子字符串之后的子字符串。与RegExp.rightContext的值相同
$n	匹配第n个捕获组的子字符串，其中n等于0～9。例如，$1是匹配第一个捕获组的子字符串， $2是匹配第二个捕获组的子字符串，以此类推。如果正则表达式中没有定义捕获组，则使用空字符串
$nn	匹配第nn个捕获组的子字符串，其中nn等于01～99。例如，$01是匹配第一个捕获组的子字符串， $02是匹配第二个捕获组的子字符串，以此类推。如果正则表达式中没有定义捕获组，则使用空字符串

（4） split()

split()方法可以基于指定的分隔符将一个字符串分割成多个子字符串，并将结果放在一个数组中。分隔符可以是字符串，也可以是一个RegExp对象（这个方法不会将字符串看成正则表达式）。 split()方法可以接受可选的第二个参数，用于指定数组的大小，以便确保返回的数组不会超过既定大小。

var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(","); 
var colors2 = colorText.split(",", 2); 
console.log(colors1); //["red", "blue", "green", "yellow"]
console.log(colors2); //["red", "blue"]

7. localeCompare()方法

与操作字符串有关的最后一个方法是localeCompare()，这个方法比较两个字符串，并返回下列值中的一个：

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

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

localeCompare()方法比较与众不同的地方，就是实现所支持的地区（国家和语言）决定了这个方法的行为。比如，美国以英语作为ECMAScript实现的标准语言，因此localeCompare()就是区分大小写的，于是大写字母在字母表中排在小写字母前头就成为了一项决定性的比较规则。不过，在其他地区恐怕就不是这种情况了。

8. fromCharCode()方法

fromCharCode()这个方法的任务是接收一或多个字符编码，然后将它们转换成一个字符串。从本质上来看，这个方法与实例方法 charCodeAt()执行的是相反的操作。

console.log(String.fromCharCode(104, 101, 108, 108, 111)); //"hello"

5.7 单体内置对象

ECMA-262 对内置对象的定义是：“由ECMAScript实现提供的、不依赖于宿主环境的对象，这些对象在 ECMAScript 程序执行之前就已经存在了。”意思就是说，开发人员不必显式地实例化内置对象，因为它们已经实例化了。

5.7.1 Global对象

不属于任何其他对象的属性和方法，最终都是它的属性和方法。事实上，没有全局变量或全局函数；所有在全局作用域中定义的属性和函数，都是 Global 对象的属性。

1. URI 编码方法

Global 对象的 encodeURI()和 encodeURIComponent()方法可以对 URI（Uniform Resource Identifiers，通用资源标识符）进行编码，以便发送给浏览器。有效的URI中不能包含某些字符，例如空格。而这两个 URI 编码方法就可以对 URI 进行编码，它们用特殊的 UTF-8 编码替换所有无效的字符，从而让浏览器能够接受和理解。

其中， encodeURI()主要用于整个 URI（例如， http://www.wrox.com/illegal value.htm），而 encodeURIComponent()主要用于对 URI 中的某一段（例如前面 URI 中的 illegal value.htm）进行编码。它们的主要区别在于， encodeURI()不会对本身属于 URI 的特殊字符进行编码，例如冒号、正斜杠、问号和井字号；而encodeURIComponent()则会对它发现的任何非标准字符进行编码。

var uri = "http://www.wrox.com/illegal value.html#start?id=1";
//"http://www.wrox.com/illegal%20value.htm#start"
console.log(encodeURI(uri));
//"http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"
console.log(encodeURIComponent(uri));

与 encodeURI()和 encodeURIComponent()方法对应的两个方法分别是 decodeURI()和 decodeURIComponent()。其中，decodeURI()只能对使用encodeURI()替换的字符进行解码。例如，它可将%20 替换成一个空格，但不会对%23作任何处理，因为%23表示井字号（#），而井字号不是使用encodeURI()替换的。同样地，decodeURIComponent()能够解码使用encodeURIComponent()编码的所有字符，即它可以解码任何特殊字符的编码。

var uri = "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start";
//http%3A%2F%2Fwww.wrox.com%2Fillegal value.htm%23start
console.log(decodeURI(uri));
//http://www.wrox.com/illegal value.htm#start
console.log(decodeURIComponent(uri));

2. eval()方法

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

当解析器发现代码中调用 eval()方法时，它会将传入的参数当作实际的 ECMAScript 语句来解析，然后把执行结果插入到原位置。通过eval()执行的代码被认为是包含该次调用的执行环境的一部分，因此被执行的代码具有与该执行环境相同的作用域链。这意味着通过 eval()执行的代码可以引用在包含环境中定义的变量。

3. Global 对象的属性

Global 对象的所有属性：

属性	说明
undefined	特殊值undefined
NaN	特殊值NaN
Infinity	特殊值Infinity
Object	构造函数Object
Array	构造函数Array
Function	构造函数Function
Boolean	构造函数Boolean
String	构造函数String
Number	构造函数Number
Date	构造函数Date
RegExp	构造函数RegExp
Error	构造函数Error
EvalError	构造函数EvalError
RangeError	构造函数RangeError
ReferenceError	构造函数ReferenceError
SyntaxError	构造函数SyntaxError
TypeError	构造函数TypeError
URIError	构造函数URIError

4. window 对象

Web 浏览器都是将这个全局对象作为window对象的一部分加以实现的。因此，在全局作用域中声明的所有变量和函数，就都成为了 window对象的属性。

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

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

以上代码创建了一个立即调用的函数表达式，返回this的值。如前所述，在没有给函数明确指定this 值的情况下（无论是通过将函数添加为对象的方法，还是通过调用call()或apply()）， this值等于 Global 对象。而像这样通过简单地返回this来取得Global对象，在任何执行环境下都是可行的。第 7 章将深入讨论函数表达式。

5.7.2 Math对象

ECMAScript 还为保存数学公式和信息提供了一个公共位置，即 Math 对象。与我们在 JavaScript 直接编写的计算功能相比， Math 对象提供的计算功能执行起来要快得多。

1. Math 对象的属性

属性	说明
Math.E	自然对数的底数，即常量e的值
Math.LN10	10的自然对数
Math.LN2	2的自然对数
Math.LOG2E	以2为底e的对数
Math.LOG10E	以10为底e的对数
Math.PI	π的值
Math.SQRT1_2	1/2的平方根（即2的平方根的倒数）
Math.SQRT2	2的平方根

2. min()和 max()方法

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

var max = Math.max(3, 54, 32, 16);
console.log(max); //54
var min = Math.min(3, 54, 32, 16);
console.log(min); //3

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

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

这个技巧的关键是把 Math对象作为apply()的第一个参数，从而正确地设置this值。然后，可以将任何数组作为第二个参数。

3. 舍入方法

Math.ceil()执行向上舍入，即它总是将数值向上舍入为最接近的整数；
Math.floor()执行向下舍入，即它总是将数值向下舍入为最接近的整数；
Math.round()执行标准舍入，即它总是将数值四舍五入为最接近的整数（这也是我们在数学课上学到的舍入规则）。

console.log(Math.ceil(25.9)); //26
console.log(Math.ceil(25.5)); //26
console.log(Math.ceil(25.1)); //26
console.log(Math.round(25.9)); //26
console.log(Math.round(25.5)); //26
console.log(Math.round(25.1)); //25
console.log(Math.floor(25.9)); //25
console.log(Math.floor(25.5)); //25
console.log(Math.floor(25.1)); //25

4. random()方法

Math.random()方法返回大于等于 0 小于 1 的一个随机数。

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

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

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

如果想要选择一个介于 2 到 10 之间的值，就应该将上面的代码改成这样：

var num = Math.floor(Math.random() * 9 + 2);

其实都可以通过一个函数来计算可能值的总数和第一个可能的值:

function selectFrom(lowerValue, upperValue) {
var choices = upperValue - lowerValue + 1;
return Math.floor(Math.random() * choices + lowerValue);
}
var num = selectFrom(2, 10);
console.log(num); // 介于 2 和 10 之间（包括 2 和 10）的一个数值

5. 其他方法

方法	说明
Math.abs(num)	返回num 的绝对值
Math.exp(num)	返回Math.E 的num 次幂
Math.log(num)	返回num 的自然对数
Math.pow(num,power)	返回num 的power 次幂
Math.sqrt(num)	返回num 的平方根
Math.acos(x)	返回x 的反余弦值
Math.asin(x)	返回x 的反正弦值
Math.atan(x)	返回x 的反正切值
Math.atan2(y,x)	返回y/x 的反正切值
Math.cos(x)	返回x 的余弦值
Math.sin(x)	返回x 的正弦值
Math.tan(x)	返回x 的正切值

5.8 小结

对象在 JavaScript 中被称为引用类型的值，而且有一些内置的引用类型可以用来创建特定的对象，现简要总结如下：

引用类型与传统面向对象程序设计中的类相似，但实现不同；
Object 是一个基础类型，其他所有类型都从 Object 继承了基本的行为；
Array 类型是一组值的有序列表，同时还提供了操作和转换这些值的功能；
Date 类型提供了有关日期和时间的信息，包括当前日期和时间以及相关的计算功能；
RegExp 类型是 ECMAScript支持正则表达式的一个接口，提供了最基本的和一些高级的正则表达式功能。

函数实际上是 Function 类型的实例，因此函数也是对象；而这一点正是 JavaScript 最有特色的地方。由于函数是对象，所以函数也拥有方法，可以用来增强其行为。

因为有了基本包装类型，所以JavaScript中的基本类型值可以被当作对象来访问。三种基本包装类型分别是： Boolean、 Number 和 String。以下是它们共同的特征：

每个包装类型都映射到同名的基本类型；
在读取模式下访问基本类型值时，就会创建对应的基本包装类型的一个对象，从而方便了数据操作；
操作基本类型值的语句一经执行完毕，就会立即销毁新创建的包装对象。

在所有代码执行之前，作用域中就已经存在两个内置对象：Global 和 Math。在大多数 ECMAScript实现中都不能直接访问 Global 对象；不过， Web 浏览器实现了承担该角色的 window 对象。全局变量和函数都是Global对象的属性。Math对象提供了很多属性和方法，用于辅助完成复杂的数学计算任务。

posted @ 2017-02-23 18:19 MiyaMiya 阅读(188) 评论(0) 编辑收藏举报

刷新页面返回顶部

Miya

javascript高级程序设计 学习笔记 第五章 下