06. JS 引用类型（对象）

一、Array 对象

• 类数组

二、Date 对象

三、String 对象

四、Number 对象

五、Math 对象

一、Array 对象

1. 数组的两种创建方式

(1) var arr = []; —> 字面量（内部还是new Array()的方式）—> 推荐

var colors = ['red','blue','green']; //创建一个包含3个字符串的数组
var name = [];  //创建一个空数组
var values = [1,2,];    // 不要这样,最后不要加 ,
var options = [,,,,,];  // 不要这样,容易混淆

(2) var arr = new Array();

• new Array 如果只传一个参数，那这个参数就是数组的长度

• 可以用来创建特定长度的空数组

var arr = new Array(1,2,3); // [1, 2, 3]
var arr1 = new Array(10);   // [empty × 10] 长度为 10 的数组
var arr2 = [10];    // [10]

console.log(arr);
console.log(arr1);
console.log(arr2);

2. 数组长度（length）

• 数组的项数保存在其 length属性中，这个属性始终会返回 0 或更大的值

var colors = ['red','blue','green'];
var names = [];

console.log(colors.length); //3
console.log(names.length); //0

• 数组的 length 属性很有特点——它不是只读的。

• 因此，通过设置这个属性，可以从数组的末尾移除项或向数组中添加新项.

var colors = ['red','blue','green']; 
colors.length =2;   //长度设置为2
console.log(colors[2]); //undefined

//设置为大于数组项数的值,则新增的每一项都会时undefined值
colors.length = 4;
console.log(colors[3]); //undefined

3. 二维数组

二维数组的定义方法：

(1)

var myarr=new Array();  //先声明一维 

for(var i=0;i<2;i++){   //一维长度为2
   myarr[i]=new Array();  //再声明二维 
   for(var j=0;j<3;j++){   //二维长度为3
        myarr[i][j]=i+j;   // 赋值，每个数组元素的值为i+j
   }
 }

(2)

var Myarr = [[0 , 1 , 2 ],[1 , 2 , 3]]

myarr[0][1]=5; //将5的值传入到数组中，覆盖原有值。

说明: myarr[0][1] ,0 表示表的行，1表示表的列。

实例：创建二维数组(一维长度3，二维长度6)，值为一维数组和二维数组索引值的积，如myarr[2][5]=2*5。

var myarr = new Array();

for(var i=0;i<3;i++){
    myarr[i] = new Array();
    for(var j=0;j<6;j++){
        myarr[i][j] = i*j;
        document.write("myarr["+i+"]["+j+"]的值:"+myarr[i][j]+"<br>");
    }
}

/*
myarr[0][0]的值:0
myarr[0][1]的值:0
myarr[0][2]的值:0
myarr[0][3]的值:0
myarr[0][4]的值:0
myarr[0][5]的值:0
myarr[1][0]的值:0
myarr[1][1]的值:1
myarr[1][2]的值:2
myarr[1][3]的值:3
myarr[1][4]的值:4
myarr[1][5]的值:5
myarr[2][0]的值:0
myarr[2][1]的值:2
myarr[2][2]的值:4
myarr[2][3]的值:6
myarr[2][4]的值:8
myarr[2][5]的值:10
*/

4. 改变原数组的几种方法

(1) push()

• 在数组的最后一位添加元素，返回的是数组的长度

// 模拟系统调用数组的push方法：
Array.prototype.push = function(){
    for(var i = 0; i <arguments.length; i++){
        this[this.length] = arguments[i];
    }
    return this.length;
}

(2) pop()

• 剪切掉数组的最后一位，返回的是剪切的数组最后一位的值

(3) shift()

• 剪切掉数组的第一位元素，返回的是剪切的数组第一位的值

(4) unshift()

• 在数组的第一位添加元素，返回的是数组的长度

(5) splice()

• splice ( 从第几位开始截取 , 截取多少位 , 在截取点处添加什么)

var arr = [1,1,2,2,3,4];
arr.splice(2,2,"a","b")//[ 1, 1, "a", "b", 3, 4]
arr.splice(4,0,8)//[1, 1, 2, 2, 8, 3, 4 ]
arr.splice(-1,1)//[1,1,2,2,3]


//负数的实现原理是这样的：pos += pos > 0 ? 0 : this.length;也就是倒数的第几位
//首先判断，如果是负数的话那就是负数加上长度就等于正数的第几位（从0开始）
var arr = [1,4,7,3,2,5,6,8,9]
arr.splice(2,1);// [ 1, 4, 3, 2, 5, 6, 8, 9 ]
arr.splice(-2,1);// [ 1, 4, 7, 3, 2, 5, 6, 9 ]

(6) reverse()

• 反转数组项的顺序

var values = [1, 2, 3, 4, 5];
values.reverse();
console.log(values);
//Array(5) [ 5, 4, 3, 2, 1 ]

(7) sort()

• 按照 ASCII 排序的

• ASCII 比较大小的时候,是比较两个数中的第一个字符。

• 常见ASCII码的大小规则，0－9＜A－Z＜a－z：

  • 数字比字母要小，如 “7”＜“F”

  • 数字0比数字9要小，并按0到9顺序递增。如 “3”＜“8”

  • 字母A比字母Z要小，并按A到Z顺序递增。如“A”＜“Z”

  • 同个字母的大写字母比小写字母要小32。如“A”＜“a”

• 记住几个常见字母的ASCII码大小： “A”为65；“a”为97；“0”为48；

var arr= [1,3,5,4,10];
arr.sort(); // 1,10,3,5,4

• 使用函数实现让数组按照大小排序

// 1. 必须写两个形参
// 2. 看返回值  1）当返回值为负数时，那么前面的是放在前面
//       		2）当返回值为正数时，那么后面的是放在前面
//        		3）为0，不动

var arr= [1,3,5,4,10];
arr.sort(function (a,b) {   //传入参数顺序：1,3 -> 1,5 -> 1,4 -> 1,10
                            //              3,5 -> 3,4 -> 3,10
                            //              5,4 -> 5,10
                            //              4,10
   if(a > b){   // 升序
       return 1;
   }else{
       return -1;
   }
   
//    if(a < b){   // 降序
//       return 1;
//   }else{
//       return -1;
//   }
 
});
console.log(arr);//[1,3,4,5,10]

// 上面高阶sortd函数的实现可以简化为下面这种形式：
arr.sort(function (a,b) {   // 直接执行
  return a-b;
// 升序    ---> if(a > b){return 1;} 相当于 a - b 返回正数，
//             又因为返回正数的话 b 就会放到 a 的前面，
//             每次循环都把小的放前面，最后的数组就是 小->大 升序

// return b-a;
// 降序   ---> if(a < b){return 1;} 相当于 b - a 返回正数，
//             又因为返回正数 b 就会放到 a 的前面，
//             每次循环都会把大的放前面，最后的数组就是 大->小 降序
});

// 给一个有序的数组排序,让它每一次执行都是乱序

var arr = [1,2,3,4,5,6,7];
arr.sort(function () {
   return Math.random() - 0.5;  // 0-1 之间随机的值
});
console.log(arr);//发现每执行一次，arr数组里面的顺序都不一样。
//因为 Math.random()返回的结果是(0,1)，这样减去0.5，那么它有为正的概率和为负的概率是一半一半。
//根据sort函数的原理，如果返回的是正数，那么后面的和前面的调个位置，如果返回的是负数或者0，那么前面的还是在前面

// 将数组里面的按字节长度排序

var arr = ['ac','nsfauigf','网络','osy题词','wdfewfef','addasd'];
function retBytes(str) {
    var num = str.length;
    for(var i = 0; i <str.length; i++){
        if(str.charCodeAt(i) > 255){
            num++;
        }
    }
    return num;
}
arr.sort(function(a,b) {
    return retBytes(a) - retBytes(b);
})

5. 不改变原数组的几种方法

(1) concat()

• 连接两个或多个数组，该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本

var arr = [1,2,3]
var arr1 = [4,5,6]
var arr3 = arr.concat(arr1);    //arr3 : [ 1, 2, 3, 4, 5, 6 ]

// 把这一串字符串链接起来，不用+号的方式（因为字符串是原始值，存在栈内存里面的，这样来回在栈内取元素很浪费时间。 ）。
var str1 = "nsd";
var str2 = "sdsfd";
var str3 = "fadf";
var arr = [str1,str3];//数组是散列结构
console.log(arr.join(""));//nsdfadf
//console.log(arr.join());// nsd,fadf
join()里面为空就是用逗号连起来。

(2) toString()

• 转换成字符串

var arr = [1,2,3,4]
console.log(arr.toString());//1,2,3,4

(3) slice()

• 返回值是截取的值，不改变原数组。

• slice两个参数(从该位为开始截取，截取到该位)

• slice一个参数(从该位开始截取到后面所有都截取)

• slice没有参数(整个截取)

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1) ; //复制从索引1开始到最后
var colors3 = colors.slice(1,4);    //复制从索引1开始到索引3
var colors4 = colors.slice(-2,-3);  //5+(-2),5+(-3) =>(3,2)
var colors5 = colors.slice(-2,-1);  //(3,4)

console.log(colors2);   //Array(4) [ "green", "blue", "yellow", "purple" ]
console.log(colors3);   //Array(3) [ "green", "blue", "yellow" ]
console.log(colors4);   //Array []  =>结束位置小于起始位置，则返回空数组
console.log(colors5);   //Array [ "yellow" ]

(4) join —> split

• join 分隔符，最后返回字符串

• 数组的方法join()和字符串的方法split()是互逆的

var arr= [1,2,3,4,5]; 
var str = arr.join("-"); // "1-2-3-4-5"
var shuzu =str.split("-");//[ "1", "2", "3", "4", "5" ]
// str.split('4'); // ['1-2-3', '-5-6']
// 按什么拆开就把那个切掉

• 可以用来连接字符串

var a = 'alibaba';
var b = 'baidu';
var c = 'tencent';

//散列
var arr = [a,b,c];
console.log(arr.join(''));  // 'alibababaidutencent'
// console.log(arr.join()); // alibaba,baidu,tencent 如果不传参数就会被识别成逗号

6. 类数组

• 类数组特性：

  • 可以利用属性名模拟数组的特性

  • 可以动态的增加length属性

  • 如果强行让类数组调用push方法，则会根据length属性值的位置进行属性值的扩充。

• 类数组举例：

  • arguments

  • 一个对象：

    • 属性要为索引（数字）属性

    • 必须有length属性

    • 最好加上push

var obj = {
    "0" : "a",
    "1" : "b",
    "2" : "c",
    "length" : 3,
    "push" : Array.prototype.push
}
obj.push('d');
console.log(obj); //{0: "a", 1: "b", 2: "c", 3: "d", length: 4, push: ƒ}

------------------------------------------------------

var obj = {
    "0" : "a",
    "1" : "c",
    "2" : "d",
    "length" : 3,
    "push" : Array.prototype.push,
	'splice':Array.prototype.splice // 加上它就会让这个对象长的完全和数组一样，但还是对象。
}
obj.push('b');
console.log(obj);
// ["a", "c", "d", "b", push: ƒ, splice: ƒ]

• 类数组里面最关键的是length属性,类数组中push实现的原理

Array.prototype.push = function (target) { 
    obj[obj.length] = target;
    obj.length++;
}

• 例题：

var obj = {
    "2" : "a",
    "3" : "b",
    "length" : 2,
    "push" : Array.prototype.push
}
obj.push('c');
// 当 push('c') 就相当于：
// Array.prototype.push = function ('c') { 
//     obj[2] = 'c';    // 在属性 2 上赋值 'c' ==> '2':'c'
//     2++; // push 完成后 length 变成 3
// }

obj.push('d');
// 当 push('d') 就相当于：
// Array.prototype.push = function ('d') { 
//     obj[3] = 'd';    // 这时候 length 已经变成 3 了，在属性 3 上赋值 'd' ==> '3':'d'
//     3++; // push 完成后 length 变成 4
// }

console.log(obj);
//Object { 2: "c", 3: "d", length: 4, push: push() }

类数组的好处就是把数组和对象的好处拼到一起

• 但是并不是所有的数组方法都能用，除非你自己添加

var obj = {
    "0" : 'a',
    "1" : 'b',
    "2" : 'c',
    name :"abc",
    age  : 123,
    length : 3,
    push : Array.prototype.push,
    splice :Array.prototype.splice
}

二、Date 对象

Date 对象用于处理日期和时间。可以通过 new 关键词来定义 Date 对象。

toString()：方法可把日期对象转换为字符串，当日期需要显示为一个字符串时，该方法会被自动调用。

valueOf()：方法返回日期对象的原始值。该方法将返回1970年元旦至今的毫秒数。

获取当前的所有日期：

var d = new Date();
//获取当前日期
document.write(d);
 
//获取当前的年份
document.write(d.getFullYear() + '年');

//获取当前月份，月份从0开始计算，所以需要+1
document.write(d.getMonth() + 1 + '月');    // 0 ~ 11

//获取当前是当月中的哪一天
document.write(d.getDate() + '日');

//获取当前时间的小时
document.write(d.getHours() + '时');

//获取当前时间的分钟
document.write(d.getMinutes() + '分');

//获取当前时的秒数
document.write(d.getSeconds() + '秒');

//获取当前的毫秒数t
document.write(d.getMilliseconds() + '毫秒');

//获取星期
document.write('星期' + d.getDay());    // 0 ~ 6

//星期从0开始算起，从星期天开始计算。
//getDay()返回的是0-6的数字，0表示星期天。如果要返回相对应的“星期”，需要通过数组完成。
var weekday = ["星期日","星期一","星期二","星期三","星期四","星期五","星期六"];
var week = d.getDay();
document.write(weekday[week]);

设置日期：

var d = new Date();

//设置年份
d.setFullYear(2020);
document.write(d);

//该方法也可用于设置月份(介于0-11之间)和天数(介于1-31之间)。
//月份：-1为去年的最后一月，-2为去年的倒数第二个月。
//12为明年的第一个月，13为明年的第二个月。
//天数：0为上个月最后一天，-1为上个月最后一天之前的天数。
//如果当月有31天，32为下个月第一天，如果当天只有30天，32则为下个月的第二天
d.setFullYear(2020, 11, -1);
document.write(d);
//设置月份(介于0-11之间)，也可用于设置天数
d.setMonth(5);
document.write(d);


//设置天数(介于1-31之间)
d.setDate(12);
document.write(d);

//设置小时
//值介于0(午夜)-23(晚上11点)之间，-1为昨天的最后一个小时，24为明天的第一个小时
d.setHours(24);
document.write(d);

//该方法也可用于设置分钟、秒以及毫秒数。
//分钟：介于0-59之间，-1为上一小时最后一分钟，60为下一个小时第一分钟
//秒：介于0-59之间，-1为上一分钟最后一秒，60为下一分钟第一秒
//毫秒：介于0-999之间，-1为上一秒钟的最后一毫秒，1000为下一秒钟的第一毫秒
d.setHours(21,30,1);
document.write(d);

//获取小时 一个小应用：返回24小时之前的的时间
var d = new Date();
d.setHours(d.getHours()-24);
document.write(d);

//设置分钟，也可用于设置秒数和毫秒数
d.setMinutes(20);
document.write(d);

//设置秒，也可用于设置毫秒
d.setSeconds(10);
document.write(d);

//设置毫秒
d.setMilliseconds(999);
document.write(d);

getTime() 和 setTime()

var d = new Date();

//获取1970年元旦距今的毫秒数
document.write(d.getTime()+'毫秒');

//向1970年元旦增加1325347200000毫秒，返回新日期
d.setTime(1325347200000);
document.write(d);

//获取指定时间据1970年之间的毫秒数
var d = Date.parse("2012, 12, 12");
document.write(d+'毫秒');

//计算1970年元旦至今有多少年：
var minutes = 1000*60;
var hours = minutes*60;
var day = hours*24;
var year = day*365;
var d = new Date();
var t = d.getTime();
var y = Math.round(t/year);
document.write(y + '年');

日期转换：

var d = new Date();
//当前时间
document.write(d);

//将日期部分(不包括时分秒)转换为字符串
document.write(d.toDateString());

//将日期部分(不包括年月日)转换为字符串
document.write(d.toTimeString());

//根据本地时间将日期转换为字符串
document.write(d.toLocaleString());

//根据本地时间将日期部分(不包括时分秒)转换为字符串
document.write(d.toLocaleDateString());

//根据本地时间将日期部分(不包括年月日)转换为字符串
document.write(d.toLocaleTimeString());

//使用ISO标准将日期转换为字符串
//该标准格式为：YYYY-MM-DDTHH:mm:ss.sssZ
document.write(d.toISOString());

//将日期转换为JSON格式
//JSON格式与ISO标准是同样的格式
document.write(d.toJSON());

三、String 对象

String 对象用于处理文本，也就是字符串。一个字符串用于存储一系列的字符，通常 JS 字符串是原始值，可以使用变量声明，也可以使用 new 关键字将字符串定义为一个对象，在 JS 中并不提倡使用 new 关键字创建对象。原始值字符串是没有属性和方法的，但是可以使用 JS 的属性和方法，因为 JS 在执行属性和方法时可以把原始值视为对象。

可以使用 JS 内置的 length 属性来计算字符串的长度：

var str = "abcdefghijklmnopqrstuvwxyz";
console.log(str.length);    //返回：26

• toString()：将对象转换为字符串

• valueOf()：将对象转换为一个基本数据的值，返回对象的原始值

(1) 字符方法

• charAt()

  • str.charAt(index)：返回指定索引位置的字符，也就是获取字符串的某一位字符

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

• charCodeAt()

  • str.charCodeAt(index)：以单字符字符串的形式返回给定位置的哪个字符的字符编码

var stringValue = new String("hello world");
alert(stringValue.charCodeAt(1));   //"101"

(2) 字符串操作方法

• concat()

  • str1.concat(str2, str3, ...., strN)：用于连接两个或多个字符串，返回连接后的新字符串。（不改变原字符串）

var stringValue=new String("hello ");
var result=stringValue.concat("world","!");
alert(result);//"hello world!"
alert(stringValue);//"hello "

• slice()

  • slice(start, end) 提取字符串的某个部分，并以新的字符串返回被提取的部分，不包括结束位置的字符

  • 返回被操作数的一个子字符串，而且也接收一或两个参数。第一个参数指定子字符串的开始位置，第二个参数（在指定的情况下）表示子字符串到哪里结束

  • 第二个参数指定的是子字符串最后一个字符后面的位置

  • 如果没有给这些方法传递第二个参数，则将字符串的末尾作为结束吧位置

  • 不会修改字符串本身的值——只是返回一个基本类型的字符串值，对原字符串没有任何影响

  • 传入参数是负数时，slice()会将传入的负值与字符串的长度相加

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

alert(stringValue.slice(-3));//"rld"
alert(stringValue.slice(3,-4));//"lo w"

• substr()

  • substr(start, length) 提取字符串从开始位置指定字符串长度的字符，并以新的字符串返回被提取的部分

  • 返回被操作数的一个子字符串，而且也接收一或两个参数。第一个参数指定子字符串的开始位置，第二个参数（在指定的情况下）表示子字符串到哪里结束

  • 第二个参数指定的是返回的字符个数

  • 如果没有给这些方法传递第二个参数，则将字符串的末尾作为结束吧位置

  • 不会修改字符串本身的值——只是返回一个基本类型的字符串值，对原字符串没有任何影响

  • 传入参数是负数时，substr()方法会将负的第一个参数加上字符串的长度，而将将负的第二个参数转换为0

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

alert(stringValue.substr(-3));//"rld"
alert(stringValue.substr(3,-4));//""
//substr()会将第二个参数转换为0，返回的字符串包含零个字符串，也就是一个空字符串

• substring()

  • substring(from, to)　提取介于字符串指定的两个下标中间的字符，并以新的字符串返回被提取的部分，不包括结束位置的字符

  • 返回被操作数的一个子字符串，而且也接收一或两个参数。第一个参数指定子字符串的开始位置，第二个参数（在指定的情况下）表示子字符串到哪里结束

  • 第二个参数指定的是子字符串最后一个字符后面的位置

  • 如果没有给这些方法传递第二个参数，则将字符串的末尾作为结束吧位置

  • 不会修改字符串本身的值——只是返回一个基本类型的字符串值，对原字符串没有任何影响

  • 传入参数是负数时，substring()方法会将所有的负值参数都转换为0

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

alert(stringValue.substring(-3));//"hello  world"
alert(stringValue.substring(3,-4));//"hel"
// substring()方法会把第二个参数转换为0，也就是substring(3,0),
// 而由于这个方法会将较小的数作为开始位置，将较大数作为结束位置，最终相当于调用了substring(0,3)

(3) 字符串位置方法

• indexOf()

  • str.indexOf(某个字符, strat)　返回字符串中某个字符从指定位置开始首次出现的位置

  • 从一个字符串中搜索给定的字符串，然后返回怒字符串的位置（如果没有找到该字符串，则返回-1）

  • indexOf()方法从字符串的开头向后搜索字符串

  • 如果给定字符串仅出现一次，那么indexOf()和lastIndexOf()会返回相同的位置值

  • 第二个参数（可选）表示从字符串中的哪个位置开始搜索

  • indexOf()会从该参数指定的位置向后搜索，忽略该位置之前的所有字符

var stringValue=new String("hello world");
alert(stringValue.indexOf("o"));//4
alert(stringValue.indexOf("o",6));//7

• lastIndexOf()

  • lastIndexOf(某个字符, strat)　返回字符串中某个字符从指定位置开始最后出现的位置，在指定位置从后向前查找

  • 从一个字符串中搜索给定的字符串，然后返回怒字符串的位置（如果没有找到该字符串，则返回-1）

  • lastIndexOf()方法是从字符串的末尾向前搜索字符串

  • 第二个参数（可选）表示从字符串中的哪个位置开始搜索

  • lastIndexOf()会从该参数指定的位置向前搜索，忽略该位置之后的所有字符

var stringValue=new String("hello world");
alert(stringValue.lastIndexOf("o"));//7
alert(stringValue.lastIndexOf("o",6));//4

(4) trim()方法

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

• trim()返回的是字符串的副本，所以原始字符串中的前置及后缀空格会保持不变

• 支持这个方法的浏览器有IE 9+、Firefox 3.5+、Safari 5+、Opera 10.5+和Chrome

• 此外，Firefox 3.5+、Safari 5+和Chrome 8+还支持非标准的trimLeft()和trimRight()方法，分别用于删除字符串开头和末尾的空格

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

(5) 字符串大小写转换方法

• toLowerCase()：将对象转换为小写

var stringValue=new String("HELLO WORLD");
console.log(stringValue.toLowerCase()); //"hello world"

• toLocaleLowerCase()

  • 针对特定时区，将对象转换为小写

  • 一般来说，在不知道自己的代码将在哪种语言环境中运行的情况下，还是使用针对地区的方法更稳妥一些

• toUpperCase()：将对象转换为大写

var stringValue=new String("hello world");
alert(stringValue.toUpperCase());//"HELLO WORLD"

• toLocaleUpperCase()

  • 针对特定时区，将对象转换为大写

  • 一般来说，在不知道自己的代码将在哪种语言环境中运行的情况下，还是使用针对地区的方法更稳妥一些

(6) 字符串的模式匹配方法

• match()

  • match()在字符串上调用这个方法，本质上与调用RegExp()的exec()方法相同

  • match()方法只接收一个参数，要么是一个正则表达式，要么是一个RegExp对象

var text=new String("cat,bat,sat,fat");
var pattern=/.at/;
//与pattern.exec(text)相同
var matches=text.match(pattern);
alert(matches.index);//0
alert(matches[0]);
alert(pattern.lastIndex);//0
//match()方法返回了一个数组
//如果是调用RegExp对象的exec()方法并传递本例中的字符串作为参数，那么也会得到与此相同的数组：数组的第一项是与整个模式匹配的字符串，之后的每一项（如果有）保存着与正则表达式中的捕获组匹配的字符串

• search()

  • search()方法的唯一参数与match()方法的参数相同：由字符串或RegExp对象指定的一个正则表达式

  • search()方法返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回-1

  • search()方法始终是从字符串开头向后查找模式

var text=new String("cat,bat,sat,fat");
var pos=text.search(/at/);
alert(pos);//1
//search()方法返回1，即"at"在字符串中第一次出现的位置

• replace()

  • replace()用于替换字符串

  • 这个方法接收两个参数：第一个参数可以是一个RegExp对象或者一个字符串（这个字符串不会被转换成正则表达式），第二个参数可以是一个字符串或者一个函数

  • 如果第一个参数是字符串，那么只会替换第一个字符串。要想替换所有子字符串，唯一的办法就是提供一个正则表达式，而且要指定全局(g)标志

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

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

function htmlEscape(text){
	return text.replace(/[<>"&]/g,function(match,pos,originalText){
		switch(match){
			case "<":return "&lt;";
			case ">":return "&map;";
			case "\"":return "&quot;";
		}
	};)
}
alert(htmlEscape("<p class=\"greeting\">Hello world!</p>"));
//&lt;p class=&quot;greeting&quot;&gt;Hello world!&lt;/p&gt;

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

var text=new String("cat,bat,sat,fat");
var result=text.replace("at","ond");
alert(result);//"cond,bat,sat,fat"
//传入replace()方法的是字符串"at"和替换用的字符串"ond"。替换的结果是把"cat"变成了"cond"，但字符串中的其他字符并没有收到任何影响

result=text.replace(/at/g,"ond");
alert(result);//"cond,bond,sond,fond"
//通过将第一个参数修改为带有全局标志的正则表达式，就将全部"at"都替换成了"ond"

var text=new String("cat,bat,sat,fat");
result=text.replace(/(.at)/g,"word($1)");
alert(result);//word(cat),word(bat),word(sat),word(fat)
//在此，每个以"at"结尾的单词都被替换了，替换结果是"word"后跟一对圆括号，而圆括号中是被字符序列$1所替换的单词

• split()

  • split()方法可以基于指定的分隔符将一个字符串分隔成多个字符串，并将结果放在一个数组中。分隔符可以是字符串，也可以是一个RegExp对象（这个方法不会将字符串看成正则表达式）

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

  • 对split()正正则表达式的支持因浏览器而异。尽管对于简单的模式没什么差别，但对于未发现匹配项及带有捕获组的模式，匹配的行为大不相同

    • IE8及之前版本会忽略捕获组。ECMA-262规定应该把捕获组拼接到结果数组中。IE9能正确地在结果中包含捕获组

    • Firefox 3.6及之前版本在捕获组未找到匹配项时，会在结果数组中包含空字符串；ECMA-262规定没有匹配项的捕获组在结果数组中应该用undefined表示

var str = "Good good study day day up！";

//忽略参数：
var arr = str.split();
document.write(arr);
//返回：Good good study day day up！

//分割每个字符包括空格：
var arr = str.split('');
document.write(arr);
//返回：G,o,o,d, ,g,o,o,d, ,s,t,u,d,y, ,d,a,y, ,d,a,y, ,u,p,！

//使用空格作为分割符：
var arr = str.split(' ');
document.write(arr);
//返回：Good,good,study,day,day,up！

//规定返回数组的最大长度
var arr = str.split(' ', 3);
document.write(arr);
//返回：Good,good,study

//使用一个字符作为分割符：
var arr = str.split('d');
document.write(arr);
//返回：Goo, goo, stu,y ,ay ,ay up！

四、Number 对象

JS 只有一种数字类型，可以是整数，也可以是小数。整数最大可以有 15 位，小数最大可以有17位，在 JS 中小数运算并不是非常精确，所以大多数情况下，需要将小数转换为整数。

注意：整数的第一位不能为 0，否则会得到意想不到的结果。

var sum = 0.1 + 0.2;
alert(sum);
//返回：0.30000000000000004

(1) infinity 和 -infinity

• 当数字运算超过了 JS 所能表示的数字上限时，结果就为一个无穷大的值，在 JS 中用 infinity 表示。

• 当负数运算超过了 JS 的负数范围，结果就为一个负无穷大的值，也叫无穷小，在 JS 中用 -infinity 表示。

• 基于无穷大的加减乘数运算，他们的结果还是无穷大，并保留正负号。一个整数或者负数除以0，得到的都是无穷大。

(2) NaN

• NaN 表示非数字的特殊值，该属性用于指示一个值不是数字。

• 返回值为布尔值。

• 可以使用函数 isNaN() 判断一个值是否是 NaN 值。

var x = 123;
var y = 'abc';

alert(isNaN(x));    //返回：false
alert(isNaN(y));    //返回：ture

alert(x == y);    //返回：false
//NaN和NaN是不相等的。所以为假。

var a = 2/0；
alert(isNaN(a));    //返回：false
//无穷大是一个数字

(3) Number 对象属性：

• MAX_VALUE 和 MIN_VALUE

  • MAX_VALUE 表示最大的数，它的近似值为： 1.7976931348623157 x 10308。如果大于该数则表示无穷大。

  • MIN_VALUE 表示最小的数，它的近似值为：5 x 10-324，MIN_VALUE 是最接近 0 的数，但不是负值。比该属性小的值用 0 表示。

  • 由于他们都是 Number 对象的静态属性，只能通过 Number 调用，所以使用自定义的 Number 将无法获取属性，返回值为 undefined。

//JS最大数
alert(Number.MAX_VALUE);
//返回：1.7976931348623157e+308

//JS最小数
alert(Number.MIN_VALUE);
//返回：5e-324
 
//e为科学计数法：
var a = 123e5;
var b = 123e-5; 

alert(a);    //返回：12300000
alert(b);    //返回：0.00123

• POSITIVE_INFINITY和 NEGATIVE_INFINITY

  • POSITIVE_INFINITY 属性代表无穷大，表示比 MAX_VALUE 大的数。

  • NEGATIVE_INFINITY 属性表示负无穷大，表示比 MIN_VALUE 小的数。

  • 由于他们都是 Number 对象的静态属性，只能通过 Number 调用，所以使用自定义的 Number 将无法获取属性，返回值为 undefined。

(4) 格式化数值方法：

• toFixed()

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

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

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

  • 不同的浏览器给这个方法设定的舍入规则可能会有所不同。在给toFixed()传入0的情况下，IE 8及之前版本不能正确舍入范围在{(-0.94,-0.5],[0.5,0.94)}之间的值。对于这个范围内的值，IE会返回0，而不是-1或1；其他浏览器都能返回正确的值。IE 9修复了这个问题

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

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

• toExponential()

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

  • toExponential()也接受一个参数，而且该参数同样也是指定输出结果中的小数位数

var num=10;
alert(num.toExponential(1));//"1.0e+1"
//以上代码输出了"1.0e+1";不过，这么小的数值一般不必使用e表示法

• toPrecision()

  • toPrecision()方法可以以合适的格式表示某个数值的最合适格式

  • 对于一个数值来说，toPrecision()方法可能会返回固定大小(fixed)格式，也可能返回指数格式；具体规则看哪种格式符合

  • 这个方法接受一个参数，即表示数值的所有数字的位数（不包括指数部分）

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

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

(5) 检测

var numberObject=new Number(10);
var numberValue=10;
alert(typeof numberObject);//"object"
alert(typeof numberValue);//"number"
alert(numberObject instanceof Number);//true
alert(numberObject instanceof Number);//false

五、Math 对象

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

(1) min() 和 max() 方法

• min()：用于确定一组数值中的最小值，可以接受任意多个数值参数

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

• max()：用于确定一组数值中的最大值，可以接受任意多个数值参数

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

• applly()：找到数组中的最大值或最小值

  • 这个方法的关键是把Math对象作为apply()的第一个参数，从而正确的使之this值。然后，可以将任何数组作为第二个参数

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

var min = Math.min.apply(Math,values);
console.log(min);   //1

(2) 舍入方法

• Math.ceil() : 执行向上舍入，即它总是将数值向上舍入为最接近的整数

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

• Math.floor() : 执行向下舍入，即它总是将数值向下舍入为最接近的整数

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

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

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

(3) random()方法

• 可返回介于 0 ~ 1（大于或等于 0 但小于 1 )之间的一个随机数。

//获得一个随机数：
alert(Math.random());

//获得 0~10 之间的随机数：
alert(Math.random()*10);

//random ()方法和round()方法配合，可获得一个不大于10的整数：
alert(Math.round(Math.random()*10));

//随机数每次返回的值都不同。