"红砖"JS高程笔记P4

引用类型的值(对象)是引用类型的一个实例.
在ECMAScript中,引用类型是一种数据结构,常被称为类.
但它不具备传统面向对象语言所支持的类和接口等基本结构.
引用类型(对映构造函数)有时候也被称为对象定义,它们描述一类对象所具有的属性和方法.
对象是某种特定引用类型的实例.
新对象是使用new操作符后跟一个构造函数来创建的.
构造函数本身就是一个函数,值不过是处于创建对象的目的而定义的.
var person = new Object();
代码创建了Object引用类型的一个新实例,然后把实例保存在变量person中.
使用的构造函数是Object,它为新对象定义了默认的属性和方法.
Object是ECMAScript提供的很多原生引用类型之一.




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




Object类型
创建Object实例的方式有两种:
1.使用new操作符后跟Object构造函数
var person = new Object();
person.name = 'Nicholas';
person.age = 29;
在使用Object构造函数时可以省略new操作符.
另一种方式是使用对象字面量表示法,对象字面量是对象定义的一种简写形式,目的在于简化创建包含大量属性对象的过程.
var person = { name : "Nicholas" , age : 29 };
在使用对象字面量定义对象时,实际上不会调用Object构造函数.
在使用对象字面量语法时,属性名可以使用字符串,不是字符串也会自动转换为字符串.
所以字面量定义中,属性名可以任意取名.
访问对象属性时可使用点表示法和方括号表示法.
在使用方括号语法时应将访问的属性以字符串形式表示.
person["name"];
person.name;
方括号语法的主要优点是可以通过变量来访问属性.
如果属性名中包含会导致语法错误的字符,也可使用方括号访问.
var propertyName = "name";
person[propertyName];
person["first name"];




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




Array类型
ECMAScript数组的每一项可以保存任何类型的数据.
ECMAScript数组的大小是可以动态调整的,即可以随着数据的添加自动增长以容纳新增数据.
创建数组的基本方式有两种.
第一种是使用Array构造函数:
var colors = new Array();
var colors = new Array(20); //创建length值为20,包含20项的数组.
var colors = new Array("red","blue","green"); //创建一个包含3个字符串值的数组.
在使用Array构造函数时可以省略new操作符.
第二种基本方式是使用数组字面量表示法(与对象一样,在使用数组字面量表示法时,也不会调用Array构造函数):
var colors = ["red","blur","green"]; //定义一个字符串数组
var name = []; //定义一个空数组
alert(colors[0]); //显示第一项
colors[2] = "black"; //修改第三项
colors[3] = "brown"; //新增第四项
数组的项数保存在length属性中.
数组的length属性不是只读的,通过设置这个属性,可以从数组的末尾移除项或向数组中添加新项.
colors.length = 5; //新增项(位置4),值为undefined.
colors[colors.length] = "white"; //在位置5添加最新项.
由于数组最后一项的索引始终是length-1,因此下一个新项的位置是length.




检验数组
在包含多个框架的网页中,会有多个全局执行环境,会存在多个不同的Array构造函数,
所以不能使用value instanceof Array来检测数组,若用第一个框架value检查第二个框架的Array会出错.
在现代浏览器中,可使用Array.isArray()方法检测数组.
if(Array.isArray(value)){
//do someting
}
此方法目的是最终确定value是不是数组,而不管在哪个全局环境中创建.




转换方法
调用数组的toString()方法会返回由数组中每个值的字符串形式拼接而形成的一个以逗号分隔的字符串,调用valueOf()返回的还是数组.
创建这个字符串会调用数组每一项的toString()方法.
alert()要接收字符串参数,所以会在后台调用toString()方法.
使用join()方法,可以使用不同的分隔符来构建数组返回的字符串.
join()方法只接收一个参数,即用作分隔符的字符串,返回包含所有数值项的字符串.
如果不给join()方法传入任何值,或者给它传入undefined,则默认用逗号作为分隔符.
如果数组中的某一项的值是null或undefined,那么该值在join(),toLocleString(),toString(),valueOf()方法返回的结果中以空字符串表示.




栈方法(LIFO-后进先出)
push()方法可以接收任意数量的参数,把它们逐个添加到数组末尾,并返回修改后数组的长度.
pop()方法则从数组末尾移除最后一项,减少数组的length值,然后返回移除的项.
var colors = new Array(); //创建一个数组
var count = colors.push("red","green"); //推入两项
alert(count); //2
var item = colors.pop();
alert(item); //"green"
alert(colors.length); //1




队列方法(FIFO-先进先出)
shift()方法能够移除数组中的第一个项并返回该项,同时将数组长度减1.
unshift()方法能在数组前端添加任意个项并返回新数组的长度.
var colors = new Array();
var count = colors.push("red","green");
alert(count); //2
var item = colors.shift(); //移除第一项并返回该项
alert(item); //"red"
var count1 = colors.unshift("black"); //推入一项
alert(count1); //2




重排序方法
reverse()方法会反转数组项的顺序.
sort()方法按升序排列数组项,为了实现排序,sort()方法会调用每个数组项的toString()转型方法,然后比较得到的字符串.
即使是数值亦会转换成字符串进行比较.
sort()方法可以接收一个比较函数作为参数,函数接收两个参数,如果第一个参数应该位于第二个之前则返回一个负数,如果两个参数相等则返回0,
如果第一个参数应该位于第二个之后则返回一个正数.
function compare(value1,value2){
if(value1 < value2){
return -1;
}else if(value1 > value2){
return 1;
}else{
return 0;
}
}
compare比较函数适用于大多数数据类型,作为参数传递给sort().
var arr = [0,5,4,3,2,1];
arr.sort(compare);
alert(arr); //0,1,2,3,4,5
对于数值类型或者其valueOf()方法会返回数值类型的对象类型,可以使用以下比较函数:
arr.sort(function(value1,value2){
return value2 - value1;
});
//value1-value2是从小到大排序,value2-value1是从大到小排序.
reverse()和sort()方法的返回值是经过排序之后的原来的数组.




操作方法
concat()方法会先创建当前数组一个副本,然后将接收到的参数添加到这个副本的末尾,最后返回新构建的数组.
如果传递给concat()方法的是一或多个数组,则该方法会将这些数组中的每一项都添加到结果数组中.
在没有给concat()方法传递参数的情况下,它只是复制当前数组并返回副本.
如果传递的值不是数组,这些值就会被简单地添加到结果数组的末尾.
var colors = ["red","green","blue"];
var result = colors.concat("yellow",["black","brown"]);
alert(result); //red,green,blue,yellow,black,brown
slice()方法能够基于当前数组中的一或多个项创建一个新数组.
slice()方法可以接受一或两个参数(数值类型),即要返回项的起始和结束位置.
一个参数时,slice()方法返回从该参数指定位置开始到当前数组末尾的所有项.
两个参数,该方法返回起始和结束位置之间的项,但不包括结束位置的项.
如果结束位置小于起始位置,则返回空数组,如果参数是负数,则倒数计算.
slice()方法不会影响原数组.
var colors = ["red","green","blue","yellow","purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2); //green,blue,yellow,purple
alert(colors3); //green,blue,yellow
splice()的主要用途是向数组的中部插入项,有3种情况:
1.删除:可以删除任意数量的项,只需指定两个参数,要删除的第一项的位置和要删除的项数.
2.插入:可以向指定位置插入任意数量的项,需要3个参数,起始位置,0(要删除的项数),要插入的项.
  如,splice(2,0,"red","green")会从当前数组的位置2开始插入字符串"red"和"green".
3.替换:可以向指定位置插入任意数量的项,且同时删除任意数量的项,只需3个参数,起始位置,要删除的项数,要插入的任意数量的项.
  插入的项数不必与删除的项数相等.如,splice(2,1,"red","green")会删除当前数组位置2的项,然后再从位置2开始插入字符串.
splice()方法始终都会返回一个数组,该数组中包含从原始数组中删除的项(如果没有删除任何项,则返回一个空数组).




位置方法
indexOf()和lastIndexOf()两个方法都接收两个参数:要查找的项和(可选)表示查找起点位置的索引.
其中,indexOf()方法从数组的开头(位置0)开始向后查找,lastIndexOf()方法则从数组的末尾开始向前查找.
两个方法都返回要查找的项在数组中的位置,或者在没找到的情况下返回-1.
在比较第一个参数与数组中的每一项时,会使用全等操作符.
var numbers = [1,2,3,4,5,4,3,2,1]
alert(numbers.indexOf(4)); //3
alert(numbers.lastIndexOf(4)); //5
var person = { name : "Movement"};
var people = [{ name : "Movement"}];
var morePeople = [person];
alert(people.indexOf(person)); //-1
alert(morePeople.indexOf(person)); //0
/*以上例子中,person与people并非全等关系,因为people数组中是创建了一个新对象,*/
/*即person和people是分别两个对象,所以值引用的不是同一个对象*/




迭代方法
共有5个迭代方法,每个方法都接收两个参数:要在每一项上运行的函数和(可选)运行该函数的作用域对象(影响this的值).
传入这些方法中的函数会接收三个参数:数组项的值,该项在数组中的位置,数组对象本身.
根据使用的方法不同,这个函数执行后的返回值可能会也可能不会影响方法的返回值.
1.every() : 对数组中的每一项运行给定函数,如果该函数对每一项都返回true,则返回true.
2.filter() : 对数组中的每一项运行给定函数,返回该函数会返回true的项组成的数组.
3.forEach() : 对数组中的每一项运行给定函数,方法没有返回值.
4.map() : 对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组.
5.some() : 对数组中的每一项运行给定函数,如果该函数对任一项返回true,则返回true.
以上方法都不会修改数组中的包含的值.
如,map()返回一个数组,这个数组的每一项都是在原始数组中的对应项上运行传入函数的结果,如给每项乘以2,然后返回这些乘积组成的数组.
var numbers = [1,2,3,4,5,4,3,2,1];
var mapResult = numbers.map(function(item,index,array){
return item * 2;
});
alert(mapResult); //[2,4,6,8,10,8,6,4,2]




归并方法
reduce()和reduceRight()两个归并方法会迭代数组的所有项,然后构建一个最终返回值.
其中,reduce()从数组第一项开始,逐个遍历到最后,而reduceRight()则从数组的最后一项开始,向前遍历到第一项.
两个方法都接收两个参数:一个在每一项上调用的函数和(可选)作为归并基础的初始值.
函数接收4个参数:前一个值,当前值,项的索引,数组对象.
这个函数返回的任何值都会作为第一个参数自动传给下一项.
第一次迭代发生在数组的第二项上,因此第一个参数是数组的第一项,第二个参数就是数组的第二项.
var values = [1,2,3,4,5];
var sum = values.reduce(function(prev,cur,index,array){
return prev + cur;
});
alert(sum); //15
第一次执行回调函数,prev是1,cur是2;第二次,prev是3(1+2的结果).cur是3(数组的第三项),这个过程会持续到把数组中的每一项都访问一遍.




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




Date类型
var now = new Date();
在调用Date构造函数而不传递参数的情况下,新创建的对象自动获得当前日期和时间.
Date.parse()方法接收一个表示日期的字符串参数,然后尝试根据这个字符串返回相应日期的毫秒数.
var someDate = new Date(Date.parse("May 25,2004"));
如果传入Date.parse()方法的字符串不表示日期就返回NaN.
实际上,将直接表示日期的字符串传递给Date构造函数,也会在后台调用Date.parse().
var someDate = new Date("May 25,2004");
Date.now()方法返回表示调用这个方法时的日期和时间的毫秒数.
//取得开始时间
vr start = Date.now();
//调用函数
doSomething();
//取得停止时间
var stop = Date.now(),result = stop - start;




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




RegExp类型
使用字面量形式定义正则表达式 : var expression = /pattern/flags;
其中的模式(pattern)部分可以是任何简单或复杂的正则表达式.
每个正则表达式都可带有一或多个标志(flags),用以标明正则表达式的行为.
共有3个标志:
g : 表示全局模式,即模式将被应用于所有字符串,而非在发现第一个匹配项时立即停止.
i : 表示不区分大小写模式,即在确定匹配项时忽略模式与字符串的大小写.
m : 表示多行模式,即在到达一行文本末尾时还继续查找下一行中是否存在与模式匹配的项.
var pattern1 = /at/g; //匹配字符串中所有"at"的实例
var pattern2 = /[bc]at/i; //匹配第一个"bat"或"cat",不区分大小写
var pattern3 = /.at/gi; //匹配所有以"at"结尾的3个字符的组合,不区分大小写.
句点表示位于"at"之前的任意一个可以构成匹配项的字符.
模式中使用的所有元字符都必须转义,正则表达式中的元字符包括:
( [ { \ ^ $ | ) ? * + . ] }
使用RegExp构造函数定义正则表达式 : var pattern = new RegExp("[bc]at","i");
传递给RegExp构造函数的两个参数都是字符串,所以要对某些字符进行双重转义.
如 : /\w\\hello\\123/ 等价的字符串时 "\\w\\\\hello\\\\123"
ECMAScript5明确规定,使用正则表达式字面量必须像直接调用RegExp构造函数一样,每次都创建新的RegExp实例.


RegExp实例属性
RegExp的每个实例都具有以下属性:
1.global : 布尔值,表示是否设置了g标志.
2.ignoreCase : 布尔值,表示是否设置了i标志.
3.lastIndex : 整数,表示开始搜索下一个匹配项的字符位置,从0开始.
4.multiline : 布尔值,表示是否设置了m标志.
5.source : 正则表达式的字符串表示,按照字面量形式而非传入构造函数中的字符串模式返回.


RegExp实例方法
RegExp对象的主要方法是exec(),该方法专门为捕获组设计的.
exec()接受一个参数,即要应用模式的字符串,然后返回包含第一个匹配项信息的数组,或者在没有匹配项的情况下返回null.
返回的数组虽然是Array的实例,但包含两个额外的属性:index和input.
index表示匹配项在字符串中的位置,input表示应用正则表达式的字符串.
在数组中,第一项是与整个模式匹配的字符串,其它项是与模式中的捕获组匹配的字符串(如果没有捕获组则数组只包含一项).
var text = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/gi; //元字符括号内为一个捕获组
var matches = pattern.exec(text);
matches.index; //0
matches.input; //"mom and dad and baby"
matches[0]; //"mom and dad and baby"
matches[1]; //" and dad and baby"
matches[2]; //" and baby"
对于exec()方法而言,即使在模式中设置了全局标志,它每次也只会返回一个匹配项.
在不设置全局标志的情况下,在同一个字符串上多次调用exec()将始终返回第一个匹配项的信息.
而在设置全局标志的情况下,每次调用exec()则都会在字符串中继续查找新匹配项.
var text = "cat, bat, sat, fat";
var pattern = /.at/g;
var matches = pattern.exec(text);
alert(matches.index); //0
alert(matches[0]); //cat
alert(pattern.lastIndex); //3
matches = pattern.exec(text);
alert(matches.index); //5
alert(matches[0]); //bat
alert(pattern.lastIndex); //8
test()方法接受一个字符串参数,在模式与该参数匹配的情况下返回true,否则返回false.


RegExp构造函数属性
RegExp构造函数包含一些属性(在其他语言称为静态属性).
这些属性适用于作用域中的所有正则表达式,并且基于所执行的最近一次正则表达式操作而变化.
这些属性可通过两种方式访问,长属性名和短属性名(部分浏览器不支持短属性名).
长属性名 短属性名 说明
input $_ 最近一次要匹配的字符串.
lastMatch $& 最近一次的匹配项.
lastParen $+ 最近一次匹配的捕获组.
leftContext $`input字符串中lastMatch之前的文本.
multiline $* 布尔值,表示是否所有表达式都使用多行模式.
rightContext $'input字符串中lastMatch之后的文本.
由于短属性名大都不是有效的ECMAScript标识符,因此必须通过方括号语法来访问它们.
还有$1-9共9个用于存储捕获组的构造函数属性,访问语法RegExp.$1,RegExp.$2...等,分别用来存储第一,第二....个匹配的捕获组.
在调用exec()或test()方法时,这些属性自动填充.




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




Function类型
在ECMAScript中函数实际上是对象.
每个函数都是Function类型的实例,而且都与其他引用类型一样具有属性和方法.
由于函数是对象,因此函数名实际上也是一个指向函数对象的指针.
function sum(num1, num2){
return num1 + num2;
}
var sum = function(num1, num2){
return num1 + num2;
};
不推荐使用new Function('参数','函数体')的方式定义函数.
注意,使用不带圆括号的函数名是访问函数指针,而非调用函数.


没有重载
当声明了两个同名的函数,则后面的函数会覆盖前面的函数.


函数的声明与函数表达式
解析器在向执行环境中加载数据时,对函数声明和函数表达式并非一样.
解析器会先读取函数声明,并使其在执行任何代码之前可访问,而函数表达式则需等到解析器执行到其所在的代码行才被解析执行.
对代码求值时,JS引擎在第一遍会声明函数并将它们放到源代码树的顶部,则即使声明函数的代码在调用它的代码后面,JS引擎也能把函数声明提升到顶部.


函数内部属性
在函数内部,有两个特殊对象:arguments和this.
arguments是一个类数组对象,包含着传入函数中的所有参数.
arguments对象有一个名叫callee的属性,该属性是一个指针,指向拥有这个arguments对象的函数.
如,阶乘函数:
function factorial(num){
if(num <= 1){
return 1;
}else{
return num * arguments.callee(num-1);
}
}
this对象引用的是函数据以执行的环境对象(也可以说是this值),当在网页的全局作用域中调用函数时,this对象引用的是window.


函数属性和方法
函数对象的属性caller,这个属性中保存着调用当前函数的函数的引用,如果是在全局作用域中调用当前函数,它的值为null.
function outer(){
inner();
}
function inner(){
alert(arguments.callee.caller);
}
inner(); //返回outer()函数的源代码
每个函数都有两个属性: length 和 prototype.
length属性表示函数希望接收的命名参数的个数.
prototype属性是不可枚举的,因此使用for-in无法发现.
对于ECMAScript中的引用类型而言,
prototype是保存它们所有实例方法的真正所在,诸如toString()和valueOf()等方法实际上都保存在prototype名下,
只不过是通过各自对象的实例访问罢了.
每个函数都包含三个非继承而来的方法:apply()和call()和bind()
前两个方法的用途都是在特定的作用域中调用函数,实际上等于设置函数体内this对象的值.
apply()方法接收两个参数:一个是在其中运行函数的作用域,另一个是参数数组,其中第二个参数可以是Array的实例,也可以是arguments对象.
function sum(num1, num2){
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
以上例子中,this值是向指sum执行的环境对象,即是window.
对于call(),第一个参数不变,其余参数都是直接传递给函数,即参数必须逐个列举出来.
apply()与call()能够扩充函数赖以运行的作用域.
window.color = "red";
var o = { color : "blue" };
function sayColor(){
alert(this.color);
}
sayColor(); //red
sayColor.call(this); //red
sayColor.call(window); //red
sayColor.call(o); //blue
bind()方法会创建一个函数实例,其this值会被绑定到传给bind()函数的值.
window.color = "red";
var 0 = { color : "blue" };
function sayColor(){
alert(this.color);
}
var objectSayColor = sayColor.bind(o);
objectSayColor(); //blue
每个函数继承的toLocaleString()和toString()和valueOf()方法始终都返回函数的代码.




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




基本包装类型
为了便于操作基本类型值,ECMAScript提供了3个特殊的引用类型 : Boolean , Number , String.
实际上,每当读取一个基本类型值的时候,后台就会创建一个对应的基本包装类型的对象,从而让我们能够调用一些方法来操作数据.
当存放字符串的变量被访问时,访问过程处于一种读取模式,也就是要从内存中读取字符串的值,这时,后台就会自动完成创建.
引用类型与基本包装类型的主要区别在对象的生存期.使用new操作符创建的引用类型的实例,在执行流离开当前作用域之前都一直保存在内存中.
而自动创建的基本包装类型的对象,则只存在于一行代码的执行瞬间,然后立即被销毁.
这意味着不能在运行时为基本类型值添加属性和方法.
Object构造函数也会像工厂方法一样,根据传入值的类型返回相应基本包装类型的实例,如:
var obj = new Object("some text");
alert(obj instanceof String); //true
对基本包装类型的实例调用typeof会返回"object",在布尔表达式中所有基本包装类型的对象都会被转换为布尔值true.


Boolean类型
var falseObject = new Boolean(fales);
var result = falseObject && true;
alert(result); //true
因为基本包装类型的对象都会被转换为true,所以返回true.


Number类型
toFixed()方法会按照指定小数位返回数值的字符串表示:
var num = 10;
alert(num.toFixed(2)); //"10.00",以0填补小数位
如果数值本身包含的小数位比指定的还多,那么接近指定的最大小数位的值就会舍入.
var num = 10.005;
alert(num.toFixed(2)); //"10.01"
用于格式化数值的方法toExponential(),该方法返回以指数表示法(e表示法)表示的数值的字符串形式.
toExponential()接收一个参数,而且该参数同样也是指定输出结果中的小数位数.
var num = 10;
alert(num.toExponential(1)); //"1.0e+1"
toPrecision()方法可能会返回固定大小格式,也可能返回指数格式,具体规则是看哪种格式最合适.
方法接收一个参数,即表示数值的所有数字的位数(不包括指数部分).
var num = 99;
alert(num.toPrecision(1)); //"1e+2"
alert(num.toPrecision(2)); //"99"
alert(num.toPrecision(3)); //"99.0"


String类型
String类型的每个实例都有一个length属性,表示字符串中包含多个字符.
1.字符方法
两个用于访问字符串中特定字符的方法: charAt() 和 charCodeAt().
两个方法都接收一个参数,基于0的字符位置.
charAt()方法以单字符字符串的形式返回给定位置的那个字符.
charCodeAt()方法返回的是字符的字符编码.
在现代浏览器中可以使用方括号加数字索引来访问字符串中的特定字符.
var stringValue = "hello world";
alert(stringValue[1]); //e
2.字符串操作方法
concat()用于将一或多个字符串拼接起来,返回拼接得到的新字符串.
concat()方法可以接受任意多个参数,也就是说可以通过它拼接任意多个字符串.
var stringValue = "hello ";
var result = stringValue.concat("world","!");
alert(result); //"hello world!"
slice(),substr(),substring()三个方法都返回被操作字符串的一个子字符串(新创建),而且也都接受一或两个参数.
第一个参数指定子字符串的开始位置,第二个参数(在指定情况下)表示子字符串到哪里结束.
slice()和substring()的第二个参数指定的是子字符串最后一个字符后面的位置,而substr()的第二个参数指定的是返回的字符个数.
如果没有给这些方法传递第二个参数,则将字符串的长度作为结束位置.
与concat()方法一样,slice(),substr(),substring()也不会修改字符串本身的值,它们只是返回一个基本类型的字符串值,对原始字符串没有任何影响.
var stringValue = "hello world";
alert(stringValue.slice(3,7)); //"lo w"
alert(stringValue.substring(3,7)); //"lo w"
alert(stringValue.substr(3,7)); //"lo worl"
三个方法接收负参数时行为各不同:
slice()方法会将传入的负值与字符串的长度相加.
substr()方法将负的第一个参数与字符串长度相加,将负的第二个参数转换为0.
substring()方法会把所有负值参数都转换为0.
3.字符串位置方法
indexOf()和lastIndexOf()两个方法都是从一个字符串中搜索给定的子字符串,然后返回子字符串的位置(如果没有则返回-1).
indexOf()从字符串开头向后搜索子字符串,lastIndexOf()从字符串的末尾向前搜索子字符串.
两个方法都可以接收可选的第二个参数,表示从字符串中的哪个位置开始搜索.
var stringValue = "Lorem ipsum dolor sit amet, consectetur adipisicing elit";
var positions = new Array();
var pos = stringValue.indexOf("e");
while(pos > -1){
positions.push(pos);
pos = stringValue.indexOf("e" , pos + 1);
}
alert(positions); //3,24,32,35,52
4.trim()方法会创建一个字符串的副本,删除前置及后缀的所有空格,然后返回结果.
5.字符串大小写转换方法
4个 : toLowerCase(),toLocaleLowerCase(),toUpperCase(),toLocaleUpperCase().
var stringValue = "hello world";
alert(stringValue.toUpperCase()); //"HELLO WORLD"
alert(stringValue.toLowerCase()); //"hello world"
6.字符串的模式匹配方法
在字符串上调用match()方法本质上与调用RegExp的exec()方法相同.
match()方法只接受一个参数,要么是一个正则表达式(字符串),要么是一个RegExp对象.
用于查找模式的方法search(),这个方法接受一个参数,RegExp对象或正则表达式.
search()方法返回字符串中第一个匹配项的索引,如果没有找到匹配项,则返回-1,而且方法始终从字符串开头找起.
var text = "cat, bat, sat, fat";
var pos = text.search(/at/);
alert(pos); //1
replace()方法接受两个参数:第一个参数可以是一个RegExp对象或者一个字符串(这个字符串不会被转换成正则表达式),
第二个参数可以是一个字符串或者一个函数,如果第一个参数是字符串,那么只会替换第一个字符串.
要想替换所有子字符串,唯一办法是提供一个正则表达式,而且要指定全局(g)标志,如:
var text = "cat, bat, sat, fat";
var result = text.replace("at","ond");
alert(result); //"cond, bat, sat, fat"
result = text.replace(/at/g,"ond");
alert(result); //"cond, bond, sond, fond"
如果第二个参数是字符串,那么还可以使用一些特殊的字符序列,将正则表达式操作得到的值插入到结果字符串中.
字符序列 替换文本
$$ $
$& 匹配整个模式的子字符串,与RegExp.lastMatch的值相同.
$' 匹配的子字符串之前的子字符串,与RegExp.leftContext的值相同.
$` 匹配的子字符串之后的子字符串,与RegExp.rightContext的值相同.
$n 匹配第n个捕获组的子字符串,其中n等于0~9,亦可是nn,nn等于01~99,如果正则表达式中没有定义捕获组,则使用空字符串.
通过这些特殊的字符序列,可以使用最近一次匹配结果中的内容,如:
var text = "cat, bat, sat, fat";
result = text.replace(/(.at)/g,"word ($1)");
alert(result); //word (cat), word (bat), word (sat), word (fat)
replace()方法的第二个参数也可以是一个函数.
在只有一个匹配项(即与模式匹配的字符串)的情况下,会向这个函数传递3个参数:模式的匹配项,模式匹配项在字符串中的位置和原始字符串.
在正则表达式中定义了多个捕获组的情况下,传递给函数的参数依次是模式的匹配项,第一个捕获组的匹配项,第二个捕获组的匹配项.....,
但最后两个参数仍然分别是模式的匹配项在字符串中的位置和原始字符串.
这个函数应该返回一个字符串,表示应该被替换的匹配项,如:
function htmlEscape(text){
return text.replace(/[<>"&]/g,function(match, pos, originalText){
switch(match){
case "<":
return "&lt;";
case ">":
return "&gt";
case "&":
return "&amp";
case "\"":
return "&quot";
}
});
}
alert(htmlEscape("<p class=\"greeting"\>Hello world</p>"));
//&lt;p class=&quot;greeting&quot;&gt;Hello world!&lt;/p&gt;
split()这个方法可以基于指定的分隔符将一个字符串分割成多个子字符串,并将结果放在一个数组中.
分隔符可以是字符串,也可以是一个RegExp对象(这个方法不会将字符串看成正则表达式).
split()方法可以接受可选的第二个参数,用于指定数组的大小,以便确保返回的数组不会超出既定大小.
var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(","); //["red","blue","green","yellow"]
var colors2 = colorText.split(",",2); //["red","blue"]
var colors3 = colorText.split(/[^\,]+/) //["", ",", ",", ",", ""]
//最后一次调用传入正则表达式,匹配非逗号以外的字符,第一项和最后一项是两个空字符串,因为通过正则指定的分隔符出现
//在了字符串的开头(red)和结尾(yellow).
7.localeCompare()方法
这个方法比较两个字符串,并返回下列值中的一个:
a.如果字符串在字母表中应该排在字符串参数之前,则返回一个负数(一般是-1).
b.如果字符串等于字符串参数,则返回0.
c.如果字符串在字母表中应该排在字符串参数之后,则返回一个正数(一般是1).
var stringValue = "yellow";
alert(stringValue.localeCompare("brick")); //1
alert(stringValue.localeCompare("yellow")); //0
alert(stringValue.localeCompare("zoo")); //-1
8.fromCharCode()方法
String构造函数本身还有一个静态方法:fromCharCode(),这个方法接收一或多个字符编码,然后将它们转换成一个字符串.
这方法与实例方法charCodeAt()执行的是相反的操作.
alert(String.fromCharCode(104,101,108,108,111)); //"hello"




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




单体内置对象
由ECMAScript实现提供的,不依赖于宿主环境的对象,这些对象在ECMAScript程序执行之前就已经存在了,则为内置对象.
开发人员不必显式地实例化内置对象,因为它们已经实例化了.
//之前介绍的引用类型就是内置的构造函数对象,
//这些构造函数对象保存在Global对象属性中,
//而Global和Math对象则是单体内置对象.


Global对象
所有在全局作用域中定义的属性和函数,都是Global对象的属性.
1.URI编码方法
Global对象的encodeURI()和encodeURIComponent()方法可以对URI(Uniform Resource Identifiers,通用资源标识符)进行编码,
以便发生给浏览器.有效的URI中不能包含某些字符,例如空格.
而这两个URI编码方法就可以对URI进行编码,它们用特殊的UTF-8编码替换所有无效的字符,从而让浏览器能够接受和理解.
encodeURI()主要用于整个URI,而encodeURIComponent()主要用于对URI中的某一段进行编码,
encodeURI()不会对本身属于URI的特殊字符进行编码,而encodeURIComponent()则会对它发现的任何非标准字符进行编码.
decodeURI()能对使用encodeURI()替换的字符进行解码.
decodeURIComponent()能对encodeURIComponent()进行解码
2.eval()方法
eval()方法就像是一个完整的ECMAScript解析器,它只接受一个参数,即要执行的ECMAScript字符串.
当解析器发现代码中调用eval()方法时,它会将传入的参数当作实际的ECMAScript语句来解析,然后把执行结果插入到原位置.
通过eval()执行的代码被认为是包含该次调用的执行环境的一部分,因此被执行的代码具有与该执行环境相同的作用域链.
在eval()中创建的任何变量或函数都不会被提升,因为在解析代码的时候,它们被包含在一个字符串中,它们只在eval()执行时创建.
3.Global对象的属性
特殊值(undefined,NaN,Infinity)和所有原生引用类型的构造函数都是Global对象的属性.
禁止给undefined,NaN,Infinity赋值.
4.window对象
虽没法直接访问Global对象,但Web浏览器都是将这个全局对象作为window对象的一部分加以实现.
因此,在全局作用域中声明的所有变量和函数,就都成为了window对象的属性.


Math对象
ECMAScript还为保存数学公式和信息提供了一个公共位置,即Math对象.
1.Math对象的属性
Math.PI为π的值.
Math.SQRT2为2的平方根.
2.min()和max()方法
min()和max()方法用于确定一组数值中的最小值和最大值.
这两个方法都可以接受任意多个数值参数.
要找到数组中的最大或最小值,可以使用apply()方法:
var values = [1,2,3,4,5,6,7,8];
var max = Math.max.apply(Math, values);
3.舍入方法
Math.ceil()执行向上舍入,即它总是将数值向上舍入为最接近的整数.
Math.floor()执行向下舍入,即它总是将数值向下舍入为最接近的整数.
Math.round()执行标准舍入,即它总是将数值四舍五入为最接近的整数.
4.random()方法
Math.random()方法返回大于等于0小于1的一个随机数.
用以下公式,就可以利用Math.random()从某个整数范围内随机选择一个值.
值 = Math.floor(Math.random() * 可能值的总数 + 第一个可能的值).
如要选择一个介于2到10之间的值:
var num = Math.floor(Math.random() * 9 + 2);
函数:
function selectFrom(lowerValue, upperValue){
var choices = upperValue - lowerValue +1;
return Math.floor(Math.random() * choices + lowerValue);
}
var num = selectFrom(2,10);
alert(num); //介于2和10之间,包括2和10的一个值
应用:
var colors = ["red","green","blue","yellow","black","purple","brown"];
var color = colors[selectFrom(0,colors.length-1)];
alert(color); //可能是数组中包含的任何一个字符串
5.其他方法
Math.abs(num); //返回num的绝对值
Math.log(num); //返回num的自然对数
Math.pow(num,power); //返回num的power次幂
Math.sqrt(num); //返回num的平方