方法1： 用SET PASSWORD命令

　　mysql -u root

　　mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('newpass');

方法2：用mysqladmin

　　mysqladmin -u root password "newpass"

　　如果root已经设置过密码，采用如下方法

　　mysqladmin -u root password oldpass "newpass"

方法3： 用UPDATE直接编辑user表

　　mysql -u root

　　mysql> use mysql;

　　mysql> UPDATE user SET Password = PASSWORD('newpass') WHERE user = 'root';

　　mysql> FLUSH PRIVILEGES;

在丢失root密码的时候，可以这样

　　mysqld_safe --skip-grant-tables&

　　mysql -u root mysql

　　mysql> UPDATE user SET password=PASSWORD("new password") WHERE user='root';

　　mysql> FLUSH PRIVILEGES;

引言

　　数据库的设计范式是数据库设计所需要满足的规范，满足这些规范的数据库是简洁的、结构明晰的，同时，不会发生插入（insert）、删除（delete）和更新（update）操作异常。反之则是乱七八糟，不仅给数据库的编程人员制造麻烦，而且面目可憎，可能存储了大量不需要的冗余信息。

　　设计范式是不是很难懂呢？非也，大学教材上给我们一堆数学公式我们当然看不懂，也记不住。所以我们很多人就根本不按照范式来设计数据库。

　　实质上，设计范式用很形象、很简洁的话语就能说清楚，道明白。本文将对范式进行通俗地说明，并以笔者曾经设计的一个简单论坛的数据库为例来讲解怎样将这些范式应用于实际工程。

　　范式说明

　　第一范式（1NF）：数据库表中的字段都是单一属性的，不可再分。这个单一属性由基本类型构成，包括整型、实数、字符型、逻辑型、日期型等。

　　例如，如下的数据库表是符合第一范式的：

　　很显然，在当前的任何关系数据库管理系统（DBMS）中，傻瓜也不可能做出不符合第一范式的数据库，因为这些DBMS不允许你把数据库表的一列再分成二列或多列。因此，你想在现有的DBMS中设计出不符合第一范式的数据库都是不可能的。

　　第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖（部分函数依赖指的是存在组合关键字中的某些字段决定非关键字段的情况），也即所有非关键字段都完全依赖于任意一组候选关键字。

　假设仓库管理关系表为StorehouseManage(仓库ID, 存储物品ID, 管理员ID, 数量)，且有一个管理员只在一个仓库工作；一个仓库可以存储多种物品。这个数据库表中存在如下决定关系：

　　(仓库ID, 存储物品ID) →(管理员ID, 数量)

　　(管理员ID, 存储物品ID) → (仓库ID, 数量)

　　所以，(仓库ID, 存储物品ID)和(管理员ID, 存储物品ID)都是StorehouseManage的候选关键字，表中的唯一非关键字段为数量，它是符合第三范式的。但是，由于存在如下决定关系：

　　(仓库ID) → (管理员ID)

　　(管理员ID) → (仓库ID)

　　即存在关键字段决定关键字段的情况，所以其不符合BCNF范式。它会出现如下异常情况：

　　(1) 删除异常：

　　当仓库被清空后，所有"存储物品ID"和"数量"信息被删除的同时，"仓库ID"和"管理员ID"信息也被删除了。

　　(2) 插入异常：

　　当仓库没有存储任何物品时，无法给仓库分配管理员。

　　(3) 更新异常：

　　如果仓库换了管理员，则表中所有行的管理员ID都要修改。

　　把仓库管理关系表分解为二个关系表：

　　仓库管理：StorehouseManage(仓库ID, 管理员ID)；

　　仓库：Storehouse(仓库ID, 存储物品ID, 数量)。

　　这样的数据库表是符合BCNF范式的，消除了删除异常、插入异常和更新异常。

范式应用

　　我们来逐步搞定一个论坛的数据库，有如下信息：

　　（1） 用户：用户名，email，主页，电话，联系地址

　　（2） 帖子：发帖标题，发帖内容，回复标题，回复内容

　　第一次我们将数据库设计为仅仅存在表：
　　

注意：
    当内存表中的数据大于max_heap_table_size设定的容量大小时，mysql会转换超出的数据存储到磁盘上，因此这是性能就大打折扣了，所以我们还需要根据我们的实际情况调整max_heap_table_size，例如在.cnf文件中[mysqld]的下面加入：
        max_heap_table_size = 2048M
    另外在建表语句中还可以通过MAX_ROWS来控制表的记录数。

内存表使用哈希散列索引把数据保存在内存中，因此具有极快的速度，适合缓存中小型数据库，但是使用上受到一些限制，以下是蓝草使用的一些感受。

1、heap对所有用户的连接是可见的，这使得它非常适合做缓存。

2、仅适合使用的场合。heap不允许使用xxxTEXT和xxxBLOB数据类型；只允许使用=和<=>操作符来搜索记录（不允许<、>、<=或>=）；不支持auto_increment；只允许对非空数据列进行索引（not null）。
注：操作符 “<=>” 说明：NULL-safe equal.这个操作符和“=”操作符执行相同的比较操作，不过在两个操作码均为NULL时，其所得值为1而不为NULL，而当一个操作码为NULL时，其所得值为0而不为NULL。

3、一旦服务器重启，所有heap表数据丢失，但是heap表结构仍然存在，因为heap表结构是存放在实际数据库路径下的，不会自动删除。重启之后，heap将被清空，这时候对heap的查询结果都是空的。

4、如果heap是复制的某数据表，则复制之后所有主键、索引、自增等格式将不复存在，需要重新添加主键和索引，如果需要的话。

5、对于重启造成的数据丢失，有以下的解决办法：
　a、在任何查询之前，执行一次简单的查询，判断heap表是否存在数据，如果不存在，则把数据重新写入，或者DROP表重新复制某张表。这需要多做一次查询。不过可以写成include文件，在需要用该heap表的页面随时调用，比较方便。
　b、对于需要该heap表的页面，在该页面第一次且仅在第一次查询该表时，对数据集结果进行判断，如果结果为空，则需要重新写入数据。这样可以节省一次查询。
　c、更好的办法是在mysql每次重新启动时自动写入数据到heap，但是需要配置服务器，过程比较复杂，通用性受到限制。

6、一些预期可能用到的sql语句

//如果表存在，则删除
DROP TABLE IF EXISTS `abc`;
//复制整张表xyz为heap表abc（包含所有数据）
CREATE TABLE `abc` type=heap select * from `xyz`;
//添加主键id
ALTER TABLE `abc` ADD PRIMARY KEY (`id`);
//添加索引username
ALTER TABLE `abc` ADD INDEX `abc` (`username`);
出自蓝草空间

/*连接Sqlite数据库，参数：dbname->数据库名字*/
function Open($dbname) {
if(!($this->link = @sqlite_open($dbname))) {
$this->halt('Can not Open to Sqlite');
}
}

/*执行sql语句，返回对应的结果标识*/
function Query($sql) {
$this->querynum++;
if($query = @sqlite_query($this->link, $sql)) {
return $query;
} else {
$this->halt('Sqlite Query Error', $sql);
}
}

/*执行Insert Into语句，并返回最后的insert操作所产生的自动增长的id*/
function Insert($table, $iarr) {
$value = $this->InsertSql($iarr);
$this->Query('INSERT INTO "' . $table . '" ' . $value);
return sqlite_last_insert_rowid($this->link);
}

/*执行Update语句，并返回最后的update操作所影响的行数*/
function Update($table, $uarr, $condition = '') {
$value = $this->UpdateSql($uarr);
if ($condition) {
$condition = ' WHERE ' . $condition;
}
$this->Query('UPDATE "' . $table . '"' . ' SET ' . $value . $condition);
return sqlite_changes($this->link);
}

/*执行Delete语句，并返回最后的Delete操作所影响的行数*/
function Delete($table, $condition = '') {
if ($condition) {
$condition = ' WHERE ' . $condition;
}
$this->Query('DELETE "' . $table . '"' . $condition);
return sqlite_changes($this->link);
}

/*将字符转为可以安全保存的sqlite值，比如a'a转为a''a*/
/*
function EnCode($str) {
if (strpos($str, "\0") === false) {
if (strpos($str, '\'') === false) {
return $str;
} else {
return str_replace('\'', '\'\'', $str);
}
} else {
$str = str_replace("\0", '', $str);
if (strpos($str, '\'') === false) {
return $str;
} else {
return str_replace('\'', '\'\'', $str);
}
}
}
*/
function EnCode($str) {
return sqlite_escape_string($str);
}

/*将可以安全保存的sqlite值转为正常的值，比如a''a转为a'a*/
function DeCode($str) {
if (strpos($str, '\'\'') === false) {
return $str;
} else {
return str_replace('\'\'', '\'', $str);
}
}

/*将对应的列和值生成对应的insert语句，如：array('id' => 1, 'name' => 'name')返回("id", "name") VALUES (1, 'name')*/
function InsertSql($iarr) {
if (is_array($iarr)) {
$fstr = '';
$vstr = '';
foreach ($iarr as $key => $val) {
$fstr .= '"' . $key . '", ';
$vstr .= '\'' . $val . '\', ';
}
if ($fstr) {
$fstr = '(' . substr($fstr, 0, -2) . ')';
$vstr = '(' . substr($vstr, 0, -2) . ')';
return $fstr . ' VALUES ' . $vstr;
} else {
return '';
}
} else {
return '';
}
}

/*将对应的列和值生成对应的insert语句，如：array('id' => 1, 'name' => 'name')返回"id" = 1, "name" = 'name'*/
function UpdateSql($uarr) {
if (is_array($uarr)) {
$ustr = '';
foreach ($uarr as $key => $val) {
$ustr .= '"' . $key . '" = \'' . $val . '\', ';
}
if ($ustr) {
return substr($ustr, 0, -2);
} else {
return '';
}
} else {
return '';
}
}

/*返回对应的查询标识的结果的一行*/
function GetRow($query, $result_type = SQLITE_ASSOC) {
return sqlite_fetch_array($query, $result_type);
}

/*清空查询结果所占用的内存资源*/
function Clear($query) {
$query = null;
return true;
}

/*关闭数据库*/
function Close() {
return sqlite_close($this->link);
}

function halt($message = '', $sql = '') {
$ei = sqlite_last_error($this->link);
$message .= '<br />Sqlite Error: ' . $ei . ', ' . sqlite_error_string($ei);
if ($sql) {
$sql = '<br />sql:' . $sql;
}
exit('DataBase Error.<br />Message: ' . $message . $sql);
}
}

在生成缩略图的过程当中我们需要用到GD库当中的几个函数：

getimagesize(string filename [,array var])),取得图像的信息，返回值是一人array,包括几项信息$var[0]----返回图像的width,$var[1]----返回height,[2]返回图像文件的type,[4]返回的是与<img src="">当中的wdith,height有关的width="",height=""信息。

imageX(resource image)

imageY(resource image)  返回图像的宽和高

imagecopyresized(des img,src img,int des_x,int des_y,int src_x,int src_y,int des_w,int des_h,int src_w,int src_y)  复制并截取区域图像

imagecreatetruecolor(int width,int height)  创建一个真彩图

imagejpeg(resource image)

下面就是Code:
<?php
# Constants
define(IMAGE_BASE, '/var/www/html/mbailey/images');
define(MAX_WIDTH, 150);
define(MAX_HEIGHT, 150);

# Get image location
$image_file = str_replace('..', '', $_SERVER['QUERY_STRING']);
$image_path = IMAGE_BASE . "/$image_file";

# Load image
$img = null;
$ext = strtolower(end(explode('.', $image_path)));
if ($ext == 'jpg' || $ext == 'jpeg') {
    $img = @imagecreatefromjpeg($image_path);
} else if ($ext == 'png') {
    $img = @imagecreatefrompng($image_path);
# Only if your version of GD includes GIF support
} else if ($ext == 'gif') {
    $img = @imagecreatefrompng($image_path);
}

# If an image was successfully loaded, test the image for size
if ($img) {

    # Get image size and scale ratio
    $width = imagesx($img);
    $height = imagesy($img);
    $scale = min(MAX_WIDTH/$width, MAX_HEIGHT/$height);

    # If the image is larger than the max shrink it
    if ($scale < 1) {
        $new_width = floor($scale*$width);
        $new_height = floor($scale*$height);

        # Create a new temporary image
        $tmp_img = imagecreatetruecolor($new_width, $new_height);

        # Copy and resize old image into new image
        imagecopyresized($tmp_img, $img, 0, 0, 0, 0,
                         $new_width, $new_height, $width, $height);
        imagedestroy($img);
        $img = $tmp_img;
    }
}

# Create error image if necessary
if (!$img) {
    $img = imagecreate(MAX_WIDTH, MAX_HEIGHT);
    imagecolorallocate($img,0,0,0);
    $c = imagecolorallocate($img,70,70,70);
    imageline($img,0,0,MAX_WIDTH,MAX_HEIGHT,$c2);
    imageline($img,MAX_WIDTH,0,0,MAX_HEIGHT,$c2);
}

# Display the image
header("Content-type: image/jpeg");
imagejpeg($img);
?>

我们把上面的Code存储为test.php,然后通过test.php?image name的形式来访问，结果会让你惊喜的，因为在这里你看到了PHP的优点，它可以让ASP相形见绌。

上面的这段代码当中我们通过end(explode(".",$image_path)来取得文件的扩展名，但是我感觉还是不理想。这样是能够取得文件的类型的，因为end()函数会跳到本array的最后一个单元，但是如果我们采用getimagesize()会取得更为强大的专门针对于图像文件的类型。

本程序显示的缩略图是限制宽高都在150内，然后用min()函数来取得它们比值的最小值来计算缩略图的宽和高，并且通过一系列的GD库函数来取得相应的信息，并且呈现给浏览器，当然你也可以写到你所使用的硬盘当中。

好了，这就是PHP的缩略图功能，大家觉得有什么好的意见可以多多拍砖!

 // 读取指定目录内容，返回内容数组
 function list_dir($path="."){
  if(!is_dir($path)) return $this->error_occur(oxooob,__FUNCTION__);
  if(!is_readable($path)) return $this->error_occur(0x0002,$path);
  $dh=@opendir($path);
  $result=array();
  $path=realpath($path);
  //// 保证目录绝对地址后带目录分隔符
  if($path[strlen($path)-1]!=DIRECTORY_SEPARATOR) $path.=DIRECTORY_SEPARATOR;

  // 使用 !== 防止处理名称为 0 或 FALSE 的文件、目录
  while(FALSE!=($fh=readdir($dh))){
   if($fh=="." || $fh=="..") continue;
   $i=$path.$fh;
   $t=array("name"=>$fh,"location"=>$i,"type"=>is_file($i)?1:(is_dir($i)?0:-1));
   $result[]=$t;
  }
  closedir($dh);
  unset($dh,$fh,$t,$i);
  clearstatcache();// 清除文件系统缓存
  return $this->result=$result;
 }
/**
         * @]Method Name[= file_info()
         * @]Purpose[=
         *     获取指定文件或目录的属性
         * @]Parameter[=
         *     string $dir_path 指定目录路径，默认为当前目录
         * @]Return[= mixed 错误返回 FALSE，否则返回
         *     array("name","location","type","size","access","change","modify","read","write"),
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */

 //获取指定文件或目录的属
 function file_info($path="."){
  $path=realpath($path);
  if(!$path) return $this->error_occur(oxoooa,__FUNCTION__);
  $result=array(
   "name"=>substr($path,strpos($path,DIRECTORY_SEPARATOR)+1),
   "location"=>$path,
   "type"=>is_file($i)?1:(is_dir($i)?0:-1),
   "size"=>filesize($path),
   "access"=>fileatime($path),
   "modify"=>filemtime($path),
   "change"=>filectime($path),
   "read"=>is_readable($path),
   "write"=>is_writeable($path)
  );
  clearstatcache();
  return $this->result=$result;
 }
/**
         * @]Method Name[= seek_file()
         * @]Purpose[=
         *     根据正则表达式条件，在相应目录及给定层次的子目录中搜索匹配的文件、目录
         * @]Parameter[=
         *     string $pattern 兼容 PERL 标准的正则表达式指明搜索匹配要求，会添加 /^ $/，默认为 .*
         *     string $path 进行搜索的目录路径，默认为当前路径
         *     enum $seesk_type 有 -1 0 1 三种可能值，0 仅文件夹，1 仅文件，-1 两者都包括，默认为 1
         *     int $sub_dir 搜索的子目录深度，指定目录不算，建议不要超过 5，默认为 0
         *     limit $limit 搜索结果限制，避免过度浪费系统资源，默认为 100
         * @]Return[= mixed 错误返回 FALSE，否则
         *     array(
         *         array(
         *             "name","locate","type"
         *         ),
         *         ......
         *     )
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */

 //根据正则表达式条件，在相应目录及给定层次的子目录中搜索匹配的文件、目录
 function seek_file($path=".*",$path=".",$seek_type=1,$sub_dir_level=0,$limit=100){
  //check parameter
  $is_error=$seek_type!=1&&$seek_type!=0&&$seek_type!=1;
  $is_error=$is_error && (!is_int($sub_dir_level) || $sub_dir_level < 0);
  $is_error = $is_error && (!is_int($limit) || $limit < 1);
        if ($is_error) return $this->error_occur(0x000B, __FUNCTION__);
        unset($is_error);
        $result = array();
        /* array() == FALSE，所以需要使用 === */
        if (FALSE===$i=$this->list_dir($path)) return FALSE; // 如果不能列举目录，返回
        for ($j=0,$k=count($i);$j<$k;$j++) {
             if ($i[$j]["type"]==-1) continue; // 对于非目录非文件项目，跳过
             if ($i[$j]["type"]==0&&$sub_dir_level) { // 如果需要搜索下层目录
                if (FALSE===$l=$this->seek_file($pattern,$i[$j]["location"],$seek_type,($sub_dir_level - 1),$limit)) return FALSE;
                    $result = array_merge($result, $l); // 将下层目录搜索结果添加
                }
                if ($seek_type+$i[$j]["type"]==1||!preg_match("/^".$pattern."$/", $i[$j]["name"])) continue; // 如果不搜索当前类型，跳过
                $result[] = $i[$j];
                if (count($result)>=$limit) { // 截去超过要求的长度，离开列举
                    array_splice($result, $limit);
                    break;
                }
            }
        unset($i, $j, $k, $l);
        return $this->result = $result;

 }
  /*
         * @]Method Name[= delete()
         * @]Purpose[=
         *     删除指定对象，文件或文件夹——包括内含子目录和文件的非空文件夹
         * @]Parameter[=
         *     string $path 指定要删除的内容路径，文件或目录均可
         * @]Return[= boolean 错误返回 FALSE，否则 TRUE
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function delete($path="") {
            $path = realpath($path);
            if (!$path) return $this->error_occur(0x000A, __FUNCTION__);
            if (!is_dir($path)) {
                if (@unlink($path)) return TRUE; // 文件删除成功
                return $this->error_occur(0x0004, $path);
            } else {
                if (FALSE===$i=$this->list_dir($path)) return FALSE; // 不能列举目录
                for ($j=0,$k=count($i);$j<$k;$j++)
                    if (!$this->delete($i[$j]["location"])) return FALSE; // 删除目录内容出错
                unset($i, $j, $k);
                return TRUE;
            }
        }

        /**
         * @]Method Name[= generate_path()
         * @]Purpose[=
         *     获取现有或不存在文件、目录的绝对地址
         * @]Parameter[=
         *     string $path 要获取地址的文件、目录现有相对、绝对地址
         * @]Return[= string 获得的地址
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function generate_path($path="") {
            $i = "/"==DIRECTORY_SEPARATOR ? "\\" : "/"; // 统一目录分割符
            $path = str_replace($i, DIRECTORY_SEPARATOR, strval($path));
            if ($path[strlen($path)-1]!=DIRECTORY_SEPARATOR) $path .= DIRECTORY_SEPARATOR;
            $i = strpos($path, DIRECTORY_SEPARATOR); // 获得路径中首个目录分割符的位置
            $ext = substr($path, $i+1);
            $path = substr($path, 0, $i+1);
            if ($i=realpath($path)) $path = $i; // 得到基本路径
            else {
                $ext = $path.$ext;
                $path = realpath(".");
            }
            if (strlen($ext)) { // 对剩余内容处理
                $ext = preg_replace("/[\:\*\?\"\<\>\|]/", "", explode(DIRECTORY_SEPARATOR, $ext));
                array_pop($ext);
                $path = explode(DIRECTORY_SEPARATOR, $path); // 建立目录层轴
                if ($path[count($path)-1]=="") array_pop($path);
                while (count($ext)) {
                    $i = array_shift($ext);
                    if ($i==".."&&count($path)>1) array_pop($path);
                    elseif (""!=str_replace(".", "", $i)) $path[] = $i;
                }
                $path = implode(DIRECTORY_SEPARATOR, $path);
            }
            unset($ext, $i);
            return $path;
        }

        /**
         * @]Method Name[= make_dir()
         * @]Purpose[=
         *     建立任意文件夹，相对或绝对路径皆可，深层建立亦可
         * @]Parameter[=
         *     string $path 要建立的最终目录路径
         * @]Return[= boolean 错误返回 FALSE，否则 TRUE
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function make_dir($path="") {
            $i = explode(DIRECTORY_SEPARATOR, $this->generate_path($path)); // 生成目录路径
            $path = array_shift($i);
            for ($j=0,$k=count($i);$j<$k;$j++) {
                $path .= DIRECTORY_SEPARATOR.$i[$j];
                if (!is_dir($path)) {
                    if ($this->exist_dir=="") $this->exist_dir = $path; // 记录最后存在的目录路径
                    if (!@mkdir($path)) return $this->error_occur(0x0003, substr($path, 0, strrpos($path, DIRECTORY_SEPARATOR)));
                }
            }
            if ($this->exist_dir=="") $this->exist_dir = $path;
            return TRUE;
        }

        /**
         * @]Method Name[= verify_file()
         * @]Purpose[=
         *     使用 MD5 算法比较两个文件是否相同
         * @]Parameter[=
         *     string $src 源文件路径
         *     string $dst 目标文件路径
         *     boolean $interal 对于超过 1MB 文件，设置 FALSE 省去 MD5 检验步骤，减轻服务器负担
         * @]Return[= boolean 错误返回 FALSE，否则 TRUE
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function verify_file($src="", $dst="", $interal=TRUE) {
            if (!is_file($src)||!is_file($dst)) return $this->error_occur(0x000B, __FUNCTION__);
            if (!is_readable($src)) return $this->error_occur(0x0006, $src);
            if (!is_readable($dst)) return $this->error_occur(0x0006, $dst);
            $i = filesize($src);
            if (filesize($dst)!=$i) { // 文件大小不等
                unset($i);
                return FALSE;
            }
            if ($i>1024*1024*1024&&!$interal) { // 对于 1MB 的文件，如果不要求精确检查，跳过
                unset($i);
                return TRUE;
            }
            unset($i);
            if (md5_file($src)!=md5_file($dst)) return FALSE; // 文件 MD5 效验不符合，内容不相同
            return TRUE;
        }

        /**
         * @]Method Name[= copy()
         * @]Purpose[=
         *     对任意文件夹、文件进行复制，相对或绝对路径皆可，文件复制完成后会进行效验，检查是否出错数据错误
         * @]Parameter[=
         *     string $src_path 指定要复制的源内容路径，文件或目录均可
         *     string $dst_path 指定要复制的目标内容路径，文件或目录均可，性质由 $src_path 决定，可为 $src_path 下层目录
         * @]Return[= boolean 错误返回 FALSE，否则 TRUE
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function copy($src="", $dst="", $sub=FALSE) {
            if (!$src=realpath($src)) return $this->error_occur(0x000B, __FUNCTION__);
            $dst = $this->generate_path($dst);
            if (is_dir($src)) { // 处理目录
                /*
                 * 关于算法的说明：
                 *     本来打算使用很简单的递归算法，遇神杀神，遇魔斩魔的，后来发现一个问题：如果目标路径
                 *   为源路径的后代路径怎么办？这样算法会不停的探测下去…
                 *     于是添加了 $this->exist_dir 属性，用来记录这一情况下目标路径中存在的部分。于是新的问
                 *   题出来了：如何保存这一属性？
                 *     将整个功能整合到 $this->copy() 方法中，那么必然需要在这个函数中记录 $this->exist_dir
                 *   的变化，于是乎需要另外的一个有效的方法来阻止每一次操作中对其的更改。
                 *     作为变通，我使用的隐藏参数 $sub，这个参数无论如何，只要算法不变，永远在参数表的最
                 *   后一个。因此，方法开始变得不稳定，但这也没有办法，只能希望程序员自己不要故意破坏。
                 *     在外部调用时，因为默认 FALSE，所以对 $this->exist_dir 写。内部递归时，显性 TRUE，不
                 *   该属性，保证有效性。
                 */
                if (!is_readable($src)) return $this->error_occur(0x0002, $src);
                if ($dst[strlen($dst)-1]!=DIRECTORY_SEPARATOR) $dst .= DIRECTORY_SEPARATOR;
                if (TRUE===$sub&&$src==$this->exist_dir) return TRUE; // 源路径为记录的目标路径
                if (TRUE!==$sub) $this->exist_dir = ""; // 记录创建目录前目标目录路径中存在的目录路径
                if (!$this->make_dir($dst)) return FALSE; // 创建目录
                if (FALSE===$i=$this->list_dir($src)) return FALSE; // 读取目录出错
                for ($j=0,$k=count($i);$j<$k;$j++) if (!$this->copy($i[$j]["location"], $dst.$i[$j]["name"],TRUE)) return FALSE;
                unset($i, $j, $k);
                RETURN TRUE;
            } else {
                if (!is_readable($src)) return $this->error_occur(0x0006, $src);
                if ($this->verify_file($src,$dst)) return TRUE;
                if (!copy($src,$dst)) return $this->error_occur(0x0007, $dst);
                if (!$this->verify_file($src,$dst)) {
                    @unlink($dst); // 复制文件失败删除新文件
                    return $this->error_occur(0x0007, $dst);
                }
                return TRUE;
            }
        }

        /**
         * @]Method Name[= move()
         * @]Purpose[=
         *     对任意文件夹、文件进行移动，相对或绝对路径皆可，文件移动完成后会进行效验，检查是否出错数据错误
         * @]Parameter[=
         *     string $src_path 指定要移动的源内容路径，文件或目录均可
         *     string $dst_path 指定要移动的目标内容路径，文件或目录均可，性质由 $src_path 决定，可为 $src_path 下层目录
         * @]Return[= boolean 错误返回 FALSE，否则 TRUE
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function move($src="", $dst="", $sub=FALSE) {
            if (!$src=realpath($src)) return $this->error_occur(0x000B, __FUNCTION__);
            $dst = $this->generate_path($dst);
            if (is_dir($src)) { // 处理目录
                if (!is_readable($src)) return $this->error_occur(0x0002, $src);
                if ($dst[strlen($dst)-1]!=DIRECTORY_SEPARATOR) $dst .= DIRECTORY_SEPARATOR;
                if (TRUE===$sub&&$src==$this->exist_dir) return TRUE;
                if (TRUE!==$sub) $this->exist_dir = "";
                if (!$this->make_dir($dst)) return FALSE;
                if (FALSE===$i=$this->list_dir($src)) return FALSE;
                for ($j=0,$k=count($i);$j<$k;$j++) if (!$this->move($i[$j]["location"], $dst.$i[$j]["name"],TRUE)) return FALSE;
                unset($i, $j, $k);
                if (FALSE===strpos($this->exist_dir,$src))
                    if (!@rmdir($src)) return $this->error_occur(0x0004, $src); // 对非目标目录的上层目录，删除
                return TRUE;
            } else {
                if (!is_readable($src)) return $this->error_occur(0x0006, $src);
                if ($this->verify_file($src,$dst)) return TRUE;
                if (!copy($src,$dst)) return $this->error_occur(0x0007, $dst);
                if (!$this->verify_file($src,$dst)) {
                    @unlink($dst);
                    return $this->error_occur(0x0007, $dst);
                }
                if (!@unlink($src)) return $this->error_occur(0x0006, $src); // 删除源文件
                return TRUE;
            }
        }

        /**
         * @]Method Name[= no_comment()
         * @]Purpose[=
         *     清除文件中 C 规范的注释
         * @]Parameter[=
         *     string $path 指定要执行操作的文件
         * @]Return[= boolean 错误返回 FALSE，否则 TRUE
         * @]Author[= SNakeVil <51JS,BU,PHPx> (snakevil@qq.com)
         * @]See[=
         */
        function no_comment($path="") {
            if (!is_file($path)) return $this->error_occur(0x000B, __FUNCTION__);
            if (!is_readable($path)) return $this->error_occur(0x0006, $path);
            if (!is_writeable($path)) return $this->error_occur(0x0007, $path);
            if (!$th=tmpfile()) return $this->error_occur(0x000C, $path); // 创建临时文件
            $fh = fopen($path, "r+b");
            if (!flock($fh,LOCK_EX)) { // 锁定文件
                fclose($fh);
                unset($fh);
                return $this->error_occur(0x0009, $path);
            }
            $fbuffer = fread($fh, $this->buffer_size*2); // 文件读取缓冲区
            $tbuffer = ""; // 临时文件缓冲区
            $in_dq = $in_sq = $in_lc = $in_bc = FALSE;
            while ($fblen=strlen($fbuffer)) { // 处理原始数据
                $fstats = feof($fh);
                for ($i=0;$i<$fblen;$i++) { // 分析文件内容
                    if (!$fstats&&$i+5>$fblen) break; // 文件未完全读取时临近缓冲区读取完成读取下一块文件内容
                    $j = substr($fbuffer, $i, 2);
                    $k = $j[0];
                    if ($j=="/*"&&!$in_dq&&!$in_sq&&!$in_lc) { // 不在字符串和行注释中，块注释开始
                        $in_bc = TRUE;
                        $i++;
                    } elseif ($j=="*/"&&$in_bc) { // 块注释结束
                        $in_bc = FALSE;
                        $i+=2;
                    } elseif ($j=="//"&&!$in_dq&&!$in_sq&&!$in_bc) { // 行注释开始
                        $in_lc = TRUE;
                        $i++;
                    } elseif ($in_lc&&($k=="\r"||$k=="\n")) $in_lc = FALSE; // 行注释结束
                    elseif ($j=="\\\\"||$j=="\\\""||$j=="\\'") { // 转义字符
                        $tbuffer .= $j;
                        $i++;
                        continue;
                    } elseif ($k=="\""&&!$in_sq&&!$in_bc&&!$in_lc) $in_dq = !$in_dq; // 双引号字符串开始、结束
                    elseif ($k=="'"&&!$in_dq&&!$in_bc&&!$in_lc) $in_sq = !$in_sq; // 单引号字符串开始、结束
                    if ($in_lc||$in_bc) continue; // 在注释中，跳过
                    $tbuffer .= $fbuffer[$i];
                }
                $fbuffer = substr($fbuffer, $i); // 抛弃读取过的部分
                unset($i, $j, $k);
                if (!$fstats) $fbuffer .= fread($fh, $this->buffer_size);
                if ($fstats||strlen($tbuffer)>=$this->buffer_size) { // 写入合法数据到临时文件
                    if (!fwrite($th,$tbuffer)) { // 写入失败，空间不足
                        fclose($th);
                        flock($fh, LOCK_UN);
                        fclose($fh);
                        unset($th, $fh, $in_dq, $in_sq, $in_lc, $in_bc, $i, $j, $k);
                        return $this->error_occur(0x000D, "");
                    }
                    $tbuffer = "";
                }
            }
            unset($fbuffer, $tbuffer, $fstats, $in_dq, $in_sq, $in_lc, $in_bc);
            rewind($fh); // 回移文件指针到文件首
            rewind($th);
            $i = $j = "";
            $k = 0;
            while (!feof($th)) { // 将临时文件数据写回源文件
                $i = fgets($th, $this->buffer_size);
                if ($j=="") { // 获得文件系统的换行符
                    $j= substr($i, -2);
                    if ($j=="\r\n") $k = 2;
                    elseif ($j[1]=="\r"||$j[1]=="\n") {
                        $k = 1;
                        $j = $j[1];
                    } else $j = "";
                }
                if (substr($i, -$k)==$j) {
                    $i = rtrim(substr($i, 0, -$k), " \t");
                    if (strlen($i)) fwrite($fh, $i.$j); // 清除右方空格
                    else continue;
                } else fwrite($fh, rtrim($i, " \t"));
            }
            fflush($fh); // 保存、关闭文件
            ftruncate($fh, ftell($fh));
            fclose($th);
            flock($fh, LOCK_UN);
            fclose($fh);
            unset($i, $j, $k, $fh, $th);
            return TRUE;
        }
    /**
     * @]Error List[=
     *     0x0001  指定目录不存在
     *     0x0002  指定目录无读取权限
     *     0x0003  指定目录无写入权限
     *     0x0004  指定目录无删除权限
     *     0x0005  指定文件不存在
     *     0x0006  指定文件无读取权限
     *     0x0007  指定文件无写入权限
     *     0x0008  指定文件无删除权限
     *     0x0009  指定文件无法锁定
     *     0x000A  指定对象不存在
     *     0x000B  方法指定参数不正确
     *     0x000C  无法创建临时文件
     *     0x000D  磁盘空间不足
     *     0x000E 
     *     0x000F 
     *     0x0010 
     *     0x0011 
     *    
     */
}

;?>

php

原作者：epsilon7 
//SonyMusic(sonymusic@163.net) 

 BrowserDetector { 

/*

 

 BrowserDetector(){ 

(HTTP_USER_AGENT); 

; 

; 

); 

) { 

)); 

UA)); 

); 

) { 

); 
} 
} 

 { 

UA; 
} 

; 

)); 

) { 

) { 
} 

)) { 

; 
} 

)) { 

; 
} 

)) { 

; 
} 

)) { 

; 
} 

)) { 

; 
} 

); 
} 

); 

) { 

)); 
} 

; 

) { 

; 

)); 
} 

) { 

; 

)); 
} 

) { 

; 

)); 
} 

) { 

; 

)); 
} 

) { 

; 

)); 
} 

); 

); 

) { 

); 
} 

 { 

; 
} 

); 

) { 

); 

VERSION)); 
} 

 { 

VERSION; 
} 
} 
} 

 browserdetector; 

; 

; 

; 

; 

; 

; 

 

<?php
//原作者：epsilon7
//SonyMusic(sonymusic@163.net)
class BrowserDetector {
var $UA = ""; //$HTTP_USER_AGENT的内容
var $BROWSER= "Unknown"; //浏览器类型
var $PLATFORM = "Unknown"; //操作系统
var $VERSION= ""; //浏览器版本号
var $MAJORVER = ""; //浏览器主版本号
var $MINORVER = ""; //浏览器副版本号
/* 构造函数开始 */
function BrowserDetector(){
$this->UA = getenv(HTTP_USER_AGENT);
$preparens = "";
$parens = "";
$i = strpos($this->UA,"(");
if ($i >= 0) {
$preparens = trim(substr($this->UA,0,$i));
$parens = substr($this->UA,$i+1,strlen($this->UA));
$j = strpos($parens,")");
if($j>=0) {
$parens = substr($parens,0,$j);
}
}
else {
$preparens = $this->UA;
}
$browVer = $preparens;
$token = trim(strtok($parens,";"));
while($token) {
if($token=="compatible") {
}
elseif(preg_match("/MSIE/i","$token")) {
$browVer = $token;
}
elseif(preg_match("/Opera/i","$token")) {
$browVer = $token;
}
elseif(preg_match("/X11/i","$token") || preg_match("/SunOS/i","$token") || preg_match ("/Linux/i","$token")) {
$this->PLATFORM = "Unix";
}
elseif(preg_match("/Win/i","$token")) {
$this->PLATFORM = $token;
}
elseif(preg_match("/Mac/i","$token") || preg_match("/PPC/i","$token")) {
$this->PLATFORM = $token;
}
$token = strtok(";");
}
$msieIndex = strpos($browVer,"MSIE");
if($msieIndex >= 0) {
$browVer = substr($browVer,$msieIndex,strlen($browVer));
}
$leftover = "";
if(substr($browVer,0,strlen("Mozilla")) == "Mozilla") {
$this->BROWSER = "Netscape";
$leftover=substr($browVer,strlen("Mozilla")+1,strlen($browVer));
}
elseif(substr($browVer,0,strlen("Lynx")) == "Lynx") {
$this->BROWSER = "Lynx";
$leftover=substr($browVer,strlen("Lynx")+1,strlen($browVer));
}
elseif(substr($browVer,0,strlen("MSIE")) == "MSIE") {
$this->BROWSER = "IE";
$leftover=substr($browVer,strlen("MSIE")+1,strlen($browVer));
}
elseif(substr($browVer,0,strlen("Microsoft Internet Explorer")) == "Microsoft Internet Explorer") {
$this->BROWSER = "IE";
$leftover=substr($browVer,strlen("Microsoft Internet Explorer")+1,strlen($browVer));
}
elseif(substr($browVer,0,strlen("Opera")) == "Opera") {
$this->BROWSER = "Opera";
$leftover=substr($browVer,strlen("Opera")+1,strlen($browVer));
}
$leftover = trim($leftover);
$i=strpos($leftover," ");
if($i > 0) {
$this->VERSION = substr($leftover,0,$i);
}
else {
$this->VERSION = $leftover;
}
$j = strpos($this->VERSION,".");
if($j >= 0) {
$this->MAJORVER = substr($this->VERSION,0,$j);
$this->MINORVER = substr($this->VERSION,$j+1,strlen($this->VERSION));
}
else {
$this->MAJORVER = $this->VERSION;
}
}
}

//测试程序开始
$test=new browserdetector;
echo $test->UA."<br>";
echo $test->BROWSER."<br>";
echo $test->PLATFORM."<br>";
echo $test->VERSION."<br>";
echo $test->MAJORVER."<br>";
echo $test->MINORVER."<br>";
?>

************************************
    mysql连接类实现 -write by 三千
 *************************************

 

 使用方法(可以执行一般mysql命令,insert, delete select  update)
 在文件前,需要加载方法
 require("mysql.class.php")
 $db=new dbMysql; 加载类
 $db->dbServer="localhost";
 $db->dbUser="root";
 $db->dbPwd="";
 $db->dbDatabase="";
 $db->dbConnect();

 query($sql,$database);
 query_first($sql,$database);
 fetch_array($sql,$database);
 count_records($table,$index,$where,$database);)//为得到一个表记录的数目，$table为表名，$index为key，$where为条件，$dbbase为数据库，后两个可以不选
 

 

 db_Mysql
 {
  
  

;
  

;
  

; 
  

;
  

;
  

;
  

;
  

 传回query命令所影响的列数目
                  // INSERT、UPDATE 或 DELETE 所影响的列 (row) 数目。
                  // delete 如果不带where，那么则返回0

)
  {
   

)
    

    

short connect
   //$this->dbhalt($this->dbbase);

);
   

dbDatabase;
   

dbLink))
    

);
  } 

 end func() connect database
  //change database

){
   

);
  
  }
  

){
   

);
   

);
   

query_id;
  }
  

){
   

);
   

);
   

);
   

);
   

;
  }
  

){
   

database is wrong!

;
   

;
   

;
   

();
  }
  

){
   

);
   

);
   

){
    

)
     

);
    

     

);
   }
   

);
   

;
  }
  

){
   

);
   

dbLink);
   

);
  }
  

){
   

);
   

dbLink);
   

dbLink);
   

);
  }
  

){
   

);
   

dbLink);
   

dbLink);
   

);
  }
  

){
   

);
   

dbLink);
   

);
    

);
   

;
  }
  

){
   

);
   

;
  }
  

){
   @

);
  }
  

 dbclose(){
   

dbLink);
  }
 } 

 db_Mysql;
 

;
 

;
 

;
 

; 

/*************************************
    mysql连接类实现 -write by 三千
 **************************************/
 /*
 使用方法(可以执行一般mysql命令,insert, delete select  update)
 在文件前,需要加载方法
 require("mysql.class.php")
 $db=new dbMysql; 加载类
 $db->dbServer="localhost";
 $db->dbUser="root";
 $db->dbPwd="";
 $db->dbDatabase="";
 $db->dbConnect();

 query($sql,$database);
 query_first($sql,$database);
 fetch_array($sql,$database);
 count_records($table,$index,$where,$database);)//为得到一个表记录的数目，$table为表名，$index为key，$where为条件，$dbbase为数据库，后两个可以不选
 */

 class db_Mysql
 {
 
  var $usepconnect;
  var $dbSever;
  var $dbDatabase;
  var $dbbase;
  var $dbUser;
  var $dbPwd;
  var $dbLink;
  var $query_id;// 执行query命令的指针
  var $num_rows;// 返回的条目数
  var $insert_id;// 传回最后一次使用 INSERT 指令的 ID
  var $affected_rows;// 传回query命令所影响的列数目
                  // INSERT、UPDATE 或 DELETE 所影响的列 (row) 数目。
                  // delete 如果不带where，那么则返回0
  function dbconnect($dbbase,$usepconnect)
  {
   //global $usepconnect;
   if($usepconnect==1)
    $this->dbLink=@mysql_pconnect($this->dbServer,$this->dbUser,$this->dbPwd);//long connect
   else
    $this->dbLink=@mysql_connect($this->dbServer,$this->dbUser,$this->dbPwd);//short connect
   //$this->dbhalt($this->dbbase);
   if(!$this->dbLink) $this->dbhalt("exsiting error when connecting!");
   if($this->dbbase=="") $this->dbbase=$this->dbDatabase;
   if(!@mysql_select_db($this->dbbase,$this->dbLink))
    $this->dbhalt("can't use this database,please check database!");
  } // end func() connect database
  //change database
  function dbchange_db($dbbase){
   $this->dbconnect($dbbase);
 
  }
  function dbquery($sql){
   //if($dbbase!="") $this->dbchange_db($dbbase);
   $this->query_id=mysql_query($sql);
   //print($query_id);
   if(!$this->query_id) $this->dbhalt("wrong sql sentence!".$sql);
   return $this->query_id;
  }
  function dbquery_first($sql,$dbbase){
   $query_id=dbquery($sql,$dbbase);
   $returnarray=mysql_fetch_array($query_id);
   $this->num_rows=mysql_num_rows($query_id);
   $this->dbfree_result($query_id);
   return $returnarray;
  }
  function dbhalt($errmsg){
   $msg="

database is wrong!

";
   $msg=$errmsg;
   echo"$msg";
   die();
  }
  function dbfetch_array($sql,$dbbase,$type){
   $query_id=$this->dbquery($sql,$dbbase);
   $this->numrows=mysql_num_rows($query_id);
   for($i=0;$i<$this->numrows;$i++){
    if($type==0)
     $array[$i]=mysql_fetch_array($query_id);
    else
     $array[$i]=mysql_fetch_array($query_id);
   }
   $this->dbfree_result($query_id);
   return $array;
  }
  function dbdelete($sql,$dbdase){
   $query_id=$this->dbquery($sql,$dbbase);
   $this->affected_rows=mysql_affected_rows($this->dbLink);
   $this->free_reuslt($query_id);
  }
  function dbinsert($sql,$dbbase){
   $query_id=$this->dbquery($sql,$dbbase);
   $this->insert_id=mysql_insert_id($this->dbLink);
   $this->affected_rows=mysql_affected_rows($this->dbLink);
   $this->free_reuslt($query_id);
  }
  function dbupdate($sql,$dbbase){
   $query_id=$this->dbquery($sql,$dbbase);
   $this->insert_id=mysql_insert_id($this->dbLink);
   $this->affected_rows=mysql_affected_rows($this->dbLink);
   $this->free_reuslt($query_id);
  }
  function dbcount_records($table,$index="id",$where="",$dbbase){
   if($dbbase!="")$this->dbchangedb($dbbase);
   $result=@mysql_query("select count(".$index.") as 'num' form".$table."where".$where,$this->dbLink);
   if(!$result) $this->dbhalt("wrong sql sentence".$sql);
    $num=@mysql_result($result,0,"num");
   return $num;
  }
  function dbgetnum($result){
   $num=@mysql_numrows($result);
   return $num;
  }
  function dbfree_result($result_id){
   @mysql_free_result($query_id);
  }
  function dbclose(){
   mysql_close($this->dbLink);
  }
 } // end class
 $db=new db_Mysql;
 $db->dbServer="localhost";
 $db->dbUser="root";
 $db->dbPwd="";
 $db->dbbase="test";

?>

function  checkIP2(sIPAddress)
{
     var   exp =/^ (\d{ 1 , 2 } | 1 \d\d | 2 [ 0 - 4 ]\d | 25 [ 0 - 5 ])\ . (\d{ 1 , 2 } | 1 \d\d | 2 [ 0 - 4 ]\d | 25 [ 0 -

5 ])\ . (\d{ 1 , 2 } | 1 \d\d | 2 [ 0 - 4 ]\d | 25 [ 0 - 5 ])\ . (\d{ 1 , 2 } | 1 \d\d | 2 [ 0 - 4 ]\d | 25 [ 0 - 5 ])$ / ;
     var  reg  =  sIPAddress . match( exp );
     var  ErrMsg = " 你输入的是一个非法的IP地址段！\nIP段为：:xxx.xxx.xxx.xxx（xxx

为0-255)！ "     
     var  Msg = " 你输入的是一个合法的IP地址段！ "     
     if (reg == null )
    {
        alert(ErrMsg);
    }
     else
    {
        alert(reg);
    }
}

function checkIP2(sIPAddress)
{
    var exp=/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-

5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/;
    var reg = sIPAddress.match(exp);
    var ErrMsg="你输入的是一个非法的IP地址段！\nIP段为：:xxx.xxx.xxx.xxx（xxx

为0-255)！"   
    var Msg="你输入的是一个合法的IP地址段！"   
    if(reg==null)
    {
        alert(ErrMsg);
    }
    else
    {
        alert(reg);
    }
}

　　在数据库领域内，常常把使用数据库的各类系统统称为数据库应用系统。

一、数据库和信息系统
　　(1)数据库是信息系统的核心和基础，把信息系统中大量的数据按一定的模型组织起来，提供存储、维护、检索数据的
　   　功能，使信息系统可以方便、及时、准确地从数据库中获得所需的信息。
　　(2)数据库是信息系统的各个部分能否紧密地结合在一起以及如何结合的关键所在。
　　(3)数据库设计是信息系统开发和建设的重要组成部分。
　　(4)数据库设计人员应该具备的技术和知识：
　　　 　数据库的基本知识和数据库设计技术
　　　　 计算机科学的基础知识和程序设计的方法和技巧
　　　 　软件工程的原理和方法
　　　　 应用领域的知识

二、数据库设计的特点
　　数据库建设是硬件、软件和干件的结合
　　　三分技术，七分管理，十二分基础数据
　　　技术与管理的界面称之为“干件”
　　数据库设计应该与应用系统设计相结合
　　　结构（数据）设计：设计数据库框架或数据库结构
　　　行为（处理）设计：设计应用程序、事务处理等
　　结构和行为分离的设计
　　　传统的软件工程忽视对应用中数据语义的分析和抽象，只要有可能就尽量推迟数据结构设计的决策早期的数据库设计致力于数据模型和建模方法研究，忽视了对行为的设计
　　如图：

　　　　　　   　
三、数据库设计方法简述
　　手工试凑法
　　　设计质量与设计人员的经验和水平有直接关系
　　　缺乏科学理论和工程方法的支持，工程的质量难以保证
　　　数据库运行一段时间后常常又不同程度地发现各种问题，增加了维护代价
　　规范设计法
　　　手工设计方
　　　基本思想
　　过程迭代和逐步求精
　　规范设计法(续)
　　典型方法：
　　(1)新奥尔良（New Orleans）方法：将数据库设计分为四个阶段
　　　　S.B.Yao方法：将数据库设计分为五个步骤
　　　　I.R.Palmer方法：把数据库设计当成一步接一步的过程
　　(2)计算机辅助设计
　　　　ORACLE Designer 2000
　　　　SYBASE PowerDesigner

四、数据库设计的基本步骤
　　数据库设计的过程(六个阶段)
　  1.需求分析阶段
　　　准确了解与分析用户需求（包括数据与处理）
　　　是整个设计过程的基础，是最困难、最耗费时间的一步
　　2.概念结构设计阶段
　　　是整个数据库设计的关键
　　　通过对用户需求进行综合、归纳与抽象，形成一个独立于具体DBMS的概念模型
　　3.逻辑结构设计阶段
　　　将概念结构转换为某个DBMS所支持的数据模型
　　　对其进行优化
　　4.数据库物理设计阶段
　　　为逻辑数据模型选取一个最适合应用环境的物理结构（包括存储结构和存取方法）
　　5.数据库实施阶段
　　　运用DBMS提供的数据语言、工具及宿主语言，根据逻辑设计和物理设计的结果
　　　建立数据库，编制与调试应用程序，组织数据入库，并进行试运行
　　6.数据库运行和维护阶段
　　　数据库应用系统经过试运行后即可投入正式运行。
　　　在数据库系统运行过程中必须不断地对其进行评价、调整与修改
　　设计特点:
　　　在设计过程中把数据库的设计和对数据库中数据处理的设计紧密结合起来将这两个方面的需求分析、抽象、设计、实现在各个阶段同时进行，相互参照，相互补充，以完善两方面的设计

　　设计过程各个阶段的设计描述：
　　如图：
         

五、数据库各级模式的形成过程
　　1.需求分析阶段：综合各个用户的应用需求
　　2.概念设计阶段：形成独立于机器特点，独立于各个DBMS产品的概念模式(E-R图)
　　3.逻辑设计阶段：首先将E-R图转换成具体的数据库产品支持的数据模型，如关系模型，形成数据库逻辑模式；然后根据用户处理的要求、安全性的考虑，在基本表的基础上再建立必要的视图(View)，形成数据的外模式
　　4.物理设计阶段：根据DBMS特点和处理的需要，进行物理存储安排，建立索引，形成数据库内模式

六、数据库设计技巧

　　1. 设计数据库之前（需求分析阶段）
　　1) 理解客户需求，询问用户如何看待未来需求变化。让客户解释其需求，而且随着开发的继续，还要经常询问客户保证其需求仍然在开发的目的之中。
　　2) 了解企业业务可以在以后的开发阶段节约大量的时间。
　　3) 重视输入输出。
　　在定义数据库表和字段需求（输入）时，首先应检查现有的或者已经设计出的报表、查询和视图（输出）以决定为了支持这些输出哪些是必要的表和字段。
　　举例：假如客户需要一个报表按照邮政编码排序、分段和求和，你要保证其中包括了单独的邮政编码字段而不要把邮政编码糅进地址字段里。
　　4) 创建数据字典和ER 图表
　　ER 图表和数据字典可以让任何了解数据库的人都明确如何从数据库中获得数据。ER图对表明表之间关系很有用，而数据字典则说明了每个字段的用途以及任何可能存在的别名。对SQL 表达式的文档化来说这是完全必要的。
　　5) 定义标准的对象命名规范
　　数据库各种对象的命名必须规范。

　　2. 表和字段的设计（数据库逻辑设计）
　　表设计原则
　　1) 标准化和规范化
　　数据的标准化有助于消除数据库中的数据冗余。标准化有好几种形式，但Third Normal Form（3NF）通常被认为在性能、扩展性和数据完整性方面达到了最好平衡。简单来说，遵守3NF 标准的数据库的表设计原则是：“One Fact in One Place”即某个表只包括其本身基本的属性，当不是它们本身所具有的属性时需进行分解。表之间的关系通过外键相连接。它具有以下特点：有一组表专门存放通过键连接起来的关联数据。
　　举例：某个存放客户及其有关定单的3NF 数据库就可能有两个表：Customer 和Order。Order 表不包含定单关联客户的任何信息，但表内会存放一个键值，该键指向Customer 表里包含该客户信息的那一行。
　　事实上，为了效率的缘故，对表不进行标准化有时也是必要的。
　　2) 数据驱动
　　采用数据驱动而非硬编码的方式，许多策略变更和维护都会方便得多，大大增强系统的灵活性和扩展性。
　　举例，假如用户界面要访问外部数据源（文件、XML 文档、其他数据库等），不妨把相应的连接和路径信息存储在用户界面支持表里。还有，如果用户界面执行工作流之类的任务（发送邮件、打印信笺、修改记录状态等），那么产生工作流的数据也可以存放在数据库里。角色权限管理也可以通过数据驱动来完成。事实上，如果过程是数据驱动的，你就可以把相当大的责任推给用户，由用户来维护自己的工作流过程。
　　3) 考虑各种变化
　　在设计数据库的时候考虑到哪些数据字段将来可能会发生变更。
　　举例，姓氏就是如此（注意是西方人的姓氏，比如女性结婚后从夫姓等）。所以，在建立系统存储客户信息时，在单独的一个数据表里存储姓氏字段，而且还附加起始日和终止日等字段，这样就可以跟踪这一数据条目的变化。

　　字段设计原则
　　4) 每个表中都应该添加的3 个有用的字段
dRecordCreationDate，在VB 下默认是Now()，而在SQL Server 　　• 下默认为GETDATE()
sRecordCreator，在SQL Server 下默认为NOT NULL DEFAULT 　　• USER
nRecordVersion，记录的版本标记；有助于准确说明记录中出现null 数据或者丢失数据的原因 　　•
　　5) 对地址和电话采用多个字段
　　描述街道地址就短短一行记录是不够的。Address_Line1、Address_Line2 和Address_Line3 可以提供更大的灵活性。还有，电话号码和邮件地址最好拥有自己的数据表，其间具有自身的类型和标记类别。
　　6) 使用角色实体定义属于某类别的列
　　在需要对属于特定类别或者具有特定角色的事物做定义时，可以用角色实体来创建特定的时间关联关系，从而可以实现自我文档化。
　　举例：用PERSON 实体和PERSON_TYPE 实体来描述人员。比方说，当John Smith, Engineer 提升为John Smith, Director 乃至最后爬到John Smith, CIO 的高位，而所有你要做的不过是改变两个表PERSON 和PERSON_TYPE 之间关系的键值，同时增加一个日期/时间字段来知道变化是何时发生的。这样，你的PERSON_TYPE 表就包含了所有PERSON 的可能类型，比如Associate、Engineer、Director、CIO 或者CEO 等。还有个替代办法就是改变PERSON 记录来反映新头衔的变化，不过这样一来在时间上无法跟踪个人所处位置的具体时间。
　　7) 选择数字类型和文本类型尽量充足
　　在SQL 中使用smallint 和tinyint 类型要特别小心。比如，假如想看看月销售总额，总额字段类型是smallint，那么，如果总额超过了$32,767 就不能进行计算操作了。
　　而ID 类型的文本字段，比如客户ID 或定单号等等都应该设置得比一般想象更大。假设客户ID 为10 位数长。那你应该把数据库表字段的长度设为12 或者13 个字符长。但这额外占据的空间却无需将来重构整个数据库就可以实现数据库规模的增长了。
　　8) 增加删除标记字段
　　在表中包含一个“删除标记”字段，这样就可以把行标记为删除。在关系数据库里不要单独删除某一行；最好采用清除数据程序而且要仔细维护索引整体性。

　　3. 选择键和索引（数据库逻辑设计）
　　键选择原则：
　　1) 键设计4 原则
为关联字段创建外键。 　　•
所有的键都必须唯一。 　　•
避免使用复合键。 　　•
外键总是关联唯一的键字段。 　　•
　　2) 使用系统生成的主键
　　设计数据库的时候采用系统生成的键作为主键，那么实际控制了数据库的索引完整性。这样，数据库和非人工机制就有效地控制了对存储数据中每一行的访问。采用系统生成键作为主键还有一个优点：当拥有一致的键结构时，找到逻辑缺陷很容易。
　　3) 不要用用户的键(不让主键具有可更新性)
　　在确定采用什么字段作为表的键的时候，可一定要小心用户将要编辑的字段。通常的情况下不要选择用户可编辑的字段作为键。
　　4) 可选键有时可做主键
　　把可选键进一步用做主键，可以拥有建立强大索引的能力。

　　索引使用原则：
　　索引是从数据库中获取数据的最高效方式之一。95%的数据库性能问题都可以采用索引技术得到解决。
　　1) 逻辑主键使用唯一的成组索引，对系统键（作为存储过程）采用唯一的非成组索引，对任何外键列采用非成组索引。考虑数据库的空间有多大，表如何进行访问，还有这些访问是否主要用作读写。
　　2) 大多数数据库都索引自动创建的主键字段，但是可别忘了索引外键，它们也是经常使用的键，比如运行查询显示主表和所有关联表的某条记录就用得上。
　　3) 不要索引memo/note 字段，不要索引大型字段（有很多字符），这样作会让索引占用太多的存储空间。
　　4) 不要索引常用的小型表
　　不要为小型数据表设置任何键，假如它们经常有插入和删除操作就更别这样作了。对这些插入和删除操作的索引维护可能比扫描表空间消耗更多的时间。

　　4. 数据完整性设计（数据库逻辑设计）
　　1) 完整性实现机制：
　　实体完整性：主键
　　参照完整性：
　　父表中删除数据：级联删除；受限删除；置空值
　　父表中插入数据：受限插入；递归插入
　　父表中更新数据：级联更新；受限更新；置空值
　　DBMS对参照完整性可以有两种方法实现：外键实现机制（约束规则）和触发器实现机制
　　用户定义完整性：
　　NOT NULL；CHECK；触发器
　　2) 用约束而非商务规则强制数据完整性
　　采用数据库系统实现数据的完整性。这不但包括通过标准化实现的完整性而且还包括数据的功能性。在写数据的时候还可以增加触发器来保证数据的正确性。不要依赖于商务层保证数据完整性；它不能保证表之间（外键）的完整性所以不能强加于其他完整性规则之上。
　　3) 强制指示完整性
　　在有害数据进入数据库之前将其剔除。激活数据库系统的指示完整性特性。这样可以保持数据的清洁而能迫使开发人员投入更多的时间处理错误条件。
　　4) 使用查找控制数据完整性
　　控制数据完整性的最佳方式就是限制用户的选择。只要有可能都应该提供给用户一个清晰的价值列表供其选择。这样将减少键入代码的错误和误解同时提供数据的一致性。某些公共数据特别适合查找：国家代码、状态代码等。
　　5) 采用视图
　　为了在数据库和应用程序代码之间提供另一层抽象，可以为应用程序建立专门的视图而不必非要应用程序直接访问数据表。这样做还等于在处理数据库变更时给你提供了更多的自由。

　　5. 其他设计技巧
　　1) 避免使用触发器
　　触发器的功能通常可以用其他方式实现。在调试程序时触发器可能成为干扰。假如你确实需要采用触发器，你最好集中对它文档化。
　　2) 使用常用英语（或者其他任何语言）而不要使用编码
　　在创建下拉菜单、列表、报表时最好按照英语名排序。假如需要编码，可以在编码旁附上用户知道的英语。
　　3) 保存常用信息
　　让一个表专门存放一般数据库信息非常有用。在这个表里存放数据库当前版本、最近检查/修复（对Access）、关联设计文档的名称、客户等信息。这样可以实现一种简单机制跟踪数据库，当客户抱怨他们的数据库没有达到希望的要求而与你联系时，这样做对非客户机/服务器环境特别有用。
　　4) 包含版本机制
　　在数据库中引入版本控制机制来确定使用中的数据库的版本。时间一长，用户的需求总是会改变的。最终可能会要求修改数据库结构。把版本信息直接存放到数据库中更为方便。
　　5) 编制文档
　　对所有的快捷方式、命名规范、限制和函数都要编制文档。
　　采用给表、列、触发器等加注释的数据库工具。对开发、支持和跟踪修改非常有用。
　　对数据库文档化，或者在数据库自身的内部或者单独建立文档。这样，当过了一年多时间后再回过头来做第2 个版本，犯错的机会将大大减少。
　　6) 测试、测试、反复测试
　　建立或者修订数据库之后，必须用用户新输入的数据测试数据字段。最重要的是，让用户进行测试并且同用户一道保证选择的数据类型满足商业要求。测试需要在把新数据库投入实际服务之前完成。
　　7) 检查设计
　　在开发期间检查数据库设计的常用技术是通过其所支持的应用程序原型检查数据库。换句话说，针对每一种最终表达数据的原型应用，保证你检查了数据模型并且查看如何取出数据。

If you love someone, set him/her free.

If he/she comes back to you,it's meant to be.

　　mysqldump -u wcnc -p smgp_apps_wcnc > wcnc.sql

　　2.导出一个表

　　mysqldump -u 用户名 -p 数据库名 表名> 导出的文件名

　　mysqldump -u wcnc -p smgp_apps_wcnc users> wcnc_users.sql

　　3.导出一个数据库结构

　　mysqldump -u wcnc -p -d --add-drop-table smgp_apps_wcnc >d:wcnc_db.sql

　　-d 没有数据 --add-drop-table 在每个create语句之前增加一个drop table

　　4.导入数据库

　　常用source 命令

　　进入mysql数据库控制台，

　　如mysql -u root -p

　　mysql>use 数据库

　　然后使用source命令，后面参数为脚本文件(如这里用到的.sql)

　　mysql>source d:wcnc_db.sql

　　mysql> INSERT INTO mysql.user (Host,User,Password) VALUES

　　('%','system', PASSWORD('manager'));

　　mysql> FLUSH PRIVILEGES 　　

　　确切地说这是在增加一个用户，用户名为system，密码为manager。注意要使用PASSWORD函数，然后还要使用FLUSH

　　PRIVILEGES来执行确认。 　　

　　方法四 　　

　　和方法三一样，只是使用了REPLACE语句

　　mysql> REPLACE INTO mysql.user (Host,User,Password)

　　VALUES('%','system',PASSWORD('manager'));

　　mysql> FLUSH PRIVILEGES 　

　　方法五 　　

　　使用SET PASSWORD语句 　　

　　mysql> SET PASSWORD FOR system@"%" = PASSWORD('manager'); 　　

　　你也必须使用PASSWORD()函数，但是不需要使用FLUSH PRIVILEGES来执行确认。 　　

　　方法六 　　

　　使用GRANT ... IDENTIFIED BY语句，来进行授权。 　　

　　mysql> GRANT USAGE ON *.* TO system@"%" IDENTIFIED BY 'manager'; 　　

　　这里PASSWORD()函数是不必要的，也不需要使用FLUSH PRIVILEGES来执行确认。 　　

　　注：PASSWORD()函数作用是为口令字加密，在程序中MySql自动解释。

背景介绍 ：

    代理服务器是使用非常普遍的一种将局域网主机联入互联网的一种方式，使用代理上网可以节约紧缺的IP地址资源，而且可以阻断外部主机对内部主机的访问，使内部网主机免受外部网主机的攻击。但是，如果想让互联网上的主机访问内部网的主机资源（例如：Web站点），又想使内部网主机免受外部网主机攻击，一般的代理服务是不能实现的，需要使用反向代理来实现。

    本文将详细介绍反向代理服务的概念以及如何利用反向代理服务器提高WEB服务器的性能和安全性。

一．       反向代理的概念

什么是反向代理呢？其实，反向代理也就是通常所说的WEB服务器加速，它是一种通过在繁忙的WEB服务器和Internet之间增加一个高速的WEB缓冲服务器（即：WEB反向代理服务器）来降低实际的WEB服务器的负载。典型的结构如下图所示：

Web 服务器加速（反向代理）是针对Web服务器提供加速功能的。它作为代理Cache，但并不针对浏览器用户，而针对一台或多台特定Web服务器（这也是反向代理名称的由来）。实施反向代理（如上图所示），只要将Reverse Proxy Cache设备放置在一台或多台Web服务器前端即可。当互联网用户访问某个WEB服务器时，通过DNS服务器解析后的IP地址是Reverse Proxy Server的IP地址,而非原始Web服务器的IP地址,这时Reverse Proxy Server设备充当Web服务器，浏览器可以与它连接，无需再直接与Web服务器相连。因此，大量Web服务工作量被卸载到反向代理服务上。不但能够防止外部网主机直接和web服务器直接通信带来的安全隐患，而且能够很大程度上减轻web服务器的负担，提高访问速度。

二．       反向代理和其它代理的比较

    下面将对几种典型的代理服务作一个简单的比较。 在网络上常见的代理服务器有三种：

1．  标准的代理缓冲服务器

    一个标准的代理缓冲服务被用于缓存静态的网页（例如：html文件和图片文件等）到本地网络上的一台主机上（即代理服务器）。当被缓存的页面被第二次访问的时候，浏览器将直接从本地代理服务器那里获取请求数据而不再向原web站点请求数据。这样就节省了宝贵的网络带宽，而且提高了访问速度。但是，要想实现这种方式，必须在每一个内部主机的浏览器上明确指明代理服务器的IP地址和端口号。客户端上网时，每次都把请求送给代理服务器处理，代理服务器根据请求确定是否连接到远程web服务器获取数据。如果在本地缓冲区有目标文件，则直接将文件传给用户即可。如果没有的话则先取回文件，先在本地保存一份缓冲，然后将文件发给客户端浏览器。

2．  透明代理缓冲服务器

    透明代理缓冲服务和标准代理服务器的功能完全相同。但是，代理操作对客户端的浏览器是透明的（即不需指明代理服务器的IP和端口）。透明代理服务器阻断网络通信，并且过滤出访问外部的HTTP（80端口）流量。如果客户端的请求在本地有缓冲则将缓冲的数据直接发给用户，如果在本地没有缓冲则向远程web服务器发出请求，其余操作和标准的代理服务器完全相同。对于Linux操作系统来说，透明代理使用Iptables或者Ipchains实现。因为不需要对浏览器作任何设置，所以，透明代理对于ISP（Internet服务器提供商）特别有用。

3．  反向代理缓冲服务器

    反向代理是和前两种代理完全不同的一种代理服务。使用它可以降低原始WEB服务器的负载。反向代理服务器承担了对原始WEB服务器的静态页面的请求，防止原始服务器过载。它位于本地WEB服务器和Internet之间，处理所有对WEB服务器的请求，组织了WEB服务器和Internet的直接通信。如果互联网用户请求的页面在代理服务器上有缓冲的话，代理服务器直接将缓冲内容发送给用户。如果没有缓冲则先向WEB服务器发出请求，取回数据，本地缓存后再发送给用户。这种方式通过降低了向WEB服务器的请求数从而降低了WEB服务器的负载。

三．反向代理工作原理

    反向代理服务器位于本地WEB服务器和Internet之间,如下图所示：

当用户浏览器发出一个HTTP请求时，通过域名解析将请求定向到反向代理服务器（如果要实现多个WEB服务器的反向代理，需要将多个WEB服务器的域名都指向反向代理服务器）。由反向代理服务器处理器请求。反向代理一般只缓存可缓冲的数据（比如html网页和图片等），而一些CGI脚本程序或者ASP之类的程序不缓存。它根据从WEB服务器返回的HTTP头标记来缓冲静态页面。有四个最重要HTTP头标记：

• Last-Modified: 告诉反向代理页面什么时间被修改
• Expires: 告诉反向代理页面什么时间应该从缓冲区中删除
• Cache-Control: 告诉反向代理页面是否应该被缓冲
• Pragma: 告诉反向代理页面是否应该被缓冲.

例如：在默认情况下，ASP页面返回” Cache-control: private.” ，所以ASP页面时不会在反向代理服务器缓存的

四． 代理服务器软件squid简介

Squid Internet Object Cache (Harvest Project 的后续版本) 是美国政府大力助的一项研究计划，其目的为解决网络带宽不足的问题，是现在Unix系统上使用者最多功能也最完整的一套软体。Apache和Netscape虽附有相关的Proxy模块，但因其功能简单而不够普及。有关squid的详细说明可到squid网站(http://www.squid-cache.org)查询。

Squid 最典型的应用是代理局域网的机器联入互联网，它支持现在流行的网络协议。 Squid 的另一项非常出色的功能就是实现反向代理功能。

五．使用Squid配置反向代理（HTTP 加速器）

    通过squid配置反向代理主要就是配置“squid.conf”这个配置文件。下面以Linux操作系统为例进行介绍，其它版本的在UNIX也同样适用。在Linux中squid如果是以源代码方式安装的话，这个文件一般在“/usr/local/squid/etc/”目录下。如果是系统自带的squid，一般配置文件在“/etc/squid/”目录下。

1．  Squid 反向代理单个后台WEB服务器

如果WEB服务器和反向代理服务器是两台单独的机器（一般的反向代理应该有两块网卡分别连接了内外部网络）。那么，应该修改下面的内容来设置反向代理服务。

http_port 80 # squid 监听的端口
httpd_accel_host 172.16.250.250 # 内部WEB服务器的IP地址
httpd_accel_port 80 # WEB服务器的IP地址
httpd_accel_single_host on # 转发为缓冲的请求到一台单独的机器
httpd_accel_with_proxy on #
httpd_accel_uses_host_header off

    如果WEB服务器和反向代理服务器是同一台机器。那么，应该设置WEB服务器的监听端口为非80端口（比如：81端口）。要修改的内容如下：

http_port 80 # squid 监听的端口
httpd_accel_host localhost # 内部WEB服务器的IP地址
httpd_accel_port 81 # WEB服务器的IP地址
httpd_accel_single_host on # 转发为缓冲的请求到一台单独的机器
httpd_accel_with_proxy on #
httpd_accel_uses_host_header off

下面解释一下配置指令。

http_port 80

选项 http_port 指定squid监听HTTP请求的端口，一般都设置成80端口，这样使用户感觉不到反向代理的存在，就像访问真正的WEB服务器一样。

httpd_accel_host 172.16.250.250 和 httpd_accel_port 80

选项httpd_accel_host 和 httpd_accel_port 指定WEB服务器的IP地址和端口号，可以根据自己的WEB服务器的实际情况而定。

httpd_accel_single_host on

选项 httpd_accel_single_host 为on 时，squid被设置成仅对单一的web服务器作反向代理。不考虑HTTP头信息，Squid转发所有的未被缓冲的页面请求到这个web服务器。如果squid需要做多个web服务器反向代理，必须将此选项设置为off，并且使用转向器或者DNS去映射请求到合适的后台WEB服务器。

httpd_accel_with_proxy on

如果希望squid既作反向代理服务器又作本地机器的上网代理，需要将httpd_accel_with_proxy 改为 on ，默认情况下是off

httpd_accel_uses_host_header off

在HTTP协议1.1中，HTTP请求包括一个主机头信息，指定URL的主机名或者主机的IP地址。这个选项可以用来完成多个后台WEB服务器的反向代理功能。

2 ． Squid 反向代理多个后台 WEB 服务器

我们可以用 Squid 反向代理多个后台 WEB 服务器。例如：我们可以配置 squid 同时反向代理 www.abc.com, www.xyz.com, www.lmn.com 三个后台 WEB 服务器，示意图如下：

Squid 的配置如下：

httpd_accel_host virtual
httpd_accel_port 80
httpd_accel_single_host off
httpd_accel_uses_host_header on

（注意:编译Squid时需激活Internal DNS选项）

然后设置设置反响代理需要的域名解析（Internet用户通过这里解析三个网站的域名）如下：

www.abc.com 202.102.240.74
www.xyz.com 202.102.240.74
www.lmn.com 202.102.240.74

使三个域名都指向反向代理服务器的IP地址202.102.240.74。

下面设置反向代理所需要的DNS入口信息（即设置内部DNS，仅仅是squid在内部使用，Internet用户不可见）。有两种方法可以设置内部DNS，使用内部DNS服务器来解析或者使用/etc/hosts文件来实现。

使用内部DNS服务器的资源记录如下：
www.abc.com IN A 172.16.1.2
www.xyz.com IN A 172.16.1.3
www.lmn.com IN A 172.16.1.4

如果使用/etc/hosts文件来实现内部DNS（编译时应使用disable internal dns选项）,编辑/etc/hosts文件添加如下条目：
172.16.1.2 www.abc.com
172.16.1.3 www.xyz.com
172.16.1.4 www.lmn.com

结论

    通过本文中的论述和相关实例，可以看出，反向代理方式不单是一种WEB服务器加速器，而且使也一种对外提供Web发布时使用的有效的防火墙技术，使用它不但能节约紧缺的IP地址资源，加速WEB服务器的访问速度，而且能够保护WEB主机，因此能够适应多种应用场合。

show.html //客户端

<script language="JavaScript">
function GetResult() {
   http_request = false;
  //开始初始化XMLHttpRequest对象
  if(window.XMLHttpRequest) { //Mozilla 浏览器
   http_request = new XMLHttpRequest();
   if (http_request.overrideMimeType) {//设置MiME类别
    http_request.overrideMimeType('text/xml');
   }
  }
  else if (window.ActiveXObject) { // IE浏览器
   try {
    http_request = new ActiveXObject("Msxml2.XMLHTTP");
   } catch (e) {
    try {
     http_request = new ActiveXObject("Microsoft.XMLHTTP");
    } catch (e) {}
   }
  }
  if (!http_request) { // 异常，创建对象实例失败
   window.alert("不能创建XMLHttpRequest对象实例.");
   return false;
  }

http_request.open("POST","rand.php",false);
http_request.send();
var strResult = http_request.responseText;

 RemoveRow(); //删除以前的数据.

 num1 = strResult; //字段num1的值

 row1 = tb.insertRow();
 cell1 = row1.insertCell();
 cell1.innerText = num1;
 
}

function RemoveRow() {
    //保留第一行表头,其余数据均删除.
   var iRows = tb.rows.length;
   for(var i=0;i<iRows-1;i++) {
      tb.deleteRow(1);
   }
}

function MyShow() {
    //2秒自动刷新一次,2秒取得一次数据.
   timer = window.setInterval("GetResult()",2000);
}
</script>

<body onload="MyShow()">
<p>
</p>
<table width="47%" height="23"border="0" cellpadding="1" cellspacing="0" id="tb">
<tr>
<td>num1</td>

</tr>
</table>

get.php //服务端

<?

echo rand();

?>

二 配置
1 最好是无论使用何种接口（CGI 或者 SAPI）都确保 php5ts.dll 可用，因此必须将此文件放到 Windows 路径中。最好的位置是 Windows 的 system 目录

c:\windows\system for Windows 9x/ME 
c:\winnt\system32 for Windows NT/2000 或者 c:\winnt40\system32 for Windows NT/2000 服务器版 
c:\windows\system32 for Windows XP 

2 下一步是设定有效的 PHP 配置文件，php.ini。压缩包中包括两个 ini 文件，php.ini-dist 和 php.ini-recommended。建议使用 php.ini-recommended，因为此文件对默认设置作了性能和安全上的优化。
将选择的 ini 文件拷贝到 PHP 能够找到的目录下并改名为 php.ini。PHP 默认在 Windows 目录下搜索 php.ini

3 在 Windows 9x/ME/XP 下将选择的 ini 文件拷贝到 %WINDIR%，通常为 c:\windows。

4 Apache中PHP的设置
有两种方法使得 PHP 工作在 Windows 下的 Apache。一是使用 CGI 二进制文件，另一是使用 Apache 模块 DLL。无论那种方法，您首先必须停止 Apache 服务器，然后编辑 httpd.conf，以配置 Apache 和 PHP 协同工作。

如果我们要使用CGI二进制文件,那么我们要将如下指令插入到 Apache 的 httpd.conf 配置文件中，以设置 CGI 二进制文件：
 
PHP 以 CGI 方式安装到 Apache 2.0:

ScriptAlias /php/ "c:/php/"
AddType application/x-httpd-php .php
Action application/x-httpd-php "/php/php.exe"

如果我们想把 PHP 作为 Apache 2.0 的模块，那么就一定要移动 php4ts.dll 到 winnt/system32（Windows NT/2000）或 windows/system32（Windows XP），覆盖原有文件（如果有的话），对于 PHP 5，这个文件是 php5ts.dll。然后我们要插入如下两行到 httpd.conf 中，以使我们的 PHP 作为 Apache 的 PHP-Module 安装：

PHP 以模块方式安装到 Apache 2.0:

; For PHP 4 do something like this:
LoadModule php4_module "c:/php/php4apache2.dll"
AddType application/x-httpd-php .php

; For PHP 5 do something like this:
LoadModule php5_module "c:/php/php5apache2.dll"
AddType application/x-httpd-php .php

经过这样的配置以后,我们就安装好了我们的PHP和Apache服务器了.我们可以简单的测试一下:
1 测试Apache:
我们打开浏览器,在地址栏中输入localhost,如果可以出现Apache页面,则说明我们的Apache可以正常工作了.
2测试PHP设置:
我们可以简单的编写一个PHP页面,我们可以用文本编辑器,输入下面的代码:
<html>
<head>
<title>
hello
</title>
</head>
<body>
<?php echo "hello,php"; ?>
</body>
</html>
然后将这个文件存为hello.php,将其放在Apache的htdocs目录中(我们也可以在http.conf文件中来更改这个目录的),然后在我们的浏览器中输入http://localhost/hello.php,如果能够正确的显示hello,php就说明我们的PHP配置是可以正常工作的.
这样以后我们也可以来设计我们的PHP站点了.

mysql扩展
搜索extension_dir = ./ 这行，并将其路径指到你的PHP目录下的extensions目录，比如：
　　extension_dir = C:\php\extensions

　　如若想支持更多模块，，搜索：
;Windows Extensions
;Note that MySQL and ODBC support is now built in, so no dll is needed for it.
;
下面都用分号在前面注释掉了支持的扩展模块，如果你想PHP支持某个模块，请将前面的“;”去掉即可
修改完成后,保存php.ini，到此完成PHP的安装和配置。
我们在下面加入一行
extension=php_mysql.dll

header("Content-Type:text/html;charset=GB2312");

而对于发送到服务器的中文进行转码。
如下
$_POST["content"]=iconv("UTF-8","gb2312",$_POST["content"]);
因而这样可以解决乱码问题

方法二，是都采用UTF-8编码。这里就不多说了

附测试例程
客户端

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>ajax post test</title>
</head>
<body>
<div id="msg"></div>
<script language="javascript">
/**
* 初始化一个xmlhttp对象
*/
function InitAjax()
{
　var ajax=false;
　try {
　　ajax = new ActiveXObject("Msxml2.XMLHTTP");
　} catch (e) {
　　try {
　　　ajax = new ActiveXObject("Microsoft.XMLHTTP");
　　} catch (E) {
　　　ajax = false;
　　}
　}
　if (!ajax && typeof XMLHttpRequest!='undefined') {
　　ajax = new XMLHttpRequest();
　}
　return ajax;
}
//在form 测试页面内有一个表单，一个显示的层
function sendData()
{
 var msg=document.getElementById("msg");
 var f=document.form1;
 var c=f.content.value;
 //接收数据的URL
 var url="dispmsg.php";
 var poststr="content="+c;
 var ajax=InitAjax();
 ajax.open("POST",url,true);
 ajax.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
 ajax.send(poststr);
 ajax.onreadystatechange=function(){
  if(ajax.readyState==4 && ajax.status==200){
  alert("I got something");
   msg.innerHTML=ajax.responseText;
  }
 }
}

</script>

<form name='form1'>
<input type="text" name='content' size=10>
<input type="button" value="确定" onclick="sendData()"><!--我用submit时就出错-->
</form>
</body>
</html>

服务器端
<?php
header("Content-Type:text/html;charset=GB2312");
if($_POST['content'])
{
 $_POST["content"]=iconv("UTF-8","gb2312",$_POST["content"]);
 print("内容是".$_POST['content']);
}
else
{
 print("没有内容发送");
}
?>

　$fp = fopen ("temp.html","r");
 $content = fread ($fp,filesize ("temp.html"));
 $content .= str_replace ("{ file }",$file,$content);
 $content .= str_replace ("{ title }",$title,$content);

 echo $content;
?>
模板解析处理，即将经PHP脚本解析处理后得出的结果填充(content)进模板的处理过程。通常借助于模板类。目前较流行的模板解析类有phplib，smarty，fastsmarty等等。模板解析处理的原理通常为替换。也有些程序员习惯将判断，循环等处理放进模板文件中，用解析类处理，典型应用为block概念，简单来说即为一个循环处理。由PHP脚本指定循环次数，如何循环代入等，再由模板解析类具体实施这些操作。
　　好了，对比过静态页面与动态页面各自的优劣，现在我们就来说说，如何用PHP生成静态文件。
　　PHP生成静态页面并不是指PHP的动态解析，输出HTML页面，而是指用PHP创建HTML页面。同时因为HTML的不可写性，我们创建的HTML若有修改，则需删掉重新生成即可。(当然你也可以选择用正则进行修改，但个人认为那样做倒不如删掉重新生成来得快捷，有些得不偿失。)
　　言归正传。用过PHP文件操作函数的PHP FANS知道，PHP中有一个文件操作函数fopen，即打开文件。若文件不存在，则尝试创建。这即是PHP可以用来创建HTML文件的理论基础。只要用来存放HTML文件的文件夹有写权限(即权限定义0777)，即可创建文件。（针对UNIX系统而言，Win系统无须考虑。）仍以上例为例，若我们修改最后一句，并指定在test目录下生成一个名为test.html的静态文件：
<?php
 $title = " http://siyizhu.com/ 测试模板";
 $file = "TwoMax Inter test templet,<br>author： Matrix@Two_Max ";
　$fp = fopen ("temp.html","r");
 $content = fread ($fp,filesize ("temp.html"));
 $content .= str_replace ("{file}",$file,$content);
 $content .= str_replace ("{title}",$title,$content);
 // echo $content;
 $filename = "test/test.html";
 $handle = fopen ($filename,"w"); //打开文件指针，创建文件
 /*
　检查文件是否被创建且可写
 */
 if (!is_writable ($filename)){
 die ("文件：".$filename."不可写，请检查其属性后重试！");
 }
 if (!fwrite ($handle,$content)){ //将信息写入文件
 die ("生成文件".$filename."失败！");
 }
 fclose ($handle); //关闭指针
 
 die ("创建文件".$filename."成功！");
?>

实际应用中常见问题解决方案参考：
　　一，文章列表问题：　　
　　在数据库中创建字段，记录文件名，每生成一个文件，将自动生成的文件名存入数据库，对于推荐文章，只需指向存放静态文件的指定文件夹中的该页面即可。利用PHP操作处理文章列表，存为字符串，生成页面时替换此字符串即可。如，在页面中放置文章列表的表格加入标记{articletable}，而在PHP处理文件中：
<?php
 $title = " http://siyizhu.com/ 测试模板";
 $file = "TwoMax Inter test templet,<br>author： Matrix@Two_Max ";
 $fp = fopen ("temp.html","r");
 $content = fread ($fp,filesize ("temp.html"));
 $content .= str_replace ("{file}",$file,$content);
 $content .= str_replace ("{title}",$title,$content);
 // 生成列表开始
 $list = '';
 $sql = "select id,title,filename from article";
 $query = mysql_query ($sql);
 while ($result = mysql_fetch_array ($query)){
 $list .= '<a href='.$root.$result['filename'].' target=_blank>'.$result['title'].'</a><br>';
 }
 $content .= str_replace ("{articletable}",$list,$content);
 //生成列表结束
 // echo $content;
 $filename = "test/test.html";
 $handle = fopen ($filename,"w"); //打开文件指针，创建文件
 /*
　检查文件是否被创建且可写
 */
 if (!is_writable ($filename)){
 die ("文件：".$filename."不可写，请检查其属性后重试！");
 }
 if (!fwrite ($handle,$content)){ //将信息写入文件
 die ("生成文件".$filename."失败！");
 }
 fclose ($handle); //关闭指针
 die ("创建文件".$filename."成功！");
?>
二，分页问题。
　　如我们指定分页时，每页20篇。某子频道列表内文章经数据库查询为45条，则，首先我们通过查询得到如下参数：1，总页数；2，每页篇数。第二步，for ($i = 0; $i < allpages; $i++)，页面元素获取，分析，文章生成，都在此循环中执行。不同的是，die ("创建文件".$filename."成功！";这句去掉，放到循环后的显示，因为该语句将中止程序执行。例：
<?php
 $fp = fopen ("temp.html","r");
 $content = fread ($fp,filesize ("temp.html"));
 $onepage = '20';
 $sql = "select id from article where channel='$channelid'";
 $query = mysql_query ($sql);
 $num = mysql_num_rows ($query);
 $allpages = ceil ($num / $onepage);
 for ($i = 0;$i<$allpages; $i++){
 if ($i == 0){
 $indexpath = "index.html";
 } else {
 $indexpath = "index_".$i."html";
 }
 $start = $i * $onepage;
 $list = '';
 $sql_for_page = "select name,filename,title from article where channel='$channelid' limit $start,$onepage";
 $query_for_page = mysql_query ($sql_for_page);
 while ($result = $query_for_page){
 $list .= '<a href='.$root.$result['filename'].' target=_blank>'.$title.'</a><br>';
 }
 $content = str_replace ("{articletable}",$list,$content);
 if (is_file ($indexpath)){
 @unlink ($indexpath); //若文件已存在，则删除
 }
 $handle = fopen ($indexpath,"w"); //打开文件指针，创建文件
 /*
　 检查文件是否被创建且可写
 */
 if (!is_writable ($indexpath)){
 echo "文件：".$indexpath."不可写，请检查其属性后重试！"; //修改为echo
 }
 if (!fwrite ($handle,$content)){ //将信息写入文件
 echo "生成文件".$indexpath."失败！"; //修改为echo
 }
 fclose ($handle); //关闭指针
 }
 fclose ($fp);
 die ("生成分页文件完成，如生成不完全，请检查文件权限系统后重新生成！");
?>
大致思路如此，其中如其它数据生成，数据输入输出检查，分页内容指向等可酌情在页面中加入。
　　在实际文章系统处理过程当中，还有许多问题有待考虑，与动态页面不同之处，需注意的地方还有很多。但大致思路即是如此，其它方面可举一反三而得。

文章转载于：http://www.tsingfeng.com/trackback.asp?tbID=249

从天极网上看了一些关于AJAX的内容之后，就想试试看。小试牛刀，写了一个小程序

这是客户端代码：
<html>
<head>
<title></title>
<script language="javascript">
/**
* 初始化一个xmlhttp对象
*/
function InitAjax()
{
　var ajax=false;
　try {
　　ajax = new ActiveXObject("Msxml2.XMLHTTP");
　} catch (e) {
　　try {
　　　ajax = new ActiveXObject("Microsoft.XMLHTTP");
　　} catch (E) {
　　　ajax = false;
　　}
　}
　if (!ajax && typeof XMLHttpRequest!='undefined') {
　　ajax = new XMLHttpRequest();
　}
　return ajax;
}
</script>
</head>
<body>
<a href="#" onclick="getNews(1)">新闻</a>
<div id="show_news"></div>
<script>
function getNews(newID)
{
if(typeof(newID)=='undefined')
{
 return false;
}
var url="getmsg.php?id="+newID;
var show=document.getElementById("show_news");
var ajax=InitAjax();
ajax.open("GET",url,true);
ajax.onreadystatechange=function(){
if(ajax.readyState==4&& ajax.status==200){
show.innerHTML=ajax.responseText;
}
}
ajax.send(null);
}
</script>

下面是服务器端的.PHP文件
<?php
if($_GET[id]){
 echo"all right<br>";
 echo"the id is".$id;
}
?>
放到我的空间上测度一下效果不错。

在Ajax中，关键就是用到了xmlhttp对象以及javascript,先是在初始化程序中生成一个xmlhttp对象，如果是IE的话，就是ActiveXObject对象。进一步就是把请求方法和url作为参数传入这个对象，当有响应时再实现onreadystatechange()方法。对返回的内容进行处理。原理就是这样简单。

用POST方法实现，上面那个用的是GET方法。这个我没有写具体的代码作测试，只是我把不同的地方指出来。
POST方法主要是通过表单来实现，但是这个表单不能写上提交目标，表单的头应该写成类似于下面的格式
<form name="user_info">,而action，method就可以免了。

//构建一个表单，表单中不需要action、method之类的属性，全部由ajax来搞定了。
＜form name="user_info"＞
姓名：＜input type="text" name="user_name" /＞＜br /＞
年龄：＜input type="text" name="user_age" /＞＜br /＞
性别：＜input type="text" name="user_sex" /＞＜br /＞

＜input type="button" value="提交表单" onClick="saveUserInfo()"＞
＜/form＞
//构建一个接受返回信息的层：
＜div id="msg"＞＜/div＞

function saveUserInfo()
{
　//获取接受返回信息层
　var msg = document.getElementById("msg");

　//获取表单对象和用户信息值
　var f = document.user_info;
　var userName = f.user_name.value;
　var userAge = f.user_age.value;
　var userSex = f.user_sex.value;

　//接收表单的URL地址
　var url = "/save_info.php";

　//需要POST的值，把每个变量都通过&来联接
　var postStr = "user_name="+ userName +"&user_age="+ userAge +"&user_sex="+ userSex;

　//实例化Ajax
　var ajax = InitAjax();
　
　//通过Post方式打开连接
　ajax.open("POST", url, true);

　//定义传输的文件HTTP头信息
　ajax.setRequestHeader("Content-Type","application/x-www-form-urlencoded");

　//发送POST数据
　ajax.send(postStr);

　//获取执行状态
　ajax.onreadystatechange = function() {
　　//如果执行状态成功，那么就把返回信息写到指定的层里
　　if (ajax.readyState == 4 && ajax.status == 200) {
　　　msg.innerHTML = ajax.responseText;
　　}
　}
}

比较GET和POST两方法，因为POST方法能发送任何数据，而且大小没有限制，因而比较灵活。不过要在ajax对象中指定HTTP头信息。其它同GET方法类似。