ECMAScript《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());

得到的结果如图所示:

ECMAScript 1

别的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的兑现帮助那种格式。

譬如,要为二〇〇四年1九月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,5月是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 (中国标准时间)

说明下:

格林wich Mean 提姆e
(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()——以一定于完毕的格式突显星期几、月、日和年;

to提姆eString()——以一定于完结的格式展现时、分、秒和时区;

toLocaleDateString()——以一定与地方的格式显示星期几、月、日和年;

toLocale提姆eString()——以一定于贯彻的格式显示时、分、秒;

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)。
get提姆e() 重回 1970 年 1 月 1
日至今的飞秒数。
get提姆ezoneOffset()
重临本地时间与格林威治标准时间 (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)。
set米尔iseconds() 设置 Date 对象中的微秒 (0 ~
999)。
set提姆e() 以飞秒设置 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中时间new
Date()详解以及实例

岁月处理统计

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构造函数形式参数时字符串,所以再某些景况下要对字符进项双重转义。所有元字符都必须另行转义,如字面量模式为 style=”color: #ff0000;”>/\[bc\]at/,那么等价的字符串为 style=”color: #ff0000;”>"/\\[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对象

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