20xx年8月20日

书名：《心平气和当老师》

作者：茅卫东

感想：

教师不是单纯的知识和价值观的输出者，在滋养和守护学生生命体验的旅途中，教师的生命也变得更加饱满和勃发。

在《心平气和当老师》这本书中，茅卫东讲述了20年来他作为一名教师，作为一名教育记者，如何坚守自己的原则，如何践行自己教育理念的故事。从这个意义上讲，这是茅卫东用20年的坚守与践行“做”出来的一本书，它呈现了一个让人耳目一新的教师形象。

首先是它揭示了作为教师必须要面对两个层面的真实。第一个是外部环境的真实，更多指向制度与文化，任何一个教师都不得不面对。第二个层面的真实，就是如何面对自己，相对于外部环境的真实，真实地面对自己要困难得多。许多教师常常没有勇气直面自己的问题，很多时候都把自身的真实和外部的真实混为一谈，把人的问题和制度问题拧在一起，或者把批判的矛头指向外部的真实和他人的真实，不肯直面自身的缺点，以致于一方面高度自尊，一方面又怨天尤人。茅卫东在书中袒露了他内心的愤怒与无奈、愉悦和欣慰，讲述自己作为教师的感受，甚至真诚地表现出他的无力与软弱。这体现了一种理性的心态，只有敢于揭示自己的真实、自己的脆弱、自己的不足，我们才有可能反思自身，完善自身。

作为一名教师，直面真实不过是一个起点。茅卫东始终坚持做一个行动者，做一个尽可能解决实际问题的创造者和实践者。

第二篇：C#高级编程《第7版》读书笔记(7-9章)

第七章 运算符和类型强制转换

?? C#中的可用运算符

?? 处理引用类型和值类型时相等的含义

?? 基本数据类型之间的数据转换

?? 使用装箱技术把值类型转换为引用类型

?? 通过强制转换技术在引用类型之间转换

?? 重载标准的运算符，重载标准的运算符，以支持对定制类型的操作

?? 给定制类型添加强制转换运算符，给定制类型添加强制转换运算符，以支持无缝的数据类型转换 C#支持的运算符支持的运算符 C#支持的运算符

类 别

算术运算符

逻辑运算符

字符串连接运算符 增量和减量运算符

移位运算符

比较运算符

赋值运算符

成员访问运算符(用于对象和结构)

索引运算符(用于数组和索引器)

数据类型转换运算符

条件运算符 (三元运算符)

委托连接和删除运算符

对象创建运算符

类型信息运算符

溢出异常控制运算符

间接寻址运算符

命名空间别名限定符

空接合运算符 运 算 符 + – * / % & | ^ ~ && || ! + ++ – – << >> == != < > <= >= = += –= *= /= %= &= |= ^= <<= >>= . [] () ?: 是if...else结构的简化形式 + – new sizeof (只用于不安全的代码) is typeof as Checked、 unchecked * –> & (只用于不安全代码) [] :: ??

用/checked编译器选项进行编译，就可以检查程序中所有未标记代码中的溢出。

下列4个运算符(sizeof、*、->、&)只能用于不安全的代码

类 别

运算符关键字

运算符 运 算 符 sizeof(仅用于.NET Framework 1.0和1.1) *、–>、&

sizeof运算符在.NET Framework 1.0和1.1中使用，它需要不安全模式。自从.NET Framework 2.0以来，就没有这个运算符了。

在C#中很少会用到指针，因此也很少用到间接寻址运算符(->)。使用它们的唯一场合是在不安全的代码块中，因为只有在此C++才允许使用指针。

is运算符可以检查对象是否与特定的类型兼容。运算符"兼容"表示对象是该类型，或者派生于该类型。

运算符用于执行引用类型的显式类型转换。如果要转换的类型与指定的类型兼容，转换as运算符

就会成功进行；如果类型不兼容，as运算符就会返回值null。

Q:asQ:和强制转换之间的区别?

A:as和强制转换之间最大的区别就在于如何处理用户自定义的转换如何处理用户自定义的转换。操作符 as和 is 都如何处理用户自定义的转换

只检查被转换对象的运行时类型，并不执行其他的操作。如果被转换对象的运行时类型既不是所转换的目标类型，也不是其派生类型，那么转型将告失败。但是强制转型则会使用转换操作符来执行转型操作，这包括任何内建的数值转换（如：long转int）。

一般情况我们应该先考虑使用as进行类型转换，然后再考虑使用is,最后才考虑使用强制转换。

sizeof运算符可以确定堆栈中值类型需要的长度(单位是字节). 运算符

typeof运算符返回一个表示特定类型的运算符System.Type对象。

例如，typeof(string)返回表示System.String类型的Type对象。

在使用反射技术动态查找对象的信息时，这个运算符是很有效的。

可空类型和运算符 可空类型和运算符

可空类型可以表示基础类型的所有值，另外还可以表示 null 值。可空类型可通过下面两种方式中的一种声明：

System.Nullable<T> variable

- 或 -

T? variable

T 是可空类型的基础类型。T 可以是包括 struct 在内的任何值类型；但不能是引用类型。

空接合运算符(??)

空接合运算符(??)提供了一种快捷方式，可以在处理可空类型和引用类型时表示null值。 这个运算符放在两个操作数之间，第一个操作数第一个操作数必须是一个可空类型或引用类型，第二第二 第一个操作数第二 个操作数必须与第一个操作数的类型相同，或者可以隐含地转换为第一个操作数的类型。 个操作数

空接合运算符的计算如下：

?? 如果第一个操作数不是null，则整个表达式就等于第一个操作数的值。 ?? 如果第一个操作数是null，则整个表达式就等于第二个操作数的值。

示例：

int? a = null; //可空类型可空类型

int b;

b = a ?? 10; // b has the value 10

a = 3;

b = a ?? 10; // b has the value 3

运算符的优先级 组 运 算 符

初级运算符

一元运算符

乘/除运算符

加/减运算符

移位运算符

关系运算符

比较运算符

按位AND运算符

按位XOR运算符

按位OR运算符

布尔 AND运算符

布尔OR运算符

条件运算符

赋值运算符 () . [] x++ x–– new typeof sizeof checked unchecked + – ! ~ ++x ––x和数据类型转换 * / % + – << >> < > <= >= is as = = != & ^ | && || ?: = += –= *= /= %= &= |= ^= <<= >>= >>>=

类型安全性 类型安全性

C#还支持在不同引用类型之间的转换，允许指定自己创建的数据类型如何与其他类型进行相互转换。泛型是C#中的一个特性，它可以避免对一些常见的情形进行类型转换。 类型转换

byte value1 = 10;

byte value2 = 23;

byte total; //long total; 修改为这样就没问题

total = value1 + value2; //两个byte型数据加在一起时，应返回int型结果 Console.WriteLine(total);

上述代码编译时，会产生一个错误：Cannot implicitly convert type 'int' to 'byte' (不能把int类型隐式地转换为byte类型)

C#有两种转换方式：有两种转换方式：隐式转换方式和显式转换方式。

隐式类型转换 隐式类型转换

源 类 型

sbyte

byte

short

ushort

int

uint

long、ulong

float

char

? 目 的 类 型 short、int、long、float、double、decimal short、ushort、int、uint、long、ulong、float、double、decimal int、long、float、double、decimal int、uint、long、ulong、float、double、decimal long、float、double、decimal long、ulong、float、double、decimal float、double、decimal double ushort、int、uint、long、ulong、float、double、decimal 可空类型隐式转换为其他可空类型，应遵循上表非可空类型的转换规则。即int?隐式转

换long?、float?、double?和decimal?

?

? 非可空类型隐式转换为可空类型也遵循上表的转换规则，即int隐式转换为long?、float?、 double?和decimal? 可空类型不能隐式转换为非可空类型，此时必须进行显式转换

显式转换方式

不能隐式地转换类型

?

?

?

?

?

?

? int转换为short-- 会丢失数据 int转换为uint-- 会丢失数据 uint转换为int-- 会丢失数据 float转换为int-- 会丢失小数点后面的所有数据 任何数字类型转换为char -- 会丢失数据 decimal转换为任何数字类型-- 因为decimal 类型的内部结构不同于整数和浮点数 int? 转换为int-- 可空类型的值可以是null

装箱(boxing)&拆箱(unboxing)

装箱装箱：将值类型转换为引用类型。 装箱

拆箱拆箱：将引用类型转换为值类型。 拆箱

.NET

的实现方式有点魔术性的方式，即装箱(boxing)。如下图所示：

装箱与拆箱的原理也很容易了解。就是值类型与Object类型的转换。

装箱是隐式

装箱步骤：装箱步骤：。

1. 从托管堆中为新生成的引用类型对象分配内存。分配内存的大小为，值类型实例本身的大小加上额外空间。

2. 将值类型实例的字段拷贝到托管堆上新分配对象的内存中。

3. 返回托管堆中新分配对象的地址。该地址就是一个指向对象的引用。值类型实例也就变成了一个引用对象的实例。

C#和VB在必要的时候都会自动产生代码来将值类型实例装箱为引用类型。

经过装箱的值类型实例的生存期超出了未装箱的值类型实例的生存期。

拆箱是显式转换

这里有一个值得注意的地方。在拆箱时，必须非常小心，确保得到的值变量有足够的空间存储拆箱的值中的所有字节。如C#的int 只有32位，所以把long值(64位)拆箱为int时，会产一个InvalidCastException异常 拆箱步骤:拆箱步骤:

1. 如果该引用为null,将会抛出一个NullReferencrException异常。

2. 如果该引用指向的对象不是一个期望的值类型的已装箱对象，将会抛出一个 InvaildCastException异常。

3. 一个指向包含在已装箱对象中的值类型部分的指针被返回。该指针指向的值类型对 于引用类型对象通常所具有的附加成员一无所知。

对象相等比较

1.ReferenceEquals(object o1, object o2)：比较两个对象的引用，引用相同返回true，否则返回false，同为null是返回true；

2.Equals(object o)：虚拟Equals方法，比较引用，可以重写比较值；

3.Equals(object o1, object o2)：静态Equals方法，先判断两个对象是否为空，如果都不为空，则调用虚拟Equals方法；

4.object1 == object2：比较运算符，比较引用,可以重写；

注意：值类型比较时应采用重写后的Equals方法，使用ReferenceEquals进行值类型比较时总是返回false，因为两个值类型需要分别装箱到对象中，是不同的引用

运算符重载

C# 运算符重载一览表 类

别 算术二元运算符 算术一元运算符 按位二元运算符 按位一元运算符 比较运算符 赋值运算符 索引运算符

运 算 符 +, *, /, –, % +, –, ++, –– &, |, ^, <<, >> !, ~, true, false ==, !=, >=, <, <=, > +=,–=,*=,/=,>>=,<<=,%=, &=,|=,^= []

限 制 无 无 无

true和false运算符必须成对重载 必须成对重载

不能显式重载这些运算符，在重写单个运算符如+,–,%等时，它们会被隐式重写 不能直接重载索引运算符。第2章介绍的索引器成员类型允许在类和结构上支持索引运算符

数据类型转换运算符 () 不能直接重载数据类型转换运算符。用户定义的数据类型转换(本章的后面介

绍)允许定义定制的数据类型转换

注：C#要求成对重载比较运算符。如果重载了==，也必须重载！=，否则会产生编译错误。 在重载==和!=时，还应重载从System.Object中继承的Equals()和GetHashCode()方法， 否则会产生一个编译警告。原因是Equals()方法应执行与==运算符相同的相等逻辑。

不要通过调用从System.Object中继承的Equals()方法的实例版本，来重载比较运算符，如果这么做，在objA是null时计算(objA==objB)，就会产生一个异常，因为.NET运行库会试图计算null.Equals(objB)。采用其他方法(重写Equals()方法，调用比较运算符)比较安全。

好处

1、使得代码更加容易理解和阅读。

2、可以利用现有运算符的优先级关系规则处理对象之间的运算。

3、使得代码更加灵活，对象可操作性更好。

4、开发人员可以举一反三，因为他们熟悉了常规值类型上的运算符使用，这样可以直接将 这些规则引入到自定义对象上。

用户定义的类型的强制转换

系统预定义的数据类型，如int,float,double,string等，有的时候并不能满足我们的需要，这个时候我们需要自己的数据类型，即为自定义数据类型

但是自定义数据类型默认是不能同系统预定义的类型进行转换操作的，这时自定义类型完全没有一点作用，所以为了能在系统中运用自定义数据类型

要进行必要的用户自定义数据类型的转换，把它转换为系统可以识别的、同预定义数据类型进行操作转换的数据，为系统所使用。

第八章 委托、委托、lambda表达式和事件

?

?

?

? 委托 匿名方法 lambda表达式 事件

Q：委托是什么？匿名方法是什么？在C# 3.0中，Lambda表达式是什么？扩展方法是什么？LINQ是什么？您觉得C# 3.0中还有哪些重要的特性，它们带来了什么优势？BCL中哪些类库和这些特性有关？您平时最常用哪些？

委托：委托：是一种定义方法签名的类型。委托的作用（用于将方法作为参数传递给其它方法）,不用方法名就可以实现方法一样的效果。委托可以调用静态和非静态方法

声明一个委托要使用delegate关键字，如下:

delegate int Echo(string message);

这句代码声明了一个委托类型类型，实例可以接受参数为string，返回值为int类型这个委托类型的实例实例

型的函数。这个方法可以是对象的方法，也可以静态方法，还可以是匿名方法，只要方法的签名和返回值是和声明一致的。

1、委托和C的函数指针很像，但是函数指针仅仅包含函数入口地址，而委托是一个类型，它具有比函数指针更强的功能。(类型的安全性)

2、委托是支持多播的，也就是一串方法可以依次被执行。

如：

static int EchoOriginal(string message)

{

Console.WriteLine(message);

return 1;

}

static int EchoReverse(string message)

{

StringBuilder sb=new StringBuilder();

for(int i=message.Length-1;i>=0;i--)

sb.Append(message[i]);

Console.WriteLine(sb.ToString());

return -1;

}

static void Main(string[] args)

{

Echo eo = EchoOriginal;

Echo er = EchoReverse;

Echo all = eo + er;

//Echo的all实例可以接受两个委托，调用all的时候，eo，er会被一次调用，\ //返回值是最后一个委托的返回值。

eo("Hello world");

int i=all("Hello Delegate");

Console.WriteLine(i);

…

委托实现为派生自基类System. Multicast Delegate的类，System.MulticastDelegate又派生自基类System.Delegate。

.NET的事件机制是以委托为基础的。事件机制有两部分组成，一部分是事件发布者，

其实现原理就是由事件发布者声明一个委托对象，由事件响应者向那一部分是事件响应者。

个委托挂载具体的处理方法，事件发布者在需要的时候调用这个委托，这样响应者的代码就会被执行。

最简单的事件处理委托.net已经声明了：

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

有这样的类，每当找到一个奇数，他就会触发一个事件。我们的程序在接到这个事件的时候在屏幕输出一个提示

匿名方法（） 匿名方法（.net 2.0引入）

匿名方法使用delegate关键字加上参数表，最后是代码块来定义。它可以作为委托赋值给

委托类型。它可以省去单独定义一个方法的麻烦。

lambda表达式（.Net 3.0引入）l表达式 表达式

(input parameters) => expression //(参数列表) => 表达式或语句块

左侧是参数列表，=>右侧是方法体，可以是一个表达式(expression lambda)，也可以是大括号括起来的语句段(statement lambda)。它省略了delegate关键字，使得代码更加紧凑。 n=>n%2==0; 等价于 delegate(int n){ return n%2==0;}

Lambda表达式参数类型可以是隐式类型或显式类型。

在显式列表中，每个参数的类型是显式指定的，

在隐式列表中，参数的类型由Lambda表达式出现的语境自动推断类型。

Lambda表达式的参数列表可以有一个或多个参数，或者无参数。在有单一的隐型参数的lambda表达式中，圆括号可以从参数列表中省略。

事件 事件

事件基于委托，为委托提供一种发布/订阅机制。

第九章 字符串和正则表达式

?

?

? 创建字符串 格式化表达式 正则表达式

System.String类 下表方法不完整

方 法

Compare

CompareOrdinal

Concat

CopyTo

Format

IndexOf

IndexOfAny

Insert

Join

LastIndexOf

LastIndexOfAny

PadLeft

PadRight 作 用 比较字符串的内容，考虑文化背景(区域)，确定某些字符是否相等 与Compare一样，但不考虑文化背景 把多个字符串实例合并为一个实例 把特定数量的字符从选定的下标复制到数组的一个全新实例中 格式化包含各种值的字符串和如何格式化每个值的说明符 定位字符串中第一次出现某个给定子字符串或字符的位置 定位字符串中第一次出现某个字符或一组字符的位置 把一个字符串实例插入到另一个字符串实例的指定索引处 合并字符串数组，建立一个新字符串 与IndexOf一样，但定位最后一次出现的位置 与IndexOfAny，但定位最后一次出现的位置 在字符串的开头，通过添加指定的重复字符填充字符串 在字符串的结尾，通过添加指定的重复字符填充字符串

Replace

Split

Substring

ToLower

ToUpper

Trim 用另一个字符或子字符串替换字符串中给定的字符或子字符串 在出现给定字符的地方，把字符串拆分为一个子字符串数组 在字符串中获取给定位置的子字符串 把字符串转换为小写形式 把字符串转换为大写形式 删除首尾的空白

1. string greetingText = "Hello, ";

2. greetingText += "World."; //创建一个新字符串实例，给它分配足够的内存，以

存储合并的文本

最初的文本"Hello, "复制到这个新字符串中，再加上额外的文本"World."。然后更新存储在变量greetingText中的地址，使变量正确地指向新的字符串对象。现在没有引用旧的字符串对象-- 不再有变量引用它，下一次垃圾收集器清理应用程序中所有未使用的对象时，就会删除它

System.Text.StringBuilderSystem.Text.StringBuilder类

StringBuilder类有两个主要的属性：

1、Length指定字符串的实际长度；

2、Capacity指定字符串在分配的内存中的最大长度。

StringBuilder类主要的方法 名 称

Append()

AppendFormat()

Insert()

Remove()

Replace()

ToString() 作 用 给当前字符串添加一个字符串 添加特定格式的字符串 在当前字符串中插入一个子字符串 从当前字符串中删除字符 在当前字符串中，用某个字符替换另一个字符，或者用当前字符串中的一个子字符串替换另一字符串 把当前字符串转换为System.String对象(在System.Object中被重写) System.Text 和 System.Text.Regular ExpressionsSystem.Text.Regular Expressions System.TextSystem.Text.Regular Expressions

正则表达式 正则表达式

正则表达式(regular expression)描述了一种字符串匹配的模式，可以用来检查一个字符串是否含有某种子串、替换匹配的子串，或者从某个字符串中取出符合条件的子串等等。 正则表达式

是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

可以通过在一对分隔符之间放入表达式模式的各种组件来构造一个正则表达式，即/expression/ 普通字符

由所有那些未显式指定为元字符的打印和非打印字符组成。这包括所有的大写和小写字母字符，所有数字，所有标点符号以及一些符号。

非打印字符

字符

\cx 含义 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为

A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。

\f

\n

\r

\s

\S

\t

\v 匹配一个换页符。等价于 \x0c 和 \cL。 匹配一个换行符。等价于 \x0a 和 \cJ。 匹配一个回车符。等价于 \x0d 和 \cM。 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 匹配一个制表符。等价于 \x09 和 \cI。 匹配一个垂直制表符。等价于 \x0b 和 \cK。

特殊字符 特殊字符

所谓特殊字符，就是一些有特殊含义的字符，如上面说的”*.txt”中的*，简单的说就是表示任何字符串的意思。如果要查找文件名中有＊的文件，则需要对＊进行转义，即在其前加一个\。ls \*.txt。正则表达式有以下特殊字符。 特别说明 字符

$

( )

*

+

.

[

? 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 \$。 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。 匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使

用 \?。

将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如，‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\\’ 匹配 “\”，而 ‘\(’ 则匹配 “(”。

匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。

标记限定符表达式的开始。要匹配 {，请使用 \{。

指明两项之间的一个选择。要匹配 |，请使用 \|。 \ ^ { |

构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与操作符将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。

限定符 限定符

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有*或+或?或{n}或{n,}或{n,m}共6种。

*、+和?限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。

正则表达式的限定符有： 字符 描述

*

+

?

{n} 匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。 匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。 匹配前面的子表达式零次或一次。例如，”do(es)?” 可以匹配 “do” 或 “does” 中的”do” 。? 等价于 {0,1}。 n 是一个非负整数。匹配确定的 n 次。例如，’o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。

n 是一个非负整数。至少匹配n 次。例如，’o{2,}’ 不能匹配 “Bob” 中的 ‘o’，{n,} 但能匹配 “foooood” 中的所有 o。’o{1,}’ 等价于 ‘o+’。’o{0,}’ 则等价

于 ‘o*’。

m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例

{n,m}如，”o{1,3}” 将匹配 “fooooood” 中的前三个 o。’o{0,1}’ 等价于 ‘o?’。

请注意在逗号和两个数之间不能有空格。

定位符 定位符

用来描述字符串或单词的边界，^和$分别指字符串的开始与结束，\b描述单词的前或后边界，\B表示非单词边界。不能对定位符使用限定符。

选择 选择

用圆括号将所有选择项括起来，相邻的选择项之间用|分隔。但用圆括号会有一个副作用，是相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种副作用。 其中?:是非捕获元之一，还有两个非捕获元是?=和?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

后向引用 后向引用

对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获 的每个子匹配都按照在正则表达式模式中从左至右所遇到的内容存储。存储子匹配的缓冲区编号从 1 开始，连续编号直至最大 99 个子表达式。每个缓冲区都可以使用 ‘\n’ 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。

可以使用非捕获元字符 ‘?:’, ‘?=’, or ‘?!’ 来忽略对相关匹配的保存。 各种操作符的运算优先级 各种操作符的运算优先级

相同优先级的从左到右进行运算，不同优先级的运算先高后低。各种操作符的优先级从高到低如下：

操作符

\

(), (?:), (?=), [] 描述 转义符 圆括号和方括号

*, +, ?, {n}, {n,}, {n,m}限定符

^, $, \anymetacharacter 位置和顺序

|

全部符号解释 字符

\ 描述 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，’n’ 匹配字符 “n”。’\n’ 匹配一个换行符。

序列 ‘\\’ 匹配 “\” 而 “\(” 则匹配 “(”。

匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，

^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。

匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，

$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。

匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。

* 等价于{0,}。

匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 “zo” 以及

“zoo”，但不能匹配 “z”。+ 等价于 {1,}。

匹配前面的子表达式零次或一次。例如，”do(es)?” 可以匹配 “do” 或

“does” 中的”do” 。? 等价于 {0,1}。

n 是一个非负整数。匹配确定的 n 次。例如，’o{2}’ 不能匹配 “Bob” 中

的 ‘o’，但是能匹配 “food” 中的两个 o。

n 是一个非负整数。至少匹配n 次。例如，’o{2,}’ 不能匹配 “Bob” 中

的 ‘o’，但能匹配 “foooood” 中的所有 o。’o{1,}’ 等价于

‘o+’。’o{0,}’ 则等价于 ‘o*’。

m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例

如，”o{1,3}” 将匹配 “fooooood” 中的前三个 o。’o{0,1}’ 等价于

‘o?’。请注意在逗号和两个数之间不能有空格。

当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，

匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的

贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串

“oooo”，’o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。

匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，

请使用象 ‘[.\n]’ 的模式。 “或”操作 ^ $ * + ? {n} {n,} {n,m} ? .

匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合

(pattern) 得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属

性。要匹配圆括号字符，请使用 ‘\(’ 或 ‘\)’。

匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存

储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很(?:pattern)有用。例如， ‘industr(?:y|ies) 就是一个比 ‘industry|industries’ 更

简略的表达式。

正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，’Windows (?=95|98|NT|2000)’ 能匹配 “Windows 2000″ 中的 “Windows” ，但不(?=pattern)能匹配 “Windows 3.1″ 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’ 能匹配 “Windows 3.1″ 中的 “Windows”，但不能(?!pattern)匹配 “Windows 2000″ 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始

x|y

[xyz]

[^xyz]

[a-z]

[^a-z]

\b

\B

\cx

\d

\D

\f

\n

\r

\s

\S

\t

\v

\w

\W

\xn 匹配 x 或 y。例如，’z|food’ 能匹配 “z” 或 “food”。’(z|f)ood’ 则匹配 “zood” 或 “food”。 字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。 负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p'。 字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ‘a’ 到‘z’ 范围内的任意小写字母字符。 负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。 匹配一个数字字符。等价于 [0-9]。 匹配一个非数字字符。等价于 [^0-9]。 匹配一个换页符。等价于 \x0c 和 \cL。 匹配一个换行符。等价于 \x0a 和 \cJ。 匹配一个回车符。等价于 \x0d 和 \cM。 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 匹配一个制表符。等价于 \x09 和 \cI。 匹配一个垂直制表符。等价于 \x0b 和 \cK。 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字

长。例如，’\x41′ 匹配 “A”。’\x041′ 则等价于 ‘\x04′ & “1″。

正则表达式中可以使用 ASCII 编码。.

\num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1′

匹配两个连续的相同字符。

标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表

达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个

八进制转义值。

标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子

表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个

后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制

数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八

进制转义值 nml。

匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如，

\u00A9 匹配版权符号 (?)。 \n \nm \nml \un

常用正则表达式速查：

只能输入数字："^[0-9]*$"。

只能输入n位的数字："^\d{n}$"。

只能输入至少n位的数字："^\d{n,}$"。

只能输入m~n位的数字："^\d{m,n}$"

只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。

只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。

只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。

只能输入非零的正整数："^\+?[1-9][0-9]*$"。

只能输入非零的负整数："^\-[1-9][]0-9"*$。

只能输入长度为3的字符："^.{3}$"。

只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。

只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。

只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。

只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。

只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。

验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。

验证是否含有^%&',;=?$\"等字符："[^%&',;=?$\x22]+"。

只能输入汉字："^[\u4e00-\u9fa5]{0,}$"

验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。

验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。

验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。 验证身份证号（15位或18位数字）："^\d{15}|\d{18}$"。

验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。

验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～"31"。

利用正则表达式限制网页表单里的文本框输入内容：

用正则表达式限制只能输入中文：

onkeyup="value=".cn/value.replace(/["^\u4E00- \u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

用正则表达式限制只能输入全角字符：

onkeyup="value=".cn/value.replace(/["^\uFF00- \uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

用正则表达式限制只能输入数字：

onkeyup="value=".cn/value.replace(/["^\d]/g,'')

"onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

用正则表达式限制只能输入数字和英文：

onkeyup="value=".cn/value.replace(/[\W]/g,"'')

"onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1 s=/page1.htm

s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")

alert(s)

匹配双字节字符(包括汉字在内)：[^\x00-\xff]

应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String.prototype.len=function(){return

this.replace([^\x00-\xff]/g,"aa").length;}

匹配空行的正则表达式：\n[\s| ]*\r

匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/

匹配首尾空格的正则表达式：(^\s*)|(\s*$)

String.prototype.trim = function()

{

return this.replace(/(^\s*)|(\s*$)/g, "");

}

利用正则表达式分解和转换IP地址：

下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序： function IP2V(ip)

{

re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式

if(re.test(ip))

{

return

RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1 }

else

{

throw new Error("Not a valid IP address!")

}

}