C#编程（四十六）----------正则表达式

正则表达式

1.定义一个Regex类的实例

Regex regex=new Regex(“”);

这里初始化参数就是一个正则表达式,”\d”表示配置数字

2.判断是否匹配

判断一个字符串,是否匹配一个正则表达式,在Regex对象中,可以使用Regex.IsMatch(string )方法.

Regex regex = new Regex(@"\d");

bool b1=regex.IsMatch("abc"); //返回值为false，字符串中未包含数字

bool b2 = regex.IsMatch("abc3abc"); //返回值为true，因为字符串中包含了数字

3.获取匹配次数

使用Regex.Matches(string)方法得到一个Matched集合,再使用这个集合的Count属性.

int count=regex.Matches(“abc123abc”).Count;

count的值为3,因为匹配了三次数字

4.获取匹配内容

使用regex.Match(string)方法进行匹配

Regex regex = new Regex(@"\d");

string str=regex.Match("abc123abc").Value;

Console.WriteLine(str);

返回值为1,表示第一个匹配到的值

5.捕获

正则表达式中可以使用括号对部分值进行捕获,想要获取捕获的值,可以使用Regex.Match(string).Groups[int].Value来获取.

Regex regex = new Regex(@"\w2(\d*)"); //匹配两个字母间的数字串

string str=regex.Match("abc123abc").Groups[0].Value; //返回值为“123”

Console.WriteLine(str);

一.C#正则表达式符号模式

说明:由于在正则表达式中“ \ ”、“ ? ”、“ * ”、“ ^ ”、“ $ ”、“ + ”、“（”、“）”、“ | ”、“ { ”、“ [ ”等字符已经具有一定特殊意义,如果需要用他们的原始意义,则应该对它进行转义,例如希望在字符串中至少有一个”\”,那么正则表达式应该这么说:\\+.

一.在C#中,要使用正则表达式,请在源文件开头处添加以下语句:

using System.Text.RegularExpressions

二.Regex类常用的方法

1.静态的Match方法

使用静态Match方,可以得到源中第一个匹配模式的连续子串.

静态的Match方法有两个重载,分别是:

Regex.Match(string input,string pattren);

Regex.Match(string input,string pattren ,RegexOptions options);

第一种重载的参数表示:输入,模式

第二种重载的参数表示:输入,模式,RegexOptions枚举的”按位或”组合.

RegexOptions枚举的有效值是：

Complied表示编译此模式

CultureInvariant表示不考虑文化背景

ECMAScript表示符合ECMAScript，这个值只能和IgnoreCase、Multiline、Complied连用

ExplicitCapture表示只保存显式命名的组

IgnoreCase表示不区分输入的大小写

IgnorePatternWhitespace表示去掉模式中的非转义空白，并启用由#标记的注释

Multiline表示多行模式，改变元字符^和$的含义，它们可以匹配行的开头和结尾

None表示无设置，此枚举项没有意义

RightToLeft表示从右向左扫描、匹配，这时，静态的Match方法返回从右向左的第一个匹配

Singleline表示单行模式，改变元字符.的意义，它可以匹配换行符

注意：Multiline在没有ECMAScript的情况下，可以和Singleline连用。Singleline和Multiline不互斥，但是和ECMAScript互斥

2.静态的Matches方法

这个方法的重载形式同静态的Match方法,返回一个MatchCollection,表示输入中,匹配模式的匹配的集合.

3.静态的IsMatch()方法

此方法返回一个bool,重载形式同静态的Matches,若输入中匹配模式,返回true,否则返回false.可以理解为:IsMatch方法,返回Matches方法返回的集合是否为空.

四.Regex类的实例

1.字符串替换

例如我想把如下格式记录中的NAME值修改为WANG

string line="ADDR=1234;NAME=ZHANG;PHONE=123456";

Regex reg=new Regex("NAME=(.+);");

string modified=reg.Replace(line,"NAME=WANG;");

Console.WriteLine(modified);

分析:修改后的字符串为ADDR=1234;NAME=WANG;PHONE=123456

2.字符串匹配

例如我想提取刚才那条记录中的NAME值.

string line="ADDR=1234;NAME=ZHANG;PHONE=123456";

Regex reg=new Regex("NAME=(.+);");

Match match = reg.Match(line);

string value = match.Groups[1].Value;

Console.WriteLine(value);

3.Match实例:文本中含有"speed=30.2mph",需要提取该速度值，但是速度的单位可能是公制也可能是英制，mph,km/h,m/s都有可能；另外前后可能有空格。

string line = "lane=1;speed=30.3mph;acceleration=2.5mph/s";

Regex reg = new Regex(@"speed\s*=\s*([\d\.]+)\s*(mph|km/h|m/s)*");

Match match = reg.Match(line);

string value = match.Groups[1].Value;//数值

Console.WriteLine(value);

Console.WriteLine(match.Groups[2].Value);//单位

4.案例:解码gps的GPRMC字符串

Regex reg = new Regex(@"^\$GPRMC,[\d\.]*,[A|V],(-?[0-9]*\.?[0-9]+),([NS]*),(-?[0-9]*\.?[0-9]+),([EW]*),.*");

分析:以前需要几十行代码的工作,现在一行就完成了.

五.System.Text.RegularExpressions命名空间的说明

该命名空间包括8个类,1个枚举,1以委托.他们分别是:

Capture: 包含一次匹配的结果； CaptureCollection: Capture的序列； Group: 一次组记录的结果，由Capture继承而来； GroupCollection：表示捕获组的集合 Match: 一次表达式的匹配结果，由Group继承而来； MatchCollection: Match的一个序列； MatchEvaluator: 执行替换操作时使用的委托； Regex：编译后的表达式的实例。 RegexCompilationInfo：提供编译器用于将正则表达式编译为独立程序集的信息 RegexOptions 提供用于设置正则表达式的枚举值 Regex类中还包含一些静态的方法： Escape: 对字符串中的regex中的转义符进行转义； IsMatch: 如果表达式在字符串中匹配，该方法返回一个布尔值； Match: 返回Match的实例； Matches: 返回一系列的Match的方法； Replace: 用替换字符串替换匹配的表达式； Split: 返回一系列由表达式决定的字符串； Unescape:不对字符串中的转义字符转义。

(1)”@”符号

“@”符号表示,跟在它后面的字符串是个”逐字字符串”,举例,一下两个声明是等效的:

string x=”c:\\syx\\haha”

string [email protected]”c:\syx\haha”

事实上如果按照如下声明:

string y=”c:\syx\haha”,C#会报错,因为”\”在C#中用于实现转移,如”\n”表示换行.

(2)基本的语法字符


字符
含义

\d
0-9的数字

\D
\d的补集(以所有字符为全集,下同),即所有的非数字的字符

\w
单词字符,指大小写字母,0-9的数字,下划线

\W
\w的补集

\s
空白字符,包括换行符\n,回车符\r,制表符\t,垂直制表符\v,换页符\f

\S
\s的补集

[...]
匹配[]内所列出的所有字符

[^...]
匹配非[]内所列出的所有字符

.
除换行符\n以外的任意字符

案例:

string i = "\n";

string m = "3";

Regex r = new Regex(@"\D");//同Regex r = new Regex("\\D");

Console.WriteLine(r.IsMatch(i));//输出true

Console.WriteLine(r.IsMatch(m));//输出false

案例:

string i = "%";

string m = "3";

//匹配小写字母或数字字符

Regex r = new Regex("[a-z0-9]");

Console.WriteLine(r.IsMatch(i));//输出false

Console.WriteLine(r.IsMatch(m));//输出true

(3)定位字符:

“定位字符”所代表的是一个虚的字符,它代表一个位置,你可以直观的认为”定位字符”所代表的hi某个字符与自附件的那个微小间隙.


定位字符
含义

^
表示其后的字符必须位于字符串的开始处

$
表示其前面的字符必须位于字符串的结尾处

\b
匹配一个单词的边界

\B
匹配一个非单词的边界

\A
前面的字符必须位于字符处的开始出

\z
前面的字符必须位于字符串的结尾处

\Z
前面的字符必须位于字符串的结尾处,或者位于换行符前

案例:

string i = "Live for nothing,die for something";

Regex r1 = new Regex("^Live for nothing,die for something$");

//r1.IsMatch(i) true

Regex r2 = new Regex("^Live for nothing,die for some$");

//r2.IsMatch(i) false

Regex r3 = new Regex("^Live for nothing,die for some");

//r3.IsMatch(i) true

案例:

string i = @"Live for nothing,

die for something";//多行

Regex r1 = new Regex("^Live for nothing,die for something$");

Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0

Regex r2 = new Regex("^Live for nothing,die for something$", RegexOptions.Multiline);

Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//0

Regex r3 = new Regex("^Live for nothing,\r\ndie for something$");

Console.WriteLine("r3 match count:" + r3.Matches(i).Count);//1

Regex r4 = new Regex("^Live for nothing,$");

Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//0

Regex r5 = new Regex("^Live for nothing,$", RegexOptions.Multiline);

Console.WriteLine("r5 match count:" + r5.Matches(i).Count);//0

Regex r6 = new Regex("^Live for nothing,\r\n$");

Console.WriteLine("r6 match count:" + r6.Matches(i).Count);//0

Regex r7 = new Regex("^Live for nothing,\r\n$", RegexOptions.Multiline);

Console.WriteLine("r7 match count:" + r7.Matches(i).Count);//0

Regex r8 = new Regex("^Live for nothing,\r$");

Console.WriteLine("r8 match count:" + r8.Matches(i).Count);//0

Regex r9 = new Regex("^Live for nothing,\r$", RegexOptions.Multiline);

Console.WriteLine("r9 match count:" + r9.Matches(i).Count);//1

Regex r10 = new Regex("^die for something$");

Console.WriteLine("r10 match count:" + r10.Matches(i).Count);//0

Regex r11 = new Regex("^die for something$", RegexOptions.Multiline);

Console.WriteLine("r11 match count:" + r11.Matches(i).Count);//1

Regex r12 = new Regex("^");

Console.WriteLine("r12 match count:" + r12.Matches(i).Count);//1

Regex r13 = new Regex("$");

Console.WriteLine("r13 match count:" + r13.Matches(i).Count);//1

Regex r14 = new Regex("^", RegexOptions.Multiline);

Console.WriteLine("r14 match count:" + r14.Matches(i).Count);//2

Regex r15 = new Regex("$", RegexOptions.Multiline);

Console.WriteLine("r15 match count:" + r15.Matches(i).Count);//2

Regex r16 = new Regex("^Live for nothing,\r$\n^die for something$", RegexOptions.Multiline);

Console.WriteLine("r16 match count:" + r16.Matches(i).Count);//1

对于一个多行字符串,在设置了Multiline选项之后,^和$将出现多次匹配.

案例:

string i = "Live for nothing,die for something";

string m = "Live for nothing,die for some thing";

Regex r1 = new Regex(@"\bthing\b");

Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0

Regex r2 = new Regex(@"thing\b");

Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//2

Regex r3 = new Regex(@"\bthing\b");

Console.WriteLine("r3 match count:" + r3.Matches(m).Count);//1

Regex r4 = new Regex(@"\bfor something\b");

Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//1

\b通常用于约束一个完整的单词

(4)重复描述符

“重复描述符”是体现C#正则表达式”很好很强大”的地方之一


重复描述符
含义

{n}
匹配前面的字符n次

{n,}
匹配前面的字符n次或多余n次

{n,m}
匹配前面的字符n到m次

?
匹配前面的字符0或者1次

+
匹配前面的字符1次或多于1次

*
匹配前面的字符0次或多于0次

案例:匹配1000到9999的整数

string x = "1024";

string y = "+1024";

string z = "1,024";

string a = "1";

string b = "-1024";

string c = "10000";

Regex r = new Regex(@"^\+?[1-9],?\d{3}$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//1

Console.WriteLine("z match count:" + r.Matches(z).Count);//1

Console.WriteLine("a match count:" + r.Matches(a).Count);//0

Console.WriteLine("b match count:" + r.Matches(b).Count);//0

Console.WriteLine("c match count:" + r.Matches(c).Count);//0

(5)择一匹配

C#正则表达式中的(|)符号似乎没有一个专门的称为,姑且称之为”择一匹配”吧.事实上,像[a-z]也是一种择一匹配,只不过它只能匹配单个字符,而(|)则提供了更大的范围,(ab|xy)表示匹配ab或匹配xy.注意”|”与”()”在此是一个整体.

案例:匹配0到100的整数.最外层的括号包含两部分”(100(.0+)*)” , “([1-9]?[0-9])(\.\d+)*”,这两部分是”OR”的关系,即正则表达式引擎会现场时匹配100,如果失败,则尝试匹配后一个表达式(表示[0,100)范围中的数字)

string x = "0";

string y = "0.23";

string z = "100";

string a = "100.01";

string b = "9.9";

string c = "99.9";

string d = "99.";

string e = "00.1";

Regex r = new Regex(@"^\+?((100(.0+)*)|([1-9]?[0-9])(\.\d+)*)$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//1

Console.WriteLine("z match count:" + r.Matches(z).Count);//1

Console.WriteLine("a match count:" + r.Matches(a).Count);//0

Console.WriteLine("b match count:" + r.Matches(b).Count);//1

Console.WriteLine("c match count:" + r.Matches(c).Count);//1

Console.WriteLine("d match count:" + r.Matches(d).Count);//0

Console.WriteLine("e match count:" + r.Matches(e).Count);//0

(6)特殊字符的匹配

案例:匹配“\”

string x = "\\";

Regex r1 = new Regex("^\\\\$");

Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1

Regex r2 = new Regex(@"^\\$");

Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1

Regex r3 = new Regex("^\\$");

Console.WriteLine("r3 match count:" + r3.Matches(x).Count);//0

案例:匹配双引号

string x = "\"";

Regex r1 = new Regex("^\"$");

Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1

Regex r2 = new Regex(@"^""$");

Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1

(7)组与非捕获组

案例:

//正则表达式引擎会记忆“()”中匹配到的内容，作为一个“组”，并且可以通过索引的方式进行引用。表达式中的“\1”，用于反向引用表达式中出现的第一个组，即粗体标识的第一个括号内容，“\2”则依此类推。

string x = "Live for nothing,die for something";

string y = "Live for nothing,die for somebody";

Regex r = new Regex(@"^Live ([a-z]{3}) no([a-z]{5}),die \1 some\2$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//0

案例:            //获取组中的内容。注意，此处是Groups[1]，因为Groups[0]是整个匹配的字符串，即整个变量x的内容。

string x = "Live for nothing,die for something";

Regex r = new Regex(@"^Live for no([a-z]{5}),die for some\1$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//输出：thing

}

案例:            //可根据组名进行索引。使用以下格式为标识一个组的名称(?<groupname>…)。

string x = "Live for nothing,die for something";

Regex r = new Regex(@"^Live for no(?<g1>[a-z]{5}),die for some\1$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups["g1"].Value);//输出：thing

}

案例:            //删除原字符串中重复出现的“nothing”。在表达式之外，使用“$1”来引用第一个组，下面则是通过组名来引用：

string x = "Live for nothing nothing";

Regex r = new Regex(@"([a-z]+) \1");

if (r.IsMatch(x))

{

x = r.Replace(x, "$1");

Console.WriteLine("var x:" + x);//输出：Live for nothing

}

案例://在组前加上“?:”表示这是个“非捕获组”，即引擎将不保存该组的内容。

string x = "Live for nothing nothing";

Regex r = new Regex(@"(?<g1>[a-z]+) \1");

if (r.IsMatch(x))

{

x = r.Replace(x, "${g1}");

Console.WriteLine("var x:" + x);//输出：Live for nothing

}

string x = "Live for nothing";

Regex r = new Regex(@"^Live for no(?:[a-z]{5})$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//输出：(空)

}

(8)贪婪与非贪婪

正则的引擎是贪婪,只要模式允许,它将匹配尽可能多的字符.通过在”重复描述符”(+,*)后面添加”?”,可以将匹配模式改成非贪婪.实例:

string x = "Live for nothing,die for something";

Regex r1 = new Regex(@".*thing");

if (r1.IsMatch(x))

{

Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,die for something

}

Regex r2 = new Regex(@".*?thing");

if (r2.IsMatch(x))

{

Console.WriteLine("match:" + r2.Match(x).Value);//输出：Live for nothing

}

(9)回溯与非回溯

使用”(?>...)”方式进行非回溯声明.由于正则表达式引擎的贪婪特性,导致他在某些情况下,将进行回溯以获得匹配,实例:

//在r1中，“.*”由于其贪婪特性，将一直匹配到字符串的最后，随后匹配“thing”，但在匹配“,”时失败，此时引擎将回溯，并在“thing,”处匹配成功。

string x = "Live for nothing,die for something";

Regex r1 = new Regex(@".*thing,");

if (r1.IsMatch(x))

{

Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,

}

Regex r2 = new Regex(@"(?>.*)thing,");

if (r2.IsMatch(x))//不匹配

{

Console.WriteLine("match:" + r2.Match(x).Value);

}

分析:由于强制非回溯,所以整个表达式匹配失败.

(10)正向预搜索,反向预搜索

正向预搜索声明格式:正声明”(?=...)”,负声明”(?!...)”,声明本身不作为最终匹配结果的一部分,示例如下:

//r1中的正声明表示必须保证在四位数字的后面必须紧跟着“ used”，r2中的负声明表示四位数字之后不能跟有“ used”。

string x = "1024 used 2048 free";

Regex r1 = new Regex(@"\d{4}(?= used)");

if (r1.Matches(x).Count == 1)

{

Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024

}

Regex r2 = new Regex(@"\d{4}(?! used)");

if (r2.Matches(x).Count == 1)

{

Console.WriteLine("r2 match:" + r2.Match(x).Value); //输出：2048

}

反向预搜索声明格式：正声明“(?<=)”，负声明“(?<!)”，声明本身不作为最终匹配结果的一部分，请看下面的示例：

//r1中的反向正声明表示在4位数字之前必须紧跟着“used:”，r2中的反向负声明表示在4位数字之前必须紧跟着除“used:”之外的字符串。

string x = "used:1024 free:2048";

Regex r1 = new Regex(@"(?<=used:)\d{4}");

if (r1.Matches(x).Count == 1)

{

Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024

}

Regex r2 = new Regex(@"(?<!used:)\d{4}");

if (r2.Matches(x).Count == 1)

{

Console.WriteLine("r2 match:" + r2.Match(x).Value);//输出：2048

}

(11)十六进制字符范围

正则表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）形式字符范围：

\xXX       编号在 0到255 范围的字符，比如：空格可以使用 "\x20" 表示。

\uXXXX   任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，比如：汉字可以使用“[\u4e00-\u9fa5]”表示。

(12)对[0,100]的比较完备的匹配

案例:

下面是一个比较综合的示例，对于匹配[0,100]，需要特殊考虑的地方包括

*00合法，00.合法，00.00合法，001.100合法

*空字符串不合法，仅小数点不合法，大于100不合法

*数值是可带后缀的，如“1.07f”表示该值为一个float类型（未考虑）

Regex r = new Regex(@"^\+?0*(?:100(\.0*)?|(\d{0,2}(?=\.\d)|\d{1,2}(?=($|\.$)))(\.\d*)?)$");

string x = "";

while (true)

{

x = Console.ReadLine();

if (x != "exit")

{

if (r.IsMatch(x))

{

Console.WriteLine(x + " succeed!");

}

else

{

Console.WriteLine(x + " failed!");

}

}

else

{

break;

}

}

（13）精确匹配有时候是困难的

有些需求要做到精确匹配比较困难，例如：日期、Url、Email地址等，其中一些你甚至需要研究一些专门的文档写出精确完备的表达式，对于这种情况，只能退而求其次，保证比较精确的匹配。例如对于日期，可以基于应用系统的实际情况考虑一段较短的时间，或者对于像Email的匹配，可以只考虑最常见的形式。

时间： 2024-11-03 01:50:06

C#编程（四十六）----------正则表达式的相关文章

C#高级编程四十六天----正则表达式

正则表达式 1.定义一个Regex类的实例 Regex regex=new Regex(""); 这里初始化参数就是一个正则表达式,"\d"表示配置数字 2.判断是否匹配 判断一个字符串,是否匹配一个正则表达式,在Regex对象中,可以使用Regex.IsMatch(string )方法. Regex regex = new Regex(@"\d"); bool b1=regex.IsMatch("abc"); //返回值为f

ActionScript3游戏中的图像编程（连载四十六）

总目录:http://blog.csdn.net/iloveas2014/article/details/38304477 3.1.2 以小见大--从细节损失洞悉滤镜本质 把它再改回内斜角,边缘似乎光滑了些,但这种错觉仅仅是由于阴影与蓝色的对比度不够强烈,才会让边缘的粗糙不够显眼.把文字颜色调成浅紫以后,转角处的锯齿依旧一览无余.(图 3.6),而Photoshop应用同样的设置则不会出现同样的问题(图 3.7). 图 3.6 模糊值为3的内侧斜角滤镜 图 3.7 大小等于3的斜面样式 如果认为

QT开发（四十六）——QT数据库编程基础

QT开发(四十六)--QT数据库编程基础 一.Qt SQL模块简介 1.Qt SQL模块简介 QT通过Qt SQL模块提供了对SQL数据库的支持,Qt SQL模块中的API分为三层:驱动层.SQL接口层.用户接口层. 如果要使用Qt SQL模块中的类,需要在工程文件(.pro文件)中添加QT += sql代码. 2.驱动层 驱动层为具体的数据库和SQL接口层之间提供了底层的桥梁,主要类包括Qt SQL模块中的QSqlDriver.QSqlDriverCreator.QSqlDriverCreat

“全栈2019”Java多线程第四十六章：判断任意线程是否已持有写锁

难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多线程第四十六章:判断任意线程是否已持有写锁 下一章 "全栈2019"Java多线程第四十七章:判断锁是否为公平锁isFair() 学习小组 加入同步学习小组,共同交流与进步. 方式一:加入编程圈子. 方式二:关注头条号Gorhaf,私信"Java学习小组". 方式三:关

NeHe OpenGL教程 第四十六课：全屏反走样

转自[翻译]NeHe OpenGL 教程 前言 声明,此 NeHe OpenGL教程系列文章由51博客yarin翻译(2010-08-19),本博客为转载并稍加整理与修改.对NeHe的OpenGL管线教程的编写,以及yarn的翻译整理表示感谢. NeHe OpenGL第四十六课:全屏反走样 全屏反走样 当今显卡的强大功能,你几乎什么都不用做,只需要在创建窗口的时候该一个数据.看看吧,驱动程序为你做完了一切. 在图形的绘制中,直线的走样是非常影响美观的,我们可以使用反走样解决这个问题.在众多的解决

四十六、android中的Bitmap

四十六.android中的Bitmap: http://www.cnblogs.com/linjiqin/archive/2011/12/28/2304940.html 四十七.实现调用Android手机的拍照功能: http://www.cnblogs.com/linjiqin/archive/2011/12/28/2304970.html

【Unity 3D】学习笔记四十六：输入与控制——键盘事件

在游戏中,玩家控制主角移动,按键攻击,选择行走.都需要在程序中监听玩家的输入.unity为开发者提供了input库,来支持键盘事件,鼠标事件以及触摸事件.本文主要回顾键盘事件,以后会逐文复习鼠标以及触摸事件. 键盘事件 一般的PC键盘有104个不同的按键,在程序中通过监听这些按键事件,从而进一步执行逻辑操作.如:射击游戏中,W表示前进,S表示后退,A表示左移,D表示右移. 按下事件 在脚本中,用input.GetKeyDown( )方法将按键值作为参数,监听此按键是否被按下.按下返回true,否

程序员的奋斗史（四十六）——大学断代史（十）——给学弟学妹们的忠告——终结篇

文/温国兵 「写在前面」 大学断代史终于要完结了,就像一条再长的路总有终点一样.该系列文章前前后后写了一两个月,也该收尾了,至于收尾的文章,想了想,决定写写自己对学弟学妹的忠告.本篇文章以话题的形式呈现. 「关于专业」 我相信大多数的读者在高考填志愿都不知道软件工程或者计算机专业是做啥的,稀里糊涂就踏上了这条IT不归路.身处小乡村,消息相对闭塞,能使用电脑都是奢侈的事情,这就是当初我高考后的境况,相信现在有很大的改变.如果你对IT行业抱有一番热情,恭喜你,选对了好专业,好好学,今后的路错不了.如

第四十六章

第四十六章1 马应该种田,不应该打仗:你应该工作,不应该总想买买买 天下有道,却走马以粪.天下无道,戎马生于郊. 天下有道的时候,马都在田里耕地,天下无道的时候,马都在战场打仗. 要放低欲望,把资源用在正地方. 各位朋友大家好,清晨起来,我们接着来讲<道德经>,看看老子老先生带给我们什么样人生启发.我在今天起床之前做梦,梦是让人黯然神伤的,我做梦梦见自己给一帮孩子妈妈,带着小朋友讲课,就讲这个“道”,结果妈妈不听,在下面聊天,孩子哭闹,乱作一团,大家说讲点感冒吧,讲“道”有什么用,我说“道”很

第四十六个知识点 在Sigma协议中，正确性，公正性和零知识性意味着什么

第四十六个知识点 在Sigma协议中,正确性,公正性和零知识性意味着什么 Sigma协议 Sigma协议是Alice想要向Bob证明一些东西的协议(Alice知道一些秘密).他们有下面的一般范式:Alice知道一个秘密,Alice和Bob都分享了一些相同的信息.因此: Alice给Bob发送了一个值,这个值叫做承诺(commitment). Bob均匀的随机选择一个挑战(challenge)发送给Alice. Alice计算一个回应(response)发送给Bob. Bob检查回应,接受或者拒绝