“以直代曲”的思想是利用直线段来近似曲线，也即通过某点的切线来代替曲线，这样使得有关曲线的问题转化到直线段上来，从而得到简化。

随机变量x的分布函数

A=0B=0.5 c=2 

 a=[-1,1,2;-2,3,1;4,0,9]

for i=1:size(a,2) 
    for j=1:size(a,2) 
        c(i,j)=sum((a(:,i)-mean(a(:,i))).*(a(:,j)-mean(a(:,j))))/(size(a,1)-1);
    end 
end

c =

   10.3333   -4.1667    3.0000

   -4.1667    2.3333   -1.5000

    3.0000   -1.5000    1.0000 

 c为求得的协方差矩阵，在matlab以矩阵a的每一列为变量，对应的每一行为样本。这样在矩阵a中就有3个列变量分别为a（:,1), a(:,2), a(:,3)。

 在协方差矩阵c中，每一个元素c(i,j)为对第i列与第j列的协方差，例如c(1,2) = -4.1667为第一列与第二列的协方差。

 

 拿c(1,2)的求解过程来说

 c(1,2)=sum((a(:,1)-mean(a(:,1))).*(a(:,2)-mean(a(:,2))))/(size(a,1)-1);

 1. a(:,1)-mean(a(:,1))，第一列的元素减去该列的均值得到

   -1.3333

   -2.3333

    3.6667

2,  a(:,2)-mean(a(:,2))，第二列的元素减去该列的均值得到

   -0.3333

    1.6667

   -1.3333

3, 再将第一步与第二部的结果相乘

   -1.3333        -0.3333           0.4444

   -2.3333  .*     1.6667  =     -3.8889

    3.6667         -1.3333          -4.8889

 

4, 再将结果求和/size(a,1)-1 得 -4.1667,该值即为c（1,2）的值。

 

再细看一下是不是与协方差公式：Cov(X,Y) = E{ [ (X-E(X) ] [ (Y-E(Y) ] } 过程基本一致呢，只是在第4步的时候matlab做了稍微的调整，自由度为n-1，减少了一行的样本值个数。

>> a=[-1,1,2;-2,3,1;4,0,9]

a =

    -1     1     2

    -2     3     1

     4     0     9

>> cov(a)

ans =

   10.3333   -4.1667   14.0000

   -4.1667    2.3333   -5.5000

   14.0000   -5.5000   19.0000

>> dim1=a(:,1)

dim1 =

    -1

    -2

     4

>> dim2=a(:,2)

dim2 =

     1

     3

     0

>> dim3=a(:,3)

dim3 =

     2

     1

     9

>> dim1-mean(dim1)

ans =

   -1.3333

   -2.3333

    3.6667

>> dim2-mean(dim2)

ans =

   -0.3333

    1.6667

   -1.3333

>> m=dim1-mean(dim1)

m =

   -1.3333

   -2.3333

    3.6667

>> m=dim2-mean(dim2)

m =

   -0.3333

    1.6667

   -1.3333

>> m=dim1-mean(dim1)

m =

   -1.3333

   -2.3333

    3.6667

>> n=dim2-mean(dim2)

n =

   -0.3333

    1.6667

   -1.3333

>> m.*n

ans =

    0.4444

   -3.8889

   -4.8889

>> size(a,1)

ans =

     3

>> sum(m.*n)

ans =

   -8.3333

>> ans/2

ans =

   -4.1667

本文来自网上，本人只是整理一下，放到这里以备查用。

1. 特殊变量与常数

2. 操作符与特殊字符

         3、基本数学函数

       4、基本矩阵和矩阵操作

    5.数值分析和傅立叶变换

 6.多项式与插值

           
 7.绘图函数

挂载好新硬盘后输入fdisk -l命令看当前磁盘信息

可以看到除了当前的第一块硬盘外还有一块sdb的第二块硬盘，然后用fdisk /dev/sdb 进行分区

进入fdisk命令，输入h可以看到该命令的帮助，按n进行分区

这里输入e即分为逻辑分区，按p即分为主分区，我们要将这块盘分为主分区即输入p

到这里输入该主分区为第几个主分区，由于是新盘我们输入1来分第一个主分区

First Cylinder是选择该分区的起始磁盘数，这里可自定义也可不做选择，默认是1，如无特殊需求强烈建议选择默认，也就是1来分区（直接按回车）

接下来是定义该分区的大小，如果按默认（按回车）即是使用全部可用存储额，也可以是用M或m单位结尾的数字(大写M是大B的意思，如果输入1M实际上是X8也就是8m的空间)，这里我们先分一个1G的空间，所以输入+1024m

之后输入w写入分区，等待结束皆可

再输入fdisk -l 可以看到我们刚才分的一个分区，之后用mkfs -t ext3 -c /dev/sdb1进行格式化，如有多个分区可把sdb1改成sdb2 sdb3...以此类推，具体可用fdisk -l看到每个分区的名字

上图蓝色部分是写硬盘卷标的，如不想要卷标可直接按回车，现在分区好了我们用mount 挂载一下该分区即可使用了，这里我把它挂载到mnt目录下，也可以自建一个目录挂载

来看一下分区大小是否和预定的一样，使用df -TH命令看一下当前挂载的分区和大小，看到我们刚分的分区了吧

如果想每次系统重启都能自动挂载该分区可修改/etc/fstab文件，在最后加一段 /dev/sdb1    /www    ext3    defaults 1 2 (格式说明：/dev/sdb1 代表哪个分区  ext3是该分区的格式 defaults 是挂载时所要设定的参数(只读，读写，启用quota等)，输入defaults包括的参数有(rw、dev、exec、auto、nouser、async) ，1是使用dump是否要记录，0是不要。 2是开机时检查的顺序，是boot系统文件就为1，其他文件系统都为2，如不要检查就为0)

Centos 

yum remove php  php-bcmath php-cli php-common  php-devel php-fpm    php-gd php-imap  php-ldap php-mbstring php-mcrypt php-mysql   php-odbc   php-pdo   php-pear  php-pecl-igbinary  php-xml php-xmlrpc

rpm -Uvh http://mirror.webtatic.com/yum/el6/latest.rpm

yum install php54w  php54w-bcmath php54w-cli php54w-common  php54w-devel php54w-fpm    php54w-gd php54w-imap  php54w-ldap php54w-mbstring php54w-mcrypt php54w-mysql   php54w-odbc   php54w-pdo   php54w-pear  php54w-pecl-igbinary  php54w-xml php54w-xmlrpc php54w-opcache php54w-intl php54w-pecl-memcache

yum remove php  php-bcmath php-cli php-common  php-devel php-fpm    php-gd php-imap  php-ldap php-mbstring php-mcrypt php-mysql   php-odbc   php-pdo   php-pear  php-pecl-igbinary  php-xml php-xmlrpc

rpm -Uvh http://mirror.webtatic.com/yum/el6/latest.rpm

yum install php55w  php55w-bcmath php55w-cli php55w-common  php55w-devel php55w-fpm    php55w-gd php55w-imap  php55w-ldap php55w-mbstring php55w-mcrypt php55w-mysql   php55w-odbc   php55w-pdo   php55w-pear  php55w-pecl-igbinary  php55w-xml php55w-xmlrpc php55w-opcache php55w-intl php55w-pecl-memcache

架构设计是一个非常大的话题，不管写几篇文章，接触到的始终只是冰山一角，更多的是实践中去体会。这篇文章主要介绍面向对象OO、面向方面AOP和面向服务SOA这三个要素在架构设计中的位置与作用。

架构设计有三个维度，或者说是我们在考虑架构时需要思考三个方向。

这三个维度分别为面向对象、面向方面、面向服务。

这三个维度可以看作是正交的，但不同维度会互相印证，互相支撑，整个架构的示意图如图所示。

图：架构三维度结构图

面向对象

面向对象技术最初是从面向对象的程序设计开始的，它的出现以上世纪60年代Simula语言为标志，并在Smalltalk语言的完善和标准化过程中得到更多的扩展和对以前思想的重新注解。

上世纪80年代中后期，面向对象程序设计逐渐成熟，被计算机界理解和接受，人们又开始进一步考虑面向对象的开发问题。直到现在，面向对象已经成为一种非常流行的编程方式，以及软件设计的架构。

面向对象提出有三个主要目标:重用性、灵活性和扩展性，强调对象的“抽象”、“封装”、“继承”和“多态”。它能让人们以更加接近于现实世界的方式来思考程序，这点可以说是面向对象最大的进步。

在OO思想的运用上，业界出现了很多好的经验与技巧，从而涌现出大量的设计模式，可以说面向对象是系统分析与设计时的一个很重要的方面。

面向方面

面向方面最初来源于hook技术，本质上就是满足扩展的需求，可以在程序中自由扩展功能。

面向方面不仅仅是一门编程技术，同样也是一种架构设计的思路。如果说OO是纵向地分析、切割整个系统，那么可以认为AOP是横向地对系统作切片。

简单地理解，OO与AOP分别从两个不同的角度给我们提供了分析系统的思路。面向方面可以弥补面向对象的缺陷，两种方式有机的结合在一起，可以更加有效地对系统进行分析。

我们认为OO是接近于人类认识自然的思维方式，但对于东方而言却并不一定是这样的。

当西方人看到一个复杂系统的时候，只会有一种思路，就是“分解”，将系统分解成一块一块，然后每个部分进行研究。

当东方人看到一个复杂系统的时候，更多地会关注系统中存在的关系，将系统作为一个有机的整体进行研究，这也是东方和西方在事物看法上存在的差异。

这两种思维方式都没有问题，如果结合起来分析问题，解决问题会更好。面向对象与面向方面也同样如此，都能对应到人类认识自然的思维方式上。

面向服务

面向服务可以说是最近炒得比较火热的概念。包括现在提到的SaaS（Software as a service），软件即服务。准确而言，面向服务不仅仅是软件行业的概念，这个要从社会的产业结构说起。

社会产业总共分为三个，第一产业农业，第二产业工业，第三产业服务业。最早社会的主要产业是第一产业农业，将近有几万年的历史。

十八世纪下半叶在英国开始的工业革命，对人们的生活产生了根本性的影响，社会的主要产业成了第二产业工业。

现在仍然属于工业时代，或者有人说的“后工业时代”。而在后工业时代，社会的经济体制必定要向第三产业服务业逐渐转型。面向服务其实是社会经济体制重心的一种迁移。

还是说回到软件行业，社会的主要产业将转变成服务业，自然软件行业也会出现对应的变化，那就是这里提到的面向服务。面向服务今后会影响到软件的交付模式，会对整个软件行业的体制产生影响。

而说到架构层面，面向服务是系统发布功能的一种方式。并且基于这种方式下不同的系统之间能有效地通信、协作。常见的实现技术就是Web Service。

软件全局观

软件架构设计的三个维度：面向对象、面向方面、面向服务。

最年长的一个维度就是面向对象，发展了好几十年，也是相对而言比较成熟的一个维度。它解决的问题是系统内部结构的设计。

面向方面思想的提出能够弥补面向对象的缺陷。面向对象的方式不能实现横切关注点的分离，而面向方面正是为了解决这个问题。面向方面与面向对象一样都是解决系统内部结构的设计。

面向服务更多的是涉及到系统的外部，简单地说就是发布功能。它并不关注系统内部结构的实现，所以说面向服务与面向对象或者面向方面并不冲突。

这三个维度并不是绝对孤立的，它们之间会互相影响、制约，相互发展的。我们在分析架构的时候需要同时考虑到这三个维度的问题，这样有助于我们设计出更加优秀的架构。

十几年软件研发的沧桑岁月，和一度险濒于破产的痛苦经历，让俺对软件产品开发有了更深层的体会。新年到来之际，写出来和大家作个交流。

一、农业境界

　　刚参加工作，朋友问我，你能用电脑干啥？我口出狂言，只要你想得出来的，我都能做得到。其实，我说这话相当无知。

　　柏拉图曾经说过，人的知识犹如一个圆，圆内是你已经知道的，圆外是你还不知道的，圆周就是你已经知道的还没解决的问题。你的知识越丰富，这个圆就越大，圆的周长也越长，也就是你知道的没解决的问题也越多。

　　如果你觉得自己没有啥问题，就说明你很无知。

　　无数年轻人就是凭自己的热情，初生牛犊不怕虎的冲劲，在完全没有经验和章法的情况下，投入了不会取得胜利的第一场战斗。通俗一点讲，就是试图用垒狗窝的技术建高楼大厦。

　　企业在这个阶段，充其量就是个手工作坊。有人说，我的研发团队上百号人呢。对不起，您是否出于这个阶段和企业人数没多大关系。

二、工业境界

　　了解到软件产品设计研发是一个复杂的系统工程，很多人会尝试运用一些必要的技术把复杂系统分解成简单子系统。在这个阶段，一些软件工程理论开始逐步被吸收。这包括：

　　面向对象的设计思想

　　UML、RUP、XP编程、设计模式等软件工程理论和工具

　　组件化系统设计——COM、DCOM、ActiveX、Corba、WebServices等技术开始进入产品设计

　　简单地讲，已经知道如何把高楼大厦拆解成多个狗窝，化繁为简；已经懂得遵循软件工业标准开发能重用的系统组件。

　　很多人以为已经到达软件研发的终点，掌握了终极的技术手段。然而，这只是软件产品研发的启蒙阶段，随着发现更多并解决深层次的问题，你需要更有效的理论提升你对软件产品开发的驾驭能力。

三、数学境界

　　工业化境界提供了化繁为简的技术支撑和思路，但是，好的工具并不能保证出现正确的设计。

　　我们学习解一元二次方程的时候，什么十字相乘法、配方法等等，开始会学习很多技巧性的解法。这类似工业化境界——让你把复杂问题分解转化成更简单的问题。但是，这些技巧不总是有效，最终的解决方案还是推导出求解公式，彻底解决此类问题。

　　软件产品设计是否存在从需求到代码的求解公式呢？这是一个已经被研究半个世纪的课题了，可惜国内99%的软件研发人员并不了解这方面的进展。等到洋人的坚船利炮打到你家门口的时候，你才发现人家用这么好的技术武装自己，那就为时太晚了。

　　在这个阶段，你会用数学方法保障软件系统设计的正确性。你可能会把下面这些理论引入你的设计过程：

　　在系统设计中自觉运行有限状态机、Petri网等数学模型去设计、分析系统结构。

　　引进诸如净室技术、B方法、Z语言等形式化软件工程技术，确保系统设计的正确性。

　　最后你会发现，软件产品设计真正是一件严格科学过程，如果以山野村夫的心态做这件事情，最终必然一塌糊涂。

四、艺术境界

　　人本质上是非理性的动物，我们为人类设计产品的最终目标不是为了正确，因此，数学境界并未把你带到最终目的地。

　　人类还没解决温饱问题的时候，就学会了在岩石上涂鸦，在脖子上挂项链，为人类设计产品，得满足他们这些貌似毫无价值的癖好。

　　因此，在能熟练驾驭正确设计产品的技能之后，软件产品设计将为艺术而战——我们不是在替客户设计干活的工具，相反，我们是在为他们设计一个吸引眼球的超级玩具，一件艺术品。

　　软件产品设计师——你不仅仅是工程师，更进一步，你应该是一名驾驭高科技技术的艺术家！

五、宗教境界

　　阿克毛被枪毙了，他不是为科学而来，亦不是为艺术而来，而是为夺取我们的心灵而来！

　　之所以被枪毙，是因为他采取了文明社会不认可的手段和产品——海洛因。

　　异曲同工，软件产品设计的最高境界亦是征服客户的心灵，让客户像崇拜上帝一样被您的软件所征服。似乎除了海洛因，能做到这一点的就是宗教了。

　　看看IBM、看看微软、看看Intel、看看苹果，这些超级商业巨人，为了让你把口袋的钱老老实实地掏出来，是不是一个个俨然一副布道者的模样？

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/quicmous/archive/2010/01/03/5125373.aspx

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URLDecoder;
import java.util.StringTokenizer;

/*
用Java语言实现HTTP服务器,首先启动一个java.net.ServerSocket在提供服务的端口上监听连接.向客户返回文本时,可以用
PrintWriter,但是如果返回二进制数据,则必须使用OutputStream.write(byte[])方法,返回的应答消息字符串可以使用
String.getBytes()方法转换为字节数组返回,或者使用PrintStream的print()方法写入文本,用
write(byte[])方法写入二进制数据.

以工程所在目录为web的根目录。 在工程的根目录下放一个大概如下的index.html

<!DOCTYPE html PUBLIC "-//WDTD HTML  Transitional//EN"
 * "http://www.wg/TR/htmlose.dtd"> <html> <head> <meta
 * http-equiv="Content-Type" content="text/html; charset=gbk">
 * <title>简单的测试</title> </head> <body> 你好！这是一个 简单的web服务器。<br>
 * 这是一个图片！br>
 *
 * <form action="/index.html"> <img alt="" src="images/test.gif"><br>
 * 姓名：<input type="text" name="name" /><br>
 * 密码：<input type="password" name="pass"></input><br>
 * <input type="submit"/> </form> </body> </html>
 *
 * 放入图片位置： 工程根目录/images/test.gif <br>
 * 打开浏览器输入http://localhost/index.html 可以展示index.html
 *
 * @author guazi
 */
public class SimpleHttpServer implements Runnable {

    ServerSocket serverSocket;// 服务器Socket
    /**
     * 服务器监听端口, 默认为
     */
    public static int PORT = 81; // 标准HTTP端口

    /**
     * 开始服务器 Socket 线程.
     */
    public SimpleHttpServer() {
        try {
            serverSocket = new ServerSocket(PORT);
        } catch (Exception e) {
            System.out.println("无法启动HTTP服务器:" + e.getMessage());
        }
        if (serverSocket == null) {
            System.exit(0);
        }

        new Thread(this).start();
        System.out.println("HTTP服务器正在运行,端口:" + PORT);
    }

    /**
     * 运行服务器主线程, 监听客户端请求并返回响应.
     */
    public void run() {
        while (true) {
            try {
                Socket client = null;// 客户Socket
                client = serverSocket.accept();// 客户机(这里是 IE 等浏览器)已经连接到当前服务器
                if (client != null) {
                    System.out.println("连接到服务器的用户:" + client);
                    try {
                        // 第一阶段: 打开输入流
                        BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));

                        System.out.println("客户端发送的请求信息: ***************");
                        // 读取第一行, 请求地址
                        System.out.println("http协议头部信息：");

                        String line = in.readLine();
                        System.out.println("开始："+line+"结束");
                        String resource = line.substring(line.indexOf('/'), line.lastIndexOf('/') - 5);
                        // 获得请求的资源的地址
                        resource = URLDecoder.decode(resource, "gbk");// 反编码

                        String method = new StringTokenizer(line).nextElement().toString();// 获取请求方法, GET 或者 POST

                        // 读取浏览器发送过来的请求参数头部信息
                        while ((line = in.readLine()) != null) {
                            System.out.println(line);

                            if (line.equals("")) {
                                break;
                            }
                        }

                        System.out.println("http协议头部结束 ***************");
                        System.out.println("用户请求的资源是:" + resource);
                        System.out.println("请求的类型是: " + method);

                        String params = null;

                        if (resource.indexOf("?") > -1) {
                            params = resource.substring(resource.indexOf("?") + 1);
                            resource = resource.substring(0, resource.indexOf("?"));
                        }

                        // 显示 POST 表单提交的内容, 这个内容位于请求的主体部分
                        if ("POST".equalsIgnoreCase(method)) {
                            if (params != null) {
                                params += "&" + in.readLine();
                            } else {
                                params = in.readLine();
                            }
                        }

                        System.out.println("打印提交的数据：");
                        printParams(params);

                        // 读取资源并返回给客户端
                        fileReaderAndReturn(resource, client);
                        // 关闭客户端链接
                        client.close();
                        System.out.println("客户端返回完成！");
                    } catch (Exception e) {
                        System.out.println("HTTP服务器错误:" + e.getMessage());
                    }
                }

            } catch (Exception e) {
                System.out.println("HTTP服务器错误:" + e.getMessage());
            }
        }
    }

    /**
     * 读取一个文件的内容并返回给浏览器端.
     *
     * @param fileName
     *            文件名
     * @param socket
     *            客户端 socket.
     * @throws IOException
     */
    void fileReaderAndReturn(String fileName, Socket socket) throws IOException {
        if ("/".equals(fileName)) {// 设置欢迎页面，呵呵！
            fileName = "/index.html";
        }
        fileName = fileName.substring(1);
        PrintStream out = new PrintStream(socket.getOutputStream(), true);
        File fileToSend = new File(fileName);

        String fileEx = fileName.substring(fileName.indexOf(".") + 1);
        String contentType = null;
        // 设置返回的内容类型
        // 此处的类型与tomcat/conf/web.xml中配置的mime-mapping类型是一致的。测试之用，就写这么几个。
        if ("htmlhtmxml".indexOf(fileEx) > -1) {
            contentType = "text/html;charset=GBK";
        } else if ("jpegjpggifbpmpng".indexOf(fileEx) > -1) {
            contentType = "application/binary";
        }
        if (fileToSend.exists() && !fileToSend.isDirectory()) {
            // http 协议返回头
            out.println("HTTP/1.0 200 OK");// 返回应答消息,并结束应答
            out.println("Content-Type:" + contentType);
            out.println("Content-Length:" + fileToSend.length());// 返回内容字节数
            out.println();// 根据 HTTP 协议, 空行将结束头信息

            FileInputStream fis = null;
            try {
                fis = new FileInputStream(fileToSend);
            } catch (FileNotFoundException e) {
                out.println("<h1>404错误！</h1>" + e.getMessage());
            }
            byte data[];
            try {
                data = new byte[fis.available()];

                fis.read(data);
                out.write(data);
            } catch (IOException e) {
                out.println("<h1>500错误!</h1>" + e.getMessage());
                e.printStackTrace();
            } finally {
                out.close();
                try {
                    fis.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }
            }
        } else {
            out.println("<h1>404错误！</h1>" + "文件没有找到");
            out.close();

        }

    }

    void printParams(String params) throws IOException {
        if (params == null) {
            return;
        }
        String[] maps = params.split("&");
        for (String temp : maps) {
            String[] map = temp.split("=");
            System.out.println(map[0] + "==" + map[1]);
        }
    }

    /**
     * 启动 HTTP 服务器
     *
     * @param args
     */
    public static void main(String[] args) {
        try {
            if (args.length != 1) {
                System.out.println("这是一个简单的web服务器 ，端口是： 80.");
            } else if (args.length == 1) {
                PORT = Integer.parseInt(args[0]);
            }
        } catch (Exception ex) {
            System.err.println("服务器初始化错误" + ex.getMessage());
        }

        new SimpleHttpServer();

    }
}

再谈如何成为技术领袖

——技术不是充分条件

被访者：IBM软件集团两岸三地大中华区
总工程师  寇卫东

文/卢鸫翔

要想成为一名优秀的技术领袖，需要具备哪些方面的素质？我在IBM辅导很多年轻同事，如何才能帮助他们在职业生涯中成长为技术领军人物？是否只要拥有了过硬的技术本领，就能成为技术领袖？许多年轻的朋友技术拔尖，然而却觉得没有得到领导的赏识， 这又是什么原因呢？我常常都在思考这些问题。去年这个时候，我同读者朋友们分享了一些心得，我想结合自己多年的高校教育和IT从业经验，再同大家谈谈这一话题。

1.我很清楚地告诉大家，要成为技术领袖，技术是必要条件，但不是充分条件。如果一个人技术基础不够扎实，他几乎等同外行，领导其他技术人员不说没有可能，但至少会相当困难。另一方面我们在国内外都能看到不少拔尖的技术人员，有的是一流的科学家，有的是一流的技术专才，可一旦把他们放在领导岗位上，却都以失败告终。他们虽然技术出色，但是没有当领袖的能力，工作中四处碰壁，缺乏凝聚力，不得人心。

2.要成为技术领袖就要清楚公司的业务，知道技术应当如何配合业务需求。作为技术领袖，只有做到这点，才能使公司业务有大的发展，才会得到高层领导的认同。如果你只懂技术而不懂公司业务，或者你在大学工作而不懂领导教学科研，是没有办法胜任技术领袖的。我们钻研技术的朋友往往忽略了这一点，对某项技术非常专注，但是两耳不闻窗外事，没有把注意力放到公司的发展需求上来。

为了更好地协调个人职业发展与企业业务发展，需要处理好工作的优先级，分清主次。在日常工作当中，我常常为同事画下面这幅图，帮助他们进行分析。

如果有一项工作摆在面前，我们如何定义它的重要性，应该花多少力气去做？我们可以通过象限分析找出答案。第I象限表示此项工作对企业业务发展和个人职业发展都很重要，这是最完美的结合，优先级应该放在最高级。我们在企业中应该多做此类工作。第II象限表示此项工作对企业业务非常重要，但是对个人目前的职业发展看似并不特别重要。我们要以企业的利益为重，所以优先级应该放在第二位。第III象限表示此项工作对个人职业发展很重要，但是对企业业务发展不那么重要，我们应该把它放在第三位。第IV象限表示此项工作对企业业务发展和个人职业发展都不重要，优先级应该是最低的。对这类工作，自己最好不做或者少做；就是做，也应该尽可能少花时间去做；或是请其他同事去做，因为对你的个人职业发展不重要的工作不等于对其他同事的个人职业发展也不重要，换言之，此项工作可能对其他同事的个人职业发展很重要呢。

许多企业都在创造一种文化，希望能将企业业务发展和员工的个人职业发展紧密结合起来，尽管有时候很难兼顾。作为一名领袖人物，他一定更多地在关注大局，而不是仅仅看到自己。关注大局的人会处处从公司的业务、公司的需求出发。在实际工作中我们常常可以看到，一个真正把大局放在第一位的人，即便今天不是领袖，明天也一定非他莫属。现在的领导不欣赏，将来必会为其他领导所赏识。

3.一个能把握大局的人需要具备很多能力，其中非常重要的一项就是我下面要谈到的第三点——决策力。作为技术领袖，要有坚强的领导能力，敢于面对各种困难的挑战，敢于决断。有些人天生就有准确的决策能力，而更多人需要靠后天来培养。

在我的孩子还小的时候，我就给他灌输这种思想，培养锻炼他。如果他要问我，我就让他自己做决定，不论决定是对是错、是好是坏，在我看来都是正确的。因为最大的错误是该做决定时你举棋不定。再举一个例子，美国前总统布什刚刚上任的时候，很多人批评他没有总统的风范，但是经过几年的洗礼他的确拥有了总统的气质。原因又是什么呢？因为那个职位训练了他，很多情况他必须要做出决策。

对于程序员来说，虽然无法像领导那样做重大的决定，但仍然可以在自己的范围内做出决策。例如使用什么样的技术手段， 采用何种算法实现， 选择哪种数据结构，如何撰写文档，同谁一起合作，这些并不一定非要等老板或者构架师来判断。大家应该有意识地锻炼自己，慢慢成长，直到将来能够领导大的项目。每个人不可能一开始就能对一个完整的系统做出决策，可是如果不从当程序员的时候就开始锻炼自己，将来也做不了。

面对决策失败可能带来的后果，我们应该学会坦然面对，学会承担。如果不去做决策，不愿承担责任，就永远无法取得进步，无法获得做技术领袖的能力。

4.要想成为技术领袖必须有远见，有智慧。有远见有智慧的人才能有承担。我有一个在加拿大的同事，开始的时候只是一般的技术人员，很短的时间内就变成经理，再后来没有经过多长时间又被提升为主管。原因很简单：他有远见，并且有足够的智慧知道应该如何去做。像他这样的员工虽然刚开始的职位很低，但是公司领导觉得这样的人才对公司将来的发展大有帮助，另外，如果这样的员工离职，不但是公司的损失，还会助长竞争对手的实力。所以公司一旦有职位就会提升这样的员工。我们作为技术人员也是一样的道理，面对一套大的系统方案，只有穿透障碍看到未来，才有机会获得提升，成为技术领袖。

5.成为技术领袖需要自信、自觉和自律。自信，这和领导能力有关，没自信怎么来领导别人呢？自觉包含两个方面的内容：自我感知和自我解嘲。自我感知是要对自己有一个正确的评价，“人贵有自知之明”——我们老祖宗都这样讲。有些人不知道自己的情况，要么估计过低，要么估计过高，对自己没有一个公正的评价。很多事情要靠下意识的感觉，你可能并不知道具体发生了什么事情，但是凭感觉就能判断出对错。自嘲是能给自己台阶下，这很重要，往往很多人都做不到，一不小心就陷入骑虎难下的境地。另外对自己有一个正确的评价，才不会弄得自己下不来台。

自律就是要约束自己，保持良好的品行。自律不是做给别人看，也不是做给领导看，而是为自己而做。每个人心中都应该有把标尺，衡量什么事情该做，什么事情不该做。自律很关键，年轻人尤其应该加以重视。有好的人品才会得到大家信任，如果不自律，没有良好的品行，有谁会对他心悦诚服，又怎样来做大家的榜样呢？

6.勇于承担，敢于付出。也就是说一个人的工作既不是为了金钱，也不是为了名誉，单单只是为了实现自己人生的价值，获得成功。自己驱动自己，不畏艰难险阻，不达目的誓不罢休。不愿意承担，不愿意付出，处处计较得失的人是没有办法成为领袖的。

这里所说的成功，并非单纯的职位上的成功，还包括技术上的成功，做人的成功等。其中做人的成功最重要，往往却被最多的人所忽视。职位只不过是领导给的一个头衔，技术领袖所具有的影响力并不是单单靠领导所给的头衔就能获得的。不管大公司小公司，很重要的一点就是先做人。我认为衡量一个人是否成功，首先看做人，然后看技术，最后才是职位、名誉、金钱。而且往往人和技术做好了，金钱名誉就会随之而来。正如诺贝尔奖得主们无一人不是勤勤恳恳做事，假使一开始就想着名誉、奖金，或许他们永远都无法取得举世瞩目的成就。

成功是一个很宽泛的概念，如何衡量成功是因人而异的。一般来说，成功是一个正态分布的频谱，不是一个单脉冲。有些人拥有很高的职位、很丰厚的收入，但却没有家庭、没有生活，因为他们把所有心思都放在了工作上，最终获得了事业上的成功，一个脉冲式的成功。相对他们的度量标准来说是成功了，然而对另一些人来说，他们并不成功、或者不值得效仿。因为事业成功只是一方面，除了工作，我们还有生活，还有家庭的维系、子女的教育、八小时后的个人爱好。一个和谐的成功是一个频谱式的成功：也许没有哪一方面是特别突出的，但是有几个方面是相当好的，其他方面也还可以，这样综合来看是最好的。

7.能领会别人的感觉和想法，会与他人相处。一个拥有领袖潜质的人，往往能够很快感知周围的氛围，别人的感受，他能够通过简单的语言、位置调整，使大家轻松舒服地投入工作。

8.能把大家团结起来，人气旺。很多时候，某个人并不是领导，但是大家都愿意听他的话，成了无冕之王，这样的人即便现在不是，将来也必然会成为领袖，这只是时间的问题。

读者朋友们大多都是技术人员，但是大家不要被技术所束缚。我年轻的时候也走过弯路，希望这些心得体会能对年轻的朋友们有所帮助。成为技术领袖并非遥不可及，只需要比别人多付出一点坚定和执著，多注重先做人后做事。

 // TODO: Add your message handler code here and/or call default
 /*HDC hdc;
 hdc=::GetDC(m_hWnd);
 MoveToEx(hdc,m_ptOrigin.x,m_ptOrigin.y,NULL);
 LineTo(hdc,point.x,point.y);
 ::ReleaseDC(m_hWnd,hdc);*/
 /*CDC *pDC=GetDC();
 pDC->MoveTo(m_ptOrigin);
 pDC->LineTo(point);
 ReleaseDC(pDC);*/

 //CClientDC dc(this);
 /*CClientDC dc(GetParent());
 dc.MoveTo(m_ptOrigin);
 dc.LineTo(point);*/

 //CWindowDC dc(this);
 //CWindowDC dc(GetParent());
 /*CWindowDC dc(GetDesktopWindow());
 dc.MoveTo(m_ptOrigin);
 dc.LineTo(point);*/
 /*CPen pen(PS_DOT,1,RGB(0,255,0));
 CClientDC dc(this);
 CPen *pOldPen=dc.SelectObject(&pen);
 dc.MoveTo(m_ptOrigin);
 dc.LineTo(point);
 dc.SelectObject(pOldPen);*/
// CBrush brush(RGB(255,0,0));

 /*CBitmap bitmap;
 bitmap.LoadBitmap(IDB_BITMAP1);
 CBrush brush(&bitmap);*/
 /*CClientDC dc(this);
 //dc.FillRect(CRect(m_ptOrigin,point),&brush);
 CBrush *pBrush=CBrush::FromHandle((HBRUSH)GetStockObject(NULL_BRUSH));
 CBrush *pOldBrush=dc.SelectObject(pBrush);
 dc.Rectangle(CRect(m_ptOrigin,point));
 dc.SelectObject(pOldBrush);*/
 m_bDraw=FALSE;
 CView::OnLButtonUp(nFlags, point);

#include <iostream.h>
#include <string>
char* strToBinary(int x);
char* strToHex(int i);
char* transToGKB(char *t);

int main ()

{
char *p=strToBinary(233);
//cout<<p;

//cout<<strToHex(233);
cout<<transToGKB("商");
return 0;
}
char* transToGKB(char *t){
 int res=0;
   int intlen;
   intlen=strlen(t);
   if(intlen>1){
    char *result=new char[5];
   int i=0;
 if(0>t[0]){
    res=256+t[0];
  }
 char *p1=strToHex(res);
 if(0>t[1]){
  res=256+t[1];
 }
 char *p2=strToHex(res);
 result=p1;
 result[2]=p2[0];
 result[3]=p2[1]; 
 result[4]='\0'; 
 return result;
 }
   else{
    //if(t[0]>64)
    char * p=new char[3];
    p=strToHex(t[0]);
    p[2]='\0';
    return  p;
   }

}

//数字转为二进制（255以内的正数）
char* strToBinary(int i){
 char *result=new   char[9];
 int n=1;
 int m;
 int c=0;
 int j=8;
 for(c=0;c<8;c++){
  m=i%2;
  j=j-1;
  i=n=i/2;
  if(n>=0){
   if (m>0){
    result[j]='1';
   }else
   {
    result[j]='0';
   } 
  }
  
 }
 result[8]='\0';
 
// cout<<result;
 return result;
}
//数字转为十六进制（255以内的正数）
char* strToHex(int i){
 char *result=new   char[3];
 int n=1;
 int m;
 int c=0;
 int j=2;
 for(c=0;c<2;c++){
  m=i%16;
  j=j-1;
  i=n=i/16;
  if(n>=0){
   if (m>0){
    if (m==1){
                  result[j]='1';
    }
    else if (m==2){
     result[j]='2';
    }
    else if (m==3){
     result[j]='3';
    }
    else if (m==4){
     result[j]='4';
    }
    else if (m==5){
     result[j]='5';
    }
    else if (m==6){
     result[j]='6';
    }
    else if (m==7){
     result[j]='7';
    }
    else if (m==8){
     result[j]='8';
    }
    else if (m==9){
     result[j]='9';
    }
    else if (m==10){
     result[j]='A';
    }
    else if (m==11){
     result[j]='B';
    }
    else if (m==12){
     result[j]='C';
    }
    else if (m==13){
     result[j]='D';
    }
    else if (m==14){
     result[j]='E';
    }
    else if (m==15){
     result[j]='F';
    }
   }else
   {
    result[j]='0';
   } 
  }
 }
 result[2]='\0';
 return result;
}

#include <iostream.h>

#include <string>
void yihuo(char *t,int n, int m);
void  myToBinary();
void transToGKB(char *t);
void  myToHex();
int main(){
//cout<<"GOOD";
int i=122;
int j=233;
int m=j^i;
 char t[128]={0xC9,0xCC,0xC9,0xCC,0xC9,0xCC,'\0',0xC9,0xCC,0xC9,0xCC};
yihuo(t,0, 2);
// transToGKB(t);
//cout<<m;
//yihuo(2, 3);
//myToHex();
// myToBinary();
cout<<endl;
return 0;
}
//进制之间的转换
  // 字符串传为16进制
void  myToHex(){
 char c[] = "CC";
 unsigned long tt= strtoul(c, NULL, 16);
cout<<strtol(c, NULL, 16);

}

// 字符串传为16进制
void  myToBinary(){
 char c[] = "10000000";
// unsigned long tt= strtoul(c, NULL, 2);
 cout<<strtol(c, NULL, 2);
 
 
}
//汉字的转换， 16进制转换为汉字
void transToGKB(char *t){

 
 // char *t="商户";
 // CharN
 //如果是负数，则转为正整数
 // if(0>t[0]){
 //    res=256+t[0];
 // }
 int j=t[0];
 cout<<t<<endl;

}

void yihuo(char *t,int n, int m) {

 char *tt="商户说的算";
    //转成数字并且保存到数组，然后求异或

 //求的长度
const int mylen=strlen(tt)+1;
char mysplit[1000];
//循环对这个整形数组进行赋值
int i=0;
for(i<0;i<mylen-1;i++){
 if (tt[i]<0){
mysplit[i]=256+tt[i];
 }else
 {
mysplit[i]=tt[i];
 }
}
int result=mysplit[n-1];
int j;
for(j=n;j<n+m;j++){
 result=result^mysplit[n];
 cout<<"L"<<endl;
cout<<mysplit[n];
 cout<<"M"<<endl;

}

//进行遍历求异或
mysplit[mylen-1]='\0';
cout<<mysplit;

cout<<"ee";
if(result<0)
result=256+result;
cout<<result;
 //int j=t[0];
// cout<<t<<endl;

 }

Private Sub UserControl_ReadProperties(PropBag As PropertyBag)

 Text1.Text = PropBag.ReadProperty("RecordSource", _
       m_def_recordSource)
  Text2.Text = PropBag.ReadProperty _
   ("ConnectionString", m_def_connectionString)

End Sub

int main(void)
{
   int m=4;
   int nn;
   int  *n;
   int *s;
   int *p;
   int *q;
   n=&m;
  
  nn=n;
   q=n;
  s=nn;
   printf("%08x",*s);

   return 0;
}

0xFFFFFF20  数据输入缓冲区
0xFFFFFF24  输出数据缓冲区   
0xFFFFFF28  控制寄存器

1.程序段:程序段为程序代码在内存中的映射.一个程序可以在内存中多有个副本.

2.初始化过的数据:在程序运行值初已经对变量进行初始化的

3.未初始化过的数据:在程序运行初未对变量进行初始化的数据

4.堆(stack):存储局部,临时变量,在程序块开始时自动分配内存,结束时自动释放内存.存储函数的返回指针.

5.栈(heap):存储动态内存分配,需要程序员手工分配,手工释放.

 

# include <stdio.h>

int g1=0, g2=0, g3=0;

intmax(int i)
{
    int m1=0,m2,m3=0,*p_max;
    static n1_max=0,n2_max,n3_max=0;
    p_max =(int*)malloc(10);
    printf("打印max程序地址\n");
    printf("in max: 0x%08x\n\n",max);
    printf("打印max传入参数地址\n");
    printf("in max: 0x%08x\n\n",&i);
    printf("打印max函数中静态变量地址\n");
    printf("0x%08x\n",&n1_max);//打印各本地变量的内存地址
    printf("0x%08x\n",&n2_max);
    printf("0x%08x\n\n",&n3_max);
    printf("打印max函数中局部变量地址\n");
    printf("0x%08x\n",&m1);//打印各本地变量的内存地址
    printf("0x%08x\n",&m2);
    printf("0x%08x\n\n",&m3);
    printf("打印max函数中malloc分配地址\n");
    printf("0x%08x\n\n",p_max);//打印各本地变量的内存地址

    if(i)return 1;
    elsereturn 0;
}

int main(int argc,char**argv)
{
staticint s1=0, s2, s3=0;
int v1=0, v2, v3=0;
int*p;    
p =(int*)malloc(10);

printf("打印各全局变量(已初始化)的内存地址\n");
printf("0x%08x\n",&g1);//打印各全局变量的内存地址
printf("0x%08x\n",&g2);
printf("0x%08x\n\n",&g3);
printf("======================\n");
printf("打印程序初始程序main地址\n");
printf("main: 0x%08x\n\n", main);
printf("打印主参地址\n");
printf("argv: 0x%08x\n\n",argv);
printf("打印各静态变量的内存地址\n");
printf("0x%08x\n",&s1);//打印各静态变量的内存地址
printf("0x%08x\n",&s2);
printf("0x%08x\n\n",&s3);
printf("打印各局部变量的内存地址\n");
printf("0x%08x\n",&v1);//打印各本地变量的内存地址
printf("0x%08x\n",&v2);
printf("0x%08x\n\n",&v3);
printf("打印malloc分配的堆地址\n");
printf("malloc: 0x%08x\n\n",p);
printf("======================\n");
    max(v1);
printf("======================\n");
printf("打印子函数起始地址\n");
printf("max: 0x%08x\n\n",max);
return 0;
}

 

这个程序可以大致查看整个程序在内存中的分配情况:
可以看出,传入的参数,局部变量,都是在栈顶分布,随着子函数的增多而向下增长.
函数的调用地址(函数运行代码),全局变量,静态变量都是在分配内存的低部存在,而malloc分配的堆则存在于这些内存之上,并向上生长

#include <stdio.h>
#include <string.h>
hello(){
char *hello="dddd大点的";
int i;
for(i=0;i<strlen(hello);i++){
printf("%s\n",&hello[i]);
}
}
void testStr(){
int i=0;
 for(i=0;i<128;i++)
 {
printf("%c",(char)i);
 }
}
void testmy(){
 char *hello="?？大点的";

 char hellodd[]={hello};
 unsigned char test= hellodd[2];
 if(test>137){

 printf("大于%u",test);
 }else
 {
  printf("小于");
 }
//putchar((char)hello[5]);
printf("字符：%d \n",hellodd[2]);
printf("%d",strlen( hellodd));

}
//相当于substring
teststrcopy(){
char *s="到的得到";
char d[]={"  "};
//strncpy(d,s+0,2);
strncpy(d,s,2);
printf("%s\n",d);
}
int main(void){
//testmy();
 //teststrcopy();
 return 0;
}

void testmy(){
 char *hello="?？大点的";

 char hellodd[]={hello};
 unsigned char test= hellodd[2];
 if(test>137){

 printf("大于%u",test);
 }else
 {
  printf("小于");
 }
//putchar((char)hello[5]);
printf("字符：%d \n",hellodd[2]);
printf("%d",strlen( hellodd));

}

用记事本编辑修改一下，选择后面的空格得去掉

带有finally的方法的反编译之后

1、导出，首先创建导出一个目录，示例中在/db/目录下创建sunguorong的一个文件夹

 dbexport  dbname -c -ss -o /db/sunguorong

2、导出完成后，在sunguorong目录下生成一个dbname.exp的目录，找到该目录下的dbname.sql模式脚本文件，需要利用工具（如sqleditor）来验证一下脚本的语法的正确性（导出的脚本可能存在语法上的错误），需要加以修改纠正。

3、导入，在导入之前，需要按照存储情况先划分好DBSPACE

 dbimport dbname -i /db/sunguorong dbname -c -l buffered -d
 dbimport ecardsafe -i D:/mydbback ecardsafe -c -l
4、导入完成后，进行数据库级别的统计更新

 update statistics ;

<script type="text/javascript">
function validateXML(txt)
{

// code for IE
if (window.ActiveXObject)
  {
  var xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
  xmlDoc.async="false";
  xmlDoc.loadXML(document.all(txt).value);

  if(xmlDoc.parseError.errorCode!=0)
    {
    txt="Error Code: " + xmlDoc.parseError.errorCode + "\n";
    txt=txt+"Error Reason: " + xmlDoc.parseError.reason;
    txt=txt+"Error Line: " + xmlDoc.parseError.line;
    alert(txt);
    }
  else
    {
    alert("No errors found");
    }
  }
// code for Mozilla, Firefox, Opera, etc.
else if (document.implementation.createDocument)
  {
var parser=new DOMParser();
var text=document.getElementById(txt).value;
var xmlDoc=parser.parseFromString(text,"text/xml");

  if (xmlDoc.documentElement.nodeName=="parsererror")
    {
    alert(xmlDoc.documentElement.childNodes[0].nodeValue);
    }
  else
    {
    alert("No errors found");
    }
  }
else
  {
  alert('Your browser cannot handle XML validation');
  }
}
</script>

 <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
 </bean>
<bean id="UserDAOProxy"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
 <property name="proxyTargetClass">
   <value>true</value>
  </property>

  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="target">
   <ref local="UserDAO" />
  </property>
  <property name="transactionAttributes">
   <props>
    <prop key="*">PROPAGATION_REQUIRED</prop>
   </props>
  </property>
 </bean>
 

　　 六顶帽子思考法特点一览表

　　1.白色帽子思考法

　　白色帽子思考法的主要特点是细致，客观，注重细节和沟通。它是沟通的有效工具，它强调的是事实本身而不是解释。

　　其行为要点最重要的是事实。这是最基本的一个方面，其他的都是对这个方面的扩展。

　　要清楚的知道事实和解释之间的差别，是相信的事实还是验证过的事实，是事实本身还是近似事实，都要明辨区别。

　　如果了解真实的情况不可能，或者成本很高，应该采用“一般来说”或“绝对真理”的做法。须要注意的是，这个“一般来说”或“绝对真理”是有一定条件的，要注意其适用的环境因素有没有发生变化，如果发生了变化，“一般来说”的经验或“绝对真理”可能就不再适用了。

　　2.红色帽子思考法

　　红色帽子思考法是情绪化、感情化、非理性的。因为人是情感性的动物，情感自始至终在引导、影响着我们的思考，所以在传统的思考方法当中，把这些情感因素列为对思考的一种干扰，要尽可能排除。但是六顶帽子思考方法把情感因素作为合理存在，给了它一个合理的存在地位。因为它的确在主导着我们的想法。红色帽子思考法的行为要点的一个重要方面就是不要问为什么。此外，红色帽子思考法不光是正面的，也包括负面的，只要是非理性的想法都归在红色帽子里面。

　　3.黑色帽子思考法

　　黑色帽子思考法的特点是否定的、怀疑的、悲观的。它的行为要点是合乎逻辑的。同时，在运用这种方法时，要避免辩论、避免沉溺于攻击他人的快感之中。

　　4.黄色帽子思考法

　　黄色帽子思考法的特点是积极的、乐观的。它与黑色帽子恰好相反，一个是朝最坏的可能性去思考，一个是朝最好的可能情况去思考。不过，黄色帽子思考法的行为要点跟黑色帽子的行为要点却很相像——要有逻辑，而不是想象，即使是想象也是有限的。无限的想象无论朝积极的方向还是消极的方向，都把它归在红色帽子底下。

　　当讨论的是一个新事物、新办法、新思路的时候，先要扶持；但是戴完黄帽子以后还要戴黑帽子，要考虑这个新东西在未来的成长过程中可能要面对的风风雨雨，要考虑怎样去防范这些风风雨雨。

　　发生负面情况或者风险比较大的时候，要先戴黑色帽子，先把最坏的情况想出来，做好防范，避免最坏可能性的发生，尽量减少可能的损失。在这样的情况下应该先戴黑色帽子，然后再戴黄色帽子。

　　表 12-2 黄色帽子与其它帽子对比表

　　5.青色帽子思考法

　　黄色帽子没有离开现状，就好像我们蹦得再高，也终归会回到地面上。但是青色帽子就突破了地心引力，到了另外一个领域里。它最大的特点是：新、变。

　　要用创新的变化的想法，集中所有人的精力去创新；要清楚认识到这种创新可能是没有结果的，但是这不妨碍在这方面付出心智去考虑到各种各样的可能性。

　　创新性思维的方法很多，有坐标交叉法、随意诱因法、加减法等等。

　　6.蓝色帽子思考法

　　蓝色帽子作为控制者和组织者，其最主要的责任就是控制、组织、指挥和协调整个思考过程，使思考过程程序化、清晰化、条理化。其技术要点有两个：问正确的问题和定义问题。蓝色帽子还要在思考的过程中不断做摘要、概括、总结，维持思考的秩序，使思考集中到一个方向，不断的从一个台阶走上另一个台阶，不断前进。

版本：v2.3 (2008-4-13) 作者：deerchao 转载请注明来源

目录

跳过目录

1. 本文目标
2. 如何使用本教程
3. 正则表达式到底是什么东西？
4. 入门
5. 测试正则表达式
6. 元字符
7. 字符转义
8. 重复
9. 字符类
10. 分枝条件
11. 反义
12. 分组
13. 后向引用
14. 零宽断言
15. 负向零宽断言
16. 注释
17. 贪婪与懒惰
18. 处理选项
19. 平衡组/递归匹配
20. 还有些什么东西没提到
21. 联系作者
22. 最后,来点广告...
23. 网上的资源及本文参考文献
24. 更新说明

本文目标

30分钟内让你明白正则表达式是什么，并对它有一些基本的了解，让你可以在自己的程序或网页里使用它。

如何使用本教程

最重要的是——请给我30分钟，如果你没有使用正则表达式的经验，请不要试图在30秒内入门——除非你是超人 :)

别被下面那些复杂的表达式吓倒，只要跟着我一步一步来，你会发现正则表达式其实并没有你想像中的那么困难。当然，如果你看完了这篇教程之后，发现自己明白了很多，却又几乎什么都记不得，那也是很正常的——我认为，没接触过正则表达式的人在看完这篇教程后，能把提到过的语法记住80%以上的可能性为零。这里只是让你明白基本的原理，以后你还需要多练习，多使用，才能熟练掌握正则表达式。

除了作为入门教程之外，本文还试图成为可以在日常工作中使用的正则表达式语法参考手册。就作者本人的经历来说，这个目标还是完成得不错的——你看，我自己也没能把所有的东西记下来，不是吗？

清除格式 文本格式约定：专业术语 元字符/语法格式 正则表达式 正则表达式中的一部分(用于分析) 对其进行匹配的源字符串 对正则表达式或其中一部分的说明

隐藏边注 本文右边有一些注释，主要是用来提供一些相关信息，或者给没有程序员背景的读者解释一些基本概念，通常可以忽略。

正则表达式到底是什么东西？

字符是计算机软件处理文字时最基本的单位，可能是字母，数字，标点符号，空格，换行符，汉字等等。字符串是0个或更多个字符的序列。文本也就是文字，字符串。说某个字符串匹配某个正则表达式，通常是指这个字符串里有一部分（或几部分分别）能满足表达式给出的条件。

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard)，也就是*和?。如果你想查找某个目录下的所有的Word文档的话，你会搜索*.doc。在这里，*会被解释成任意的字符串。和通配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符，它能更精确地描述你的需求——当然，代价就是更复杂——比如你可以编写一个正则表达式，用来查找所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

入门

学习正则表达式的最好方法是从例子开始，理解例子之后再自己对例子进行修改，实验。下面给出了不少简单的例子，并对它们作了详细的说明。

假设你在一篇英文小说里查找hi，你可以使用正则表达式hi。

这几乎是最简单的正则表达式了，它可以精确匹配这样的字符串：由两个字符组成，前一个字符是h,后一个是i。通常，处理正则表达式的工具会提供一个忽略大小写的选项，如果选中了这个选项，它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。

不幸的是，很多单词里包含hi这两个连续的字符，比如him,history,high等等。用hi来查找的话，这里边的hi也会被找出来。如果要精确地查找hi这个单词的话，我们应该使用\bhi\b。

\b是正则表达式规定的一个特殊代码（好吧，某些人叫它元字符，metacharacter），代表着单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格，标点符号或者换行来分隔的，但是\b并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。

如果需要更精确的说法，\b匹配这样的位置：它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)\w。

假如你要找的是hi后面不远处跟着一个Lucy，你应该用\bhi\b.*\bLucy\b。

这里，.是另一个元字符，匹配除了换行符以外的任意字符。*同样是元字符，不过它代表的不是字符，也不是位置，而是数量——它指定*前边的内容可以连续重复出现任意次以使整个表达式得到匹配。因此，.*连在一起就意味着任意数量的不包含换行的字符。现在\bhi\b.*\bLucy\b的意思就很明显了：先是一个单词hi,然后是任意个任意字符(但不能是换行)，最后是Lucy这个单词。

换行符就是'\n',ASCII编码为10(十六进制0x0A)的字符。

如果同时使用其它元字符，我们就能构造出功能更强大的正则表达式。比如下面这个例子：

0\d\d-\d\d\d\d\d\d\d\d匹配这样的字符串：以0开头，然后是两个数字，然后是一个连字号“-”，最后是8个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为3位的情形)。

这里的\d是个新的元字符，匹配一位数字(0，或1，或2，或……)。-不是元字符，只匹配它本身——连字符或者减号。

为了避免那么多烦人的重复，我们也可以这样写这个表达式：0\d{2}-\d{8}。 这里\d后面的{2}({8})的意思是前面\d必须连续重复匹配2次(8次)。

测试正则表达式

如果你不觉得正则表达式很难读写的话，要么你是一个天才，要么，你不是地球人。正则表达式的语法很令人头疼，即使对经常使用它的人来说也是如此。由于难于读写，容易出错，所以找一种工具对正则表达式进行测试是很有必要的。

由于在不同的环境下正则表达式的一些细节是不相同的，本教程介绍的是微软 .Net Framework 2.0下正则表达式的行为，所以，我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0，然后下载Regex Tester。这是个绿色软件，下载完后打开压缩包,直接运行RegexTester.exe就可以了。

下面是Regex Tester运行时的截图：

元字符

现在你已经知道几个很有用的元字符了，如\b,.,*，还有\d.正则表达式里还有更多的元字符，比如\s匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。\w匹配字母或数字或下划线或汉字等。

对中文/汉字的特殊处理是由.Net提供的正则表达式引擎支持的，其它环境下的具体情况请查看相关文档。

下面来看看更多的例子：

\ba\w*\b匹配以字母a开头的单词——先是某个单词开始处(\b)，然后是字母a,然后是任意数量的字母或数字(\w*)，最后是单词结束处(\b)。

好吧，现在我们说说正则表达式里的单词是什么意思吧：就是多于一个的连续的\w。不错，这与学习英文时要背的成千上万个同名的东西的确关系不大 :)

\d+匹配1个或更多连续的数字。这里的+是和*类似的元字符，不同的是*匹配重复任意次(可能是0次)，而+则匹配重复1次或更多次。

\b\w{6}\b 匹配刚好6个字母/数字的单词。

元字符^（和数字6在同一个键位上的符号）和$都匹配一个位置，这和\b有点类似。^匹配你要用来查找的字符串的开头，$匹配结尾。这两个代码在验证输入的内容时非常有用，比如一个网站如果要求你填写的QQ号必须为5位到12位数字时，可以使用：^\d{5,12}$。

这里的{5,12}和前面介绍过的{2}是类似的，只不过{2}匹配只能不多不少重复2次，{5,12}则是重复的次数不能少于5次，不能多于12次，否则都不匹配。

因为使用了^和$，所以输入的整个字符串都要用来和\d{5,12}来匹配，也就是说整个输入必须是5到12个数字，因此如果输入的QQ号能匹配这个正则表达式的话，那就符合要求了。

和忽略大小写的选项类似，有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项，^和$的意义就变成了匹配行的开始处和结束处。

字符转义

如果你想查找元字符本身的话，比如你查找.,或者*,就出现了问题：你没办法指定它们，因为它们会被解释成别的意思。这时你就得使用\来取消这些字符的特殊意义。因此，你应该使用\.和\*。当然，要查找\本身，你也得用\\.

例如：unibetter\.com匹配unibetter.com，C:\\Windows匹配C:\Windows。

重复

你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码，例如*,{5,12}等)：

下面是一些使用重复的例子：

Windows\d+匹配Windows后面跟1个或更多数字

^\w+匹配一行的第一个单词(或整个字符串的第一个单词，具体匹配哪个意思得看选项设置)

字符类

要想查找数字，字母或数字，空白是很简单的，因为已经有了对应这些字符集合的元字符，但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办？

很简单，你只需要在方括号里列出它们就行了，像[aeiou]就匹配任何一个英文元音字母，[.?!]匹配标点符号(.或?或!)。

我们也可以轻松地指定一个字符范围，像[0-9]代表的含意与\d就是完全一致的：一位数字；同理[a-z0-9A-Z_]也完全等同于\w（如果只考虑英文的话）。

下面是一个更复杂的表达式：\(?0\d{2}[) -]?\d{8}。

“(”和“)”也是元字符，后面的分组节里会提到，所以在这里需要使用转义。

这个表达式可以匹配几种格式的电话号码，像(010)88886666，或022-22334455，或02912345678等。我们对它进行一些分析吧：首先是一个转义字符\(,它能出现0次或1次(?),然后是一个0，后面跟着2个数字(\d{2})，然后是)或-或空格中的一个，它出现1次或不出现(?)，最后是8个数字(\d{8})。

分枝条件

不幸的是，刚才那个表达式也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题，我们需要用到分枝条件。正则表达式里的分枝条件指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用|把不同的规则分隔开。听不明白？没关系，看例子：

0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

\(0\d{2}\)[- ]?\d{8}|0\d{2}[- ]?\d{8}这个表达式匹配3位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。

\d{5}-\d{4}|\d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字，或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题：使用分枝条件时，要注意各个条件的顺序。如果你把它改成\d{5}|\d{5}-\d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时，将会从左到右地测试每个条件，如果满足了某个分枝的话，就不会去再管其它的条件了。

分组

我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；但如果想要重复多个字符又该怎么办？你可以用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

(\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：\d{1,3}匹配1到3位的数字，(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次，最后再加上一个一到三位的数字(\d{1,3})。

IP地址中每个数字都不能大于255，大家千万不要被《24》第三季的编剧给忽悠了...

不幸的是，它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个正确的IP地址：((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

理解这个表达式的关键是理解2[0-4]\d|25[0-5]|[01]?\d\d?，这里我就不细说了，你自己应该能分析得出来它的意义。

反义

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义：

例子：\S+匹配不包含空白符的字符串。

<a[^>]+>匹配用尖括号括起来的以a开头的字符串。

后向引用

使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

后向引用用于重复搜索前面某个分组匹配的文本。例如，\1代表分组1匹配的文本。难以理解？请看示例：

\b(\w+)\b\s+\1\b可以用来匹配重复的单词，像go go, 或者kitty kitty。这个表达式首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b)，这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符(\s+)，最后是分组1中捕获的内容（也就是前面匹配的那个单词）(\1)。

你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?<Word>\w+)(或者把尖括号换成'也行：(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用\k<Word>,所以上一个例子也可以写成这样：\b(?<Word>\w+)\b\s+\k<Word>\b。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面，也不会拥有组号。

零宽断言

地球人，是不是觉得这些术语名称太复杂，太难记了？我也和你一样。知道有这么一种东西就行了，它叫什么，随它去吧！“无名，万物之始...”

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为零宽断言。最好还是拿例子来说明吧：

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。

(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。

(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=\d)\d{3})*\b，用它对1234567890进行查找时结果是234567890。

下面这个例子同时使用了这两种断言：(?<=\s)\d+(?=\s)匹配以空白符间隔的数字(再次强调，不包括这些空白符)。

负向零宽断言

前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

\b\w*q[^u]\w*\b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像Iraq,Benq，这个表达式就会出错。这是因为[^u]总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u]将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的\w*\b将会匹配下一个单词，于是\b\w*q[^u]\w*\b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题，因为它只匹配一个位置，并不消费任何字符。现在，我们可以这样来解决这个问题：\b\w*q(?!u)\w*\b。

零宽度负预测先行断言 (?!exp)，断言此位置的后面不能匹配表达式exp。例如：\d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字；\b((?!abc)\w)+\b匹配不包含连续字符串abc的单词。

同理，我们可以用(?<!exp),零宽度正回顾后发断言来断言此位置的前面不能匹配表达式exp：(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。

请详细分析表达式(?<=<(\w+)>).*(?=<\/\1>)，这个表达式最能表现零宽断言的真正用途。

一个更复杂的例子：(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容。(<?(\w+)>)指定了这样的前缀：被尖括号括起来的单词(比如可能是<b>)，然后是.*(任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/，它用到了前面提过的字符转义；\1则是一个反向引用，引用的正是捕获的第一组，前面的(\w+)匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。

注释

小括号的另一种用途是通过语法(?#comment)来包含注释。例如：2[0-4]\d(?#200-249)|25[0-5](?#250-255)|[01]?\d\d?(?#0-199)。

要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如，我们可以前面的一个表达式写成这样：

      (?<=    # 断言要匹配的文本的前缀
      <(\w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
      )       # 前缀结束
      .*      # 匹配任意文本
      (?=     # 断言要匹配的文本的后缀
      <\/\1>  # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签
      )       # 后缀结束

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。考虑这个表达式：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。

有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。

为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。

处理选项

在C#中，你可以使用Regex(String, RegexOptions)构造函数来设置正则表达式的处理选项。如：Regex regex = new Regex("\ba\w{6}\b", RegexOptions.IgnoreCase);

上面介绍了几个选项如忽略大小写，处理多行等，这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项：

一个经常被问到的问题是：是不是只能同时使用多行模式和单行模式中的一种？答案是：不是。这两个选项之间没有任何关系，除了它们的名字比较相似（以至于让人感到疑惑）以外。

平衡组/递归匹配

这里介绍的平衡组语法是由.Net Framework支持的；其它语言／库不一定支持这种功能，或者支持此功能但需要使用不同的语法。

有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构，这时简单地使用\(.+\)则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如( 5 / ( 3 + 2 ) ) )，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？

为了避免(和\(把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy这样的字符串里，最长的配对的尖括号内的内容捕获出来？

这里需要用到以下的语法构造：

• (?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
• (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
• (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
• (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你自称程序员但是不知道堆栈是什么东西），你就这样理解上面的三种语法吧：第一个就是在黑板上写一个"group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部分，否则就匹配no部分。

我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。

<                         #最外层的左括号
    [^<>]*                #最外层的左括号后面的不是括号的内容
    (
        (
            (?'Open'<)    #碰到了左括号，在黑板上写一个"Open"
            [^<>]*       #匹配左括号后面的不是括号的内容
        )+
        (
            (?'-Open'>)   #碰到了右括号，擦掉一个"Open"
            [^<>]*        #匹配右括号后面不是括号的内容
        )+
    )*
    (?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败

>                         #最外层的右括号

平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签：<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div>.

还有些什么东西没提到

我已经描述了构造正则表达式的大量元素，还有一些我没有提到的东西。下面是未提到的元素的列表，包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。

一、汉字编码的种类

    汉字编码中现在主要用到的有三类，包括GBK，GB2312和Big5。

    1 、GB2312又称国标码， 由国家标准总局发布， 1981 年 5 月 1 日实施，通行于大陆。新加坡等地也使用此编码。它是一个简化字的编码规范，当然也包括其他的符号、字母、日文假名等，共 7445 个图形字符，其中汉字占 6763 个。我们平时说 6768 个汉字，实际上里边有 5 个编码为空白，所以总共有 6763 个汉字。

      GB2312 规定“对任意一个图形字符都采用两个字节表示，每个字节均采用七位编码表示”，习惯上称第一个字节为“高字节”，第二个字节为“低字节”。 GB2312 中汉字的编码范围为，第一字节0xB0-0xF7(对应十进制为176-247)，第二个字节0xA0-0xFE（对应十进制为160-254）。

    GB2312 将代码表分为 94 个区，对应第一字节（ 0xa1-0xfe ）；每个区 94 个位（ 0xa1-0xfe ），对应第二字节，两个字节的值分别为区号值和位号值加 32 （ 2OH ），因此也称为区位码。 01-09 区为符号、数字区， 16-87 区为汉字区（ 0xb0-0xf7 ）， 10-15 区、 88-94 区是有待进一步标准化的空白区。

       2 、 Big5 又称大五码，主要为香港与台湾使用，即是一个繁体字编码。 每个汉字由两个字节构成，第一个字节的范围从 0X81 － 0XFE （即 129-255 ），共 126 种。第二个字节的范围不连续，分别为 0X40 － 0X7E （即 64-126 ）， 0XA1 － 0XFE （即 161-254 ），共 157 种。

    3 、GBK是GB2312的扩展，是向上兼容的，因此GB2312中的汉字的编码与GBK中汉字的相同。另外，GBK中还包含繁体字的编码，它与Big5编码之间的关系我还没有弄明白，好像是不一致的。GBK中每个汉字仍然包含两个字节，第一个字节的范围是0x81-0xFE（即129-254），第二个字节的范围是0x40-0xFE（即64-254）。GBK中有码位23940个，包含汉字21003个。

                                   表1 汉字编码范围

二、对汉字进行hash

    为了处理汉字的方便，在查找汉字的时候，我们通常会用到hash的方法，那怎么来确定一个汉字位置呢？这就和每种编码的排列有关了，这里主要给出一种hash函数的策略。

    对于GB2312编码，设输入的汉字为GBword，我们可以采用公式(C1-176)*94 + (C2-161)确定GBindex。其中，C1表示第一字节，C2表示第二字节。具体如下：

    GBindex = ((unsigned char)GBword.at(0)-176)*94 + (unsigned char)GBword.at(1) - 161;

    之所以用unsigned char类型，是因为char是一个字节，如果用unsigend int，因为int是4个字节的，所以会造成扩展，导致错误。

       对于GBK编码，设输入的汉字为GBKword，则可以采用公式   index=(ch1-0x81)*190+(ch2-0x40)-(ch2/128) ，其中ch1是第一字节，ch2是第二字节。

    具体的，

    GBKindex = ((unsigned char)GBKword[0]-129)*190 +

               ((unsigned char)GBKword[1]-64) - (unsigned char)GBKword[1]/128;

三、怎样判断一个汉字的是什么编码

直接根据汉字的编码范围判断，对于GB2312和GBK可用下面两个程序实现。

1 、判断是否是GB2312

bool isGBCode(const string& strIn)

{

    unsigned char ch1;

    unsigned char ch2;

    if (strIn.size() >= 2)

    {

        ch1 = (unsigned char)strIn.at(0);

        ch2 = (unsigned char)strIn.at(1);

        if (ch1>=176 && ch1<=247 && ch2>=160 && ch2<=254)

            return true;

        else return false;

    }

    else return false;

}

2 、判断是否是GBK编码

bool isGBKCode(const string& strIn)

{

    unsigned char ch1;

    unsigned char ch2;

    if (strIn.size() >= 2)

    {

        ch1 = (unsigned char)strIn.at(0);

        ch2 = (unsigned char)strIn.at(1);

        if (ch1>=129 && ch1<=254 && ch2>=64 && ch2<=254)

            return true;

        else return false;

    }

    else return false;

}

3 、对于Big5

    它的范围为：高字节从0xA0到0xFE，低字节从0x40到0x7E，和0xA1到0xFE两部分。判断一个汉字是否是BIG5编码，可以如上对字符的编码范围判断即可。如何定位呢？那么也想象所有编码排列为一个二维坐标，纵坐标是高字节，横坐标是低字节。这样一行上的汉字个数：(0x7E-0x40+1)+(0xFE-0xA1+1)＝157。那么定位算法分两块，为:  

    if 0x40<=ch2<=0x7E: #is big5 char

    index=((ch1-0xA1)*157+(ch2-0x40))*2

    elif 0xA1<=ch2<=0xFE: #is big5 char

    index=((ch1-0xA1)*157+(ch2-0xA1+63))*2

对于第二块，计算偏移量时因为有两块数值，所以在计算后面一段值时，不要忘了前面还有一段值。0x7E-0x40+1=63。

四、如果判断一个字符是西文字符还是中文字符

    大家知道西文字符主要是指 ASCII 码，它用一个字节表示。且这个字符转换成数字之后，该数字是大于0的，而汉字是两个字节的，第一个字节的转化为数字之后应该是小于0的，因此可以根据每个字节转化为数字之后是否小于0，判断它是否是汉字。

    例如，设输入字为strin，则，

     If (strin.at(0) < 0)

       cout << ” 是汉字” << endl;

     else cout << ” 不是汉字” << endl;

五、编码表下载

   GBK编码表，下载

   GB2312编码表，下载

下面都是我收集的一些比较常用的正则表达式，因为平常可能在表单验证的时候，用到的比较多。特发出来，让各位朋友共同使用。呵呵。

匹配中文字符的正则表达式： [u4e00-u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^x00-xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：ns*r
评注：可以用来删除空白行

匹配HTML标记的正则表达式：< (S*?)[^>]*>.*?|< .*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^s*|s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式


匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用

匹配国内电话号码：d{3}-d{8}|d{4}-d{7}
评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]d{5}(?!d)
评注：中国邮政编码为6位数字

匹配身份证：d{15}|d{18}
评注：中国的身份证为15位或18位

匹配ip地址：d+.d+.d+.d+
评注：提取ip地址时有用

匹配特定数字：
^[1-9]d*$　 　 //匹配正整数
^-[1-9]d*$ 　 //匹配负整数
^-?[1-9]d*$　　 //匹配整数
^[1-9]d*|0$　 //匹配非负整数（正整数 + 0）
^-[1-9]d*|0$　　 //匹配非正整数（负整数 + 0）
^[1-9]d*.d*|0.d*[1-9]d*$　　 //匹配正浮点数
^-([1-9]d*.d*|0.d*[1-9]d*)$　 //匹配负浮点数
^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$　 //匹配浮点数
^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串

在使用RegularExpressionValidator验证控件时的验证功能及其验证表达式介绍如下:

只能输入数字：“^[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}$”

正确格式为：“XXXX-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”。

匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
匹配空行的正则表达式：n[s| ]*r
匹配HTML标记的正则表达式：/< (.*)>.*|< (.*) />/
匹配首尾空格的正则表达式：(^s*)|(s*$)
匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

(1)应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^x00-xff]/g,”aa”).length;}

(2)应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现
String.prototype.trim = function()
{
return this.replace(/(^s*)|(s*$)/g, “”);
}
(3)应用：利用正则表达式分解和转换IP地址
function IP2V(ip) //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!”)
}
}
(4)应用：从URL地址中提取文件名的javascript程序
s=”http://www.9499.net/page1.htm”;
s=s.replace(/(.*/){0,}([^.]+).*/ig,”$2″) ; //Page1.htm
(5)应用：利用正则表达式限制网页表单里的文本框输入内容
用正则表达式限制只能输入中文：onkeyup=”value=”/blog/value.replace(/["^u4E00-u9FA5]/g,”) ” onbeforepaste=”clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^u4E00-u9FA5]/g,”))”
用正则表达式限制只能输入全角字符： onkeyup=”value=”/blog/value.replace(/["^uFF00-uFFFF]/g,”) ” onbeforepaste=”clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^uFF00-uFFFF]/g,”))”
用正则表达式限制只能输入数字：onkeyup=”value=”/blog/value.replace(/["^d]/g,”) “onbeforepaste= “clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^d]/g,”))”
用正则表达式限制只能输入数字和英文：onkeyup=”value=”/blog/value.replace(/[W]/g,””) “onbeforepaste=”clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^d]/g,”

一、汉字编码的种类

    汉字编码中现在主要用到的有三类，包括GBK，GB2312和Big5。

    1 、GB2312又称国标码， 由国家标准总局发布， 1981 年 5 月 1 日实施，通行于大陆。新加坡等地也使用此编码。它是一个简化字的编码规范，当然也包括其他的符号、字母、日文假名等，共 7445 个图形字符，其中汉字占 6763 个。我们平时说 6768 个汉字，实际上里边有 5 个编码为空白，所以总共有 6763 个汉字。

      GB2312 规定“对任意一个图形字符都采用两个字节表示，每个字节均采用七位编码表示”，习惯上称第一个字节为“高字节”，第二个字节为“低字节”。 GB2312 中汉字的编码范围为，第一字节0xB0-0xF7(对应十进制为176-247)，第二个字节0xA0-0xFE（对应十进制为160-254）。

    GB2312 将代码表分为 94 个区，对应第一字节（ 0xa1-0xfe ）；每个区 94 个位（ 0xa1-0xfe ），对应第二字节，两个字节的值分别为区号值和位号值加 32 （ 2OH ），因此也称为区位码。 01-09 区为符号、数字区， 16-87 区为汉字区（ 0xb0-0xf7 ）， 10-15 区、 88-94 区是有待进一步标准化的空白区。

       2 、 Big5 又称大五码，主要为香港与台湾使用，即是一个繁体字编码。 每个汉字由两个字节构成，第一个字节的范围从 0X81 － 0XFE （即 129-255 ），共 126 种。第二个字节的范围不连续，分别为 0X40 － 0X7E （即 64-126 ）， 0XA1 － 0XFE （即 161-254 ），共 157 种。

    3 、GBK是GB2312的扩展，是向上兼容的，因此GB2312中的汉字的编码与GBK中汉字的相同。另外，GBK中还包含繁体字的编码，它与Big5编码之间的关系我还没有弄明白，好像是不一致的。GBK中每个汉字仍然包含两个字节，第一个字节的范围是0x81-0xFE（即129-254），第二个字节的范围是0x40-0xFE（即64-254）。GBK中有码位23940个，包含汉字21003个。

                                   表1 汉字编码范围

二、对汉字进行hash

    为了处理汉字的方便，在查找汉字的时候，我们通常会用到hash的方法，那怎么来确定一个汉字位置呢？这就和每种编码的排列有关了，这里主要给出一种hash函数的策略。

    对于GB2312编码，设输入的汉字为GBword，我们可以采用公式(C1-176)*94 + (C2-161)确定GBindex。其中，C1表示第一字节，C2表示第二字节。具体如下：

    GBindex = ((unsigned char)GBword.at(0)-176)*94 + (unsigned char)GBword.at(1) - 161;

    之所以用unsigned char类型，是因为char是一个字节，如果用unsigend int，因为int是4个字节的，所以会造成扩展，导致错误。

       对于GBK编码，设输入的汉字为GBKword，则可以采用公式   index=(ch1-0x81)*190+(ch2-0x40)-(ch2/128) ，其中ch1是第一字节，ch2是第二字节。

    具体的，

    GBKindex = ((unsigned char)GBKword[0]-129)*190 +

               ((unsigned char)GBKword[1]-64) - (unsigned char)GBKword[1]/128;

三、怎样判断一个汉字的是什么编码

直接根据汉字的编码范围判断，对于GB2312和GBK可用下面两个程序实现。

1 、判断是否是GB2312

bool isGBCode(const string& strIn)

{

    unsigned char ch1;

    unsigned char ch2;

    if (strIn.size() >= 2)

    {

        ch1 = (unsigned char)strIn.at(0);

        ch2 = (unsigned char)strIn.at(1);

        if (ch1>=176 && ch1<=247 && ch2>=160 && ch2<=254)

            return true;

        else return false;

    }

    else return false;

}

2 、判断是否是GBK编码

bool isGBKCode(const string& strIn)

{

    unsigned char ch1;

    unsigned char ch2;

    if (strIn.size() >= 2)

    {

        ch1 = (unsigned char)strIn.at(0);

        ch2 = (unsigned char)strIn.at(1);

        if (ch1>=129 && ch1<=254 && ch2>=64 && ch2<=254)

            return true;

        else return false;

    }

    else return false;

}

3 、对于Big5

    它的范围为：高字节从0xA0到0xFE，低字节从0x40到0x7E，和0xA1到0xFE两部分。判断一个汉字是否是BIG5编码，可以如上对字符的编码范围判断即可。如何定位呢？那么也想象所有编码排列为一个二维坐标，纵坐标是高字节，横坐标是低字节。这样一行上的汉字个数：(0x7E-0x40+1)+(0xFE-0xA1+1)＝157。那么定位算法分两块，为:  

    if 0x40<=ch2<=0x7E: #is big5 char

    index=((ch1-0xA1)*157+(ch2-0x40))*2

    elif 0xA1<=ch2<=0xFE: #is big5 char

    index=((ch1-0xA1)*157+(ch2-0xA1+63))*2

对于第二块，计算偏移量时因为有两块数值，所以在计算后面一段值时，不要忘了前面还有一段值。0x7E-0x40+1=63。

四、如果判断一个字符是西文字符还是中文字符

    大家知道西文字符主要是指 ASCII 码，它用一个字节表示。且这个字符转换成数字之后，该数字是大于0的，而汉字是两个字节的，第一个字节的转化为数字之后应该是小于0的，因此可以根据每个字节转化为数字之后是否小于0，判断它是否是汉字。

    例如，设输入字为strin，则，

     If (strin.at(0) < 0)

       cout << ” 是汉字” << endl;

     else cout << ” 不是汉字” << endl;

　汉字在 Unicode 里面有单独的几块区域，是中日韩（朝鲜）共享的。
以下两段
U+4e00 ~ U+9FB0 原来 GB2312 和 GBK 中的汉字
U+3400 ~ U+4DB6 包括 GB18030.2000 中那些增加的汉字

五、编码表下载

   GBK编码表，下载

   GB2312编码表，下载

Unicode字符编码规范
Unicode是一种字符编码规范 。
先从ASCII说起。ASCII是用来表示英文字符的一种编码规范，每个ASCII字符占用1个字节（8bits）

因此，ASCII编码可以表示的最大字符数是256，其实英文字符并没有那么多，一般只用前128个（最高位为0），其中包括了控制字符、数字、大小写字母和其他一些符号
。
而最高位为1的另128个字符被成为“扩展ASCII”，一般用来存放英文的制表符、部分音标字符等等的一些其他符号
这种字符编码规范显然用来处理英文没有什么问题
。（实际上也可以用来处理法文、德文等一些其他的西欧字符，但是不能和英文通用），但是面对中文、阿拉伯文之类复杂的文字，255个字符显然不够用
于是，各个国家纷纷制定了自己的文字编码规范，其中中文的文字编码规范叫做“GB2312-80”，它是和ASCII兼容的一种编码规范，其实就是利用扩展ASCII没有真正标准化这一点，把一个中文字符用两个扩展ASCII字符来表示。
但 是这个方法有问题，最大的问题就是，中文文字没有真正属于自己的编码，因为扩展ASCII码虽然没有真正的标准化，但是PC里的ASCII码还是有一个事 实标准的（存放着英文制表符），所以很多软件利用这些符号来画表格。这样的软件用到中文系统中，这些表格符就会被误认作中文字，破坏版面。而且，统计中英 文混合字符串中的字数，也是比较复杂的，我们必须判断一个ASCII码是否扩展，以及它的下一个ASCII是否扩展，然后才“猜”那可能是一个中文字
。
总之当时处理中文是很痛苦的。而更痛苦的是GB2312是国家标准，台湾当时有一个Big5编码标准，很多编码和GB是相同的，所以……，嘿嘿。
这 时候，我们就知道，要真正解决中文问题，不能从扩展ASCII的角度入手，也不能仅靠中国一家来解决。而必须有一个全新的编码系统，这个系统要可以将中 文、英文、法文、德文……等等所有的文字统一起来考虑，为每个文字都分配一个单独的编码，这样才不会有上面那种现象出现。
于是，Unicode诞生了。
Unicode有两套标准，一套叫UCS-2(Unicode-16)，用2个字节为字符编码，另一套叫UCS-4(Unicode-32)，用4个字节为字符编码。
以目前常用的UCS-2为例，它可以表示的字符数为2^16=65535，基本上可以容纳所有的欧美字符和绝大部分的亚洲字符
。
UTF-8的问题后面会提到 。
在Unicode里，所有的字符被一视同仁。汉字不再使用“两个扩展ASCII”，而是使用“1个Unicode”，注意，现在的汉字是“一个字符”了，于是，拆字、统计字数这些问题也就自然而然的解决了
。
但是，这个世界不是理想的，不可能在一夜之间所有的系统都使用Unicode来处理字符，所以Unicode在诞生之日，就必须考虑一个严峻的问题：和ASCII字符集之间的不兼容问题。
我们知道，ASCII字符是单个字节的，比如“A”的ASCII是65。而Unicode是双字节的，比如“A”的Unicode是0065，这就造成了一个非常大的问题：以前处理ASCII的那套机制不能被用来处理Unicode了
。
另一个更加严重的问题是，C语言使用’\0′作为字符串结尾，而Unicode里恰恰有很多字符都有一个字节为0，这样一来，C语言的字符串函数将无法正常处理Unicode，除非把世界上所有用C写的程序以及他们所用的函数库全部换掉
。
于是，比Unicode更伟大的东东诞生了，之所以说它更伟大是因为它让Unicode不再存在于纸上，而是真实的存在于我们大家的电脑中。那就是：UTF
。
UTF= UCS Transformation Format UCS转换格式
它是将Unicode编码规则和计算机的实际编码对应起来的一个规则。现在流行的UTF有2种：UTF-8和UTF-16
。
其中UTF-16和上面提到的Unicode本身的编码规范是一致的，这里不多说了。而UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容
。
UTF-8有点类似于Haffman编码，它将Unicode编码为00000000-0000007F的字符，用单个字节来表示；
00000080-000007FF的字符用两个字节表示
00000800-0000FFFF的字符用3字节表示
因为目前为止Unicode-16规范没有指定FFFF以上的字符，所以UTF-8最多是使用3个字节来表示一个字符。但理论上来说，UTF-8最多需要用6字节表示一个字符。
在UTF-8里，英文字符仍然跟ASCII编码一样，因此原先的函数库可以继续使用。而中文的编码范围是在0080-07FF之间，因此是2个字节表示（但这两个字节和GB编码的两个字节是不同的），用专门的Unicode处理类可以对UTF编码进行处理。
下面说说中文的问题。
由于历史的原因，在Unicode之前，一共存在过3套中文编码标准。
GB2312-80，是中国大陆使用的国家标准，其中一共编码了6763个常用简体汉字。Big5，是台湾使用的编码标准，编码了台湾使用的繁体汉字，大概有8千多个。HKSCS，是中国香港使用的编码标准，字体也是繁体，但跟Big5有所不同。
这3套编码标准都采用了两个扩展ASCII的方法，因此，几套编码互不兼容，而且编码区间也各有不同
因为其不兼容性，在同一个系统中同时显示GB和Big5基本上是不可能的。当时的南极星、RichWin等等软件，在自动识别中文编码、自动显示正确编码方面都做了很多努力
。
他们用了怎样的技术我就不得而知了，我知道好像南极星曾经以同屏显示繁简中文为卖点。
后来，由于各方面的原因，国际上又制定了针对中文的统一字符集GBK和GB18030，其中GBK已经在Windows、Linux等多种操作系统中被实现。
GBK兼容GB2312，并增加了大量不常用汉字，还加入了几乎所有的Big5中的繁体汉字。但是GBK中的繁体汉字和Big5中的几乎不兼容。
GB18030相当于是GBK的超集，比GBK包含的字符更多。据我所知目前还没有操作系统直接支持GB18030。
谈谈Unicode编码，简要解释UCS、UTF、BMP、BOM等名词
这是一篇程序员写给程序员的趣味读物。所谓趣味是指可以比较轻松地了解一些原来不清楚的概念，增进知识，类似于打RPG游戏的升级。整理这篇文章的动机是两个问题：
问题一：
使用Windows记事本的“另存为”，可以在GBK、Unicode、Unicode big
endian和UTF-8这几种编码方式间相互转换。同样是txt文件，Windows是怎样识别编码方式的呢？
我很早前就发现Unicode、Unicode big
endian和UTF-8编码的txt文件的开头会多出几个字节，分别是FF、FE（Unicode）,FE、FF（Unicode big
endian）,EF、BB、BF（UTF-8）。但这些标记是基于什么标准呢？
问题二：
最 近在网上看到一个ConvertUTF.c，实现了UTF-32、UTF-16和UTF-8这三种编码方式的相互转换。对于Unicode(UCS2)、 GBK、UTF-8这些编码方式，我原来就了解。但这个程序让我有些糊涂，想不起来UTF-16和UCS2有什么关系。
查了查相关资料，总算将这些问题弄清楚了，顺带也了解了一些Unicode的细节。写成一篇文章，送给有过类似疑问的朋友。本文在写作时尽量做到通俗易懂，但要求读者知道什么是字节，什么是十六进制。
0、big endian和little endian
big endian和little
endian是CPU处理多字节数的不同方式。例如“汉”字的Unicode编码是6C49。那么写到文件里时，究竟是将6C写在前面，还是将49写在前面？如果将6C写在前面，就是big
endian。还是将49写在前面，就是little endian。
“endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开，由此曾发生过六次叛乱，其中一个皇帝送了命，另一个丢了王位。
我们一般将endian翻译成“字节序”，将big endian和little
endian称作“大尾”和“小尾”。
1、字符编码、内码，顺带介绍汉字编码
字符必须编码后才能被计算机处理。计算机使用的缺省编码方式就是计算机的内码。早期的计算机使用7位的ASCII编码，为了处理汉字，程序员设计了用于简体中文的GB2312和用于繁体中文的big5。
GB2312(1980年)一共收录了7445个字符，包括6763个汉字和682个其它符号。汉字区的内码范围高字节从B0-F7，低字节从A1-FE，占用的码位是72*94=6768。其中有5个空位是D7FA-D7FE。
GB2312 支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号，它分为汉字区和图形符号区。汉字区包括21003个字符。2000年的 GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。现在的PC平 台必须支持GB18030，对嵌入式产品暂不作要求。所以手机、MP3一般只支持GB2312。
从ASCII、GB2312、GBK到 GB18030，这些编码方法是向下兼容的，即同一个字符在这些方案中总是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文可以统一地 处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB2312、GBK到GB18030都属于双字节字符集
(DBCS)。
有的中文Windows的缺省内码还是GBK，可以通过GB18030升级包升级到GB18030。不过GB18030相对GBK增加的字符，普通人是很难用到的，通常我们还是用GBK指代中文Windows内码。
这里还有一些细节：
GB2312的原文还是区位码，从区位码到内码，需要在高字节和低字节上分别加上A0。
在DBCS中，GB内码的存储格式始终是big endian，即高位在前。
GB2312 的两个字节的最高位都是1。但符合这个条件的码位只有128*128=16384个。所以GBK和GB18030的低字节最高位都可能不是1。不过这不影 响DBCS字符流的解析：在读取DBCS字符流时，只要遇到高位为1的字节，就可以将下两个字节作为一个双字节编码，而不用管低字节的高位是什么。
2、Unicode、UCS和UTF
前面提到从ASCII、GB2312、GBK到GB18030的编码方法是向下兼容的。而Unicode只与ASCII兼容（更准确地说，是与ISO-8859-1兼容），与GB码不兼容。例如“汉”字的Unicode编码是6C49，而GB码是BABA。
Unicode也是一种字符编码方法，不过它是由国际组织设计，可以容纳全世界所有语言文字的编码方案。Unicode的学名是”Universal
Multiple-Octet Coded Character Set”，简称为UCS。UCS可以看作是”Unicode
Character Set”的缩写。
根据维基百科全书(http://zh.wikipedia.org/wiki/)的记载：历史上存在两个试图独立设计Unicode的组织，即国际标准化组织（ISO）和一个软件制造商的协会（unicode.org）。ISO开发了ISO
10646项目，Unicode协会开发了Unicode项目。
在1991年前后，双方都认识到世界不需要两个不兼容的字符集。于是它们开始合并双方的工作成果，并为创立一个单一编码表而协同工作。从Unicode2.0开始，Unicode项目采用了与ISO
10646-1相同的字库和字码。
目前两个项目仍都存在，并独立地公布各自的标准。Unicode协会现在的最新版本是2005年的Unicode
4.1.0。ISO的最新标准是10646-3:2003。
UCS规定了怎么用多个字节表示各种文字。怎样传输这些编码，是由UTF(UCS
Transformation Format)规范规定的，常见的UTF规范包括UTF-8、UTF-7、UTF-16。
IETF的RFC2781和RFC3629以RFC的一贯风格，清晰、明快又不失严谨地描述了UTF-16和UTF-8的编码方法。我总是记不得IETF是Internet
Engineering Task
Force的缩写。但IETF负责维护的RFC是Internet上一切规范的基础。
3、UCS-2、UCS-4、BMP
UCS有两种格式：UCS-2和UCS-4。顾名思义，UCS-2就是用两个字节编码，UCS-4就是用4个字节（实际上只用了31位，最高位必须为0）编码。下面让我们做一些简单的数学游戏：
UCS-2有2^16=65536个码位，UCS-4有2^31=2147483648个码位。
UCS-4根据最高位为0的最高字节分成2^7=128个group。每个group再根据次高字节分为256个plane。每个plane根据第3个字节分为256行
(rows)，每行包含256个cells。当然同一行的cells只是最后一个字节不同，其余都相同。
group 0的plane 0被称作Basic Multilingual Plane,
即BMP。或者说UCS-4中，高两个字节为0的码位被称作BMP。
将UCS-4的BMP去掉前面的两个零字节就得到了UCS-2。在UCS-2的两个字节前加上两个零字节，就得到了UCS-4的BMP。而目前的UCS-4规范中还没有任何字符被分配在BMP之外。
4、UTF编码
UTF-8就是以8位为单元对UCS进行编码。从UCS-2到UTF-8的编码方式如下：
UCS-2编码(16进制) UTF-8 字节流(二进制)
0000 - 007F 0xxxxxxx
0080 - 07FF 110xxxxx 10xxxxxx
0800 - FFFF 1110xxxx 10xxxxxx 10xxxxxx
例如“汉”字的Unicode编码是6C49。6C49在0800-FFFF之间，所以肯定要用3字节模板了：1110xxxx
10xxxxxx 10xxxxxx。将6C49写成二进制是：0110 110001 001001，
用这个比特流依次代替模板中的x，得到：11100110 10110001 10001001，即E6 B1 89。
读者可以用记事本测试一下我们的编码是否正确。
UTF -16以16位为单元对UCS进行编码。对于小于0×10000的UCS码，UTF-16编码就等于UCS码对应的16位无符号整数。对于不小于 0×10000的UCS码，定义了一个算法。不过由于实际使用的UCS2，或者UCS4的BMP必然小于0×10000，所以就目前而言，可以认为UTF -16和UCS-2基本相同。但UCS-2只是一个编码方案，UTF-16却要用于实际的传输，所以就不得不考虑字节序的问题。
5、UTF的字节序和BOM
UTF -8以字节为编码单元，没有字节序的问题。UTF-16以两个字节为编码单元，在解释一个UTF-16文本前，首先要弄清楚每个编码单元的字节序。例如收 到一个“奎”的Unicode编码是594E，“乙”的Unicode编码是4E59。如果我们收到UTF-16字节流“594E”，那么这是“奎”还是 “乙”？
Unicode规范中推荐的标记字节顺序的方法是BOM。BOM不是“Bill Of
Material”的BOM表，而是Byte Order Mark。BOM是一个有点小聪明的想法：
在UCS编码中有一个叫做”ZERO WIDTH NO-BREAK
SPACE”的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输字符”ZERO
WIDTH NO-BREAK SPACE”。
这样如果接收者收到FEFF，就表明这个字节流是Big-Endian的；如果收到FFFE，就表明这个字节流是Little-Endian的。因此字符”ZERO
WIDTH NO-BREAK SPACE”又被称作BOM。
UTF-8不需要BOM来表明字节顺序，但可以用BOM来表明编码方式。字符”ZERO
WIDTH NO-BREAK SPACE”的UTF-8编码是EF BB
BF（读者可以用我们前面介绍的编码方法验证一下）。所以如果接收者收到以EF BB
BF开头的字节流，就知道这是UTF-8编码了。
Windows就是使用BOM来标记文本文件的编码方式的。
6、进一步的参考资料
本文主要参考的资料是 “Short overview of ISO-IEC 10646 and Unicode”
(http://www.nada.kth.se/i18n/ucs/unicode-iso10646-oview.html)。
我还找了两篇看上去不错的资料，不过因为我开始的疑问都找到了答案，所以就没有看：
“Understanding Unicode A general introduction to the Unicode Standard”
(http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter04a)
“Character set encoding basics Understanding character set encodings
and legacy encodings”
(http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter03)
附录1 再说说区位码、GB2312、内码和代码页
有的朋友对文章中这句话还有疑问： “GB2312的原文还是区位码，从区位码到内码，需要在高字节和低字节上分别加上A0。”
我再详细解释一下：
“GB2312 的原文”是指国家1980年的一个标准《中华人民共和国国家标准 信息交换用汉字编码字符集 基本集 GB 2312-80》。这个标准用两个数来编码汉字和中文符号。第一个数称为“区”，第二个数称为“位”。所以也称为区位码。1-9区是中文符号，16-55 区是一级汉字，56-87区是二级汉字。现在Windows也还有区位输入法，例如输入1601得到“啊”。
内码是指操作系统内部的字符 编码。早期操作系统的内码是与语言相关的.现在的Windows在内部统一使用Unicode，然后用代码页适应各种语言,“内码”的概念就比较模糊了。 微软一般将缺省代码页指定的编码说成是内码，在特殊的场合也会说自己的内码是Unicode，例如在 GB18030问题的处理上。
所谓代码页(code page)就是针对一种语言文字的字符编码。例如GBK的code page是CP936，BIG5的code page是CP950，GB2312的code page是CP20936。
Windows中有缺省代码页的概念，即缺省用什么编码来解释字符。例如Windows的记事本打开了一个文本文件，里面的内容是字节流：BA、BA、D7、D6。Windows应该去怎么解释它呢？
是 按照Unicode编码解释、还是按照GBK解释、还是按照BIG5解释，还是按照ISO8859-1去解释？如果按GBK去解释，就会得到“汉字”两个 字。按照其它编码解释，可能找不到对应的字符，也可能找到错误的字符。所谓“错误”是指与文本作者的本意不符，这时就产生了乱码。
答案是Windows按照当前的缺省代码页去解释文本文件里的字节流。缺省代码页可以通过控制面板的区域选项设置。记事本的另存为中有一项ANSI，其实就是按照缺省代码页的编码方法保存。
Windows的内码是Unicode，它在技术上可以同时支持多个代码页。只要文件能说明自己使用什么编码，用户又安装了对应的代码页，Windows就能正确显示，例如在HTML文件中就可以指定charset。
有 的HTML文件作者，特别是英文作者，认为世界上所有人都使用英文，在文件中不指定charset。如果他使用了0×80-0xff之间的字符，中文 Windows又按照缺省的GBK去解释，就会出现乱码。这时只要在这个html文件中加上指定charset的语句，例如：如果原作者使用的代码页和 ISO8859-1兼容，就不会出现乱码了。
再说区位码，啊的区位码是1601，写成16进制是0×10,0×01。这和计算机广泛使用 的ASCII编码冲突。为了兼容00-7f的 ASCII编码，我们在区位码的高、低字节上分别加上A0。这样“啊”的编码就成为B0A1。我们将加过两个A0的编码也称为GB2312编码，虽然 GB2312的原文根本没提到这一点。
本文来源于 冰山上的播客 http://xinsync.xju.edu.cn , 原文地址：http://xinsync.xju.edu.cn/index.php/archives/483