《JavaScript高级程序设计》总结——第5章：引用类型

一段开头：
1：引用类型的值（对象）是引用类型的一个实例。引用类型是一种数据结构，用于将数据和功能组织在一起。他也常常被称为类，但这种称呼并不妥当，尽管ECMAScript从技术上讲是一门面向对象的语言，但它不具备传统的面向对象语言所支持的类和接口等基本结构，引用类型有时也被称为对象定义，因为他描述的时一类对象所具有的属性和方法:；
2：如前所述对象是某个特定引用类型的实例。新对象是使用 new 操作符后跟一个构造函数来创建的。构造函数本身就是一个函数，只不过该函数是出于创建新对象的目的而定义的。请看下面这行代码：
var person = new Object();
这行代码创建了 Object 引用类型的一个新实例，然后把该实例保存在了变量 person 中。使用的构造函数是 Object，它只为新对象定义了默认的属性和方法。ECMAScript 提供了很多原生引用类型（例如 Object），以便开发人员用以实现常见的计算任务;

Object类型

1：目前我们看到的大多数引用类型值都是Object类型的实例；
2：创建Object实例的两种方式

• new 操作符

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

• 对象字面量表示法

var person = {
	name:"juan",	//属性名也可以用字符串表示如"name"
	age:25
}

3：访问对象属性两种方式

• person.name;
• person[“first name”]; //必须用变量访问属性时使用

---

Set类型

1：类似于数组，但是成员唯一

const s = new Set();
[1,2,3,4,5,5,5].forEach(x=> s.add(x));
for(let i of s){
	console.log(i);
}//1,2,3,4,5
//例一
const items = new Set([1,2,3,4,5,5,5]);
[...items];		//1,2,3,4,5
items.size;		//5
items.length;	//undefined？？为啥是undefined
//例二
const items2 = new Set(document.querySelectorAll("li"))

Array类型

1：ECMAScript数组的每一项可以是任何类型的数据；
2：ECMAScript数组的大小是可以动态调整的，随数据的添加自动增长以容纳新增数据；
3：创建数组两种方式

• Array构造函数
  • var colors = new Array(); //new可省略
  • var colors = new Array("pink","red");
  • var colors = new Array(20);
  • var colors = Array();
• 数组字面量表示法
  • var numbers = [1,2,3,4]; //可以不赋值

4：Array的length属性可修改，没有值的位置是undefined；
5：检测某对象是否为数组两种方式

• 方法一：instanceof方法

names instanceof Array;	//true(局限性：instanceof操作符认为页面只有一个全局执行环境，所以若页面有框架不适用)

• 方法二：isArray()函数

Array.isArray(names);	//局限性：低版本浏览器不支持

• 兼容性方案

6：所有对象都有toLocaleString()，toString()，valueOf()方法；
7：调用数组**toString()**方法：返回数组中每个值的字符串形式拼接而成的一个以逗号分割的字符串；(实际上创建这个字符串会调用数组每一项的toString()方法)

8：调用数组valueOf() 方法：返回的还是数组；
9：调用数组toLocalString() 方法：返回值与toString()相同(但是实际上创建这个字符串会调用数组每一项的toLocalString()方法)；
10：调用数组的join(“指定分隔符”)方法：返回数组中每个值的字符串形式拼接而成的一个以指定分隔符分割的字符串；
11：两个栈方法

• colors.pop(); //删除数组最后一个元素，返回被删除元素
• colors.push("green"，5); //在数组末尾添加"green",5，返回新数组长度

12：两个队列方法

• colors.shift(); //删除数组第一个元素，返回被删除元素
• colors.unshift("yellow","blue"); //在数组首部添加元素"yellow","blue",并返回新数组长度

13：两个数组重排序方法

• numbers.reverse(); //返回[4,3,2,1]
• numbers.sort(); //可接收一个比较函数,返回排序后数组

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

14： concat()方法

• concat()可以基于当前数组中所有项创建一个新数组；
• 若传递给 concat()方法的是一或多个数组，则该方法会将这些数组中的每一项都添加到结果数组中；
• 若传递的值不是数组，这些值就会被简单地添加到结果数组的末尾；

var colors = ["red","green"];
var numbers = [5,2];
var colors2 = colors.concat();	//返回colors副本
var colors3 = colors.concat("red");	//["red", "green", "red"]
var colors4 = colors.concat(numbers);	//["red", "green", 5, 2]

15：slice()方法

• 基于当前数组中的一或多个项创建一个新数组，不影响原数组；
• 接受一个或两个参数：返回项的开始和结束位置；

var colors = ["red","green"];
var colors2 = colors.slice(0);	//["red","green"]
var colors3 = colors.slice(1,1);	//["green"]
var colors4 = colors.slice(-2,1);	//["red"]

16：splice()

• 向数组指定位置添加或删除项

colors.splice(2,2,"red","green");	//会从当前数组的位置 2 开始删除两项，插入字符串"red"和"green"

17：位置方法

• colors.indexOf("red",0); //在colors数组中从索引0开始查找元素"red"，并返回其索引位置
• colors.lastIndexOf("red",5); //在colors数组中从索引5开始向前查找元素"red"，并返回其索引位置

18：数组的5个迭代方法

• every()：对数组中的每一项运行给定函数，每项都true返回true，用于查询数组中的项是否满足某个条件；

var colors = [1,2,3,4,5,6];
var result = colors.every(function(item,index,array){
	return (item>0);
})
console.log(result);	//true

• some()：对数组中的每一项运行给定函数，一项为true即返回true，用于查询数组中的项是否满足某个条件；

var colors = [1,2,3,4,5,6];
var result = colors.some(function(item,index,array){
	return (item>5);
})
console.log(result);	//true

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

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

• map()：返回运行的结果数组；

var colors = [1,2,3,4,5,6];
var result = colors.map(function(item,index,array){
	return (item+4);
})
console.log(result);	//[5,6,7,8,9,10]

• forEach()：无返回值，和for循环差不多，用于循环访问集合以获取所需信息；

19：两个归并方法

• reduce()：从前往后迭代数组的所有项，然后构建一个最终返回的值；
• reduceRight()：从后往前迭代数组的所有项，然后构建一个最终返回的值；
  • 传给他俩的函数都接受四个参数：前一个值，当前值，项的索引，数组对象
    使用reduce()计算数组和

var numbers = [1,2,3,4];
numbers.reduce(function(prev,cur,index,array){
	return prev+cur;
})	//10

Date类型

1：创建日期对象的方法

var now = new Date();	//使用new 操作符创建Data实例
var time2 = new Date();

2：Date类型使用UTC（Coordinated Universal Time，国际协调时间）1970年1月1日午夜（零时）开始经过的毫秒数来保存日期；
3：在调用 Date 构造函数而不传递参数的情况下，新创建的对象自动获得当前日期和时间；若想根据特定的日期和时间创建日期对象，必须传入表示该日期的毫秒数（即从 UTC 时间 1970 年 1 月 1 日午夜起至该日期止经过的毫秒数）；
4：**Date.parse()**方法（感觉不太好用，浏览器实现也不同，地区不同结果也不同）

• 接受一个表示日期的字符串参数，然后尝试根据这个字符串返回相应日期的毫秒数，该方法因实现而异，通常因地区而异；

var someDate = new Date(Date.parse("May 25, 2004")); 
var someDate = new Date("May 25, 2004"); 	//Date也会调用Date.parse()

5：**Date.UTC()**方法

• 接受的参数：年份（必须），基于0的月份（必须），月中的哪一天，小时数，分钟，秒，毫秒数；（若未提供月中的天数，假设天数为1，若省略其他参数，统统假设为0）；

var someDate2 = new Date(Date.UTC(2000,0));	//GMT时间2000年1月1日0点0时0分
var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));	//GMT 时间 2005 年 5 月 5 日下午 5:55:55 

6：**Data.now()**方法（ECMAScript新增）

• 表示调用这个方法时的日期和时间的毫秒数；
• 使用

//在支持Date.now()方法的浏览器
//取得开始时间
var start = Date.now(); 
//调用函数
doSomething(); 
//取得停止时间
var stop = Date.now(), 
 result = stop – start; 

//在不支持Date.now()方法的浏览器，使用+操作符即可
//取得开始时间
var start = +new Date(); 
//调用函数
doSomething(); 
//取得停止时间
var stop = +new Date(), 
 result = stop - start; 

7：继承的方法
（1）与其他引用类型一样，Date类型也重写了toLocaleString()、**toString()**和 **valueOf()**方法
（2）toLocaleString()方法：按照与浏览器
设置的地区相适应的格式返回日期和时间。这大致意味着时间格式中会包含 AM 或 PM，但不会包含时区信息（浏览器不同返回结果不同）；（没啥用）
（3）toString()方法：返回带有时区信息的日期和时间，其中时间一般以军用时间（即小时的范围是 0 到 23）表示；（没啥用）
（4）valueOf() 方法：返回日期的毫秒，可用来比较时间数；

var date1 = new Date(2007, 0, 1); //"January 1, 2007" 
var date2 = new Date(2007, 1, 1); //"February 1, 2007" 
alert(date1 < date2); //true 
alert(date1 > date2); //false 

8：日期格式化为字符串的方法

• toDateString()——以特定于实现的格式显示星期几、月、日和年；
  date1.toDateString() //"Mon Jan 01 2007"
• toTimeString()——以特定于实现的格式显示时、分、秒和时区；
  date1.toTimeString() //"00:00:00 GMT+0800 (中国标准时间)"
• toLocaleDateString()——以特定于地区的格式显示星期几、月、日和年；
  date1.toTimeString() //"2007/1/1"
• toLocaleTimeString()——以特定于实现的格式显示时、分、秒；
  date1.toTimeString() //"上午12:00:00"
• toUTCString()——以特定于实现的格式完整的 UTC 日期;
  date1.toUTCString() //"Sun, 31 Dec 2006 16:00:00 GMT"
  9：日期/时间组件方法
• UTC日期值得是在没有时区偏差的情况下（将日期转换为GMT时间）的日期值
• 直接取得和设置日期值中特定部分的方法
  （太多了懒得写了）

方法	说明
getTime()	返回表示日期的毫秒数；与valueOf()方法返回的值相同
setTime(毫秒)	以毫秒数设置日期，会改变整个日期
getFullYear()	取得四位数的年份
getUTCFullYear()	返回UTC日期的4位数年份
setFullYear(年)	设置日期的年份,传入4位数字
setUTCFullYear(年)	设置UTC日期的年份。传入的年份值必须是4位数字（如2007而非仅07）
getMonth()	返回日期中的月份，其中0表示一月，11表示十二月
getDate()	返回日期月份中的天数（1到31）
getHours()	返回日期中的小时数（0到23）
getMinutes()	返回日期中的分钟数（0到59）
getSeconds()	返回日期中的秒数（0到59）
getMilliseconds()	返回日期中的毫秒数
getTimezoneOffset()	返回本地时间与UTC时间相差的分钟数。例如，美国东部标准时间返回300。在某地进入夏令时的情况下，这个值会有所变化

RegExp类型

1：两种创建语法

• 方法一：构造函数

var pattern1 = /[bc]at/i;
var pattern2 = new RegExp("[bc]at", "i");	//传递给RegExp构造函数的两个参数都是字符串，所以在某些情况下要对字符进行双重转义;
// 字面量模式    /\[bc\]at/
// 等价的字符串  "\\[bc\\]at" 

• 方法一：字面量形式

var expression = / pattern / flags ;

2：二者区别
ECMAScript3中使用正则表达式字面量始终会共享一个ReExp实例，而用构造函数创建的没一个新RegExp实例都是一个新实例；
ECMAScript5中明确规定：使用正则表达式字面量必须像直接调用 RegExp 构造函数一样，每次都创建新的 RegExp 实例；

3：flags

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

• 模式中使用的所有元字符都必须转义；
  ( [ { \ ^ $ | ) ? * + .]}

4：RegExp 的每个实例都具有下列属性
（这些属性可以获知正则表达式的各方面信息，但是没多大用处，因为这些信息全都包含在模式声明里）

属性名	说明
global	布尔值，表示是否设置了g标志
ignoreCase	布尔值，表示是否设置了i标志
m	布尔值，表示是否设置了m标志
lastIndex	整数，表示开始搜索下一个匹配项的位置
source	返回正则表达式的字面量形式，而非传入构造函数的字符串模式

5：RegExp对象的三个方法
（1） exec() 方法

• 检索字符串中的正则表达式的匹配;
• 若字符串中有匹配的值返回该匹配值，若无返回 null；
• 返回的数组是Array的实例，但是额外包含两个属性：
  • index：匹配项在字符串中的位置；
  • input：应用正则表达式的字符串；

var text = "mom and dad and baby";
var pattern = /mom( and dad(and baby)?)?/gi;
var matches = pattern.exec(text);
console.log(matches.index);	//0
console.log(matches.input);	//"mom and dad and baby"
console.log(matches[0]);	//"mom and dad and baby" 
console.log(matches[1]);
console.log(matches[2]);

（2）：RegExp对象的 test() 方法

• 检索字符串中指定的值，返回 true 或 false；
• RegExpObject.test(string)；

（3）：RegExp对象的 toString() 方法

• 返回正则表达式的字符串；

6：支持正则表达式的String 对象的四个方法
（1）search() 方法

• 检索与正则表达式相匹配的值并返回匹配字符串的起始索引位置；
• String.search(“字符串”);

var str = "Hello World!";
var n = str.search("World");	//n=6
var m = str.search(/World/i);	//m=6

• String.search(regexp);

（2）：match()方法（支持正则表达式的 String Object的方法）

• string.match(regexp)
• 检索字符串 String Object，以找到一个或多个与 regexp 匹配的文本；
• 若正则表达式无标志g：match()方法只能在stringObject中执行一次匹配，若无匹配，返回null；
• 若正则表达式有标志g：返回一个数组；

（3）：split()方法 （支持正则表达式的 String 对象的方法）

• 把字符串分割为字符串数组；
• 不改变原数组；

var str="Hello";
var n=str.split("");
console.log(n);	//["H","e","l","l","0"];

（4）：replace()方法（支持正则表达式的 String 对象的方法）

• 替换与正则表达式匹配的子串;

var str = "Hello";
var m = str.replace(/[heo]/gi,"l");	//"lllll"
var n = str.replace("H","l");	//"lello"

7：RegExp构造函数属性

• 六个属性，四个Opera都不支持，一个IE不支持，先不看了

Function类型

1：函数实际上是对象；
2：每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法；
3：由于函数是对象，因此函数名是一个指向函数对象的指针，不会与某个函数绑定；
4：使用不带括号的函数名是访问函数指针而非调用函数；

function sum(num1,num2){
	return num1+num2
}
var anotherSum = sum;	//anotherSum和sum都指向了同一个函数

5：定义函数的四种方式

• 方法一：函数声明

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

• 方法二：函数表达式；

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

• 方法三：Function构造函数
  • Function 构造函数可以接受任意数量的参数，但最后一个参数始终被看成是函数体，而前面的参数枚举了新函数的参数

var sum = new Function("num1", "num2", "return num1 + num2"); // 不推荐

6：ECMAScript函数没有重载：重复为同一个函数名指定函数，该名称只属于后者；

7：函数声明和函数表达式的区别

• 函数声明提升；
• 函数表达式必须等到解析器执行到他所在的代码行才会被执行；

//函数声明
console.log(add(1,2));
function add(num1,num2){
	return num1+num2;
}	//3
//函数表达式
console.log(sdd(1,2));
var sdd = function(num1,num2){
	return num1+num2;
};	//报错：Uncaught TypeError

• 除了什么时候可以通过变量访问函数这一点区别之外，函数声明与函数表达式的语法等价；
  8：作为值的函数
• 可以像传递参数一样把一个函数传递给另一个函数，也可以将一个函数作为另一个函数的结果返回；

//作为参数传递
function getGreeting(name){ 
 return "Hello, " + name; 
} 
var result2 = callSomeFunction(getGreeting, "Nicholas");

• 使用示例；

function createComparisonFunction(property){
	return function(object1,object2){
		var value1 = object1[propertyName]; 
 		var value2 = object2[propertyName]; 
 		if (value1 < value2){ 
 			return -1; 
 		} else if (value1 > value2){ 
 			return 1; 
 		} else { 
 			return 0; 
 		} 
	};
}
var data = [{name: "Zachary", age: 28}, {name: "Nicholas", age: 29}]; 
data.sort(createComparisonFunction("name")); 
alert(data[0].name); //Nicholas 
data.sort(createComparisonFunction("age")); 
alert(data[0].name); //Zachary 

9：函数内部属性

• arguments对象的callee属性：该属性指向拥有这个arguments对象的函数

//景点的阶乘函数
function factorial(num){
	if(num<=1){
		return 1;
	} else (
		return num*arguments.callee.(num-1);
	)
}

• this对象：引用的是函数据以执行的环境对象——或者也可以说是 this 值（当在网页的全局作用域中调用函数时，
  this 对象引用的就是 window）
• 函数的caller属性：保存着调用当前函数的函数的引用；

function outer(){ 
 inner(); 
} 
function inner(){ 
 alert(arguments.callee.caller); 
} 
outer(); 
//返回function outer(){ 
 inner(); 
} 

• 严格模式还有一个限制：不能为函数的 caller 属性赋值，否则会导致错误；

10：函数两个属性
（1）length属性表示函数希望接受的命名参数的个数；
（2）：prototype属性:

• 保存着引用类型所有的实例方法（如toString()和valueOf()等方法）；
• 在创建自定义引用类型以及实现继承时，这个属性很重要（第六章讲的）；
• ECMAScript中，该属性不可枚举；

11：函数两个非继承而来的方法apply()和call()
（1）共同点：都是在特定作用域中调用函数，实际上等于设置函数体内 this 对象的值；
（2）共同作用：扩充函数作用域，而且对象和方法不需要有任何的耦合关系；
（3） apply()

• 方法接收两个参数，参数一：在其中运行函数的作用域，参数二：参数数组（可以是Array的实例，也可以是arguments 对象）

 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 

（3）call() 方法：

• 接收多个参数：参数一：在其中运行函数的作用域；其余参数都直接传递给函数；

function sum(num1, num2){ 
 return num1 + num2; 
} 
function callSum(num1, num2){ 
 return sum.call(this, num1, num2); 
} 
alert(callSum(10,10)); //20 

12：bind() 方法

• ECMAScript新增的，用于创建一个函数的实例，其 this 值会被绑定到传给 bind()函数的值；

window.color = "red";
var o = {color:"blue"};
function sayColor(){
	console.log(this.color);
}
var objectSayColor = sayColor.bind(0);
objectSayColor();	//blue

13：每个函数继承的toLocaleString() 和 toString() 方法始终都返回函数的代码；（返回代码的格式则因浏览器而异）

基本包装类型

1：三个特殊的基本包装类型：Boolean、Number 和 String；
2：注意：对基本包装类型的实例调用typeof 返回"Object"，而且所有基本包装类型的对象都会被转换为布尔值true；
3： 基本包装类型在后台的过程
（1）创建该类型的一个实例（String、Boolean、Number）；
（2）在实例上调用指定的方法；
（3）销毁该实例；
4：引用类型与基本包装类型的主要区别就是对象的生存期；
（1）使用new操作符创建的引用类型的实例，在执行流离开之前都一直保存在内存中；
（2） 自动创建的基本包装类型的对象，则质询在于一行代码的执行瞬间，然后立即被销毁，这意味着我们不能在运行时为基本类型值添加属性和方法；

• 使用new 调用基本包装类型的构造函数，与直接 调用通的转型函数不同；
  4：Boolean类型
  （1）建议永远不要使用Boolean对象；
  （2）创建语法

var booleanObject = new Boolean(true);

（3）重写了方法

• valueOf()方法：返回true或false；
• toString()方法：返回字符串"true"或"false"；
  （4）注意：typeof 操作符对基本类型返回"boolean"，而对引用类型返回"Object"；使用instanceof操作符测试Boolean对象返回true，测试基本类型返回false；
  （5）该对象用处不大，原因

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

var falseValue = false;
result = faleValue && true;
console.log(result);	//false

var value = "25"; 
var number = Number(value); //转型函数
alert(typeof number); //"number" 

var obj = new Number(value); //构造函数
alert(typeof obj); //"object"

5：Number类型
（1）不建议使用，因为typeof 操作符对基本类型返回"number"，而对引用类型返回"Object"；使用instanceof操作符测试Boolean对象返回true，测试基本类型返回false
（2）创建语法：
var numberObject = new Number(10);
（3）重写了方法
valueOf()：返回对象表示的基本类型的值；
toString()和toLocalString()：返回字符串形式的数值；

var num = 10; 
alert(num.toString()); //"10" 
alert(num.toString(2)); //"1010" 
alert(num.toString(8)); //"12" 
alert(num.toString(10)); //"10" 
alert(num.toString(16)); //"a" 

（4）除了继承的方法，Number类型还提供了一些用于将数值格式化为字符串的方法

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

var num = 10；
console.log(num.toFixed(2));	//"10.00"
var num2 = 10.005;
console.log(num2.toFixed(2));	//"10.01",浏览器会四舍五入

• toExponential()：返回以指数表示法表示的熟知的字符串形式；

var num = 2030;
console.log(num.toExponential(1));	//2.03e+3

• toPrecision()：可能会返回固定大小（fixed）格式，也可能返回指数（exponential）格式；具体规则是看哪种格式最合适；

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

6：String 类型

（1）创建语法：（不建议创建使用）

var numberObject = new String("a");

（2）valueOf() 方法：对象所表示的基本字符串值
（3）String() 函数：对象所表示的基本字符串值
（4）toString 方法：对象所表示的基本字符串值
（5）String.length：返回字符串包含字符数字；
（6）String.charAt(索引值)：返回指定位置的字符；
（7）String.charCodeAt(索引值)：返回指定位置的字符编码；
（8）stringValue[索引值]：返回指定位置的字符（IE7及以下不支持，返回undefined）；

（9）stringValue.indexOf(给一个字符串，起始位置非必须)：搜索给定字符串，返回字符串位置，若无，返回-1；
stringValue.indexOf("es",2);
（10）stringValue.laseIndexOf(给一个字符串，起始位置非必须)：从字符串末尾向前搜索；
stringValue.laseIndexOf("es",2);

//使用indexOf()方法取得字符串中所有字符 e 的位置;
var stringValue = "Helelele";
var positions = new Array();
var pos = stringValue.indexOf("e");
while(pos > -1){
	positions.push(pos);
	pos = stringValue.indexOf("e",pos+1);
}
console.log(positions);	//[1,3,5,7]

（11）stringValue.concat()：用于将一或多个字符串拼接起来，返回拼接得到后的新字符串；

---

（12）stringValue.slice(起始字符串位置，结束字符串位置) 方法：返回新字符串，不改变原字符串，（若传入参数为负，将传入的负值与字符串的长度相加）；

---

（13）stringValue.substring(起始字符串位置，返回字符串长度)：返回新字符串，不改变原字符串，（所有负数转为0）；

---

（14）stringValue.substr(起始字符串位置，结束字符串位置)：返回新字符串，不改变原字符串，（将负的第一个参数加上字符串的长度，而将负的第二个参数转换为 0；）

---

（15）stringValue.trim() 方法：
创建字符串副本，删除前置及后缀的所有空格，然后返回结果；
（低版本浏览器不支持该方法）
（Firefox 3.5+、Safari 5+
和 Chrome 8+还支持非标准的 trimLeft()和 trimRight()方法）

---

（16）4个字符串大小写转换方法

• stringValue.toLowerCase()：
• stringValue.toUpperCase()：
• stringValue.toLocaleLowerCase()：针对特定地区的实现
• stringValue.toLocaleUpperCase()：针对特定地区的实现

---

（10）字符串的模式匹配方法

• stringValue.match(正则表达式 || RegExp对象)：返回一个数组，数组的第一项是与整个模式匹配的字符串，之后的每一项（如果有）保存着与正则表达式中的捕获组匹配的字符串；
• stringValue.search(正则表达式 || RegExp对象)：返回字符串第一个匹配项的索引；
• stringValue.replace(正则表达式 || RegExp对象,字符串||函数)：替换指定的字符串；

var text = "var cat fat";
text.replace(/.at/,"ond");	//"var ond fat"
text.replace(/.at/g,"ond");	//"var ond ond"
text.replace(/(.at)/g,"ond($1)");	//"ond(cat), ond(bat), ond(sat), ond(fat)"

一些特殊的字符序列

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

（10）localeCompare() 方法：用于比较两个字符串

情况	返回值
若字符串在字母表中应该排在字符串参数之前	返回一个负数（大多情况是-1）
如果字符串等于字符串参数	返回 0
如果字符串在字母表中应该排在字符串参数之后	返回一个正数（大多情况是1）

（11）String.fromCharCode() 方法：接受一或多个字符编码，将参数转换为字符串；

String.formCharCode(104,101,108,108,111);

单体内置对象

1： 单体内置对象定义：由ECMAScript实现提供的、不依赖宿主环境的对象，这些对象在ECMAScript程序执行之前就已经存在了；
2：单体内置对象有：Object，Array，String，Global，Math:

3：Global对象

（1）所有在全局作用域中定义的属性和函数最终都是Global对象的属性；
（2）Global对象的属性：isNaN() , isFinite() , parseInt() , parseFloat() ,
（3）URI编码方法（用于对通用资源标识符 Uniform Resource Identifiers进行编码，以便发送给浏览器），有效的URI中不能包含某些字符，例如空格，而这两个URI编码方法就可以对URI进行编码，他们用特殊的UTF-8 编码替换所有无效的字符，从而让浏览器能够接受的理解：

• encodeURI() ：用于整个URI，不会对本身属于URI的特殊字符进行编码，例如冒号、正斜杠、问号、井号；
• encodeURIComponent()：用于URI中的某一段，会对他发现的热河非标准字符进行编码；
• decodeURI()：用于解码使用encodeURI()方法编码的字符；
• decodeURIComponent()：用于解码使用encodeURIComponent()编码的字符；

（4）**eval()**方法

• 只接受一个参数，即要执行的ECMAScript（或JavaScript字符串）；
• 通过eval()执行的代码具有与包含环境相同的作用域链；
• 在eval() 中创建的任何变量和函数都不会提升；
• 在严格模式下，在外部访问不到eval()中创建的任何变量或函数；

（5）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

（6）Window对象

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

Math对象

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

Math对象的一些方法
（2）min() 和max()：计算一组数值中的最小（大）值接收任意多个数值参数；

var values = [1,2,3,4,5,6];
var max = Math.max.apply(Math,values);
//使用技巧在于将第一个参数设置为Math从而正确的设置this值

（3）舍入方法

• Math.ceil() 执行向上舍入；（25.1=》26）
• Math.floor() 执行向下舍入；（25.9=》25）
• Math.round() 执行标准舍入；

（4）Math.random() 方法：用于返回 .0=<随机数<1；

（5）其他方法：感觉不咋实用，先不写了

小结

对象在JavaScript中被称为引用类型的值，而且有一些内置的引用类型可以用来创建热定的对象；

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

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

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

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

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