JavaScript中的时间与日期、正则表达式和Function类型

小咪咪 2022-12-02 01:04 161阅读 0赞

## 1、时间与日期 ##

ECMAScript 提供了 Date 类型来处理时间和日期。Date 类型内置一系列获取和设置日期时间信息的方法。

#### Date 类型 ####

ECMAScript 中的 Date 类型是在早期 Java 中 java.util.Date 类基础上构建的。为此，Date 类型使用 UTC（Coordinated Universal Time，国际协调时间\[又称世界统一时间\]）1970 年 1 月 1 日午夜（零时）开始经过的毫秒来保存日期。在使用这种数据存储格式的条件下，Date 类型保存的日期能够精确到 1970 年 1 月 1 日之前或之后的 285616 年。  
创建一个日期对象，使用 new 运算符和 Date 构造方法（构造函数）即可。

var box = new Date(); 		// 创建一个日期对象

在调用 Date 构造方法而不传递参数的情况下，新建的对象自动获取当前的时间和日期。

alert(box); 				// 不同浏览器显示不同

ECMAScript 提供了两个方法，Date.parse()和 Date.UTC()。Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应的毫秒数。ECMA-262 没有定义 Date.parse()应该支持哪种日期格式，因此方法的行为因实现而异，因地区而异。默认通常接收的日期格式如下：

1.  ‘月/日/年’，如 6/13/2011;
2.  ‘英文月名 日, 年’，如 May 25, 2004;
3.  ‘英文星期几 英文月名 日 年 时:分:秒 时区’，如 Tue May 25 2004 00:00:00 GMT-070

alert(Date.parse('6/13/2011')); 	// 1307894400000

如果 Date.parse()没有传入或者不是标准的日期格式，那么就会返回 NaN。

alert(Date.parse()); 				// NaN

如果想输出指定的日期，那么把 Date.parse()传入 Date 构造方法里。

var box = new Date(Date.parse('6/13/2011'));	// Mon Jun 13 2011 00:00:00 GMT+0800
    var box = new Date('6/13/2011'); 				// 直接传入，Date.parse()后台被调用

Date 对象及其在不同浏览器中的实现有许多奇怪的行为。其中有一种倾向是将超出的范围的值替换成当前的值，以便生成输出。例如，在解析“January 32, 2007”时，有的浏览器会将其解释为“February 1, 2007”。而 Opera 则倾向与插入当前月份的当前日期。  
Date.UTC()方法同样也返回表示日期的毫秒数，但它与 Date.parse()在构建值时使用不同的信息。（年份，基于 0 的月份\[0 表示 1 月，1 表示 2 月\]，月中的哪一天\[1-31\]，小时数\[0-23\] ，分钟，秒以及毫秒)。只有前两个参数是必须的。如果没有提供月数，则天数为 1；如果省略其他参数，则统统为 0。

alert(Date.UTC(2011,11)); 			// 1322697600000

如果 Date.UTC()参数传递错误，那么就会出现负值或者 NaN 等非法信息。

alert(Date.UTC()); 					// 负值或者 NaN

如果要输出指定日期，那么直接把 Date.UTC()传入 Date 构造方法里即可。

var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16));

#### 通用的方法 ####

与其他类型一样，Date 类型也重写了 toLocaleString()、toString()和 valueOf()方法；但这些方法返回值与其他类型中的方法不同。

var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16));
    alert('toString:' + box.toString());
    alert('toLocaleString:' + box.toLocaleString()); 		// 按本地格式输出

这两个方法在不同浏览器显示的效果又不一样，但不用担心，这两个方法只是在调试比较有用，在显示时间和日期上，没什么价值。valueOf()方法显示毫秒数。

#### 日期格式化方法 ####

Date 类型还有一些专门用于将日期格式化为字符串的方法。

var box = new Date();
    alert(box.toDateString()); 			// 以特定的格式显示星期几、月、日和年
    alert(box.toTimeString()); 			// 以特定的格式显示时、分、秒和时区
    alert(box.toLocaleDateString()); 	// 以特定地区格式显示星期几、月、日和年
    alert(box.toLocaleTimeString()); 	// 以特定地区格式显示时、分、秒和时区
    alert(box.toUTCString()); 			// 以特定的格式显示完整的 UTC 日期

#### 组件方法 ####

组件方法，是为我们单独获取你想要的各种时间/日期而提供的方法。需要注意的时候 ，这些方法中，有带 UTC 的，有不带 UTC 的。UTC 日期指的是在没有时区偏差的情况下的日期值。

alert(box.getTime()); 				// 获取日期的毫秒数，和 valueOf()返回一致
    alert(box.setTime(100)); 			// 以毫秒数设置日期，会改变整个日期
    alert(box.getFullYear()); 			// 获取四位年份
    alert(box.setFullYear(2012)); 		// 设置四位年份，返回的是毫秒数
    alert(box.getMonth()); 				// 获取月份，没指定月份，从 0 开始算起
    alert(box.setMonth(11)); 			// 设置月份
    alert(box.getDate()); 				// 获取日期
    alert(box.setDate(8)); 				// 设置日期，返回毫秒数
    alert(box.getDay()); 				// 返回星期几，0 表示星期日，6 表示星期六
    alert(box.setDay(2)); 				// 设置星期几
    alert(box.getHours()); 				// 返回时
    alert(box.setHours(12)); 			// 设置时
    alert(box.getMinutes()); 			// 返回分钟
    alert(box.setMinutes(22)); 			// 设置分钟
    alert(box.getSeconds()); 			// 返回秒数
    alert(box.setSeconds(44)); 			// 设置秒数
    alert(box.getMilliseconds()); 		// 返回毫秒数
    alert(box.setMilliseconds()); 		// 设置毫秒数
    alert(box.getTimezoneOffset()); 	// 返回本地时间和 UTC 时间相差的分钟数

以上方法除了 getTimezoneOffset()，其他都具有 UTC 功能，例如 setDate()及 getDate()获取星期几，那么就会有 setUTCDate()及getUTCDate()，表示世界协调时间。

## 2、正则表达式 ##

假设用户需要在 HTML 表单中填写姓名、地址、出生日期等。那么在将表单提交到服务器进一步处理前，JavaScript 程序会检查表单以确认用户确实输入了信息并且这些信息是符合要求的。

#### 什么是正则表达式 ####

正则表达式（regular expression）是一个描述字符模式的对象。ECMAScript 的 RegExp 类表示正则表达式，而 String 和 RegExp 都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。  
正则表达式主要用来验证客户端的输入数据。用户填写完表单单击按钮之后，表单就会被发送到服务器，在服务器端通常会用 PHP、ASP.NET 等服务器脚本对其进行进一步处理 。因为客户端验证，可以节约大量的服务器端的系统资源，并且提供更好的用户体验。

#### 创建正则表达式 ####

创建正则表达式和创建字符串类似，创建正则表达式提供了两种方法，一种是采用 new 运算符，另一个是采用字面量方式。

1.  两种创建方式

var box = new RegExp('box'); 			// 第一个参数字符串
    var box = new RegExp('box', 'ig'); 		// 第二个参数可选模式修饰符

**模式修饰符的可选参数**

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>i</td> 
   <td>忽略大小写</td> 
  </tr> 
  <tr> 
   <td>g</td> 
   <td>全局匹配</td> 
  </tr> 
  <tr> 
   <td>m</td> 
   <td>多行匹配</td> 
  </tr> 
 </tbody> 
</table>

var box = /box/; 		// 直接用两个反斜杠
    var box = /box/ig; 		// 在第二个斜杠后面加上模式修饰符

1.  测试正则表达式

RegExp 对象包含两个方法：test()和 exec()，功能基本相似，用于测试字符串匹配。test()方法在字符串中查找是否存在指定的正则表达式并返回布尔值，如果存在则返回 true，不存在则返回 false。exec()方法也用于在字符串中查找指定正则表达式，如果 exec()方法执行成功，则返回包含该查找字符串的相关信息数组。如果执行失败，则返回 null。  
**RegExp 对象的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>test</td> 
   <td>在字符串中测试模式匹配，返回 true 或 false</td> 
  </tr> 
  <tr> 
   <td>exec</td> 
   <td>在字符串中执行匹配搜索，返回结果数组</td> 
  </tr> 
 </tbody> 
</table>

// 使用 new 运算符的 test 方法示例
    var pattern = new RegExp('box', 'i'); 	// 创建正则模式，不区分大小写
    var str = 'This is a Box!'; 			// 创建要比对的字符串
    alert(pattern.test(str)); 				// 通过 test()方法验证是否匹配
    
    // 使用字面量方式的 test 方法示例
    var pattern = /box/i; 					// 创建正则模式，不区分大小写
    var str = 'This is a Box!';
    alert(pattern.test(str));
    
    // 使用一条语句实现正则匹配
    alert(/box/i.test('This is a Box!')); 	// 模式和字符串替换掉了两个变量
    
    // 使用 exec 返回匹配数组
    var pattern = /box/i;
    var str = 'This is a Box!';
    alert(pattern.exec(str)); 				// 匹配了返回数组，否则返回 null

1.  使用字符串的正则表达式方法

除了 test()和 exec()方法，String 对象也提供了 4 个使用正则表达式的方法。  
**String 对象中的正则表达式方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>match(pattern)</td> 
   <td>返回 pattern 中的子串或 null</td> 
  </tr> 
  <tr> 
   <td>replace(pattern, replacement)</td> 
   <td>用 replacement 替换 pattern</td> 
  </tr> 
  <tr> 
   <td>search(pattern)</td> 
   <td>返回字符串中 pattern 开始位置</td> 
  </tr> 
  <tr> 
   <td>split(pattern)</td> 
   <td>返回字符串按指定 pattern 拆分的数组</td> 
  </tr> 
 </tbody> 
</table>

// 使用 match 方法获取获取匹配数组
    var pattern = /box/ig; 							// 全局搜索
    var str = 'This is a Box!，That is a Box too';
    alert(str.match(pattern)); 						// 匹配到两个 Box,Box
    alert(str.match(pattern).length); 				// 获取数组的长度
    
    // 使用 search 来查找匹配数据
    var pattern = /box/ig;
    var str = 'This is a Box!，That is a Box too';
    alert(str.search(pattern)); 					// 查找到返回位置，否则返回-1

因为 search 方法查找到即返回，也就是说无需 g 全局。

// 使用 replace 替换匹配到的数据
    var pattern = /box/ig;
    var str = 'This is a Box!，That is a Box too';
    alert(str.replace(pattern, 'Tom')); 				// 将 Box 替换成了 Tom
    
    // 使用 split 拆分成字符串数组
    var pattern = / /ig;
    var str = 'This is a Box!，That is a Box too';
    alert(str.split(pattern)); 							// 将空格拆开分组成数组

**RegExp 对象的静态属性**

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>短名</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>input</td> 
   <td>$_</td> 
   <td>当前被匹配的字符串</td> 
  </tr> 
  <tr> 
   <td>lastMatch</td> 
   <td>$&amp;</td> 
   <td>最后一个匹配字符串</td> 
  </tr> 
  <tr> 
   <td>lastParen</td> 
   <td>$+</td> 
   <td>最后一对圆括号内的匹配子串</td> 
  </tr> 
  <tr> 
   <td>leftContext</td> 
   <td>$`</td> 
   <td>最后一次匹配前的子串</td> 
  </tr> 
  <tr> 
   <td>multiline</td> 
   <td>$*</td> 
   <td>用于指定是否所有的表达式都用于多行的布尔值</td> 
  </tr> 
  <tr> 
   <td>rightContext</td> 
   <td>$’</td> 
   <td>在上次匹配之后的子串</td> 
  </tr> 
 </tbody> 
</table>

// 使用静态属性
    var pattern = /(g)oogle/;
    var str = 'This is google！';
    pattern.test(str); 				// 执行一下
    alert(RegExp.input); 			// This is google！
    alert(RegExp.leftContext); 		// This is
    alert(RegExp.rightContext); 	// ！
    alert(RegExp.lastMatch); 		// google
    alert(RegExp.lastParen); 		// g
    alert(RegExp.multiline); 		// false

Opera 不支持 input、lastMatch、lastParen 和 multiline 属性。IE 不支持 multiline 属性。所有的属性可以使用短名来操作。RegExp.input 可以改写成 `RegExp['$_']`，依次类推。但 RegExp.input 比较特殊，它还可以写成 RegExp.$\_。  
**RegExp 对象的实例属性**

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>global</td> 
   <td>Boolean 值，表示 g 是否已设置</td> 
  </tr> 
  <tr> 
   <td>ignoreCase</td> 
   <td>Boolean 值，表示 i 是否已设置</td> 
  </tr> 
  <tr> 
   <td>lastIndex</td> 
   <td>整数，代表下次匹配将从哪里字符位置开始</td> 
  </tr> 
  <tr> 
   <td>multiline</td> 
   <td>Boolean 值，表示 m 是否已设置</td> 
  </tr> 
  <tr> 
   <td>Source</td> 
   <td>正则表达式的源字符串形式</td> 
  </tr> 
 </tbody> 
</table>

// 使用实例属性
    var pattern = /google/ig;
    alert(pattern.global); 				// true，是否全局了
    alert(pattern.ignoreCase); 			// true，是否忽略大小写
    alert(pattern.multiline); 			// false，是否支持换行
    alert(pattern.lastIndex); 			// 0，下次的匹配位置
    alert(pattern.source); 				// google，正则表达式的源字符串
    var pattern = /google/g;
    var str = 'google google google';
    pattern.test(str); 					// google，匹配第一次
    alert(pattern.lastIndex); 			// 6，第二次匹配的位

以上基本没什么用。并且 lastIndex 在获取下次匹配位置上 IE 和其他浏览器有偏差 ，主要表现在非全局匹配上。lastIndex 还支持手动设置，直接赋值操作。

#### 获取控制 ####

正则表达式元字符是包含特殊含义的字符。它们有一些特殊功能，可以控制匹配模式的方式。反斜杠后的元字符将失去其特殊含义。  
**字符类：单个字符和数字**

<table> 
 <thead> 
  <tr> 
   <th>元字符/元符号</th> 
   <th>匹配情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>.</td> 
   <td>匹配除换行符外的任意字符</td> 
  </tr> 
  <tr> 
   <td>[a-z0-9]</td> 
   <td>匹配括号中的字符集中的任意字符</td> 
  </tr> 
  <tr> 
   <td><code>[^a-z0-9]</code></td> 
   <td>匹配任意不在括号中的字符集中的字符</td> 
  </tr> 
  <tr> 
   <td>\d</td> 
   <td>匹配数字</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>匹配非数字，同<code>[^0-9]</code>相同</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>匹配字母和数字及_</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>匹配非字母和数字及_</td> 
  </tr> 
 </tbody> 
</table>

**字符类：空白字符**

<table> 
 <thead> 
  <tr> 
   <th>元字符/元符号</th> 
   <th>匹配情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\0</td> 
   <td>匹配 null 字符</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>匹配空格字符</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>匹配进纸字符</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>匹配换行符</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>匹配回车字符</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>匹配制表符</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>匹配空白字符、空格、制表符和换行符</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>匹配非空白字符</td> 
  </tr> 
 </tbody> 
</table>

**字符类：锚字符**

<table> 
 <thead> 
  <tr> 
   <th>元字符/元符号</th> 
   <th>匹配情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>^</td> 
   <td>行首匹配</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td>行尾匹配</td> 
  </tr> 
  <tr> 
   <td>\A</td> 
   <td>只有匹配字符串开始处</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>匹配单词边界，词在[]内时无效</td> 
  </tr> 
  <tr> 
   <td>\B</td> 
   <td>匹配非单词边界</td> 
  </tr> 
  <tr> 
   <td>\G</td> 
   <td>匹配当前搜索的开始位置</td> 
  </tr> 
  <tr> 
   <td>\Z</td> 
   <td>匹配字符串结束处或行尾</td> 
  </tr> 
  <tr> 
   <td>\z</td> 
   <td>只匹配字符串结束处</td> 
  </tr> 
 </tbody> 
</table>

**字符类：重复字符**

<table> 
 <thead> 
  <tr> 
   <th>元字符/元符号</th> 
   <th>匹配情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>x?</td> 
   <td>匹配 0 个或 1 个 x</td> 
  </tr> 
  <tr> 
   <td>x*</td> 
   <td>匹配 0 个或任意多个 x</td> 
  </tr> 
  <tr> 
   <td>x+</td> 
   <td>匹配至少一个 x</td> 
  </tr> 
  <tr> 
   <td>(xyz)+</td> 
   <td>匹配至少一个(xyz)</td> 
  </tr> 
  <tr> 
   <td>x{m,n}</td> 
   <td>匹配最少 m 个、最多 n 个 x</td> 
  </tr> 
 </tbody> 
</table>

**字符类：替代字符**

<table> 
 <thead> 
  <tr> 
   <th>元字符/元符号</th> 
   <th>匹配情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>this</td> 
   <td>where</td> 
  </tr> 
 </tbody> 
</table>

**字符类：记录字符**

<table> 
 <thead> 
  <tr> 
   <th>元字符/元符号</th> 
   <th>匹配情况</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>(string)</td> 
   <td>用于反向引用的分组</td> 
  </tr> 
  <tr> 
   <td>\1 或$1</td> 
   <td>匹配第一个分组中的内容</td> 
  </tr> 
  <tr> 
   <td>\2 或$2</td> 
   <td>匹配第二个分组中的内容</td> 
  </tr> 
  <tr> 
   <td>\3 或$3</td> 
   <td>匹配第三个分组中的内容</td> 
  </tr> 
 </tbody> 
</table>

// 使用点元字符
    var pattern = /g..gle/; 									// .匹配一个任意字符
    var str = 'google';
    alert(pattern.test(str));
    
    // 重复匹配
    var pattern = /g.*gle/; 									// .匹配 0 个一个或多个
    var str = 'google'; //*,?,+,{n,m}
    alert(pattern.test(str));
    
    // 使用字符类匹配
    var pattern = /g[a-zA-Z_]*gle/; 							// [a-z]*表示任意个 a-z 中的字符
    var str = 'google';
    alert(pattern.test(str));
    var pattern = /g[^0-9]*gle/; 								// [^0-9]*表示任意个非 0-9 的字符
    var str = 'google';
    alert(pattern.test(str));
    var pattern = /[a-z][A-Z]+/; 								// [A-Z]+表示 A-Z 一次或多次
    var str = 'gOOGLE';
    alert(pattern.test(str));
    
    // 使用元符号匹配
    var pattern = /g\w*gle/; 									// \w*匹配任意多个所有字母数字_
    var str = 'google';
    alert(pattern.test(str));
    var pattern = /google\d*/; 									// \d*匹配任意多个数字
    var str = 'google444';
    alert(pattern.test(str));
    var pattern = /\D{7,}/; 									// \D{7,}匹配至少 7 个非数字
    var str = 'google8';
    alert(pattern.test(str));
    
    // 使用锚元字符匹配
    var pattern = /^google$/; 									// ^从开头匹配，$从结尾开始匹配
    var str = 'google';
    alert(pattern.test(str));
    var pattern = /goo\sgle/; 									// \s 可以匹配到空格
    var str = 'goo gle';
    alert(pattern.test(str));
    var pattern = /google\b/; 									// \b 可以匹配是否到了边界
    var str = 'google';
    alert(pattern.test(str));
    
    // 使用或模式匹配
    var pattern = /google|baidu|bing/; 							// 匹配三种其中一种字符串
    var str = 'google';
    alert(pattern.test(str));
    
    // 使用分组模式匹配
    var pattern = /(google){4,8}/; 								// 匹配分组里的字符串 4-8 次
    var str = 'googlegoogle';
    alert(pattern.test(str));
    var pattern = /8(.*)8/; 									// 获取 8..8 之间的任意字符
    var str = 'This is 8google8';
    str.match(pattern);
    alert(RegExp.$1); 											// 得到第一个分组里的字符串内容
    var pattern = /8(.*)8/;
    var str = 'This is 8google8';
    var result = str.replace(pattern,'<strong>$1</strong>'); 	// 得到替换的字符串输出
    document.write(result);
    var pattern = /(.*)\s(.*)/;
    var str = 'google baidu';
    var result = str.replace(pattern, '$2 $1'); 				// 将两个分组的值替换输出
    document.write(result);

// 关于贪婪和惰性
    var pattern = /[a-z]+?/; 											// ?号关闭了贪婪匹配，只替换了第一个
    var str = 'abcdefjhijklmnopqrstuvwxyz';
    var result = str.replace(pattern, 'xxx');
    alert(result);
    var pattern = /8(.+?)8/g; 											// 禁止了贪婪，开启的全局
    var str = 'This is 8google8, That is 8google8, There is 8google8';
    var result = str.replace(pattern,'<strong>$1</strong>');
    document.write(result);
    var pattern = /8([^8]*)8/g; 										// 另一种禁止贪婪
    var str = 'This is 8google8, That is 8google8, There is 8google8';
    var result = str.replace(pattern,'<strong>$1</strong>');
    document.write(result);
    
    // 使用 exec 返回数组
    var pattern = /^[a-z]+\s[0-9]{4}$/i;
    var str = 'google 2012';
    alert(pattern.exec(str)); 											// 返回整个字符串
    var pattern = /^[a-z]+/i; 											// 只匹配字母
    var str = 'google 2012';
    alert(pattern.exec(str)); 											// 返回 google
    var pattern = /^([a-z]+)\s([0-9]{4})$/i; 							// 使用分组
    var str = 'google 2012';
    alert(pattern.exec(str)[0]); 										// google 2012
    alert(pattern.exec(str)[1]);										// google
    alert(pattern.exec(str)[2]); 										// 2012
    
    // 捕获性分组和非捕获性分组
    var pattern = /(\d+)([a-z])/; 										// 捕获性分组
    var str = '123abc';
    alert(pattern.exec(str));
    var pattern = /(\d+)(?:[a-z])/; 									// 非捕获性分组
    var str = '123abc';
    alert(pattern.exec(str));
    
    // 使用分组嵌套
    var pattern = /(A?(B?(C?)))/; 										// 从外往内获取
    var str = 'ABC';
    alert(pattern.exec(str));
    
    // 使用前瞻捕获
    var pattern = /(goo(?=gle))/; 										// goo 后面必须跟着 gle 才能捕获
    var str = 'google';
    alert(pattern.exec(str));
    
    // 使用特殊字符匹配
    var pattern = /\.\[\/b\]/; 											// 特殊字符，用\符号转义即可
    var str = '.[/b]';
    alert(pattern.test(str));
    
    // 使用换行模式
    var pattern = /^\d+/mg; 											// 启用了换行模式
    var str = '1.baidu\n2.google\n3.bing';
    var result = str.replace(pattern, '#');
    alert(result);

#### 常用的正则 ####

1.  检查邮政编码

var pattern = /[1-9][0-9]{5}/; 			// 共 6 位数字，第一位不能为 0
    var str = '224000';
    alert(pattern.test(str));

1.  检查文件压缩包

var pattern = /[\w]+\.zip|rar|gz/; 		// \w 表示所有数字和字母加下划线
    var str = '123.zip'; 					// \.表示匹配.，后面是一个选择
    alert(pattern.test(str));

1.  删除多余空格

var pattern = /\s/g; 					// g 必须全局，才能全部匹配
    var str = '111 222 333';
    var result = str.replace(pattern,''); 	// 把空格匹配成无空格
    alert(result);

1.  删除首尾空格

var pattern = /^\s+/; 								// 强制首
    var str = ' goo gle ';
    var result = str.replace(pattern, '');
    pattern = /\s+$/; 									// 强制尾
    result = result.replace(pattern, '');
    alert('|' + result + '|');
    var pattern = /^\s*(.+?)\s*$/; 						// 使用了非贪婪捕获
    var str = ' google ';
    alert('|' + pattern.exec(str)[1] + '|');
    var pattern = /^\s*(.+?)\s*$/;
    var str = ' google ';
    alert('|' + str.replace(pattern, '$1') + '|'); 		// 使用了分组获取

1.  简单的电子邮件验证

var pattern = /^([a-zA-Z0-9_\.\-]+)@([a-zA-Z0-9_\.\-]+)\.([a-zA-Z]{2,4})$/;
    var str = 'yc60.com@gmail.com';
    alert(pattern.test(str));
    var pattern = /^([\w\.\-]+)@([\w\.\-]+)\.([\w]{2,4})$/;
    var str = 'yc60.com@gmail.com';
    alert(pattern.test(str));

## 3、Function类型 ##

在 ECMAScript 中，Function（函数）类型实际上是对象。每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针。

#### 函数的声明方式 ####

1.  普通的函数声明

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

1.  使用变量初始化函数

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

1.  使用 Function 构造函数

var box= new Function('num1', 'num2' ,'return num1 + num2');

第三种方式我们不推荐，因为这种语法会导致解析两次代码（第一次解析常规 ECMAScript 代码，第二次是解析传入构造函数中的字符串），从而影响性能。但我们可以通过这种语法来理解"函数是对象，函数名是指针"的概念。

#### 作为值的函数 ####

ECMAScript 中的函数名本身就是变量，所以函数也可以作为值来使用。也就是说，不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。

function box(sumFunction, num) {
    	return sumFunction(num); 		// someFunction
    }
    function sum(num) {
    	return num + 10;
    }
    var result = box(sum, 10); 			// 传递函数到另一个函数里

#### 函数内部属性 ####

在函数内部，有两个特殊的对象：arguments 和 this。arguments 是一个类数组对象，包含着传入函数中的所有参数，主要用途是保存函数参数。但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。

function box(num) {
    	if (num <= 1) {
    		return 1;
    	} else {
    		return num * box(num-1); 					// 一个简单的的递归
    	}
    }

对于阶乘函数一般要用到递归算法，所以函数内部一定会调用自身；如果函数名不改变是没有问题的，但一旦改变函数名，内部的自身调用需要逐一修改。为了解决这个问题，我们可以使用 arguments.callee 来代替。

function box(num) {
    	if (num <= 1) {
    		return 1;
    	} else {
    		return num * arguments.callee(num-1);		// 使用 callee 来执行自身
    	}
    }

函数内部另一个特殊对象是 this，其行为与 Java 和 C\#中的 this 大致相似。换句话说 ，this 引用的是函数据以执行操作的对象，或者说函数调用语句所处的那个作用域。当在全局作用域中调用函数时，this 对象引用的就是 window。

// 便于理解的改写例子
    window.color = '红色的'; 		// 全局的，或者 var color = '红色的';也行
    alert(this.color); 				// 打印全局的 color
    var box = {
    	color : '蓝色的', 			// 局部的 color
    	sayColor : function () {
    		alert(this.color); 		// 此时的 this 只能 box 里的 color
    	}
    };
    box.sayColor(); 				// 打印局部的 color
    alert(this.color); 				// 还是全局的
    
    // 引用教材的原版例子
    window.color = '红色的'; 		// 或者 var color = '红色的';也行
    var box = {
    	color : '蓝色的'
    };
    function sayColor() {
    	alert(this.color); 			// 这里第一次在外面，第二次在 box 里面
    }
    getColor();
    box.sayColor = sayColor; 		// 把函数复制到 box 对象里，成为了方法
    box.sayColor();

#### 函数属性和方法 ####

ECMAScript 中的函数是对象，因此函数也有属性和方法。每个函数都包含两个属性 ：length 和 prototype。其中，length 属性表示函数希望接收的命名参数的个数。

function box(name, age) {
    	alert(name + age);
    }
    alert(box.length); 				// 2

对于 prototype 属性，它是保存所有实例方法的真正所在，也就是原型。这个属性 ，我们将在面向对象一章详细介绍。而 prototype 下有两个方法：apply()和 call()，每个函数都包含这两个非继承而来的方法。这两个方法的用途都在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。

call()方法于 apply()方法相同，他们的区别仅仅在于接收参数的方式不同。对于 call()方法而言，第一个参数是作用域，没有变化，变化只是其余的参数都是直接传递给函数的。

function box(num1, num2) {
    	return num1 + num2;
    }
    function callBox(num1, num2) {
    	return box.call(this, num1, num2); 		// 和 apply 区别在于后面的传参
    }
    alert(callBox(10,10));

事实上，传递参数并不是 apply()和 call()方法真正的用武之地；它们经常使用的地方是能够扩展函数赖以运行的作用域。

var color = '红色的'; 		// 或者 window.color = '红色的';也行
    var box = {
    	color : '蓝色的'
    };
    function sayColor() {
    	alert(this.color);
    }
    sayColor(); 				// 作用域在 window
    sayColor.call(this); 		// 作用域在 window
    sayColor.call(window); 		// 作用域在 window
    sayColor.call(box); 		// 作用域在 box，对象冒充

这个例子是之前作用域理解的例子修改而成，我们可以发现当我们使用 call(box)方法的时候，sayColor()方法的运行环境已经变成了 box 对象里了。  
使用 call()或者 apply()来扩充作用域的最大好处，就是对象不需要与方法发生任何耦合关系（耦合，就是互相关联的意思，扩展和维护会发生连锁反应）。也就是说，box 对象和 sayColor()方法之间不会有多余的关联操作，比如 `box.sayColor = sayColor;`。