使用关系代数合并数据

1 关系代数

合并数据集合的理论基础是关系代数，它是由E.F.Codd于1970年提出的。

在关系代数的形式化语言中：

?          用表、或者数据集合表示关系或者实体。

?          用行表示元组。

?          用列表示属性。

关系代数包含以下8个关系运算符

?          选取――返回满足指定条件的行。

?          投影――从数据集合中返回指定的列。

?          笛卡尔积――是关系的乘法，它将分别来自两个数据集合中的行以所有可能的方式进行组合。

?          并――关系的加法和减法，它可以在行的方向上合并两个表中的数据，就像把一个表垒在另一个表之上一样。

?          交――返回两个数据集合所共有的行。

?          差――返回只属于一个数据集合的行。

?          连接――在水平方向上合并两个表，其方法是：将两个表中在共同数据项上相互匹配的那些行合并起来。

?          除――返回两个数据集之间的精确匹配。

此外，作为一种实现现代关系代数运算的方法，SQL还提供了：

?          子查询――类似于连接，但更灵活；在外部查询中，方式可以使用表达式、列表或者数据集合的地方都可以使用子查询的结果。

本章将主要讲述多种类型的连接、简单的和相关的子查询、几种类型的并、关系除以及其他的内容。

2 使用连接

2.1 连接类型

在关系代数中，连接运算是由一个笛卡尔积运算和一个选取运算构成的。首先用笛卡尔积完成对两个数据集合的乘运算，然后对生成的结果集合进行选取运算，确保只把分别来自两个数据集合并且具有重叠部分的行合并在一起。连接的全部意义在于在水平方向上合并两个数据集合（通常是表），并产生一个新的结果集合，其方法是将一个数据源中的行于另一个数据源中和它匹配的行组合成一个新元组。

SQL提供了多种类型的连接方式，它们之间的区别在于：从相互交叠的不同数据集合中选择用于连接的行时所采用的方法不同。

连接类型          定义

内连接          只连接匹配的行

左外连接          包含左边表的全部行（不管右边的表中是否存在与它们匹配的行），以及右边表中全部匹配的行

右外连接          包含右边表的全部行（不管左边的表中是否存在与它们匹配的行），以及左边表中全部匹配的行

全外连接          包含左、右两个表的全部行，不管另外一边的表中是否存在与它们匹配的行。

(H)(theta)连接          使用等值以外的条件来匹配左、右两个表中的行

交叉连接          生成笛卡尔积－它不使用任何匹配或者选取条件，而是直接将一个数据源中的每个行与另一个数据源的每个行都一一匹配

在INFORMIX中连接表的查询

如果FROM子句指定了多于一个表引用，则查询会连接来自多个表的行。连接条件指定各列之间（每个表至少一列）进行连接的关系。因为正在比较连接条件中的列，所以它们必须具有一致的数据类型。

SELECT语句的FROM子句可以指定以下几种类型的连接

FROM子句关键字          相应的结果集

CROSS JOIN          笛卡尔乘积（所有可能的行对）

INNER JOIN          仅对满足连接条件的CROSS中的列

LEFT OUTER JOIN          一个表满足条件的行，和另一个表的所有行

RIGHT OUTER JOIN          与LEFT相同，但两个表的角色互换

FULL OUTER JOIN        LEFT OUTER 和 RIGHT OUTER中所有行的超集

2.2 内连接（Inner Join）

内连接是最常见的一种连接，它页被称为普通连接，而E.FCodd最早称之为自然连接。

下面是ANSI SQL－92标准

select *

from    t_institution i

inner join t_teller t

on i.inst_no = t.inst_no

where i.inst_no = "5801"

其中inner可以省略。

等价于早期的连接语法

select *

from t_institution i, t_teller t

where i.inst_no = t.inst_no

and i.inst_no = "5801"

2.3 外连接

2.3.1          左外连接(Left Outer Jion)

select *

from    t_institution i

left outer join t_teller t

on i.inst_no = t.inst_no

其中outer可以省略。

2.3.2          右外连接(Rigt Outer Jion)

select *

from    t_institution i

right outer join t_teller t

on i.inst_no = t.inst_no

2.3.3          全外连接(Full Outer)

全外连接返回参与连接的两个数据集合中的全部数据，无论它们是否具有与之相匹配的行。在功能上，它等价于对这两个数据集合分别进行左外连接和右外连接，然后再使用消去重复行的并操作将上述两个结果集合并为一个结果集。

在现实生活中，参照完整性约束可以减少对于全外连接的使用，一般情况下左外连接就足够了。在数据库中没有利用清晰、规范的约束来防范错误数据情况下，全外连接就变得非常有用了，你可以使用它来清理数据库中的数据。

select *

from    t_institution i

full outer join t_teller t

on i.inst_no = t.inst_no

2.3.4          外连接与条件配合使用

当在内连接查询中加入条件是，无论是将它加入到join子句，还是加入到where子句，其效果是完全一样的，但对于外连接情况就不同了。当把条件加入到join子句时，SQL Server、Informix会返回外连接表的全部行，然后使用指定的条件返回第二个表的行。如果将条件放到where子句中，SQL Server将会首先进行连接操作，然后使用where子句对连接后的行进行筛选。下面的两个查询展示了条件放置位子对执行结果的影响：

条件在join子句

select *

from    t_institution i

left outer join t_teller t

on i.inst_no = t.inst_no

and i.inst_no = “5801”

结果是：

inst_no      inst_name              inst_no      teller_no    teller_name

5801         天河区                 5801         0001         tom

5801         天河区                 5801         0002         david

5802         越秀区

5803         白云区

条件在where子句

select *

from    t_institution i

left outer join t_teller t

on i.inst_no = t.inst_no

where i.inst_no = “5801”

结果是：

inst_no      inst_name              inst_no      teller_no    teller_name

5801         天河区                 5801         0001         tom

5801         天河区                 5801         0002         david

2.4 自身连接

自身连接是指同一个表自己与自己进行连接。这种一元连接通常用于从自反关系（也称作递归关系）中抽取数据。例如人力资源数据库中雇员与老板的关系。

下面例子是在机构表中查找本机构和上级机构的信息。

select s.inst_no superior_inst, s.inst_name sup_inst_name, i.inst_no, i.inst_name

from t_institution i

join t_institution s

on i.superior_inst = s.inst_no

结果是：

superior_inst sup_inst_name          inst_no      inst_name

800             广州市                 5801         天河区

800             广州市                 5802         越秀区

800             广州市                 5803         白云区

2.5 交叉(无限制) 连接

交叉连接用于对两个源表进行纯关系代数的乘运算。它不使用连接条件来限制结果集合，而是将分别来自两个数据源中的行以所有可能的方式进行组合。数据集合中一的每个行都要与数据集合二中的每一个行分别组成一个新的行。例如，如果第一个数据源中有5个行，而第二个数据源中有4个行，那么在它们之间进行交叉连接就会产生20个行。人们将这种类型的结果集称为笛卡尔乘积。

大多数交叉连接都是由于错误操作而造成的；但是它们却非常适合向数据库中填充例子数据，或者预先创建一些空行以便为程序执行期间所要填充的数据保留空间。

select *

from    t_institution i

cross join t_teller t

在交叉连接中没有on条件子句

键盘用户界面模块使用说明

1.       键盘用户界面模块介绍

健盘用户界面模块是一个处理WEB编程中常用的针对健盘用户界面交互功能的通用javascript模块，主要功能有输入强制性验证，回车切换输入域，快捷键执行功能按钮或切换输入域，输入域活动提示，友好提示信息显示等主要功能。

2.       模块所处位置与调用说明

该模块处在：defaultroot/platform/js/UiKey.js

调用方式为：

<script src="/defaultroot/platform/js/UiKey.js "></script>

该名必须必须放在</body>标签的前一句
提交前验证:
function SubmitForm(form)
{
    if(!checkFormInput(form)) return false;
    form.submit();
}

3.       功能介绍与实现说明

l         输入强制性验证

比如有如下输入框，该输入框只能输入数字字符，用如下方式声明

<input type="text" name="credNumber" minlength="5" maxlength="16" charset="Number" datatype="Cardnumber" nullable="true" size="40" tabindex="9" value="">

charset=”Number”属性就能定义该输入框所能输入的字符类型

注意：其实在实现上，该例子模块会自动调用isNumber(handle,keyCode)来进行验证，系统默认提供了几个验证函数，当需要其它验证方式时，可以自己定义相关的验证函数来进行验证

比如，我有一个输入框，需要输入IP地址，则可以如下声明：

Number:<input type="text" name="credNumber" minlength="5" maxlength="16" charset="Ip" datatype="Cardnumber" nullable="true" size="40" tabindex="9" value="">

然后实现isIP(handle,keyCode)函数即可纳入统一的验证框架之下

本验证只实现输入过程中的验证，至于输入完后格式正确性的验证由如下实现:
<input type="text" name="credNumber" minlength="5" maxlength="16" charset="Number" datatype="Cardnumber" nullable="true" size="40" tabindex="9" value="">
datetype=”Cardnumber”属性就能定义该输入框所需要输入的数据类型

注意：其实在实现上，该例子模块会自动调用isCardnumber(handle)来进行验证，系统默认提供了几个验证函数，当需要其它验证方式时，可以自己定义相关的验证函数来进行验证

比如，我有一个输入框，需要输入移动电话地址，则可以如下声明：

Number:<input type="text" name="Phone" minlength="5" maxlength="16" charset="Number" datatype="Mobile" nullable="true" size="40" tabindex="9" value="">

然后实现isMobile(handle)函数(其实已经实现)即可纳入统一的验证框架之下

l         回车切换输入域

一般情况下，用户在有多输入域的时候都希望在敲下回车后切换到下一输入域，本模块以统一的方式实现了，并且能够识别普通输入域与按钮（包括图片按钮，注意，只要图片有onclick事件，则认为是按钮），在按钮上敲回车将会执行该按钮功能。

要实现该功能，只要定义输入的域tabindex属性即可，如下所示

Number:<input type="text" id="test1" charset="Number" tabindex=1>

<p>

Visible:<input type="text" id="test5" charset="Visible" tabindex=2>

<p>

<IMG SRC="http://www.QQread.com/Java/D:/eclipse/workspace/PFE/defaultroot/style/tempstylefolder/images/3_ico_3.gif" border="5" WIDTH="48" HEIGHT="40" BORDER="0" charset="ddd" AccessKey="Z" onclick="alert('image1 click');" tabindex=3 >

<INPUT TYPE="button" accessKey="5" value="(1)" onclick="alert('button click');" tabindex=4>

如果一路按回车键，则焦点会按tabindex的顺序往下跳，在图片按钮与普通按钮上则不回跳，直接执行onclcik事件

l         快捷键功能

本模块能够定义各页面元素的快捷键，包括图片按钮，普通按钮，各输入域，其定义方式为设置对象的accessKey属性，如下所示

Number:<input type="text" id="test1" charset="Number" tabindex=1 accessKey=”1”>

<p>

Visible:<input type="text" id="test5" charset="Visible" tabindex=2 accessKey=”2”>

<p>

<IMG SRC="http://www.qqread.com/java/D:/eclipse/workspace/PFE/defaultroot/style/tempstylefolder/images/3_ico_3.gif" border="5" WIDTH="48" HEIGHT="40" BORDER="0" charset="ddd" accessKey="Z" onclick="alert('image1 click');" tabindex=3 >

<INPUT TYPE="button" accessKey="5" value="(1)" onclick="alert('button click');" tabindex=4>

当按下ALT+1或者ALT+2后，第一个输入框和第二个输入框会得到焦点

当按下ALT+z或者ALT+5时，图片的onclick事件与按钮的onclick事件会执行

本模块模认定义home键将焦点落在第一个输入域上，end键将焦点落在最后一个输入区域上

l         输入域活动提示

本模块会自动完成，当某一个输入域获得焦点时，会加重显示该输入域，当文本输入域

获得焦点时会自动选择其所有文本

l         友好提示信息

信息提示一直采用alert的方式，这种方式不友好，用户要点击确定后才能继续进行下去，本模块提供汽球型友好提示方式，调用方式如下：

showTip(handle,”必须输入用户名!”);

handle为输入框的句柄
注意，为了显示对应的汽泡提示，还有几个对应的小图片，可以自己帮，也可以找我要!
如果要用在struts 标签库中也是可以的，不过要改一下标签库，如果有需要的也可以直接联系我!
QQ:6045306
EMAIL:huijunzi@21cn.com

//以下为代码
/*
说明:文本框输入格式验证与气球提示实现,图片快捷键功能实现
版权:Copyright (C) 2004 Cyril
作者:Cyril
调用方式:
<script src="UIKey.js"></script>
必须放在</body>标签的前一句
*/
//初始化调用
//先提示画层
drawTipDiv();
//输出样式表
drawStyle();
//装载侦听器
addListener();
//容错处理
function killErrors() {
return true;
}
//window.onerror = killErrors;
//================以下为系统函数区=======================//
//全局变量区
var oldInputStyle;
var oldImgStyle;
var firstInput;
var endInput;
var timer;

//显示提示信息层
function showTip(handle,msg) {
    //alert(handle.type);
    handle.focus();   
 var pos = getPosition(handle);
 var t = pos.top;
 var l = pos.left;
 document.all.checkMsgDiv.style.left=l-10+getTextLength(handle);
    document.all.checkMsgDiv.style.top=t+handle.clientHeight;
    document.all.checkMsgTd.innerHTML=msg;
 document.all.checkMsgDiv.style.visibility = 'visible';
 //隐藏被层遮挡的选择框
 HideOverSels("checkMsgDiv");
 timer = setTimeout("hideTip();", 2500);
 return false;
}

//表单校验函数
function checkFormInput(handle) {
  var controlList = handle.elements;
  var controlObj;
  for(var i=0;i<controlList.length;i++) {
   //如果是text控件,需要进行数据校验
   controlObj = controlList[i];
   if(isControlVisible(controlObj)) {
    if(controlObj.type=='text' controlObj.type=='passWord') {
     //如果不充许为空,则需要判断
           if((controlObj.nullable=="false") && (controlObj.value=="")) {
hideTip();

    showTip(controlObj,"此输入域不能为空!");
    return false;
     }
     //如果有最小长度限制,则需要判断
     if(controlObj.value!='' && controlObj.minlength!=null) {
     var realLength = controlObj.value.length;
     var needLength = controlObj.minlength;
              if(realLength<needLength) {
                 hideTip();
     showTip(controlObj,"此输入域至少需要"+needLength+"个字符!");
     return false;
     }
     }
     //判断数据的类型，调用相关的数据校验函数
     if(controlObj.datatype!=null && controlObj.value!='') {
          var typeStr = controlObj.datatype.toLowerCase();
          var firstChar = typeStr.substring(0,1);
          firstChar = firstChar.toUpperCase();
          typeStr = firstChar+typeStr.substring(1,typeStr.length);
          var tempMsg=eval("is"+typeStr+"(controlObj);");
          if (tempMsg!=true)
          {
       hideTip();
          showTip(controlObj,"此输入域"+tempMsg);
       return false;
       }
     }
    }
   }
  }
  return true;
}

//系统调用接口
function handleKeyDown(event) {

  //有按键就要关闭tip层
  hideTip();
  //home键与end键定位第一个与最后一个输入域上
  if(event.srcElement.type!="text" && event.srcElement.type!="textarea" && event.keyCode==36) {
   if(firstInput) firstInput.focus();
  }
  if(event.srcElement.type!="text" && event.srcElement.type!="textarea" && event.keyCode==35) {
   if(endInput) endInput.focus();
  }
  //处理回车切换焦点以及按钮与图片执行功能
  if(event.keyCode==13 && event.srcElement.type!="button" && event.srcElement.type!="reset" && event.srcElement.type!="" && event.srcElement.type!="textarea") {
   if(event.srcElement.src) {
    if(event.srcElement.onclick) {
    event.srcElement.fireEvent("onclick")
    return;
    } else {
    event.keyCode=9;
    return;
    }
   } else {
    event.keyCode=9;
    return;
   }
  }

  //处理图片按钮的快捷键
  if(event.altKey && event.keyCode!=18) {
   var shortKey=String.fromCharCode(event.keyCode);
   var quickKey = "";
      for(var i=0;i<document.images.length;i++) {
          quickKey = document.images[i].accessKey;
          quickKey = quickKey.toUpperCase();
    if(quickKey==shortKey) {
 if(document.images[i].onclick) {
         document.images[i].fireEvent("onclick");
         break;
     }
    }
   }
   //处理输入对象快捷方式
   var inputList = document.body.getElementsByTagName("INPUT");

      for(var i=0;i<inputList.length;i++) {
        quickKey = inputList[i].accessKey;
        quickKey = quickKey.toUpperCase();
  if(quickKey==shortKey) {
    inputList[i].focus();
        break;
  }
      }
   return;
  }
  if(event.srcElement.type=='text' && event.srcElement.charset!=null) {
    //alert(event.srcElement.charset);
 if((event.keyCode>48 && event.keyCode<112) (event.keyCode>127 && event.keyCode!=144))  checkInputChar(event.srcElement,event.keyCode);
  }
}

//有效性判断入口
function checkInputChar(handle,keyCode) {
    hideTip();
 var typeStr = handle.charset.toLowerCase();
 var firstChar = typeStr.substring(0,1);
 firstChar = firstChar.toUpperCase();
 typeStr = firstChar+typeStr.substring(1,typeStr.length);
 var tempMsg=eval("input"+typeStr+"(handle,keyCode);");
 if (tempMsg!=true)
 {
  hideTip();
  showTip(handle,tempMsg);
 }
}

//关闭提示信息层
function hideTip() {
  document.all.checkMsgDiv.style.visibility = 'hidden';
  //显示被隐藏了的选择框
  ShowOverSels("checkMsgDiv");
 clearTimeout(timer);
}

//获得文本框中文本的象素单位的宽度
function getTextLength(handle)
{
    var range = handle.createTextRange();
    return range.boundingWidth;
    //return 0;
}

//画一个隐藏的层
function drawTipDiv() {
  document.write("<div id=\"checkMsgDiv\"  style=\"position:absolute; width:218px; overflow: visible; z-index:1; visibility:hidden; left: 103px; top: 69px; height: 66px; border: 1px none #000000;\"> ");
  document.write("  <table width=\"218\" height=\"65\" border=\"0\" cellpadding=\"0\" cellspacing=\"0\"  id=\"checkMsgTable\">");

  document.write("    <tr> ");
  document.write("      <td height=\"13\" valign=\"top\"><img src=\"/platform/js/t_top.gif\" width=\"218\" height=\"26\"></td>");
  document.write("    </tr>");
  document.write("    <tr> ");
  document.write("      <td height=\"42\" valign=\"top\" background=\"/platform/js/t_bg.gif\">");
  document.write("  <table width=\"95%\" border=\"0\" align=\"center\" cellpadding=\"0\" cellspacing=\"0\" style=\"font:9pt 宋体;\">");
  document.write("          <tr>");
  document.write("            <td id=\"checkMsgTd\">sdafs </td>");
  document.write("          </tr>");
  document.write("        </table></td>");
  document.write("    </tr>");

document.write("    <tr>");
  document.write("      <td height=\"10\" valign=\"bottom\"><img src=\"/platform/js/t_bottom.gif\" width=\"218\" height=\"10\"></td>");
  document.write("    </tr>");
  document.write("  </table>");
  document.write("</div>");
}

//输出样式表
function drawStyle() {
  document.write("<style type=\"text/Css\">");
  document.write("input.activeInput{border-top-color:#0000CC;border-top-width:1px;border-bottom-color:#0000CC;border-bottom-width:1px;border-left-color:#0000CC;border-left-width:1px;border-right-color:#0000CC;border-right-width:1px;}");
  document.write("img.activeImg{border-top-color:#3366FF;border-top-width:1px;border-bottom-color:#3366FF;border-bottom-width:1px;border-left-color:#3366FF;border-left-width:1px;border-right-color:#3366FF;border-right-width:1px;}");

  document.write("</style>");
}

//控件onFocus事件的侦听器
function onInputFocus() {
  if(window.event.srcElement.src) {
 if(window.event.srcElement.onclick) {
 oldImgStyle = window.event.srcElement.style;
    window.event.srcElement.className="activeImg";
 }
  } else {
 oldInputStyle = window.event.srcElement.style;
 window.event.srcElement.className="activeInput";
 if(window.event.srcElement.select) window.event.srcElement.select();
  }
}

//控件onblur事件的侦听器
function onInputBlur() {
  if(window.event.srcElement.src) {
    window.event.srcElement.className = "";
  } else {
    window.event.srcElement.className = "";
  }
}

//控件onkeypress事件的侦听器
function onInputKeydown () {
  handleKeyDown(window.event);
}

//控件onPaste事件的侦听器
function onInputPaste () {
 return false;
}

//表单onSubmit事件的侦听器
function onFormSubmit () {
  return checkFormInput(window.event.srcElement);
}

//控件onMouseover事件的侦听器
function onInputMouseover () {
  onInputFocus(); 
}

//控年onMouseout事件的侦听器
function onInputMouseout () {
  onInputBlur();
}

//为每个可输入控件装载侦听器
function addListener() {
 var inputList = document.body.getElementsByTagName("INPUT");
 if(inputList[0]) firstInput = inputList[0];
    for(var i=0;i<inputList.length;i++) {
   inputList[i].attachEvent ('onkeydown', onInputKeydown);
   inputList[i].attachEvent ('onfocus', onInputFocus);
   inputList[i].attachEvent ('onblur', onInputBlur);
   //inputList[i].attachEvent ('onpaste', onInputPaste);
   inputList[i].attachEvent ('onmouseover', onInputMouseover);
   inputList[i].attachEvent ('onmouseout', onInputMouseout);
   }
   if(inputList[i-1]) endInput = inputList[i-1];

   var inputList = document.body.getElementsByTagName("IMG");
   for(var i=0;i<inputList.length;i++) {
   inputList[i].attachEvent ('onkeydown', onInputKeydown);
   inputList[i].attachEvent ('onfocus', onInputFocus);
   inputList[i].attachEvent ('onblur', onInputBlur);
   }
   document.body.attachEvent('onkeydown', onInputKeydown);

   var formList = document.body.getElementsByTagName("FORM");
   for(var i=0;i<formList.length;i++) {
 formList[i].attachEvent ('onsubmit',onFormSubmit);
   }
}

// 隐藏被ID为objID的对象（层）遮挡的所有select
function HideOverSels(objID)
{
    var sels = document.getElementsByTagName('select');
    for (var i = 0; i < sels.length; i++)
      if (Obj1OverObj2(document.all[objID], sels[i]))
        sels[i].style.visibility = 'hidden';
}

// 显示被ID为objID的对象（层）遮挡的所有select
function ShowOverSels(objID)
{
    var sels = document.getElementsByTagName('select');
    for (var i = 0; i < sels.length; i++)
      if (Obj1OverObj2(document.all[objID], sels[i]))
        sels[i].style.visibility = 'visible';
}

//判断obj1是否遮挡了obj2
function Obj1OverObj2(obj1, obj2)
{
  var pos1 = getPosition(obj1)
  var pos2 = getPosition(obj2)
  var result = true;
  var obj1Left = pos1.left - window.document.body.scrollLeft;
  var obj1Top = pos1.top - window.document.body.scrollTop;
  var obj1Right = obj1Left + obj1.offsetWidth;
  var obj1Bottom = obj1Top + obj1.offsetHeight;
  var obj2Left = pos2.left - window.document.body.scrollLeft;
  var obj2Top = pos2.top - window.document.body.scrollTop;
  var obj2Right = obj2Left + obj2.offsetWidth;

  var obj2Bottom = obj2Top + obj2.offsetHeight;
  if (obj1Right <= obj2Left obj1Bottom <= obj2Top
      obj1Left >= obj2Right obj1Top >= obj2Bottom)
    result = false;
  return result;
}

// 获取对象的坐标
function getPosition(Obj)
{

var sumTop=0;
    var sumLeft=0;   
    while(Obj!=window.document.body) {
      sumTop+=Obj.offsetTop;
      if(Obj.tagName.toLowerCase()=='div') {
        sumTop-=Obj.scrollTop;
      }
      sumLeft+=Obj.offsetLeft;
      Obj=Obj.offsetParent;
    }
 return {left:sumLeft,top:sumTop}
}

//判断控件的可见性
function isControlVisible(handle) {
  var retValue = true;
  while(handle.tagName.toLowerCase()!='form' && handle.style.display.toLowerCase()!='none') {
    handle = handle.parentElement;
  }
  if(handle.style.display=='none') retValue = false;
  return retValue;
}

//================以上为系统函数区=======================//

//以下为输入过程中输入内容即时验证函数
//必须输入是数字
function inputNumber(handle,keyCode) {
  if(!((keyCode>=48&&keyCode<=57)(keyCode>=96&&keyCode<=105))) {
 window.event.returnValue=false;
 return "必须输入数字!即如下字符:<br>1234567890";
  } else return true;
}
//必须输入字母
function inputLetter(handle,keyCode) {
  if(!((keyCode>=97&&keyCode<=122)(keyCode>=65&&keyCode<=90))) {
 window.event.returnValue=false;
 return "必须输入大小写字母!即如下字符:<br>abcdefghijklmnopqrstuvwxyz<br>ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  } else return true;
}
//必须输入所有可见字符
function inputVisible(handle,keyCode) {

 var pattern = "<,-[]{}?/+=\\\'\":;~!#$%">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.@><,-[]{}?/+=\\\'\":;~!#$%()`";
var keyValue=String.fromCharCode(keyCode);
 if(keyCode==190) keyValue = ".";
 if(keyCode==189) keyValue = "-";
 if(keyCode==188) keyValue = "<";
 if(keyCode==219) keyValue = "[";
 if(keyCode==221) keyValue = "]";
 if(keyCode==191) keyValue = "?";
 if(keyCode==187) keyValue = "+";
 if(keyCode==220) keyValue = "";
 if(keyCode==222) keyValue = "'";
 if(keyCode==186) keyValue = ";";
 if(keyCode==192) keyValue = "~";
 if(pattern.indexOf(keyValue)!=-1) {
  window.event.returnValue=true;
  return true;
 }else{
  window.event.returnValue=false;
  return "必须输入可见字符!即如下字符:<br>ABCDEFGHIJKLMNOPQRSTUVWXYZ<br>abcdefghijklmnopqrstuvwxyz<br>0123456789.@><,-[]{}?/+=\\\'\":<br>;~!#$%()`";
 }
}
//必须输入字母与数字
function inputNormal(handle,keyCode) {
 var pattern = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 var keyValue=String.fromCharCode(keyCode);
 if(pattern.indexOf(keyValue)!=-1) {
  window.event.returnValue=true;
  return true;
 }else{
  window.event.returnValue=false;
  return "必须输入可见字符!即如下字符:<br>ABCDEFGHIJKLMNOPQRSTUVWXYZ<br>abcdefghijklmnopqrstuvwxyz<br>0123456789";
 }
}

//================以下为校验函数区=======================//
//函数名说明:is+TypeName,TypeName首字母大写
//参数handle为当前控件句柄
//参数keyCode为当前按钮的值
//返回说明:通过返回"",不通过返回不通过的原因描述
/*格式支持例表
格式字符           格式描述       格式说明
Number             数字型
Userid             用户ID
Username           用户名称
Enterprisename     企业单位名称
Loginname          登录名称
Cardnumber         证件号码
Address            地址
Phone              电话号码
Mobile             手机号码
Postcode           邮政编码
Email              电子邮件
Namesimplicity     姓名简拼
Password           密码
Namestr            名称字符串
DescStr            描述字符串
Pageurl            页面URL
Dirctory           磁盘路径
*/

//判断是否是数字
 function isNumber(handle){
  var pattern = /^(\d){1,14}$/;
    if (!pattern.exec(handle.value)) return "必须输入数字!";
    return true;
 }
//判断是否是用户账号
 function isUserid(handle){
  var pattern = /^(\d\w){3,14}$/;
    if (!pattern.exec(handle.value)) return "必须输入数字<br>且长度需大于等于3位小于等于14位!";
    return true;
 }
//判断是否用户名称可以是字母也可以是中文
 function isUsername(handle){
  var pattern = /^[a-zA-Z\u4E00-\u9FA5]{2,50}$/;
    if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于2位小于等于50位!"
 return true;
    }
//判断是否是企业名称:可以是字母 数字 中文 - _
    function isEnterprisename(handle){
        var pattern = /^[a-zA-Z0-9-_\u4E00-\u9FA5]{2,200}$/;
        if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于2位小于等于200位!";
        return true;
    }
//判断是否是登录名称
    function isLoginname(handle){
        var pattern = /^([a-z][A-Z][0-9]){2,25}$/;
        if (!pattern.exec(handle.value)) return "必须是字母或者数字<br>且长度需大于等于2位小于等于25位!";
        return true;
 }
//判断是否是证件号码
 function isCardnumber(handle){
   var pattern;
  pattern = /^(\d){5,18}$/;
   if (!pattern.exec(handle.value)) return "必须是数字<br>且长度需大于等于5位小于等于16位!";
   return true;
 }
//地址
 function isAddress(handle){
  var pattern = /^[a-zA-Z0-9\u4E00-\u9FA5]{2,200}$/;
    if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于2位小于等于200位!";
    return true;
 }
//联系电话
 function isPhone(handle){
  var pattern = /^(\d){6,30}$/;
    if (!pattern.exec(handle.value)) return "必须是数字<br>且长度需大于等于6位小于等于30位!";
    return true;
 }
//手机
 function isMobile(handle){
  var pattern = /^[1][3](\d){9}$/;
    if (!pattern.exec(handle.value)) return "必须是数字<br>且首两位是13长度是11位!";
    return true;
 }
//邮编
 function isPostcode(handle){
var pattern = /^(\d){6}$/;
    if (!pattern.exec(handle.value)) return "必须是数字<br>且长度需是6位!";
    return true;
 }
//email

 function isEmail(handle){
  var pattern = /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(\.[a-zA-Z0-9_-])+/;
    if (!pattern.exec(handle.value)) return "必须符合电子邮件地址格式";
    return true;
 }
//简拼
 function isNamesimplicity(handle){
  var pattern = /^([a-zA-Z]){2,25}$/;
    if (!pattern.exec(handle.value)) return "必须是字母<br>且长度需大于等于2位小于等于25位!";
    return true;
 }
//密码
 function isPassword(handle){
  var pattern = /^([a-zA-Z][0-9]){2,25}$/;
    if (!pattern.exec(handle.value)) return "必须是字母或者数字<br>且长度需大于等于2位小于等于25位!";
    return true;
 }
//判断是否是名称:可以是字母 数字 中文 - _
    function isNamestr(handle){
        var pattern = /^[a-zA-Z0-9-_\u4E00-\u9FA5]{1,40}$/;
        if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于1位小于等于40位!";
        return true;
    }
//判断是否是描述信息:可以是字母 数字 中文 - _ , .
    function isDescstr(handle){
        var pattern = /^[a-zA-Z0-9-_,.\u4E00-\u9FA5]{1,50}$/;
        if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于1位小于等于50位!";
        return true;
    }

//页面URL
    function isPageurl(handle){
        var pattern = /^[a-zA-Z0-9-_,./\u4E00-\u9FA5]{1,80}$/;
 if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于`位小于等于80位!";
        return true;
    }

//目录路径
    function isDirctoryurl(handle){
        var pattern = /^[a-zA-Z0-9-_,.\\u4E00-\u9FA5]{1,300}$/;

        if (!pattern.exec(handle.value)) return "必须是中文字母或者数字<br>且长度需大于等于1位小于等于300位!";
        return true;
    }

/*
//高强度身份号码验证
var aCity={11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江",31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"西藏",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外"}
function cidInfo(sId){
 var iSum=0
 var info=""
 if(!/^\d{17}(\dx)$/i.test(sId))return false;
 sId=sId.replace(/x$/i,"a");
 if(aCity[parseInt(sId.substr(0,2))]==null)return "Error:非法地区";
 sBirthday=sId.substr(6,4)+"-"+Number(sId.substr(10,2))+"-"+Number(sId.substr(12,2));
 var d=new Date(sBirthday.replace(/-/g,"/"))
 if(sBirthday!=(d.getFullYear()+"-"+ (d.getMonth()+1) + "-" + d.getDate()))return "Error:非法生日";
 for(var i = 17;i>=0;i --) iSum += (Math.pow(2,i) % 11) * parseInt(sId.charAt(17 - i),11)
 if(iSum%11!=1)return "Error:非法证号";
 return aCity[parseInt(sId.substr(0,2))]+","+sBirthday+","+(sId.substr(16,1)%2?"男":"女")
}

document.write(cidInfo("380524198002300016"),"<br/>");
document.write(cidInfo("340524198002300019"),"<br/>")
document.write(cidInfo("340524197711111111"),"<br/>")
document.write(cidInfo("34052419800101001x"),"<br/>");

function isip(s){
 var check=function(v){try{return (v<=255 && v>=0)}catch(x){return false}};
 var re=s.split(".")
 return (re.length==4)?(check(re[0]) && check(re[1]) && check(re[2]) && check(re[3])):false
}

var s="202.197.78.129";
alert(isip(s))*/

//================以上为校验函数区=======================//

[转载：http://www.regexlab.com/zh/encoding.htm]

级别：初级

摘要：本文将完整，通俗地介绍字符编码，软件国际化等相关概念，也就是编码问题，内容涵盖常说的“中文问题”，“乱码问题”。本文针对亚洲的读者，讲解了产生乱码问题的原理以及解决办法。同时也针对西方的读者，讲解了字符编码的概念，为西方国家的朋友开发国际化软件打一个必要的基础。

引言

“编码问题”是一个被经常讨论的话题。即使这样，时常出现的乱码仍然困扰着大家。虽然有很多的办法可以用来消除乱码，但我们并不一定理解这些办法的内在原理。我们在写出代码并尝试所掌握的办法之前，仍然无法保证乱码不会出现。而有的乱码产生的原因，实际上是 JDBC 驱动或 ODBC 驱动本身有问题所导致的。因此，不仅是初学者会对编码问题感到模糊，不少的编程高手同样对编码问题缺乏准确的理解。

本文将讲解编码问题产生的由来，编码概念的正确理解，各种环节编码的处理办法，以及产生乱码的原因和解决办法。

回页首

1. 编码问题的由来

最早诞生的 ASCII 码只包含了英语字母和一些常用标点符号，编号为0~127。后来制定了扩展 ASCII 码，增加了一些欧洲语言中的字母和其他的一些符号，编号为0~255。在计算机中，使用一个字节来存储一个字母或符号。

随着计算机的发展，各个国家和地区为了能在计算机上使用自己的语言，纷纷研究技术方案和制定相关标准。通常采取的办法是，保留 ASCII 中的0~127部分不变，然后使用128~255范围的2个字节来表示1个字符。比如：汉字‘中’在 GB2312 标准中，使用 [D6][D0] 这两个字节表示。不同的国家和地区制定了不同的标准，由此产生了 GB2312, BIG5, JIS 等各自的编码标准。

这些所有使用 2 个字节来代表一个字符的各种汉字延伸编码方式，称为 ANSI 编码。在简体中文系统下，ANSI 编码代表 GB2312 编码，在繁体中文系统下，ANSI 编码代表 BIG5 编码，在日文操作系统下，ANSI 编码代表 JIS 编码。

这些标准之间互不兼容，比如：在汉语和日语中都有‘中’字，同样为了表示‘中’字，GB2312 使用的两个字节与 JIS 使用的两个字节是不一样的。

回页首

2. 正确的理解相关概念

2.1 字符与字节

在很长一段时间里，计算机只支持英语和欧洲的语言，一个字母或符号就用一个字节表示，字符的含义就相当于字节。比如 C 语言中的一个字符(char)就表示一个字节。当汉语等语言被支持以后，汉字需要使用多个字节表示，因此，字符的含义不再等同于字节。现在我们必须明确区分这两者的概念：

在这里，我们对字符和字节的含义进行了区分。当提到“字符”的时候，我们只需要想到它是一个符号，不要去考虑它在内存中是什么样子。当我们提到“字节”的时候，我们只需要想到它是一个8位二进制数，不要去考虑它表示哪个字符。对于某个字符，不同的编码标准可能会规定不同的字节来表示。因此，单纯的问：“计算机中某个字符是用怎么存储的”这个问题是没有意义的。

在 Java 语言中 char 的含义与在 C 语言中是不同的。Java 中的 char 表示“字符”，代表一个抽象意义上的符号，byte 表示“字节”。而在 C 语言中 char 代表一个字节。

回页首

2.2 字符集，编码

不同的国家和地区所制定的不同标准，都只规定了各自所需的字符。比如：汉字标准（GB2312）中就没有规定韩国语字符的表示办法。这些标准中规定的内容有两层含义：

1. 使用哪些字符：哪些汉字，字母和符号会被收入标准中。所包含字符的集合就叫做“字符集”。
2. 规定每一个字符怎样用字节存储的，这个规定就叫做“编码”。

各个国家和地区在制定编码标准的时候，“字符的集合”和“编码”都是同时制定的。因此，平常我们所说的“字符集”，比如：GB2312, GBK, JIS 等，除了有“字符的集合”这层含义外，同时也包含了“编码”的含义。

回页首

2.3 UNICODE 字符集

不同字符集的编码规则互不兼容。两个不同字符分别属于两个字符集，采用各自编码规则后可能得到相同的字节，因此，当我们想要在计算机中同时表示这两个字符时就无法做到。

为了解决这个问题，使国际间信息交流更加方便，国际组织制定了 UNICODE 字符集。UNICODE 包含了各种语言里面所使用到的所有字符，并为每一个字符赋予了一个唯一的序号。不论在什么平台下，什么程序中，不论用在什么语言里，UNICODE 对同一个字符赋予的序号总是相同的。

与其他“字符集”不同的是，“UNICODE”并不代表一种“编码”，只代表一个“字符的集合”。用来给 UNICODE 字符集编码的标准有很多种，比如：UTF-8, UTF-7, UTF-16, UnicodeLittle, UnicodeBig 等。

回页首

3. 实际应用中编码问题的处理方法

在大家正确理解了相关概念后，以下的章节都是对这些概念在实际应用场合的更深入的讲解。如果你在进行以下章节的过程中，感觉理解比较困难，说明前面所讲的概念你还没有理解正确，有必要回头去复习一下第 2 节中的内容。

3.1 操作系统中的字符串

在 UNICODE 被采用之前，计算机想要记录一段文字，内存中实际存放的内容是：按照指定编码规则得到的字节串。也就是按照 ANSI 编码方式存储在内存中的。比如：在中文 DOS, Windows 95, Windows 98 操作系统中，字符串 "中文123" 存放在内存中时，实际存放的是 [D6][D0][CE][C4][31][32][33] 这7个字节。（'中' 和 '文' 分别占2个字节。）

而在 UNICODE 被采用之后，计算机想要记录一段文字时，内存中不再存放根据特定编码而得到的字节串，而改为存放各个字符在 UNICODE 中的序号。比如：在 Windows NT/2000/XP, Linux, Java 系统中，字符串 "中文123" 存放在内存中时，实际记录的是 20013, 25991, 49, 50, 51 这5个序号。当不同语言中的字符需要同时表示时，不会因为编码冲突而无法表示。

字符串实际所占内存空间的大小，要取决于当前系统采用多少字节来存放一个“序号”。如果使用2个字节存放一个序号，那么 "中文123" 在内存中就占10个字节。如果使用4个字节存放一个序号，那么 "中文123" 就占20个字节。

回页首

3.2 Java, C++ 中的字符与字节

在 Java 和 C++ 中，分别代表字节和字符的数据类型是：

	字节	字符	字节串	字符串
Java	byte	char	byte[]	String
C++	char	wchar_t	char*	char*(ANSI), wchar_t*(UNICODE), CString(Visual C++)

在 Java 中，“字符串”与“字节串”之间可以方便地按照指定编码规则进行转化：

byte [] b = "中文123".getBytes("GB2312"); // 从字符串按照 GB2312 得到字节串 System.out.println(b.length); // 得到长度为7个 (D6,D0,CE,C4,31,32,33) String str = new String(b, "GB2312"); // 从字节串按照 GB2312 得到字符串 System.out.println("中文123".length()); // 得到长度为5，因为是5个字符

在 java.io.* 包里面有很多类，其中，以“Stream”结尾的类都是用来操作“字节串”的类，以“Reader”，“Writer”结尾的类都是用来操作“字符串”的类。任何一个文件保存到硬盘上的时候，都是以字节为单位保存的，当要把“字符串”保存到硬盘上的文本文件，必然要选择一种编码。

有两种方法来指定编码：

String str = "中文123"; // 第一种办法：先用指定编码转化成字节串，然后用 Stream 类写入 OutputStream os = new FileOutputStream("1.txt"); byte [] b = str.getBytes("utf-8"); os.write(b); os.close(); // 第二种办法：构造指定编码的 Writer 来写入字符串 Writer ow = new OutputStreamWriter(new FileOutputStream("2.txt"), "utf-8"); ow.write(str); ow.close(); // 最后得到的 1.txt 和 2.txt 都是 9 个字节。（汉字在 utf-8 编码规则中占3字节）

在 C++ 中，操作字节串（char*）和操作字符串（wchar_t*）各有一套函数。在 Windows API 中，字符串与字节串相互转化的函数是：MultiByteToWideChar() 和 WideCharToMultiByte()。

回页首

3.3 数据库编码

我们在安装数据库的时候，比如安装 MySQL、MS SQL Server、Oracle 时，都会要求选择一种编码。数据库中跟字符串相关的类型有：char, varchar, text, nchar, nvarchar, ntext 等。其中，char, varchar, text 这几种类型的存储方式，是按照所选编码将文本转化为字节进行存储的。char(10) 和 varchar(10) 的长度限制，指的是字节的长度限制。另外的 nchar, nvarchar, ntext 这几种类型的存储方式，是直接按照字符的 UNICODE 序号进行存储的，nchar(10) 和 nvarchar(10) 的长度限制，指的是字符数限制。

比如，在使用 GB2312 编码的 SQL Server 数据库中，对于如下表：

CREATE TABLE TEST(     VAR_10 varchar(10) NULL,     NVAR_10 nvarchar(10) NULL )

能够存储的最大字符串长度分别是：

对于 MySQL 和 Oracle ，细节的地方不一定完全相同。

访问数据库最常用的接口是 JDBC 或者 ODBC。这些访问接口在读取字符串字段时，负责与数据库服务器交互，获知数据库服务器使用的是哪一种编码，并将数据库服务器传输过来的字节流，按照正确的编码还原成“字符”串，然后交给应用程序。

回页首

3.4 网页表单提交时的编码

当网页上的表单（form）提交数据到 Web 服务器时，'?', '&', '=', '%', '+' 等符号在提交的数据中都有特殊的定义和用途。因此，如果所要提交的某个表单项中，包含这些符号，那么这些符号就需要进行一下转化，然后服务器再进行逆向转化而得到本来所要提交的数据。

转化的格式是：%XX （百分号再跟上被转化符号的16进制编码）。比如：'?' 会被转化成 '%3F'，空格 ' ' 会被转化成 '+' 或者 '%20'。

如果所要提交的表单数据中，包含有汉字，那么浏览器会将会将每个汉字根据当前页面所使用的的编码转化成字节，然后将每个字节采用 %XX 的格式提交到服务器。服务器端遇到 %XX 格式的数据时，会根据 XX 编号得到字节，然后再根据同样的编码得到字符串。

举例说明：提交内容“a=%D6%D0%CE%C4%31%32%33”到服务器，通过服务器提供的功能获取表单项“a”得到的内容是：“中文123”。

回页首

3.5 电子邮件中的编码

当一段 Text 或者 HTML 通过电子邮件传送时，发送的内容首先通过一种指定的字符编码转化成“字节串”，然后再将得到的“字节串”通过一种指定的传输编码（Content-Transfer-Encoding）进行转化得到另一串“字节串”。比如，打开一封电子邮件源代码，可以看到：

Content-Type: text/plain;         charset="gb2312" Content-Transfer-Encoding: base64 sbG+qcrQuqO17cf4yee74bGjz9W7+b3wudzA7dbQ0MQNCg0KvPKzxqO6uqO17cnnsaPW0NDEDQoNCg==

当二进制文件，比如图片、word文档等，通过电子邮件发送时，不存在通过字符编码进行转化这个步骤，而是直接按照字节流，通过传输编码（Content-Transfer-Encoding）进行转化得到另一串“字节串”。

Content-Type: application/x-zip-compressed;         name="=?gb2312?B?XEytWy2LzQLnppcA==?=" Content-Transfer-Encoding: base64 Content-Disposition: attachment;         filename="=?gb2312?B?XEytWy2LzQLnppcA==?=" UEsDBAoAAAAAAGNJHzMAAAAAAAAAAAAAAAAJAAAAyO28/rmyz+0vUEsDBBQAAAAIALZ9HjPyoUd36gAA……（省略）

使用传输编码进行转化的目的，主要是为了使电子邮件源代码都处于可打印字符范围之内。

最常用的 Content-Transfer-Encoding 有：Base64 和 Quoted-Printable 两种。在对二进制文件和中文文本进行转化时，Base64 得到的“字节串”比 Quoted-Printable 更短。在英文文本进行转化时，Quoted-Printable 得到的“字节串”比 Base64 更短。

需要注意的是，Base64 和 Quoted-Printable 等编码属于“Content-Transfer-Encoding”，是将“字节串”转化成为另一个“字节串”的编码，与平时提到的 GB2312, BIG5, JIS, UTF8 等字符编码是两种完全不同类型的概念，不能混淆。

邮件标题的表示方法

邮件标题，或者附件的文件名，表示方法为：“=?gb2312?B?XEytWy2LzQLnppcA==?=”，虽然看起来很复杂，其实同样也是“字符编码”与“传输编码”两个概念：

• 第一个“=?”与“?”中间的部分指定了字符编码。
• 第二个“?”和第三个“?”之间的 B 代表 Base64。也有可能是 Q，代表 Quoted-Printable。
• 第三个“?”与最后的“?=”之间的部分就是内容。

在使用 JavaMail 发送邮件时，字符编码和传输编码的指定方法为：

// 设定标题 msg.setSubject("标题 - 测试"); // 设定内容，并指定字符编码 msg.setText   ("内容 - 中文123", "GB2312"); // 指定传输编码 msg.setHeader ("Content-Transfer-Encoding","Quoted-Printable");

将指定传输编码的 setHeader() 位于 setText() 之前，则不能起作用。

回页首

4. 乱码产生的原因及解决办法

一直在微软的平台下进行开发的程序员，很少遇到乱码问题，比如：Visual Basic, ASP, .NET 等。并不是因为他们全都掌握和理解字符与编码的相关技术，而是因为微软的平台没有概念上的错误，所提供的 ODBC 驱动，ASP 引擎，.NET 平台等没有将编码问题遗留给使用者。

而我们常用的很多开源项目，中间往往有一些处理不正确的环节。比如：Tomcat，JDBC，MySQL 等项目。有些乱码产生的根源，就是由这些开源项目中的错误造成的。这些项目大部分参与者都是西方人，他们对怎样支持亚洲语言容易产生一个误解。而 JDK 本身没有问题。

这些遗留的编码问题，留给了本不应该来处理这些问题的广大程序员们，也就是我们。我们中的几乎所有人，在刚开始遇到乱码时，都不知所措。现在，经过大家的努力，虽然我们有了很多方法可以消除乱码，但仍然对编码问题存在误解。在想办法消除乱码时，只能是试，而并不理解。

回页首

4.1 非 UNICODE 软件在国际间移植时显示乱码

非 UNICODE 软件所使用的字符串，在内存中都是以 ANSI 编码方式存储的。软件在日文环境下开发，软件中的字符串常量就是以 JIS 编码的字节形式存储的，软件在简体中文环境下开发，就是以 GB2312 编码的字节形式存储的。软件在运行时，只是直接将这些字节交给系统提供的 API，系统则按照本地 ANSI 编码的字符串来处理。如果运行时的语言环境与开发时不同，界面上显示出来的就是乱码。

相比之下，采用 UNICODE 的软件，字符串常量都是以 UNICODE 的序号来存储的。不管在什么语言环境下，同一个编号都代表同一个符号。因此，采用 UNICODE 的日文软件，在中文操作系统上运行时，仍然可以看到正常的日文界面。

非 UNICODE 软件将逐渐被淘汰。过渡时期，出现了“南极星”“AppLocale”等软件，可以用来在一个语言环境下模拟另一个语言环境，运行在不同环境下开发的软件。

回页首

4.2 东西方人对编码问题通常的误解

东西方人对编码误解是不同的：

	对编码的误解
东方人	一直以来的非 UNICODE 软件开发，字符串都是以 ANSI 编码的字节形式存在的。这种以字节形式存在的字符串，必须知道是哪种编码才能被正确显示。这使我们形成了一个惯性思维：“字符串”的编码。 当 UNICODE 被支持后，Java 中的 String 是以字符的“序号”来存储的，不是以“某种编码的字节”来存储的，因此已经不存在“字符串的编码”这个概念了。只有在“字符串”与“字节串”转化时，或者，将一个“字节串”当成一个 ANSI 字符串时，才有编码的概念。
西方人	西方的同行们，在将“字节串”转化成“字符串”时，容易产生的误解是：认为每“一个字节”就是“一个字符”。而事实上，应该按照编码规则，有可能“多个字节”才能得到“一个字符”。 在字符集标准中，ISO-8859-1 字符集的范围是 0~255，字符与字节的转换关系是：一一对应。 认为每“一个字节”就是“一个字符”而得到的“字符串”，只能再通过 getBytes() 得到了之前的“字节串”，重新进行处理。这就是为什么我们经常使用 str = new String(str.getBytes("ISO-8859-1"), "GB2312"); 的原因。

底层开发的人对编码的误解，导致的乱码的产生。上层人员对编码的误解，导致了消除乱码的复杂性。只要对概念理解正确，乱码问题其实也容易解决。

回页首

4.3 通过 ODBC 或者 JDBC 从数据库获取字符串字段时得到乱码

如果 ODBC 或 JDBC 驱动在读取字符串字段时，没有正确的将数据库发送过来的“字节流”使用正确的“编码”进行转化，所得到的字符串就是乱码。通常的错误同样是：简单的认为每“一个字节”就是“一个字符”。而没有根据数据库所选的编码进行转化。

解决的办法通常是：getBytes("ISO-8859-1") 的到原始的字节，再使用正确的编码重新new String()。

回页首

4.4 Tomcat 中，通过 request.getParameter() 获取表单数据时得到乱码

在 Tomcat 3.3 以前，request.getParameter() 所得到的字符串，都是以每“一个字节”就是“一个字符”的方式返回的。从页面提交到 Tomcat 服务器的中文内容，request.getParameter() 得到的字符串都是乱码。

要得到正确的中文字符串，只能是使用 getBytes("ISO-8859-1") 的到原始的“字节串”，再按照正确的编码重新 new String()。这个乱码问题的产生，是由 Tomcat 自身引起的，采用 new String(str.getBytes("ISO-8859-1"), "GB2312") 这样的用法也是迫不得已。

从 Tomcat 4 以后，request 中增加了一个新的接口方法：request.setCharsetEncoding()。这个方法的作用是：在调用 request.getParameter() 之前，设定与提交页面相同的编码，则可以使 request.getParameter() 返回正确的字符串。

进行实际测试，对于以下的 JSP 页面：

<% request.setCharacterEncoding("GB2312"); response.setContentType("text/html; charset=GB2312"); String aaa = request.getParameter("aaa"); if(aaa != null)     out.print(aaa.length() + " "); out.print(aaa); %> method=POST action="?">   type=text name=aaa>type=submit value=POST> method=GET>   type=text name=aaa>type=submit value=GET>

输入中文，进行提交，实际测试结果如下：

	Tomcat 3.3.2	Tomcat 4.1.31	Tomcat 5.0.28	Tomcat 5.5.9
POST	显示乱码（1）	正确显示中文	正确显示中文	正确显示中文
GET	显示乱码	正确显示中文	显示乱码（2）	显示乱码

（1）	Tomcat 3.3 以前没有 request.setCharacterEncoding() 方法，因此自然得到乱码。
（2）	不知何故，Tomcat 5 以后的 request.setCharacterEncoding() 方法对 GET 方法提交的数据无效，对 POST 提交的数据处理正确。这样的效果还不如 Tomcat 3.3 那样更好。

大多数浏览器都支持的脚本方法 escape()，可以采用汉字的 UNICODE 序号将汉字转化成 %uXXXX 的格式用来提交到服务器。但 Tomcat 的 request.getParameter() 方法不支持这种格式。

回页首

4.5 打开电子邮件，标题或者内容不能正常显示

电子邮件与其它场合不同点就是，除了有“字符编码”外，还有“传输编码”（Content-Transfer-Encoding）。邮件内容中编码的指定方法是：在 MIME 格式的头部分别指定 charset 和 Content-Transfer-Encoding。邮件标题中编码的指定方法是：=?xxx?B?xxxxxxx?= 格式，在一行中简单明了的描述了两种类型的编码以及编码后的标题内容。

如果遇到显示乱码，一种可能是：未指定“字符编码”和“传输编码”，直接将ANSI编码的“字节流”使用在邮件中。另一种可能是：指定了错误的字符编码。

不可避免我们有时会收到一些不规范的电子邮件，解决的办法只能是，选择正确的编码方式来查看。我们在发送邮件的时候，尽可能的按照规范，正确指定“字符编码”和“传输编码”。

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针

malloc（）工作机制

　　malloc函数的实质体现在，它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时，它沿连接表寻找一个大到足以满足用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等，另一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传给用户，并将剩下的那块（如果有的话）返回到连接表上。调用free函数时，它将用户释放的内存块连接到空闲链上。到最后，空闲链会被切成很多的小内存片段，如果这时用户申请一个大的内存片段，那么空闲链上可能没有可以满足用户要求的片段了。于是，malloc函数请求延时，并开始在空闲链上翻箱倒柜地检查各内存片段，对它们进行整理，将相邻的小空闲块合并成较大的内存块。 

malloc（）在操作系统中的实现

　　在 C 程序中，多次使用malloc () 和 free()。不过，您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。
　　在大部分操作系统中，内存分配由以下两个简单的函数来处理：
　　void *malloc (long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。
　　void free(void *firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。

　　malloc_init 将是初始化内存分配程序的函数。它要完成以下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效内存地址，然后建立起指向我们管理的内存的指针。这三个变量都是全局变量：

        

;
        

managed_memory_start;
        

如前所述，被映射的内存的边界（最后一个有效地址）常被称为系统中断点或者 当前中断点。在很多 UNIX? 系统中，为了指出当前系统中断点，必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点，然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码，它将找到当前中断点并初始化我们的变量：

现在，为了完全地管理内存，我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后，我们需要做的是诸如将它们标记为未被使用的等事情，并且，在调用 malloc 时，我们要能够定位未被使用的内存块。因此， malloc 返回的每块内存的起始处首先要有这个结构：

现在，您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构？答案是它们不必知道；在返回指针之前，我们会将其移动到这个结构之后，把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的内存。那样，从调用程序的角度来看，它们所得到的全部是空闲的、开放的内存。然后，当通过 free() 将该指针传递回来时，我们只需要倒退几个内存字节就可以再次找到这个结构。

　　在讨论分配内存之前，我们将先讨论释放，因为它更简单。为了释放内存，我们必须要做的惟一一件事情就是，获得我们给出的指针，回退 sizeof(struct mem_control_block) 个字节，并将其标记为可用的。这里是对应的代码：

如您所见，在这个分配程序中，内存的释放使用了一个非常简单的机制，在固定时间内完成内存释放。分配内存稍微困难一些。我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码：

这就是我们的内存管理器。现在，我们只需要构建它，并在程序中使用它即可.多次调用malloc（）后空闲内存被切成很多的小内存片段，这就使得用户在申请内存使用时，由于找不到足够大的内存空间，malloc（）需要进行内存整理，使得函数的性能越来越低。聪明的程序员通过总是分配大小为2的幂的内存块，而最大限度地降低潜在的malloc性能丧失。也就是说，所分配的内存块大小为4字节、8字节、16字节、18446744073709551616字节，等等。这样做最大限度地减少了进入空闲链的怪异片段（各种尺寸的小片段都有）的数量。尽管看起来这好像浪费了空间，但也容易看出浪费的空间永远不会超过50%。

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

malloc函数
函数声明(函数原型)：
void *malloc(int size);
说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。
从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。比如：
int *p;
p = new int; //返回类型为int* 类型(整数型指针)，分配大小为 sizeof(int);
或：
int* parr;
parr = new int [100]; //返回类型为 int* 类型(整数型指针)，分配大小为 sizeof(int) * 100;
而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。
int* p;
p = (int *) malloc (sizeof(int));
第一、malloc 函数返回的是 void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。
第二、函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。如果你写成：
int* p = (int *) malloc (1);
代码也能通过编译，但事实上只分配了1个字节大小的内存空间，当你往里头存入一个整数，就会有3个字节无家可归，而直接“住进邻居家”！造成的结果是后面的内存中原有数据内容全部被清空。
malloc 也可以达到 new [] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。
比如想分配100个int类型的空间：
int* p = (int *) malloc ( sizeof(int) * 100 ); //分配可以放得下100个整数的内存空间。
另外有一点不能直接看出的区别是，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。
除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

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

有了malloc/free 为什么还要new/delete ？
malloc 与free 是C++/C 语言的标准库函数，new/delete 是C++的运算符。它们都可
用于申请动态内存和释放内存。
对于非内部数据类型的对象而言，光用maloc/free 无法满足动态对象的要求。对象
在创建的同时要自动执行构造函数， 对象在消亡之前要自动执行析构函数。由于
malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数
和析构函数的任务强加于malloc/free。
因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个
能完成清理与释放内存工作的运算符delete。注意new/delete 不是库函数。
我们先看一看malloc/free 和new/delete 如何实现对象的动态内存管理，见示例7-8。
class Obj
{
public :
Obj(void){ cout << “Initialization” << endl; }
~Obj(void){ cout << “Destroy” << endl; }
void Initialize(void){ cout << “Initialization” << endl; }
void Destroy(void){ cout << “Destroy” << endl; }
};
void UseMallocFree(void)
{
Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存
a->Initialize(); // 初始化
//…
a->Destroy(); // 清除工作
free(a); // 释放内存
}
void UseNewDelete(void)
{
Obj *a = new Obj; // 申请动态内存并且初始化
//…
delete a; // 清除并且释放内存
}
示例7-8 用malloc/free 和new/delete 如何实现对象的动态内存管理
类Obj 的函数Initialize 模拟了构造函数的功能，函数Destroy 模拟了析构函数的功
能。函数UseMallocFree 中，由于malloc/free 不能执行构造函数与析构函数，必须调用
成员函数Initialize 和Destroy 来完成初始化与清除工作。函数UseNewDelete 则简单得

多。
所以我们不要企图用malloc/free 来完成动态对象的内存管理，应该用new/delete。
由于内部数据类型的“ 对象”没有构造与析构的过程，对它们而言malloc/free 和
new/delete 是等价的。
既然new/delete 的功能完全覆盖了malloc/free，为什么C++不把malloc/free 淘
汰出局呢？这是因为C++程序经常要调用C 函数，而C 程序只能用malloc/free 管理动
态内存。
如果用free 释放“new 创建的动态对象”，那么该对象因无法执行析构函数而可能
导致程序出错。如果用delete 释放“malloc 申请的动态内存”，理论上讲程序不会出错，
但是该程序的可读性很差。所以new/delete 必须配对使用，malloc/free 也一样。

我们可以把任意类型的文件保存到SQL Server中，在进行例子之前，先建立测试用表格，TestFile.sql：

下面创建上传表单：

一旦提交了表单，我们使用HtmlInputFile类的PostedFile属性来访问我们上载的文件，用HttpPostedFile类的属性和方法来进行读取、保存上载文件和得到上载文件的其它信息。这里我们不使用SaveAs方法，因为它是用来保存文件的。我们要把数据保存到数据库中，我们使用InputStream属性，它用来初始化流来读取我们的数据。同时，我们使用ContentLength来读取文件大小，ContentType读取文件类型。然后创建byte数组，把文件流保存进该数组，然后保存到数据库即可。

保存-----------------------------

public static Connection conn(){
  Connection con = null;
  try {
   Class.forName("com.mysql.jdbc.Driver");
   con = DriverManager.getConnection("jdbc:mysql://localhost:3306/filedb", "root", "root");
   return con;
  } catch (Exception e) {
   e.printStackTrace();
  }
  return null;
 }
 
 public static void storeDB(String strFile)throws Exception{
  File file = new File(strFile);
  String name = file.getName();
  String type = name.substring(name.lastIndexOf("."), name.length());
  long size = file.length();
  byte[] bye = new byte[new Long(size).intValue()];
  FileInputStream fi = new FileInputStream(file);
  fi.read(bye, 0, new Long(size).intValue());
  
  
  PreparedStatement pstmt = null;
  String strSql = "insert into filetable(name,size,type,data)values(?,?,?,?);";
  try{
   pstmt = conn().prepareStatement(strSql);
   pstmt.setString(1,name);
   pstmt.setLong(2, size);
   pstmt.setString(3, type);
   pstmt.setBytes(4, bye);
   System.out.println(pstmt.executeUpdate());
  }catch(Exception e){
   System.out.println("失败");
   e.printStackTrace();
  }
  System.out.println("插入成功");
 }

一旦我们上载成功，我们可以对文件进行浏览：只需要设置页面的MIME类型，然后用Response对象的BinaryWrite()进行输出。

加载：

public static void loadFile(){
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  String strSql = "select id,name,size,type,data from filetable where id = 3;";
  String name = "";
  String type = "";
  long size = 0;
  byte [] bye = null;
  try{
   pstmt = conn().prepareStatement(strSql);
   rs = pstmt.executeQuery();
   while(rs.next()){
    name = rs.getString("name");
    type = rs.getString("type");
    size = rs.getLong("size");
    bye = new byte[new Long(size).intValue()];
    bye = rs.getBytes("data");
   }
  System.out.println("数据操作完毕");
  File file = new File("f:\\"+name);
  FileOutputStream fo = new FileOutputStream(file);
  fo.write(bye, 0, new Long(size).intValue());
  
  fo.flush();
  fo.close();
  }catch(Exception e){
   System.out.println("失败");
   e.printStackTrace();
  }
  System.out.println("加载文件成功");
 }

HtmlParser主要靠Node、AbstractNode和Tag来表达Html，因为Remark和Text相对简单，此处就将其忽略了。

• Node是形成树结构表示HTML的基础，所有的数据表示都是接口Node的实现，Node定义了与页面树结构所表达的页面Page对象，定义了获取父、子、兄弟节点的方法，定义了节点到对应html文本的方法，定义了该节点对应的起止位置，定义了过滤方法，定义了Visitor访问机制。
• AbstractNode是Node的一种具体的类实现，起到构成树形结构的作用，除了同具体Node相关的accetp方法，toString，toHtml，toPlainTextString方法以外，AbstractNode实现了大多基本的方法，使得它的子类，不用理会具体的树操作。
• Tag是具体分析的主要内容。Tag分成composite的Tag和不能包含其他Tag的简单Tag两类，其中前者的基类是CompositeTag，其子类包含BodyTag,Div,FrameSetTag,OptionTag，等27个子类；而简单Tag有BaseHrefTag、DoctypeTag,FrameTag，ImageTag，InputTag，JspTag，MetaTag，ProcessingInstructionTag这八类。

Node分成三类：

• RemarkNode:代表Html中的注释
• TagNode：标签节点，是种类最多的节点类型，上述Tag的具体节点类都是TagNode的实现。
• TextNode：文本节点

• 用一个URL或页面String做一个Parser
• 用这个Parser做一个Visitor
• 使用Parser.visitAllNodeWith(Visitor)来遍历节点
• 获取Visitor遍历后得到的数据

• 做解析之前做的事情：visitor.beginParsing();
• 每次取到一个节点Node，让该Node接受accept该Visitor
• 做解析后做的事情：visitor.finishedParsing();

• 对于所有TagNode都使用一个accept方法，即TagNode的accept方法。首先判断是否是标签结尾，如果是就visitor.visitEndTag (this)；否则visitor.visitTag (this);
• 如果是TextNode，那就visitor.visitStringNode (this);就可以了。
• 如果是RemarkNode，那就visitor.visitRemarkNode (this);就可以了。

实际上NodeVisitor里边这四种visit方法都是空的，因为在不同的Visitor中对于这三类节点的处理是不同的；对于需要处理的节点，只要重载对应的visit方法就行了，如果不处理那就不理会就可以了；另外，如果用户用自己的Visitor，那么还可以灵活的处理不同类型的节点了。

• ObjectFindingVisitor：用来找出所有指定类型的节点，采用getTags()来获取结果。
• StringBean：用来从一个指定的URL获取移除了<SCRIPT></SCRIPT>和<PRE></PRE>之间代码的Html代码，也可以用做Visitor，用来移除这两种标签内部的代码，采用StringBean.getStrings()来获取结果。
• HtmlPage：提取Title，body中的节点和页面中的TableTag节点。
• LinkFindingVisitor:找出节点中包含某个链接的总个数。
• StringFindingVisitor：找出遍历的TextNode中含有指定字符串的个数。
• TagFindingVisitor：找出指定Tag的所有节点，可以指定多种类型。
• TextExtractingVisitor：从网页中把所有标签去掉来提取文本，这个提取文本的Visitor有时是很实用的，只是注意在提取文本时将标签的属性也去掉了，也就是说只剩下标签之间的文本，例如<a>中的链接也去掉了。
• UrlModifyingVisitor：用来修改网页中的链接。

佛学的181条智慧 献给压抑的IT人

一、人之所以痛苦，在于追求错误的东西。　

二、与其说是别人让你痛苦，不如说是自己的修养不够。　

三、如果你不给自己烦恼，别人也永远不可能给你烦恼。因为在你自己的内心，你放不下。

四、好好的管教你自己，不要管别人。

五、不宽恕众生，不原谅众生，是苦了你自己。　

六、别说别人可怜，自己更可怜，自己又懂得人生多少？　

七、学佛是对自己的良心交待，不是做给别人看的。

八、福报不够的人，就会常常听到是非；福报够的人，从来就没听到过是非。　

九、修行是点滴的工夫。　

十、在顺境中修行，永远不能成佛。

十一、你永远要感谢给你逆境的众生。

十二、你随时要认命，因为你是人。

十三、你永远都要宽恕众生，不论他有多坏，甚至他伤害过你，你一定要放下，才能得到真正的快乐。

十四、这个世界本来就是痛苦的，没有例外的。　

十五、当你快乐时，你要想，这快乐不是永恒的。当你痛苦时你要想这痛苦也不是永恒的。

十六、认识自己，降伏自己，改变自己，才能改变别人。

十七、今日的执著，会造成明日的后悔