博客园_酷赛瑞

向IIS注册ASP.NET代码

2012-02-03T08:59:00Z

C:\Windows\Microsoft.NET\Framework\v2.0.50727\aspnet_regiis.exe -i

本文链接

Windows下安装Redmine

2012-01-04T07:43:00Z

为food项目配置了项目管理平台，综合了trac、dotProject、Redmine等几个开源平台，最终选择了Redmine。项目主页 http://www.redmine.org

下面是安装方法：

一、Redmine安装。

1、准备

安装之前请阅读：RailsInstaller简化了Rails在Windows上的安装过程

英文原文：RailsInstaller Provides Easy Rails on Windows Installation

作者：Rob Bazinet 译者：张龙

RailsInstaller向Windows开发者提供了一种便捷的方式以轻松、快速创建Ruby on Rails 3应用。到目前为止，Windows开发者需要自己搭建好Ruby、RubyGems、Rails以及SQLite才能开始创建Rails应用。多亏了来自Engine Yard的Nic Williams博士及其团队，现在一切都变得简单异常。

目前的RailsInstaller提供了如下功能：

通过向导的轻松安装
Rails 3.0.3
Ruby 1.8.7——p330
SLQite 3.7.3
Git 1.7.3.1
DevKit

2、安装

注意：下面的操作要在联网的情况下进行。

转自：http://www.cppblog.com/giigie/archive/2011/07/31/152160.html

最近在一家公司实习。公司用的项目管理软件是开源的redmine，体验非常不错。我想这个东西不仅可以用来管理项目，也可以用来管理个人的学习工作进展啊。于是，我也在自己的虚拟机的2003 server 下安装。

之前为了安装wordpress，我已经在我的电脑上安装了 xampp。这是一个搭建服务器环境的傻瓜式安装包，里面集成了apache,php,mysql,phpMyAdmin,FileZilla FTP Server,Tomcat，这些组件可以选择安装。.

因为redmine是需要apache 和mysql的，所以正好。此外，redmine使用ruby写的，所以还需要ruby的环境。

配置ruby 的环境我选用的是railsinstaller 。

之前我在网上搜索安装redmine 的教程，配置ruby环境大多是用InstantRails。我实际用了一下，效果不太好。因为InstantRails从2007年开始就没有更新了，里面包含的很多组件版本都很旧，直接搭建的话需要升级各种组件，而且组件之间的依赖关系比较混乱，反正我是在里面绕了很多弯路。而且InstantRails 里面自带有很低版本的apache,mysql,phpMyAdmin,如果你电脑本来安装了这些，那么又要改这些服务的端口和对应的配置文件。总之一句话，InstantRails 已经过时了。

好了，现在开始进入正题吧。

1.去redmine的官方网站下载 redmine 的最新版本。我下载的的是redmine 1.2.1.然后弄清楚这个版本的需要的环境。Redmine 的网站的Guide » Installation Guide » 会清楚的告诉你这些事项的。

2.如果你的电脑上还没有apache ,php,mysql 建议你去下载xampp,如果有的话，跳过这步。

3.去railsinstaller 的官方网站去下载最新版的railsinstaller 。看它所包含的组件以及其版本。然后安装。

4.做好这些准备工作了。就可以开始配置redmine运行环境了。把redmine的解压到railsinstaller所产生的sites目录。在dos窗口进入sites\redmine目录下。

5.gem install rails -v=2.3.11 安装rails 2.3.11版本，这个redmine 1.2.1所要求的。

6.gem install rack -v=1.1.1 安装rack 1.1.1版本，这个redmine 1.2.1所要求的。

7.gem install -v=0.4.2 i18n 这个根据安装时返回的错误命令提示来决定。比如的我就是提示Missing the i18n 0.4.2 gem. Please `gem install -v=0.4.2 i18n`

8.进入phpMyAdmin 创建数据库。执行以下三条sql 语句。

create database redmine character set utf8;

create user 'redmine'@'localhost' identified by 'my_password';

grant all privileges on redmine.* to 'redmine'@'localhost';

9.拷贝config/database.yml.example文件到config/database.yml，修改database.yml的内容 production:

adapter: mysql

database: redmine

host: localhost

username: redmine

password: my_password

Username 和password字段就是自己要设置的数据库的账号和密码。

10.回到dos 窗口下，设置Session Key，执行 rake generate_session_store

如果提示 mysql 错误，再执行如下语句 gem install mysql

11.然后set RAILS_ENV=production

rake db:migrate

rake redmine:load_default_data

执行rake load_default_data RAILS_ENV="production" 完后，会提示Select language: bg, bs, ca, cs, da, de, el, en, en-GB, es, eu, fi, fr, gl, he, hr, hu, id, it, ja, ko, lt, lv, mn, nl,no, pl, pt, pt-BR, ro, ru, sk, sl, sr, sr-CY, sv, th, tr, uk, vi, zh, zh-TW [en] zh

输入zh选择中文

12.最后ruby script/server webrick -e production 启动。以后每次开机后都需要这句来启动。

13.打开浏览器输入 http://localhost:3000 。账号，密码都是 admin 。

14.安装完了，就可以使用admin用户登录，密码也是admin，登入后，发现页面又变成了英文的，在这里要设置个人用户，修改语言为中文就可以了。然后进入管理页面，可以管理项目，用户，角色，权限，问题状态，跟踪类型，流程等。

上面的步骤是比较顺利的，如果是组件的版本有问题，这篇博客比较有价值http://like-eagle.iteye.com/blog/847218。

如果还有问题，你可以根据问题的提示去google.

下面我简单翻译一下redmine 1.2.1 官方的安装向导。（仅 windows 平台）

官方发行版已经在其 vendor 目录包含了适当的Rails 版本，所以不需要为此做什么。

你也可以查看redmine 的版本，运行一下命令特地的为它安装某个版本的组件：

gem install rails -v=2.3.11

安装rack

gem install rack -v=1.1.0

兼容性提示

· Ruby 1.9 版本目前还不支持，但你必须安装ruby 1.8.x 以上的版本。

· RubyGems 1.3.7 或者更高版本有以下限制 :

o Rails 2.3.5 与rubygems 1.5.0或者更高的版本工作会失败，请使用rubygems的更早的版本!

o Rails 2.3.11 与rubygems 1.7.9或者更高版本工作会失败，请使用rubygems更早的版本 !

· 需要Rake 0.8.7 (rake 0.9.x 尚未被 Rails 支持)

· 需要Rack1.1.x , 1.1.0 版本有引用 (#8416)所描述的bug. 同其他版本的迁移会失败.

· Mongrel1.1.5 需要补丁 #7688 才能和 Rails 2.3.11工作. 在升级的情况下，其他问题可能会出现 (#7857).

· Redmine >= 1.0.5版本需要I18n 0.4.2

数据库

· 需要mysql 5.0或者更高的版本。MySQL 5.0 or higher (建议)

安装步骤

1.获得redmine 的源代码或者发行包。参见 Download.

2.用mysql 创建一个空的数据库和一个名为 redmine的用户，例如：

create database redmine character set utf8;

create user 'redmine'@'localhost' identified by 'my_password';

grant all privileges on redmine.* to 'redmine'@'localhost';

对于mysql 5.0.2 的版本跳过create user ,用这个代替grant all privileges on redmine.* to 'redmine'@'localhost' identified by 'my_password';

3.复制Copy config/database.yml.example改为 config/database.yml ，编辑文件配置数据库设置。例如mysql:

production:

adapter: mysql

database: redmine

host: localhost

username: redmine

password: my_password

如果服务器没有工作在3306端口，用下面的配置代替：

production:

adapter: mysql

database: redmine

host: localhost

port: 3307

username: redmine

password: my_password

4.生成会话密钥：

rake generate_session_store

5.创建数据库：

AILS_ENV=production rake db:migrate

这将创建一个管理员账户。

如果你得到以下错误：

Rake aborted!

no such file to load -- net/https

你需要安装libopenssl-ruby1.8

6.向数据库插入默认的配置数据

RAILS_ENV=production rake redmine:load_default_data

7.运行使用ruby script/server webrick -e production命令

配置：

从1.2.0版本开始，redmine的配置都在config/configuration.yml文件里。不要忘记修改了默认配置都需要重启服务。

Window 用户的特别提醒

RAILS_ENV=production rake db:migrate

RAILS_ENV=production rake redmine:load_default_data

等命令已经变成了

set RAILS_ENV=production

rake db:migrate

rake redmine:load_default_data

如果你需要安装mysql ，使用如下命令：

gem install mysql

在一些情况下，你需要复制libmysql.dll到你的ruby/bin目录，但不是所有的libmysql.dll 都适合，请参考

http://instantrails.rubyforge.org/svn/trunk/InstantRails-win/InstantRails/mysql/bin/libmySQL.dll

二、Redmine集成SVN

参考http://www.cnblogs.com/Quincy/archive/2011/06/03/2070479.html

进入Redmine目录下Config，有文件“configuration.yml.example”，复制该文件重命名“configuration.yml”，修改其中的SVN配置

scm_subversion_command: svn # (default: svn)，

这里需要设置在环境变量PATH中添加svn所在的目录

再重启服务器，配置SCM，选用SVN设置库路径，就可以看到代码了。

三、Redmine配置上传文件存储地址、邮件服务器等

参考上步，在这个文件中有相应的配置选项。

注意：configuration.yml 中无用的项不用写，有严格的格式

下面这两句是一个配置例子：

default:
attachments_storage_path: D:\RedmineFiles
scm_subversion_command: svn

四、Redmine以windows服务方式启动

参考 http://bufeifang.blog.163.com/blog/static/558981512009421113134391/

Redemine的启动是用命令行执行的，在Redmine根目录下执行：ruby script/server -e production即可，但是执行后不能关闭控制台，不然服务就会关闭，这对于重启服务器来说是一件很麻烦的事情，每次都要手动启动Redmine；

既然Windows有服务，可自启，那就安装成服务，安装步骤如下：

A、先安装mongrel_service，在在C:\InstantRails\ruby\bin目录下运行：gem install mongrel_service，此过程中会下载一些其他必须的包；

B、使用mongrel_service将Redmine安装为服务：mongrel_rails service::install -N RedMine -c C:\redmine -p 3000 –e production；C:\redmine是具体的目录，参考修改；

C、安装服务后，查看-e后的参数是不是production，如果不是production而是development，则在注册表中把参数手动改为production即可，修改方法是：在“开始→运行”中键入“regedit.exe”，打开“注册表编辑器”，展开分支“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services”，在下面都是系统服务的名称，右侧窗格中显示的就是服务的详细参数。找到ImagePath项，修改保存后在服务列表中启动服务，并把服务设置自动启动。

然后修改启动方式为自动启动，并添加MySQL服务为其依赖服务（如果你的MySQL服务器不是本机就不用麻烦了）：

sc config RedMine start= auto depend= MySQL

注意：上面命令=后有一个空格。

注意，执行sc config系列指令，服务必须是未启动的才行，否则会出错。

将来如果想去掉这个服务，只要执行：

mongrel_rails service::remove -N RedMine

五、Redmine服务方式不能正常运行bug补丁

注意：

补丁（很重要）

上面第四步操作完以后，Redmine并不能正常运行，log中有这日志

A NoMethodError occurred in account#login

参见 http://www.redmine.org/issues/7857

解决办法：

由 Alfredo Bonilla

Hi everybody, we are trying to upgrade to 1.2 and we are having both problems here described... the problem is that after applying what here is detailed... there is no way... problems still remain.

Please, let me know if I'm missing something or doing something wrong!!):

Copy mongrel.rb (https://gist.github.com/826692), patch_for_mongrel.rb (http://www.redmine.org/attachments/4699/patch_for_mongrel.rb) and rails_6440_patch.rb (http://www.redmine.org/attachments/6146/rails_6440_patch.rb) files in /<my-redmine-path>/config/initializers

Thx in advance

由 Etienne Massip

mongrel.rb is mandatory to get mongrel 1.1.5 work with RoR 2.3.11. It's the only patch I'm actually running with.
patch_for_mongrel.rb might be useful for a sub-URL Redmine setup ?
rails_6440_patch.rb might be useful at start to prevent the hereby discussed issue (maybe only in case of a Redmine upgrade) but can be remove after some time

由 Alfredo Bonilla

Thanks for clarifications. As I commented in http://www.redmine.org/issues/7688, our problem was not having installed the mongrel gems. Once installed, just with mongrel.rb in /config/initializers, everything is working. :)

文章信息：

作者：一个农夫

出处：一个园子 - http://www.cnblogs.com/afarmer

本文版权归作者和博客园共有，转载请遵循“署名-非商业使用-禁止演绎”协议，未经作者授权，必须在文章页面明显位置给出原文连接，同时诚挚期望您保留此段声明。谢谢合作。

本文链接

Perl简单教程

2011-12-23T03:36:00Z

第一节：
基本上，简单变量就是一个数据单元，这个单元可以是数字或字符串。
一、整型
1、整型
PERL最常用的简单变量，由于其与其它语言基本相同，不再赘述。
例：
$x = 12345;
if (1217 + 116 == 1333) {
# statement block goes here
}
整型的限制：
PERL实际上把整数存在你的计算机中的浮点寄存器中，所以实际上被当作浮点数看待。在多数计算机中，浮点寄存器可以存贮约16位数字，长于此的被丢弃。整数实为浮点数的特例。
2、8进制和16进制数
8进制以0打头，16进制以0x打头。
例：$var1 = 047; (等于十进制的39)
$var2 = 0x1f; (等于十进制的31)
二、浮点数
如 11.4 、 -0.3 、.3 、 3. 、 54.1e+02 、 5.41e03
浮点寄存器通常不能精确地存贮浮点数，从而产生误差，在运算和比较中要特别注意。指数的范围通常为-309到+308。
例：

#!/usr/local/bin/perl
$value = 9.01e+21 + 0.01 - 9.01e+21;
print ("first value is ", $value, "\n");
$value = 9.01e+21 - 9.01e+21 + 0.01;
print ("second value is ", $value, "\n");

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

$ program3_3
first value is 0
second value is 0.01
三、字符串
惯用C的程序员要注意，在PERL中，字符串的末尾并不含有隐含的NULL字符，NULL字符可以出现在串的任何位置。
. 双引号内的字符串中支持简单变量替换，例如：
$number = 11;
$text = "This text contains the number $number.";
则$text的内容为："This text contains the number 11."

.双引号内的字符串中支持转义字符
Table 3.1. Escape sequences in strings.

Escape Sequence Description
\a Bell (beep)
\b Backspace
\cn The Ctrl+n character
\e Escape
\E Ends the effect of \L, \U or \Q
\f Form feed
\l Forces the next letter into lowercase
\L All following letters are lowercase
\n Newline
\r Carriage return
\Q Do not look for special pattern characters
\t Tab
\u Force next letter into uppercase
\U All following letters are uppercase
\v Vertical tab

\L、\U、\Q功能可以由\E关闭掉，如：
$a = "T\LHIS IS A \ESTRING"; # same as "This is a STRING"

.要在字符串中包含双引号或反斜线，则在其前加一个反斜线，反斜线还可以取消变量替换，如：
$res = "A quote \" and A backslash \\";
$result = 14;
print ("The value of \$result is $result.\n")的结果为：
The value of $result is 14.

.可用\nnn(8进制)或\xnn(16进制)来表示ASCII字符，如：
$result = "\377"; # this is the character 255,or EOF
$result = "\xff"; # this is also 255

.单引号字符串
单引号字符串与双引号字符串有两个区别，一是没有变量替换功能，二是反斜线不支持转义字符，而只在包含单引号和反斜线时起作用。单引号另一个特性是可以跨多行，如：
$text = 'This is two
lines of text
';
与下句等效：
$text = "This is two\nlines of text\n";

.字符串和数值的互相转换
例1：
$string = "43";
$number = 28;
$result = $string + $number; # $result = 71
若字符串中含有非数字的字符，则从左起至第一个非数字的字符，如：
$result = "hello" * 5; # $result = 0
$result = "12a34" +1; # $result = 13

.变量初始值
在PERL中，所有的简单变量都有缺省初始值：""，即空字符。但是建议给所有变量赋初值，否则当程序变得大而复杂后，很容易出现不可预料且很难调试的错误。

第二节：

一、算术操作符：+(加)、-(减)、*(乘)、/(除)、**(乘幂)、%(取余)、-(单目负)
(1)乘幂的基数不能为负，如 (-5) ** 2.5 # error；
(2)乘幂结果不能超出计算机表示的限制，如10 ** 999999 # error
(3)取余的操作数如不是整数，四舍五入成整数后运算；运算符右侧不能为零
(4)单目负可用于变量： - $y ; # 等效于 $y * -1
二、整数比较操作符

Table 3.1. 整数比较操作符

操作符描述
< 小于
> 大于
== 等于
<= 小于等于
>= 大于等于
!= 不等于
<=> 比较，返回 1, 0, or -1

操作符<=>结果为：
0 - 两个值相等
1 - 第一个值大
1 - 第二个值大
三、字符串比较操作符

Table 3.2. 字符串比较操作符

操作符描述　
lt 小于　
gt 大于　
eq 等于　
le 小于等于　
ge 大于等于　
ne 不等于　
cmp 比较，返回 1, 0, or -1 　

四、逻辑操作符
逻辑或：$a || $b 或 $a or $b
逻辑与：$a && $b 或 $a and $b
逻辑非：! $a 或 not $a
逻辑异或：$a xor $b
五、位操作符
位与：&
位或：|
位非：~
位异或：^
左移：$x << 1
右移：$x >> 2
注：不要将&用于负整数，因为PERL将会把它们转化为无符号数。
六、赋值操作符

Table 3.3. 赋值操作符

操作符描述
= Assignment only
+= Addition and assignment
-= Subtraction and assignment
*= Multiplication and assignment
/= Division and assignment
%= Remainder and assignment
**= Exponentiation and assignment
&= Bitwise AND and assignment
|= Bitwise OR and assignment
^= Bitwise XOR and assignment

Table 3.4. 赋值操作符例子

表达式等效表达式
$a = 1; none (basic assignment)
$a -= 1; $a = $a - 1;
$a *= 2; $a = $a * 2;
$a /= 2; $a = $a / 2;
$a %= 2; $a = $a % 2;
$a **= 2; $a = $a ** 2;
$a &= 2; $a = $a & 2;
$a |= 2; $a = $a | 2;
$a ^= 2; $a = $a ^ 2;

.=可在一个赋值语句中出现多次，如：
$value1 = $value2 = "a string";
.=作为子表达式
($a = $b) += 3;
等价于
$a = $b;
$a += 3;
但建议不要使用这种方式。
七、自增自减操作符：++、--(与C++中的用法相同)
.不要在变量两边都使用此种操作符：++$var-- # error
.不要在变量自增/减后在同一表达式中再次使用：$var2 = $var1 + ++$var1; # error
.在PERL中++可用于字符串，但当结尾字符为'z'、'Z'、'9'时进位，如：
$stringvar = "abc";
$stringvar++; # $stringvar contains "abd" now

$stringvar = "aBC";
$stringvar++; # $stringvar contains "aBD" now

$stringvar = "abz";
$stringvar++; # $stringvar now contains "aca"

$stringvar = "AGZZZ";
$stringvar++; # $stringvar now contains "AHAAA"

$stringvar = "ab4";
$stringvar++; # $stringvar now contains "ab5"

$stringvar = "bc999";
$stringvar++; # $stringvar now contains "bd000"
.不要使用--，PERL将先将字符串转换为数字再进行自减
$stringvar = "abc";
$stringvar--; # $stringvar = -1 now

.如果字符串中含有非字母且非数字的字符，或数字位于字母中，则经过++运算前值转换为数字零，因此结果为1，如：
$stringvar = "ab*c";
$stringvar++;
$stringvar = "ab5c";
$stringvar++;
八、字符串联结和重复操作符
联接: .
重复：x
联接且赋值(类似+=)： .=
例：
$newstring = "potato" . "head";
$newstring = "t" x 5;
$a = "be";
$a .= "witched"; # $a is now "bewitched"
九、逗号操作符
其前面的表达式先进行运算，如：
$var1 += 1, $var2 = $var1;
等价于
$var1 += 1;
$var2 = $var1;
使用此操作符的唯一理由是提高程序的可读性，将关系密切的两个表达式结合在一起，如：
$val = 26;
$result = (++$val, $val + 5); # $result = 32
注意如果此处没有括号则意义不同：
$val = 26;
$result = ++$val, $val + 5; # $result = 27
十、条件操作符
与C中类似，条件?值1:值2，当条件为真时取值1，为假时取值2，如：
$result = $var == 0 ? 14 : 7;
$result = 43 + ($divisor == 0 ? 0 : $dividend / $divisor);
PERL 5中，还可以在赋值式左边使用条件操作符来选择被赋值的变量，如：
$condvar == 43 ? $var1 : $var2 = 14;
$condvar == 43 ? $var1 = 14 : $var2 = 14;
十一、操作符的次序

Table 3.6. 操作符次序

操作符描述
++, -- 自增，自减
-, ~, ! 单目
** 乘方
=~, !~ 模式匹配
*, /, %, x 乘，除，取余，重复
+, -, . 加，减，联接
<<, >> 移位
-e, -r, etc. 文件状态
<, <=, >, >=, lt, le, gt, ge 不等比较
==, !=, <=>, eq, ne, cmp 相等比较
& 位与
|, ^ 位或，位异或
&& 逻辑与
|| 逻辑或
.. 列表范围
? and : 条件操作符
=, +=, -=, *=, 赋值
and so on 　
, 逗号操作符
not Low-precedence logical NOT
and Low-precedence logical AND
or, xor Low-precedence logical OR and XOR

.操作符结合性(associativity)：

Table 3.7. 操作符结合性

操作符结合性
++, -- 无
-, ~, ! Right-to-left
** Right-to-left
=~, !~ Left-to-right
*, /, %, x Left-to-right
+, -, . Left-to-right
<<, >> Left-to-right
-e, -r, 无
<, <=, >, >=, lt, le, gt, ge Left-to-right
==, !=, <=>, eq, ne, cmp Left-to-right
& Left-to-right
|, ^ Left-to-right
&& Left-to-right
|| Left-to-right
.. Left-to-right
? and : Right-to-left
=, +=, -=, *=, Right-to-left
and so on 　
, Left-to-right
not Left-to-right
and Left-to-right
or, xor Left-to-right

建议：
1、当你不确定某操作符是否先执行时，一定要用括号明确之。
2、用多行、空格等方式提高程序的可读性。

第三节：

一、列表
列表是包含在括号里的一序列的值，可以为任何数值，也可为空，如：(1, 5.3 , "hello" , 2)，空列表：()。
注：只含有一个数值的列表(如：(43.2) )与该数值本身(即：43.2 )是不同的，但它们可以互相转化或赋值。
列表例：
(17, $var, "a string")
(17, 26 << 2)
(17, $var1 + $var2)
($value, "The answer is $value")
二、数组--列表的存贮
列表存贮于数组变量中，与简单变量不同，数组变量以字符"@"打头，如：
@array = (1, 2, 3);
注：
(1)数组变量创建时初始值为空列表：()。
(2)因为PERL用@和$来区分数组变量和简单变量，所以同一个名字可以同时用于数组变量和简单变量，如：
$var = 1;
@var = (11, 27.1 , "a string");
但这样很容易混淆，故不推荐。
1、数组的存取
.对数组中的值通过下标存取，第一个元素下标为0。试图访问不存在的数组元素，则结果为NULL，但如果给超出数组大小的元素赋值，则数组自动增长，原来没有的元素值为NULL。如：
@array = (1, 2, 3, 4);
$scalar = $array[0];
$array[3] = 5; # now @array is (1,2,3,5)
$scalar = $array[4]; # now $scalar = null;
$array[6] = 17; # now @array is (1,2,3,5,"","",17)
.数组间拷贝
@result = @original;
.用数组给列表赋值
@list1 = (2, 3, 4);
@list2 = (1, @list1, 5); # @list2 = (1, 2, 3, 4, 5)
.数组对简单变量的赋值
(1) @array = (5, 7, 11);
($var1, $var2) = @array; # $var1 = 5, $var2 = 7, 11被忽略
(2) @array = (5, 7);
($var1, $var2, $var3) = @array; # $var1 = 5, $var2 = 7, $var3 ="" (null)
.从标准输入(STDIN)给变量赋值
$var = <STDIN>;
@array = <STDIN>; # ^D为结束输入的符号
2 、字符串中的方括号和变量替换
"$var[0]" 为数组@var的第一个元素。
"$var[0]" 将字符"["转义，等价于"$var". "[0]"，$var被变量替换，[0]保持不变。
"${var}[0]" 亦等价于"$var" ."[0]"。
"${var}"则取消了大括号的变量替换功能，包含文字：${var}.
3、列表范围：
(1..10) = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(2, 5..7, 11) = (2, 5, 6, 7, 11)
(3..3) = (3)
.用于实数
(2.1..5.3) = (2.1, 3.1 ,4.1, 5.1)
(4.5..1.6) = ()
.用于字符串
("aaa".."aad") = ("aaa","aab", "aac", "aad")
@day_of_month = ("01".."31")
.可包含变量或表达式
($var1..$var2+5)
.小技巧：
$fred = "Fred";
print (("Hello, " . $fred . "!n") x 2);
其结果为：
Hello, Fred!
Hello, Fred!
4、数组的输出：
(1) @array = (1, 2, 3);
print (@array, "n");
结果为：
123
(2) @array = (1, 2, 3);
print ("@arrayn");
结果为：
1 2 3
5、列表/数组的长度
当数组变量出现在预期简单变量出现的地方，则PERL解释器取其长度。
@array = (1, 2, 3);
$scalar = @array; # $scalar = 3,即@array的长度
($scalar) = @array; # $scalar = 1,即@array第一个元素的值
注：以数组的长度为循环次数可如下编程：
$count = 1;
while ($count <= @array) {
print ("element $count: $array[$count-1]n");
$count++;
}
6、子数组
@array = (1, 2, 3, 4, 5);
@subarray = @array[0,1]; # @subarray = (1, 2)
@subarray2 = @array[1..3]; # @subarray2 = (2,3,4)
@array[0,1] = ("string", 46); # @array =("string",46,3,4,5) now
@array[0..3] = (11, 22, 33, 44); # @array = (11,22,33,44,5) now
@array[1,2,3] = @array[3,2,4]; # @array = (11,44,33,5,5) now
@array[0..2] = @array[3,4]; # @array = (5,5,"",5,5) now
可以用子数组形式来交换元素：
@array[1,2] = @array[2,1];
7、有关数组的库函数
(1)sort--按字符顺序排序
@array = ("this", "is", "a","test");
@array2 = sort(@array); # @array2 = ("a","is", "test", "this")
@array = (70, 100, 8);
@array = sort(@array); # @array = (100, 70, 8) now
( 2)reverse--反转数组
@array2 = reverse(@array);
@array2 = reverse sort (@array);
(3)chop--数组去尾
chop的意义是去掉STDIN（键盘）输入字符串时最后一个字符--换行符。而如果它作用到数组上，则将数组中每一个元素都做如此处理。
@list = ("rabbit", "12345","quartz");
chop (@list); # @list = ("rabbi", "1234","quart") now
( 4)join/split--连接/拆分
join的第一个参数是连接所用的中间字符，其余则为待连接的字符数组。
$string = join(" ", "this", "is","a", "string"); # 结果为"this is a string"
@list = ("words","and");
$string = join("::", @list, "colons"); #结果为"words::and::colons"
@array = split(/::/,$string); # @array = ("words","and", "colons") now

第四节：

一、条件判断
if ( <expression>) {
<statement_block_1>
}
elsif ( <expression> ) {
<statement_block_2>
}
...
else{
<statement_block_3>
}
二、循环：
1、while循环
while ( <expression> ) {
<statement_block>
}
2、until循环
until ( <expression> ) {
<statement_block>
}
3、类C的for循环，如
for ($count=1; $count <= 5; $count++) {
# statements inside the loop go here
}
下面是在for循环中使用逗号操作符的例子：
for ($line = <STDIN>, $count = 1; $count <= 3; $line = <STDIN>, $count++) {
print ($line);
}
它等价于下列语句：
$line = <STDIN>;
$count = 1;
while ($count <= 3) {
print ($line);
$line = <STDIN>;
$count++;
}
4、针对列表(数组)每个元素的循环：foreach，语法为：
foreach localvar (listexpr) {
statement_block;
}
例：
foreach $word (@words) {
if ($word eq "the") {
print ("found the word 'the'n");
}
}
注：
(1)此处的循环变量localvar是个局部变量，如果在此之前它已有值，则循环后仍恢复该值。
(2)在循环中改变局部变量，相应的数组变量也会改变，如：
@list = (1, 2, 3, 4, 5);
foreach $temp (@list) {
if ($temp == 2) {
$temp = 20;
}
}
此时@list已变成了(1, 20, 3, 4, 5)。
5、do循环
do {
statement_block
} while_or_until (condexpr);
do循环至少执行一次循环。
6、循环控制
退出循环为last，与C中的break作用相同；执行下一个循环为next，与C中的continue作用相同；PERL特有的一个命令是redo，其含义是重复此次循环，即循环变量不变，回到循环起始点，但要注意，redo命令在do循环中不起作用。
7、传统的goto label;语句。

三、单行条件
语法为statement keyword condexpr。其中keyword可为if、unless、while或until，如：
print ("This is zero.n") if ($var == 0);
print ("This is zero.n") unless ($var != 0);
print ("Not zero yet.n") while ($var-- > 0);
print ("Not zero yet.n") until ($var-- == 0);
虽然条件判断写在后面，但却是先执行的。

第五节：

一、定义
子程序即执行一个特殊任务的一段分离的代码，它可以使减少重复代码且使程序易读。PERL中，子程序可以出现在程序的任何地方。定义方法为：
sub subroutine{
statements;
}
二、调用
调用方法如下：
1、用&调用
&subname;
...
sub subname{
...
}
2、先定义后调用，可以省略&符号
sub subname{
...
}
...
subname;
3、前向引用，先定义子程序名，后面再定义子程序体
sub subname;
...
subname;
...
sub subname{
...
}
4、用do调用
do my_sub(1, 2, 3);等价于&my_sub(1, 2, 3);
三、返回值
缺省的，子程序中最后一个语句的值将用作返回值。语句return (retval);也可以推出子程序并返回值retval，retval可以为列表。
四、局部变量
子程序中局部变量的定义有两种方法：my和local。其区别是：my定义的变量只在该子程序中存在；而local定义的变量不存在于主程序中，但存在于该子程序和该子程序调用的子程序中(在PERL4中没有my)。定义时可以给其赋值，如：
my($scalar) = 43;
local(@array) = (1, 2, 3);
五、子程序参数传递
1、形式
&sub1(&number1, $number2, $nubmer3);
...
sub sub1{
my($number1, $number2, $number3) = @_;
...
}
2、传送数组
&addlist (@mylist);
&addlist ("14", "6", "11");
&addlist ($value1, @sublist, $value2);
...
sub addlist {
my (@list) = @_;
...
}
参数为数组时，子程序只将它赋给一个数组变量。如
sub twolists {
my (@list1, @list2) = @_;
}
中@list2必然为空。但简单变量和数组变量可以同时传递：
&twoargs(47, @mylist); # 47赋给$scalar，@mylist赋给@list
&twoargs(@mylist); # @mylist的第一个元素赋给$scalar，其余的元素赋给@list
...
sub twoargs {
my ($scalar, @list) = @_;
...
}
六、递归子程序
PERL中，子程序可以互相调用，其调用方法与上述相同，当调用该子程序本身时，即成了递归子程序。递归子程序有两个条件：1、除了不被子程序改变的变量外，所有的变量必须的局部的；2、该子程序要含有停止调用本身的代码。
七、用别名传递数组参数
1、用前面讲到的调用方法&my_sub(@array)将把数组@array的数据拷贝到子程序中的变量@_中，当数组很大时，将会花费较多的资源和时间，而用别名传递将不做这些工作，而对该数组直接操作。形式如：
@myarray = (1, 2, 3, 4, 5);
&my_sub(*myarray);
sub my_sub {
my (*subarray) = @_;
}
2、此方法类似于C语言中的传递数组的起始地址指针，但并不一样，在定义数组的别名之后，如果有同名的简单变量，则对该变量也是起作用的。如：
$foo = 26;
@foo = ("here's", "a", "list");
&testsub (*foo);
...
sub testsub {
local (*printarray) = @_;
...
$printarray = 61;
}
当子程序执行完，主程序中的$foo的值已经成了61，而不再是26了。
3、用别名的方法可以传递多个数组，如：
@array1 = (1, 2, 3);
@array2 = (4, 5, 6);
&two_array_sub (*array1, *array2);
sub two_array_sub {
my (*subarray1, *subarray2) = @_;
}
在该子程序中，subarray1是array1的别名，subarray2是array2的别名。
八、预定义的子程序
PERL5预定义了三个子程序，分别在特定的时间执行，它们是：BEGIN子程序在程序启动时被调用；END子程序在程序结束时被调用；AUTOLOAD子程序在找不到某个子程序时被调用。你可以自己定义它们，以在特定时间执行所需要的动作。如：
BEGIN {
print("Hi! Welcome to Perl!n");
}
AUTOLOAD{
print("subroutine $AUTOLOAD not foundn"); # 变量$AUTOLOAD即未找到的子程序名
print("arguments passed: @_n");
}
若同一个预定义子程序定义了多个，则BEGIN顺序执行，END逆序执行。

第六节：

一、数组变量的限制
在前面讲的数组变量中，可以通过下标访问其中的元素。例如，下列语句访问数组@array的第三个元素：
$scalar = $array[2];
虽然数组很有用，但它们有一个显著缺陷，即很难记住哪个元素存贮的什么内容。假如我们来写一个程序计算某文件中首字母大写的单词出现的次数，用数组来实现就比较困难，程序代码如下：

1 : #!/usr/local/bin/perl
2 :
3 : while ($inputline = <STDIN>) {
4 : while ($inputline =~ /b[A-Z]S+/g) {
5 : $word = $&;
6 : $word =~ s/[;.,:-]$//; # remove punctuation
7 : for ($count = 1; $count <= @wordlist;
8 : $count++) {
9 : $found = 0;
10: if ($wordlist[$count-1] eq $word) {
11: $found = 1;
12: $wordcount[$count-1] += 1;
13: last;
14: }
15: }
16: if ($found == 0) {
17: $oldlength = @wordlist;
18: $wordlist[$oldlength] = $word;
19: $wordcount[$oldlength] = 1;
20: }
21: }
22: }
23: print ("Capitalized words and number of occurrences:n");
24: for ($count = 1; $count <= @wordlist; $count++) {
25: print ("$wordlist[$count-1]: $wordcount[$count-1]n");
26: }

运行结果如下：

Here is a line of Input.
This Input contains some Capitalized words.
^D
Capitalized words and number of occurrences:
Here: 1
Input: 2
This: 1
Capitalized: 1

这个程序每次从标准输入文件读一行文字，第四行起的循环匹配每行中首字母大写的单词，每找到一个循环一次，赋给简单变量$word。在第六行中去掉标点后，查看该单词是否曾出现过，7~15行中在@wordlist中挨个元素做此检查，如果某个元素与$word相等，@wordcount中相应的元素就增加一个数。如果没有出现过，即@wordlist中没有元素与$word相等，16~20行给@wordlist和@wordcount增加一个新元素。
二、定义
正如你所看到的，使用数组元素产生了一些问题。首先，@wordlist中哪个元素对应着哪个单词并不明显；更糟的是，每读进一个新单词，程序必须检查整个列表才能知道该单词是否曾经出现过，当列表变得较大时，这是很耗费时间的。
这些问题产生的原因是数组元素通过数字下标访问，为了解决这类问题，Perl定义了另一种数组，可以用任意简单变量值来访问其元素，这种数组叫做关联数组，也叫哈希表。
为了区分关联数组变量与普通的数组变量，Perl使用%作为其首字符，而数组变量以@打头。与其它变量名一样，%后的第一个字符必须为字母，后续字符可以为字母、数字或下划线。
三、访问关联数组的元素
关联数组的下标可以为任何简单/标量值，访问单个元素时以$符号打头，下标用大括号围起来。例如：

$fruit{"bananas"}
$number{3.14159}
$integer{-7}

简单变量也可作为下标，如：
$fruit{$my_fruit}
四、增加元素
创建一个关联数组元素最简单的方法是赋值，如语句$fruit{"bananas"} = 1；把1赋给关联数组%fruit下标为bananas的元素，如果该元素不存在，则被创建，如果数组%fruit从未使用过，也被创建。
这一特性使得关联数组很容易用于计数。下面我们用关联数组改写上面的程序，注意实现同样的功能此程序简化了许多。

1 : #!/usr/local/bin/perl
2 :
3 : while ($inputline = ) {
4 : while ($inputline =~ /b[A-Z]S+/g) {
5 : $word = $&;
6 : $word =~ s/[;.,:-]$//; # remove punctuation
7 : $wordlist{$word} += 1;
8 : }
9 : }
10: print ("Capitalized words and number of occurrences:n");
11: foreach $capword (keys(%wordlist)) {
12: print ("$capword: $wordlist{$capword}n");
13: }

运行结果如下：

Here is a line of Input.
This Input contains some Capitalized words.
^D
Capitalized words and number of occurrences:
This: 1
Input: 2
Here: 1
Capitalized: 1

你可以看到，这次程序简单多了，读取输入并存贮各单词数目从20行减少到了7行。
本程序用关联数组%wordlist跟踪首字母大写的单词，下标就用单词本身，元素值为该单词出现的次数。第11行使用了内嵌函数keys()。这个函数返回关联数组的下标列表，foreach语句就用此列表循环。
注：关联数组总是随机存贮的，因此当你用keys()访问其所有元素时，不保证元素以任何顺序出现，特别值得一提的是，它们不会以被创建的顺序出现。
要想控制关联数组元素出现的次序，可以用sort()函数对keys()返回值进行排列，如：

foreach $capword (sort keys(%wordlist)) {
print ("$capword: $wordlist{$capword}n");
}

五、创建关联数组
可以用单个赋值语句创建关联数组，如：
%fruit = ("apples",17,"bananas",9,"oranges","none");
此语句创建的关联数组含有下面三个元素：

下标为apples的元素，值为17
下标为bananas的元素，值为9
下标为oranges的元素，值为none
注：用列表给关联数组赋值时，Perl5允许使用"=>"或","来分隔下标与值，用"=>"可读性更好些，上面语句等效于：
%fruit = ("apples"=>17,"bananas"=>9,"oranges"=>"none");
六、从数组变量复制到关联数组
与列表一样，也可以通过数组变量创建关联数组，当然，其元素数目应该为偶数，如：
@fruit = ("apples",17,"bananas",9,"oranges","none");
%fruit = @fruit;
反之，可以把关联数组赋给数组变量，如：
%fruit = ("grapes",11,"lemons",27);
@fruit = %fruit;
注意，此语句中元素次序未定义，那么数组变量@fruit可能为("grapes",11,"lemons",27)或("lemons",27,"grapes",11)。
关联数组变量之间可以直接赋值，如：%fruit2 = %fruit1; 还可以把数组变量同时赋给一些简单变量和一个关联数组变量，如：
($var1, $var2, %myarray) = @list;
此语句把@list的第一个元素赋给$var1，第二个赋给$var2，其余的赋给%myarray。
最后，关联数组可以通过返回值为列表的内嵌函数或用户定义的子程序来创建，下例中把split()函数的返回值--一个列表--赋给一个关联数组变量。

1: #!/usr/local/bin/perl
2:
3: $inputline = <STDIN>;
4: $inputline =~ s/^s+|s+n$//g;
5: %fruit = split(/s+/, $inputline);
6: print ("Number of bananas: $fruit{"bananas"}n");

运行结果如下：

oranges 5 apples 7 bananas 11 cherries 6
Number of bananas: 11

七、元素的增删
增加元素已经讲过，可以通过给一个未出现过的元素赋值来向关联数组中增加新元素，如$fruit{"lime"} = 1;创建下标为lime、值为1的新元素。
删除元素的方法是用内嵌函数delete，如欲删除上述元素，则：
delete ($fruit{"lime"});
注意：

1、一定要使用delete函数来删除关联数组的元素，这是唯一的方法。
2、一定不要对关联数组使用内嵌函数push、pop、shift及splice，因为其元素位置是随机的。

八、列出数组的索引和值
上面已经提到，keys()函数返回关联数组下标的列表，如：

%fruit = ("apples", 9,
"bananas", 23,
"cherries", 11);
@fruitsubs = keys(%fruits);
这里，@fruitsubs被赋给apples、bananas、cherries构成的列表，再次提请注意，此列表没有次序，若想按字母顺序排列，可使用sort()函数。
@fruitindexes = sort keys(%fruits);
这样结果为("apples","bananas","cherries")。类似的，内嵌函数values()返回关联数组值的列表，如：

%fruit = ("apples", 9,
"bananas", 23,
"cherries", 11);
@fruitvalues = values(%fruits);
这里，@fruitvalues可能的结果为(9,23.11)，次序可能不同。
九、用关联数组循环
前面已经出现过利用keys()函数的foreach循环语句，这种循环效率比较低，因为每返回一个下标，还得再去寻找其值，如：

foreach $holder (keys(%records)){
$record = $records{$holder};
}

Perl提供一种更有效的循环方式，使用内嵌函数each()，如：

%records = ("Maris", 61, "Aaron", 755, "Young", 511);
while (($holder, $record) = each(%records)) {
# stuff goes here
}

each()函数每次返回一个双元素的列表，其第一个元素为下标，第二个元素为相应的值，最后返回一个空列表。
注意：千万不要在each()循环中添加或删除元素，否则会产生不可预料的后果。
十、用关联数组创建数据结构
用关联数组可以模拟在其它高级语言中常见的多种数据结构，本节讲述如何用之实现：链表、结构和树。
1、(单)链表
链表是一种比较简单的数据结构，可以按一定的次序存贮值。每个元素含有两个域，一个是值，一个是引用（或称指针），指向链表中下一个元素。一个特殊的头指针指向链表的第一个元素。
在Perl中，链表很容易用关联数组实现，因为一个元素的值可以作为下一个元素的索引。下例为按字母顺序排列的单词链表：

%words = ("abel", "baker",
"baker", "charlie",
"charlie", "delta",
"delta", "");
$header = "abel";
上例中，简单变量$header含有链表中第一个单词，它同时也是关联数组第一个元素的下标，其值baker又是下一个元素的下标，依此类推。
下标为delta的最后一个元素的值为空串，表示链表的结束。
在将要处理的数据个数未知或其随程序运行而增长的情况下，链表十分有用。下例用链表按字母次序输出一个文件中的单词。

1 : #!/usr/local/bin/perl
2 :
3 : # initialize list to empty
4 : $header = "";
5 : while ($line = <STDIN>) {
6 : # remove leading and trailing spaces
7 : $line =~ s/^s+|s+$//g;
8 : @words = split(/s+/, $line);
9 : foreach $word (@words) {
10: # remove closing punctuation, if any
11: $word =~ s/[.,;:-]$//;
12: # convert all words to lower case
13: $word =~ tr/A-Z/a-z/;
14: &add_word_to_list($word);
15: }
16: }
17: &print_list;
18:
19: sub add_word_to_list {
20: local($word) = @_;
21: local($pointer);
22:
23: # if list is empty, add first item
24: if ($header eq "") {
25: $header = $word;
26: $wordlist{$word} = "";
27: return;
28: }
29: # if word identical to first element in list,
30: # do nothing
31: return if ($header eq $word);
32: # see whether word should be the new
33: # first word in the list
34: if ($header gt $word) {
35: $wordlist{$word} = $header;
36: $header = $word;
37: return;
38: }
39: # find place where word belongs
40: $pointer = $header;
41: while ($wordlist{$pointer} ne "" &&
42: $wordlist{$pointer} lt $word) {
43: $pointer = $wordlist{$pointer};
44: }
45: # if word already seen, do nothing
46: return if ($word eq $wordlist{$pointer});
47: $wordlist{$word} = $wordlist{$pointer};
48: $wordlist{$pointer} = $word;
49: }
50:
51: sub print_list {
52: local ($pointer);
53: print ("Words in this file:n");
54: $pointer = $header;
55: while ($pointer ne "") {
56: print ("$pointern");
57: $pointer = $wordlist{$pointer};
58: }
59: }

运行结果如下：

Here are some words.
Here are more words.
Here are still more words.
^D
Words in this file:
are
here
more
some
still
words

此程序分为三个部分：

主程序：读取输入并转换到相应的格式。
子程序：add_word_to_list，建立排序单词链表。
子程序：print_list，输出单词链表
第3~17行为主程序，第4行初始化链表，将表头变量$header设为空串，第5行起的循环每次读取一行输入，第7行去掉头、尾的空格，第8行将句子分割成单词。9~15行的内循环每次处理一个单词，如果该单词的最后一个字符是标点符号，就去掉。第13行把单词转换成全小写形式，第14行传递给子程序 add_word_to_list。
子程序add_word_to_list先在第24行处检查链表是否为空。如果是，第25行将单词赋给$header，26行创建链表第一个元素，存贮在关联数组%wordlist中。如果链表非空，37行检查第一个元素是否与该单词相同，如果相同，就立刻返回。下一步检查这一新单词是否应该为链表第一个元素，即其按字母顺序先于$header。如果是这样，则：
1、创建一个新元素，下标为该新单词，其值为原第一个单词。
2、该新单词赋给$header。
如果该新单词不该为第一个元素，则40~44行利用局域变量$pointer寻找其合适的有效位置，41~44行循环到$wordlist{$ pointer}大于或等于$word为止。接下来46行查看该单词是否已在链表中，如果在就返回，否则47~48行将其添加到链表中。首先47行创建新元素$wordlist{$word}，其值为$wordlist{$pointer}，这时$wordlist{$word}和$wordlist{$ pointer}指向同一个单词。然后，48行将$wordlist{$pointer}的值赋为$word，即将$wordlist{$ pointer}指向刚创建的新元素$wordlist{$word}。
最后当处理完毕后，子程序print_list()依次输出链表，局域变量$pointer含有正在输出的值，$wordlist{$pointer}为下一个要输出的值。
注：一般不需要用链表来做这些工作，用sort()和keys()在关联数组中循环就足够了，如：

foreach $word (sort keys(%wordlist)) {
# print the sorted list, or whatever }

但是，这里涉及的指针的概念在其它数据结构中很有意义。
2、结构
许多编程语言可以定义结构(structure)，即一组数据的集合。结构中的每个元素有其自己的名字，并通过该名字来访问。
Perl不直接提供结构这种数据结构，但可以用关联数组来模拟。例如模拟C语言中如下的结构：

struce{
int field1;
int field2;
int field3; }mystructvar;

我们要做的是定义一个含有三个元素的关联数组，下标分别为field1、field2、field3，如：

%mystructvar = ("field1" , "" ,
"field2" , "" ,
"field3" , "" ,);

像上面C语言的定义一样，这个关联数组%mystrctvar有三个元素，下标分别为field1、field2、field3，各元素初始值均为空串。对各元素的访问和赋值通过指定下标来进行，如：
$mystructvar{"field1"} = 17;
3、树
另一个经常使用的数据结构是树。树与链表类似，但每个节点指向的元素多于一个。最简单的树是二叉树，每个节点指向另外两个元素，称为左子节点和右子节点（或称孩子），每个子节点又指向两个孙子节点，依此类推。
注：此处所说的树像上述链表一样是单向的，每个节点指向其子节点，但子节点并不指向父节点。
树的概念可以如下描述：

因为每个子节点均为一个树，所以左/右子节点也称为左/右子树。（有时称左/右分支）
第一个节点（不是任何节点的子节点的节点）称为树的根。
没有孩子（子节点）的节点称为叶节点。
有多种使用关联数组实现树结构的方法，最好的一种应该是：给子节点分别加上left和right以访问之。例如，alphaleft和alpharight指向alpha的左右子节点。下面是用此方法创建二叉树并遍历的例程：

1 : #!/usr/local/bin/perl
2 :
3 : $rootname = "parent";
4 : %tree = ("parentleft", "child1",
5 : "parentright", "child2",
6 : "child1left", "grandchild1",
7 : "child1right", "grandchild2",
8 : "child2left", "grandchild3",
9 : "child2right", "grandchild4");
10: # traverse tree, printing its elements
11: &print_tree($rootname);
12:
13: sub print_tree {
14: local ($nodename) = @_;
15: local ($leftchildname, $rightchildname);
16:
17: $leftchildname = $nodename . "left";
18: $rightchildname = $nodename . "right";
19: if ($tree{$leftchildname} ne "") {
20: &print_tree($tree{$leftchildname});
21: }
22: print ("$nodenamen");
23: if ($tree{$rightchildname} ne "") {
24: &print_tree($tree{$rightchildname});
25: }
26: }

结果输出如下：

grandchild1
child1
grandchild2
parent
grandchild3
child2
grandchild4

第七节：

一、引用简介
二、使用引用
三、使用反斜线()操作符
四、引用和数组
五、多维数组
六、子程序的引用
子程序模板
七、数组与子程序
八、文件句柄的引用

一、引用简介
引用就是指针，可以指向变量、数组、哈希表（也叫关联数组）甚至子程序。Pascal或C程序员应该对引用（即指针）的概念很熟悉，引用就是某值的地址，对其的使用则取决于程序员和语言的规定。在Perl中，可以把引用称为指针，二者是通用的，无差别的。引用在创建复杂数据方面十分有用。
Perl5中的两种引用类型为硬引用和符号引用。符号引用含有变量的名字，它对运行时创建变量名并定位很有用，基本上，符号引用就象文件名或UNIX系统中的软链接。而硬引用则象文件系统中的硬链接。
Perl4只允许符号引用，给使用造成一些困难。例如，只允许通过名字对包的符号名哈希表（名为_main{}）建立索引。Perl5则允许数据的硬引用，方便多了。
硬引用跟踪引用的计数，当其数为零时，Perl自动将被引用的项目释放，如果该项目是对象，则析构释放到内存池中。Perl本身就是个面向对象的语言，因为Perl中的任何东西都是对象，包和模块使得对象更易于使用。
简单变量的硬引用很简单，对于非简单变量的引用，你必须显式地解除引用并告诉其应如何做，详见《第章Perl中的面向对象编程》。
二、使用引用
本章中，简单变量指像$pointer这样的变量，$pointer仅含一个数据项，其可以为数字、字符串或地址。
任何简单变量均可保存硬引用。因为数组和哈希表含有多个简单变量，所以可以建立多种组合而成的复杂的数据结构，如数组的数组、哈希表的数组、子程序的哈希表等等。只要你理解其实只是在用简单变量在工作，就应该可以正确的在最复杂的结构中正确地解除引用。
首先来看一些基本要点。
如果$pointer的值为一个数组的指针，则通过形式@$pointer来访问数组中的元素。形式@$pointer的意义为“取出$pointer中的地址值当作数组使用”。类似的，%$pointer为指向哈希表中第一个元素的引用。
有多种构建引用的方法，几乎可以对任何数据建立引用，如数组、简单变量、子程序、文件句柄，以及--C程序员会感兴趣的--引用。Perl使你有能力写出把自己都搞糊涂的极其复杂的代码。:)
下面看看Perl中创建和使用引用的方法。
三、使用反斜线()操作符
反斜线操作符与C语言中传递地址的操作符&功能类似。一般是用创建变量又一个新的引用。下面为创建简单变量的引用的例子：
$variavle = 22;
$pointer = $variable;
$ice = "jello";
$iceprt = $ice;
引用$pointer指向存有$variable值的位置，引用$iceptr指向"jello"。即使最初的引用$variable销毁了，仍然可以通过$pointer访问该值，这是一个硬引用，所以必须同时销毁$pointer和$variable以便该空间释放到内存池中。
在上面的例子中，引用变量$pointer存的是$variable的地址，而不是值本身，要获得值，形式为两个$符号，如下：

#!/usr/bin/perl
$value = 10;
$pointer = $value;
printf "n Pointer Address $pointer of $value n";
printf "n What Pointer *($pointer) points to $$pointern";

结果输出如下：

Pointer Address SCALAR(0x806c520) of 10
What Pointer *(SCALAR(0x806c520)) points to 10

每次运行，输出结果中的地址会有所改变，但可以看到$pointer给出地址，而$$pointer给出$variable的值。
看一下地址的显示，SCALAR后面一串十六进制，SCALAR说明该地址指向简单变量（即标量），后面的数字是实际存贮值的地址。
注意：指针就是地址，通过指针可以访问该地址处存贮的数据。如果指针指向了无效的地址，就会得到不正确的数据。通常情况下，Perl会返回NULL值，但不该依赖于此，一定要在程序中把所有的指针正确地初始化，指向有效的数据项。
四、引用和数组
关于Perl语言应该记住的最重要的一点可能是：Perl中的数组和哈希表始终是一维的。因此，数组和哈希表只保存标量值，不直接存贮数组或其它的复杂数据结构。数组的成员要么是数（或字符串）要么是引用。
对数组和哈希表可以象对简单变量一样使用反斜线操作符，数组的引用如下：

1 #!/usr/bin/perl
2 #
3 # Using Array references
4 #
5 $pointer = @ARGV;
6 printf "n Pointer Address of ARGV = $pointern";
7 $i = scalar(@$pointer);
8 printf "n Number of arguments : $i n";
9 $i = 0;
10 foreach (@$pointer) {
11 printf "$i : $$pointer[$i++]; n";
12 }

运行结果如下：

$ test 1 2 3 4
Pointer Address of ARGV = ARRAY(0x806c378)
Number of arguments : 4
0 : 1;
1 : 2;
2 : 3;
3 : 4;

第5行将引用$pointer指向数组@ARGV，第6行输出ARGV的地址。$pointer返回数组第一个元素的地址，这与C语言中的数组指针是类似的。第7行调用函数scalar()获得数组的元素个数，该参数亦可为@ARGV，但用指针则必须用@$pointer的形式指定其类型为数组，$ pointer给出地址，@符号说明传递的地址为数组的第一个元素的地址。第10行与第7行类似，第11行用形式$$pointer[$i]列出所有元素。
对关联数组使用反斜线操作符的方法是一样的--把所有关联数组名换成引用$poniter。注意数组和简单变量（标量）的引用显示时均带有类型--ARRAY和SCALAR，哈希表（关联数组）和函数也一样，分别为HASH和CODE。下面是哈希表的引用的例子。

#!/usr/bin/perl
1 #
2 # Using Associative Array references
3 #
4 %month = (
5 '01', 'Jan',
6 '02', 'Feb',
7 '03', 'Mar',
8 '04', 'Apr',
9 '05', 'May',
10 '06', 'Jun',
11 '07', 'Jul',
12 '08', 'Aug',
13 '09', 'Sep',
14 '10', 'Oct',
15 '11', 'Nov',
16 '12', 'Dec',
17 );
18
19 $pointer = %month;
20
21 printf "n Address of hash = $pointern ";
22
23 #
24 # The following lines would be used to print out the
25 # contents of the associative array if %month was used.
26 #
27 # foreach $i (sort keys %month) {
28 # printf "n $i $$pointer{$i} ";
29 # }
30
31 #
32 # The reference to the associative array via $pointer
33 #
34 foreach $i (sort keys %$pointer) {
35 printf "$i is $$pointer{$i} n";
36 }

结果输出如下：

$ mth
Address of hash = HASH(0x806c52c)
01 is Jan
02 is Feb
03 is Mar
04 is Apr
05 is May
06 is Jun
07 is Jul
08 is Aug
09 is Sep
10 is Oct
11 is Nov
12 is Dec

与数组类似，通过引用访问哈希表的元素形式为$$pointer{$index}，当然，$index是哈希表的键值，而不仅是数字。还有几种访问形式，此外，构建哈希表还可以用=>操作符，可读性更好些。下面再看一个例子：

1 #!/usr/bin/perl
2 #
3 # Using Array references
4 #
5 %weekday = (
6 '01' => 'Mon',
7 '02' => 'Tue',
8 '03' => 'Wed',
9 '04' => 'Thu',
10 '05' => 'Fri',
11 '06' => 'Sat',
12 '07' => 'Sun',
13 );
14 $pointer = %weekday;
15 $i = '05';
16 printf "n ================== start test ================= n";
17 #
18 # These next two lines should show an output
19 #
20 printf '$$pointer{$i} is ';
21 printf "$$pointer{$i} n";
22 printf '${$pointer}{$i} is ';
23 printf "${$pointer}{$i} n";
24 printf '$pointer->{$i} is ';
25
26 printf "$pointer->{$i}n";
27 #
28 # These next two lines should not show anything 29 #
30 printf '${$pointer{$i}} is ';
31 printf "${$pointer{$i}} n";
32 printf '${$pointer->{$i}} is ';
33 printf "${$pointer->{$i}}";
34 printf "n ================== end of test ================= n";
35

结果输出如下：

================== start test =================
$$pointer{$i} is Fri
${$pointer}{$i} is Fri
$pointer->{$i} is Fri
${$pointer{$i}} is
${$pointer->{$i}} is
================== end of test =================

可以看到，前三种形式的输出显示了预期的结果，而后两种则没有。当你不清楚是否正确时，就输出结果看看。在Perl中，有不明确的代码就用print语句输出来实验一下，这能使你清楚Perl是怎样解释你的代码的。
五、多维数组
语句@array = list;可以创建数组的引用，中括号可以创建匿名数组的引用。下面语句为用于画图的三维数组的例子：
$line = ['solid' , 'black' , ['1','2','3'] , ['4','5','6']];
此语句建立了一个含四个元素的三维数组，变量$line指向该数组。前两个元素是标量，存贮线条的类型和颜色，后两个元素是匿名数组的引用，存贮线条的起点和终点。访问其元素语法如下：

$arrayReference->[$index] single-dimensional array
$arrayReference->[$index1][$index2] two-dimensional array
$arrayReference->[$index1][$index2][$index3] three-dimensional array

可以创建在你的智力、设计经验和计算机的内存允许的情况下极尽复杂的结构，但最好对可能读到或管理你的代码的人友好一些--尽量使代码简单些。另一方面，如果你想向别人炫耀你的编程能力，Perl给你足够的机会和能力编写连自己都难免糊涂的代码。:)
建议：当你想使用多于三维的数组时，最好考虑使用其它数据结构来简化代码。
下面为创建和使用二维数组的例子：

1 #!/usr/bin/perl
2 #
3 # Using Multi-dimensional Array references
4 #
5 $line = ['solid', 'black', ['1','2','3'] , ['4', '5', '6']];
6 print "$line->[0] = $line->[0] n";
7 print "$line->[1] = $line->[1] n";
8 print "$line->[2][0] = $line->[2][0] n";
9 print "$line->[2][1] = $line->[2][1] n";
10 print "$line->[2][2] = $line->[2][2] n";
11 print "$line->[3][0] = $line->[3][0] n";
12 print "$line->[3][1] = $line->[3][1] n";
13 print "$line->[3][2] = $line->[3][2] n";
14 print "n"; # The obligatory output beautifier.

结果输出如下：

$line->[0] = solid
$line->[1] = black
$line->[2][0] = 1
$line->[2][1] = 2
$line->[2][2] = 3
$line->[3][0] = 4
$line->[3][1] = 5
$line->[3][2] = 6

那么三维数组又如何呢？下面是上例略为改动的版本。

1 #!/usr/bin/perl
2 #
3 # Using Multi-dimensional Array references again
4 #
5 $line = ['solid', 'black', ['1','2','3', ['4', '5', '6']]];
6 print "$line->[0] = $line->[0] n";
7 print "$line->[1] = $line->[1] n";
8 print "$line->[2][0] = $line->[2][0] n";
9 print "$line->[2][1] = $line->[2][1] n";
10 print "$line->[2][2] = $line->[2][2] n";
11 print "$line->[2][3][0] = $line->[2][3][0] n";
12 print "$line->[2][3][1] = $line->[2][3][1] n";
13 print "$line->[2][3][2] = $line->[2][3][2] n";
14 print "n";

结果输出如下：

$line->[0] = solid
$line->[1] = black
$line->[2][0] = 1
$line->[2][1] = 2
$line->[2][2] = 3
$line->[2][3][0] = 4
$line->[2][3][1] = 5
$line->[2][3][2] = 6

访问第三层元素的方式形如$line->[2][3][0]，类似于C语言中的Array_pointer[2][3][0]。本例中，下标均为数字，当然亦可用变量代替。用这种方法可以把数组和哈希表结合起来构成复杂的结构，如下：

1 #!/usr/bin/perl
2 #
3 # Using Multi-dimensional Array and Hash references
4 #
5 %cube = (
6 '0', ['0', '0', '0'],
7 '1', ['0', '0', '1'],
8 '2', ['0', '1', '0'],
9 '3', ['0', '1', '1'],
10 '4', ['1', '0', '0'],
11 '5', ['1', '0', '1'],
12 '6', ['1', '1', '0'],
13 '7', ['1', '1', '1']
14 );
15 $pointer = %cube;
16 print "n Da Cube n";
17 foreach $i (sort keys %$pointer) {
18 $list = $$pointer{$i};
19 $x = $list->[0];
20 $y = $list->[1];
21 $z = $list->[2];
22 printf " Point $i = $x,$y,$z n";
23 }

结果输出如下：

Da Cube
Point 0 = 0,0,0
Point 1 = 0,0,1
Point 2 = 0,1,0
Point 3 = 0,1,1
Point 4 = 1,0,0
Point 5 = 1,0,1
Point 6 = 1,1,0
Point 7 = 1,1,1

这是一个定义立方体的例子。%cube中保存的是点号和坐标，坐标是个含三个数字的数组。变量$list获取坐标数组的引用：$list = $$ pointer{$i}; 然后访问各坐标值：$x = $list->[0]; ... 也可用如下方法给$x、$y和$z赋值：($x,$y,$z) = @$list;
使用哈希表和数组时，用$和用->是类似的，对数组而言下面两个语句等效：
$$names[0] = "kamran";
$names->[0] = "kamran";
对哈希表而言下面两个语句等效：
$$lastnames{"kamran"} = "Husain";
$lastnames->{"kamran"} = "Husain";
Perl中的数组可以在运行中创建和扩展。当数组的引用第一次在等式左边出现时，该数组自动被创建，简单变量和多维数组也是一样。如下句，如果数组contours不存在，则被创建：
$contours[$x][$y][$z] = &xlate($mouseX, $mouseY);
六、子程序的引用
perl中子程序的引用与C中函数的指针类似，构造方法如下：
$pointer_to_sub = sub {... declaration of sub ...};
通过所构造的引用调用子程序的方法为：
&$pointer_to_sub(parameters);
子程序模板
子程序的返回值不仅限于数据，还可以返回子程序的引用。返回的子程序在调用处执行，但却是在最初被创建的调用处被设置，这是由Perl对Closure处理的方式决定的。Closure意即如果你定义了一个函数，它就以最初定义的内容运行。(Closure详见OOP的参考书)下面的例子中，设置了多个错误信息显示子程序，这样的子程序定义方法可用于创建模板。

#!/usr/bin/perl
sub errorMsg {
my $lvl = shift;
#
# define the subroutine to run when called.
#
return sub {
my $msg = shift; # Define the error type now.
print "Err Level $lvl:$msgn"; }; # print later.
}
$severe = errorMsg("Severe");
$fatal = errorMsg("Fatal");
$annoy = errorMsg("Annoying");

&$severe("Divide by zero");
&$fatal("Did you forget to use a semi-colon?");
&$annoy("Uninitialized variable in use");

结果输出如下：

Err Level Severe:Divide by zero
Err Level Fatal:Did you forget to use a semi-colon?
Err Level Annoying:Uninitialized variable in use

上例中，子程序errorMsg使用了局域变量$lvl，用于返回给调用者。当errorMsg被调用时，$lvl的值设置到返回的子程序内容中，虽然是用的my函数。三次调用设置了三个不同的$lvl变量值。当errorMsg返回时，$lvl的值保存到每次被声明时所产生的子程序代码中。最后三句对产生的子程序引用进行调用时$msg的值被替换，但$lvl的值仍是相应子程序代码创建时的值。
很混淆是吗？是的，所以这样的代码在Perl程序中很少见。
七、数组与子程序
数组利于管理相关数据，本节讨论如何向子程序传递多个数组。前面我们讲过用@_传递子程序的参数，但是@_是一个单维数组，不管你传递的参数是多少个数组，都按序存贮在@_中，故用形如my(@a,@b)=@_; 的语句来获取参数值时，全部值都赋给了@a，而@b为空。那么怎么把一个以上的数组传递给子程序呢？方法是用引用。见下例：

#!/usr/bin/perl
@names = (mickey, goofy, daffy );
@phones = (5551234, 5554321, 666 );
$i = 0;
sub listem {
my ($a,$b) = @_;
foreach (@$a) {
print "a[$i] = " . @$a[$i] . " " . "tb[$i] = " . @$b[$i] ."n";
$i++;
}
}
&listem(@names, @phones);

结果输出如下：

a[0] = mickey b[0] = 5551234
a[1] = goofy b[1] = 5554321
a[2] = daffy b[2] = 666
注意：

1、当想传递给子程序的参数是多于一个的数组时一定要使用引用。
2、一定不要在子程序中使用形如 (@variable)=@_; 的语句处理参数，除非你想把所有参数集中到一个长的数组中。

八、文件句柄的引用
有时，必须将同一信息输出到不同的文件，例如，某程序可能在一个实例中输出到屏幕，另一个输出到打印机，再一个输出到记录文件，甚至同时输出到这三个文件。相比较于每种处理写一个单独的语句，可以有更好的实现方式如下：
spitOut(*STDIN);
spitOut(*LPHANDLE);
spitOut(*LOGHANDLE);
其中子程序spitOut的代码如下：

sub spitOut {
my $fh = shift;
print $fh "Gee Wilbur, I like this lettucen";
}

注意其中文件句柄引用的语法为*FILEHANDLE。
Perl中的模块

注: 如果你的e文好, 那就看一看PERL的MAN手册吧那里面什么都有PERL 中的模块结构很简单用起来也不难但至少我不是很喜欢它

注意 PERL中的模块和类是同意词

perlobj.1 中对模块有三条简单的定义

1 一个模块是一个引用但系统知道它属于那一个类

2 一个类是一个包它提供了一些方法

3 一个方法是一个SUB 它的第一个参数为一个类的引用

在PERL中并没有明确的定义类的构造函数

我们所使用的类的引用一般是一个HASH的引用通过调用函数bless

将它同一个类绑在一起

例如:

Critter.pm

package Critter

sub new {

bless {};

}

本例中返回了一个空的HASH表(PERL中也叫做匿名表)

复杂一点的例子

try.pm

package try;

sub new {

$para = @_;

%hash = {};

$hash{'a'} = $para{'a'};

bless %hash, try;

return %hash;

}

sub pp {

print shift;

print ("\n", @_);

}

a.pl // 它与try.pm放在同一个目录下

use try;

$m_try = try::new(a => "hello");

$m_try->pp("hello world");

一般的文章上都说应该这样用:

sub new {

my $this = shift;

my $class = ref($this) || $this;

my $self = {};

bless $self, $class

$self->initialize();

return $self;

}

而上面的例子却不是这样 Why?

这个问题涉及到如何new一个类.

1 try::new(a => "hello");

2 try->new(a => "hello");

3 new try(a => "hello");

第二个和第三个是一样的

2,3 中函数new的参数是 ('try', 'a', 'hello')

1 的参数却是('a', 'hello');

#对于2 3 你可以理解为将class->new(arg); 转换为 new::(class,arg)

#这与class是什么东西无关如同 $m_class->method(arg)被转换为

#class::method($m_class,arg)一样

PERL的类常用 2 3 两种方法创建

当调用一个类中的方法时第一个参数为HASH表的引用

try.pm

sub pp {

$class = shift;

print (@_, $class->{'a'});

}

$m_try = new try('a' => 'hello');

$m_try->pp("ha ha ha");

下面看一看 PERL中类的继承

PERL的类继承很奇怪子类的目录比父类低一层

如

Tk.pm

Tk/Button.pm

Button.pm

package Tk::Button.pm

...

另一种方法是使用@ISA

class UNIVERSAL

这是一个特殊的类所有的类都是它的子类它定义了如下的方法

isa 判断是不是某个类的引用

can 是否存在某个方法

VERSION 判断版本号

SUPER:: 用于调用父类中的方法

如:

$self->SUPER::get();

先看一看如何使用@ISA 完成类的继承

#try.pm 父类

package try;

$VERSION = "1.00";

sub new {

bless {} ,try;

}

sub pp {

print "this is in father class\n";

}

#tt.pm 子类

package tt;

use trk;

@ISA = qw(try); #这样在tt中找不到的方法会在try中查找

#如同tt是try的子类

sub new {

bless {} ,tt;

}

sub pp {

print "this is in son class\n";

}

#c.pl

#!/usr/bin/perl

use tt;

$m_tt = new tt;

$m_tt->pp;

这中方法会显示 "this is in son class"

注: 你应该定义new在类tt.pm中, 不然会显示

"this is in father class"

原因是调用了try中的new, 引用被bless成了try的.

修改tt.pm

sub pp {

$self = shift;

$self->SUPER::pp; #调用父类中的方法

}

会显示"this is in father"
9: Perl 中的正则表达式
正则表达式的三种形式

正则表达式中的常用模式

正则表达式的 8 大原则

正则表达式是 Perl 语言的一大特色，也是 Perl 程序中的一点难点，不过如果大家能够很好的掌握他，就可以轻易地用正则表达式来完成字符串处理的任务，当然在 CGI 程序设计中就更能得心应手了。下面我们列出一些正则表达式书写时的一些基本语法规则。

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

9.1 正则表达式的三种形式
首先我们应该知道 Perl 程序中，正则表达式有三种存在形式，他们分别是：

匹配：m/<regexp>/ （还可以简写为 /<regexp>/ ，略去 m）

替换：s/<pattern>/<replacement>/

转化：tr/<pattern>/<replacemnt>/

这三种形式一般都和 =~ 或 !~ 搭配使用（其中 "=~" 表示相匹配，在整条语句中读作 does，"!~" 表示不匹配，在整条语句中读作 doesn't），并在左侧有待处理的标量变量。如果没有该变量和 =~ !~ 操作符，则默认为处理 $_ 变量中的内容。举例如下：

$str = "I love Perl";
$str =~ m/Perl/; # 表示如果在 $str 中发现 "Perl" 字符串，则返回 "1" 否则返回 "0"。
$str =~ s/Perl/BASH/; # 表示将变量 $str 中的 "Perl" 字符串替换为 "BASH"，如果发生此替换则返回 "1"，否则返回 "0"。
$str !~ tr/A-Z/a-z/; # 表示将变量 $str 中的所有大写字母转化为小写字母，如果转化发生了则返回 "0"，否则返回 "1"。

另外还有：

foreach (@array) { s/a/b/; } # 此处每次循环将从 @array 数组中取出一个元素存放在 $_ 变量中，并对 $_ 进行替换处理。
while (<FILE>) { print if (m/error/); } # 这一句稍微复杂一些，他将打印 FILE 文件中所有包含 error 字符串的行。

Perl 的正则表达式中如果出现 () ，则发生匹配或替换后 () 内的模式被 Perl 解释器自动依次赋给系统 $1, $2 ...... 请看下面的例子：

$string = "I love perl";
$string =~ s/(love)/<$1>/; # 此时 $1 = "love"，并且该替换的结果是将 $string 变为 "I <love> perl"
$string = "i love perl";
$string =~ s/(i)(.*)(perl)/<$3>$2<$1>/; # 这里 $1 = "i"，$2 = " love "，$3 = "perl"，并且替换后 $string 变为 "<perl> love <i>"

替换操作 s/<pattern>/<replacement>/ 还可以在末尾加上 e 或 g 参数，他们的含义分别为：

s/<pattern>/<replacement>/g 表示把待处理字符串中所有符合 <pattern> 的模式全部替换为 <replacement> 字符串，而不是只替换第一个出现的模式。
s/<pattern>/<replacement>/e 表示将把 <replacemnet> 部分当作一个运算符，这个参数用的不多。

比如下面的例子：

$string = "i:love:perl";
$string =~ s/:/*/; #此时 $string="i*love:perl";
$string = "i:love:perl";
$string =~ s/:/*/g; #此时 $string="i*love*perl";
$string =~ tr/*/ /; #此时 $string="i love perl";
$string = "www22cgi44";
$string =~ s/(\d+)/$1*2/e; # (/d+)代表 $string 中的一个或多个数字字符，将这些数字字符执行 *2 的操作，因此最后 $string 变成了 "www44cgi88"。

下面给出一个完整的例子：

#!/usr/bin/perl

print"请输入一个字符串!\n";
$string = <STDIN>; # <STIDN>代表标准输入，会让使用者输入一字符串
chop($string); # 将$string最后一个换行的字符\n删除掉
if($string =~ /perl/){
print("输入的字符串中有 perl 这个字符串!\n";
}

如果输入的字符串含有 perl 这个字符串的话，就会显示后面的提示信息。

9.2 正则表达式中的常用模式
下面是正则表达式中的一些常用模式。

/pattern/ 结果
. 匹配除换行符以外的所有字符
x? 匹配 0 次或一次 x 字符串
x* 匹配 0 次或多次 x 字符串，但匹配可能的最少次数
x+ 匹配 1 次或多次 x 字符串，但匹配可能的最少次数
.* 匹配 0 次或一次的任何字符
.+ 匹配 1 次或多次的任何字符
{m} 匹配刚好是 m 个的指定字符串
{m,n} 匹配在 m个以上 n个以下的指定字符串
{m,} 匹配 m个以上的指定字符串
[] 匹配符合 [] 内的字符
[^] 匹配不符合 [] 内的字符
[0-9] 匹配所有数字字符
[a-z] 匹配所有小写字母字符
[^0-9] 匹配所有非数字字符
[^a-z] 匹配所有非小写字母字符
^ 匹配字符开头的字符
$ 匹配字符结尾的字符
\d 匹配一个数字的字符，和 [0-9] 语法一样
\d+ 匹配多个数字字符串，和 [0-9]+ 语法一样
\D 非数字，其他同 \d
\D+ 非数字，其他同 \d+
\w 英文字母或数字的字符串，和 [a-zA-Z_0-9] 语法一样
\w+ 和 [a-zA-Z0-9]+ 语法一样
\W 非英文字母或数字的字符串，和 [^a-zA-Z_0-9] 语法一样
\W+ 和 [^a-zA-Z_0-9]+ 语法一样
\s 空格，和 [\n\t\r\f] 语法一样
\s+ 和 [\n\t\r\f]+ 一样
\S 非空格，和 [^\n\t\r\f] 语法一样
\S+ 和 [^\n\t\r\f]+ 语法一样
\b 匹配以英文字母,数字为边界的字符串
\B 匹配不以英文字母,数值为边界的字符串
a|b|c 匹配符合a字符或是b字符或是c字符的字符串
abc 匹配含有 abc 的字符串
(pattern) () 这个符号会记住所找寻到的字符串，是一个很实用的语法。第一个 () 内所找到的字符串变成 $1 这个变量或是 \1 变量，第二个 () 内所找到的字符串变成 $2 这个变量或是 \2 变量，以此类推下去。
/pattern/i i 这个参数表示忽略英文大小写，也就是在匹配字符串的时候，不考虑英文的大小写问题。
\ 如果要在 pattern 模式中找寻一个特殊字符，如 "*"，则要在这个字符前加上 \ 符号，这样才会让特殊字符失效

下面给出一些例子：

范例说明
/perl/ 找到含有 perl 的字符串
/^perl/ 找到开头是 perl 的字符串
/perl$/ 找到结尾是 perl 的字符串
/c|g|i/ 找到含有 c 或 g 或 i 的字符串
/cg{2,4}i/ 找到 c 后面跟着 2个到 4个 g ，再跟着 i 的字符串
/cg{2,}i/ 找到 c 后面跟着 2个以上 g ，再跟着 i 的字符串
/cg{2}i/ 找到 c 后面跟着 2个 g，再跟着 i 的字符串
/cg*i/ 找到 c 后面跟着 0个或多个 g ，再跟着 i 的字符串，如同/cg{0,}i/
/cg+i/ 找到 c 后面跟着一个以上 g，再跟着 i 的字符串，如同/cg{1,}i/
/cg?i/ 找到 c 后面跟着 0个或是 1个 g ，再跟着 i 的字符串，如同/cg{0,1}i/
/c.i/ 找到 c 后面跟着一个任意字符，再跟着 i 的字符串
/c..i/ 找到 c 后面跟着二个任意字符，再跟着 i 的字符串
/[cgi]/ 找到符合有这三个字符任意一个的字符串
/[^cgi]/ 找到没有这三个字符中任意一个的字符串
/\d/ 找寻符合数字的字符，可以使用/\d+/来表示一个或是多个数字组成的字符串
/\D/ 找寻符合不是数字的字符，可以使用/\D+/来表示一个或是更多个非数字组成的字符串
/\*/ 找寻符合 * 这个字符，因为 * 在常规表达式中有它的特殊意思，所以要在这个特殊符号前加上 \ 符号，这样才会让这个特殊字符失效
/abc/i 找寻符合 abc 的字符串而且不考虑这些字符串的大小写

9.3 正则表达式的八大原则
如果在 Unix 中曾经使用过 sed、awk、grep 这些命令的话，相信对于 Perl 语言中的正则表达式(Regular Expression)不会感到陌生。Perl 语言由于有这个功能，所以对字符串的处理能力非常强。在Perl语言的程序中，经常可以看到正则表达式的运用，在 CGI 程序设计中也不例外。

正则表达式是初学 Perl 的难点所在，不过只要一旦掌握其语法，你就可以拥有几乎无限的模式匹配能力，而且 Perl 编程的大部分工作都是掌握常规表达式。下面给大家介绍几条正则表达式使用过程中的 8 大原则。

正则表达式在对付数据的战斗中可形成庞大的联盟——这常常是一场战争。我们要记住下面八条原则：

· 原则1：正则表达式有三种不同形式(匹配(m/ /)，替换(s/ / /eg)和转换(tr/ / /))。

· 原则2：正则表达式仅对标量进行匹配( $scalar =~ m/a/; 可以工作; @array =~ m/a/ 将把@array作为标量对待，因此可能不会成功)。

· 原则3：正则表达式匹配一个给定模式的最早的可能匹配。缺省时，仅匹配或替换正则表达式一次( $a = 'string string2'; $a =~ s/string/ /; 导致 $a = 'string 2')。

· 原则4：正则表达式能够处理双引号所能处理的任意和全部字符( $a =~ m/$varb/ 在匹配前把varb扩展为变量；如果 $varb = 'a' $a = 'as'，$a =~ s/$varb/ /; 等价于 $a =~ s/a/ /; ，执行结果使 $a = " s" )。

· 原则5：正则表达式在求值过程中产生两种情况：结果状态和反向引用： $a=~ m/pattern/ 表示 $a 中是否有子串 pattern 出现，$a =~ s/(word1)(word2)/$2$1/ 则“调换”这两个单词。

· 原则6：正则表达式的核心能力在于通配符和多重匹配运算符以及它们如何操作。$a =~ m/\w+/ 匹配一个或多个单词字符；$a =~ m/\d/" 匹配零个或多个数字。

· 原则7：如果欲匹配不止一个字符集合，Perl使用 "|" 来增加灵活性。如果输入 m/(cat|dog)/ 则相当于“匹配字符串 cat 或者 dog。

· 原则8：Perl用 (?..) 语法给正则表达式提供扩展功能。（这一点请同学们课后看相关资料）

想要学习所有这些原则？我建议大家先从简单的开始，并且不断的尝试和实验。实际上如果学会了 $a =~ m/ERROR/ 是在 $a 中查找子串ERROR，那么你就已经比在 C 这样的低层语言中得到了更大的处理能力。
Perl 数据结构

变量名字

Perl 有三种数据结构: 数值, 数值的数组, 还有数值的关联数组, 即``哈希表''. 普通的数组以数字为索引, 从 0 开始(负值的下标从数组尾部开始计算). 哈希表中的元素是以字符串索引.

数值变量以 '$' 打头, 当引用数组中的一个元素时也一样. 意思是"这". 举例:

$days # 数值变量 &quot;days&quot; $days[28] # 数组 @days 的第29个元素 $days{'Feb'} # 哈希表 %days 中 'Feb' 代表的数值 $#days # 数组 @days 的最大下标

当表示整个数组或数组的一部分时, 用 '@' 打头, 意思是 "这些" 或 "那些"

@days # ($days[0], $days[1],... $days[n]) @days[3,4,5] # 即 @days[3..5] @days{'a','c'} # 即 ($days{'a'},$days{'c'})

当表示整个哈希表时用 '%' 打头:

%days # (key1, val1, key2, val2 ...)

此外, 子过程用 '&' 打头, 当不致引起混淆的时候可以省略. 符号表表项用 '*' 打头, 手册后面部分有详细说明.

不同的变量类型有自己的名字空间. 为一个数值变量, 一个数组和一个哈希表(一个文件句柄, 一个子过程, 一个标号)取相同的名字并不会引起冲突. 也就是说, $foo 和 @foo 是两个不同的变量. $foo[1] 是 @foo 的一部分, 而不是 $foo 的一部分. 看起来也许有点怪, 但要习惯它.

既然变量和数组名都是以 '$', '@', 或 '%' 打头, 那些 ``保留字'' 实际上并非对变量而言. (它们实际上是对标号和文件句柄而言, 标号和文件句柄是没有特殊的打头字母. 给一个文件句柄取名 ``log'' 是错误的. 应该用 open(LOG,'logfile') 而非 open(log,'logfile') . 用大写字母来表示文件句柄也增加了可读性, 避免和将来出现的保留字冲突.) 大小写是区分的 -- ``FOO'', ``Foo'' 和 ``foo'' 是完全不同的名字. 以字母或下划线开头的名字可以包含数字和下划线.

一个以字母数字组成的名字代表的变量可以用一个返回同类型的引用的表达式代替, 详见 perlref .

数字开头的名字只能包含更多的数字. 不是以字母, 数字, 下划线开头的名字只能有一个字符. 例如: $% 或 $$ . (大部分这些单字符名字是 Perl 的预定义变量, 例如, $$ 是当前进程号.)

变量名字
Perl 对操作和变量值的解释有时依赖于上下文. 主要的上下文有两种: 数值和列表. 某些操作, 如果上下文期待的是列表, 就返回列表结果, 对期待数值的上下文就返回数值(如果某种操作有这种上下文依赖性, 会在有关文档中说明). 换句话说, Perl 会根据期待的结果是单个或多个重载一些操作.

与此相对的, 一个操作会为它的每一个参数确定上下文. 例如

int( <stdin>)

取整数操作为 <STDIN> 提供了一个数值上下文, <STDIN> 在 STDIN 读入一行并传送给取整数操作, 后者求出这一行代表的整数值并返回. 而下面的例子

sort( <stdin>)

排序操作为 <STDIN> 提供了一个列表上下文, 从 STDIN 中读入所有的行直到文件结束, 这些行组成的列表被传送到排序操作, 后者对它们排序并返回排序后的行列表.

赋值操作是用等号左边的参数来确定右边参数的上下文. 为数值变量赋值的操作给右边参数确定了数值上下文, 给数组或数组的一部分赋值的时候右边参数是处于列表上下文.

自定义的子过程可以自行确定被调用时的上下文, 但很多场合下不需要这么做, 因为数值可以自动转化成列表. 参看 wantarray .

数值变量
Perl 里的数据要么是数值型, 要么是数值型的数组, 要么是数值型的哈希表. 数值变量可以存放不同类型的单个数据, 比如数字, 字符串, 和引用. 一般情况下, 不同类型之间的转换是透明的. (一个数值型不能存放多个值, 但可以存放对数组或哈希表的引用.) 由于自动类型转换, 返回数值型的操作和函数不需要担心(实际上是不能担心)上下文是等待一个数字还是一个字符串.

数值型不必确定自己的类型. 其实也没有地方去把一个数值型变量声明为``string'', 或 ``number'', 或``filehandle'', 或是其它什么类型. 在 Perl 中, 数值型变量的类型可以是数字或字符串或引用, 根据上下文确定. 字符串和数字实际上没什么两样, 但引用是不可转换的指针, 有内建的引用计数和析构过程.

非空的字符串或非 0 (字符串``0'')的数字可以表示布尔类型中的真值. 布尔上下文是一种特殊的数值型上下文.

空数值型实际上有两种情况: 已定义和未定义的. 当没有任何实际的值存在时, 未定义的空数值型被返回, 比如发生错误的时候, 或者读到文件结束的地方, 或者引用了一个未初始化的变量. 当一个未定义的空数值型首次被使用时, 就变成已定义的, 在此之前可以用 defined() 去检查一个值是否被定义了.

要知道一个字符串是否一个有效的非 0 数字, 一般是确定它不是数值 0 或字符串 ``0''

if ($str == 0 &amp;&amp; $str ne &quot;0&quot;) { warn &quot;That doesn't look like a number&quot;; }

别的方法是用正则表达式进行检查, 参看 perlre 中对正则表达式的详细介绍.

warn &quot;has nondigits&quot; if /\D/; warn &quot;not a whole number&quot; unless /^\d+$/; warn &quot;not an integer&quot; unless /^[+-]?\d+$/ warn &quot;not a decimal number&quot; unless /^[+-]?\d+\.?\d*$/ warn &quot;not a C float&quot; unless /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;

数组的长度是一个数值型. 数组 @days 的长度是 $# days, 的值, 和 csh 里一样. (实际上这不是数组的长度, 是最大的下标, 因为有数组里第 0 个元素.) 给 $# days 赋值可以改变数组的长度. 用同样的方法缩短数组的长度会破坏被截去的数值. 重新增加被缩短的数组不再能恢复这些数值(在 Perl 4 里是可以的, 但为了保证正确的调用析构做了这样的改变). 给超出最大下标的数组元素赋值可以扩展数组的长度, 给数组赋上空的列表 () 就把数组的长度减为 0 .

@whatever = (); $#whatever = $[ - 1;

如果在数值型上下文里计算数组的值, 会得到数组的长度. (并不适用于列表, 会返回最后一个值, 象 C 的逗号操作符) 以下的等式是成立的:

scalar(@whatever) == $#whatever - $[ + 1;

Perl 第 5 版改变了 $[ 的语意: 不设置 $[ 的文件不用担心别的文件会否改变自己的 $[ 的值. (换句话说, 不赞成使用 $[) 所以一般可以认为

scalar(@whatever) == $#whatever + 1;

有些程序员选择显式的转换:

$element_count = scalar(@whatever);

如果在数值型上下文里计算哈希表的值, 如果哈希表里有key/value对, 会得到一字符串, 其中包含了该哈希表占据的空间和已经分配的空间, 用 '/' 分开. 这可以检查一下 Perl 的散列算法是否有效. 比如, 在哈希表里存放了 10,000 个元素, 而在数值型上下文里计算 %HASH 得到 ``1/16'', 那情况就太浪费空间了.

数值型的值的表示
数字用习惯的浮点数或整数表示法:

12345 12345.67 .23E-10 0xffff # 16 进制 0377 # 8 进制 4_294_967_296 # 用下划线容易阅读

字符串一般用单引号或双引号括住. 引号的作用和 shell 里类似: 双引号字符串中可以有反斜杠和变量替换; 单引号字符串不行(除了 ``\''' 和 ``\\''). 一般的 Unix 反斜杠替换规则同样用来表示换行符, 制表符...等等. 见列表qq.

换行符可以直接嵌入在字符串中. 但如果忘记了结尾的引号, 直到 Perl 找到另外一行有引号的行前不会报出任何错误. 字符串中的变量替换限制于数值型, 数组和数组的部分. (即以$ 或 @ 打头的标识符, 后跟一个可选的括起来的下标) 下面的代码打印出 "The price is $100."

$Price = '$100'; # not interpreted print &quot;The price is $Price.\n&quot;; # interpreted

和在某些 shell 下一样, 可以用花括号把标识符括住, 以区别于其他后随的字母. 实际上, 花括号中的标识符一定是个字符串, 就象一个哈希表的下标. 早先的例子

$days{'Feb'}

可以写成

$days{Feb}

引号是会被自动加上, 而下标中复杂的部分会被解释为表达式.

要注意, 单引号字符串要和前面的词用空白隔开, 因为单引号本身是可以组成标识符. (参看Packages).

有两个特别的字符串是 __LINE__ 和 __FILE__, 分别代表程序执行点的当前行号和文件名. 它们只能用做分隔记号; 不能被转换成字符串. 此外, __END__ 可以用于在脚本的真正结束位置前标记逻辑结束位置, 在此后的所有文字都被忽略, 但可以通过 DATA 文件句柄读出. (DATA 文件句柄只能从主脚本读取, 不能从required包含的文件或计算的字符串读取) 控制字符 ^D 和 ^Z 是 __END__ 的同义字. (在模块里是 __DATA__ 的同义字; 关于 __DATA__ 的详细说明, 参看SelfLoader)

在语法上没有其他解释的词都被看作一个引起来的字符串. 称为``净词''. 和文件句柄和标号一样, 全是小写字母的净词可能会和将来的保留字冲突, 如果使用 -w 选项, Perl 会对这些词发出警告. 有些人会完全不使用净词. 如果用

use strict 'subs';

那么所有不能被解释为子过程调用的净词都会产生一条编译时刻错误. 严格检查一直到闭合块的结尾为止. 内部块用以下方法可以撤消严格检查 no strict 'subs' .

如果把数组的所有元素连接到一起形成一个双引号字符串, 以变量 $" ( $LIST_SEPARATOR )指定的字符做为分隔符(默认为空格).

$temp = join($&quot;,@ARGV); system &quot;echo $temp&quot;; system &quot;echo @ARGV&quot;;

在搜索模式(也要做替换)中模糊是很糟糕的: 到底 /$foo[bar]/ 是解释为 /${foo}[bar]/ ([bar]/ 是正则表达式字符类) 还是解释成 /${foo[bar]}/ ([bar]/ 是数组下标)? 如果 @foo 不存在, 那么明显是个字符类. 如果 @foo 存在, Perl 要猜测 [bar] 是什么, 一般结果是正确的. 但如果猜错了, 或者你可以用花括号来指示正确的解释方法.

面向行的引用是建立在 shell 的 ``here-doc'' 语法上. 在 << 后面指定一个结束引用的字符串, 当前行的所有后随行直到结束串都是引用的内容. 结束字符串可以是一个标识符(一个词), 或引起来的一段文字. 如果是引起来的文字, 引的方式决定了对文字的处理, 象普通的引用. << 和标识符之间不能够有空白. 如果有空白, 引用到第一个空白行为止. 结束字符串必须单独出现在一行, 前后不能有空白.

print <<EOF; # same as above
The price is $Price.
EOF
print <<``EOF''; # same as above
The price is $Price.
EOF
print <<`EOC`; # execute commands
echo hi there
echo lo there
EOC
print <<``foo'', <<``bar''; # you can stack them
I said foo.
foo
I said bar.
bar
myfunc(<<``THIS'', 23, <<'THAT'');
Here's a line
or two.
THIS
and here another.
THAT

要记得结束的分号, 下面的代码是错误的

print <<ABC
179231
ABC
+ 20;

列表值的表示
列表值用多个用逗号分隔的单独值表示(并用括号括起来):

(LIST)

在非列表的上下文里, 列表的值是最后一个元素的值. 例如,

@foo = ('cc', '-E', $bar);

把整个列表的值赋给数组foo, 而

$foo = ('cc', '-E', $bar);

把变量bar的值赋给变量foo. 注意在数值型的上下文里数组的值是数组的长度; 下面的赋值把 $foo 的值设为 3:

@foo = ('cc', '-E', $bar); $foo = @foo; # $foo gets 3

列表的结束括号前可以有一个逗号:

@foo = ( 1, 2, 3, );

列表会把子列表自动展开. 当列表被求值时, 其中的每个元素都在列表上下文里被展开, 最后的结果形成一张大的列表. 数组在列表里不再独立存在. 下面的列表

(@foo,@bar,&amp;SomeSub) 包含了 @foo 中的所有元素, 后面是 @bar 的所有元素, 再后面是子过程 SomeSub 在列表上下文里被调用时返回的所有元素. 要使用不展开列表的引用, 参看 perlref

空列表用 () 表示. 在列表中展开一个空列表是不产生任何变化. 因此 ((),(),()) 等同于 (). 类似的, 在列表中展开一个空数组也不产生任何变化.

可以把列表当作数组, 用下标去访问它的值. 但必须用括号括起列表以避免产生混乱. 例如:

# Stat 返回列表值 $time = (stat($file))[8]; # 语法错误 $time = stat($file)[8]; # 漏了括号 # Find a hex digit. $hexdigit = ('a','b','c','d','e','f')[$digit-10]; # A &quot;reverse comma operator&quot;. return (pop(@foo),pop(@foo))[0];

Lists may be assigned to if and only if each element of the list is legal to assign to: 只有当可以对列表中的每个元素赋值, 才可以对列表赋值.

($a, $b, $c) = (1, 2, 3); ($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);

在数值型上下文里, 列表的赋值操作的返回值是等号右边的表达式的值.

$x = (($foo,$bar) = (3,2,1)); # $x = 3, 不是 2 $x = (($foo,$bar) = f()); # $x 等于 f() 的返回值

当在布尔型的上下文里进行列表赋值操作时, 检查返回值是有意义的. 大部分列表函数结束的时候返回空列表, 即数值 0, 布尔值 FALSE.

待赋值列表的最后一个元素可以是哈希表:

($a, $b, @rest) = split; local($a, $b, %rest) = @_;

实际上, 赋值的时候可以把哈希表放在列表的任何位置, 但列表中第一个出现的哈希表会取去所有的值, 后面的元素都得到一个空值. 这个特点在 local() 或 my() 里可能会有用.

哈希表的元素是一对对的数值, 即键和值的对应.

# same as map assignment above %map = ('red',0x00f,'blue',0x0f0,'green',0xf00);

列表和数组之间通常是可以互相转换的, 但不适用于哈希表. 列表中的元素可以象数组一样用下标去访问, 但不能用键去访问列表元素.

在哈希表的键和值之间使用 => 操作符会更加明白. => 操作符是逗号的同意词, 但兼有引起左操作数的功能, 特别适用于哈希表的初始化.

%map = ( red =&gt; 0x00f, blue =&gt; 0x0f0, green =&gt; 0xf00, );

或者是初始化哈希表的引用, 当作记录使用.

$rec = { witch =&gt; 'Mable the Merciless', cat =&gt; 'Fluffy the Ferocious', date =&gt; '10/31/1776', };

或是用于按名调用的复杂函数:

$field = $query-&gt;radio_group( name =&gt; 'group_name', values =&gt; ['eenie','meenie','minie'], default =&gt; 'meenie', linebreak =&gt; 'true', labels =&gt; \%labels );

要记住哈希表的初始化顺序不等于数据的存放顺序. 参看 sort 中有关对输出进行排序的例子

Typeglobs 和文件句柄
Perl 用一个叫 typeglob 的内部类型来保存一条整份符号表表项. typeglob 的类型前缀是 *, 代表任意的类型. 它原来是给函数传递数组和哈希表引用的方法, 不过现在有了真正的引用, 就很少用到了.

有一个地方还会用到 typeglobs, 就是传递或存放文件句柄的时候. 要保存一个文件句柄, 可以这样做:

$fh = *STDOUT;

或者用真正的引用:

$fh = \*STDOUT;

这也是建立局部文件句柄的方法. 例如:

sub newopen { my $path = shift; local *FH; # 不用 my! open (FH, $path) || return undef; return \*FH; } $fh = newopen('/etc/passwd');

欲知更多有关 typeglobs 的信息, 参看 perlref , perlsub , 和 ``Symbols Tables'' . 欲知其他生成文件句柄的方法, 参看 open .

本文链接

常用的PHP数据库操作方法（MYSQL版）

2011-12-21T06:30:00Z

一、数据库操作

1. 连接MYSQL数据

mysql_connect()

e.g.

$db = mysql_connect(MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD) or die(‘Unable to connect, please check connection paremeters’);

2. 选择数据库

mysql_select_db()

连接上数据库后，PHP默认选择的数据库未必是我们后面操作中需要的数据库，为确保数据库选择正确，一般在数据库连接语句后面还要加上数据库选择语句。

e.g.

mysql_select_db(MYSQL_DB, $db) or die(mysql_error($db));

3. 执行SQL语句

mysql_query()

该函数将SQL语句发送到当前活动的数据库并执行语句，返回结果。

e.g.

$query = “SELECT * FROM $table”

$result = mysql_query($query, $db) or die(mysql_error($db));

4. 关闭数据库

mysql_close()

该函数用于关闭不需要继续活跃的数据库，但该方法不是必须的，一般PHP会自动关闭不继续活跃的数据库。

e.g.

mysql_close($db);

5. 释放SQL结果

mysql_free_result()

该函数用于释放mysql_query()执行结果占用的内存，该函数很少被调用，除非result很大，占用太多内存；一般在PHP脚本执行结束之后很自动释放占用的内存。

二、SQL执行结果操作

1. 返回执行结果中的一行

mysql_fetch_row()

返回执行结果的当前行的数值数组，执行这个函数后，结果指向下一行。

e.g.

$row = mysql_fetch_row($result);

处理执行结果一般放在while循环中，遍历每一行

e.g.

while($row = mysql_fetch_row($result))
{……}

2. mysql_fetch_row()的替代方法

mysql_fetch_array()

mysql_fetch_assoc()

mysql_fetch_array()返回键值对数组，键为查询的table的列名；

mysql_fetch_assoc()返回结果时可以先排序（如果为可选参数赋值），相当于mysql_fetch_array()+MYSQL_ASSOC

3. 执行结果的字段（列）属性

mysql_fetch_field()

4. 查询数据库中的表名

mysql_list_tables()

e.g.

$db_name = MYSQL_DB;
$result = mysql_list_tables($db_name);
echo “数据库中包含如下表：”;
while ($row = mysql_fetch_row($result))
{
echo $row[0];
}

5. 查询数据库的列名（字段名）

mysql_list_fields()

e.g.

$fields = mysql_list_fields($db_name,$table);
$columns = mysql_num_fields($fields);
for ($i = 0; $i < $columns; $i++)
echo mysql_field_name($fields, $i);

三、其他函数

1. mysql_num_rows()

返回执行结果的行数。

e.g.

$num = mysql_num_rows($result);

2. mysql_num_fields()

返回执行结果的列数（字段数）。

e.g. $num = mysql_num_fields($result);

3.mysql_set_charset()

设置执行结果的编码，防止在网页中显示中文时乱码。

e.g.

$query = “select * from $table_name”;
mysql_query(‘set names utf8′);
$result = mysql_query($query, $db) or die(mysql_error($db));

注：

1. 文中大写代码为预定义的内容，如define(MYSQL_HOST, ‘localhost’);

2. 本文仅总结了PHP操作数据库的主要函数，完整的内容请参考PHP手册的相关内容。

本文链接

Windows 7 下如何配置PHP网站运行环境

2011-12-21T06:03:00Z

一、Apache安装

版本解释：openssl是表示带有openssl模块，利用openssl就可以给Apache配置SSL安全链接的，也就是使用https://方式进行访问。
　　　　　nossl则表示不带OpenSSL模块，无　法用于SSL安全链接，在这里我们下载带OpenSSL的。

选择版本：apache_2.2.14-win32-x86-openssl-0.9.8k.msi （此处以32位为例）
下载地址：http://www.apache.org/dist/httpd/binaries/win32/

首先我们在D盘（盘符根据实际情况自己选择）新建一个目录，并且命名为“WAMP”其意义为“Wdindows Apache Mysql PhpMyAdmin” 之后安装的一些内容，也都将安装在该目录下。

1.安装说明：

运行apache安装程序，方法非常简单，弹安装界面后一直“next”

接着会出现一个界面，需要填写3个内容，分别为：Network Domain、Server Name、Administrator’s Email Address 随便填写就好，不影响内容。

在下面还有2个选项，默认选择为80端口，第二个为8080端口，根据个人需求选择，一般为默认80端口。
我们继续安装，选择Custom（自定义安装）-“next”

其中有打着红X的组件，我们单击这个组件容，选择“This feature, and all subfeatures, will be installed on local hard drive.”，即“此部分，及下属子部分内容，全部安装在本地硬盘上”。-“next”

然后选择右下角的“change ”改变安装路径，安装到刚才建立的目录中“D:\WAMP\Apache\”-“next”
安装完毕后，电脑右下角会多出一个图标，双击打开，选择start或restart，能正常运行，至此安装完毕。

2.修改配置：

打开安装录下D:\WAMP\Apache\conf\httpd.conf 文件(修改配置文件时，不建议使用记事本，可能会对其造成影响，推荐使用Notepad++或其他编辑软件打开修改)

打开以后Ctrl+F查找所要修改的内容

在#LoadModule vhost_alias_module modules/mod_vhost_alias.so下添加：
LoadModule php5_module “D:/WAMP/PHP/php5apache2_2.dll”
PHPIniDir “D:/WAMP/PHP”
AddType application/x-httpd-php .php
AddType application/x-httpd-php .htm
AddType application/x-httpd-php .html

DocumentRoot “E:/WAMP/Apache/htdocs”
修改成(这里的路径和IIS中wwwroot目录一样，用于存放网页，自定义或不做修改默认)：DocumentRoot “D:/WAMP/www”

修改成(自定义或不做修改默认)：

DirectoryIndex index.html
修改成：DirectoryIndex index.php default.php index.html index.htm default.html default.htm

3.测试

在D:/WAMP/www目录下建立个index.html页面
在浏览器中输入 http://localhost/
如果能正常显示，Apache配置完毕，已经正常运行。

二、MySql安装

版本解释：The Essentials Package：不包含 embedded server and benchmark suite，有自动安装程序和配置向导，没有MySQL Documentation。
　　　　　The Complete Package：包含 embedded server and benchmark suite，有自动安装程序和配置向导，有MySQL Documentation。
　　　　　The Noinstall Archive：包含 embedded server and benchmark suite，没有自动安装程序和配置向导，有MySQL Documentation。
选择版本：mysql-essential-5.1.44-win32.msi
下载地址：http://www.mysql.com/downloads/mysql/

1.安装说明：
打开安装程序，单击“next”
选择custom，组件为默认选择，我们不做改动-“next”

路径设置为“D:\WAMP\Mysql”-“next”

安装好以后点击“finish”
跟着会出现一个配置向导-“next”

选择“Detailed Configuration（详细配置）”-“next”

这里有3个选项：

Developer Machine，将只用尽量少的内存；
Server Machine，将使用中等数量内存；
Dedicated MySQL Server Machine，这台服务器上面只跑mysql数据库，将占用全部的内存。
可以根据自己需求选择，这里我们选择第二种“Server Machine”-“next”

选择数据库用途，同样有3个选项：

Mutltifunctional Database多功能用途，将把数据库优化成很好的innodb存储类型和高效率的myisam存储类型；
Transactional Database Only只用于事务处理类型，最好的优化innodb，但同时也支持myisam；
Non-Transactional Databse Only非事务处理类型，适合于简单的应用，只有不支持事务的myisam类型是被支持的。
一般选择第一种多功能的，同样我们也是。-“next”

选择InnodDB的数据存放位置，一般默认就行，为了统一我填写了“WAMP/MySQL Datafiles”-“next”

选择mysql允许的最大连接数，第一种是最大20个连接并发数，第二种是最大500个并发连接数，最后一种是自定义，自己可以根据需求选择，我选择第二个-“next”

下面是选择数据库监听的端口，一般默认是3306，如果改成其他端口，以后连接数据库的时候都要记住修改的端口，否则不能连接mysql数据库，比较麻烦，这里不做修改，用mysq的默认端口：3306-“next”

这一步设置mysql的默认编码，我们选择第三个，并在Character Set菜单中，选择“gbk”编码-“next”
(注：如果要用原来数据库的数据，最好能确定原来数据库用的是什么编码，如果这里设置的编码和原来数据库数据的编码不一致，在使用的时候可能会出现乱码。)

这一步是是否要把mysql设置成windows的，一般选择设成服务，这样以后就可以通过服务中启动和关闭mysql数据库。下面的复选框也勾选上，这样，在cmd模式下，不必非到mysql的bin目录下执行命令。也就是把上下2个勾都打上，中间默认-“next”

这一步是设置mysql的超级用户密码，这个超级用户非常重要，对mysql拥有全部的权限，请设置好并牢记超级用户的密码，下面有个复选框是选择是否允许远程机器用root用户连接到你的mysql服务器上面，如果有这个需求，也请勾选。这里我们使用默认选择，在New root password和Confirm中输入密码。“next”

点击“execute”进行配置，稍微等待一会，圆点上的勾全部打上，就代表配置完毕。

2.修改配置：

打开D:\WAMP\MySQL\my.ini
设置datadir为D:/WAMP/MySQL/data/或你所要存放数据位置的目录即可。

三、PHP安装

版本解释：VC9 专门为IIS定值的脚本，使用Visual Studio 2008编译器编译，支持最新的微软组建，从而提高效率。
　　　　　VC6 是为了其他WEB服务软件提供的脚本如 Apache。
　　　　　Thread Safe 现成安全，之星时会进行线程安全检查，以防止有心要求就启动新线程(Thread)的CGI执行方式而耗尽系统资源。
　　　　　Non Thread Safe是非线程安全，在执行时不进行线程(Thread)安全检查
选择版本：PHP5.3(5.3.1)中VC6 x86 Thread Safe下 ZIP下载

下载地址：http://windows.php.net/download/

1.安装说明
由于我们下载的的是ZIP压缩包，只需要将文件解压到“D:\WAMP\PHP”目录下即可

2.修改配置
将E:\WAMP\PHP\php.ini-development 文件修改成php.ini
打开php.ini

; extension_dir = “ext”
修改成：extension_dir = “E:\WAMP\PHP\ext”

将947行下，这些文件前面的“;”去除
extension=php_curl.dll
extension=php_gd2.dll
extension=php_mbstring.dll
extension=php_mysql.dll
extension=php_mysqli.dll
extension=php_pdo_mysql.dll
extension=php_xmlrpc.dll

;date.timezone =
修改成(很多网站没提到这里要修改，默认为美国时间，如果不修改会报错)：date.timezone = Asia/Shanghai

3.测试

重启Apache(修改过配置文件必须重启Apache才会生效)
新建个index.php 页面，代码中输入，保存文件放到“D:\WMAP\www\”目录下
打开浏览器输入：http://localhost/index.php 如果能正常显示，说明PHP配置完毕，可以查看该页面的PHP信息是否正确。
(注：在改文件中输入函数可输出大量的有关PHP当前状态的信息，如PHP版本，服务器信息和环境等。)
(注：)

接着我们测试下，是否能连接到Mysql
再新建个link.php，下代码中输入
$link=mysql_connect(“127.0.0.1″,”root”,”Mysql安装时填写的密码”);
if(!$link) echo “Mysql数据库连接失败!”;
else echo “Mysql数据库连接成功!”;
mysql_close();
?＞
也保存文件放到“D:\WMAP\www\”目录下
打开浏览器输入：http://localhost/link.php 查看

四、PhpMyAdmin安装

版本解释：phpMyAdmin-3.2.5
选择版本：phpMyAdmin-3.2.5-all-languages.zip
下载地址：http://www.phpmyadmin.net/home_page/downloads.php

1.安装说明
解压到D:\WAMP\phpMyAdmin

2.修改配置
打开D:\WAMP\phpMyAdmin\libraries\config.default.php

$cfg['PmaAbsoluteUri'] = ”;
修改成(填写访问phpMyAdmin的绝对URL)：$cfg['PmaAbsoluteUri'] = ‘http://localhost/PHPMyadmin/’;

$cfg['Servers'][$i]['host'] = ‘localhost’;
修改成(填写服务器地址，通常默认，不需要修改)：$cfg['Servers'][$i]['host'] = ‘localhost’;

$cfg['Servers'][$i]['user'] = ‘root’;
修改成(填写Mysql用户名，这里我们默认)：$cfg['Servers'][$i]['user'] = ‘root’;

$cfg['Servers'][$i]['password'] = ”;
修改成(填写Mysql密码)：$cfg['Servers'][$i]['password'] = ‘Mysql PWD;

$cfg['Servers'][$i]['auth_type'] = ‘cookie’;
修改成(设置认证方法，安全因素考虑，填写成cookie)：$cfg['Servers'][$i]['auth_type'] = ‘cookie’;

$cfg['blowfish_secret'] = ”;
修改成(设置短语密码，如果上面设置成cookie，那这里不能留空，不然登陆会提示错误)：$cfg['blowfish_secret'] = ‘cookie’;

3.测试
打开浏览器输入：http://localhost/phpmyadmin/ 访问和登陆

五、结尾

至此Windows7下的PHP环境搭建完毕，大家尽情的使用吧。

本文链接

Tomcat建立多个应用(Web Server)、多个主机、多个站点的方法

2011-12-21T02:21:00Z

当你使用Tomcat作为Web Server的时候，是不是会想过这样的一个问题：如何利用Tomcat建立多个Web应用呢？
要实现这一点是很简单的,也有多种方法.(以下说明使用%tomcat_home%代表Tomcat安装目录).

一.首先介绍一下Tomcat及server.xml

Tomcat服务器是由一系列的可配置的组件构成,tomcat的组件可以在%tomcat_home%/conf/server.xml文件中进行配置,每个Tomcat组件和server.xml文件的一种配置元素对应.
主要分为4类:
1.顶层类元素:包括和,他们位于整个配置文件的顶层.
元素代表整个Catalina Servlet 容器,由org.apache.catalin.Server接口定义.包含一个或多个元素.
元素由org.apache.catalin.Service 接口定义.包含一个元素,及一个或多个元素.多个元素共享一个元素.
2.连接器类元素
连接器类代表了介于客户与服务之间的通信接口,负责将客户的请求发送给服务器,并将服务器的响应结果传递给客户.
元素由org.apache.catalin.Connector 接口定义.代表了与客户程序实际交互的组件,它负责接收客户请求,以及向客户返回响应结果.
3.容器类元素
容器类元素代表处理客户请求并生成响应的组件.包括和.
元素由org.apache.catalin.Engine 接口定义.每个只能包含一个元素,元素处理在同一个中的所有元素收到的客户请求.
元素由org.apache.catalin.Host 接口定义.一个元素中可以包含多个元素.每个元素定义了一个虚拟主机,她可以包含一个或多个Web 应用.
元素由org.apache.catalin.Context 接口定义.代表了运行在虚拟主机上的一个Web 应用.一个元素可以包含多个元素
4.嵌套类元素
嵌套类元素代表了可以加到容器中的组件,如和.

关于server.xml的更多信息,可以参考Tomcat的文档:/webapps/tomcat-docs/config/index.html

样例:

二.建立多个Web应用方法:

在这之前,我已经将默认8080更改为80了.

1.通过配置多个元素(这是最为普遍的方法)
在下配置多个元素

然后通过主机名:端口/应用名访问,如: http://localhost/app1 或 http://localhost/app2

2.通过配置多个元素
在下配置多个元素

然后通过主机名:端口访问,如: http://xok.la/ 或 http://xok.cc/
需要注意的是这样需要机器连接到局域网上.

3.通过配置多个元素(多端口多应用)
在下配置多个元素

第2个应用只是在默认端口第1位数字上加1
定义了两个Service分别是Catalina和Catalina2,侦听的端口分别是80和90
然后通过主机名:端口访问,如: http://localhost/ 或 http://localhost:90/

本文来自: E点废墟(http://www.xok.la/) 详细出处参考：http://xok.la/2008/11/tomcat_create_web_server_host.html

本文链接

CentOS上搭建Nginx + Mono 运行 asp.net

2011-12-17T01:56:00Z

安装步骤：

一、获取开源相关程序：

1、利用CentOS Linux系统自带的yum命令安装、升级所需的程序库：

sudo -s
LANG=C
yum -y install gcc gcc-c++ autoconf libjpeg libjpeg-devel libpng libpng-devel freetype freetype-devel libxml2 libxml2-devel zlib zlib-devel glibc glibc-devel glib2 glib2-devel bzip2 bzip2-devel bison pkgconfig glib2-devel gettext make

复制代码

2、下载程序源码包：

Nginx安装包：下载地址：http://nginx.org/en/download.html

mkdir -p /down
cd /down
wget http://nginx.org/download/nginx-1.1.11.tar.gz

复制代码

Mono下载:官网：http://download.mono-project.com/sources/mono/(请下载最新版)

wget http://download.mono-project.com/sources/mono/mono-2.10.7.tar.bz2

libgdiplus下载:http://download.mono-project.com/sources/libgdiplus/(请下载最新版)

wget http://download.mono-project.com/sources/libgdiplus/libgdiplus-2.10.tar.bz2

xsp下载:http://download.mono-project.com/sources/xsp/(请下载最新版)

wget http://download.mono-project.com/sources/xsp/xsp-2.10.2.tar.bz2

pcre下载（Nginx所需的pcre库）：ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/（请下最新版）

wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.21.tar.gz

二、安装编译Nginx：

1、安装安装Nginx所需的pcre库：

cd /down
tar zxvf pcre-8.21.tar.gz
cd pcre-8.21/
./configure
make && make install
cd ../

复制代码

2、创建www用户和组

/usr/sbin/groupadd www
/usr/sbin/useradd -g www www
mkdir -p /data0/web
chmod +w /data0/web
chown -R www:www /data0/web

复制代码

3、安装Nginx

tar zxvf nginx-1.1.11.tar.gz
cd nginx-1.1.11/
./configure --user=www --group=www --prefix=/opt/nginx --with-http_stub_status_module --with-http_ssl_module
make && make install
cd ../

复制代码

4、开放80端口：

iptables -IINPUT -p tcp --dport 80 -j ACCEPT

启动nginx

/opt/nginx/sbin/nginx

复制代码

在浏览器上输入访问地址 http://192.168.1.1(根据个人本机地址页定)，正常会看到默认nginx页面

三、安装编译Mono

1、安装libgdiplus:

cd /down

tar -jxvf libgdiplus-2.10.tar.bz2
cd libgdiplus-2.10
./configure --prefix=/opt/mono 
make && make install
echo "/opt/mono/lib" > /etc/ld.so.conf.d/mono.conf
ldconfig

复制代码

2、安装Mono:

tar –jxvf mono-2.10.7.tar.bz2
cd mono-2.10.7
./configure --prefix=/opt/mono
make && make install //此处时间较长

echo export PKG_CONFIG_PATH=/opt/mono/lib/pkgconfig:$PKG_CONFIG_PATH>>~/.bash_profile
echo export LD_LIBRARY_PATH=/opt/mono/lib:$LD_LIBRARY_PATH>>~/.bash_profile
echo export PATH=/opt/mono/bin:$PATH>>~/.bash_profile
source ~/.bash_profile

复制代码

输入 mono -V 如有mono版本信息,则安装成功.

3、安装XSP:

cd /down
tar –jxvf xsp-2.10.2.tar.bz2
./configure --prefix=/opt/mono
make && make install

复制代码

四、配置Nginx

vi /opt/nginx/conf/nginx.conf

server {
         listen   80;
         server_name  localhost;
         location / {
                 root /data0/web;
                 index index.html index.htm;
                 fastcgi_index Default.aspx;
                 fastcgi_pass 127.0.0.1:9000;
                 include fastcgi_params;
         }
 }

复制代码

五、配置fastcgi_params增加下面两行：

vi /opt/nginx/conf/fastcgi_params

fastcgi_param  PATH_INFO          "";
fastcgi_param  SCRIPT_FILENAME    $document_root$fastcgi_script_name;

复制代码

六、启动：

1、重启nginx:

/opt/nginx/sbin/nginx -s reload

2、启动 fastcgi_mono服务器

fastcgi-mono-server2 /applications=/:/data0/web /socket=tcp:127.0.0.1:9000 &

七、测试：

新建一个asp.net web项目上传至 /data0/web目录下，测试运行。

本文链接

CentOS Apache+Tomcat 整合配置（两种办法）

2011-12-16T08:39:00Z

整合篇方法一
#wget http://archive.apache.org/dist/t ... s-1.2.30-src.tar.gz
#tar zxvf tomcat-*
#cd tomcat-*/native
#./configure --with-apxs=/usr/local/apache/bin/apxs
#make && make install
到apache的modules下面看看有没有mod_jk.so模块

配置apache支持jk模块

#vim /usr/local/apache/conf/httpd.conf

添加 index.jsp

DirectoryIndex index.jsp index.html

LoadModule jk_module modules/mod_jk.so…

Include conf/extra/mod_jk.conf

#vim /usr/local/apache/conf/extra/mod_jk.conf
JkWorkersFile conf/extra/workers.properties
JkLogFile logs/mod_jk.log
JkShmFile logs/jk-runtime-status
JkLogLevel info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories
JkRequestLogFormat "%w %V %T"
#Sample JkMounts. Replace these with the paths you would
#like to mount from your JSP server.
#syntax: JkMount ${URL_DIR}/*.jsp worker_name
JkMount /images/avatar/*    worker1
JkMount /*.jsp worker1
JkMount /*.page worker1
JkMount /*.cic worker1
JkMount /func/* worker1
JkMount /assets/*       worker1
JkMount /remote/*       worker1
JkMount /services/*       worker1
JkMount /homebase/*       worker1
JkMount /skin/*    worker1
JkMount /error/*    worker1
JkMount /lib/*    worker1
JkMount /protected/*    worker1
JkMount /rounded/*    worker1
JkMount /FormOverLogin*    worker1
JkMount /fckeditor/editor/filemanager/connectors/*    worker1
JkMount /upload/image/*    worker1

#vim /usr/local/apache/conf/extra/workers.properties
worker.list=worker1
worker.worker1.port=8009
worker.worker1.host=localhost
worker.worker1.type=ajp13
worker.woker1.lbfactor=1

修改tomcat跟apache知道让web指向同一个目录
#vim /usr/src/tomcat/conf/server.xml
   <Host name="localhost" appBase="webapps"
         unpackWARs="true" autoDeploy="true"
         xmlValidation="false" xmlNamespaceAware="false">
   <Context path="/" docBase="/usr/local/apache/htdocs" debug="0" workDir="/tmp" reloadable="false"/>

#/usr/local/apache/bin/apachectl restart
# /usr/local/tomcat/bin/shutdown.sh
#/usr/local/tomcat/bin/startup.sh

测试页面
#vim /usr/local/apache/htdocs/index.jsp

<%
out.print("jsp页面测试");
%

访问 localhost

完毕!

整合篇，方法二。
在 /usr/local/apache/conf/httpd.conf  末尾加入：
<Proxy balancer://localCluster>
      BalancerMember ajp://localhost:8009
</Proxy>
RewriteEngine On
ProxyPreserveHost On
RewriteRule ^/$ balancer://localCluster/ [P,L,NC]
RewriteRule ^/(.*)$ balancer://localCluster/$1 [P,L,NC]

修改tomcat跟apache知道让web指向同一个目录
#vim /usr/local/tomcat/conf/server.xml
   <Host name="localhost" appBase="/usr/local/apache/htdocs"
         unpackWARs="true" autoDeploy="true"
         xmlValidation="false" xmlNamespaceAware="false">
   <Context path="/" docBase="." debug="0" workDir="/tmp" reloadable="false"/>

新建测试页
vi  /usr/local/apache/htdocs/index.jsp
<html>
<body>
<h1>JSP Test Page</h1>
<%=new java.util.Date()
%>
</body>
</html>
重启apache和tomcat，
然后直接访问 http://localhost

本文链接

卸载CentOS 5.4自带的OpenJDK，配置新的Java环境

2011-12-16T08:38:00Z

本文CentOS版本为5.4 final，使用图形界面与命令结合的操作方式

由于CentOS 5.4在默认情况下，会安装OpenOffice之类的软件，而这些软件需要Java支持，因此系统会默认安装一个JDK环境，如果需要使用特定的Java环境，最好将这些默认安装的JDK卸载或者彻底删除。

在安装完成CentOS 5.4之后，直接在终端中输入“java -version”，系统会显示当前的jdk版本号“java-1.6.0-openjdk-1.6.0.0-1.7.b09.el5”，可以看到jdk使用的是openjdk1.6版本的。

如果此时，直接在centOS的“应用程序--添加/删除软件--基本系统--java”中，删除java，与之相关的openoffice等软件，也会自动随之删除，因此，在进行原有的jdk删除之前，最好先安装配置好新的JDK及相应的环境。

首先，在Sun（现在属于Oracle）的网站下载相应的JDK版本，这里使用的是目前最新的JDK6.0_update21版本，在下载时，建议下载-rpm的安装文件，将下载完成的文件放在指定位置，这里直接放在/usr下。默认下载的JDK文件名较长，可以根据需要修改文件名，这里修改为 “jdk-6u21.bin”。

其次，在jdk所在目录中打开终端，给当前用户赋予执行权限，“chmod +x jdk-6u21.bin”，或者直接在图形界面下右击文件，在弹出菜单中依次选择“属性”--“权限”，选择“以程序执行文件”复选框，“确定”按钮，完成执行权限的赋予。

然后，在jdk所在目录中打开终端，在终端中输入“./jdk-6u21.bin”执行解压及安装操作。此时，在“/usr”目录下，新增一个“/java”目录，另外，会有一些以“sun”开头的rpm文件，这些文件不用理会。

接下来，设置Java的环境变量。

用文本编辑器打开/etc/profile（说明：根目录下的/etc/目录，其中的profile文件）
在profile文件末尾加入如下字符串
  JAVA_HOME=/usr/java/jdk1.6.0_21
  PATH=$JAVA_HOME/bin:$PATH
  CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
  export JAVA_HOME
  export PATH
  export CLASSPATH

至此，新的JDK环境安装配置完成。

接下来，删除原有的jdk环境。

首先，在终端中输入“rpm -qa|grep gcj”，查看gcj的版本号，在这里得到的结果是：

java-1.4.2-gcj-compat-1.4.2.0-40jpp.115
libgcj-4.1.2-48.el5

其次，卸载系统自带jdk。在终端中输入“yum -y remove java java-1.4.2-gcj-compat-1.4.2.0-40jpp.115”，然后等待，等待系统卸载完自带的jdk。最终在终端中显示“Complete!”，卸载完成。

至此，关于CentOS的JDK配置基本完成，重启系统。

在终端中输入“java -version”，系统显示：

java version "1.6.0_21"
Java(TM) SE Runtime Environment (build 1.6.0_21-b06)
Java HotSpot(TM) Client VM (build 17.0-b16, mixed mode, sharing)

JDK安装成功！

本文链接

【经验】CentOS 5.2 下用Yum安装Apache+PHP+MySQL环境

2011-12-16T07:17:00Z

CentOS 5.2 下用Yum安装Apache+PHP+MySQL环境

Fedora 8下用Yum安装Apache+PHP+MySQL环境

fedora8 用yum来管理安装Apache+PHP+Mysql的基本安装。

1. 安装Apahce, PHP, Mysql, 以及php连接mysql库组件。

yum -y install httpd php mysql mysql-server php-mysql

centos安装php插件就是yum install php-*

yum install php-gd 安装图形支持

也可以通过光驱iso安装

mount /dev/cdrom /mnt挂载光驱到mnt

rpm -ivh /mnt/centos/httpd ****.rpm 安装ISO里的包

测试环境

rpm -qa |grep mysql

rpm -qa |grep httpd

rpm -qa |grep php

2. 配置开机启动服务

/sbin/chkconfig httpd on [设置apache服务器httpd服务开机启动]

/sbin/chkconfig --add mysqld [在服务清单中添加mysql服务]

/sbin/chkconfig mysqld on [设置mysql服务开机启动]

/sbin/service httpd start [启动httpd服务,与开机启动无关]

/sbin/service mysqld start [启动mysql服务,与开机无关]

3.设置mysql数据库root帐号密码。

mysqladmin -u root password 'newpassword' [引号内填密码]

4. 让mysql数据库更安全

mysql -u root -p

mysql> DROP DATABASE test; [删除test数据库]

mysql> DELETE FROM mysql.user WHERE user = ''; [删除匿名帐户]

mysql> FLUSH PRIVILEGES; [重载权限]

5. 按照以上的安装方式, 配置出来的默认站点目录为/var/www/html/

新建一个php脚本:

6. 新建一个数据库，添加一个数据库用户，设置用户权限。写个php脚本测试一下数据库连接吧。

mysql> CREATE DATABASE my_db;

mysql> GRANT ALL PRIVILEGES ON my_db.* TO 'user'@'localhost' IDENTIFIED BY 'password';

//安装apache扩展

yum -y install httpd-manual mod_ssl mod_perl mod_auth_mysql

//安装php的扩展

yum install php-gd

yum -y install php-gd php-xml php-mbstring php-ldap php-pear php-xmlrpc

//安装mysql扩展

yum -y install mysql-connector-odbc mysql-devel libdbi-dbd-mysql

[root@soft bin]# mysql

ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)

""mysql dead but subsys locked

解决办法如下:

[root@soft mysql-4.1.19]# rm -fr /var/lib/mysql/*

[root@soft mysql-4.1.19]# rm /var/lock/subsys/mysql

rm: remove regular empty file `/var/lock/subsys/mysqld'? yes

shell> killall mysqld

shell> service mysqld start

[root@soft mysql-4.1.19]# /etc/rc.d/init.d/mysqld status

mysqld (pid 5457) is running...

###数据库运行正常；

一、两个重要目录：

Apache有两个重要的目录：1、配置目录 /etc/httpd/conf；2、文档目录 /var/www：

二、两种配置模式：

Apache在Fedora下的两种配置方式：文本模式（终端命令行）和图形化配置。两者各有优势：图形化下配置，更容易上手，在文本模式下直接编辑httpd.conf文件，自由性更强些、更直接。

三、Apache服务的启动与关闭

Apache服务的停止、启动、关闭可以通过两种模式下进行操作：文本（终端）模式下和图形化界面。

四、终端下的操作

如果你想用Linux作为WWW服务器，我建议不要安装图形界面（即X window、KDE或GNOME桌面），很显然不安装这些程序，会显著提高系统的性能，易操作性和美丽的界面是要付出代价。我认为Linux的精髓在于命令行的丰富。Linux的命令可以完成所有任务。

1、Apache的启动、重启、停止服务：

cd /etc/init.d命令切换到 /etc/init.d目录，运行如下命令：

./httpd start //启动Apache服务

./httpd restart //重新启动Apache服务

./httpd stop //停止Apache服务

开机自动启动Apache服务

cd /sbin命令切换到/sbin目录,运行chkconfig命令，参数：./chkconfig --level 5 httpd on

./chkconfig --list可以检查一下httpd开机是否自动启动，如果5:启动，表示开机自动启动。

2、配置

cd /etc/httpd/conf命令切换到目录/etc/httpd/conf，用vi编辑器打开、编辑httpd.conf配置，在配置之前，为了防止配置出错，先备份

<?php

phpinfo();

保存为info.php放到网站目录

然后输入http://ip/info.php看看测试环境

2安装Apache+php+Mysql#

a.用yum安装前.先是替换为中国CentOS镜像服务器!中国官方镜像网站: http://centos.ustc.edu.cn/

安装后请按照以下步骤修改CenOS-Base.repo,以后就可以方便的用yum安装软件了

cd /etc/yum.repos.d

mv CentOS-Base.repo CentOS-Base.repo.save

wget http://centos.ustc.edu.cn/CentOS-Base.repo.5

mv CentOS-Base.repo.5 CentOS-Base.repo

b、更新系统内核到最新. yum -y update

c、安装Apahce, PHP, Mysql, 以及php连接mysql库组件

yum -y install httpd php mysql mysql-server php-mysql

d、安装mysql扩展

yum -y install mysql-connector-odbc mysql-devel libdbi-dbd-mysql

或一次性粘贴安装

yum -y install httpd php mysql mysql-server php-mysql httpd-manual mod_ssl mod_perl mod_auth_mysql php-mcrypt php-gd php-xml php-mbstring php-ldap php-pear php-xmlrpc mysql-connector-odbc mysql-devel libdbi-dbd-mysql

设置mysql数据库root帐号密码

mysqladmin -u root password ‘newpassword’

[引号内填密码]

f、让mysql数据库更安全

mysql -u root -p [此时会要求你输入刚刚设置的密码，输入后回车即可

mysql> DROP DATABASE test; [删除test数据库]

mysql> DELETE FROM mysql.user WHERE user = ”; [删除匿名帐户]

mysql> FLUSH PRIVILEGES; [重载权限]

按照以上的安装方式, 配置出来的默认站点目录为/var/www/html/新建一个php脚本

<?php

phpinfo();

配置防火墙4添加允许访问HTTP、FTP端口

iptables -I RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 21 -j ACCEPT

iptables -I RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 80 -j ACCEPT

重启iptables: service iptables restart

安装phpMyAdmin)

进入phpMyAdmin官方下载(不要最新版本，下phpMyAdmin 2.11.9.5就行了,3.1以上需php 5.2以上)，上传到你的网站目录下，然后进行配置。只需几步即可搞定。

config.sample.inc.php更名为config.inc.php;

II.

打开config.inc.php文件，进行以下修改:

// $cfg['Servers'][$i]['controluser'] = ‘pma’;

// $cfg['Servers'][$i]['controlpass'] = ‘pmapass’;

// $cfg['Servers'][$i]['pmadb'] = ‘phpmyadmin’;

// $cfg['Servers'][$i]['bookmarktable'] = ‘pma_bookmark’;

// $cfg['Servers'][$i]['relation'] = ‘pma_relation’;

// $cfg['Servers'][$i]['table_info'] = ‘pma_table_info’;

// $cfg['Servers'][$i]['table_coords'] = ‘pma_table_coords’;

// $cfg['Servers'][$i]['pdf_pages'] = ‘pma_pdf_pages’;

// $cfg['Servers'][$i]['column_info'] = ‘pma_column_info’;

// $cfg['Servers'][$i]['history'] = ‘pma_history’;

// $cfg['Servers'][$i]['designer_coords'] = ‘pma_designer_coords’

去掉每行前面的//;

II.

$cfg['blowfish_secret'] = ”; |修改为| $cfg['blowfish_secret'] = ‘http’

$cfg['Servers'][$i]['controluser'] = ‘pma’; |把’pma’修改为你的帐号|$cfg['Servers'][$i]['controlpass'] = ‘pmapass’; |把’pmapass设置为你的mysql登录密码|

V. $cfg['blowfish_secret'] = ”; | 添加短语密码例如：$cfg['blowfish_secret'] = ‘onohot’

6、//安装php的扩展

yum -y install php-gd php-xml php-mbstring php-ldap php-pear php-xmlrpc

7、//安装apache扩展

yum -y install httpd-manual mod_ssl mod_perl mod_auth_mysql

本文链接