Php入门教程之PHP 变量基本语法

变量是php中非常常用的一个东西，所有的操作都要经过变量来传递，下面我来给各位同学介绍在php中变量的一些常用用法与关于php变量基础知识。

具体方法

PHP 变量

PHP变量用于存储字符、数字、数组甚至对象内容等，以便在我们需要的地方使用。

定义一个变量的语法：

$变量名 = 值;

使用变量的例子：

 

代码如下	复制代码
<?php   $var_char = "你好！";   echo $var_char;   ?>

执行这段代码输出的结果是：

1 你好！
从这个例子可以看出，变量名以 $ 开始，标明这是一个变量。变量名以字母（a-z、A-Z）或者下划线 _ 开始，后面可以跟任意字母或数字以及下划线，但不能是空格。

如下这些变量名是有效的：

 $var_char

 $varChar

 $_varChar

 $var_char5

提示

关于变量命名，我们建议变量名以标明其实际语意的组合为佳，如 $my_name 或 $myName 格式。

全局变量global

全局变量便是其中之一,当然这个观点颇具争议,有许多人还是建议禁用全局变量,使用不当对造成程序的可读性很差!结构混乱,调试更是一头雾水,但是不可否认他的便捷,这便是php为什么会用全局变量global原因吧!…

今天就遇到了php 全局变量不起作用的问题.

先上一段简单的代码:

代码如下	复制代码
<?php $a = 0 ; function Test() {     $a =1; } Test(); echo $a; ?>

上面的代码中输出是0,那是因为函数体Test内$a变量被缺省设置为局部变量,$a的作用域就是在Test内.修改代码如下

代码如下	复制代码
<?php $a = 0 ; function Test() {    global $a;//申明函数体Test内使用的$a变量为global全局变量    $a =1; } Test(); echo $a; ?>

申明函数体Test内使用的$a变量为global全局变量后,使得$a的作用全局,所以输出为1.
上面的实例只是基本的global全局变量知识,下面我们看看复杂点的:

代码如下	复制代码
//A.php 文件 <?php function Test_Global() {     include 'B.php';     Test(); } $a = 0 ; Test_Global(); echo $a; ?> //B.php 文件 <?php function Test() {    global $a;//申明函数体Sum内使用的$a变量为global全局变量    $a =1; } ?>

为什么输出的却是0?!!

在用户自定义函数中，一个局部函数范围将被引入。任何用于函数内部的变量按缺省情况将被限制在局部函数范围内(包括include 和 require 导入的文件内的变量)!
解释:A.php文件的内Test_Global是定义好的第三方函数,该函数用include导入了B.php文件内的$a的global全局变量,所以$a被限制在Test_Global局部函数范围内,所以B.php文件内的$a的作用范围都在Test_Global内,而不是作用了整个A.php内….

解决方案:

1. 冲出局部函数//A.php 文件

代码如下	复制代码
<?php function Test_Global() {     Test(); } include 'B.php'; //将include 从局部Test_Global函数中移出 $a = 0 ; Test_Global(); echo $a; ?> //B.php 文件 <?php function Test() {     global $a;     $a =1; } ?>

2.优秀的访问器

代码如下	复制代码
//A.php 文件 <?php include 'B.php'; $a =0; Set_Global($a); echo $a; ?> //B.php 文件 <?php function Set_Global(&$var) {     $var=1; } ?>

php变量 引用函数 static变量

“无论怎样声明变量（按值或按引用），总之在PHP脚本的任何位置都可以声明变量。但是，声明的位置会大大影响访问变量的范围。这个可访问的范围称为作用域(scope)” –PHP与MySQL程序设计
在了解php变量之前，我们先看看段式内存管理架构的内存段的划分。通常操作系统会将物理内存划分为以下几个逻辑段。

Text-Segment,这个段最大的特点就是只读。一般存放可执行代码，也有可能常量也存放在这里，比如字符串常量
BSS-Segment,这里存放了那些没有初始化的变量。某种意义来讲，没有初始化的变量都是垃圾，不可用
Data-Segment,这里存放了全局变量和静态变量，直到脚本运行结束，操作系统才会回收这里的内存空间，变量亦会被销毁。
Stack-Heap Segment 函数参数与本地变量(也称局部变量)存放在堆中(stack)，还有返回值等等。用完了，操作系统就会回收这部分内存空间。对于C程序员而言，可以自行从栈中(heap)申请内存空间，用完了，也需要自己手动释放。
作为PHP程序言而言，我们关心的是全局变量、静态变量、局部变量、函数参数以及函数返回值。局部变量和函数参数基本上一样，在初始化的时候分配内存空间，退出函数后操作系统会回收内存空间。而全局变量与静态变量要直php脚本运行结束后，内存空间才会被释放。与全局变量不同的时，所有静态变量在程序执行之前就初始化并且分配了内存空间。

注:
1.函数外部声明静态变量意义不大，函数内部声明静态变量受限于作用域，函数外部不能修改函数内部静态变量。
2.引用变量，也是变量，只不过它的值是变量的内存地址。

php保留字 global和static

代码如下	复制代码
<?php $i = $j = 8; function global_var() {    global $j, $b;    $c = $j = $b = $i = 4; } global_var(); echo "i:$i, j:$j b:$b c:$c n"; //i:8, j:4 b:4 c: ?>

函数外和内都有变量$i，但是他们二个是完全不同的变量。函数外的$i是全局变量，该内存空间直到脚本运行结束后才会被释放。函数内的$i是局部变量，程序流经过函数的时候，初始化，退出函数的时候，内存被系统回收，再次调用函数，则再次分配内存空间和回收内存空间。二次分配的内存空间有可能是同一内存地址，也有可能不能同一内存地址。
与$i不同的是$j，通过关键字global将局部变量”转为”全局变量。当调用函数global_var()的时候，并不会重新给$j分配内存空间。同样的，可以在函数外打印$b，却不能打印$c是因为$b是全局变量，不会被销毁。而$c则不能打印，$c已经不存在了，在退出函数就给销毁了。

代码如下	复制代码
<?php $a = 2; static $b = 2; static $c = 3; function global_var() {     static $i, $c;     global $j, $a;     $c = $a = $b = $i = $j = 4; } global_var(); echo "a:$a b:$b c:$c i:$i j:$j"; //a:4 b:2 c:3 i: j:4 ?>

首先，我们看函数外的$b和$c，即是全局变量又是static变量。这里static修饰没有太大的意义，因为他们都存放在数据段(data-segment)，直到脚本运行完了之后才会被回收。然后，我们再看函数里面的$i和$c，函数调用后，$i和$c其实都没有被回收，但是$i输出是NULL和$c输出是3，这是因为他们的作用域是函数内部，不是函数外部，也就是说$i和$c在函数外是不可见的。函数内static变量的意义就在于此：仅函数内部可见且不会被销毁。也就是说，保证函退出函数，变量也不会被回收，但又不会被其它函数修改。(注：函数外和函数内的$c是二个不同的变量)

代码如下	复制代码
<?php function global_var() {    static $i;    ++$j;    ++$i;    echo "j:$j i:$i n"; } global_var(); //j:1 i:1  global_var();  //j:1 i:2 global_var();  //j:1 i:3 ?>

上例中,变量$j一直都是1，而$i每调用一次就累加1。这是因为，局部变量存放在堆段,每次退出函数时都会被回收。而$i存放在存放在数据段(data-segment)，直到程序执行完毕才会被回收。我们平常说的static变量，如果没有特别指明，都说的是函数内部的static变量。

引用函数与static变量
既然static变量要直到脚本执行结束，才会被销毁。那么，有没有办法访问该变量的值呢？我们来看看下面的示例:

代码如下

复制代码

<?php get_local_static_var(); $ptr = &get_local_static_var(); get_local_static_var(); ++$ptr; get_local_static_var(); what_i($ptr); get_local_static_var();  //?? what_p($ptr); get_local_static_var();  //??   function &get_local_static_var() {     static $i;     ++$i;     echo "i:$i n";     return $i; }   function what_i($ptr) {    $i = &get_local_static_var();    ++$i;    ++$ptr; }   function what_p(&$ptr) {    $i = &get_local_static_var();    ++$i;    ++$ptr; } ?>

二个凝问号处，分别输出是8和12。这就说明了只要变量没有被销毁，还是可以被访问。我们可以通过引用函数将static变量的地址返回其它函数。其它函数则可通过static变量的地址访问并且修改它的值。
上例第一处??，为什么是8，而不是9。这是因为what_i($ptr)函数，要求参数是按值传递，即此处的$ptr实参值是5，且参数$ptr和全局变量$ptr是二个不同的变量。第二处??的值是12，为什么不是11的道理亦是如此。what_p(&$ptr)函数，要求参数是按引用传递，即此处的$ptr是指向static变量$i的地址，需要注意的是参数$ptr和全局变量$ptr也是二个不同的变量，只不过他们都指向同一个地方。

drupal应用赏析
drupal定义了一个drupal_static函数，其它函数的static变量都存放在一个数组中，然后对drupal应用到的所有static进行统一管理，比如赋值，重置，删除等。我觉得，这是一个好办法。

代码如下

复制代码

<? function &drupal_static($name, $default_value = NULL, $reset = FALSE) {   static $data = array(), $default = array();   if (!isset($name)) {     foreach ($default as $name => $value) {       $data[$name] = $value;     }     return $data;   }   if ($reset) {     if (array_key_exists($name, $default)) {       $data[$name] = $default[$name];     }     else {       return $data;     }   }   elseif (!array_key_exists($name, $data)) {     $default[$name] = $data[$name] = $default_value;   }   return $data[$name]; }   function ip_address() {   $ip_address = &drupal_static(__FUNCTION__);     if (!isset($ip_address)) {     $ip_address = $_SERVER['REMOTE_ADDR'];       if (variable_get('reverse_proxy', 0)) {       if (array_key_exists('HTTP_X_FORWARDED_FOR', $_SERVER)) {         $reverse_proxy_addresses = variable_get('reverse_proxy_addresses', array());         if (!empty($reverse_proxy_addresses) &&      in_array($ip_address, $reverse_proxy_addresses, TRUE)     ) {           $ip_address_parts = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);           $ip_address = trim(array_pop($ip_address_parts));         }       }       if (array_key_exists('HTTP_X_CLUSTER_CLIENT_IP', $_SERVER)) {         $ip_address = $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'];       }     }   }     return $ip_address; }   ip_address(); //在drupal中很多这样的应用方式,将其它函数的static变量都存放到一个地方,即drupal_static的data中，然后再统一管理，比如重置等等。 ?>

在php中变量有很多种如普通的变量及全局变量（Global与$GLOBALS），本文章来给大家介绍在php中Global与$GLOBALS的用法区别。

Global,全局变量

  PHP Global变量在实际应用中会发现许多问题需要我们不断的去完善处理。我们在这篇文章中就针对PHP Global变量出现的问题给出了一些具体的解决办法。

PHP hack的使用技巧详解
代码实现PHP GTK写文本查看器
网站开发中PHP语言优缺点
如何正确实现PHP function函数扩展
PHP error_log()函数处理错误日志

1：PHP Global变量的作用是定义全局变量,但是这个全局变量不是应用于整个网站,而是应用于当前页面,包括include或require的所有文件

代码如下	复制代码
$a=123;   function aa() { Global $a;  //如果不把$a定义为global变量 ,函数体内是不能访问$a的 echo $a; } aa(); 总结:

在函数体内定义的PHP Global变量,函数体外可以使用,在函数体外定义的global变量不能在函数体内使用,

 

代码如下	复制代码
$glpbal $a;  $a=123;   function f()  {  echo $a; //错误,  }

再看看下面一例

代码如下	复制代码
function f()  {  global $a;  $a=123;  }   f();  echo $a;

//正确,可以使用

2：PHP Global变量问题解析：

question：我在config.inc.php中定义了一些变量（$a），在别的文件中函数外部 include("config.inc.php")，函数内部需要使用这些变量$a，如果没有声明的话，echo $a是打印不出来任何东西的。因此声明global $a，但是有很多函数和很多变量，总不能不断重复的这样声明吧？有什么好的解决办法，请指点。

answer1：先在config.inc.php里定义常量：define(常量名,常量值)，再在其他需要用到的地方require 'config.inc.php'，然后就能在这个文件里直接使用这个常量了。

answer2：我也有个办法，就是定义数组，如$x[a]，$x，那样就只要声明global $x一个了。

answer3：我试了你的这个方法，不行啊。

answer4：改你的php.ini文件。

设置PHP Global变量 为 on

,下面我们看看复杂点的:

代码如下	复制代码
//A.php 文件 <?php function Test_Global() {     include 'B.php';     Test(); } $a = 0 ; Test_Global(); echo $a; ?> //B.php 文件 <?php function Test() {    global $a;//申明函数体Sum内使用的$a变量为global全局变量    $a =1; } ?>

为什么输出的却是0?!!

在用户自定义函数中，一个局部函数范围将被引入。任何用于函数内部的变量按缺省情况将被限制在局部函数范围内(包括include 和 require 导入的文件内的变量)!
解释:A.php文件的内Test_Global是定义好的第三方函数,该函数用include导入了B.php文件内的$a的global全局变量,所以$a被限制在Test_Global局部函数范围内,所以B.php文件内的$a的作用范围都在Test_Global内,而不是作用了整个A.php内….

解决方案:
1. 冲出局部函数

代码如下	复制代码
//A.php 文件 <?php function Test_Global() {     Test(); } include 'B.php'; //将include 从局部Test_Global函数中移出 $a = 0 ; Test_Global(); echo $a; ?> //B.php 文件 <?php function Test() {     global $a;     $a =1; } ?>

global和$GLOBALS的区别

php中global和$GLOBALS不仅仅是写法不一样以为,2者的区别还是很大的,在实际应用中需要注意!

先看下面的例子:

PHP代码

 

代码如下	复制代码
<?php  // 例子1  function test_global() {    global $var1, $var2;    $var2 =& $var1;  }  function test_globals() {    $GLOBALS['var3'] =& $GLOBALS['var1'];  }  $var1 = 5;  $var2 = $var3 = 0;  test_global();  print $var2 .”n”;  test_globals();  print $var3 .”n”;  ?>

执行结果为:

0

5

怎么会这样呢?不应该是2个5吗?怎么会出现1个0和1个5呢?

恩,我们保留以上问题,深入分析$GLOBALS和global的原理!

我们都知道变量其实是相应物理内存在代码中的”代号”而已

引用php手册的$GLOBALS的解释:

Global 变量：$GLOBALS,注意: $GLOBALS 在 PHP 3.0.0 及以后版本中适用。

由所有已定义全局变量组成的数组。变量名就是该数组的索引。这是一个“superglobal”，或者可以描述为自动全局变量。

也就是说上面代码中的$var1和$GLOBALS['var1']是指的同一变量，而不是2个不同的变量！

下面来分析global到底做了什么？

引用php手册的global的解释:

如果在一个函数内部给一个声明为 global 的变量赋于一个引用，该引用只在函数内部可见。可以通过使用 $GLOBALS 数组避免这一点。

我们都知道php中的函数所产生的变量都是函数的私有变量，那么global关键字产生的变量也肯定逃不出这个规则，为什么这么说呢，看下面的代码：

PHP代码

 

代码如下	复制代码
<?php  // 例子2  function test() {    global $a;    unset($a);  }  $a = 1;  test();  print $a;  ?>

执行结果为：

1

为什么会输出1呢？不是已经把$a给unset了吗？unset失灵了？php的bug？

都不是，其实unset起作用了，是把test函数中的$a给unset掉了，可以在函数test()中加入

print $a;

来测试！

接着回到上面的例子1，看test_global中的这一代码“$var2 =& $var1;”，上面是一个引用赋值运算，也就是$var2将指向var1所指向的物理内存地址，所以例子1执行过test_global函数以后，变量的变化只在函数的局部产生效应,在函数外部$var2的指向物理内存地址并没有变化,还是它自己.

此时，就能理解为什么例子1执行完以后，$var2是0，而$var3是5了！

所以我们得出一个结论，在函数中global和$GLOBALS[]的区别在于：

global在函数产生一个指向函数外部变量的别名变量，而不是真正的函数外部变量，一但改变了别名变量的指向地址，就会发生一些意料不到情况，例如例子 1.

$GLOBALS[]确确实实调用是外部的变量，函数内外会始终保持一致

可以对照 下面两个列子再加深下印象：

global：

代码如下	复制代码
<?php function myfunction(){     global $bar;     unset($bar); } $bar=”someting”; myfunction(); echo $bar; ?> 输出：someting $GLOBALS[]: <?php     function foo() {     unset($GLOBALS['bar']); } $bar = “something”; foo(); echo $bar; ?>

输出：空

当按照上面的思路理解后,碰到下面的情况是不是又有些晕呢?

代码如下	复制代码
<?php $a = 1; $b = 2; function Sum() {    global $a, $b;    $b = $a + $b; } Sum(); echo $b; ?>

输出将是 “3″。在函数中申明 了全局变量 $a 和 $b，任何变量的所有引用变量都会指向到全局变量。

怎么不是2呢,在函数外部不是不影响吗,请注意$b在函数中并没有通过引用修改,而是修改的$b指向物理内存的值,因此外部输入为3。

php中global和$GLOBALS不仅仅是写法不一样以为,2者的区别还是很大的,在实际应用中需要注意!

先看下面的例子:

PHP代码

 

代码如下	复制代码
<?php   // 例子1   function test_global() {     global $var1, $var2;     $var2 =& $var1;   }   function test_globals() {     $GLOBALS['var3'] =& $GLOBALS['var1'];   }   $var1 = 5;   $var2 = $var3 = 0;   test_global();   print $var2 .”n”;   test_globals();   print $var3 .”n”;   ?>

执行结果为:

0

5

怎么会这样呢?不应该是2个5吗?怎么会出现1个0和1个5呢?

恩,我们保留以上问题,深入分析$GLOBALS和global的原理!

我们都知道变量其实是相应物理内存在代码中的“代号“而已

引用php手册的$GLOBALS的解释:

Global 变量：$GLOBALS,注意: $GLOBALS 在 PHP 3.0.0 及以后版本中适用。

由所有已定义全局变量组成的数组。变量名就是该数组的索引。这是一个“superglobal”，或者可以描述为自动全局变量。

也就是说上面代码中的$var1和$GLOBALS['var1']是指的同一变量，而不是2个不同的变量！

 

下面来分析global到底做了什么？

引用php手册的global的解释:

如果在一个函数内部给一个声明为 global 的变量赋于一个引用，该引用只在函数内部可见。可以通过使用 $GLOBALS 数组避免这一点。

我们都知道php中的函数所产生的变量都是函数的私有变量，那么global关键字产生的变量也肯定逃不出这个规则，为什么这么说呢，看下面的代码：

PHP代码

代码如下	复制代码
<?php   // 例子2   function test() {     global $a;     unset($a);   }      $a = 1;   test();   print $a;   ?>

执行结果为：

1

为什么会输出1呢？不是已经把$a给unset了吗？unset失灵了？php的bug？

都不是，其实unset起作用了，是把test函数中的$a给unset掉了，可以在函数test()中加入

print $a;

来测试！

 

接着回到上面的例子1，看test_global中的这一代码“$var2 =& $var1;”，上面是一个引用赋值运算，也就是$var2将指向var1所指向的物理内存地址，所以例子1执行过test_global函数以后，变量的变化只在函数的局部产生效应,在函数外部$var2的指向物理内存地址并没有变化,还是它自己.

此时，就能理解为什么例子1执行完以后，$var2是0，而$var3是5了！

 

所以我们得出一个结论，在函数中global和$GLOBALS[]的区别在于：

global在函数产生一个指向函数外部变量的别名变量，而不是真正的函数外部变量，一但改变了别名变量的指向地址，就会发生一些意料不到情况，例如例子 1.

 

$GLOBALS[]确确实实调用是外部的变量，函数内外会始终保持一致

可以对照 下面两个列子再加深下印象：

global：

代码如下	复制代码
<?php function myfunction(){     global $bar;     unset($bar); } $bar=”someting”; myfunction(); echo $bar; ?>

输出：someting

 

代码如下	复制代码
$GLOBALS[]: <?php     function foo() {     unset($GLOBALS['bar']); } $bar = “something”; foo(); echo $bar; ?>

输出：空

 

当按照上面的思路理解后,碰到下面的情况是不是又有些晕呢?

代码如下	复制代码
<?php $a = 1; $b = 2; function Sum() {    global $a, $b;    $b = $a + $b; } Sum(); echo $b; ?>

输出将是 “3″。在函数中申明 了全局变量 $a 和 $b，任何变量的所有引用变量都会指向到全局变量。

怎么不是2呢,在函数外部不是不影响吗,请注意$b在函数中并没有通过引用修改,而是修改的$b指向物理内存的值,因此外部输入为3。

常量在php中是一个非常重新的数据类型了，下面我来给初学者详细介绍PHP常量一些用法，有需要了解的同学可进入参考。

PHP 常量
define() 函数用于定义常量。一个常量一旦被定义，就不能再改变或者取消定义。

定义常量的例子：

代码如下	复制代码
<?php define("CONSTANT", "你好！"); echo CONSTANT; ?>

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

常量默认为大小写敏感，按照惯例常量标识符总是大写的，在脚本执行期间该值不能改变。

定义常量和定义变量的区别：

1.常量前面没有美元符号（$）
2.常量只能用 define() 函数定义，而不能通过赋值语句
3.常量可以不用理会变量范围的规则而在任何地方定义和访问
4.常量一旦定义就不能被重新定义或者取消定义
5.常量的值只能是标量
PHP内置了大量预定义常量，具体的可以在网上搜PHP手册里面有具体的内容。

判断一个常量是否已经定义

如何判断一个php常量是否已经定义过了，突然之间还有点迷茫，晕，特意查了下手册，备案本次总结结果如下：

（1）判断常量是否存在

代码如下	复制代码
if(defined('MYCONSTANT')){      echo MYCONSTANT;    }

（2）判断变量是否定义

代码如下	复制代码
if(isset($myvar)){      echo "存在变量$myvar.";   3 }

（3）判断函数是否存在

代码如下	复制代码
if(function_exists('imap_open')){  echo "存在函数imag_open"; }else{  echo "函数imag_open不存在"; }

常量和变量相比,不同点:

1:常量是全局有效的, 因此在页面内,函数内,类内部甚至数组内部都可以直接引用.
 

代码如下	复制代码
$a=66;     function t(){ echo $a; }     t();//此时不能打印出来99，因为函数作用域影响，如果要打印出99，可以改为：     define(“A”,66);     function t(){ echo A; }     t();

2:常量一旦定义,就不可以重新定义,不可以清除.也不可以修改;

常量也可以动态的哦

 

代码如下	复制代码
define("A","常量介绍");   define("B","常量动态调用");   $c=$_get['c'];//此处直接把b的值,并不会再b的值当成常量名再次解析   echo constant($c);// constant(常量名)  ---> 返回常量的值

面向对象之const常量修饰符

中常用的常量修饰符const。

我们知道，在PHP中定义常量是通过define()函数来完成的，但在类中定义常量不能使用define(),而需要使用const修饰符。类中的常量使用const定义后，其访问方式和静态成员类似，都是通过类名或在成员方法中使用self访问,但在PHP 5.3.0之后也可以使用对象来访问。被const定义的常量不能重新赋值，如果在程序中试图改变它的值将会出现错误

代码如下

复制代码

<?php      class MyClass {            const CONSTANT = 'CONSTANT value' ; //使用const声明一个常量，并直接赋上初使值              function showConstant() {                                    echo  self ::CONSTANT ."<br>" ;//使用self访问常量，注意常量前不要加“$”               }        }        echo MyClass:: CONSTANT . "<br>" ; //在类外部使用类名称访问常量，也不要加”$”        $class = new MyClass();                            $class->showConstant();                              echo $class ::CONSTANT;  // PHP 5.3.0之后   ?>

关注细节：使用const定义的常量名称前不需要使用“$“符号，且常量名称通常都是大写的。

试图为const定义的常量赋值，将会出现错误。

代码如下

复制代码

<?php       class MyClass {            const CONSTANT = 'CONSTANT value' ;                 function setCONSTANT(){                 self ::CONSTANT  = 'news CONSTANT' ;//程序运行结果将会出错。        }                                                                                                                                                                                                  }       echo MyClass:: CONSTANT ;                                                                                                                                                                                         ?>

CONSTANTS and PHP Class Definitions

Using "define('MY_VAR', 'default value')" INSIDE a class definition does not work. You have to use the PHP keyword 'const' and initialize it with a scalar value -- boolean, int, float, or string (no array or other object types) -- right away.

不能在类里面使用"define('MY_VAR', 'default value')"来定义常量，你必须使用PHP的关键字 'const'去初始化一个标量--boolean, int, float, or string (除了数组和其他对象类型)、

代码如下

复制代码

<?php define('MIN_VALUE', '0.0');   // RIGHT - Works OUTSIDE of a class definition. define('MAX_VALUE', '1.0');   // RIGHT - Works OUTSIDE of a class definition. //const MIN_VALUE = 0.0;         WRONG - Works INSIDE of a class definition. //const MAX_VALUE = 1.0;         WRONG - Works INSIDE of a class definition. class Constants {   //define('MIN_VALUE', '0.0');  WRONG - Works OUTSIDE of a class definition.   //define('MAX_VALUE', '1.0');  WRONG - Works OUTSIDE of a class definition.   const MIN_VALUE = 0.0;      // RIGHT - Works INSIDE of a class definition.   const MAX_VALUE = 1.0;      // RIGHT - Works INSIDE of a class definition.   public static function getMinValue()   {     return self::MIN_VALUE;   }   public static function getMaxValue()   {     return self::MAX_VALUE;   } } ?>

#Example 1:
You can access these constants DIRECTLY like so:
 * type the class name exactly.
 * type two (2) colons.
 * type the const name exactly.

#Example 2:
Because our class definition provides two (2) static functions, you can also access them like so:
 * type the class name exactly.
 * type two (2) colons.
 * type the function name exactly (with the parentheses).

代码如下	复制代码
<?php #Example 1: $min = Constants::MIN_VALUE; $max = Constants::MAX_VALUE; #Example 2: $min = Constants::getMinValue(); $max = Constants::getMaxValue(); ?>

 

Once class constants are declared AND initialized, they cannot be set to different values -- that is why there are no setMinValue() and setMaxValue() functions in the class definition -- which means they are READ-ONLY and STATIC (shared by all instances of the class).

当类常量被声明和初始化后，他们就不能被设置成其他值--这就是为什么他们在类定义时没有setMinValue()和setMaxValue()这两个方法--这说明他们都是只读而且是静态的（被所有该类的对象共享）。

注释符号和格式我想很多php入门者都只会简单的//或/*之类的，下面我来给各位同学详细介绍在php中注释符号和格式有需要了解的朋友可参考。

PHP 注释符号

■C++ 风格：// 这是 C+ 风格的注释
■C 风格：/* 这是 C 风格的注释 */
■Unix Shell 风格：# 这是 Unix Shell 风格的注释
一般使用是‘//’和‘/* 注释内容 */’，还有在一些系统配置文档中，如我们搭建php环境的时候用到的php.ini里面的注释符号就是 ‘#’ 注释符号。

PHP 注释格式
PHP 注释格式分为单行注释与多行注释。

PHP 单行注释
以上三种符号都可用于单行注释，只是使用 // 或 # 注释符时，注释符号后面的文本（本行内）都被视作注释内容，而 /* */ 风格注释符必须以 */ 结尾。

例子：

代码如下	复制代码
<?php // 这是单行注释 echo '你好!'; // 这是单行注释 /* 注释内容 */ ?>

上面的行尾注释，通常只是对本行前面的内容进行注释，单写一行的注释可能是对下面的一行或多行代码进行注释，也可能是为了程序的整体美观。

PHP 多行注释
多行注释一般使用 C 风格注释符，以 /* 开头，*/ 结尾来包含多行注释内容：

代码如下	复制代码
<?php echo "你好！"; /* 多行注释内容 */ ?>

注意

不要嵌套使用 C 风格注释符，因为在碰到第一个 */ 时系统即认为该段注释结束，在注释掉一大块代码时很容易出现该错误。如下述用法将产生 PHP 语法错误：

代码如下	复制代码
<?php echo '你好！'; /* 这是多行大块注释 echo '输出另一些内容';  /* 添加的本行注释 */ */ ?>

也可以多次使用 // 符号来注释多行代码：

代码如下	复制代码
<?php // 注释说明 // 说明一 // 说明二 echo '注释例子'; } ?>

PHP 注释中不能包含 PHP 代码结束符即：?>，因为PHP在 检测到该结束符，即认为该段 PHP 代码结束而跳出 PHP 的执行这样会导致程序出错。还有一点就是好的php编辑器可以为我们省去很多麻烦。比如：phpdesigner，zend等等。

数据类型在php并不像java中那详细那么多种类型，下面我来给各位同学介绍php 数据类型的一些基础知道，各位同学可参考。

PHP 数据类型
PHP 支持八种原始类型（type）。

四种标量类型：

1.string（字符串）
2.integer（整型）
3.float（浮点型，也作 double ）
4.boolean（布尔型）
两种复合类型：

1.array（数组）
2.object（对象）
两种特殊类型：

1.resource（资源）
2.NULL（空）
查看变量类型
通过 gettype() 函数可以方便的查看某个变量的类型：

<?php
$bool = TRUE;     // 布尔型
$str  = "foo";     // 字符串
$int  = 12;        // 整型

echo gettype($bool);        // 输出 boolean
echo gettype($str);     // 输出 string
echo gettype($int);     // 输出 integer
?>

判断变量类型

如果想通过判断变量类型来可以使用 is_type 函数：

<?php
$var_int  = 12;

// 如果 $var_int 是 int 类型，这进行加法
if (is_int($var_int)) {
    $var_int = $var_int+4;
}
echo $var_int;  // 输出 16
?>

以上基本就是PHP数据类型的基本内容，大家如果想了解具体每个数据类型的用法，可以查阅PHP手册，里面有详细的说明。

数据类型转换

PHP数据类型有三种转换方式：

•在要转换的变量之前加上用括号括起来的目标类型
•使用3个具体类型的转换函数，intval()、floatval()、strval()
•使用通用类型转换函数settype(mixed var,string type)
 第一种转换方式： (int)  (bool)  (float)  (string)  (array) (object)
 
•<?php  
•$num1=3.14;   
•$num2=(int)$num1;   
•var_dump($num1); //输出float(3.14)   
•var_dump($num2); //输出int(3)   
•?> 

第二种转换方式：  intval()  floatval()  strval()

 
•<?php  
•$str="123.9abc";   
•$int=intval($str);     //转换后数值：123   
•$float=floatval($str); //转换后数值：123.9   
•$str=strval($float);   //转换后字符串："123.9"    
•?> 

第三种转换方式：  settype();

 
•<?php  
•$num4=12.8;   
•$flg=settype($num4,"int");   
•var_dump($flg);  //输出bool(true)   
•var_dump($num4); //输出int(12)   
•?>

PHP数据类型隐性转换的陷阱

我这里说的是php5+上跑的，php4的请飘过。

先把错误报告打开，以防看不到错误信息
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
?>

根据php manual 中 http://www.php.net/manual/zh/language.operators.comparison.php
“Comparison Operators” 一章的说明可知，number 和string进行比较的时候，会先将string类
型首先转化为number，然后再进行比较操作。

1.类型自动转换为数组
当我们把一个非数组的变量当做数组来调用的时候，该变量在调用时数据类型临时自动转换成数组。
例如如下代码：
<?php
$str = 'string';
var_dump($str['aaa']);  // string(1) "s"
var_dump($str);  // string(6) "string"

if($str['aaa'] === $str[0]) {
    print "===";
}
?>

如下例子可以明显的看出下标类型自动转换在发生。
<?php 
$link = '<a href="http://yulans.cn">yulans</a>'; 
$key = '1-10'; 
echo "$link[$key]n";  // 同 $link[1]
echo "{$link[$key]}n";  // 同 $link[1]
//echo "$link['$key']n";  // 报错
echo "{$link['$key']}n";  // 同 $link[0]
?> 

这里字符串在 var_dump($str['aaa']) 被临时转换成了数组 array('s','t','r','i', 'n','g')，而用关联数组方式
$str['aaa']读取索引数组的值，关联数组的下标'aaa'将被转换成整形下标，
因而在这里的$str['aaa']全等于$str[0]。

其他数据类型隐性转换成数组也隐藏有陷阱，一般都不是报出undefined index错误。举例如下代码：
<?php
/**
 * 测试变量隐性转换成数组
 *
 * @param mixed $param
 */
function test2Arr($param) {
    var_dump($param['abc']);
}

test2Arr(false); // NULL
test2Arr(123); // NULL
test2Arr(123.456); // NULL
test2Arr('string'); // string(1) "s"
test2Arr(array('abc'=>'text'));  // string(4) text
test2Arr(new ArrayObject()); // Notice: undefined index: abc

?>

解决办法：
函数参数数据类型是数组的时候，防止用户输入字符串导致错误
如下例子，当添加用户的时候，我们要求用户必须输入用户名。没有哪个SB把要求是数组的参数传入
字符串，但是防人之心不可无，说不定我连续工作超过十几个小时后一不小心就成那个SB了，又或许
某人想绕过代码执行操作。
<?php
/**
 * 添加用户(错误的写法)
 *
 * @param array $user
 */
function addUser($user) {
    if(empty($user['name'])) {  // 这里当输入类型是不为空的字符串的时候会出错，
        echo "用户名必填n";
        return false;
    }

    // do sth.

    echo "测试n";

    return true;
}

/**
 * 添加用户(正确的写法)
 *
 * @param array $user
 */
function addUser2($user) {
    if(!is_array($user) || empty($user['name'])) {
        echo "用户名必填n";
        return false;
    }

    // do sth.

    echo "测试n";

    return true;
}

$user = 'xiaoxiao';
addUser($user);
addUser2($user);

?>

2.纯数字字符串比较时自动转换成整形超过范围时发生溢出
<?php
$x1 = '111111111111111111';
$x2 = '111111111111111112';

echo ($x1 === $x2) ? "true" : "false";  // false 如我们所愿，这两个字符串确实不一样。
echo ($x1 == $x2) ? "true" : "false";    // true 这里被偷偷的转换类型了，
                                                           // 成了 echo (intval($x1) == intval($x2)) ? "true" : "false"; 整形溢出

?>

3、整形和字符串比较时数据类型隐性转换有可能发生问题
<?php
$number = 0;
$string = 'text';

if($number == $string) {
    print "true";
} else {
    print "false";
}

?>

很遗憾这里输出的是 true
我们知道 $number === $string 肯定是false，手册上说 === 是比较值&&数据类型，而用 == 只是比较值，
$number == $string 这里不是比较值吗？ '0' 和 'text' 明显不一样啊。小心了，这里的$string是
先被秘密转成和$number一样的整形再比较的，$number == (int)$string的确是true

4. in_array 小陷阱
<?php

var_dump(in_array(0, array('s')));  // true

?>
因为in_array会将0 和's' 进行比较，0是number类型，'s'是string类型， 's'转化为number的结果为0，
而0 == 0 的结果是true，所以in_array(0, array('s', 'ss'))的结果也是true

如果把in_array 的第三个参数strict设置为 true，比较的时候 就会判断值和类型是否都相当。
如果都相当的话，才会返回true，否则返回false.