《JavaScript高级程序设计》笔记：引用类型（五）

Object类型

创建object实例方法有两种。第一种方法使用new操作符后跟object构造函数。如下：

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

第二种方法使用对象字面量表示法。如下：

var person={
    name:"Nicholas",
    age:29
}

Array类型

检测数组

使用instanceof操作符：

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

ECMAScript5新增加Array.isArray()方法。这个方法的目的是最终确定某个值到底是不是数组，而不管它是在哪个全局执行环境中创建的。这个方法如下：

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

IE9+及以上，其它主流浏览器兼容。

 转换方法

toLocaleString()方法

toString()方法

valueOf()方法

join()方法

所有对象都具有toLocaleString()、toString()、valueOf()方法。其中调用数组的toString方法会返回以数组中的每个值的字符串形式拼接而成的一个以逗号分割的字符串。

而调用valueOf()方法返回的还是数组。

var colors = ['red','blue','green'];
console.log(colors.toString());
console.log(colors.valueOf());
console.log(colors.toLocaleString());

得到的结果如图所示：

另外toLocaleString()方法经常会返回跟toString()和valueOf()方法相同的值。但也不是总如此。当调用数组的toLocaleString()方法时，它也会创建一个数组值的以逗号分割的字符串。而与前两个方法唯一不同的是，这一次为了取得每一项的值，调用的每一项的toLocaleString()方法，而不是toString()方法。如下面例子：

var person1 = {
    toLocaleString: function(){
        return "Nikolaos";
    },
    toString: function(){
        return "Nicholaos";
    }
}
var person2 = {
    toLocaleString: function(){
        return "Grigorios";
    },
    toString: function(){
        return "Greg";
    }
}

var person = [person1,person2];
alert(person); //Nicholaos,Greg
alert(person.toString()); //Nicholaos,Greg
alert(person.toLocaleString());//Nikolaos,Grigorios
    

说明：由于alert()要接收字符串参数，所有它会在后台调用toString()方法，得到跟直接调用toString()方法一样的结果。

数组继承的toLocaleString()、toString()、valueOf()方法，在默认情况下都会以逗号分割的字符串的形式返回数组项。可以使用join()方法，则可以使用不同的分隔符来构建这个字符串。

join()方法

join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。返回一个字符串。

var colors = ['red','blue','green'];
console.log(colors.join(',')); //red,blue,green
console.log(colors.join('||')); //red||blue||green

栈方法（后进先出）

栈是一种LIFO（Last-In-First-Out,后进先出）的数据结构，也就是最新添加的元素最早被移除。

ArrayObj.push()方法

ArrayObj.pop()方法

ArrayObj.push()：就是向数组末尾添加新的元素，返回的是数组新的长度。
ArrayObj.pop()：就是向数组中删除数组最后一个元素并且返回该元素。如果数组为空就返回undefined。

队列方法（先进先出）

ArrayObj.shift()

ArrayObj.unshift()

ArrayObj.shift():方法用于把数组中的第一个元素删除，并返回第一个元素的值。
如果数组是空的，则shift() 方法不进行任何操作，返回undefined。请注意，该方法不创建新数组，而是直接修改原来的数组。该方法会改变数组的长度。

ArrayObj.unshift() ：该方法可把它的参数顺序添加到数组的头部。它直接修改了数组，而不是创建一个新的数组。返回的是新数组的长度。 
unshift()在IE6，IE7下，数据有添加成功，但返回值却是undefined.

重排序方法

reverse()方法

sort()方法

reverse()方法会对反转数组项的顺序。

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

这里数组的初始值及顺序是1、2、3、4、5。而调用数组的reverse()方法后，其值的顺序变成了5、4、3、2、1。

sort()方法按升序排列数组——即最小的值位于最前面，最大的值排在最后面。为了实现排序，sort()方法会调用每个数组项的toString()转型方法，然后比较得到字符串，以确定如何排序。即使数组中的每一项都是数组，sort()方法比较的也是字符串，如下所示：

var values = [0, 1, 5, 10, 15];
values.sort();
alert(values);  //0,1,10,15,5

这种排序方式在很多情况下都不是最佳方案。因此sort()方法可以接受一个比较函数作为参数，以便我们指定那个值位于那个值的前面。

比较函数接受两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等，则返回0，如果第一个参数位于第二个之后则返回一个正数。以下就是一个简单的比较函数：

function compare(value1, value2) {
   if (value1 < value2) {
       return -1;
   } else if (value1 > value2) {
       return 1;
   } else {
       return 0;
   }
}

这个比较函数可以使用于大多数数据类型，只要将其作为参数传递给sort()方法即可，如下面这个例子所示：

var values = [0, 1, 2, 5, 10, 15];
values.sort(compare);
alert(values);  //0,1,5,10,15

在将比较函数传递到sort()方法之后，数值仍然保持了正确的升序。当然，也可以通过比较函数产生降序排序的结果，只要交换比较函数返回的值即可：

function compare(value1, value2) {
   if (value1 < value2) {
       return 1;
   } else if (value1 > value2) {
       return -1;
   } else {
       return 0;
   }
}
var values = [0, 1, 2, 5, 10, 15];
values.sort(compare);
alert(values);  //15,10,5,1,0

reverse()和sort()方法会返回值是经过排序之后的数组。

对于数值类型或者其valueOf方法会返回数值类型的对象类型，可以使用一个更简单的比较函数。这个函数只要用第二个值减第一个值即可：

function compare(value1, value2) {
   return value2 - value1;
}

由于比较函数通过返回一个小于零、等于零或大于零的值来影响排序结果，因此减法操作就可以适当处理所有情况。

操作方法

concat()方法

slice()方法

splice()方法

concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

<script type="text/javascript">

var a = [1,2,3];
document.write(a.concat(4,5));

</script>

输出的结果：1,2,3,4,5

简介slice()与splice()方法

slice(start,end)方法
start 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。 
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
返回值：返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。

splice() 方法用于插入、删除或替换数组的元素

语法：arrayObject.splice(index,howmany,element1,.....,elementX)

index 必需。规定从何处添加/删除元素。
该参数是开始插入和（或）删除的数组元素的下标，必须是数字。

howmany 必需。规定应该删除多少元素。必须是数字，但可以是 "0"。
如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。

element1 可选。规定要添加到数组的新元素。从 index 所指的下标处开始插入。 
elementX 可选。可向数组添加若干元素。

返回值：如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。
说明：splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。

下面简要概括一下slice()与splice()方法

slice(start, end); slice()方法返回从参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起死和结束位置之间的项，但不包括结束位置的项。

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);

console.log(colors2); // green, blue, yellow, purple
console.log(colors3); // green, blue, yellow

splice（）有删除，插入，替换的功能

删除
需要两个参数，要删除的第一项的位置和要删除的项数。

var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1);
console.log(colors); // greeen, blue
console.log(removed); // red

插入
需要三个参数：起始位置、0（要删除的项数）和要插入的项

var colors = ["red", "green", "blue"];
var removed = colors.splice(1,0,"yellow", "orange");
console.log(colors); // ["red", "yellow", "orange", "green", "blue"]
console.log(removed); // 返回空

替换
需要三个参数：起始位置、要删除的项数和要插入的任意数量的项。

var colors = ["red", "green", "blue"];
var removed = colors.splice(1,1,"yellow", "orange");
console.log(colors);  // ["red", "yellow", "orange", "blue"]
console.log(removed); // ["green"]

 位置方法

indexOf()方法

lastIndexOf()方法

ECMAScript5为数组实例添加了两个位置方法：indexOf()和lastIndexOf()。这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中indexOf()方法从数组开头（位置0）开始向后查找，lastIndexOf()方法则从数组的末尾开始向前查找。

这两个方法都返回查找的项在数组中的位置，或者没有查找到的情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符；也就是说要求查找的项必须严格相等（就像使用===一样）。

var numbers = [1,2,3,4,5,4,3,2,1];
console.log(numbers.indexOf(4));//3
console.log(numbers.lastIndexOf(4));//5
console.log(numbers.indexOf(4,4)); //5
console.log(numbers.lastIndexOf(4,4));//3
var person = {name:'Niccholas'};
var people = [{name:'Niccholas'}];
var morePeople = [person];
console.log(people.indexOf(person));//-1
console.log(morePeople.indexOf(person)); //0

支持的浏览器IE9+，FireFox2+，Safari3+，Opera9.5+和Chrome。

迭代方法

ECMAScript5为数组定义了5个迭代方法。每个方法都接收两个参数：要在每一项上运行的函数和（可选的）运行该函数的作用域对象——影响this的值。传入这些方法的函数会接收三个参数：数组项的值、该项在数组中的位置和数组对象本身。根据使用的方法不同，这个函数执行后的返回值可能会也可能不会影响访问的返回值。

every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。

filter()：对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。

forEach()：对数组中的每一项运行给定函数，这个方法没有返回值。

map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

some()：对数组中的每一项运行给定函数，如果该函数对某一项返回true，则返回true。

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

在这些方法中最相似的是every()和some()，他们都用于查询数组中的某一项是否满足某个条件。

var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.every(function(item,index,array){
    return (item > 2);
});
console.log(everyResult); //false

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

filter():

var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function(item,index,array){
    return (item > 2);
});
console.log(filterResult); //[3, 4, 5, 4, 3]

map():

var numbers = [1,2,3,4,5,4,3,2,1];
var mapResult = numbers.map(function(item,index,array){
    return (item * 2);
});
console.log(mapResult);  //[2, 4, 6, 8, 10, 8, 6, 4, 2]

forEach()：

这个方法没有返回值，本质上和使用for循环迭代数组一样。

支持的浏览器IE9+，FireFox2+，Safari3+，Opera9.5+和Chrome。

缩小方法

ECMAScript5还新增了两个缩小数组的方法。reduce()和reduceRight()方法。这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。其中reduce()方法从数组中的第一项开始，逐个遍历到最后。而reduceRight()则从数组的最后一项开始，向前遍历到第一项。

这两个方法都接收两个参数：一个在每一项上调用的函数和（可选）作为缩小基础的初始值。传给reduce()和reduceRight()的函数接收四个参数：前一个值、当前值、项的所有、数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代放生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数是数组的第二项。

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

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

reduceRight()方法相似，只是方法想法而已。

支持的浏览器IE9+，FireFox2+，Safari3+，Opera9.5+和Chrome。

Date类型

要创建一个日期对象，使用new操作符和Date构造函数即可：

var now = new Date();

 Date.parse()方法和Date.UTC()方法

其中Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应日期的毫秒数。ECAM-262没有定义Date.parse()应该支持哪种日期格式，因此这个方法的行为因实现而异，而且通常是因地区而异。将地区设置为美国的浏览器通常都接受下列日期格式：

"月/日/年"，如6/13/2004;

"英文月名 日,年"，如May 12,2004;

"英文星期几 英文月名 日 年 时:分:秒 时区"，如Tue May 25 2004 00:00:00 GMT+0800。

ISO 8601扩展格式YYYY-MM-DDTHH:mm:ss:sssZ（例如 2004-05-25T00::00:00）。只有兼容ECMAScript5的实现支持这种格式。

例如，要为2004年5月25日创建一个日期对象，可以使用下面的代码：

var someDate = new Date(Date.parse('May 25,2004')); //Tue May 25 2004 00:00:00 GMT+0800 (中国标准时间)

如果传入Data.parse()的方法的字符串 不能表示日期格式，会返回NAN。实际上，如果直接将表示日期的字符串传递给Date构造函数，也会在后台调用Date.parse()方法，例如下面的代码跟前面的是等价的。

var someDate = new Date('May 25,2004'); //Tue May 25 2004 00:00:00 GMT+0800 (中国标准时间)

 这行代码将会得到与前面一行相同的日期对象。

Date.UTC()方法

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));
console.log(y2k); //Sat Jan 01 2000 08:00:00 GMT+0800 (中国标准时间)

//GMT时间2005年5月5日下午5:55:55
var allFives = new Date(Date.UTC(2005,4,5,17,55,55));
console.log(allFives);//Fri May 06 2005 01:55:55 GMT+0800 (中国标准时间)

说明下：

Greenwich Mean Time (GMT)格林尼治标准时间英国、爱尔兰、冰岛和葡萄牙属于该时区。这个时区与中国北京时间的时差是8个小时，也就是说比北京时间晚8个小时。

比如，如果是北京时间的下午3:00，也就是这个时区的上午7:00。

Date构造函数

Date构造函数会模仿Date.UTC(),但有一点 不同的是，日期和时间都是基于本地时区而非GMT来创建。不过他们的参数跟Date.UTC()的参数一样。

例如：

//本地时间2000年1月1日午夜零时
var y2k = new Date(2000,0);
console.log(y2k); //Sat Jan 01 2000 00:00:00 GMT+0800 (中国标准时间)

//本地时间2005年5月5日下午5:55:55
var allFives = new Date(2005,4,5,17,55,55);
console.log(allFives);//Thu May 05 2005 17:55:55 GMT+0800 (中国标准时间)

Date.now()方法

ES5添加了Date.now()方法，返回表示这个方法时的日期和时间的毫秒数。这个方法简化了使用Date对象分析代码的工作，例如：

//取得开始时间
var start = Date.now();

//调用函数
dosomething();

//取得结束时间
var stop = Date.now(),
    result = stop - start;
console.log(start,stop,result); //1494292306763 1494292306768 5


function dosomething(){
    console.log('打印结果');
}

支持Date.now()方法的浏览器包括IE9+，FireFox3+，Safari3+，Opera10.5+和Chrome。在不支持的其它浏览器，使用+操作符把Date对象转成字符串，也可以达到相同的目的。

//取得开始时间
var start = +new Date();

//调用函数
dosomething();

//取得结束时间
var stop = +new Date(),
    result = stop - start;
console.log(start,stop,result); //1494292306763 1494292306768 5


function dosomething(){
    console.log('打印结果');
}

 继承的方法

与其它引用类型一样，Date类型也重写了toLocaleString()、toString()和valueOf()方法。

其中toLocaleString()、toString()在显示日期和时间没有什么价值；而valueOf()方法不是返回的字符串，而是返回日期的毫秒表示。因此可以方便使用比较操作符（大于或小于）来比较日期值。如下面的例子：

var date1 = new Date(2007,0,1);
var date2 = new Date(2007,1,1);
console.log(date1 < date2); //true
console.log(date1 > date2); //false

日期格式化方法

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

toDateString()——以特定于实现的格式显示星期几、月、日和年；

toTimeString()——以特定于实现的格式显示时、分、秒和时区；

toLocaleDateString()——以特定与地区的格式显示星期几、月、日和年；

toLocaleTimeString()——以特定于实现的格式显示时、分、秒；

toUTCString()——以特定于实现的格式完整的UTC日期。

与toLocaleString()和toString()方法一样，以上这些字符串格式的方法输出也是因浏览器而异的。因此没有哪一个方法能够用来在用户界面上显示一致的日期信息。

日期/时间组件方法

Date() 返回当日的日期和时间。
getDate() 从 Date 对象返回一个月中的某一天 (1 ~ 31)。
getDay() 从 Date 对象返回一周中的某一天 (0 ~ 6)。
getMonth() 从 Date 对象返回月份 (0 ~ 11)。
getFullYear() 从 Date 对象以四位数字返回年份。
getYear() 请使用 getFullYear() 方法代替。
getHours() 返回 Date 对象的小时 (0 ~ 23)。
getMinutes() 返回 Date 对象的分钟 (0 ~ 59)。
getSeconds() 返回 Date 对象的秒数 (0 ~ 59)。
getMilliseconds() 返回 Date 对象的毫秒(0 ~ 999)。
getTime() 返回 1970 年 1 月 1 日至今的毫秒数。
getTimezoneOffset() 返回本地时间与格林威治标准时间 (GMT) 的分钟差。
getUTCDate() 根据世界时从 Date 对象返回月中的一天 (1 ~ 31)。
getUTCDay() 根据世界时从 Date 对象返回周中的一天 (0 ~ 6)。
getUTCMonth() 根据世界时从 Date 对象返回月份 (0 ~ 11)。
getUTCFullYear() 根据世界时从 Date 对象返回四位数的年份。
getUTCHours() 根据世界时返回 Date 对象的小时 (0 ~ 23)。
getUTCMinutes() 根据世界时返回 Date 对象的分钟 (0 ~ 59)。
getUTCSeconds() 根据世界时返回 Date 对象的秒钟 (0 ~ 59)。
getUTCMilliseconds() 根据世界时返回 Date 对象的毫秒(0 ~ 999)。
setDate() 设置 Date 对象中月的某一天 (1 ~ 31)。
setMonth() 设置 Date 对象中月份 (0 ~ 11)。
setFullYear() 设置 Date 对象中的年份（四位数字）。
setYear() 请使用 setFullYear() 方法代替。
setHours() 设置 Date 对象中的小时 (0 ~ 23)。
setMinutes() 设置 Date 对象中的分钟 (0 ~ 59)。
setSeconds() 设置 Date 对象中的秒钟 (0 ~ 59)。
setMilliseconds() 设置 Date 对象中的毫秒 (0 ~ 999)。
setTime() 以毫秒设置 Date 对象。
setUTCDate() 根据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
setUTCMonth() 根据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCFullYear() 根据世界时设置 Date 对象中的年份（四位数字）。
setUTCHours() 根据世界时设置 Date 对象中的小时 (0 ~ 23)。
setUTCMinutes() 根据世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTCSeconds() 根据世界时设置 Date 对象中的秒钟 (0 ~ 59)。
setUTCMilliseconds() 根据世界时设置 Date 对象中的毫秒 (0 ~ 999)。

 可查看相应的使用以及说明：

• JS日期Date详解与实例扩展
• JS进阶Date format(日期格式化)

RegExp类型

ECMAScript通过RegExp类型支持正则表达式，如下：

var expression = /pattern/flags;

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

• g：表示全局模式,即模式将被应用到所有字符串，而非在发现第一个匹配项时立即停止。

• i：表示不区分大小写模式。

• m：表示多行模式，即在到达一行文本末尾时还在继续查找下一行中是否存在于模式匹配的项。

以字面量的形式来定义正则表达式

例如：匹配第一个bat或者cat,不区分大小写

var pattern = /[bc]at/i;

使用RegExp构造函数

它接收两个参数：一个是要匹配的字符串模式，另一个是可选的标志字符串。可以使用字面量定义的任何表达式，都可以使用构造函数来定义，还是以上面的例子为例：

var pattern = new RegExp("[bc]at","i");

注意:RegExp构造函数模式参数时字符串，所以再某些情况下要对字符进项双重转义。所有元字符都必须双重转义，如字面量模式为/[bc]at/,那么等价的字符串为"/\[bc\]at/"

例子：

var re = null,
    i;
    for(i=0; i < 10; i++){
        re = /cat/g;
        console.log(re.test("catastrophe"));
    }
    for(i=0; i < 10; i++){
        re = new RegExp("cat","g");
        console.log(re.test("catastrophe"));
    }

打印结果都为10个true

RegExp实例方法

exec

exec接收一个参数，即要应用模式的字符串，然后返回包含第一个匹配信息的数组。

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

var matches = pattern1.exec(text);
console.log(matches); // ["cat"]

match
match是字符串执行匹配正则表达式规则的方法，他的参数是正则表达

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

var matches2 = text.match(pattern1);
console.log(matches2); // ["cat"]

test
test()接收一个字符串参数

var text = "000-00-0000";
var pattern = /d{3}-d{2}-d{4}/;

if (pattern.test(text)){
    console.log("The pattern was matched"); // The pattern was matched
}

详细解释可查看《js正则表达式详解》

 Function类型

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

function sum(num1,num2){
return num1 + num2;
}
console.log(sum(10,10)); //20

var anotherSum = sum;
console.log(anotherSum(10,10)); //20

sum = null;
console.log(anotherSum(10,10)); //20

注意：使用不带圆括号的函数名是访问函数指针，而非调用函数。

没有重载（深入理解）

函数声明与函数表达式

作为值的函数

函数内部属性

在函数内部有两个特殊的对象：arguments和this。

把arguments转为数组

(function() {
    var slice = Array.prototype.slice,
        aArguments = slice.apply(arguments);

        console.log(aArguments);
})(10, 20, 30);

arguments.callee

该属性是一个指针，指向拥有这个arguments对象的函数。当函数在严格模式下运行时，访问arguments.callee会导致错误。

this

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

函数属性和方法

length

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

prototype

在es5中prototype属性是不可枚举的，因此使用for-in无法发现。

每个函数都包含两个非继承而来的方法：call()和apply()。他们的区别在于接收的参数方式不同。

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

传递参数并非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

es5还定义了一个方法：bind()方法，这个方法会创建一个函数的实例，其中this会被绑定到传给bind()函数的值。

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

function sayColor(){
console.log(this.color);
}

var objectSayColor = sayColor.bind(o);
objectSayColor(); //blue

sayColor调用bind()并传入o对象，创建了objectSayColor()函数,objectSayColor()函数的this值等于o。

因此即使是在全局作用域中调用这个函数，结果也是blue。

 基本包装类型

var value = "25";
var number = Number(value);
console.log(typeof number);
console.log(number instanceof Number);// false

var obj = new Number(value);
console.log(typeof obj);
console.log(obj instanceof Number);// true

Boolean类型

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

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

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(falseObject instanceof Boolean); //true
console.log(falseValue instanceof Boolean); // false

Number类型

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

String类型

字符方法

charAt() charCodeAt()

charAt()方法以单字符字符串的形式返回给定位置的那个字符串。

charCodeAt()返回的是字符编码。

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

字符串操作方法

concat()

concat()用于将一或多个字符串拼接起来。

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

slice(start, end)
end 表示字符串到哪里结束。
如果传入的是负数，slice()方法会将传入的负值与字符串长度相加。

var str="Hello happy world!";
console.log(str.slice(6)); // happy world!
console.log(str.slice(6,11));// happy
console.log(str.slice(-3)); // ld!
console.log(str.slice(3, -4)); //lo happy wo 

substring(start, end)
如果传入的是负数, substring()会把所有字符参数都转换为0

var str="Hello happy world!";
console.log(str.substring(6)); // happy world!
console.log(str.substring(6,11));// happy
console.log(str.substring(-3)); // Hello happy world!
console.log(str.substring(3, -4)); //Hel

substr(start, length)
如果传入的是负数，substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为0

var str="Hello world!";
console.log(str.substr(3)); //lo world!
console.log(str.substr(3, 7)); //lo worl
console.log(str.substr(-3)); // ld!
console.log(str.substr(3, -3)); // 空字符串

字符串位置方法

indexOf() lastIndexOf()

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

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

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

字符串的模式匹配方法

match()

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

var matches = text.match(pattern);
console.log(matches.index); //0
console.log(matches[0]); // cat
console.log(pattern.lastIndex); //0

search()

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

replace()

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

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

单体内置对象

Global对象

URI编码方法
Global对象的encodeURI()和encodeURIComponent()方法可以对URI(Uniform Resources Identifiers，通用资源标识符)进行编码，以便发送给浏览器。

var url = "http://www.baidu.com/";
console.log(encodeURI(url));
console.log(encodeURIComponent(url));

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

Math对象

Math.ceil()、Math.floor()、Math.round()

Math.ceil()执行向上取舍。

Math.floor()执行向下取舍。

Math.round()执行标准舍入。

例如：

console.log(Math.ceil(25.6)); //26
console.log(Math.ceil(25.1)); //26

console.log(Math.floor(25.6));//25
console.log(Math.floor(25.1));//25

console.log(Math.round(25.6));//26
console.log(Math.round(25.4));//25

Math.random()方法

Math.random()方法返回介于0和1之间一个随机数，不包含0和1。对于某些站点来说，这个方法非常实用，因为可以利用它来随机显示一些名言和新闻事件。套用下面的公式，就可以利用Math.random()从某个整数范围内随机选择一个值。

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

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

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

function selectFrom(lowerValue,upperValue){
    var choice = upperValue - lowerValue + 1;
    return Math.floor(Math.random()*choice+lowerValue);
}

var num = selectFrom(2,10);
console.log(num);

var colors = ["red", "green", "blue", "yellow", "black", "purple", "brown"];
var color = colors[selectFrom(0, colors.length-1)];
console.log(color);