《JavaScript高级程序设计》——JS中其他对象与常用方法

//Date对象
console.log(Date.parse("Mon Apr 04 2016 10:45:49 GMT+0800"));		//转换为格林威治标准时间（毫秒数）
var d = new Date(Date.parse("Mon Apr 04 2016 10:45:49 GMT+0800"));
console.log(d);							//输出了时间
console.log(new Date("Mon Apr 04 2016 10:45:49 GMT+0800"));			   //输出了同样的时间，传入一个字符串，会自动调用Date.parse方法。

console.log(Date.UTC(2014,4,4,18,55,55));			//UTC：将多个数值类型读取为时间，并返回毫秒数。
console.log(new Date(2014,4,4,18,55,55));    			 //另一种方法：调用了Date.UTC(参数中只有前两个参数是必须的。)

console.log(Date.parse("Mon Apr 04 2016 10:45:49 GMT+0800"));				//基于GMT
console.log(Date.UTC(2016,4,4,10,45,49));						//基于本地时区。

var start = Date.now();			//获取当前时间
for(var i=0;i<1000000000;i++){
continue;
}
var end = Date.now();
console.log(end-start);

var start = +new Date();		//达到同样效果。（用+将date转换为字符串，在有些不支持Date.now()的浏览器中可以这样做。）
for(var i=0;i<1000000000;i++){
continue;
}
var end = +new Date();
console.log(end-start);

console.log(new Date().toString());
console.log(new Date().toLocaleDateString());		//根据浏览器地区输出字符串。(具体格式因浏览器而异)

console.log(new Date() < new Date());              //自动调用了valueOf方法。

//正则对象
var pattern1 = /.+at/i;		//i：不区分大小写。
console.log(pattern1.test("CcccccccAt"));

var pattern2 = /\[.\]at/i;	//鉴别"[" "]"用转义字符
console.log(pattern2.test("[W]aT)"));

var pattern31 = /.at/i;
var pattern32 = new RegExp(".at","i");            //这两种方法等价

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"));		//每次创建的都是新实例（所以一直输出true）
}

var re = new RegExp("\\[cat\\]","g");
console.log(re.source);                    //source属性：按照字面量形式返回(\[cat\])。

var re = /cat/g;
console.log(re.test("catastrophecat"));
console.log(re.lastIndex);       //返回3（下一个匹配项的位置）。

var re = /[a-z]at/g;
console.log(re.exec("catastrophecat"));		//cat，输出了符合要求的数组。

var re = /[a-z]at/g;
console.log(re.toString());
console.log(re.toLocaleString());			//这两个方法都是输出字面量正则表达式。

var re = /[a-z]at/g;
console.log(re.$_);		//相当于re.input（长属性名和短属性名）

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

if(pattern.test(text)){
console.log(RegExp.input);
console.log(RegExp.lastMatch);
console.log(RegExp.leftContext);      //RegExp中的方法，基于最近一次正则表达式的操作而变化。
}

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

reg.test(text);
console.log(RegExp.$1);					//用RegExp的属性返回捕获组,$1是第一组，$2是第二组，类推。捕获组：正则表达式中括号中的内容。
console.log(RegExp.$2);

var text = "this has been a short summer";
var reg = /^this has been a short summer$/g;	//表示字符串开始，$表示结束。
console.log(reg.test(text));

//函数对象
var sum1 = function(num1,num2){
return num1+num2;
};

function sum2(num1,num2){
return num1+num2;
}
//两种声明方法相差无几

console.log(sum1(2,3));
console.log(sum2(2,3));

var sum3 = new Function("num1","num2","return num1+num2");
//用Function创建函数，有助于理解函数是对象，参数是指针。不过不推荐（二次解析，影响性能。）
console.log(sum3(2,3));

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

var anotherSum = sum;
sum = null;

console.log(anotherSum(2,3));		//理解：函数是一个对象，函数名为指向实例的指针。

console.log(sum1(2,3));
function sum1(num1,num2){		//解析器进行了函数声明提升，代码在定义函数之前就可以访问到。
return num1+num2;
}

console.log(sum2(2,4));
var sum2 = function(num1,num2){		//因为函数被初始化语句定义，解析器不会进行函数声明提升，所以语句出错。
return num1+num2;
}
//除了什么时候访问函数之外，函数声明和函数表达式是等价的。（使用函数声明，编译器会进行函数声明提升，在函数之前就可以访问到。）

function sayHello(){
return "Hello";
}

function greeting(method,name){
return method(name)+" "+name;
}

console.log(greeting(sayHello,"Steve"));		//函数也可以作为一个参数传递。要访问函数的指针而不是执行函数，不要加圆括号。

function createComparisonFuncion(propertyName){		//可以将函数作为返回值：此函数意为传入一个属性名，返回一个指定比较器。可以理解成比较器生成器。
return function(object1,object2){
var value1 = object1[propertyName];				//用变量操作属性名：方括号表示法。
var value2 = object2[propertyName];
if(value1<value2){
return -1
} else if(value1>value2) {
return 1;
}
return 0;
}
}

var persons = new Array();
var p1 = {
name: "Steve",
age: 28
}
var p2 = {
name: "Jack",
age: 32
}
var p3 = {
name: "Erison",
age: 50
}
var p4 = {
name: "Bill",
age: 15
}
persons.push(p1);
persons.push(p2);
persons.push(p3);
persons.push(p4);
console.log(persons[1].age);
persons.sort(createComparisonFuncion("age"));		//用函数创建的比较器进行比较。
console.log(persons[1].age);				//值改变了

function factorial(num){
if(num==1)
return 1;
return num*factorial(num-1);		//经典递归阶乘函数
}
console.log(factorial(5));

function factorial(num){
if(num==1)
return 1;
return num*arguments.callee(num-1);	//复写：修正了函数中语句与函数名的耦合性（使用arguments.callee()调用本函数）
}

var trueFactorial = factorial;
factorial = function(){
return 0;
}
console.log(factorial(5));
console.log(trueFactorial(5));		//解除了耦合性以后，就算修改指针名，也不会造成函数出错（因为在函数中不再调用指针名）。

window.color = "blue";

var o = {
color: "red"
};

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

sayColor();				//调用时的this是全局变量。
o.sayColor = sayColor;			//当把sayColor方法赋给o时，sayColor中的this指的就是环境对象：o对象，所以输出的是o的color属性
//对this.color求值变成了对o.color求值。
o.sayColor();

function letSayHi(){
sayHi();
}
function sayHi(){
console.log(arguments.callee.caller);		//arguments.callee：表示本函数	输出函数调用过程中调用此函数的函数(caller)的源代码
}							//严格模式会发生错误：不允许查看源代码，加强安全性。

function fun(arg1,arg2,arg3){
return 0;
}
console.log(fun.length);			//函数的length属性：返回函数定义的参数个数。

//apply方法
function sum(num1,num2){
return num1+num2;
}

function callSum1(num1,num2){
return sum.apply(this,[num1,num2]);
}

function callSum2(num1,num2){
return sum.apply(this,arguments);
}

console.log(sum(2,3));
console.log(callSum1(2,3));
console.log(callSum2(2,3));				//调用apply的两种方法。传入环境，再传入参数数组或者arguments。如果不指定this，则自动转型为window
//因为函数在全局环境中调用，所以这里的this就是window

//call	方法
functio	n sum(num1,num2){
return num1+num2;
}

function callSum1(num1,num2){
return sum.call(this,num1,num2);		//call与apply的不同：call是直接把参数传递，而不是传入数组或者arguments（传递给函数的参数需要逐个列举）。
}

console.log(callSum1(2,3));

//apply与call的作用：扩充函数作用域。

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

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

sayColor.call(this);			//red
sayColor.call(window);			//red
sayColor.call(o);			//blue		函数的环境对象被指向了o。
//好处：对象不需要与方法有任何的耦合关系（不需要将方法放到对象内再调用对象内的方法）。
oSayColor = sayColor.bind(o);	//新建了一个函数实例，将环境对象设置为o
oSayColor();					//blue

//基本包装类型

//String
var s1 = "hehe";
var s2 = s1.substring(2);		//s2是基本类型，但是调用了它的对象。
//后台处理过程：1.将s2包装成类 2.调用s2的subString方法 3.销毁s2的类
//自动创建的基本包装类型，会在代码执行完立即被销毁（只存在一瞬间）。

var s1 = "some text";
s1.color = "red";
console.log(s1.color);			//undefined
console.log(s1.color="red");	//red
//原因，对象只执行了一瞬间就被销毁，只有在执行的时候去访问才能访问到该对象的属性。

var obj = new Object("some text");		//传入字符串会得到String的实例，传入数值会得到Number的实例，传入布尔值会得到Boolean的实例。
console.log(typeof obj);		//基本包装类型是Object

//Number

var number = Number(25);
console.log(typeof number);		//number

var obj = new Number(25);
console.log(typeof obj);		//object
//加不加new不一样。不加new是类型转换函数，加上new是新建object实例的构造函数。

var falseObject = new Boolean(false);
if(falseObject){
console.log("object is true");	//boolean对象不管false还是true都会被转换成true。所以容易造成误解。
}
//Boolean对象和布尔值的区别：1.typeof返回值不同，一个object（Boolean），一个boolean（boolean）。
//2.instanceof Boolean，一个返回true（Boolean），一个返回false（boolean）。
//建议不要使用Boolean对象。

var num = new Number(20);
console.log(num.toString(16));		//使用16进制toString
console.log(num.toFixed(3));		//格式化字符串——toFixed():指定小数点后位数

var num2 = 10.005;
console.log(num2.toFixed(2));		//原来位数比指定的大，会四舍五入。

console.log(num2.toExponential(3));	//用科学记数法返回，可传入小数位数，会四舍五入

console.log(num2.toPrecision(1));	//1e+1 指定显示的数字所有位数的数值，返回最合适的方法（舍入或科学记数法）因为用1位只能用科学记数法表示。
console.log(num2.toPrecision(4));	//10.01 不用科学记数法比较精确。

//String

var hello = new String("Hello");
var result1 = hello.concat("world");
console.log(result1);				//Helloworld
console.log(hello);              	//Hello			原字符串不变，而是返回了一个拼接以后的新字符串。（相当于'+'）
var result2 = hello.concat("world1","world2","world3","world4")
console.log(result2);               //Helloworld1world2world3world4 说明可以同时传入多个参数，一并连接。

/*
切割：
slice,substring: 		从…到…
substr：			从…取…
负数：
slice：				负值与字串长度相加
substring：			负值变为0
substr：			如果第一个值是负值，与字串长度相加（负值想当于倒着取的位数）
注意：substring以两个参数中较小一个作为起始位置，顺序无所谓。
*/

var hello = new String("Hello World");
console.log(hello.substr(-3));		//llo		substr:将负的第一个参数与字符串长度相加
console.log(hello.slice(-3));		//llo		slice:将负数与字符串长度相加
console.log(hello.substring(-3));	//Hello		substring:将所有负数值转换为0
*/
/*
*	 理解：	slice		相当于“选取”。最短小，所以最灵活，所以两个值都可以传入负数，表示从后往前取的位数
* 		substring	相当于“切割”，因为两个值的前后顺序无所谓（太万能了），所以不能传入负数表示从后往前取，传入负数自动变成0。
* 		substr		是另一种切割，表示从第几位往后取几位，不能往前选，所以传入的第二个负数等于0，而第一个参数若是负数，就和字串长度相加（表示从后往前取负数的绝对值位）。
*/

var hello = new String("Hello World");
console.log(hello.substr(-6,5));
console.log(hello.slice(-6,5));			//等于从第（-6+11）=5位到第5位，所以是空串。
console.log(hello.substring(7,5));		//相当于substring(-6,5)，从较小的那一位（5）开始，取到较大的那一位（7）。

//寻找所有制定字母的位置并返回。

var hello = new String("don't you dare let all there memory bring you sorrow,yesterday i saw a lion kissed a dear.");
var positions = new Array();
var pos = hello.indexOf("e");		//先寻找一次，初始条件。
while(pos>-1){				//找不时会返回-1，所以以-1为条件。
positions.push(pos);
pos = hello.indexOf("e",pos+1);
}
console.log(positions);		//13,16,25,27,30,54,57,80,86

var reg = /[abc]At/ig
var s = new String("catCaT");
console.log(s.match(reg));		//返回与正则表达式相符合的值，返回值是一个数组。cat,CaT

console.log(s.search(reg));		//0,返回第一个匹配项的索引。
console.log(s.search(reg));

var reg = /[abc](At)/ig;
var s = new String("catCaT");

var result = s.replace(reg,"F$1");		//FatFaT：替换指定字符加上匹配之前的第一组。
console.log(result);

reg = /([Cc])/g							//将c的大小写转换：捕获组并传入一个转换函数
var result2 = s.replace(reg,function(match){
switch(match){
case "c": return "C";
case "C": return "c";
}

});
console.log(result2);

var colors = "blue&yellow&green&red&black";
console.log(colors.split(/&/));			//"blue,yellow,green,red,black" 通过正则进行切割
console.log(colors.split(/[^&]+/));		//,&,&,&,&,  根据"&"进行切割。包含两个空字符串原因：通过正则表达式指定的分隔符出现在了字符串的开头和末尾。（？）

//localeCompare：比较字符串是否大于其参数。 由地区决定，比如美国的大写字母排在小写字母之前。
var hello = "hello";
var hellO = "hellO";
console.log(hello.localeCompare(hellO));		//-1 因为字符串在字母表中的位置在其参数之前。
console.log(hellO.localeCompare(hello));		//1	因为字符串在字母表中的位置在其参数之后。
console.log(hello.localeCompare(hello));		//0	因为相等

console.log(String.fromCharCode(65,66,67,68,69,70));		//ABCDEF：根据ASCII码获取字符并拼接成字符串。

//URI
var uri = "https://detail.tmall.com/item.htm?spm a1z0d.6639537.1997196601.4.uhl1y7&id=521502059389";

console.log(encodeURI(uri));					//不会对本身属于URI的特殊字符编码。对应decodeURI()方法
console.log(encodeURIComponent(uri));			//对任何非标准字符进行编码。		对应decodeURIComponent()方法

var encodeUri = "https%3A%2F%2Fdetail.tmall.com%2Fitem.htm%3Fspm%20Da1z0d.6639537.1997196601.4.uhl1y7%26id%3D521502059389";
console.log(decodeURI(encodeUri));				//解码失败（只解码了空格）
console.log(decodeURIComponent(encodeUri));		//解码成功

eval("console.log('hehe')");		//hehe eval：以字符串的方式执行语句，可以将字符串中所有语句当作代码执行。

var global = function(){		//获取window对象。
return this;
}();

var values = [1,2,3,4,5,6,7,8,9];
console.log(Math.max.apply(Math,values));		//通过apply方法用数组执行Math.max

//返回lowerValue和upperValue之间的随机整数。
function selectFrom(lowerValue,upperValue){
return Math.floor(Math.random()*(upperValue-lowerValue+1)+lowerValue);
}

console.log(selectFrom(2,10));