JavaScript 对象

为什么80%的码农都做不了架构师？>>>   

1.从数组到对象

数组实际上就是一组值的列表。该表中的每一个值都有自己的索引值（即数字健值），索引序列从0开始，依次递增。

例：

var myarr = ["red","yellow","blue","purple"];

document.write(myarr + "<br>");

document.write(myarr[0] + "<br>"); //red

document.write(myarr[3] + "<br>"); //purple

事实上对象情况跟数组很相似，唯一的不同是它的键值类型是自定义的。也不是不仅限于数字索引了，也可以是字符串。

例：

var teacher = {

id:1,

name:”monan”

age:29

};

l 表示对象的变量名teacher

l 与定义数组不同，定义对象使用的是大括号{}

l 括号中用逗号分割着的是组成该对象的元素（通常称为属性）

l 键/值对之间用冒号隔开。

关于键名：

键名向下面这三种情况都是合法的：

var o = {prop:1};

var o = {“prop”:1};

var o = {‘prop’:1};

通常情况下，不建议在属性名上加引号。为什么呢？因为这样可以减少一些输入。但在以下的情况下是需要加引号的：

l 如果属性名是JavaScript中的保留字之一的话。

l 如果属性名中包含空格或其它特殊字符。

l 如果属性名以数字开头的话。

一句话说明清楚：如果我们所用的属性名不符合JavaScript中的变量名命名规则，就必须加上引号，不管是双引号、单引号都可以。

var o = {

something: 1,

‘yes or no’: ‘yes’,

‘*@$%^&!~’:true

}

总这在这里我要告诉大家，用[]声明的是数组，用{}声明的是对象。

1.1.元素、属性、方法

在说到数组的时候，我们学说其中包含的是元素。而当我们说对象的时候，就会说其中包含的是属性。实际上对于JavaScript来说，它们并没有本质的不同，只是在技术术语上的表达不同而已。

另外，对象的属性也可以是一个函数，因为函数本身也是一种数据，在这种情况下我们称该属性为方法。

var dog = {

name: ‘dahuang’;

talk: function(){

alert(‘汪汪汪…’);

}

};

dog.name; //属性

dog.talk; //方法

1.2哈希表、关联型数组

在一些程序语言中，通常会存在两种不同的数组形式：

l 一般性数组，也叫做索引型数组或叫做枚举型数组（通常以数字为键值）。

l 关联型数组，也叫做哈希表（通常以字符串为键值）。

在JavaSciprt中，我们会用数组来表示索引数组，而用对象来表示关联数组。

1.3访问对象属性

我们有两种方式来访问对象属性：

l 一各是以中括号的形式，例如：dog[“name”];

l 二种是以点的形式，例如：dog.name;

通常情况下都是用点的形式来访问对象属性，但是如果我们访问的属性不是一个合法的命名规则的时候，就不能通过点号来访问。

如果访问的属性不存在就会反回undefined。

对象可以可以包含任意数据类型，自然也可以包括其它对象：

var book = {

name:"细说PHP2",

published:2012,

author:{

firstname: "高洛峰",

lastname: "易第优教育组"

}

}

document.write(book['name'] + '<br>');

document.write(book.published + '<br>');

document.write(book['author'].firstname + '<br>');

document.write(book.author['lastname'] + '<br>');

1.4 调用对象方法

对象方法实际上是一个函数类型的属性，因此访问形式与属性完全相同。也主是说用点的方式和中括号的方式都可以。而其调用方式也与调用函数一样，在指定的方法名后面加上一个括号即可。

var dog = {

name: “dahuang”,

talk: function(){

document.write(‘汪汪汪…<br>’);

}

}

dog.talk();

dog[‘talk’]();

1.5 修改属性与方法

由于JavaScirpt是一种动态语言，所以它允许我们随时对现存的对象和属性和方法进行修改。

//先创建一个空对象

var pen = {};

//alert(pen.name);

//添加几个属性

pen.name = '钢笔';

pen.color = '白色';

alert(pen.name);

pen.write = function(){

return  pen.name;

}

document.write(pen.write('我是中国人'));

//删除属性

delete pen.name;

alert(pen.name);

alert(pen.write()); //再调用这个方法就会出错

1.6 使用this

当在对象内部使用this时，代表的就是“这个对象”或“当前对象”。

var pen = {

name: ‘钢笔’,

write: function(){

return this.name;

}

}

pen.write(); //钢笔

1.7 构造函数 (constructor)

为了能使用函数来创建对象，我们需要用new操作符。

例：

function pen(){

this.name = "钢笔";

}

var pen1 = new pen;

document.write(pen1.name);

使用构造函数的好处在于，它可以在创建对象时接收一些参数。

例：

function pen(name){

this.name = name;

}

var pen1 = new pen("毛笔");

document.write(pen1.name);

利用构造器函数可以创建不同的对象了。

按照惯例，我们应该将构造器函数的首字母大写，以便区别于其它的一般函数。

1.8全局对象

function pen(name){

this.name = name;

}

var pen1 = pen('钢笔');

document.write(pen1); //这个时候返回undefined

这是因为，没有new操作符，这时候就和调用一个普通函数没有什么区别。这里的pen1值应该就是函数的返回值undefined.

那这个时候函数内部的this代表的是什么呢？答案是“全局对象”。

事实上，程序所在的环境中一般会提供一个全局对象，而我们前面所学的全局变量，就是全局对象的属性罢了。当程序的所在环境是Web浏览器时，这个全局变量就是Window了。

var a = '全局对象的全局变量';

//可以作为全局变量来访问

document.write(a + "<br>");

//也可以作为全局对象的属性来访问

document.write(window.a + "<br>");

document.write(window['a'] + "<br>");

所以上面的例子可以这样来访问

function pen(name){

this.name = name;

}

var pen1 = pen('钢笔');

//document.write(pen1.name + "<br>");

//document.write(typeof pen1.name + "<br>");

//其实它是创建了一个全局变量

document.write(name + "<br>");

//这就成了window对象的属性，也可以这样来调用

document.write(window.name + "<br>");

所以上一章所学的系统函数，也可以当作全局对象的方法来调用。

例:

parseInt(‘111’);

window.parseInt(‘111’);

1.9 构造器属性

当我们创建对象时，实际上同时也赋予了该对象一种特殊的属性——即构造器属性（constructor property）。该属性实际上是一个指向用于创建该对象的构造器函数的引用。

function pen(name){

this.name = name;

}

var pen1 = new pen('钢笔');

document.write(pen1.constructor + "<br>"); //返回构造函数

既然这样，那么我们是不是也可以这样来用：

var pen2 = new pen1.constructor('毛笔');

document.write(pen2.name);

如果是通过{}来创建的对象，那么他就是由内建构造器Object()所创建的(这个我们稍后再讲)。

var name = {};

document.write(name.constructor + "<br>");

1.10 instanceof 操作符

通过instanceof操作符，我们可以检测一个对象是不是由某个指定的构造器函数创建的。

function pen(){};

var pen1 = new pen();

var o = {};

document.write(pen1 instanceof pen);

document.write('<br>');

document.write(pen1 instanceof Object);

document.write('<br>');

document.write(o instanceof Object);

需要注意的是，这里函数名后面没有加括号，因为这里不是在调用，所心我们只需要像使用其它变量名一样，引用该函数的名字即可。

1.11 传递对象

传递对象，往往传递的都是该对象的引用。因此我们在引用上作改动，都会影响到原对象。

var obj = {name:"monan"};

var copy = obj;

document.write(copy.name + "<br/>");

copy.name = 'xiaofengfeng';

document.write(obj.name);

1.12 对象比较

var obj1 = {name:”xiaofengfeng”};

var obj2 = {name:”xiaofengfeng”};

document.write(obj1 === obj2); //false

document.write(obj1 == obj2); //false

var obj3 = obj2;

document.write(obj3 === ojb2); //true

2. 内建对象

内建对象分为三组：

l 数据封装对象：Object Array Boolean Number String。这些代表站JavaScript中不同的数据类型，并且都拥有各自不同的typeof返回值，以及undefined和null状态。

l 工具类对象： Math Date RegExp 用于提供遍历的对象

l 错误类对象：包括一般类错误对象以及其它各种特殊的错误类对象。它们可以在某些异常发生时帮助我们纠正程序工作状态。

另外值得一提的是，不要去纠结什么是内建对象，什么是内建构造器，实际上它们是一回事，要不了多久你就会明白，无论是函数还是构造器函数，最后都是对象。

2.1 Object

Object 是JavaScript中所有对象的父级对象，所有对象都继承于此。

//以下代码执行结果是等价的

var obj = {};

var obj = new Object();

空对象包含了一些对象和方法，下面列举其中一小部分：

l 返回构造器函数的构造器属性constructor

l 返回对象描述字符串的toString()方法，返回对象的描述字符串

l 返回对象单值描述信息的valueOf()方法。一般情况下，返回的就是对象本身。

例：

var obj = new Object();

document.write(obj.toString() + "<br/>"); //返回对象的描述字符串

document.write(obj.valueOf() + "<br/>"); //返回对象本身

toString()方法会在某些需要用字符串来表示对象的时候被JavaScript内部调用。例如：

alert(obj);

lalert(obj.toString); //这两个其实是一个意思。

另一种就是我们把某个对象与字符串进行连接，那么这个对象也会自己调用自身的toString()方法。

document.write(“An object:” + obj); //An object [object Object]

总而言之：

l 我们创建对象既可以用var obj = {}; 也可以用var obj = new Object();

l 无论是多复杂的对象，它都是继承自Object对象，并且拥有其所有的方法（如toString()）和属性（如constructor）。

2.2 Array

是用来构建数组的内建构造器函数

//以下两种构造函数的方法是等效的

var a = new Array();

var a = [];

构建好后，就可以往数组里添加元素，删除元素，访问元素等操作了。

也可以这样定义数组：

v ar a = new Array(1,2,3);

有一种情况是特殊的

var a = new Array(5); //这样是声明一个数组，定义了数组的长度。其值都是undefined。

既然数组也是由构造器函数创建的，那么数组也是一个对象。

document.write(typeof a); //object

既然是对象，那么也可以使用Object中的属性和方法

document.write(a.toString());

document.write(a.valueOf());

document.write(a.constructor);

尽管数组也是对象，但还是有一些特殊之处：

l 数组的属性名都是从0开始递增，并自动生成数值

l 数组拥有一个用于记录数组中元素个数的length属性

l 数组是在父级对象的基础上扩展额外的内建方法

var a = new Array(1,2,3,4);

document.write(a.length + “<br/>”);

a.length = 6; //添加了两个长度

document.write(a + “<br/>”); //后两个元素值将会以undefined来填充

a.legnth = 3;

document.write(a + “<br/>”);

值得关注的数组方法

举个例：

var a = new Array(1,2,3);

a.push('haha');

document.write(a + "<br/>");

a.pop();

document.write(a + "<br/>");

其它的自己去弄去吧。

2.3 Function

函数是一种特殊的数据类型，但事实远远不止如此，它实际上是一种对象。函数对象的内建构造器函数是Function()，我们可以把它看作是创建函数的一种备选方式，便不推荐这样用。

下面三种定义函数的方式是等效的：

function sum(a,b){

return a + b;

}

var sum = function(a,b){

return a + b;

}

var sum = new Function(‘a’,’b’,’return a + b;’);

注意：用内建构造器函数Function()创建的函数，括号中的代码全是字符串，这样的话，JavaScript要先解析这些字符串，然后再创建一个函数。这样效率是很低的。所以不推荐使用。

2.3.1 Function对象的属性

函数对象中含有一个构造器属性（constructor），其引用的就是Funciton()构造器函数

//construct 属性

var myfunc(a){return a;};

document.write(myfunc.constructor); //Function()

//length 属性：记录函数的参数个数

function myfunc(a,b,c,d,e){

return true;

}

document.write(myfunc.length);

//caller属性：在ECMA标准之外的属性，返回一个调用该函数对象的外层函数引用。

function a(){

return a.caller;

}

function b(){

return a();

}

document.write(b()); // function b(){return a();}

//prototype 属性

l 每个函数的prorotype属性中都包含了一个对象

l 它只有在该函数是构造函数时才会发挥作用

l 该函数创建的所有对象都会持有一个该prototype属性的引用，并可以将其当做自身的属性来使用。

例：

//声明一个对象

var obj = {

name: 'xiaohua',

say: function(){

return "My name is " + this.name +"<br/>";

}

}

//声明一个空函数，该函数的prototype属性是一个对象

function F(){}

document.write(F.prototype + "<br/>");

//把obj赋值给F()函数的prototype

F.prototype = obj;

//现在，我们将F()作为一个构造函数来创建对象，那么新对象obj就会对F.prototype属性的访问权

var newobj = new F();

document.write(newobj.name + "<br>");

document.write(newobj.say() + "<br>");

2.3.2 Function对象的方法：

它也拥有Object的所有方法。

//toString()方法：得到的是该函数的原代码

function myfunc(){

return arguments;

}

document.write(myfunc.toString() + "<br/>");

//如果用toString()来查看内建函数，是看不见源码的，得到的是一个没有用的字符串

document.write(eval.toString() + “<br/>”);

//call() 和 apply() 两个方法，通过这两个方法可以去借用其它对象中的方法，为己所用。这是一种代码重写的方式，非常简单，而且实用。

//声明一个对

var obj = {

name: '西门庆',

say: function(age){

return "My name is " + this.name + " My age is " + age + " year old<br/>"

}

}

//再创建一个新对象

var newobj = {name:"潘金莲"};

document.write(obj.say.call(newobj,15) + "<br/>");

document.write(obj.say.apply(newobj,[30,20]) + "<br/>");

2.3.3 重新认识arguments对象

arguments对象是用来访问传递给函数的参数。看上去像一个数组，其实只是一个年直去有点像数组的对象。因为数组是不会有方法的。arguments可以使用sort()、slice()这样的数组方法。

在这里呢，是想给大家介绍一个值得关注的属性——callee属性。该属性引用的是当前被调用的函数对象。也就是说，如果我们所建函数的返回值是arguments.callee的话，该函数在被调用时就会返回自身的引用。

//例：

function myfunc(){

return arguments.callee;

}

document.write(myfunc() + "<br/>");

//这就相当于是自己调用自己，可以用它来实现匿名函数的递归调用

(

function(count){

if(count <= 5){

document.write(count + "<br/>");

arguments.callee(++count);

}

}

)(0);

2.4 Boolean

继续内建对象，接下来介绍的是基本数据类型的封装：Boolean Number String.

首先介绍一下Boolean ,由Boolean()构造器所创建的对象并没有多少实用性，因为他并没有提供来自父级对象以外的任何方法和属性。

//这里必须明白，由内建函数创建的是一个对象，不是一个基本的布尔值。

var b = new Boolean();

document.write(typeof b + "<br/>");

document.write(typeof b.valueOf() + "<br/>");

//想获取这样的基本类型值，可以用valueOf()方法

document.write(b.valueOf() + "<br/>");

//被当作函数用的时候，会把非布尔值转换为布尔值（相当于两次取反）

document.write(Boolean("test") + "<br/>"); //字符串为真

document.write(Boolean("") + "<br/>"); //空字符串为真

document.write(Boolean({}) + "<br/>"); //空对象为真

document.write(Boolean([]) + "<br/>"); //空数组为真

document.write(Boolean(0) + "<br/>"); //0为假

2.5 Number

Number()函数与Boolean()基本相同，即：

l 在被当作一般函数时，它会试图将任何值转换为数字，这与parseInt() 和 parseFloat()起到的作用基本相同。

l 在被当作构造器函数时（即用于new操作符），它会创建一个对象。

var n = Number('12.12');

document.write(n + "<br/>"); //12.12

document.write(typeof n + "<br/>"); //number

var n = new Number('12.12');

document.write(typeof n + "<br/>"); //Object

Number对象的属性

//Number对象的属性

document.write(Number.MAX_VALUE + "<br/>"); //最大值

document.write(Number.MIN_VALUE + "<br/>"); //最小值

document.write(Number.POSITIVE_INFINITY + "<br/>"); //正无穷大

document.write(Number.NEGATIVE_INFINITY + "<br/>"); //负无穷大

document.write(Number.NaN + "<br/>"); //Not a Number

//Number对象的三个方法

var n = new Number(123.45678);

document.write(n.toFixed(1) + "<br/>");

var n = new Number(123456789);

document.write(n.toExponential(5) + "<br/>");

var n = new Number(255);

document.write(n.toString() + "<br/>"); //不填参数，默认为10进制

document.write(n.toString(10) + "<br/>"); //同上

document.write(n.toString(16) + "<br/>"); //转为十六进制

document.write(n.toString(2) + "<br/>"); //转为二进制

2.6 String对象

String()构造器函数创建一个Stirng对象。该对象为我们提供了一系列用于文本操作的方法，但我们还是推荐使用基本的字符串类型。

//通过下面的例子来看看String对象与基本字符串类型的区别

var str = "hello";

document.write(typeof str + "<br/>"); //字符串

var str = new String('world');

document.write(typeof str + "<br/>"); //对象

//String对象就像是一个数组，有索引，也有length属性

document.write(str[0] + "<br/>");

document.write(str[4] + "<br/>");

document.write(str.length + "<br/>");

//String对象继承自Object对象，因此想要查看基本类型值可能通过valueOf() toString()方法，也可以将其转换为字符串

document.write(str.valueOf() + "<br/>");

document.write(str.toString() + "<br/>");

document.write(str + "<br/>"); //第三种，拼接为字符串，也是字符串转换的一种

//如果我们将基本字符串当作对象来使用，后台就会自动调用相应的String对象创建与销毁操作

document.write("hello".length + "<br/>");

document.write("hello"[0] + "<br/>");

document.write("hello"["hello".length - 1] + "<br/>");

//再来看一个String对象和基本字符串的区别的例子

document.write(Boolean("") + "<br>");

document.write(Boolean(new String("")) + "<br>");

//与Number 和 Boolean对象类似，如果我们不作用new操作符来调用Stirng()函数，它将会将其参数转换为字符串类型的值。如果其参数是一个对象的话，就相当于调用该对象的toString()方法

document.write(typeof String(1) + "<br/>");

document.write(String({p:1}) + "<br/>");

document.write(String([1,2,3]) + "<br/>");

String对象中值得关注的方法：

var str = "Abcd EfgeE";

document.write(str.toUpperCase() + "<br/>"); //转大写

document.write(str.toLowerCase() + "<br/>"); //转小写

document.write(str.charAt(3) + "<br/>"); //返回指定位置的字符

document.write(str.indexOf('E') + "<br/>"); //返回指定字符的位置

document.write(str.lastIndexOf('E') + "<br/>"); //返回指定字符的最后出现的位置

document.write(str.toUpperCase().indexOf('E',6) + "<br/>"); //先转为大写，相当于不区分大小写，从第六个开始查询，返回E的位置

document.write(str.indexOf('z') + "<br/>"); //不存在返回-1

//slice() substring() 这两个方法都可以返回字符串的指定区间

document.write(str.slice(1,4) + "<br/>");

document.write(str.substring(1,4) + "<br/>");

//第二个参数指定的是区间的末端位置，而不是长度。这两个方法不同之处在于负值的处理方式。slice()会把这个负数和长度相加，而substring()则把它视为从0开始

document.write(str.slice(1,-1) + "<br/>");

document.write(str.substring(3,-1) + "<br/>");

//split()方法：将字符串按照指定字符分割为数组

document.write(str.split(' ') + "<br/>");

document.write(str.split(' ').join(' ') + "<br/>"); //数组又变回字符串了

//concat()方法，追加字符串，与字符串类型+操作符类似

document.write(str.concat("zzzzzzz") + "<br/>");

document.write(str + "zzzzzzz" + "<br/>");

//以上讨论的情况，都不会修改源字符串

2.7 Math对象

Math对象与其它内建对象有些区别，既不能当作一般函数来使用，也不能用new操作符来创建对象。Math只是一个包含一系列方法和属性、用于数学计算的内奸对象。

Math对象的属性都是不可修改的，因此它们都是大写的。

//Math对象的属性

//3.14

document.write(Math.PI + "<br/>");

//2的平方根

document.write(Math.SQRT2 + "<br/>");

//欧拉常数e

document.write(Math.E + "<br/>");

//2的自然对数

document.write(Math.LN2 + "<br/>");

//10的自然对数

document.write(Math.LN10 + "<br/>");

//Math对象的方法

//生成随机数 Math.round() 四舍五入  Math.ceil() Math.floor()

document.write(Math.random() + "<br/>"); //返回0到1之间的某个数

document.write(Math.round(Math.random()*100) + "<br/>"); //返回0到100之间的某个整数

//如果要获取某个区间内的值，用这个公式(max - min) * Math.random() + min

document.write(Math.round((100 - 20) * Math.random() + 20) + "<br/>")

//Math.min() Math.max() 取一个区间内的最小值，最大值

//比如如何验证一个合法的月份

var n = 13;

document.write(Math.min(Math.max(1,n),12) + "<br/>");

//2的8次方

document.write(Math.pow(2,8) + "<br/>");

//求9的平方根

document.write(Math.sqrt(9) + "<br/>");

2.8 Date对象

Date()对象是用于创建Date对象的构造函数器，可以传递以下几种参数：

l 无参数（返回当天的日期）

l 一个用于表示日期的字符串

l 分别传递日、月、时间等值

l 一个Unix时间戳

//表示一个当天时间的对象实例

document.write(new Date() + "<br/>");

//其它的一些表示

var d = new Date('2013 07 17 17:30:50');

document.write(d + "<br/>");

var d = new Date('1 1 2014');

document.write(d + "<br/>");

//通过一个字符串来表示日期不够精确

//更好的选择是向构造器传递一些具体的值

//年份，月份（0-11），日期（1-31），小时（0-23）、

//分钟（0-59），秒钟（0-59），毫秒（0-999）

var d = new Date(2013,2,30,12,13,13,888);

document.write(d + "<br/>");

//传一个Unxi时间戳

var d = new Date(1369996543234);

document.write(d + "<br/>");

//如果没有 使用new操作符，无论传不传参数，得到的都是当前时间

var d = Date(111111111111111);

document.write(d + "<br/>");

//表示一个当天时间的对象实例

document.write(new Date() + "<br/>");

//其它的一些表示

var d = new Date('2013 07 17 17:30:50');

document.write(d + "<br/>");

var d = new Date('1 1 2014');

document.write(d + "<br/>");

//通过一个字符串来表示日期不够精确

//更好的选择是向构造器传递一些具体的值

//年份，月份（0-11），日期（1-31），小时（0-23）、

//分钟（0-59），秒钟（0-59），毫秒（0-999）

var d = new Date(2013,2,30,12,13,13,888);

document.write(d + "<br/>");

//传一个Unxi时间戳

var d = new Date(1369996543234);

document.write(d + "<br/>");

//如果没有 使用new操作符，无论传不传参数，得到的都是当前时间

var d = Date(111111111111111);

document.write(d + "<br/>");

//Date对象方法的工作方式

//一旦创建了Date对象，就可以使用该对象中的很多方法

//使用最多的就是set*() 和get*()系列

//例如，getMonth(),setMonth(),getHours(),setHours()

var d = new Date();

document.write(d.getMonth() + "<br/>");

document.write(d.toLocaleString() + "<br/>");

//设置为8月

d.setMonth(7);

document.write(d.toLocaleString() + "<br/>");

//把字符串转为Unix时间戳，注意这个时间戳不是秒，而是毫秒

var d = Date.UTC(2013,7,18);

document.write(d + "<br/>");

var d = Date.parse('7,18,2013');

document.write(d + "<br/>");

document.write(new Date(d).toLocaleString() + "<br/>");

//Date()函数也可以接受一个Unix时间戳

var d = new Date(1376784000000);

document.write(d.toLocaleString() + "<br/>");

//输出一个我们习惯的时间

var d = new Date();

document.write(d.getFullYear() + "年"+ (d.getMonth() + 1)+ "月" + d.getDate(d) + "日" + d.getHours() + "时" + d.getMinutes() + "分" + d.getSeconds() + "秒" + "<br/>");

2.9 RegExp (正则表达式)

正则表达式是一种强大的文本搜索和处理方式

正则表达式的组成：

l 一个用于匹配的模式文本

l 用0个或多个修饰符描述匹配模式细节

事实上掌握正则表达式是一个很大的问题，我们不打算在这里详细的讨论这个问题。我们只是来介绍一下它在JavaScript中的语法。

//利用构造器函数来创建一个正则对象

var re = new RegExp("j.*t");

//有一个更为简便的定义正则对象的方式：文本定义方式

var re1 = /j.*t/; //这里不需要引号，如果是把它放在构造器函数中是需要引号的。

2.9.1 RegExp对象的属性

* global: 如果设置该属性为false(这也是默认值)，相关搜索会在找到第一个匹配的位置时就停止。如果需要找到所有匹配的位置，就需要设置为true

* ignoreCase: 设置是否区分大小写，默认为false

* multiline: 设置是否跨行搜索的选项，默认为false

* lastIndex: 设置开始的索引位置，默认为0

* source: 用于存储正则表达式匹配模式的属性

除了lastIndex外，上述属性定义了对象之后就不能被修改。前三个属性还可以通过RegExp修饰符来表示。当我们创建一个正则对象时，就向构造函数的第二个参数，传递下列字符中的任意组合即可。

l g 代表 global

l i 代表 ignoreCase

l m 代表 multiline

只要传递了该值就说明值被设置为true了。

例：

var re = new RegExp(“j.*t”,’gim’);

var re1 = /j.*t/gim;

2.9.2 RegExp对象的方法

test() //返回布尔值

exec() //返回匹配到的字符组成的数组

document.write(/j.*t/gim.test("JavaScript") + "<br/>"); //true

document.write(/j.*t/gi.exec("JavaScript") + "<br/>"); //JavaScript

2.9.3 以正则表达式为参数的字符串方法

* match() 返回一个包含匹配内容的数组

* search() 返回第一个匹配内容所在的位置

* replace() 将匹配到的文本替换为指定的字符串

* split() 能根据指定的正则表达式将目标字符串分割成数组元素

var s = new String("HelloJavaScriptWorld");

document.write(s.match(/[A-Z]/g) + "<br/>"); //[H,J,S,W]

document.write(s.search(/j.*a/i) + "<br/>");

document.write(s.replace(/[A-Z]/g,'**') + "<br/>");

var str = "one*two*three*four";

var newstr = str.split(/\*/);

document.write(newstr + "<br/>");

//以上四个函数，如果正则过于简单，建议直接使用字符串来表示。但是如果这们析话，就不能使用修饰符了。

2.10 Error对象

当程序出现错误时，就会抛出一个Error对象，该对象可能由以下几个内建构造器中的一个产生而成，它们包括EvalError  RangeError  ReferenceError  SyntaxError  TypeError  URIError  这些构造器都继承自Error对象。

try{

l();

}catch(e){

//try里面如果有错误，就会执行这里的代码

document.write(e.name + ":" + e.message + "<br/>");

}finally{

//有没有错误都要执行的代码

document.write("强制执行<br/>");

}

////实例二，自定义错误抛出

try{

var func = function(){return 0;};

var total = func();

if(total === 0){

throw {name:"除数", message:"OMG!除数不能为零"};

}else{

document.write(50 / total);

document.write("<br/>");

}

}catch(e){

document.write(e.name + ":" + e.message + "<br/>");

}finally{

document.write("强制执行的代码块<br/>");

}

转载于:https://my.oschina.net/appk/blog/152951