2012-1-30 11:32 Monday  
{if $_global_password} 是判断变量存不存在....

{if $_global_password!==''} 是判断变量等不等于空....

Smarty 中的 if 语句和 php 中的 if 语句一样灵活易用,并增加了几个特性以适宜模板引擎. if 必须于 /if 成对出现. 可以使用 else 和 elseif 子句. 可以使用以下条件修饰词:eq、ne、neq、gt、lt、lte、le、gte、ge、is even、is odd、is not even、is not odd、not、mod、div by、even by、odd by、==、!=、>、<、<=、>=. 使用这些修饰词时必须和变量或常量用空格格开.

equal : 相等、not equal:不等于、greater than:大于、less than:小于、less than or equal:小于等于、great than or equal:大于等于、is even:是偶数、is odd:是奇数、is not even:不是偶数、is not odd:不是奇数、not:非、mod:取余、div by:被。。。除

为什么有些函数连PHP也没自带呢?

2012-1-30 11:31 Monday  
eq       equal : 相等
neq       not equal:不等于
gt        greater than:大于
lt        less than:小于
lte       less than or equal:小于等于
gte       great than or equal:大于等于
is even:是偶数
is odd:是奇数
is not even:不是偶数
is not odd不是奇数
not:非
mod:取余
div by:被...除
2012-1-30 11:29 Monday  

花了大半个上午,就整出这个东西

<?php
/**
* @what 分页类
* @author Aboc QQ:9986584
* @version 1.0
* @date 2008-8-31
*/

class page{
var $page_name='page'; //数据名称
var $page_size; //每页条数
var $db;//数据操作对象
var $page_num;//总页数
var $page=0; //当前页码
var $num; //数据总条数

/**
* Enter 取得分页数据
*
* @param unknown_type $sql
* @param unknown_type $db
* @param unknown_type $page_size
* @return array;
*/
function getData($sql,$db,$page_size=20){
   $this->page_size=$page_size;
   if(strripos($sql,'limit') != false)die('SQL中不可出现limit');
   if($page_size<=0)die('$page_size设置错误');
   $sql=trim($sql);
   $this->num=$db->getnum($sql);
   if($this->num<=$page_size){
    $this->page_num=0;
   }else{
    $this->page_num=ceil($this->num/$page_size)-1;
   }
   if(empty($_GET[$this->page_name]) || $_GET[$this->page_name] <0 ){
    $this->page=0;
   }elseif($_GET[$this->page_name] > $this->page_num){
    $this->page=$this->page_num;
   }else{
    $this->page=$_GET[$this->page_name];
   }
   $sql.=' limit '.($this->page*$page_size).','.$page_size;
   $row=$db->getall($sql);
   //echo $sql;
   return $row;  
}

/**
* 返回去除$page_name之后的查询字串
*
* @return unknown
*/
function getquery(){
   $query=$_SERVER['QUERY_STRING'];
   //echo $query;
   //echo $this->page_name;
   //echo strripos($query,$this->page_name);
   //echo strpos($query,$this->page_name);
   if(empty($query)) return false;
   if(($end=strpos($query,$this->page_name)) !== false){
    if($end==0) $end=1;
    $query=substr($query,0,$end-1);
   }
   //echo $query;
   return $query;
}

/**
* 输出分页链接
*
* @return unknown
*/
function pagelist(){
   $query=$this->getquery();
   if(empty($query)){
    $query='';
   }else{
    $query=$query.'&';
   }
   $total='总共'.$this->num.'条 每页'.$this->page_size.'条';
   $startpage='<a href="?'.$query.$this->page_name.'=0">首页</a>';
   $endpage='<a href="?'.$query.$this->page_name.'='.$this->page_num.'">尾页</a>';
   if($this->page==0){
    $prepage='上一页';
   }else{
    $prepage='<a href="?'.$query.$this->page_name.'='.($this->page-1).'">上一页</a>';
   }
   if($this->page==$this->page_num){
    $nextpage='下一页';
   }else{
    $nextpage='<a href="?'.$query.$this->page_name.'='.($this->page+1).'">下一页</a>';
   }
   return $total.' '.$startpage.' '.$prepage.' '.$nextpage.' '.$endpage;
}
  
}
?>

演示就是下面这个样子的

2012-1-30 11:28 Monday  
ob_start()函数:打开输出缓冲区.

    函数格式 void ob_start(void)
    说明:当缓冲区激活时,所有来自PHP程序的非文件头信息均不会发送,而是保存在内部缓冲区。为了输出缓冲区的内容,可以使用ob_end_flush()或flush()输出缓冲区的内容。

Flush:刷新缓冲区的内容,输出。

    函数格式:flush()
    说明:这个函数经常使用,效率很高。

ob_get_contents :返回内部缓冲区的内容。

    函数格式:string ob_get_contents(void)
    说明:这个函数会返回当前缓冲区中的内容,如果输出缓冲区没有激活,则返回 FALSE.

ob_get_length:返回内部缓冲区的长度。

    函数格式:int ob_get_length(void)
    说明:这个函数会返回当前缓冲区中的长度;和ob_get_contents一样,如果输出缓冲区没有激活,则返回 FALSE.

ob_end_clean:删除内部缓冲区的内容,并且关闭内部缓冲区

    函数格式:void ob_end_clean(void)
    说明:这个函数不会输出内部缓冲区的内容而是把它删除

ob_end_flush:发送内部缓冲区的内容到浏览器,并且关闭输出缓冲区

    函数格式:void ob_end_flush(void)
    说明:这个函数发送输出缓冲区的内容(如果有的话)

ob_implicit_flush:打开或关闭绝对刷新

    函数格式:void ob_implicit_flush ([int flag])
    说明:默认为关闭缓冲区,打开绝对输出后,每个脚本输出都直接发送到浏览器,不再需要调用 flush()  

2012-1-30 11:28 Monday  
<?php
class cache
{
var $cache_dir = 'cache/';//This is the directory where the cache files will be stored;
var $cache_time = 1000;//How much time will keep the cache files in seconds.

var $caching = false;
var $file = '';

function cache()
{
//Constructor of the class
$this->file = $this->cache_dir . urlencode( $_SERVER['REQUEST_URI'] );
if ( file_exists ( $this->file ) && ( fileatime ( $this->file ) + $this->cache_time ) > time() )
{
//Grab the cache:
$handle = fopen( $this->file , "r");
do {
$data = fread($handle, 8192);
if (strlen($data) == 0) {
break;
}
echo $data;
} while (true);
fclose($handle);
exit();
}
else
{
//create cache :
$this->caching = true;
ob_start();
}
}

function close()
{
//You should have this at the end of each page
if ( $this->caching )
{
//You were caching the contents so display them, and write the cache file
$data = ob_get_clean();
echo $data;
$fp = fopen( $this->file , 'w' );
fwrite ( $fp , $data );
fclose ( $fp );
}
}
}

//使用方法,先实例化,最后close方法
//$ch = new cache();
//echo date("D M j G:i:s T Y");
//$ch->close();
?>

2012-1-30 11:27 Monday  

类的结构: 类的内部能可能有三种东西,就是常量(constant),属性(property)和方法

[复制此代码]CODE:
<?php
class TEST
{
const NAME = 'value'; // 常量
public $name = 'value'; // 属性
public function name() // 方法
{
echo 'value';
}
}
?>

在这之中,属性和方法又可以使用public, protected, private三个不同的关键字来将属性和方法的作用范围做进一步的区分,带有private关键字的属性和方法,只有所在的类中的方法才能调用;带有 protected关键字的属性和方法,除了自己以外,自己的父类和子类中的方法也可以调用;带有public关键字的属性和方法,则可以从实例化以后的 对象中进行调用,这样做最大的好处给所有的属性和方法增加了一些描述的特征,更便于整理和组织代码的结构。const关键字先跳过,和后面的static 一起讲。
static关键字是有别于public, protected, private的另一类型关键字(因此可以和public, protected, private叠加起来使用):
[复制此代码]CODE:
<?php
class TEST
{
public static function name()
{
echo 'value';
}
}
?>

带有static关键字的方法,可以在不对类进行实例化的情况下直接通过“::”符号调用,和public, protected, private的搭配,也可以让调用区分权限,但是一般都是和public搭档,前面提到的常量关键字const,应该就是public static类型的,因此只能通过self::NAME,TEST::NAME这样的形式调用常量,后面的__construct,__destruct 等方法,都是属于static。
类的结构部分,最后介绍的两个关键字是abstract和final,abstract关键字表示这个类必须被他的子类覆写,而final关键字表示这个 类必须不能被他的子类覆写,这两个关键字的功能是正好相反的,带有abstract的方法被成为抽象方法,带有抽象方法的类,成为抽象类,这个在后面还有 介绍。
类的使用:
类的使用主要有两种方法,一种是使用new关键字,另一种是使用“::”符号:
PHP代码
[复制此代码]CODE:
<?php
class TEST
{
public static function name()
{
echo 'value';
}
}
//方法1:使用new关键字
$test = new TEST;
$test->name();
//方法2:使用“::”符号
TEST::name();
?>

(1):使用new关键字成为实例化,上面的$test就是一个通过TEST类实例化而产生的对象,$test->name()称为调用$test对象的name方法。
(2):使用new关键字使用类的时候,可以使用$this来指代类本身。
(3):使用“::”符号的前提是方法必须是带有static关键字的,使用new关键字时,被调用的方法,必须带有public关键字(一个方法如果不带public, protected, private中的任何一个关键字,则默认为public)
(4):同一个类可以通过new关键字被实例成多个不同的对象,但是彼此之间的是隔离的;“::”符号在使用的时候,方法在多次使用之间,是共享的:
PHP代码
[复制此代码]CODE:
<?php
class TEST1
{
public $name = 0;
public function name()
{
$this->name = $this->name + 1;
}
}
$test1 = new TEST1;
$test2 = new TEST1;
$test1->name(); //$name1 == 1
$test2->name(); //$name1 == 1
/*--------------------------------------------*/
class TEST2
{
public static $name = 0;
public static function name()
{
TEST2::$name = TEST2::$name + 1;
}
}
TEST2::name(); // $name == 1
TEST2::name(); // $name == 2
?>
类的关系:
类与类之间的关系,主要有抽象,接口和继承:
PHP代码
[复制此代码]CODE:
<?php
abstract class TEST1 // 抽象
{
abstract public function name1();
public function name2()
{
}
}
class TEST2 extends TEST1 implements TEST3 // 继承
{
public function name1()
{
}
}
interface TEST3 // 接口
{
public function name2();
}
?>

(1)带有abstract关键字的类是抽象类,带有abstract关键字的方法是抽象方法,抽象类中的抽象方法,必须在子类中被覆写。
(2)带有interface关键字的类,就是接口,接口不允许实现任何的方法,接口中所有的方法,都必须在子类中被覆写。
(3)带有 classA extends classB 或者 classA implements classB 字样的就是继承,extends表示继承另一个类,implements表示继承另一个接口,一次只能extends一个类,但是可以 implements多个接口。
(4)抽象类,接口,以及最终继承并实现的方法,都必须是public的。
在继承的过程中,子类会覆写父类的同名方法,这个时候如果需要在子类中调用父类的方法,可以使用parent关键字或者类名加上“::”符号调用:
PHP代码
[复制此代码]CODE:
<?php
class TEST1 extends TEST2
{
public function name()
{
echo parent::name2();
echo TEST2::name2();
}
}
class TEST2
{
public function name2()
{
echo 'value2';
}
}
$test = new TEST1;
$test->name();
?>

这里再解释一下“::”方法在类中的作用,一个作用是在没有实例化的情况下调用常量(其实也理解成static就可以了),static属性和方法,再一个是在类的内部,通过self,parent和类名建立便捷的调用通道。
对象于对象之间的关系,主要是“==”等于,“===”全等于,不等于和clone:
PHP代码
<?php
class TEST
{
public function name()
{
}
}
$test1 = new TEST;
$test2 = new TEST;
$test3 = $test1;
echo $test1 == $test2 ? true : false; // true
echo $test1 == $test3 ? true : false; // true
echo $test2 == $test3 ? true : false; // true
echo $test1 === $test2 ? true : false; // false
echo $test1 === $test3 ? true : false; // true
echo $test2 === $test3 ? true : false; // false
?>
(1)两个类只要拥有相同的属性和方法,就是“==”等于。
(2)两个类必须是指向的同一个对象,才能是“===”全等于。
clone比较特殊,在上面的例子中,$test3 = $test1的过程并不是给了 $test3 一份 $test1 对象的拷贝,而是让 $test3 指向了 $test1,如果一定要获得一份$test1的拷贝,就必须使用clone关键字:
PHP代码
[复制此代码]CODE:
<?php
$test3 = clone $test1;
?>

类的钩子:
__autoload:
是一个函数名,也是唯一一个在类的外部使用的钩子,在实例化一个对象的时候,如果没有预先载入类,就会调用这个钩子。
__construct
在类被实例话的时候,被调用的钩子,可以做一些初始化的操作。
__destruct
在类被销毁的时候,被调用的钩子。
__call
当对象试图调用一个不存在的方法的时候,被调用的钩子
__sleep
当使用serialize()函数对一个类进行序列话操作的时候,会调用这个钩子
__wakeup
当使用unserialize()函数对一个类进行反序列话操作的时候,会调用这个钩子
__toString
当一个对象将被转变为字符串的时候,会调用这个钩子(比如echo的时候)
__set_state
当调用var_export()函数操作一个类的时候,会调用这个钩子
__clone
当使用clone关键字对一个类进行拷贝操作的时候,会调用这个钩子
__get
在获取一个类中的属性值的时候,会调用这个钩子
__set
在设置一个类中的属性值的时候,会调用这个钩子
__isset
在使用isset()函数对类中的属性值进行判定的时候,会调用这个钩子
__unset
在使用unset()函数销毁一个属性值的时候,会调用这个钩子
类的小技巧:
在实例话一个类的时候,可以使用这样的形式给__construct钩子传递参数:
PHP代码
[复制此代码]CODE:
<?php
class TEST
{
public function __construct($para)
{
echo $para;
}
}
$test = new TEST('value'); // 显示 value
?>

foreach()函数可以用来对类或者对象中的属性进行遍历,遍历的时候会先判断public, protected, private的情况而显示:
PHP代码
[复制此代码]CODE:
<?php
class TEST
{
public $property1 = 'value1';
public $property2 = 'value2';
public $property3 = 'value3';
public function name()
{
foreach($this as $key => $value)
{
print "$key => $value\n";
}
}
}
$test = new TEST;
foreach($test as $key => $value)
{
print "$key => $value\n";
}
$test->name();
?>

在给类中的方法传递参数的时候,可以对参数进行强制的判定,这里只支持对数组和对象的判定:
PHP代码
[复制此代码]CODE:
<?php
class TEST1
{
public function name( TEST2 $para )
{
}
}
class TEST2
{
}
$test2 = new TEST2;
$test1 = new TEST1;
$test1->name('value'); // 会报错,因为这个参数必须是TEST2实例化以后的对象
$test1->name($test1); // 不会报错
?>

兼容php4的语法:
php5的类是往下兼容php4的,这些php4时代的语法也得到了继承,但是并不建议在php5的环境中使用。
(1)使用var预设属性,会自动转换成public。
(2)使用类名作为构造函数,在没有__construct构造方法的情况下,会寻找和类名相同的函数作为构造函数。

2012-1-30 11:25 Monday  
把smarty下载回来,放在
本教程假设smarty解压安装在网站根目录的smarty目录下
1.smarty的配置
      首先,使用smarty第一件事是先配置好,一般有以下9行代码

require_once("smarty/libs/Smarty_class.php"); //把smarty的类定义文件包含进来
      $smarty=new smarty();
      $smarty->config_dir="smarty/libs/Config_File.class.php";
      $smarty->caching=false; //是否使用缓存,项目在调试期间,不建议启用缓存
      $smarty->cache_dir="smarty_cache/"; //缓存文件夹
      $smarty->template_dir="smarty_tpl";           //模板文件夹
      $smarty->compile_dir="smarty_compile";      //编译文件夹
      $smarty->left_delimiter="<{";            // 标签符定义不是必要的,smarty默认是使用"<"和">",强烈建议更换。
                                         //因为如果smarty的标签刚好在javascript语句里面时,冲突的可能性很大
      $smarty->right_delimiter="}>";

      以上的9行代码可以放在一个独立的文件,需要使用smarty的页面引用进来即可


2. smarty的使用
      smarty替换标签的语法:
      smarty->assign("标签名","值");
      smarty->display("index.html"); //显示内容,index为模板文件名

      假定模板文件里面有一个标签 <{ $user_name }> (注意:标签里面的变量必须带$)
那么在PHP文件可以:
      $new_name="Joan";
      smarty->assign("user_name",$new_name); (注意:在此时,user_name是不带$的)
      smarty->display("index.html"); //显示内容,index为模板文件名


3. smarty的循环
      循环的使用在php文件像处理普通标签一样处理
     
      模板文件代码:
      <table border=1 width=500>
<{section name=s loop=$stu}>
      <tr>
      <td>
           <{$stu[s]}>
      </td>
      </tr>
<{/section}>
      </table>

那么在PHP文件可以:
假如有一个数组,或一个记录集 $rs
$smarty->assign("stu",$rs);
$smarty->display("index.html"); //在PHP文件处理循环标签和普通标签没什么区别。

4.      smarty的if 语法
      模板文件
      <{if $my_r>500 }>
           <{$my_r}>
      <{/if}>

      php文件:

      $aa=123;
      $smarty->assign("my_r",$aa);     
      $smarty->display("in.html");
上例中,如果$aa>500,my_r的标签就能显示出来,否则不显示。
<{ if 条件 }> //此处的条件不要加括号,也不要像basic语言那样在后面加 then

<{/if}>

5. smarty循环配合if 使用实例

      PHP文件
----------------------------------
      $aa[0]=123;
      $aa[1]=456;
      $aa[2]=789;
      $smarty->assign("my_r",$aa);
      $smarty->display("in.html");

      模板文件
------------------------------------------------------
      <{ section name=s loop=$my_r }>
      <{if $my_r[s]>200 }>
      <{$my_r[s]}>
      <{else}>
           小于200
      <{/if}>
      <br>
      <{/section}>
-----------------------------------------------
上例中,只显示大于200的数值


<{ section name=s loop=$my_r }>
      <{if $my_r[s]=="456" }> //这是字符型的实例,用==
      <{$my_r[s]}>
      <{else}>
           Not
      <{/if}>
      <br>
<{ /section }>