05.JavaScript引用类型

最新推荐文章于 2024-03-03 10:00:00 发布

FrequencyStar

最新推荐文章于 2024-03-03 10:00:00 发布

阅读量631

点赞数

分类专栏： JavaScript自学笔记文章标签： javascript

本文链接：https://blog.csdn.net/FrequencyStar/article/details/108175501

版权

JavaScript自学笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

引用类型

引用类型的值（对象）是引用类型的一个实例。

Object
Array
Date
RegExp
Function
基本包装类型
单体内置对象

Object类型（ES6有变化）

创建

使用new操作符后跟Object构造函数

var person = new Object();
person.name = "Nicholas";
person.age = 29;

使用对象字面量表示法

var person = {
    name : "Nicholas",
    age : 29
};
var person = {};         //与new Object()相同
person.name = "Nicholas";
person.age = 29;

Array类型

ECMAScript数组的每一项可以保存任何类型的数据，ECMAScript数组的大小是可以动态调整的，即可以随着数据的添加自动增长以容纳新增数据。

创建数组

使用Array构造函数
- 如果预先知道数组要保存的项目数量，也可以给构造函数传递该数量，而该数量会自动变成length属性的值。
- 也可以向Array构造函数传递数组中应该包含的项。
- 使用Array构造函数时也可以省略new操作符。

var colors = new Array();
var colors = new Array(20);
var colors = new Array("red", "blue", "green");
var colors = Array(3);               // 创建一个包含3项的数组
var names = Array("Greg");           // 创建一个包含1项，即字符串"Greg"的数组

使用数组字面量表示法
- 数组字面量由一对包含数组项的方括号表示，多个数组项之间以逗号隔开

var colors = ["red", "blue", "green"];   // 创建一个包含3个字符串的数组
var names = [];                          // 创建一个空数组
var values = [1,2,];                     // 不要这样！这样会创建一个包含2或3项的数组
var options = [,,,,,];                   // 不要这样！这样会创建一个包含5或6项的数组

读取和修改

使用方括号并提供相应值的基于0的数字索引
数组的项数保存在其length属性中，这个属性始终会返回0或更大的值
- 数组的length属性很有特点——它不是只读的。因此，通过设置这个属性，可以从数组的末尾移除项或向数组中添加新项。

var colors = ["red", "blue", "green"];    // 定义一个字符串数组
alert(colors[0]);                         // 显示第一项
colors[2] = "black";                      // 修改第三项
colors[3] = "brown";                      // 新增第四项
alert(colors.length);            //3
colors.length = 2;

检测数组

instanceof操作符
- instanceof操作符的问题在于，它假定单一的全局执行环境。

if (value instanceof Array){ 
    //对数组执行某些操作
}

Array.isArray()方法
- 确定某个值到底是不是数组，而不管它是在哪个全局执行环境中创建的

if (Array.isArray(value)){
    //对数组执行某些操作
}

转换方法

所有对象都具有toLocaleString()、toString()和valueOf()方法。

其中，调用数组的toString()和valueOf()方法会返回相同的值，即由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。

数组继承的toLocaleString()、toString()和valueOf()方法，在默认情况下都会以逗号分隔的字符串的形式返回数组项。
join()方法，
- 可以使用不同的分隔符来构建这个字符串。join()方法只接收一个参数，即用作分隔符的字符串，然后返回包含所有数组项的字符串。
- ```
alert(colors.join("||"));      //red||green||blue
```

栈方法

数组可以表现得就像栈一样，后者是一种可以限制插入和删除项的数据结构。栈是一种LIFO（Last-In-First-Out，后进先出）的数据结构，也就是最新添加的项最早被移除。而栈中项的插入（叫做推入）和移除（叫做弹出），只发生在一个位置——栈的顶部。

通过push()和pop()方法，实现类似栈的行为。

push()方法
- 接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。
pop()方法
- 从数组末尾移除最后一项，减少数组的length值，然后返回移除的项。

var colors = new Array();                       // 创建一个数组
var count = colors.push("red", "green");        // 推入两项
alert(count);    //2

count = colors.push("black");                   // 推入另一项
alert(count);     //3

var item = colors.pop();                        // 取得最后一项
alert(item);      //"black"
alert(colors.length);   //2

队列方法

队列数据结构的访问规则是FIFO（First-In-First-Out，先进先出）。队列在列表的末端添加项，从列表的前端移除项。

结合使用shift()和push()方法，可以像使用队列一样使用数组。

使用unshift()和pop()方法，可以从相反的方向来模拟队列，即在数组的前端添加项，从数组末端移除项

shift()方法
- 移除数组中的第一个项并返回该项，同时将数组长度减1。
unshift()方法
- 在数组前端添加任意个项并返回新数组的长度。

var item = colors.shift();                  //取得第一项
count = colors.unshift("black");                //数组头部推入另一项

重排序方法

数组中已经存在两个可以直接用来重排序的方法：reverse()和sort()。

reverse()方法
- 反转数组项的顺序，返回值是经过排序之后的数组。
sort()方法
- 按升序排列数组项——即最小的值位于最前面，最大的值排在最后面，返回值是经过排序之后的数组。
- sort()方法会调用每个数组项的toString()转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值，sort()方法比较的也是字符串
```
var values = [0, 1, 5, 10, 15];
values.sort();
alert(values);     //0,1,10,15,5
```
- sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。
```
function compare(value1, value2) {
    if (value1 < value2) {
        return -1;
    } else if (value1 > value2) {
        return 1;
    } else {
        return 0;
    }
}
var values = [0, 1, 5, 10, 15];
values.sort(compare);
alert(values);   //0,1,5,10,15
```
- 对于数值类型或者其valueOf()方法会返回数值类型的对象类型，可以使用一个更简单的比较函数。这个函数只要用第二个值减第一个值即可
```
function compare(value1, value2){
    return value2 - value1;
}
```

操作方法

concat()
- 基于当前数组中的所有项创建一个新数组
- 具体来说，这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。
- 在没有给concat()方法传递参数的情况下，它只是复制当前数组并返回副本。如果传递给concat()方法的是一或多个数组，则该方法会将这些数组中的每一项都添加到结果数组中。如果传递的值不是数组，这些值就会被简单地添加到结果数组的末尾。
- ```
var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);

alert(colors);     //red,green,blue
alert(colors2);    //red,green,blue,yellow,black,brown
```
slice()
- 基于当前数组中的一或多个项创建一个新数组。
- slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。
  - 只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
  - 如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。
  - 如果结束位置小于起始位置，则返回空数组。
  - 如果slice()方法的参数中有一个负数，则用数组长度加上该数来确定相应的位置。例如，在一个包含5项的数组上调用slice(-2,-1)与调用slice(3,4)得到的结果相同。
- 注意，slice()方法不会影响原始数组。
- ```
var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);

alert(colors2);   //green,blue,yellow,purple
alert(colors3);   //green,blue,yellow
```
splice()
- 向数组的中部插入项,可以衍生出三种方法：删除，插入，替换。
- 删除
  - 可以删除任意数量的项，只需指定2个参数：要删除的第一项的位置和要删除的项数。
  - 例如，splice(0,2)会删除数组中的前两项。
- 插入
  - 可以向指定位置插入任意数量的项，只需提供3个参数：起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。
  - 例如，splice(2,0,"red","green")会从当前数组的位置2开始插入字符串"red"和"green"
- 替换
  - 可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定3个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
  - 例如，splice (2,1,"red","green")会删除当前数组位置2的项，然后再从位置2开始插入字符串"red"和"green"。
- splice()方法始终都会返回一个数组，该数组中包含从原始数组中删除的项（如果没有删除任何项，则返回一个空数组）。
```
var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1);                    // 删除第一项
alert(colors);     // green,blue
alert(removed);    // red，返回的数组中只包含一项

removed = colors.splice(1, 0, "yellow", "orange");   // 从位置1开始插入两项
alert(colors);     // green,yellow,orange,blue
alert(removed);    // 返回的是一个空数组

removed = colors.splice(1, 1, "red", "purple");      // 插入两项，删除一项
alert(colors);     // green,red,purple,orange,blue
alert(removed);    // yellow，返回的数组中只包含一项
```

位置方法

ECMAScript 5为数组实例添加了两个位置方法：indexOf()和lastIndexOf()。这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。

indexOf()
- 从数组的开头（位置0）开始向后查找
lastIndexOf()
- 从数组的末尾开始向前查找
在比较第一个参数与数组中的每一项时，会使用全等操作符；也就是说，要求查找的项必须严格相等（就像使用===一样）

迭代方法

ECMAScript 5为数组定义了5个迭代方法。每个方法都接收两个参数：要在每一项上运行的函数和（可选的）运行该函数的作用域对象——影响this的值。

传入这些方法中的函数会接收三个参数：数组项的值、该项在数组中的位置和数组对象本身。根据使用的方法不同，这个函数执行后的返回值可能会也可能不会影响访问的返回值。

every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。
filter()：对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。
forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。
map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
some()：对数组中的每一项运行给定函数，如果该函数对任一项返回true，则返回true。

以上方法都不会修改数组中的包含的值。

var numbers = [1,2,3,4,5,4,3,2,1];

var everyResult = numbers.every(function(item, index, array){
    return (item > 2); 
});

alert(everyResult);     //false

var someResult = numbers.some(function(item, index, array){
    return (item > 2);
});

alert(someResult);      //true

var numbers = [1,2,3,4,5,4,3,2,1];

var filterResult = numbers.filter(function(item, index, array){
    return (item > 2);
});

alert(filterResult);       //[3,4,5,4,3]

var numbers = [1,2,3,4,5,4,3,2,1];

var mapResult = numbers.map(function(item, index, array){
    return item * 2;
});

alert(mapResult);   //[2,4,6,8,10,8,6,4,2]

var numbers = [1,2,3,4,5,4,3,2,1];

numbers.forEach(function(item, index, array){
    //执行某些操作 
});

缩小方法

ECMAScript 5还新增了两个缩小数组的方法：reduce()和reduceRight()。这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。

这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为缩小基础的初始值。

传给reduce()和reduceRight()的函数接收4个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。

reduce()方法从数组的第一项开始，逐个遍历到最后。
reduceRight()则从数组的最后一项开始，向前遍历到第一项。
使用reduce()还是reduceRight()，主要取决于要从哪头开始遍历数组。除此之外，它们完全相同。

例如：使用reduce()方法可以执行求数组中所有值之和的操作

var values = [1,2,3,4,5];
var sum = values.reduce(function(prev, cur, index, array){
    return prev + cur; 
});
alert(sum); //15

var values = [1,2,3,4,5];
var sum = values.reduceRight(function(prev, cur, index, array){
    return prev + cur;
});
alert(sum); //15

Date类型

Date类型使用自UTC（Coordinated Universal Time，国际协调时间）1970年1月1日午夜（零时）开始经过的毫秒数来保存日期。

创建
- 使用new操作符和Date构造函数即可
- ```
var now = new Date();
```
- 在调用Date构造函数而不传递参数的情况下，新创建的对象自动获得当前日期和时间。
- 如果想根据特定的日期和时间创建日期对象，必须传入表示该日期的毫秒数（即从UTC时间1970年1月1日午夜起至该日期止经过的毫秒数）。
  - 为了简化这一计算过程，ECMAScript提供了两个方法：Date.parse()和Date.UTC()。
  - Date.parse()方法
    - 接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应日期的毫秒数。
    - 通常都接受下列日期格式：
      - “月/日/年”，如6/13/2004；
      - “英文月名日,年”，如January 12,2004；
      - “英文星期几英文月名日年时:分:秒时区”，如Tue May 25 2004 00:00:00 GMT-0700。
      - ISO 8601扩展格式YYYY-MM-DDTHH:mm:ss.sssZ（例如2004-05-25T00:00:00）。
    - 例如，要为2004年5月25日创建一个日期对象，可以使用下面的代码：
```
var someDate = new Date(Date.parse("May 25, 2004"));
```
    - 如果传入Date.parse()方法的字符串不能表示日期，那么它会返回NaN。实际上，如果直接将表示日期的字符串传递给Date构造函数，也会在后台调用Date.parse()。
      - 下面的代码与前面的例子是等价的：
        
        var someDate = new Date("May 25, 2004");
  - Date.UTC()方法
    - 同样也返回表示日期的毫秒数，但它与Date.parse()在构建值时使用不同的信息。
    - Date.UTC()的参数分别是年份、基于0的月份（一月是0，二月是1，以此类推）、月中的哪一天（1到31）、小时数（0到23）、分钟、秒以及毫秒数。在这些参数中，只有前两个参数（年和月）是必需的。
    - 如果没有提供月中的天数，则假设天数为1；如果省略其他参数，则统统假设为0。
```
// GMT时间2000年1月1日午夜零时
var y2k = new Date(Date.UTC(2000, 0));

// GMT时间2005年5月5日下午5:55:55
var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));
```
    - 如同模仿Date.parse()一样，Date构造函数也会模仿Date.UTC()，但有一点明显不同：日期和时间都基于本地时区而非GMT来创建。
```
// 本地时间2000年1月1日午夜零时
var y2k = new Date(2000, 0);

// 本地时间2005年5月5日下午5:55:55
var allFives = new Date(2005, 4, 5, 17, 55, 55);
```
  - Date.now()方法
    - 返回表示调用这个方法时的日期和时间的毫秒数。
    - ```
    //取得开始时间
    var start = Date.now();
    
    //调用函数
    doSomething();
    
    //取得停止时间
    var stop = Date.now(),
        result = stop – start;
```

继承的方法

Date类型也重写了toLocaleString()、toString()和valueOf()方法；但这些方法返回的值与其他类型中的方法不同

toLocaleString()方法会按照与浏览器设置的地区相适应的格式返回日期和时间。
toString()方法则通常返回带有时区信息的日期和时间
valueOf()方法返回日期对应的毫秒值

let result = new Date('6/13/2004');
let nowTime = new Date(Date.now());

console.log('result=' + result);
console.log('now=' + nowTime);
console.log(result.toLocaleString());
console.log(result.toString());
console.log(result.valueOf());

日期格式化方法

Date类型还有一些专门用于将日期格式化为字符串的方法，这些方法如下。

toDateString()——以特定于实现的格式显示星期几、月、日和年；
toTimeString()——以特定于实现的格式显示时、分、秒和时区；
toLocaleDateString()——以特定于地区的格式显示星期几、月、日和年；
toLocaleTimeString()——以特定于实现的格式显示时、分、秒；
toUTCString()——以特定于实现的格式完整的UTC日期。

与toLocaleString()和toString()方法一样，以上这些字符串格式方法的输出也是因浏览器而异的

toGMTString()----这是一个与toUTCString()等价的方法，其存在目的在于确保向后兼容。

日期、时间组件方法

，剩下还未介绍的Date类型的方法（如下表所示），都是直接取得和设置日期值中特定部分的方法了。需要注意的是，UTC日期指的是在没有时区偏差的情况下（将日期转换为GMT时间）的日期值。

方　　法	说　　明
`getTime()`	返回表示日期的毫秒数；与`valueOf()`方法返回的值相同
`setTime(毫秒)`	以毫秒数设置日期，会改变整个日期
`getFullYear()`	取得4位数的年份（如2007而非仅07）
`getUTCFullYear()`	返回UTC日期的4位数年份
`setFullYear(年)`	设置日期的年份。传入的年份值必须是4位数字（如2007而非仅07）
`setUTCFullYear(年)`	设置UTC日期的年份。传入的年份值必须是4位数字（如2007而非仅07）
`getMonth()`	返回日期中的月份，其中0表示一月，11表示十二月
`getUTCMonth()`	返回UTC日期中的月份，其中0表示一月，11表示十二月
`setMonth(月)`	设置日期的月份。传入的月份值必须大于0，超过11则增加年份
`setUTCMonth(月)`	设置UTC日期的月份。传入的月份值必须大于0，超过11则增加年份
`getDate()`	返回日期月份中的天数（1到31）
`getUTCDate()`	返回UTC日期月份中的天数（1到31）
`setDate(日)`	设置日期月份中的天数。如果传入的值超过了该月中应有的天数，则增加月份
`setUTCDate(日)`	设置UTC日期月份中的天数。如果传入的值超过了该月中应有的天数，则增加月份
`getDay()`	返回日期中星期的星期几（其中0表示星期日，6表示星期六）
`getUTCDay()`	返回UTC日期中星期的星期几（其中0表示星期日，6表示星期六）
`getHours()`	返回日期中的小时数（0到23）
`getUTCHours()`	返回UTC日期中的小时数（0到23）
`setHours(时)`	设置日期中的小时数。传入的值超过了23则增加月份中的天数
`setUTCHours(时)`	设置UTC日期中的小时数。传入的值超过了23则增加月份中的天数
`getMinutes()`	返回日期中的分钟数（0到59）
`getUTCMinutes()`	返回UTC日期中的分钟数（0到59）
`setMinutes(分)`	设置日期中的分钟数。传入的值超过59则增加小时数
`setUTCMinutes(分)`	设置UTC日期中的分钟数。传入的值超过59则增加小时数
`getSeconds()`	返回日期中的秒数（0到59）
`getUTCSeconds()`	返回UTC日期中的秒数（0到59）
`setSeconds(秒)`	设置日期中的秒数。传入的值超过了59会增加分钟数
`setUTCSeconds(秒)`	设置UTC日期中的秒数。传入的值超过了59会增加分钟数
`getMilliseconds()`	返回日期中的毫秒数
`getUTCMilliseconds()`	返回UTC日期中的毫秒数
`setMilliseconds(毫秒)`	设置日期中的毫秒数
`setUTCMilliseconds(毫秒)`	设置UTC日期中的毫秒数
`getTimezoneOffset()`	返回本地时间与UTC时间相差的分钟数。例如，美国东部标准时间返回300。在某地进入夏令时的情况下，这个值会有所变化

RegExp类型

ECMAScript通过RegExp类型来支持正则表达式。

var expression = / pattern / flags ;

其中的模式（pattern）部分可以是任何简单或复杂的正则表达式，可以包含字符类、限定符、分组、向前查找以及反向引用。每个正则表达式都可带有一或多个标志（flags），用以标明正则表达式的行为。正则表达式的匹配模式支持下列3个标志。

g：表示全局（global）模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止；
i：表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写；
m：表示多行（multiline）模式，即在到达一行文本末尾时还会继续查找下一行中是否存在与模式匹配的项。

/*
 * 匹配字符串中所有"at"的实例
 */
var pattern1 = /at/g;

/*
 * 匹配第一个"bat"或"cat"，不区分大小写
 */
var pattern2 = /[bc]at/i;

/*
 * 匹配所有以"at"结尾的3个字符的组合，不区分大小写
 */
var pattern3 = /.at/gi;

模式中使用的所有元字符都必须转义。正则表达式中的元字符包括：

( [ { \ ^ $ | ) ? * + .]}

字面量模式	等价的字符串
`/\[bc\]at/`	`"\\[bc\\]at"`
`/\.at/`	`"\\.at"`
`/name\/age`/	`"name\\/age"`
`/\d.\d{1,2}/`	`"\\d.\\d{1,2}"`
`/\w\\hello\\123/`	`"\\w\\\\hello\\\\123"`

RegExp实例属性

RegExp的每个实例都具有下列属性，通过这些属性可以取得有关模式的各种信息。

global：布尔值，表示是否设置了g标志。
ignoreCase：布尔值，表示是否设置了i标志。
lastIndex：整数，表示开始搜索下一个匹配项的字符位置，从0算起。
multiline：布尔值，表示是否设置了m标志。
source：正则表达式的字符串表示，按照字面量形式而非传入构造函数中的字符串模式返回。

RegExp实例方法

exec()
- 专门为捕获组而设计的
- exec()接受一个参数，即要应用模式的字符串，然后返回包含第一个匹配项信息的数组；或者在没有匹配项的情况下返回null
- 返回的数组虽然是Array的实例，但包含两个额外的属性：index和input。其中，index表示匹配项在字符串中的位置，而input表示应用正则表达式的字符串。在数组中，第一项是与整个模式匹配的字符串，其他项是与模式中的捕获组匹配的字符串
- ```
var text = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/gi;

var matches = pattern.exec(text);
alert(matches.index);     // 0
alert(matches.input);     // "mom and dad and baby"
alert(matches[0]);        // "mom and dad and baby"
alert(matches[1]);        // " and dad and baby"
alert(matches[2]);        // " and baby"
```
- 对于exec()方法而言，即使在模式中设置了全局标志（g），它每次也只会返回一个匹配项。在不设置全局标志的情况下，在同一个字符串上多次调用exec()将始终返回第一个匹配项的信息。而在设置全局标志的情况下，每次调用exec()则都会在字符串中继续查找新匹配项
text()
- 接受一个字符串参数。在模式与该参数匹配的情况下返回true；否则，返回false
- 只想知道目标字符串与某个模式是否匹配，但不需要知道其文本内容的情况下，使用这个方法非常方便。因此，test()方法经常被用在if语句中
- ```
var text = "000-00-0000";
var pattern = /\d{3}-\d{2}-\d{4}/;

if (pattern.test(text)){
    alert("The pattern was matched.");
}
```
  在这个例子中，我们使用正则表达式来测试了一个数字序列。如果输入的文本与模式匹配，则显示一条消息。这种用法经常出现在验证用户输入的情况下，因为我们只想知道输入是不是有效，至于它为什么无效就无关紧要了
RegExp实例继承的toLocaleString()和toString()方法都会返回正则表达式的字面量，与创建正则表达式的方式无关

RegExp构造函数属性

长属性名	短属性名	说　　明
`input`	`$_`	最近一次要匹配的字符串。Opera未实现此属性
`lastMatch`	`$&`	最近一次的匹配项。Opera未实现此属性
`lastParen`	`$+`	最近一次匹配的捕获组。Opera未实现此属性
`leftContext`	$`` \|input`字符串中`lastMatch`之前的文本
`multiline`	`$*`	布尔值，表示是否所有表达式都使用多行模式。IE和Opera未实现此属性
`rightContext`	`$'`	`Input`字符串中`lastMatch`之后的文本

var text = "this has been a short summer";
var pattern = /(.)hort/g;

/*
 * 注意：Opera不支持input、lastMatch、lastParen和multiline属性
 * Internet Explorer不支持multiline属性
 */
if (pattern.test(text)){
    alert(RegExp.input);                // this has been a short summer
    alert(RegExp.leftContext);          // this has been a
    alert(RegExp.rightContext);         // summer
    alert(RegExp.lastMatch);            // short
    alert(RegExp.lastParen);            // s
    alert(RegExp.multiline);            // false
}

以上代码创建了一个模式，匹配任何一个字符后跟hort，而且把第一个字符放在了一个捕获组中。RegExp构造函数的各个属性返回了下列值：

input属性返回了原始字符串；
leftContext属性返回了单词short之前的字符串，而rightContext属性则返回了short之后的字符串；
lastMatch属性返回最近一次与整个正则表达式匹配的字符串，即short；
lastParen属性返回最近一次匹配的捕获组，即例子中的s。

如前所述，例子使用的长属性名都可以用相应的短属性名来代替。只不过，由于这些短属性名大都不是有效的ECMAScript标识符，因此必须通过方括号语法来访问它们，如下所示。

var text = "this has been a short summer";
var pattern = /(.)hort/g;

/*
 * 注意：Opera不支持input、lastMatch、lastParen和multiline属性
 * Internet Explorer不支持multiline属性
 */
if (pattern.test(text)){
    alert(RegExp.$_);                   // this has been a short summer
    alert(RegExp["$`"]);                // this has been a
    alert(RegExp["$'"]);                // summer
    alert(RegExp["$&"]);                // short
    alert(RegExp["$+"]);                // s
    alert(RegExp["$*"]);                // false
}

Function类型

函数实际上是对象。每个函数都是Function类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针，不会与某个函数绑定。函数通常是使用函数声明语法定义的

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

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

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

没有重载

函数声明与函数表达式

解析器会率先读取函数声明，并使其在执行任何代码之前可用（可以访问）；至于函数表达式，则必须等到解析器执行到它所在的代码行，才会真正被解释执行

作为值的函数

不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回

function callSomeFunction(someFunction, someArgument){
    return someFunction(someArgument);
}

函数内部属性

在函数内部，有两个特殊的对象：arguments和this。其中，arguments是一个类数组对象，包含着传入函数中的所有参数。虽然arguments的主要用途是保存函数参数，但这个对象还有一个名叫callee的属性，该属性是一个指针，指向拥有这个arguments对象的函数。

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

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

函数内部的另一个特殊对象是this，其行为与Java和C#中的this大致类似。换句话说，this引用的是函数据以执行的环境对象——或者也可以说是this值

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

function outer(){
    inner(); 
}

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

outer();

以上代码会导致警告框中显示outer()函数的源代码。因为outer()调用了inter()，所以inner.caller就指向outer()。为了实现更松散的耦合，也可以通过arguments.callee.caller来访问相同的信息。

function outer(){
    inner();
}

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

outer();

函数属性和方法

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

对于ECMAScript中的引用类型而言，prototype是保存它们所有实例方法的真正所在。换句话说，诸如toString()和valueOf()等方法实际上都保存在prototype名下，只不过是通过各自对象的实例访问罢了。

每个函数都包含两个非继承而来的方法：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

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()真正的用武之地；它们真正强大的地方是能够扩充函数赖以运行的作用域。

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

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

bind()

创建一个函数的实例，其this值会被绑定到传给bind()函数的值

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

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

基本包装类型

为了便于操作基本类型值，ECMAScript还提供了3个特殊的引用类型：Boolean、Number和String

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

Boolean类型

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

var booleanObject = new Boolean(true);

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

建议永远不使用Boolean对象

Number类型

var numberObject = new Number(10);

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

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

toFixed()
- 按照指定的小数位返回数值的字符串表示
- ```
var num = 10;
alert(num.toFixed(2));     //"10.00"
```
- 如果数值本身包含的小数位比指定的还多，那么接近指定的最大小数位的值就会舍入
- ```
var num = 10.005;
alert(num.toFixed(2));     //"10.01"
```
toExponential()
- 返回以指数表示法（也称e表示法）表示的数值的字符串形式
- 也接收一个参数，而且该参数同样也是指定输出结果中的小数位数
- ```
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"
```

String类型

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

继承的valueOf()、toLocaleString()和toString()方法，都返回对象所表示的基本字符串值。

String类型的每个实例都有一个length属性，表示字符串中包含多少个字符

字符方法
- charAt()
- charCodeAt()
- 两个方法都接收一个参数，即基于0的字符位置。
- charAt()方法以单字符字符串的形式返回给定位置的那个字符
```
var stringValue = "hello world";
alert(stringValue.charAt(1));   //"e"
```
- charCodeAt()方法以字符编码的形式返回给定位置的那个字符
```
var stringValue = "hello world";
alert(stringValue.charCodeAt(1));   //输出"101"
```
- 在支持浏览器中，可以使用方括号加数字索引来访问字符串中的特定字符
```
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()方法可以接受任意多个参数，也就是说可以通过它拼接任意多个字符串
```
var stringValue = "hello ";
var result = stringValue.concat("world", "!");

alert(result);             //"hello world!"
alert(stringValue);        //"hello"
```
  - 虽然concat()是专门用来拼接字符串的方法，但实践中使用更多的还是加号操作符（+）。而且，使用加号操作符在大多数情况下都比使用concat()方法要简便易行（特别是在拼接多个字符串的情况下）。
- 基于子字符串创建新字符串的方法
  - slice()
  - substr()
  - substring()
  - 这三个方法都会返回被操作字符串的一个子字符串，而且也都接受一或两个参数。第一个参数指定子字符串的开始位置，slice()和substring()的第二个参数指定的是子字符串最后一个字符后面的位置。而substr()的第二个参数指定的则是返回的字符个数。如果没有给这些方法传递第二个参数，则将字符串的长度作为结束位置。
```
var stringValue = "hello world";
alert(stringValue.slice(3));            //"lo world"
alert(stringValue.substring(3));        //"lo world"
alert(stringValue.substr(3));           //"lo world"
alert(stringValue.slice(3, 7));         //"lo w"
alert(stringValue.substring(3,7));      //"lo w"
alert(stringValue.substr(3, 7));        //"lo worl"
```
  - 它们只是返回一个基本类型的字符串值，对原始字符串没有任何影响
  - 在传递给这些方法的参数是负值的情况下，它们的行为就不尽相同了。其中，slice()方法会将传入的负值与字符串的长度相加，substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为0。最后，substring()方法会把所有负值参数都转换为0。
```
var stringValue = "hello world";
alert(stringValue.slice(-3));           //"rld"
alert(stringValue.substring(-3));       //"hello world"
alert(stringValue.substr(-3));          //"rld"
alert(stringValue.slice(3, -4));        //"lo w"
alert(stringValue.substring(3, -4));    //"hel"
alert(stringValue.substr(3, -4));       //""（空字符串）
```
字符串位置方法
- indexOf()
- lastIndexOf()
- 从一个字符串中搜索给定的子字符串，然后返子字符串的位置（如果没有找到该子字符串，则返回-1）
- indexOf()方法从字符串的开头向后搜索子字符串，而lastIndexOf()方法是从字符串的末尾向前搜索子字符串。
- 两个方法都可以接收可选的第二个参数，表示从字符串中的哪个位置开始搜索。换句话说，indexOf()会从该参数指定的位置向后搜索，忽略该位置之前的所有字符；而lastIndexOf()则会从指定的位置向前搜索，忽略该位置之后的所有字符。

trim()

创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果

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

trimLeft()和trimRight()方法，分别用于删除字符串开头和末尾的空格。

字符串大小写转换方法

ECMAScript中涉及字符串大小写转换的方法有4个：toLowerCase()、toLocaleLowerCase()、toUpperCase()和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"

字符串的模式匹配方法

match()

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

var text = "cat, bat, sat, fat"; 
var pattern = /.at/;

//与pattern.exec(text)相同
var matches = text.match(pattern);
alert(matches.index);               //0
alert(matches[0]);                  //"cat"
alert(pattern.lastIndex);           //0

search()
- 由字符串或RegExp对象指定的一个正则表达式。search()方法返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回-1。而且，search()方法始终是从字符串开头向后查找模式
- ```
var text = "cat, bat, sat, fat"; 
var pos = text.search(/at/);
alert(pos);   //1
```

replace()

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

var text = "cat, bat, sat, fat"; 
var result = text.replace("at", "ond");
alert(result);    //"cond, bat, sat, fat"

result = text.replace(/at/g, "ond");
alert(result);    //"cond, bond, sond, fond"

如果第二个参数是字符串，那么还可以使用一些特殊的字符序列，将正则表达式操作得到的值插入到结果字符串中。下表列出了ECMAScript提供的这些特殊的字符序列

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

replace()方法的第二个参数也可以是一个函数。在只有一个匹配项（即与模式匹配的字符串）的情况下，会向这个函数传递3个参数：模式的匹配项、模式匹配项在字符串中的位置和原始字符串。

在正则表达式中定义了多个捕获组的情况下，传递给函数的参数依次是模式的匹配项、第一个捕获组的匹配项、第二个捕获组的匹配项……，但最后两个参数仍然分别是模式的匹配项在字符串中的位置和原始字符串。这个函数应该返回一个字符串，表示应该被替换的匹配项使用函数作为replace()方法的第二个参数可以实现更加精细的替换操作

function htmlEscape(text){
    return text.replace(/[<>"&]/g, function(match, pos, originalText){
        switch(match){
            case "<":
                return "&lt;";
            case ">":
                return "&gt;";
            case "&":
                return "&amp;";
            case "\"":
                return "&quot;";
        }             
    });
}

alert(htmlEscape("<p class=\"greeting\">Hello world!</p>")); 
//&lt;p class=&quot;greeting&quot;&gt;Hello world!&lt;/p&gt;

split()

基于指定的分隔符将一个字符串分割成多个子字符串，并将结果放在一个数组中。分隔符可以是字符串，也可以是一个RegExp对象

可以接受可选的第二个参数，用于指定数组的大小，以便确保返回的数组不会超过既定大小

var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(",");          //["red", "blue", "green", "yellow"]
var colors2 = colorText.split(",", 2);       //["red", "blue"]
var colors3 = colorText.split(/[^\,]+/);     //["", ",", ",", ",", ""]

localCompare()
- 比较两个字符串，并返回下列值中的一个：
  - 如果字符串在字母表中应该排在字符串参数之前，则返回一个负数（大多数情况下是-1，具体的值要视实现而定）；
  - 如果字符串等于字符串参数，则返回0；
  - 如果字符串在字母表中应该排在字符串参数之后，则返回一个正数（大多数情况下是1，具体的值同样要视实现而定）
  - ```
  var stringValue = "yellow";       
  alert(stringValue.localeCompare("brick"));         //1
  alert(stringValue.localeCompare("yellow"));        //0
  alert(stringValue.localeCompare("zoo"));           //-1
```
fromCharCode()
- 接收一或多个字符编码，然后将它们转换成一个字符串
- ```
alert(String.fromCharCode(104, 101, 108, 108, 111)); //"hello"
```

单体内置对象

ECMA-262还定义了两个单体内置对象：Global和Math。

Global对象

换句话说，不属于任何其他对象的属性和方法，最终都是它的属性和方法

事实上，没有全局变量或全局函数；所有在全局作用域中定义的属性和函数，都是Global对象的属性

前面介绍过的那些函数，诸如isNaN()、isFinite()、parseInt()以及parseFloat()，实际上全都是Global对象的方法

除此之外，Global对象还包含其他一些方法。

URI编码方法

对URI（Uniform Resource Identifiers，通用资源标识符）进行编码,以便发送给浏览器。有效的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));

decodeURI()
- 只能对使用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
alert(decodeURI(uri));

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

eval()

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

eval("alert('hi')");

这行代码的作用等价于下面这行代码：

alert("hi");

当解析器发现代码中调用eval()方法时，它会将传入的参数当作实际的ECMAScript语句来解析，然后把执行结果插入到原位置。这意味着通过eval()执行的代码可以引用在包含环境中定义的变量

Global对象的属性

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

window对象

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

var color = "red";

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

window.sayColor();  //"red"

Math对象

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

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的平方根

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对象作为apply()的第一个参数，从而正确地设置this值。然后，可以将任何数组作为第二个参数。

舍入方法

将小数值舍入为整数的几个方法
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() * 可能值的总数 + 第一个可能的值)
```

其他方法

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

小结

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

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

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

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

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

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

FrequencyStar

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

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