PHP

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/lanyue622/article/details/50577300

PHP是一种通用开源脚本语言。语法吸收了C语言、Java和Perl的特点,利于学习,使用广泛,主要适用于Web开发领域。

什么是PHP


  PHP,即——PHP: 超文本预处理器(Hypertext Preprocessor ),是一种被广泛使用的开放源代码多用途脚本语言,尤其适用于Web 开发并可以嵌入到HTML 中去。其语法利用了C,JavaPerl,非常容易学习。该语言的主要目标是让Web 开发人员可以很快写出动态生成的网页,但 PHP 的功能远不止如此。 一个简单的PHP程序:

  1. <html>
  2. <head>
  3. <title>Example</title>
  4. </head>
  5. <body>
  6. <?php
  7. echo "hello,world";
  8. ?>
  9. </body>
  10. </html>

该程序运行的结果是在网页上输出了一个内容为hello,world的字符串。

  PHP是一种语法简单、功能强大的网络编程语言。在语法格式上,PHP借鉴了广泛流行的C、JavaPerl等编程语言的特点,非常类似于C语言,但比C语言更简单,易学和易用,因此特别适合于学习过C语言,有志于网络编程的人学习和使用。

  在功能上,它提供了丰富的函数库,支持复杂字符串处理,正规表达式和图形处理,可根据用户请求将服务器的数据轻松地产生动态网页,支持目前几乎所有流行的数据库系统,如Oracle、SQL Server、MySQL、mSQL、Informix、SyBase、ODBC、PostgreSQL以及dBase等。在在可移植性上,PHP程序可在Windows下快速开发,代码甚至不加修改即可运行在Unix、Linux上。

基本语法


  PHP 的脚本块以<?php 开始,以 ?> 结束。当然,在支持简写的服务器上,也可以使用简约风格<??> 来开始和结束脚本块;还可以使用脚本风格的形式,如下代码:

  1. <script language="php">
  2. //PHP 语句
  3. </script>

我们在这里推荐使用标准风格。

  1. <?php
  2. //PHP 语句
  3. ?>

  PHP 中的每个代码行都必须以分号结束。分号是一种分隔符,用于把指令集区分开来。

  在 PHP 中,我们使用 // 来编写单行注释,或者使用 /**/ 来编写大的注释块。

   PHP 为我们提供两种输出文本的基础指令:echoprintprintecho 基本一致。但是print 不支持逗号分隔多个显示变量的语法。

  1. <html>
  2. <body>
  3. <?php
  4. echo "Hello World";
  5. echo "Hello Hubwiz";
  6. echo 12,13;
  7. print "study";
  8.  
  9. //This is a comment
  10.  
  11. /*
  12. This is
  13. a comment
  14. block
  15. */
  16. ?>
  17. </body>
  18. </html>

常量


  常量是单个值的标识符(名称)。在脚本中无法改变该值。有效的常量名以字符或下划线开头(常量名称前面没有 $ 符号)。

  常量默认为大小写敏感。传统上常量标识符总是大写的。

  常量名和其它任何 PHP 标签遵循同样的命名规则。合法的常量名以字母或下划线开始,后面跟着任何字母,数字或下划线。

设置 PHP 常量

如需设置常量,请使用 define() 函数 - 它使用三个参数:
1.首个参数定义常量的名称;
2.第二个参数定义常量的值;
3.可选的第三个参数规定常量名是否对大小写敏感。默认是 false。

下例创建了两个常量,值为 "Welcome to Hubwiz.com!":

  1. <?php
  2. //对大小写敏感
  3. define("GREETING", "Welcome to Hubwiz.com!");
  4. echo GREETING;
  5. //对大小写不敏感
  6. define("HUB", "Welcome to Hubwiz.com!", true);
  7. echo hub;
  8. //define("2FOO","Hubwiz");这样定义是不合法的
  9. ?>

预定义变量


  PHP中可以使用预定义常量获取PHP中的信息。常用的预定义常量如下表:

常量名 功能
__FILE__ 默认常量,PHP程序文件名
__LINE__ 默认常量,PHP程序行数
PHP_VERSION PHP程序版本
PHP_OS 执行PHP解析器的操作系统名称
TRUE 真值
FALSE 假值
NULL null值
E_ERROR 指到最近的错误处
E_WARNING 指到最近的警告处
E_PARSE 指解析语法有潜在问题处
E_NOTICR 为发生不寻常但不一定是错误处

其中__FILE__与__LINE__中的“_”是两条而不是一条。

  1. <?php
  2. echo "当前文件路径:".__FILE__;
  3. echo "<br>当前行数:".__LINE__;
  4. echo "<br>当前PHP版本信息:".PHP_VERSION;
  5. echo "<br>当前操作系统:".PHP_OS;
  6. ?>

变量


  变量是指在程序执行过程中其值可以变化的量。变量通过一个名字(变量名)来标识。系统为程序中的每一个变量分配一个存储单元,变量实质上就是计算机内存单元的命名。因此借助变量名就可以访问内存中的数据。

变量的名称可以很短(比如 x 和 y),也可以取更具描述性的名称(比如 carnametotal_volume)。

PHP 变量规则:
1.变量以 $ 符号开头,其后是变量的名称;
2.变量名称必须以字母或下划线开头;
3.变量名称不能以数字开头;
4.变量名称只能包含字母数字字符和下划线(A-z、0-9 以及 _);
5.变量名称对大小写敏感($y 与 $Y 是两个不同的变量)。

  1. <?php
  2. $txt="Hello world!";
  3. $x=5;
  4. $y=10.5;
  5. ?>

变量的作用域


  变量在使用时,要符合变量的定义规则。变量必须在有效范围内使用,如果超出有效范围,变量也就失去意义了。

  局部变量:即在函数内部定义的变量,其作用域是所在函数。

  全局变量:即被定义在所有函数以外的变量,其作用域是整个PHP文件,但是在用户自定义函数内部是不可用的。想在用户自定义函数内部使用全局变量,要使用global关键字声明

  1. <?php
  2. $zy="你好";
  3. $zyy="PHP语言";
  4. function lxt(){
  5. echo $zy."<br>"; //$zy 不能被调用,没有输出
  6. global $zyy; //利用关键字global 在函数内部说明,不说明认为是私有变量
  7. echo $zyy."<br>"; //调用$zyy
  8. }
  9. lxt();
  10. ?> // 结果为:PHP语言

  在本例中定义两个全局变量$zy$zyy,在用户自定义函数lxt()里面,想要在第5行、第7行高用它们,而程序输出的结果只有$zyy的值“PHP语言”,因为在第6行用global关键字声明了全局变量$zyy。而第5行不会有任何输出,其中的$zy和第二行的$zy没有任何关系。  

  静态变量:能够在函数调用结束后仍保留变量值,当再次回到其作用域时,又可以继续使用原来的值。而一般变量是在函数调用结束后,其存储的数据值将被清除,所占的内存空间被释放。使用静态变量时,先要用static来声明变量。需要把关键字static 放在要定义的变量之前。

  1. <?php
  2. function zdy(){
  3. static $count=0;
  4. $count++;
  5. echo $count." ";
  6. }
  7. function zdy1(){
  8. $count=0;
  9. $count++;
  10. echo $count." ";
  11. }
  12. for($i=0;$i<10;$i++) zdy(); //输出1~10
  13. echo "<br>";
  14. for($i=0;$i<10;$i++) zdy1(); //输出10个1
  15. ?>

  自定义函数zdy()是输出从1到10,10个数字,而zdy1()函数则输出的是10个1。因为自定义函数zdy()含有静态变量,而函数zdy1()是一个普通变量。初始化都为0,再分别使用for循环调用两个函数,结果是静态变量的函数zdy()在被调用后,保留了$count中的值,静态变量的初始化只是在第一次遇到时被执行,以后就不再对其进行初始化操作了,将略过第3行代码不执行;而普通变量的函数zdy1()在被调用后,其变量$count失去了原来的值,重新被初始化为0。

可变变量


  可变变量是一种独特的变量,它允许动态改变一个变量名称。工作原理是该变量的名称由另外一个变量的值来确定。实现过程是在变量的前面再多加一个"$"。

  1. <?php
  2. $my_name="myname";
  3. $myname="yourname";
  4. echo $my_name; // 输出myname
  5. echo "<br>";
  6. echo $$my_name; //通过$$my_name改变变量$my_name的名称为$myname,输出yourname
  7. ?>

运行结果为:myname yourname

分类


PHP 支持8种基本的数据类型:

四种标量类型:boolean(布尔型)、integer(整型)、float (浮点型, 也称作 double)、string (字符串);
两种复合类型:array (数组)、object(对象);
最后是两种特殊类型:resource(资源)、NULLNULL)。

整数


整数是没有小数的数字。

整数规则:
整数必须有至少一个数字(0-9);整数不能包含逗号或空格;整数不能有小数点;整数正负均可;

  可以用三种格式规定整数:十进制、十六进制(前缀是 0x)或八进制(前缀是 0)。在下面的例子中,我们将测试不同的数字。PHP 用var_dump() 函数会返回变量的数据类型和值。

  1. <?php
  2. $x = 5985;
  3. var_dump($x);
  4. echo "<br>"; //起到回车的作用
  5. $x = -345; // 负数
  6. var_dump($x);
  7. echo "<br>";
  8. $x = 0x8C; // 十六进制数
  9. var_dump($x);
  10. echo "<br>";
  11. $x = 047; // 八进制数
  12. var_dump($x);
  13. ?>

运行结果为:

  1. int(5985)
  2. int(-345)
  3. int(140)
  4. int(39)

浮点数


浮点数是有小数点或指数形式的数字。

  1. <?php
  2. $x = 10.365;
  3. var_dump($x);
  4. echo "<br>";
  5. $x = 2.4e3;
  6. var_dump($x);
  7. echo "<br>";
  8. $x = 8E-5;
  9. var_dump($x);
  10. ?>

运行结果为:

  1. float(10.365)
  2. float(2400)
  3. float(8.0E-5)

布尔型


布尔型是最简单的变量,布尔变量:true和false值。

  1. <?php
  2. $True=True;
  3. echo $True;
  4. echo "<BR>";
  5. $False=False;
  6. echo $False;
  7. ?>

运行结果为:

  1. 1

truefalse实际上是代表数值1和0,因此true在输出时显示为1,但是在给变量赋值的时候,如果赋值为1,则被当成整型,如果被赋值为true,则被当成布尔型。

当转换为布尔型时,以下值被认为是false:
(1)布尔值false
(2)整型值0(零);
(3)浮点型值0.0(零);
(4)空白字符串和字符串"0";
(5)没有成员变量的数组;
(6)没有单元的对象(仅适用php4);
(7)特殊类型NULL

而所有其他值都被认为是TRUE包括任何资源。

字符串


PHP中有三种方式定义字符串:
1.单引号方式定义;
2.双引号方式定义;
3.<<<方式(HereDoc方式)给字符串赋值;

  语法为:

1> 使用操作符 “<<<”;
2> 操作符后紧跟标识符(开始标识符),之后重起新的一行输入要引用的字符串,可以包含变量;
3> 新的一行,顶格写结束表示符,以分号结束;
4> 标识符可以自定义 一般的 有EOT ,EOD EOF 等, 只有保持开始表示符和结束表示符一样即可;
5> 结束表示符必须独占一行,且必须顶格写,最后以 ‘;’ 分号结尾;
6> 所有引用的字符串中可以包含变量,无需字符串连接符。

  1. <?php
  2. $single_str='我被单引号括起来了!<br>';      //正常输出
  3. echo $single_str;
  4. $single_str='输出单引号: \'嘿嘿,我在单引号里面\'<br>';      //加了转义符可以输出单引号
  5. echo $single_str;
  6. $single_str='输出双引号:"我在双引号里面"<br>';         //正常输出
  7. print $single_str;
  8. $single_str='输双美元符号:$<br>';                 //正常输出
  9. print $single_str;
  10. $Double_str="我被双引号括起来了!<br>";
  11. echo $Double_str;
  12. $zjj1_str =<<<zjj
  13. 你好<br>
  14. 美元符号 $ <br>
  15. 反斜杠 \<br>             
  16. zjj;
  17. echo $zjj1_str;
  18. ?>

运行结果为:

  1. 我被单引号括起来了!
  2. 输出单引号: '嘿嘿,我在单引号里面'
  3. 输出双引号:"我在双引号里面"
  4. 输双美元符号:$
  5. 我被双引号括起来了!
  6. 你好
  7. 美元符号 $
  8. 反斜杠 \

转义字符


  当我们想输出“$”、“"”、“'”等字符时,这些特殊的字符都要通过转义符“\ ”来显示。常用的转义字符如下表:

转义字符 输出
\n 回车
\r 回车
\t 水平制表符
\\ 反斜线
\$ 美元符号
\' 单引号
\" 双引号
  1. <?php
  2. echo "\$"." "."\""." "."\'"; // 输出 $ " '
  3. ?>

resource


  资源又叫做“句柄”,是由编程人员来分配的,处理外部事务的函数。

  资源是由专门的函数来建立和使用。它是一种特殊的数据类型,并由程序员分配。在使用资源时,要及时地释放不需要的资源。如果程序员忘记释放资源,系统自动启用垃圾回收机制,避免内存消耗殆尽。

  在PHP中,资源类型保存了到外部资源的一个引用,实质其实就是为外部资源建立的特殊句柄,比如数据库连接、打开文件、图形画布区域等。资源类型其实仅仅是一个整数,而内核可以根据这个整数值去一个类似资源池的地方寻找最终需要的数据。

NULL 值


  特殊的 NULL 值表示变量无值。NULL 是数据类型 NULL 唯一可能的值。NULL 值标示变量是否为空。也用于区分空字符串与空值数据库。可以通过把值设置为NULL,将变量清空:

  1. <?php
  2. $x="Hello world!";
  3. $x=null;
  4. var_dump($x);
  5. ?>

运行结果为:

  1. NULL

转换数据类型


  虽然PHP是弱类型语言,但有时仍然需要用到类型转换。PHP中的类型转换和C语言一样,非常简单。在变量前加上用括号括起来的类型名称即可。类型强制转换如下表:

转换函数 转换类型
(boolean) 转换成布尔型
(string) 转换成字符串型
(integer) 转换成整型
(float) 转换成浮点型
(array) 转换成数组
(object) 转换成对象
  1. <?php
  2. $x="This is my family.";
  3. echo "这是原始的string 形式:".$x;
  4. echo "<br>";
  5. echo "这是boolean形式:".(boolean)$x;
  6. echo "<br>";
  7. echo "这是integer形式:".(integer)$x;
  8. ?>

运行结果为:

  1. 这是原始的string 形式:This is my family.
  2. 这是boolean形式:1
  3. 这是integer形式:0

算术运算符


  算术运算符号,是处理四则运算的符号。在数字的处理中,应用的最多。常用的算术运算符如下所示:

名称 操作符 实例
加法运算 + $A+$B
减法运算 - $A-$B
乘法运算 * $A*$B
除法运算 / $B/$A
取余数运算 % $B % $A
  1. <?php
  2. $a=-100;
  3. $b=50;
  4. echo "\$a+\$b=".($a+$b)."<br>";
  5. echo "\$a%\$b=".($a%$b)."<br>";
  6. ?>

运行结果为:

  1. $a+$b=-50
  2. $a%$b=0

逻辑运算符


  逻辑运算符用来组合逻辑运算结果,是程序设计中一组非常重要的运算符。PHP的逻辑运算符如下表:

操作符 实例 结果为真
&&或and $A and $B 当$A和$B都为真时
||或or $A || $B 当$A或者$B有一个为真时
Xor $A Xor $B 当$A、$B一真一假时
!$A $A为假时

  在逻辑运算符中,逻辑与和逻辑或这两个运算符有4种运算符号(&&、and和||、or),其中属于同一个逻辑结构的两个运算符号之间却有着不同的优先级。如下代码:

  1. <?php
  2. $a=true;
  3. $b=true;
  4. $c=false;
  5. echo "\$a or \$b and \$c is ".($a or $b and $c)."<br>";
  6. echo "\$a || \$b and \$c is ".($a || $b and $c)."<br>";
  7. ?>

运行结果为:

  1. $a or $b and $c is 1
  2. $a || $b and $c is

由此我们可以判断 and与or 的优先级要高于||与 &&。

比较运算符


  比较运算符就是对变量或表达式的结果进行大小、真假等比较,如果比较结果为真,则返回True,如果为假,则返回False。 PHP的比较运算符如下表:

操作符 实例 结果为真
< $A <$B 当$A小于$B时
> $A > $B 当$A>$B时
<= $A <=$B 当$A小于等于$B时
>= $A>=$B 当$A大于等于$B时
== $A==$B 当$A等于$B时
!= $A!=$B 当$A不等于$B时
=== $A===$B 当$A恒等于$B时
!== $A!==$B 当$A非恒等于$B时

  这里面不太常见的是===和!==。$a===$b,说明$a和$b不只是数值上相等,而且两者的类型也一样。 !==意思与===差不多。

  1. <?php
  2. $value=100;
  3. echo "<p>\$value===100:";
  4. var_dump($value===100);
  5. echo "<p>\$value===true:";
  6. var_dump($value===true);
  7. ?>

运行结果为:

  1. $value===100:bool(true)
  2. $value===true:bool(false)

位运算符


  位逻辑运算符是指对二进制位从低位到高位对齐后进行运算。PHP中的位运算符如下表所示:

名称 操作符 实例
按位与 & $A&$B
按位或 $A|$B
按位异或 ^ $A^$B
按位取反 ~ ~$A
向左移位 << $B << $A
向右移位 >> $B >> $A
  1. <?php
  2. $m=8;
  3. $n=12;
  4. echo $m & $n; //按位与
  5. echo " ";
  6. echo $m | $n; //按位或
  7. echo " ";
  8. echo $m ^ $n; //按位异或
  9. echo " ";
  10. echo ~$n; //按位取反
  11. echo " ";
  12. echo $m<<2; //左移两位
  13. echo " ";
  14. echo $m>>2; //右移两位
  15. ?>

运行结果为:

  1. 8 12 4 -13 32 2

字符串运算符


  字符串运算符只有一个,即英文的句号“.”。它将两个字符串连接起来。

  1. <?php
  2. $a="a123";
  3. $b="abc";
  4. echo $a.$b." "; //结果果为a123abc
  5. echo $a+$b; //结果为0;
  6. $a="123";
  7. echo $a+$b; //结果为123;
  8. ?>

  当使用"+"时,PHP会认为这是一次运算。如果"+"号的两边有字符类型,则自动转换为整型,如果是字母,则输出为0,如果是以数字开头的字符串,则会截取字符串头部的数字,再进行运算。

赋值运算符


  赋值运算符串是把基本赋值运算符(“=”)右边的值班赋给左边的变量或者常量。如下表所示

操作 符号 实例 展开形式 意义
赋值 = $A=B $A=3 将右边的赋值给左边
+= $A+=B $A=$A+B 将右边的值加到左边
-= $A-=B $A=$A-B 将右边的值减到左边
*= $A*=B $A=$A*B 将右边的值乘以左边的
/= $A/=B $A=$A/B 将右边的值除以左边的
连接字符 .= $A.=B $A=$A.B 将右边的字符串加到左边
取余数 %= $A%=B $A=$A%B 将左边的值对右边取余数

自增、自减算符


  自增或自减运算符与我们在C、C#、java中的运算符是一样的,即"++" 或"--"。它们有两种使用方法,一种是先将变量增加或都减少1后再将值赋给原变量,叫做前置递增或递减运算符;另一种是将运算符放在变量后面,即先返回变量的当前值,然后变量的当前值增加或者减少1,叫做后置递增或递减运算符。

  1. <?php
  2. $a=10;
  3. echo "\$a++的值为:".$a++."<br>"; //$a的值变为11
  4. echo "\$a的值为:".$a."<br>";
  5. echo "++\$a的值为:".++$a."<br>"; //$a的值变为12
  6. ?>

运行结果为:

  1. $a++的值为:10
  2. $a的值为:11
  3. ++$a的值为:12

其他运算符


三元运算符(?:)

  三元运算符用于根据一个表达式在另两个表达式中选择一个,而不是用来在两个语句或者程序中选择,最好放在括号里。

  1. <?php
  2. $a=10;
  3. echo ($a==true)?"三元运算":"没有该值"; //结果为三元运算
  4. ?>

@错误屏蔽

  错误屏蔽运算符可以对程序中出现错误的表达式进行操作,进而对错误信息进行屏蔽,其使用的方法就是在错误的表达式前加上“@”即可。它只是对错误信息进行屏蔽,并没有解决错误。

  1. <?php
  2. $a=10;
  3. $a=@($a/0);
  4. ?>

  按照以上代码就在输出时就什么错误都不显示了,当然错误依然在,只是看不到而已。

表达式


  表达式是构成PHP程序语言的基本元素,也是PHP最重要的组成元素。在PHP中几乎所写的任何东西都是表达式。最基本的表达式形式是常量和变量。

  表达式是通过具体的代码来实现的,是多个符号集合起来组成的代码,而这些符号只是一些对PHP解释程序有具体含义的最小单元。它们可以是变量名、函数名、运算符、字符串、数值和括号等。代码如下:

  1. <?php
  2. "fine";
  3. $a="word";
  4. ?>

  在PHP的代码中,使用分号(;)来区分表达式,表达式也可以包含在括号内。可以这样理解,一个表达式再加上一个分号,就是一条PHP语句。

定义和调用函数


  函数是代表一组语句的标识符,它能够实现程序模块化的策略。要完成一个模块化的策略就需要定义一个函数。在PHP中定义函数的语法格式如下:

  1. function function_name($arg_1,$arg_2,...$arg_n)
  2. {
  3. code 函数要执行的代码;
  4. return 返回的值;
  5. }

  其中 function 为声明自定义函数,function_name 为自定义函数的名字,$arg为参数列表,code为函数被调用时要执行的代码,要使用“{}”括起来,return 调用函数需要的返回值,return 为关键字。

  函数的调用很简单,只需要引用函数名并赋予正确的参数即可完成函数的调用。如下代码:

  1. <?php
  2. function values($a) //函数的声明
  3. {
  4. if($a==11)
  5. echo 'true';
  6. else
  7. echo 'false';
  8. }
  9. values(10); //函数的调用
  10. ?>

值传递


  在调用函数时,需要向函数传递参数,被传入的参数称为实参数,而函数定义的参数称为形参。参数传递的方式有按值传递与按引用传递。我们先介绍按值传递。

  值传递就是将实参的值复制到对应的形参中,在函数内部的操作针对形参进行,操作的结果不会影响到实参,即函数返回后,实参的值不会改变。

  1. <?php
  2. function values($a) //函数的声明
  3. {
  4. $a++;
  5. echo "在函数内:\$a=".$a; //输出形参的值
  6. }
  7. $a=1;
  8. values($a); //传值:将$a传递给形参$a
  9. echo "<p>在函数外 \$a=".$a."</p>"; //实参的值没有变化,输出 $a=1
  10. ?>

引用传递


  实参的内存地址传递到形参中,在函数内部的所有操作都会影响到实参的值,即返回后,实参的值会发生变化。传值时只需要在函数声明时的参数前加“”即可。

  1. <?php
  2. function values(&$a) //函数的声明
  3. {
  4. $a++;
  5. echo "在函数内:\$a=".$a; //输出形参的值 $a=2
  6. }
  7. $a=1;
  8. values($a); //传值:将$a传递给形参$a
  9. echo "<p>在函数外 \$a=".$a."</p>"; //实参的值有变化,输出 $a=2
  10. ?>

return


return 将函数的值返回给函数的调用者,即将程序控制权返回到调用者的作用域。

  1. <?php
  2. function values($a) //函数的声明
  3. {
  4. if($a==11)
  5. $t='true';
  6. else
  7. $t='false';
  8. return $t;
  9. }
  10. $temp=values(11); //函数的调用
  11. echo $temp; //结果为true
  12. ?>

strlen


  获取字符串的长度是字符串处理技术中非常重要的一项,通过其可以获取到指定字符串的长度,从而实现其他更多的功能。PHP为我们提供了strlen函数来实现。语法为:

  1. strlen(string str); //参数str为指定字符串,且该函数返回一个int类型的值
  1. <?php
  2. $a='1234abc';
  3. echo strlen($a); //结果为7
  4. ?>

strtoupper与ucwords


  PHP为我们提供了字符串中大小写字母转换的函数,strtoupper()将指定的字符全部转换为大写;strtolower()将北定的字符都转换成小写;ucwords()将指定字符串中每个单词的首字母都转成大写;ucfirst()函数将指定字符串的首字母转换为大写。其语法结构都是一样的,在括号中填入指定的字符串即可。

  1. <?php
  2. $a='i am A student.';
  3. echo strtoupper($a)."<br>"; // I AM A STUDENT.
  4. echo strtolower($a)."<br>"; // i am a student.
  5. echo ucfirst($a)."<br>"; // I am A student.
  6. echo ucwords($a)."<br>"; // I Am A Student.
  7. ?>

substr


  substr()函数从指定的字符串中按照指定的位置截取一定长度的字符。语法格式为:

  1. substr(string str,int start,int length);

  其中str为指定的字符串对象;start为指定开始截取字符串的位置,如果为start参数为负数,则从字符串末尾开始截取;length为可选参数,指定截取字符的个数,如果为负数则表示取到倒数第length个字符。并且该函数返回一个新的字符串。

  1. <?php
  2. $a='i am A student.';
  3. echo substr($a,0,1)." "; // i
  4. echo substr($a,-1,1)." "; // .
  5. echo substr($a,0)." "; // i am A student.
  6. ?>

注:字符串的索引是从0开始的。

strstr与strrchr


  strstr()函数获取指定字符串(A)在另一个字符串(B)中首次出现的位置到后者末尾的子字符串,区分字母大小写。语法格式如下:

  1. strstr(string haystack,string needle);

  参数haystack为指定将要被搜索的字符串;参数needle为指定将要搜索的内容,如果该参数是一个数值,那么将搜索与这个数值的ASCII值相匹配的字符。如果执行成功,则返回剩余字符串;如果没有找到,则返回False

  strrchr()函数获取字符串(A)在另一个字符串(B)中最后一次出现的位置,区分字母大小写。语法格式与strstr相同。

  1. <?php
  2. $a='i am A student.';
  3. echo strstr($a,"am"); //am A student.
  4. echo strrchr($a,"t"); //t.
  5. ?>

str_ireplace


  str_ireplace()函数将指定字符串替换为另外一个指定的字符串。语法格式为:

  1. str_ireplace(string search, string replace,string subject [,int &count])

  其中参数search为指定要查找的字符串;replace为指定替换的值;subject为指定查找的范围;count为可选参数,获取执行替换的数量。

  1. <?php
  2. $a='i am A student.';
  3. $c=0;
  4. echo str_ireplace("i am A","I am a",$a); //I an a student.
  5. echo str_ireplace("t","T",$a$c); //I am A sTudenT.
  6. echo $c; //2
  7. ?>
  另外关于字符串处理的函数还有很多.

if语句


  if条件控制语句是所有流程控制语句中最简单,最常用的一个,根据获取的不同条件判断执行不同的语句。语法为:

  1. if(exp) 语句; //基本的表达式
  2. if(exp){} //执行多条语句的表达式
  3. if(exp){}else{} //通过else延伸的表达式
  4. if(exp){}elseif(){}else{} //判断多个条件的表达式
  1. <?php
  2. $a=10;
  3. if($a==11)
  4. echo 'true';
  5. else
  6. echo 'false'; //结果为false
  7. ?>

switch语句


  switch语句和if条件控制语句类似,实现将同一个表达式与很多不同的值比较,获取相同的的值,并且执行相同的值对应的语句。其一般形式为:

  1. switch(表达式){ 
  2. case 常量表达式1:  语句1;
  3. case 常量表达式2:  语句2;
  4.  
  5. case 常量表达式n:  语句n;
  6. default:  语句n+1;
  7. }

  其语义是:计算表达式的值。 并逐个与其后的常量表达式值相比较,当表达式的值与某个常量表达式的值相等时, 即执行其后的语句,然后不再进行判断,继续执行后面所有case后的语句。如表达式的值与所有case后的常量表达式均不相同时,则执行default后的语句。 如下代码:

  1. <?php
  2. $x=3;
  3. switch ($x)
  4. {
  5. case 1:
  6. echo 'Number 1';
  7. break;
  8. case 2:
  9. echo "Number 2";
  10. break;
  11. case 3:
  12. echo "Number 3";
  13. break;
  14. default:
  15. echo "No number between 1 and 3";
  16. }
  17. ?>

while语句


  while循环控制语句,其主要作用主要是反复执行某一项操作。是循环控制语句中最简单的一个,也是最常用的一个。while循环控制语句对表达式的值进行判断,当表达式为非0值时,执行while语句中的内嵌语句号;当表达式的值为0时,则不执行while语句中的内嵌语句。其语法格为:

  1. while(expr){ //expr 为表达式
  2. statement; // 当表达式expr的值为true时,输出内容。
  3. }
  1. <?php
  2. $x=1;
  3. $sum=0;
  4. while($x<=100)
  5. {
  6. $sum+=$x;
  7. $x++;
  8. }
  9. echo "\$sum=".$sum;
  10. ?>

do...while语句


  do...while语句也是循环控制语句中的一种,使用方式和while相似,也是通过判断表达式的值来输出循环语句。该语句的操作流程是:先执行一次指定的循环体语句,然后判断表达式的值,当表达式的值为非0时,返回重新执行循环体语句的值,当表达式的值为非0时,返回重新执行循环体语句,如此反复,直到表达式的值等于0为止,此时循环结束。语法格式为:

  1. do
  2. {
  3. statement;
  4. }while(expr);
  1. <?php
  2. $x=1;
  3. $sum=0;
  4. do
  5. {
  6. $sum+=$x;
  7. $x++;
  8. }
  9. while($x<=100);
  10. echo "\$sum=".$sum;
  11. ?>

for语句


  for语句是PHP中最复杂的循环控制语句,拥有3个条件表达式。其执行的过程是首先执行表达式1;然后执行表达式2,并对表达式2的值进行判断,如果是真,则执行for循环语句中指定的内嵌语句,如果值为假,则结束循环,跳出for循环语句号;最后执行表达式3,返回表达式2继续循环执行。语法格式为:

  1. for(expr1;expr2;expr3)
  2. {
  3. statement;
  4. }
  1. <?php
  2. $sum=0;
  3. for($x=1;$x<=100;$x++)
  4. {
  5. $sum+=$x;
  6. }
  7. echo "\$sum=".$sum;
  8. ?>

break语句


  break语句用于结束当前条件控制语句if、switch或者循环控制语句while、do...while、for、foreach(后面介绍)的执行。

  1. <?php
  2. $x=3;
  3. switch ($x)
  4. {
  5. case 1:
  6. echo 'Number 1';
  7. break;
  8. case 2:
  9. echo "Number 2";
  10. break;
  11. case 3:
  12. echo "Number 3";
  13. break;
  14. default:
  15. echo "No number between 1 and 3";
  16. }
  17. ?>

continue语句


  continue跳转语句用来跳过本次循环中指定条件的语句,并且继续执行其他的循环语句。如下代码求1到100之间所有奇数的和。

  1. <?php
  2. $sum=0;
  3. for($x=1;$x<=100;$x++)
  4. {
  5. if($x%2==0) continue;
  6. $sum+=$x;
  7. }
  8. echo "\$sum=".$sum;
  9. ?>

声明数组


  在介绍PHP中数组的声明之前,首先介绍一下数组中的键。PHP提供了两种索引下标,分别为数值索引和关联索引。数值索引由数字组成,下标从0开始,数值索引一般表示数组元素在数组中的位置。与数值索引不同,关联索引一般表示索引与该索引对应的数组元素的关系。

  PHP中声明数组的方式主要有两种,第一种是应用array()函数声明数组,第二种是通过直接为数组元素赋值的方式声明数组。array()函数的声明格式如下:

  1. array("数组下标1"=>"数组元素值1","数组下标2"=>"数组元素值2",....,"数组下标n"=>"数组元素值n");

  应用array()函数声明数组时,数组下标既可以是数值索引也可以是关联索引。下标与数组元素值之间用"=>"进行连接,不同数组元素之间用逗号进行分隔。当然我们也可以用简单的定义方式:

  1. array("数组元素值1","数组元素值2","数组元素值3",...);

应用这种定义方式,下标默认从0开始,依次增1。而数组元素的访问可以通过[下标]的方式,如下代码:

  1. <?php
  2. $array=array("1"=>"你","2"=>"好","3"=>"啊"); //声明数组
  3. echo $array[1];
  4. echo $array[2]; // 输出数组元素的值
  5. echo $array[3]." ";
  6. $array1=array("你","好","啊");
  7. echo $array1[0];
  8. echo $array1[1];
  9. echo $array1[2];
  10. ?>

数组直接赋值,如下代码:

  1. <?php
  2. $array[1]="你";
  3. $array[2]="好";
  4. $array[3]="啊";
  5. print_r($array); //输出所创建的数组结构
  6. ?>

运行结果为:Array ( [1] => 你 [2] => 好 [3] => 啊 )


  对PHP中的数组元素进行输出可以通过输出语句来实现,如echo,print语句等,但这种输出方式只能对某数组中的某一元素进行输出。而通过print_r()函数可以将数组结构进行输出。

  1. <?php
  2. $array[1]="你";
  3. $array[2]="好";
  4. $array[3]="啊";
  5. print_r($array); //输出所创建的数组结构
  6. ?>

运行结果为:Array ( [1] => 你 [2] =>好 [3] => 啊 )

foreach


  foreach循环控制语句主要用于处理数组,是遍历数组的一种简单方法,语法格式为:

  1. froeach(array_expression as $value){
  2. statement;
  3. }
  4. 或者
  5. foreach(array_expression as $key=>$value){
  6. statement;
  7. }

参数array_expression是指主要遍历的数组,其中的$value是数组的值,$key是数组的键名称;statement是满足条件时要执行的语句。

  1. <?php
  2. $colors = array("red","green","blue","yellow");
  3. foreach ($colors as $value) {
  4. echo "$value <br>";
  5. }
  6. foreach($colors as $key=>$value){
  7. echo "$key $value <br>"; //输出键与值
  8. }
  9. ?>

函数介绍


  为了方便操作,提高程序的开发效率,PHP为程序开发人员提供了大量的与数组操作相关的函数。

array_key_exists()

  array_key_exists()用于判断某键值是否为该函数所指定的数组的键值,如果是则返回True,否则返回False。其语法格式为:

  1. bool array_key_exists(key,array_search)

其中key为要判断的键,array_search为要查询的数组。

count()

  count()用于返回指定数组中元素的个数。语法格式为:

  1. int count(mixed var [,int mode])

其中var为指定的数组,而mode为可选参数,如果选了,数组将进行递归计算。

sort()与rsort()

  sort()用于对指定的数组进行升序排序;rsort用于对指定数组进行降序排序。语法格式为:

  1. bool sort(array); bool rsort(array);

其中array为要排序的数组。下面代码是对以上函数的应用:

  1. <?php
  2. $array=array(1,5,6,3,7,10);
  3. if(array_key_exists("6",$array)) //判断6这个键是否在数组中
  4. echo "exist!<br>";
  5. else
  6. echo "not exist!<br>";
  7. echo "\$array的元素个数是:".count($array)."<br>";
  8. $asc=sort($array); //对数组进行升序排序
  9. foreach($array as $value){ //输出排序后的结果
  10. echo $value." ";
  11. }
  12. echo "<br>";
  13. $desc=rsort($array); //对数组进行降序排序
  14. foreach($array as $value){ //输出排序后的结果
  15. echo $value." ";
  16. }
  17. ?>

运行结果为:

  1. not exist!
  2. $array的元素个数是:6
  3. 1 3 5 6 7 10
  4. 10 7 6 5 3 1

概念


  世间万物都具有其自身的属性和方法,通过这些属性和方法可以将不同物质区分开来。例如,人具有身高、体重、胖瘦以及肤色等属性,通过这些属性可以对身边的亲戚、朋友进行简单的区分,人还可以进行吃饭、学习、走路等活动,这些活动可以称为人具有的功能。如果将人比作程序中的类,那么人的身高可以比作类中的属性,走路可以比作类中的方法。也就是说类是属性和方法的集合,是面向对象编程方式的核心和基础,通过类可以将零散的用于实现某项功能的代码进行有效管理。

  当然,类只是具备某项功能的抽象模型,实际应用中还需要对类进行实例化,这样就引入了对象的概念,对象是类进行实例化后的产物,一般情况下,程序是通过对象对类中的属性和方法进行引用的。

特点


  面向对象的编程方式具有继承、封装多态性等特点。

  (1)继承:通过继承可以创建子类和父类之间的层次关系,子类可以从其父类中继承属性和方法,通过这种关系模型可以简化类的操作,假如已经定义了A类,接下来准备定B类,而B类中有很多属性和方法与A类相同,那么就可以通过关键字extends实现B类继承A类,这样就无需再在B类中定义A类已具有的属性和方法,从而可以在很大程度数上提高程序的开发效率。

  例如,可以将水果看成一个父类,那么水果类具有颜色属性。然后再定义一个苹果类,在定义苹果类时完全可以不定义苹果烟灰缸颜色属性,通过如下继承关系完全可以使苹果类具有颜色属性。

  1. class 水果类{
  2. public 颜色; //在水果类中定义颜色属性
  3. }
  4. class 苹果类 extends 水果类{
  5. //在苹果类中定义其他属性和方法
  6. }

  (2)封装:类是属性和方法的集合,为了实现某项功能而定义类后,开发人员并不需要了解类体内每句代码的具体含义,只需通过对象来调用类内某个属性或方法即可实现某项功能,这就是类的封装性。

  例如:在使用电脑时,并不需要将电脑拆开了解每个部件的具体用外,用户只需按下主机箱上的Power按钮就可以启动电脑,在键盘上敲打就可以将文字输入到电脑中,但电脑内部的构造用户可以根本不了解,这就是封装的具体表现。

  (3)多态:类的多态性指不同的类进行同一操作可以有不同的行为。例如:定义一个为车类和一个汽车类,为车和汽车都可以移动,说明两者在这方面可以进行相同的操作,然而火车和汽车移动的行为是截然不同的,因为火车必须在铁轨上行驶,而汽车在公路上行驶,这就是类多态性的形象比喻。

类的结构及声明方式


  类是面向对象编程的核心基础,是属性和方法的集合,类不能真接编写程序时引用,必须实例化后才能使用。

  创建一个PHP类时,必须使用关键字class进行声明,该关键字后紧跟类的名称,之后用大括号将类体进行封装,类的基本声明格式如下。

  1. class 类名{
  2. //类体
  3. }

  创建完成类的基本结构后就可以编写类体。类体中主要包括属性和方法的声明及定义,当然也可能在类体中只定义属性或只定义方法,甚至类体内可以不定义任何属性。完整的类的定义格式如下。

  1. class 类名{
  2. public $attribute; //定义类的属性
  3.  
  4. public function fun(){ //定义类的方法
  5. //定义该方法所要实现的功能
  6. }
  7. }

属性和方法的定义


  通过以上介绍,已经可以对类的属性和方法有所了解,下面具体介绍类体内属性和方法的定义和使用。

  (1)属性:类的属性实质为在类体内定义的变量,用于保存或设置参数。

  (2)方法:类的方法实质为在类体内定义的函数,用于实现某项功能,其定义方法与普通函数定义方法相同,同时可以应用访问权限关键字对方法访问权限进行限制。

  1. class 类名{
  2. public $attribute; //定义类的属性
  3.  
  4. public function fun(){ //定义类的方法
  5. //定义该方法所要实现的功能
  6. }
  7. }

使用构造函数


  对类体进行初始化主要有两种方法。第一种方法是在类体中定义一个专门的用于对类体进行初始化的方法。第二种方法是应用构造函数实现类体的初始化。如下代码:

  1. <?php
  2. class car{
  3. public $color;
  4. public $size;
  5.  
  6. public function setAttribute($x,$y){ //属性初始化
  7. $this->color=$x;
  8. $this->size=$y;
  9. }
  10.  
  11. public function printAttribute(){ //输同属性
  12. echo "颜色:".$this->color;
  13. echo " 大小:".$this->size."米";
  14. }
  15. }
  16. $bus=new car();
  17. $bus->setAttribute("blue","20"); //初始化类的内部成员
  18. $bus->printAttribute(); //输出结果
  19. ?>

运行结果为:颜色:blue 大小:20米

  由于对类中属性的初始化工作频繁,如果每定义一个类都定义用于实现类体内属性初始化的方法会显得十分繁琐。为了解决这个问题,面向对象的编程提供了构造函数的概念。通过构造函数来初始化。PHP中构造函数统一的命名为_construct(),作用就是对类体进行初始化,并可在实例化对象时为构造函数指定参数。

  1. <?php
  2. class car{
  3. public $color;
  4. public $size;
  5.  
  6. public function _construct($x,$y){ //通过构造函数对类体中的属性进行初始化
  7. $this->color=$x;
  8. $this->size=$y;
  9. }
  10.  
  11. public function printAttribute(){
  12. echo "颜色:".$this->color;
  13. echo " 大小:".$this->size."米";
  14. }
  15. }
  16. $bus=new car("blue","20"); //在实例化对象时为类体中属性指定初始值
  17. $bus->printAttribute();
  18. ?>

运行结果为:颜色:blue 大小:20米

:构造函数是在对类体进行实例化时自动调用的。

使用析构函数


  与构造函数对应的是析构函数。析构函数在销毁类之前执行,并统一命名_destruct(),其作用是在类被销毁前自动完成某项功能。

  1. <?php
  2. class conn{
  3. public $hostname;
  4. public $username;
  5. public $userpwd;
  6. public $conn;
  7. public function _construct($x,$y,$z){ //应用构造函数对类体中的属性进行初始化
  8. $this->hostname=$x;
  9. $this->username=$y;
  10. $this->userpwd=$z;
  11. }
  12.  
  13. public function getConn(){ //建立数据库的连接
  14. $this->conn=MySQL_query($this->username,$this->username,$this-userpwd);
  15. return $this->conn;
  16. }
  17. public function _destruct(){ //应用析构函数自动释放连接资源
  18. MySQL_close($this->conn);
  19. }
  20. }
  21. ?>

类的实例化


  一般情况下,创建一个类后并不能直接的对属性和方法进行引用,必须对类进行实例化,即创建一个对象。PHP中用new 关键字创建对象。例如,已经创建了一个名为student的学生类,为了引用该类中的属性或方法可以按照如下形式实现。

  1. $stu=new student(参数列表);

  接下来,通过$stu对象调用student类中的属性和方法,假如该类中有一个获取学生详细信息的getStudentInfo()方法,那么通过$stu对象调用该方法的语法格式如下(即通过"->"来访问):

  1. $stu->getStudentInfo();

控制访问权限


  在PHP 5.0中引入了访问修饰符,这种权限控制机制可以控制访问权限的可见性。访问修饰符主要包括publicprivateprotect这3种,当然如果不加任何修饰符对类体中的属性或方法进行修饰,则默认为public

  1.public:如果对类体中的属性或方法用该关键字进行修饰,则被修饰的元素称为公有成员,公有成员在类体内和类体外均可被访问。

  2.private:用该关键字修饰过的属性或方法被称为私有成员,只有在类体内可以对私有成员进行访问。

  3.protect:用该关键字修饰过的属性或方法被称为保护成员,保护成员只有在类体内和该类的子类中访问。

继承


  PHP中用关键字extends指明继承关系。例如,已经定义了类A,如果让类B继承A,可以用下面的方式定义类B。

  1. class B extends A {
  2. // 类B中的成员
  3. }

  这样B类就可以继承类A的公有和受保护的成员。但类的继承是单向的,子类可以从父类中继承特征,但父类却不能从子类中继承,也就是说,类A不能继承类B的成员。

  PHP自身并不支持多继承,也就是说一个子类只能有一个父类,一个父类可以有多个子类。

重载


  如果在父类中已经定义了某属性或方法,然后在子类中定义与父类同名的属性和方法也是合法的,这就是类的重载。利用重载可以重写父类中指定方法所实现的功能。

  1. <?php
  2. class father{ //定义father 类
  3. public function printNUM(){
  4. echo 10;
  5. }
  6. }
  7.  
  8. class child extends father{ //子类child 继承 father 类
  9. public function printNUM(){ //重写 father 类中的方法,实现重载
  10. echo 10*10;
  11. }
  12. }
  13.  
  14. $test1=new father();
  15. $test1->printNUM(); //输出10
  16. echo "<br>";
  17. $test2=new child();
  18. $test2->printNUM(); // 输出100
  19. ?>

final


  并不是任何时候都可以实现继承的重载的,利用final关键字修饰的方法不能被重载,同样使用该关键字修饰的类也不能被继承。看下面实例:

  1. <?php
  2. class father{
  3. final function fun(){
  4. echo "father";
  5. }
  6. }
  7.  
  8. class child extends father{
  9. function fun(){
  10. echo "child";
  11. }
  12. }
  13.  
  14. $obj=new child();
  15. $obj->fun();
  16. ?>

运行上面代码将出现以下信息:

  1. Fatal error: Cannot override final method father::fun()

接口


接口可以看作是多继承的解决方案,其主要思想是指定一个实现了该接口的类,而在该类中必须实现接口中所有的方法。

PHP中接口是用关键字interface进行声明,例如:

  1. <?php
  2. interface test{ //定义test接口
  3. function fun();
  4. }
  5. ?>

  以上代码声明了test接口,并在接口中定义了方法fun(),但并未定义fun()方法的具体所要实现的功能。定义fun()方法所实现的功能是在实现该接口的类中定义的,这样就引入了实现接口的概念。用关键字implements指定类所要实现的接口,并且该类必须定义接口中的所指定的方法,否则程序将发生错误。继承多个接口时,每个接口名称要用逗号隔开。

  1. <?php
  2. class work implements test{ // 实现test接口
  3. function fun(){
  4. echo "实现接口";
  5. }
  6. }
  7. ?>

多个接口的实现如下代码:

  1. <?php
  2. interface test1{ //定义test1接口
  3. function fun();
  4. }
  5.  
  6. interface test2{ //定义test2接口
  7. function fu();
  8. }
  9.  
  10. interface Itest extends test1,test2{ //接口Itest 继承test1,test2 接口
  11. function ifun();
  12. }
  13.  
  14. class work implements Itest{ //接口的实现
  15. function fun(){
  16. echo "实现接口test1中的方法";
  17. }
  18. function fu(){
  19. echo "实现接口test2中的方法";
  20. }
  21. function ifun(){
  22. echo "实现接口Itest中的方法";
  23. }
  24. }
  25. ?>

域运算符


  在PHP中“::”这个叫范围解析操作符,又名域运算符。“::”符号可以认为是与C语言中的“.”相似的,而它更像C++中(Perl)的::类范围操作符。

  在没有声明任何实例的情况下访问类中的函数或者基类中的函数和变量很有用处。而:: 运算符即用于此情况。

  1. <?php
  2. class A {
  3. function example() {
  4. echo "I am the original function A::example().<br />\n";
  5. }
  6. }
  7.  
  8. class B extends A {
  9. function example() {
  10. echo "I am the redefined function B::example().<br />\n";
  11. A::example();
  12. }
  13. }
  14.  
  15. // A 类没有对象,这将输出
  16. // I am the original function A::example().<br />
  17. A::example();
  18.  
  19. // 建立一个 B 类的对象
  20. $b = new B;
  21.  
  22. // 这将输出
  23. // I am the redefined function B::example().<br />
  24. // I am the original function A::example().<br />
  25. $b->example();
  26. ?>

对象克隆


对类进行实例化后,就可以通过实例化后的对象调用类中的成员,如果要求两个对象具有相同的特征,可以再对类进行实例化来生成一个新对象,PHP 提供了关键字 clone,应用该关键字即可实现对象的克隆,如下代码:

  1. <?php
  2. class work {
  3. function fun(){
  4. echo "work!";
  5. }
  6. }
  7.  
  8. $obj1=new work();
  9. $obj2=clone $obj1; //对object1进行实例化生成对象$obj2
  10. $obj2->fun(); //与obj1有相同的特性,输出work!
  11. ?>

this


  this关键字为指向当前对象的指针,可以用该关键字调用当前类体中的属性和方法。

  1. <?php
  2. class work {
  3. private $x;
  4. private $y;
  5. function _construct($a,$b){ //通过this关键字对当前类体中的属性进行赋值
  6. $this->x=$a;
  7. $this->y=$b;
  8. }
  9. }
  10. ?>

parent


  parent关键字是指向父类的指针,主要用于调用父类的构造函数。如下代码,首先定义test类作为父类,并在该类中定义构造函数_construct(),然后定义test2并继承test,同时在test2类体中定义该子类的构造函数,并在该构造函数中用parent来实现父类的初始化。

  1. <?php
  2. class test {
  3. private $x;
  4. private $y;
  5. function _construct($a,$b){ //通过构造函数对当前类体中的属性进行赋值
  6. $this->x=$a;
  7. $this->y=$b;
  8. }
  9. }
  10.  
  11. class test2 extends test {
  12. public function _construct(){
  13. parent::_construct("软件网","在线学习"); // 通过parent 调用父类的构造函数
  14. }
  15. }
  16. ?>

self


self关键字是指向类的本身,也就是说该关键字并不指向任何已实例化的对。由于类只能直接引用类体中的静态成员,而关键字又指向类本身,所以self关键字经常用于在类体中调用类的静态成员,调用方法为self关键字加域运算符再加静态成员名。静态变量一般用static 修饰。

  1. <?php
  2. class test {
  3. static private $x;
  4. function getNum(){
  5. return ++self::$x; //通过self调用类体中的静态成员$x
  6. }
  7. }
  8. ?>

include()


  引用外部文件可以使代码变得更简洁,可以更好的理解代码结构,是PHP编程的重要技巧,首先我们先来介绍include()语句。

  使用include()语句包含外部文件时,只有代码执行到include()函数时才将外部文件包含进来,当所包含的外部文件发生错误时,系统只会给出一个警告,而整个PHP文件则继续向下执行。语法为:

  1. include(string filename);

参数filename是指定完整路径的文件名。

如下代码:

  1. <table><tbody>
  2. <tr><td><?php include("top.php");?></td></tr>
  3. <tr><td><?php include("main.php");?></td></tr>
  4. <tr><td><?php include("bottom.php");?></td></tr>
  5. </tbody></table>
这样我们就把3个外部文件top.php、main.php、bottom.php引入到想要展现的文件中来了。

reqiure()


  require()语句与include()语句类似,都是实现对外部文件的调用。当使用require()语句时载入文件时,它会作为PHP文件的一部分被载入。如果通过require()语句载入一个HTML文件,如"hello.html",文件内的任何PHP命令都会被处理。语法为:

  1. include(string filename);

参数filename是指定完整路径的文件名。

  requireinclude 几乎完全一样,除了处理失败的方式不同之外。require 在出错时产生 (E_COMPILE_ERROR) 级别的错误。换句话说将导致脚本中止而include 只产生警告(E_WARNING),脚本会继续运行。

  1. <?php
  2. require('top.php'); //嵌入外部文件top.php
  3. ?>

include_once()


  include_once()函数是include()函数的延伸,它的作用和include()函数几乎是相同的,唯一的区别在include_once()函数会在导入文件前先检测该文件是否在该页面的其它部分被导入过,如果有的话就不会重复导入该文件。

  例如,要导入的文件中存在一些自定义函数,那么如果在同一个程序中重复导入这个文件,在第二次导入时便会发生错误,因为PHP不允许相同名称的函数被重复声明第二次。语法与include函数相同。

  1. <?php
  2. include_once('top.php'); //嵌入外部文件top.php
  3. ?>

require_once()


  require_once()语句是require()语句的延伸,它的功能与require类似,不同的是require_once()语句会先检查要导入的文件是不是已经在该程序中的其它地方被调用过,如果有的话就不会再次重复调用该文件。语法与require()相同。

  比如,同时应用require_once语句在同一页面中调用了两个相同的文件,那么在输出的时候只有第一个文件被输出,第二次调用的文件不会被输出。

  1. <table><tbody>
  2. <tr><td><?php require_once("top.php"); //载入头文件 ?></td></tr>
  3. <tr><td><?php require_once("main.php"); //嵌入主文件 ?></td></tr>
  4. <tr><td><?php require_once("bottom.php"); // 嵌入尾文件 ?></td></tr>
  5. </tbody></table>

打开与关闭


  对文件进行操作时,首先要打开文件,这是进行数据存储的第一步。在PHP中可以使用fopen()函数打开一个文件,函数语法为:

  1. int fopen(string filename,string mode);

  参数filename是要打开的包含路径的文件名,可以是相对路径或绝对路径;参数mode是打开文件的方式,如下表:

文件打开方式 意义
rt 只读打开一个文本文件,只允许读数据
wt 只写打开或建立一个文本文件,只允许写数据
at 追加打开一个文本文件,并在文件末尾写数据
rb 只读打开一个二进制文件,只允许读数据
wb 只写打开或建立一个二进制文件,只允许写数据
ab 追加打开一个二进制文件,并在文件末尾写数据
rt+ 读写打开一个文本文件,允许读和写
wt+ 读写打开或建立一个文本文件,允许读写
at+ 读写打开一个文本文件,允许读,或在文件末追加数据
rb+ 读写打开一个二进制文件,允许读和写
wb+ 读写打开或建立一个二进制文件,允许读和写
ab+ 读写打开一个二进制文件,允许读,或在文件末追加数据

  文件使用方式由r、w、a、t、b 和 + 六个字符拼成,各字符的含义是:

方式 含义
r(read)
w(write)
a(append) 追加
t(text) 文本文件,可省略不写
b(binary) 二进制文件
+ 读和写

  当我们对文件操作完成以后,要用fclose()函数对文件进行关闭,语法格式为:

  1. fclose(resource handle);

  参数handle为要关闭的文件。

读取部分文件


读取一个字符:fgetc()

  在对某一个字符进行查找、替换时,就需要有针对性地对某个字符进行读取,在PHP中可以使用fgetc()函数实现此功能。格式如下:

  1. string fgetc(resource handle);

  fgetc()函数从文件指针中读取字符,返回一个字符的字符串。该字符从handle指向的文件中得到。

  1. <?php
  2. $f_open=fopen("./a.txt","rt"); //打开文件
  3. $chr=fgetc($f_open); //读取一个字符
  4. while(false!==$chr) //判断是不是读到文件的末尾
  5. {
  6. echo $chr;
  7. $chr=fgetc($f_open);
  8. }
  9. fclose($f_open); //关闭文件
  10. ?>

读取任意长度字符:fread()

  函数fread()可以从文件中读取指定长度的数据,格式如下:

  1. string fread(int handle,int length);

  该函数从文件指针handle读取length个字节。在读取了length个字节数或到达文件末尾时,就会停止读取文件。

  1. <?php
  2. $f_open=fopen("./a.txt","rt"); //打开文件
  3. $chr=fread($f_open,5);
  4. echo $chr;
  5. ?>

读取一行数据:fgets()和fgetss()

  在文件中要对数据进行逐行读取,可以使用fget()和fgetss()函数。

fgets()函数用于一次读取一行数据。函数声明如下:

  1. string fgets(int handle [,length]);

  参数handle是被打开的文件,参数length是要读取的数据长度,函数能够实现从handle指向文件中读取一行返回长度最大值为length-1个字节的字符串,如果没有指定长度,默认为1KB。

  而fgetss()函数是fets()函数的变体,用于读取一行数据,同时fgetss函数会过滤掉被读取内容中的html和php标记,而fgetss()函数需要指定长度。

  1. <?php
  2. $f_open=fopen("./a.txt","rt"); //打开文件
  3. $chr=fgets($f_open,5);
  4. echo $chr;
  5. ?>

读取部整个文件


readfile()函数

  readfile()函数用于读入一个文件,将其写入到输出缓冲,返回从文件中读入的字节数。如果出错返回False,使用它时只要一句话就可以,如下代码:

  1. readfile("./a.txt");

file()

  file()函数可以把文件读入到一个数组中,将文件作为一个数组来返回,数组中每个单元都是文件中相应的一行,包括换行符在内。失败将返回false。它的调用也很简单:

  1. <?php
  2. $chr=file("./a.txt");
  3. foreach($chr as $i=>$chr)
  4. echo $i."<br>";
  5. ?>

写入文件


  PHP为我们提供fwrite()函数向文件中写入数据。语法如下:

  1. int fwrite(resource handle,string string[,int length]);

  把内容string写入文件指针handle处。如果指定了长度长度,当写入了length个字节,定入就会停止。如果文件内容长度小于length,则会无法写入。

  1. <?php
  2. $chr=fopen("./a.txt",'a');
  3. if(!fwrite($chr,"fwrite")){
  4. print '不能写入';
  5. exit;
  6. }
  7. print '成功';
  8. fclose($chr);
  9. ?>

删除文件


  ulink()函数用于删除文件。使用时文件必须是关闭的。如果成功返回True,否则返回false。这个函数要慎用,一旦被删除就无法恢复。

  1. <?php
  2. ulink("./a.txt");
  3. ?>

复制文件


  要实现文件的复制可以使用copy()函数。声明如下:

  1. bool copy (string file1,string file2);

  该函数将文件从file1复制到file2。成功返回true,否则返回false。

  1. <?php
  2. $file1="./file1.txt";
  3. $file2="./file2.txt";
  4. copy($file1,$file2); //从file1中复制到file2中。
  5. readfile($file2);
  6. ?>

移动和重命名文件


rename()函数不仅可以实现重命名,还可以实现文件的移动。函数声明如下:

  1. bool rename(string oldname,string newname);

该函数把oldname重命名为newname,成功返回true,否则返回false。想要实现文件的移动,只要给指定的文件移动到另外一个路径下的文件夹中,不改变该文件的名称,就实现了对指定文件的移动。

  1. <?php
  2. $old_name="./file1.txt";
  3. $new_name="./file2.txt";
  4. if(rename($old_name,$new_name)
  5. echo "重命名成功<br>";
  6. if(rename($new_name,"../$new_name");
  7. echo "移动文件成功"
  8. ?>

建立目录


创建目录是通过mkdir()函数来实现的,函数语法格式如下:

  1. bool mkdir(string pathname);

本函数建立名为pathname的目录,成功返回true,否则返回false。

  1. <?php
  2. if(file_exists("./mrbook"))
  3. echo "目录已经存在";
  4. else
  5. mkdir("./mrbook");
  6. ?>

打开目录


目录作为一种特殊的文件,同样操作它的第一步也是打开。PHP 使用opendir()函数来打开目录,函数声明如下:

  1. resource opendir(string path);

参数path是一个合法的目录路径,成功执行后返回目录的指针;如果不合法,则产生错误信息。

  1. <?php
  2. $demo="./mrbook";
  3. if(is_dir($demo)) //检测是否是一个合法的目录
  4. if($dir=opendir($demo)) //打开目录
  5. echo $dir; //输出目录指针
  6. closedir($demo); //关闭目录
  7. ?>

读取目录


  在PHP中要读取已经打开目录中的数据可以使用readdir()函数。函数声明如下:

  1. string readdir(resource dir_handle);

参数dir_handle为使用opendir()函数打开一个目录返回的目录指针。该函数执行,返回目录中下一个文件名,文件名以在文件系统中的顺序返回。读取结束时返回false。 如下代码,我们在前面已经建立目录./mrbook。

  1. <?php
  2. $f_open="./mrbook";
  3. $i=0;
  4. if(is_dir($f_open)){ //检测是否是一个合法的目录
  5. if($dir=opendir($f_open)){ //打开目录
  6. while($con=readdir($dir)){//读取目录
  7. $i++;
  8. echo "$i:$con<br>"; //输出目录中的内容
  9. }
  10. }
  11. }
  12. closedir($dir);
  13. ?>

运行结果为:

  1. 1:..
  2. 2:.

删除目录


  既然可以创建设一个目录,那么也可以删除一个目录。删除目录主要通过is_dir和rmdir()。两个函数来实现,通过is_dir()来判断获取的文件是否为目录,如果是,则通过rmdir()来删除,否则提示“删除目录失败” 。删除成功返回true,失败则返回false。 rmdir()函数的语法格式如下:

  1. bool rmdir(string dirname);
  1. <?php
  2. if(!file_exists("./mrbook"))
  3. echo "目录已经干掉了";
  4. else
  5. rmdir("./mrbook");
  6. ?>

  注意:删除的目录必须是空的目录。

改变目录


在PHP中对于已经打开的目录,如果要转到另外一个目录,可以使用chdir()函数来实现该操作。函数声明如下:

  1. bool chdir(string directory);

其中directory为新的目录,成功执行返回true,否则返回false

  1. <?php
  2. $shili="D:\\asp";
  3. $dir=opendir($shili);
  4. echo $dir;
  5. closedir($dir); //关闭目录
  6. $dir=chdir("D:\\sum");
  7. echo "<p>.$dir";
  8. ?>

关闭目录


关闭目录可以使用closedir()函数,函数声明如下:

  1. void closedir(resource dir_handle);

参数dir_handle为使用opendir()函数打开一个目录返回的目录指针。

  1. <?php
  2. $shili="./mrbook";
  3. $shi=opendir($shili); //打开文件
  4. //.......... //对文件进行操作
  5. closedir($shi); // 关闭目录
  6. ?>

概述


  日期和时间在数据处理中应用非常广泛。为此PHP提供了专门用于对日期和时间进行操作的函数,为了更好的理解和运用日期和时间,下面对PHP中提供的日期和时间函数进行简单介绍:

  checkdate函数验证日期的正确性;date函数将服务器的时间格式化;getdate获得时间及日期信息;time获取目前时间的UNIX时间戳。

date


  通过date函数可以获取按照指定格式输出的日期和时间信息,如果省略参数,会自动获取本地的当前时间。声明如下:

  1. string date(string format,int timestamp);

 其中参数format为显示格式,参数timestamp为时间戳,是可选择的,默认为time(),即如果没有给出时间戳则使用本地当前时间。format格式参数在这里简单介绍几个:"Y"四位数字完整表示年份,"y"两位数字表示年份,"M"三个字母表示月份,"m"数字表示月份,"D"星期中的第几天,"d"月份中的第几天,"H"24小时格式,"h"12小时格式,"I"判断是否为夏令时,"i"分钟数,"s"秒数。

  1. <?php
  2. echo date("Y-m-d H:i:s");
  3. ?>

getdate


通过getdate()函数可以获取日期信息,而该函数返回值为一个数组,其中包括指定的日期和时间信息。如果没有给出时间戳,则输出的是本地当前的日期和时间。 声明如下:

  1. array getdate(int timestamp);
  1. <?php
  2. print_r(getdate());
  3. ?>

运行结果为:

  1. Array ( [seconds] => 11 [minutes] => 17 [hours] => 3 [mday] => 22 [wday] => 3 [mon] => 7 [year] => 2015 [yday] => 202 [weekday] => Wednesday [month] => July [0] => 1437535031 )

checkdate


程序开发过程中,在需要设计填写日期和时间的模块中,有时会因为录入失误,而产生错误。为了避免些类问题的出现,在设计时就要对日期进行检验,就是利用checkdate函数。声明如下:

  1. bool checkdata(int month,int day,int year);

如果检验有效,返回true,否则返回false。month的有效值在1-12,day在给定的月之内,包括闰年,year的值在1-32767之间。

  1. <?php
  2. echo checkdate(12,29,2015);
  3. ?>

time


获取当前时间戳通过time()函数来实现。声明如下:

  1. int time();
  1. <?php
  2. echo time(); //获取当前时间的时间戳
  3. ?>
当然处理日期和时间的函数还有很多。

概述


  Cookie和会话控制是PHP编程的重要内容,有效使用Cookie和会话控制,可以轻松完成很多复杂任务。

  Cookie是在HTTP协议下,服务器或脚本可以维护客户工作站上信息的一种方式。Cookie是由Web服务器保存在客户机上的小文本文件,它可以包含有关用户的信息(如身份识别号码、密码、用户在Web站点购物的方式等)。无论何时用户链接到服务器,Web站点都可以访问Cookie信息。

  通过会话控制可以轻松地完成很多任务,例如在网站上某一个页面中的变量(指服务器端变量)是不能在下一页中使用的,但通过Session可以解决上述问题,Session中注册的变量可以作为全局变量使用,这样就可以将Session用于用户身份认证,记录程序状态、页面之间参数传递及电子商务网站中制作购物车等。

setCookie


在PHP中通过setCookie()函数设置Cookie, setCookie()函数的语法格式如下:

  1. bool setCookie(string name[,string value[,int expire[,string path[,string domain[,int secure]]]]]);

参数说明如下:

参数 说明
name Cookie的名字
value Cookie的值
expire Cookie的过期时间
path Cookie在服务器端的有效路径
domain Cookie有效的域名
source 指明Cookie是否通过安全的HTTPS

在PHP中通过$_COOKIE预定义变量来访问Cookie的值。如下面的例子

  1. <html>
  2. <body>
  3. <?php
  4. $exam="PHP Cookie测试!";
  5. setCookie("test",$exam);
  6. echo $_COOKIE['test'];
  7. ?>
  8. </body>
  9. </html>

当设置Cookie值后,在Cookie的有效期内,Cookie都会一直存在。只要是通过这台机器登录服务器的,本机上的Cookie信息随时都可以调用。出于安全的考虑,大多数用户不希望保存Cookie,所以可以手动删除掉Cookie。删除Cookie最好的办法是使用setCookie函数设置过期时间。

  1. <?php
  2. $test="过期时间";
  3. setCookie("test",$test);
  4. setCookie("test",$test,time()+1800); //0.5小时失效
  5. ?>

我们也还可以通过这种方式:

  1. <?php
  2. setCookie("test","",time()-3600); //删除Cookie
  3. ?>

然后我们可以判断Cookie是不是为空,判断是否为空用函数empty($_COOKIE['test']),如果为空就表示已经删除了。


PHP有一种机制,它可以把数组和Cookie联系起来。使用如下格式:

  1. setCookie("Cookie_name[1]","Cookie_value1");
  2. setCookie("Cookie_name[2]","Cookie_value2");

当需要使用Cookie数组时,可以用foreach循环来读取对应的变量名和值。如下代码:

  1. <?php
  2. setCookie("Cookie[PHP]","PHP是一种脚本语言!");
  3. setCookie("Cookie[MYSQL]","MYSQL是一个数据库!");
  4. setCookie("Cookie[Apache]","Apache是一个服务器!");
  5. foreach($_COOKIE['Cookie'] as $name=>$value){
  6. echo "$name:$value<br>";
  7. }
  8. ?>

运行结果为:

  1. PHP:PHP是一种脚本语言!
  2. MYSQL:MYSQL是一个数据库!
  3. Apache:Apache是一个服务器!

会话的基本方式


会话的基本方式有会话ID的传送和会话ID的生成。

1.会话ID的传送有两种方式,一种是Cookie方式,另一种方式是URL方式。

2.会话ID的生成

  PHP的会话函数会自动处理ID的创建,但也可以通过手工方式来创建会话ID。它必须是不容易被人猜出来的,否则会有安全隐患。

一般推荐生成会话ID使用随机数发生器函数rand,函数声明如下:

  1. rand(min,max);

注:如果没有提供可选参数 min 和 max,rand() 返回 0 到 RAND_MAX 之间的伪随机整数。例如,想要 5 到 15(包括 5 和 15)之间的随机数,用 rand(5, 15)。

然后利用md5函数生成一个唯一的会话ID。如下:

  1. md5(rand());

创建会话


创建一个会话需要通过以下几个步骤:启动一个会话,注册会话变量,使用会话变量,使用会话变量和注销会话变量。

1.启动一个会话

我们可以通过session_start()函数创建会话。声明如下:

  1. bool session_start();

它判断是否有一个会话ID存在,如果不存在,就创建一个,并且使其能够通过全局数组$_SESSION进行访问。如果已经存在,则将这个已经注册的会话变量载入以供使用。

2.注册全话变量

会话变量被启动后,全部保存在数组$_SESSION中。通过数组$_SESSION创建一个会话变量很容易,只要直拉给该数组添加一个元素即可。如下代码:

  1. $_SESSION["session_name"]="session_value";

3.使用会话变量

会话变量的使用就是如何获取它的值,如下代码:

  1. if(!empty($_SESSION['session_name']))
  2. $myvalue=$_SESSION['session_name'];

4.注销会话变量

注销会话变量,同数组的操作一样,直接注销$_SESSION数组的某个元素即可。如果要注销$_SESSION['session_name']变量可以直接使用如下语句:

  1. unset($_SESSION['session_name']);

如果整个会话已经结束,首先应该注销所有的会话变量,然后使用session_destroy()函数清除会话ID。

  1. <?php
  2. session_start(); //启动会话
  3. $_SESSION['u_name']="Jim"; //创建会话变量
  4. echo "用户名:".$_SESSION['u_name']; // 使用会话变量
  5. echo '<br><a href="./dest.php">退出</a>"; // 在dest.php中注销session
  6. ?>

建立连接


  在这里选用sqlite数据库。

  PHP连接sqlite数据库的方法很简单, 如下代码:

  1. $db = new PDO("sqlite:./resultdb"); //注意冒号后面的是要连接数据库的路径,冒号前面的不能省略。
  2. if($db)
  3. echo "连接成功!";
  4. else
  5. echo "连接失败";

当数据库连接成功返回一个资源,为以后执行sql指令做准备,否则返回false。

query()


上一节中我们已经讲了连接数据库,下面我们就要对数据库中的表进行操作了。比如要执行查询语句“select”,可以通过函数query()来执行。代码如下:

  1. <?php
  2. $db = new PDO("sqlite:./resultdb"); //连接数据库
  3. $db->query("select id from t1;"); //执行query函数,向查询数据库中的数据
  4. ?>

  如果SQL语句是一个查询指令“select”,成功,则返回查询后的结果集,失败,则返回“False”;如果SQL语句是“insert、delete、update、creat”等操作指令,成功返回的是“True”,失败返回的是“False”。

exec()


  如果我们要执行多条查询语句或者插入语句,我们可以通过exec()函数来执行。代码如下:

  1. <?php
  2. $db = new PDO("sqlite:./resultdb"); //连接数据库
  3. //执行exec函数,向查询数据库中的数据
  4. $db->exec("insert into t1 values(6,'tom');insert into t1 values(7,'tonny');");
  5. ?>

  exec()函数并不返回结果集而是用于对给定的数据库执行一个无结果的查询。

遍历查询结果


  在前面的课程中,通过query()函数执行select语句返回结果集后,这时就可以用foreach来取到想要的数据。如下代码:

  1. <?php
  2. $db = new PDO("sqlite:./resultdb"); //连接数据库
  3. $ss=$db->query("SELECT id FROM t1;"); // 查询t1表中所有的id
  4. foreach ( $ss as $row)
  5. {
  6. echo "$row[0]"." "; //取到所有id
  7. }
  8. ?>
另外,还有一些其它的函数。

PHP以其简单易学的特点,以及敏捷开发的优势,从一个几乎不为人知的开源项目,慢慢成长为技术人员首选的动态Web设计工具,与其他语言相比,PHP表现的更好、更快、更简单易学。尽管如此,我们在面对一项自己不熟悉的新技术时,仍然会感到无所适从,不知从何处入手,似乎总是感觉摸不出一条清晰的脉络来。另外,最大的障碍莫过于学习的过程枯燥乏味,从而失去学习兴趣。不过,如果你能掌握一种适合你的学习方法,就可以事半功倍。本人根据自已的多年PHP教学经验,和众多人才培养的成功案例,列出的学习方法或多或少的有一定借鉴性。当然再科学的学习方法,也只是让你少走弯路,而不能一夜精通,还是需要持久的修炼!

一、确定学习的目标

学习PHP都是有原因的,是什么让你选择学习PHP呢?是爱好?是为了找工作?还是工作中的开发需要?或是他人推荐的?等等。当然,不管你是出于什么原因,即然选择学习PHP就一个要有坚定的信念。不能一时兴起学了一阵儿,当听别人说某某语言有多么的好,马上切换,或是多门语言的学习同时进行。只有专心在一门课上下苦功,才能成为“专家”,持之以恒才能产生兴趣,毕竟兴趣才是最好的老师!

二、PHP学习线路图

刚开始学习PHP时,多数新手都会有一些迷茫,不知从哪里开始学起,不了解学习的顺序,找不到学习的重点。例如,有新手听说学PHP需要先搭建好运行环境,就按网上资料搭建。网上好多这方面的资料,几乎都是真实项目上线使用的专业环境,所提供的都是Linux下源代码包安装方式,相当的复杂,成手如果按项目功能定制安装都有可能要花费一两天的时间,新手有的需要花费一两个月时间才弄个大概,这就是为什么有好多新手从一开始就选择了放弃。如果有人教你一种学习用的集成安装环境,可能你只需要5分钟就可以搞定。还有新手学了好久,就是不知道如何写项目,反反复复学习基础部分,就是停滞不前。也有的新手找不到重点,学习大量的内容,结果实际用到的并不多,有一多半可能这辈子都不会用上,浪费好多时间。所以新手开始学习,就像走到大山深处,需要有人给你指引,找到正确的方向才能大步前行。如图1-15为PHP新手学习线路图。

按PHP学习线路图1-15中的指引,可以将学习PHP的过程分为4个阶段,一步步前行,为每个阶段设定一个学习目标,并安排好学习计划,达到目标后就可以开启下一阶段的学习。

Ø 阶段一入门

这是刚刚接触PHP时的入门阶段,先要了解PHP的开发能力,并多接触一些用PHP开发过的开源项目,网上有很多开源的PHP项目可以下载,先学习一下简单功能操作即可,主要是能产生对PHP的学习兴趣,从中了解PHP的开发需求和PHP开发特点等。就像如果你想学习制造汽车或修理汽车,一定要先学会驾驶汽车一样。在本章的前面了解过Web开发所需的构件儿,所以只孤立学PHP肯定是不行的,先学PHP也不行。如果刚开始接触Web开发就直接学习PHP会力不从心,因为PHP是服务器端脚本,怎么也要安装PHP的运行环境去解析它吧。另外,PHP是嵌入到HTML中的脚本语言,所以怎么也要了解一些常见的HTML标记吧。在开始学习PHP之前先做一点准备是非常有必要的。

Ø 阶段二打基础

这个阶段是学习的重点,但方法很重要,像PHP的基本语法和语言结构(流程控制、函数、字符串等)这部分内容能学多细就学多细,每个知识点都会在开发中用上。而像数组、对象,以及文件件处理、图像处理、MySQL数据库的操作、PHP操作数据库等内容,先学一些常用的部分,会一些基本的应用够用就行,这样可以大大提高学习的进度。这个阶段的学习大多数新人都会出现两个常见的问题:第一,可能当天学的内容,下次在学习新内容时,上次学的忘的差不多了,总是记不住。当然,这个大可不必担心,不要停下来,一定要继续往下学习,因为基础的语法都是后面知识中会用到的技术,用多了自然就记住了。而像高级的部分也不用担心记不住,都是类库或函数库,只要记住系统已经提供了哪些功能就好,用时通过手册查询即可,能记住常用的当然好了。第二,就是书上的讲的内容,看能看懂,也都能理解,就是自己一动手时,不知从何下手,没有思路。所以说对这个阶段的知识点有所了解以后,一定要想尽办法做出一个小项目(例如,模拟写个小型商城、论坛,或聊天室等),这个项目不用去管安全、优化及代码质量,只要能实现功能就行。这个项目的目的就是打通你的“任督二脉”,并将基础部分的零散知识点贯穿在一起,在实际项目中去应用实践,能更好的对其理解掌握。

Ø 阶段三加强

有了阶段二的项目开发的练习后,积累了一些开发思路,需要再回过头深度学习每部分知识点,像数组、对象、正则表达式、数据库操作、数据结构和算法等,这些内容是PHP开发中最常用的技术,这个阶段去学习可以学的更全、更透彻,更容易掌握。当然还要学习一些新的内容,像模板引擎和PHP框架,然后再做一个项目。而这个阶段的项目就不能像阶段二时的项目,只是实现基本功能就行了,不仅要求代码质量要好,业务逻辑要清晰,项目的结构也要基于目前最流利的开发模式,使用框架和模板引擎的,并采用面向对象的思想,和MVC模式的设计要求,也要学习项目的开发流程和规范,尽量让这个项目达到真实上线的项目标准。

Ø 阶段四提高

这个阶段则建议在工作中去学习,因为这个阶段的内容没有统一的标准,需要根据实际项目去设计解决方案。当然多搜集和学习一些这方面的理论,或模拟场景做一些有关的实验是很有必要的。综上四个阶段,看似简单,却也需要我们全身心投入,持之以恒才行。

三、坚持动手实验

打过篮球吗?投篮理论可能掌握很快,但要提高命中率,灵活自如可就需要反复练习。学编程也是一样的,能看懂的代码,可不一定能写出来,写不出来可就不是你的!多动手练习是非常有必要的,可能刚接触时,写了几行代码就会出现n个错误,出现的错误就是你没有掌握的技术,解决掉的问题就是你学到的,当错误出现的越来越少时,你的代码编写能力也就越来越熟练。当然,为了能更快的解决代码错误,初期可以写几行代码就运行一下,这样方便定位查找Bug位置。另外,写代码可是最好的对理论进行实践的方法,你认为比较迷茫的技术,都可以通过实验解释通过。还有,在练习时一定要边练习边为代码加上注释,或记录学习笔记,总结和分析。

本人作为编程过来人,刚学编程时同样没有思路,至少也是照猫画虎画有上万行代码,才慢慢出现思路的。就像刚开始写作文时要有思路,一般也要经过几个阶段,首先学习词汇,然后学习造句,然后大量阅读别人的文章,再自己模仿着写一些,逐渐的经验积累,才能形成自己的思路。学编程,恐怕也得慢慢的来吧,只是看一看、听一听,不动手是不足以学好编程的。多动手跟着书上例子或配套的教学视频开始练习,当然最好加一些自己的功能,按自己的思路敲上一些代码,收获会大的多。量变会引起质变的,而这种质变的确发生过不少次。提醒一句,要理解代码思路之后再跟着敲,背着敲,千万不要左边摆着别人的程序,右边自己一个一个子母的照着写,这就不再是程序员了,而成打字员了。纸上得来终觉浅,别问那么多,别想那么多,动手写吧。

四、要事为先的原则

盖房子,要先建骨架,再谈修饰。画山水,要先画结构,再谈润色。认识一台结构复杂的机器,应该首先认清楚脉络,然后再逐步认识每一个关节。为了应付从小学到大学的考试,我们背了各种各样的不应该提前掌握的细节,同时也养成了见到细节就死抠的学习习惯。而现在学PHP,是到改改的时候了。“抓大放小,要事为先”这是对待繁琐事务的态度。对于以前从来没有接触过PHP的新人,PHP无疑是庞大的,似乎每个领域都可以拓展开来,都是一片开阔地,要是深入接触到每一个细节所耗费的精力无疑是巨大的。多数新手都胸怀壮志,两眼发光的盯着每一个崭新的知识点,遇见的任何一个知识点都恨不得抠的清清楚楚,明明白白。难道这有什么不对吗?我的意见是,没什么大毛病,但是学习效率太低了!任何事情都要追求完美才敢继续往后进行,是一种性格缺陷。大胆的放弃一些东西吧,有失才有得,把自己有限的、宝贵的精力用在重要知识点直接相关的地方,这才是最有效率的学习方式!等全部要点拿下以后,有时间有精力闲的没事儿干的时候,再去研究那些边边角角的技术吧。一切和我们的直接工作目标关联不大的东西,扔在一边或者弄清楚到足够支持下一步的学习就可以了。把时间和精力花在开发项目上面,花在写作品以及锻炼解决问题的能力上面,这是迈向高手的正确的而且快速的方向。

当你看书到某个地方暂时不理解的时候,暂时放手吧,追求一些行云流水、自然而然的境界吧,只是不要停下前进的脚步,不要被大路旁边的支根末节干扰了你前进的行程,项目,真实的项目,这才是目的。以项目驱动自己的学习,当把握了技术的脉络之后再去补充细节的研究,是学习PHP的正确途径。

五、Bug解决之道

不管是新手学习,还是成手程序员,写程序就不可能不遇到Bug。那么,自学时遇到Bug之后,环境配不通,程序调不出来,运行不正常,遇见这些恼人的问题的时候,该怎么办呢?首先我要恭喜你,遇见问题,意味着你又有涨经验的机会了,每解决一个问题,你的PHP经验值就应该上升几百点,问题遇到的越多,知识提升的就越快。

但是总是解决不了Bug也是很恼人的,怎么办呢?本人的建议是当你遇到一个问题的时候:首先要仔细的观察错误的现象,是的,要仔细。有不少新人的手非常快,访问页面报了一大堆的错误,扫了一眼之后就开始盯着代码一行一行的找,看清什么错误了吗?没有!还有出现Bug马上网上求救,自己都没看一下,这都是典型的不上心的方法!请记住,学习编程并不是一件很容易的事情,自己首先要重视,要用心才可以。别人帮给你解决的问题可不是你的提高,最少也要自己试着解决一会,真的没有思路了,可就别浪费时间了,再花多少时间也解决不了,这个时候就该想想别的办法了。在开发中,仔细观察出错信息,或者运行不正常的信息,是你要做的第一件事。如果错误信息读懂了,就要仔细思考问题会出在哪个环节了;如果没读懂,又要怎么办呢?读了个半懂,有些眉目但是不太能确定,也要如何处理呢?

Ø 要仔细思考问题会出在哪些环节

一辆汽车从生产线上下来,车门关不上,哪出问题了,你怎么查?当然是顺着生产线一站一站的查下来。程序也是一样的,也是一系列语句完成后产生的结果。当你读懂了一个问题之后,要好好的思考这个问题可能会在哪些环节上出错。例如,客户端产生数据->按“提交”按钮->发送到服务器->服务器接收到后保存到数据库。这几个环节都有可能会出错:有可能客户端根本就没产生数据,有可能提交按钮按下去后根本就没发出去,或者发出去的不是你产生的东西,或者根本就没连接网络,或者发送出去服务器没有接收到,或者接收到没存到数据库等。学着去这样仔细的分析程序的环节和这些环节可能会产生的问题,你的经验值自然会大幅度快速的提升。这样做很累,但是一件事情如果做下来一点都不累的话,这个东西还有价值吗?在网页A输入了一个人的名字,提交到B,首先存储到数据库,然后再读出来,发现乱码!怎么办?当然是分析环节:客户输入->HTTP发送->B接收->存储到数据库->读出->展现到网页。每个环节都可能出问题,怎么才能知道哪里出的问题?继续往下读。

Ø 如何定位错误

写代码时常见的Bug其实就两大类:一类是语法错误,例如没写结束的分号,访问时页面中就会提示哪里出错,打印出错误报告,只要认真读完错误报告,这样的问题很容易找到,也很好解决。另一类是编写的逻辑错误,这是因为设计缺陷或是开发思路混乱造成的,要定位这样的错误会麻烦一些,分析清楚有哪些环节之后,通常有三种方法找到错误位置:第一种是输出调试法,通过在多个可疑的位置打印输出不同的字符串,通过观察输出的结果,并结合输出信息的位置周围的代码来确认错误位置。第二种是注释调试法,先将所有代码注释掉,再从上到下一点点去掉注释,去一次运行一下观察运行结果,有不正常的结果出现也就定位到了错误的位置。第三种是删除调试法,先将代码备份,然后删掉一部分调试一部分,也就是去掉一部分的功能,做简化,然后调试剩下的功能。如果还查不出来,恭喜你,你遇到的错误是值得认真对待的错误,是会影响你学习生涯的错误,就使用搜索引擎吧。也可以在专业的BBS中详细列出问题。但向别人提问是非常需要技巧的!曾经有人问我这样的问题:“请问如何才能学好PHP呢?”这个要求太泛泛了。还有人给我一段长长的代码甚至项目压缩包发过来,然后说有个错误您帮我查查?还有人问这样的问题,是否有人能帮我完成一个完整聊天的程序?请帮我写一个登陆模块吧?这样的要求有些过分了,有人帮你是你的运气,没有人帮你是正常反应。向别人提问,首先应该确定你已经做了自己应该做的事,不要没有经过认真思考就草率的向别人提问,自己也不会有太多进步的。

六、看教学视频,让学习变的简单

跟教学视频学习可是最好的学习方式了,即有详细的理论讲解又有代码分析,看书和配套视频结合学习可以达到最佳的效果。目前,网上可以免费学习的技术视频越来越多,像兄弟连云课堂(yun.itxdl.cn),不仅视频种类多,视频新,讲解全面详细,而且又会根据企业实际的技术应用,不断更新,不仅可以记录学习笔记,还有专业老师在线指导答疑,也可以和同学互动。找到比较适合你的全套视频,保存在自己硬盘里就是你的了,不对!一定要有计划的学习才可以,你可以给自己定一个目标,每天看几集,每周完成哪些部分,一个月学到哪里,并不断坚持。不然,今天学点,一个月后再学点,这样不会有进展。跟着视频学习,重点内容最好过三遍,第一遍了解大概,第二遍边听边记笔记,第三遍跟着视频中的演示,自己练习代码。

七、优秀的Web程序员是怎样练成的

学习软件开发“思维逻辑”是核心,“记忆”只是辅助。每个行业都有新手和成手之分,软件开发也是一样,也可分为普通程序员和高级软件工程师等不同级别的职位。通常刚工作的普通程序员都是在维持生活的阶段,只有成为高手才能做出突出的成绩。当然从初级程序员成长为高手并不是一步到位的,而需要通过不间段的努力逐渐成长起来。例如,在工作中不断积累经验,掌握复杂网站的架构设计,并具有解决问题的能力,还要多研发产品,并能挑战高难度的项目。除了要有强烈的好奇心和学习精神以外,本人还总结以下几点提供给刚入行的新手参考。

1. 克服惯性

万事开头难,克服惯性是学习新技术的第一步。举个日常生活中惯性存在的简单例子,当我们看电视的时候会因为遥控器不在身边而懒得换台。幸运的是有很多的小技巧可以调动我们的积极性,帮助我们克服惯性。对于我来说,微习惯是一个很好用的小技巧。与其被手头的任务吓到,不如将任务细分为一个个具体的微任务,然后挑选其中的一个开始做起。就“拿到遥控器”这个例子来说,首先扭动你的手指,向前伸出,然后推动整个人离开沙发。下一步,身体滑到地上,用脚拿到遥控器,然后起身。通过完成一个个的微任务,你会发现自己克服了惯性,并且这项任务不再显得难以完成。这个方法可以被应用到学习新技能的过程中。关键就是将大块任务细分为微任务。

2.具备扎实的技术功底

PHP是众多计算机开发语言中最容易入门并上手最快的,人人都会写。但如果不了解数据结构、离散数学、编译原理、计算机网络、结合多种语言的编程特点等这些计算机科学的基础,很难写出高水准的程序。当你发现写到一定程度很难再提高的时候,就应该想想是不是要回过头来学学这些最基本的理论。因此多读一些计算机基础理论方面的书籍是非常有必要的。

3.遵循良好的编码规范

高质量的代码都具有统一的编码规范,要养成良好的编码习惯,代码的缩排编排、变量的命名规则要始终保持一致。因为在一致的环境下,团队协作中有更高的效率,团队的成员可以减少犯错的机会。另外程序员可以方便地了解其他人的代码,弄清程序的状况,就和看自己的代码一样。另外,也可以防止接触PHP的新人自创一套风格并养成终生的习惯,一次次地犯同样的错误。

4.问题要解决不要逃避

学习过程中遇到比较难理解的重要章节不要跳过,更不能放弃,要多花一些时间和精力在这些知识点上,将其攻破,这样才能不断地提高,否则在开发时会一直是你的障碍。在开发过程中如果遇到障碍,不妨暂时远离计算机,看看窗外的风景,听听轻音乐,再重新开始工作的时候,有可能会发现一些难题竟然可以迎刃而解。解决过的问题再次遇到时将不再是你的障碍。

5.扩充自己的想象力

程序员不要局限于固定的思考方式,遇到问题时要多想几种解决问题的方案,可以试试别人从没想过的方法。丰富的想像力建立在丰富的知识的基础上,除计算机之外,多涉及其他的学科,比如天文、物理、数学等。开阔的思考和了解各种业务流对Web程序员来说是很重要的。

6.对新技术的渴求

我们可以越来越方便廉价地获得大量学习资源。这些资源的传播载体由最初的教室被变成了博客,技术论坛等。坐拥如此众多的学习资源,我们没有任何理由不去好好利用。人类自然科学的发展史就是一个渴求得到答案的程序,即使只能知道答案的一小部分,也值得我们去付出。只要你坚定信念,一定要找到问题的答案,你才会付出精力去探索,即使最后没有得到答案,在程序中也会学到很多东西。

7.挖掘设计模式,提高代码质量

动手将一个新的模块开发出来以后,不要认为自己写的代码就是完美的,也不要草率地将别人的代码拿过来就直接使用,更不要在开发中多次遇到相同功能,将同一段代码直接粘贴反复使用。提高自己的编码能力一定要多参考和总结别人的设计模式,还要不断地改进和升级才能提高自己编写代码的质量,也能从中学到新的技术。

8.多与高手交流

尽量多认识一些大互联网公司的程序高手,多了解一些大型网站的解决方案,也许在一次和别人不经意的谈话中,就可以蹦出灵感。也要多上上网,看看别人对同一问题的看法,会给你很大的启发。也要经常参加一些互联网技术大会,了解一些新技术和行业的发展,拓展自己的眼界。它可以是任何你有激情去学,并且想深入学习的一些东西。这种原始的学习欲望非常重要,这种欲望可以在你的学习低潮期给你提供动力。你想学的或许是一门新的编程语言、应用框架或者是新的工具,一旦你确定了想要的是什么,就立刻去收集相应的优秀群体所做的一些优质的工作成果。

9.韧性和毅力

程序高手们并不是什么天才,而是在无数个日日夜夜中磨炼出来的,成功能给我们带来无比的喜悦,但程序却是无比的枯燥乏味。做程序员,停滞不前就是落后,要不断地学习扩展新知识,就像软件版本升级一样,也要不断地更新自己的技术。

10. 写博客

在你进行你的探险之旅的时候,实时记录下你的成长以及犯下的错误大有裨益。在技术领域,博客是最简单易得并且受欢迎的表达载体。当你准备落笔的时候,你会强迫自己整理思路,并且对积累下来的零散的知识片段进行结构梳理。说不定,通过互联网的分享,你的经历和分享会给别人的成长带来帮助。写博客能够提升你的个人沟通能力,这与你学到的技术同样重要。给别人讲解是最好的一种提高的学习方法。

11.考虑接单

许多年轻有才华的程序员正不断的寻找新的项目和解决不同的问题,以此来增加经验。然而,很少有一个单一的环境能够提供这样的条件。如果基于遗留系统代码(维护原有系统),架构方面没有多大的想象空间。因此,许多程序员觉得需要变换工作,到不同的环境去获取新一阶段的学习。然而,“跳槽“只不过是获取丰富经验的途径之一,我仍提议另一个选择:接单。




展开阅读全文

没有更多推荐了,返回首页