PHP程序开发参考手册

2017-01-05 11:11:10来源:oschina作者:newcichang人点击

摘要


php


/**语句*/
//if语句——条件控制语句
<?php
$num = 2011;
if(($num%4)==0&&($num%100)!=0){
echo "$num".'年'."是闰年";
}else{
echo "$num".'年'."是平年";
}
?>
<?php
$num = 2011;
if(($num%4)==0&&($num%100)!=0){
echo "$num".'年'."是闰年";
}else{
echo "$num".'年'."是平年";
}
?>
<?php
$a=20;
$b=30;
if($a>$b){
echo "welcome";
}else{
echo "welcome!";
}
?>
//else语句——不满足条件时执行
<?php
$string="gmy1";
if($string=="gmy"){
echo "welcome";
}else{
echo "输入的不正确";
}
?>
<?php
$num=rand(1,31);
if($num%2==0){
echo "变量$num 为偶数";
}else{
echo "变量$num 为奇数";
}
?>
//elseif语句——判断其他的条件
<?php
$moth = date("n");
$today = date("j");
if($today >= 1 and $today <= 10){
echo "今天是".$moth."月".$today."日上旬";
}elseif ($today > 10 and $today <= 20){
echo "今天是".$moth."月".$today."日中旬";
}else{
echo "今天是".$moth."月".$today."日下旬";
}
?>
//while语句——简单的循环控制语句
<?php
$user="gmy";
while($user=="gmy"){
echo "应用while";
}
?>
//do…while语句——先执行后判断
<?php
$user="mrsoft";
do{
echo "应用do...whlie";
}while($user=="gmy");
?>
//for语句——复杂的循环控制语句
<?php
for ($i=1;$i<=9;$i++){
echo "";
for ($j=1;$j<=$i;$j++){
echo "";
}
echo "
";
echo $i*$j;
echo "
";
}
?>
<?php
$b="";
for($a=0;$a<=100;$a+=2){
$b=$a+$b;
}
echo "结果为:".$b."";
?>
//foreach语句——遍历数组语句
<?php
$arr = array("We","are","the","best","team","!");
if (is_array($arr) == TRUE) {
foreach ($arr as $key => $value) {
echo $key . " = " . $value . "
";
}
} else {
echo "变量/$arr不是数组,不能用foreach语句";
}
?>
//break语句——跳出循环
<?php
for($i=1;$i<=4;$i++){
echo $i;
if($i==4){
break;
}
}
?>
//continue语句——跳过并继续下一次循环
<?php
$arr = array("PHP程序开发","JAVA程序开发","PHP函数大全");
for($i=0;$i if ($i==2){
continue;
}
echo $arr[$i]."/t | ";
}
?>
//switch语句——根据比较结果执行对应语句
<?php
$a = 60;
switch ($a){
case $a==100;
echo "满分";
break;
case $a>=90;
echo "优秀";
break;
case $a>=60;
echo "及格";
break;
default:
echo "不及格";
}
?>
//return语句——结束函数或脚本文件的执行
<?php
function sub($str,$start,$len){
$strlen = $start + $len;
for($i=0;$i<$strlen;$i++){
if(ord(substr($str, $i,1))>0xa0){
$stres.=substr($str, $i,2);
$i++;
}else{
$stres.=substr($str,$i,1);
}
}
return $stres;
}
?>
//try…catch…throw语句——捕获并抛出异常
<?php
try{
$a = "明日科技";
throw new Exception($a);
echo "为了一个共同的目标!";
}catch(Exception $e){
echo "捕获异常:",$e->getMessage(),"
";
}
echo "编程词典";
?>
//include语句——文件包含语句
<?php
include("conn/conn.php");
?>
//require语句——文件包含语句
<?php
require("top.php");
?>
//require_once语句——包含一次的语句
<?php
require_once("top.php");
?>
/**经典类*/
//PDO连接数据库类——封装PDO数据库连接
//ConnDB.class.php
<?php
class ConnDB{
var $dbtype;
var $host;
var $user;
var $pwd;
var $dbname;

function ConnDB($dbtype,$host,$user,$pwd,$dbname){
$this->dbtype=$dbtype;
$this->host=$host;
$this->user=$user;
$this->pwd=$pwd;
$this->dbname=$dbname;
}

function GetConnId(){
if($this->dbtype=="mysql"||$this->dbtype=="mssql"){
$dsn="$this->dbtype:host=$this->host;dbname=$this->dbname";
}else{
$dsn="$this->dbtype:dbname=$this->dbname";
}
try{
$conn = new PDO($dsn,$this->user,$this->pwd);
$conn->query("set names utf8");
echo "连接成功";
return $conn;
}catch(PDOException $e){
die("Error!:".$e->getMessage()."
");
}
}
}
?>
//index.php
<?php
require 'ConnDB.class.php';
$connobj=new ConnDB("mysql", "localhost", "root", "root", "php");
$conn=$connobj->GetConnId();
?>
//PDO操作数据库类——封装PDO数据库操作
//PDO分页类——封装PDO分页操作
//Smarty配置类——封装Smarty配置
//Util项目工具类——封装一些常用方法
//购物车类——封装购物车常用方法
//格式转换类——封装字符串转换方法
//验证码类——封装验证码生成方法
//省市二级菜单类——封装省市联动的方法
//PHP动态生成静态页类——封装动态生成静态页方法
//图片添加文字水印类——封装添加文字水印方法
//图片添加图像水印类——封装添加图像水印方法
//缩略图生成类——封装生成缩略图方法
//柱形图绘制类——封装柱形图绘制方法
//折线图绘制类——封装折线图绘制方法
//饼形图绘制类——封装饼形图绘制方法
//PHP伪静态——隐藏实际路径
/**数组函数库*/
//array_change_key_case函数——返回字符串键名全为小写或大写的数组
<?php
$array=array("first"=>'asp',"second"=>'php');
print_r(array_change_key_case($array,CASE_UPPER));
?>
//array_chunk函数——将一个数组分割成多个数组
<?php
$array=array('asp','php','java');
print_r(array_chunk($array, 2));
echo "
";
print_r(array_chunk($array, 2,true));
?>
//array_combine函数——合并数组
<?php
$a=array('asp','php','jsp');
$b=array('50','62','65');
$c=array_combine($a, $b);
print_r($c);
?>
//array_count_values函数——统计数组中的元素值
<?php
$array=array('asp','php','jsp');
print_r(array_count_values($array));
?>
//array_diff_assoc函数——带索引检查计算数组的差集
<?php
$array1=array('asp'=>"实例应用",'php'=>"函数手册",'jsp'=>"实战宝典");
$array2=array('asp'=>"实例应用","函数手册","实战宝典");
$result=array_diff_assoc($array1, $array2);
print_r($result);
?>
//array_diff_uassoc函数——用回调函数做索引检查来计算数组的差集
<?php
function key_compare_func($a,$b){
if($a==$b){
return 0;
}
return ($a>$b)?1:-1;
}
$array1=array("asp"=>"实例应用",'php'=>"函数手册",'jsp'=>"实战宝典",);
$array2=array('asp'=>"实例应用","函数大全","基础应用");
$result=array_diff_uassoc($array1, $array2, "key_compare_func");
print_r($result);
?>
//array_diff函数——计算数组的差集
<?php
$array1=array("asp"=>"实例应用",'php'=>"函数手册",'jsp'=>"基础应用",);
$array2=array('asp'=>"实例应用","函数大全","基础应用");
$result=array_diff($array1, $array2);
print_r($result);
?>
//array_fill函数——用给定值填充或建立数组
<?php
$array=array_fill(3, 5, 'PHP');
print_r($array);
?>
//array_filter函数——将数组值传递到自定义过滤函数
<?php
function one($arr){
return ($arr%2==1);
}
function two($arr){
return ($arr%2==0);
}
$array1=array("a"=>1,"b"=>2,"c"=>3,"d"=>4,"e"=>5);
$array2=array(6,7,8,9,10,11,12);
echo "第一个:
";
print_r(array_filter($array1,"one"));
echo "
第二个:
";
print_r(array_filter($array2,"two"))
?>
//array_flip函数——交换数组中的键和值
<?php
$array=array("html"=>46,"php"=>66,"xhtml"=>46);
$result=array_flip($array);
print_r($result);
?>
//array_intersect_assoc函数——获取多个数组的交集
<?php
$array1=array("asp"=>"实例应用",'php'=>"函数手册",'jsp'=>"基础应用",);
$array2=array('asp'=>"实例应用","函数大全","基础应用");
$result=array_intersect_assoc($array1, $array2);
print_r($result);
?>
//array_intersect函数——获取多个数组的交集
<?php
$array1=array("asp"=>"实例应用",'php'=>"函数手册",'jsp'=>"基础应用",);
$array2=array('asp'=>"实例应用","函数大全","基础应用");
$result=array_intersect($array1, $array2);
print_r($result);
?>
//array_key_exists函数——检查键名是否存在于数组中
<?php
$array=array("php"=>58,"ajax"=>54);
if(array_key_exists("php", $array)){
echo "php在数组中";
}
?>
//array_keys函数——获取数组中的所有键名
<?php
$array=array(0=>100,"php"=>"图书");
$arr1=array_keys($array);
print_r($arr1);
$array=array("php","asp","java","php");
$arr2=array_keys($array,"php");
print_r($arr2);
?>
//array_merge_recursive函数——合并数组
<?php
$array1=array("php"=>array("perl"=>3),5);
$array2=array(10,"ajax"=>array("javascript"=>15,16));
$result=array_merge_recursive($array1,$array2);
print_r($result);
?>
//array_merge函数——合并数组
<?php
$array1=array("php"=>array("perl"=>3),5);
$array2=array(10,"ajax"=>array("javascript"=>15,16));
$result=array_merge($array1,$array2);
print_r($result);
?>
//array_pad函数——填补数组
<?php
$input=array("php","jsp","html");
$result1=array_pad($input, 5, 8);
$result2=array_pad($input, -5, "asp");
$result3=array_pad($input, 1, "asp");
print_r($result1);
echo "
";
print_r($result2);
echo "
";
print_r($result3);
?>
//array_pop函数——弹出数组最后一个单元
<?php
$arr=array("php","jsp","html","asp");
$array=array_pop($arr);
echo "被弹出的单元是:$array
";
print_r($arr);
?>
//array_push函数——将值压入数组末尾
<?php
$stack=array("php软件","php图书");
array_push($stack, "asp软件","asp图书");
print_r($stack);
$stack2=array("php软件","php图书");
$stack2[]="asp软件";
$stack2[]="asp图书";
print_r($stack2);
?>
//array_rand函数——取出数组中的随机数
<?php
srand((float)microtime()*1000000);
$arr=array("php教程","php基础","php实例","php参考手册","php例");
$rand_keys=array_rand($arr,2);
echo $arr[$rand_keys[0]]."
";
echo $arr[$rand_keys[1]];
?>
//array_reduce函数——用函数将数组简化为单一的值
<?php
function rsum($v,$w){
$v+=$w;
return $v;
}
function rmul($v,$w){
$v*=$w;
return $v;
}
$a=array(1,2,3,4,5);
$x=array();
$b=array_reduce($a, "rsum");
print_r($b);
$c=array_reduce($a, "rmul",10);
print_r($c);
$d=array_reduce($x, "rsum",1);
print_r($d);
?>
//array_reverse函数——颠倒数组元素顺序
<?php
$arr=array("asp","php","jsp");
$result=array_reverse($arr);
print_r($result);
$result2=array_reverse($arr,true);
print_r($result2);
?>
//array_search函数——返回给定值的键名
<?php
$arr=array("asp","php","60");
if(array_search(60, $arr)){
echo "60在数组中
";
}else{
echo "60不在数组中
";
}
if(array_search(60, $arr,true)){
echo "60在数组中
";
}else{
echo "60不在数组中";
}
?>
//array_shift函数——移出数组第一个单元
<?php
$arr=array("php教程","php基础","php实例");
$result=array_shift($arr);
echo $result."
";
print_r($arr);
?>
//array_sum函数——计算数组的和
<?php
$a=array(1,2,8,9);
$suma=array_sum($a);
echo "sum(a)=$suma";
$b=array("a"=>1.1,"b"=>2.2,"c"=>3.3);
$sumb=array_sum($b);
echo "sum(b)=$sumb";
?>
//array_udiff_assoc函数——检查数组的差集
<?php
class cr{
private $priv_member;
function cr($val){
$this->priv_member=$val;
}
function comp_func_cr($a,$b){
if($a->priv_member===$b->priv_member) return 0;
return ($a->priv_member>$b->priv_member)?1:-1;
}
}
$a=array("0.1"=>new cr(9),"0.5"=>new cr(12),0=>new cr(23),1=>new cr(4),2=>new cr(-15));
$b=array("0.2"=>new cr(9),"0.5"=>new cr(22),0=>new cr(3),1=>new cr(4),2=>new cr(-15));
$result=array_udiff_assoc($a, $b, array("cr","comp_func_cr"));
print_r($result);
?>
//array_values函数——返回数组所有值
<?php
$array=array("手册"=>"PHP函数手册","PHP基础应用","PHP"=>"PHP函数手册","PHP基础应用","PHP典型例");
$result=array_values($array);
print_r($result);
?>
//array_walk函数——对数组单元应用自定义函数
<?php
$fruits=array("d"=>"lemon","a"=>"orange","b"=>"banana","c"=>"apple");
function test_alter($item1,$key,$prefix){
$item1="$prefix:$item1";
}
function test_print($item2,$key){
echo "$key.$item2
/n";
}
echo "before../n";
array_walk($fruits, "test_print");
array_walk($fruits, "test_alter","fruit");
echo "...and after:/n";
array_walk($fruits, "test_print");
?>
//array函数——建立数组
<?php
$array1=array("asp","php","jsp");
print_r($array1);
$array2=array(3=>"asp","php",10=>"jsp");
print_r($array2);
$array3=array("a"=>"asp","php","j"=>"jsp");
print_r($array3);
?>
//asort函数——对数组排序
<?php
$array=array("a"=>"asp","p"=>"php","j"=>"jsp");
asort($array);
print_r($array);
?>
//compact函数——建立数组
<?php
$a="asp";
$b="php";
$array=array("a","b");
$c="jsp";
$result=compact("c",$array);
print_r($result);
?>
//count函数——统计数组元素个数
<?php
$array=array("php"=>array("应用","例"),"asp"=>array("应用"));
echo count($array,COUNT_RECURSIVE);
echo count($array);
?>
//current函数——返回数组中当前单元
<?php
$transport=array("php","asp","sql","jsp");
$mode=current($transport);
echo $mode."/n";
$mode=next($transport);
echo $mode."/n";
$mode=current($transport);
echo $mode."/n";
$mode=prev($transport);
echo $mode."/n";
$mode=end($transport);
echo $mode."/n";
$mode=current($transport);
echo $mode."/n";
?>
//each函数——返回当前元素键名和对应值
<?php
$array=array("php"=>"php","ajax"=>"ajax");
$result=each($array);
print_r($result);
reset($array);
while (list($key,$value)=each($array)){
echo "$key=>$value";
}
?>
//end函数——返回数组最后一个单元
<?php
$array=array("asp","php","jsp");
$result=end($array);
echo $result;
?>
//in_array函数——判断给定值是否在数组中
<?php
$array=array("asp","php","jsp");
if(in_array("php", $array)){
echo "php in";
}
if(in_array("asp", $array)){
echo "asp in";
}
?>
//key函数——返回当前单元键名
<?php
$array=array("php"=>"php","asp"=>"php","jsp"=>"jsp");
while ($name=current($array)){
if($name=="php"){
echo key($array)."
";
}
next($array);
}
?>
//krsort函数——对键名逆向排序
<?php
$array=array("php"=>"php","asp"=>"php","jsp"=>"jsp");
krsort($array);
print_r($array);
?>
//ksort函数——对键名排序
<?php
$array=array("php"=>"php","asp"=>"asp","jsp"=>"jsp");
ksort($array);
print_r($array);
?>
//list函数——将数组元素赋给变量
<?php
$array=array("php","jsp","html");
list($a,$b,$c)=$array;
echo "$a and $b and $c";
list($a,,$b)=$array;
echo "$a and $b";
list(,,$a)=$array;
echo "$a";
?>
//next函数——返回下一个单元值
<?php
$array=array("php","jsp","html");
$result1=next($array);
echo $result1;
$result2=next($array);
echo $result2;
?>
//prev函数——返回上一个单元值
<?php
$array=array("php","jsp","html");
end($array);
$result1=prev($array);
echo $result1;
$result2=prev($array);
echo $result2;
?>
//range函数——建立指定范围内的数组
<?php
$array=range(2,8);
print_r($array);
$arr=range(b, g);
print_r($arr);
?>
//reset函数——将指针返回到第一个单元
<?php
$array=array("php","asp","jsp","ajax");
$result1=next($array);
$result2=next($array);
reset($array);
$result3=next($array);
echo "$result1,$result2,$result3";
?>
//rsort函数——对数组逆向排序
<?php
$array=array("a"=>"asp","p"=>"php","j"=>"jsp");
rsort($array);
print_r($array);
?>
//sort函数——对数组排序
<?php
$array=array("a"=>"asp","p"=>"php","j"=>"jsp");
sort($array);
print_r($array);
?>
//uasort函数——用自定义函数对数组值排序
<?php
function fc($a,$b){
if($a==$b) return 0;
return ($a<$b)?-1:1;
}
$array=array(9,6,7,3,4);
uasort($array, "fc");
print_r($array);
?>
//uksort函数——用自定义函数对数组键名排序
<?php
function fc($a,$b){
if($a==$b) return 0;
return ($a<$b)?-1:1;
}
$array=array("a"=>"asp","p"=>"php","j"=>"jsp");
uksort($array, "fc");
print_r($array);
?>
//usort函数——用自定义函数对数组值排序
<?php
function fc($a,$b){
if($a==$b) return 0;
return ($a<$b)?-1:1;
}
$array=array("a"=>"asp","p"=>"php","j"=>"jsp");
usort($array, "fc");
print_r($array);
?>
/**类和对象函数库*/
//class_exists函数——检查类是否定义
<?php
class Book{}
if(class_exists('book')){
$obj=new Book();
echo "Book类存在";
}
?>
//get_class_methods函数——返回类中方法名的数组
<?php
class Book{
function book(){}
function php(){}
function people(){}
}
$array=get_class_methods('book');
print_r($array);
?>
//get_class_vars函数——返回公有属性的关联数组
<?php
class Book{
var $var1;
var $var2=123;
var $var3='php';
function book(){
$this->var2=100;
}
}
$book=new Book();
$array=get_class_vars('book');
print_r($array);
?>
//get_class函数——返回对象所属的类名
<?php
class Book{
var $var;
}
$book=new Book();
$array=get_class($book);
echo "此对象属于$class类";
?>
//get_declared_classes函数——返回由类名组成的数组
<?php
class Book{
var $var;
}
class Php{}
class Phpbook{}
$class=get_declared_classes();
print_r($class);
?>
//get_object_vars函数——返回属性组成的关联数组
<?php
class Book{
var $var1;
var $var2="php";
var $var3;
function book($var1,$var2){
$this->var1=$var1;
$this->var2=$var2;
}
function setVar3($var3){
$this->var3=$var3;
}
}
$book = new Book("图书", "明日");
print_r(get_object_vars($book));
$book->setVar3("明日科技");
print_r(get_object_vars($book));
?>
//get_parent_class函数——返回对象或类的父类名
<?php
class MingRi{
var $mr;
}
class Book extends MingRi{
var $book;
}
class Soft extends MingRi{
var $soft;
}
$book=new Book();
$obj=get_parent_class($book);
$str=get_parent_class("soft");
echo '$book对象的父类是'.$obj;
echo "soft类的父类是".$obj;
?>
//is_a函数——检查对象和类的从属关系
<?php
class Book{
var $var="php";
}
$book=new Book();
if(is_a($book, 'book')){
echo '$book 是Book的对象';
}
?>
//is_subclass_of函数——检查对象是否是该类的子类
<?php
class Book{
var $var="php";
}
class Soft extends Book{
var $var=100;
}
$book=new Book();
$soft=new Soft();
if(is_subclass_of($book, 'book')){
echo '$book 是Book的子类的对象';
}else{
echo '$book 不是Book的子类对象';
}
if(is_subclass_of($soft, 'book')){
echo '$soft 是Book的子类的对象';
}else{
echo '$soft 不是Book的子类对象';
}
if(is_subclass_of('soft', 'book')){
echo 'soft 是Book的子类的对象';
}else{
echo 'soft 不是Book的子类对象';
}
?>
//method_exists函数——检查方法是否存在于类中
<?php
class Book{
function php(){}
function asp(){}
function jsp(){}
}
$book=new Book();
if(method_exists($book, 'php')){
echo 'php方法存在';
}else{
echo 'php方法不存在';
}
if(method_exists($book, 'java')){
echo 'java方法存在';
}else{
echo 'java方法不存在';
}
?>
/**日期时间函数库*/
//checkdate函数——验证日期有效性
<?php
$date=checkdate(6, 6, 2011);
echo $date;
?>
//date函数——格式化一个本地时间/日期
<?php
date_default_timezone_set("Asia/Hong_Kong");
$data=date("Y-m-d h:i:m");
echo $data;
?>
//getdate函数——返回数组形式的日期、时间信息
<?php
print_r(getdate());
?>
//gettimeofday函数——返回当前时间信息
<?php
print_r(gettimeofday());
?>
//gmdate函数——格式化一个GMT/UTC日期/时间
<?php
ini_set("date.timezone", "Asia/Hong_Kong");
echo date("M d Y H:i:s");
echo gmdate("M d Y H:i:s");
?>
//gmmktime函数——返回时间戳记的格林威治时间
<?php
$str=gmmktime(0,0,0,3,7,2010);
echo ("UNIX的格林威治时间戳记为:".$str."
");
echo (date("Y-m-d H:i:s",$str));
?>
//gmstrftime函数——根据区域设置格式化时间/日期
<?php
date_default_timezone_set("Asia/Hong_Kong");
echo strftime("%b %d %y %H:%M:%S",mktime())."/n";
echo gmstrftime("%b %d %y %H:%M:%S",mktime())."/n";
?>
//localtime函数——获取本地的时间
<?php
$day=time();
print_r(localtime());
print_r(localtime($day,1));
?>
//microtime函数——返回当前时间戳和微秒数
<?php
function getmicrotime(){
list($usec,$sec)=explode(" ", microtime());
return ((float)$usec+(float)$sec);
}
$time_start=getmicrotime();
for($i=0;$i<100;$i++){
echo $i;
}
$time_end = getmicrotime();
$time = $time_end-$time_start;
echo "执行for循环语句需要的时间".$time;
?>
//mktime函数——根据给定参数返回时间戳
<?php
echo "mktime函数返回的时间戳".mktime()."
";
echo date("M-d-Y",mktime());
?>
//strftime函数——根据区域设置格式化本地时间/日期
<?php
setlocale(LC_TIME, "C");
print (strftime("今天是:%A"));
setlocale(LC_TIME, "fi_FI");
print (strftime("今天是:%B月%d日"));
setlocale(LC_TIME, "fr_FR");
print (strftime("%c"));
?>
//strtotime函数——将英文的日期时间解析为时间戳
<?php
echo strtotime("now"),"/n";
?>
//time函数——返回当前UNIX时间戳
<?php
echo "输出time()函数获取的时间戳:".time();
echo date("Y-m-D",time());
?>
/**目录文件处理函数库*/
//basename函数——返回基本文件名
<?php
echo basename("F:/AppServ/www/PHPTest/index.php");
echo basename("F:/AppServ/www/PHPTest/index.php",".php");
?>
//chdir函数——改变当前目录
<?php
chdir("c:/");
?>
//chgrp函数——改变文件所属的组
<?php
chgrp("/usr/local/index.php", 'user')
?>
//chroot函数——改变当前进程的根目录
<?php
chroot("/usr/local");
?>
//chmod函数——更改指定文件所属的模式
<?php
chmod("/usr/local/index.php", 0755);
?>
//chown函数——更改指定文件的拥有者
<?php
chown("/usr/local/index.php", "usr");
?>
//clearstatcache函数——清除缓存
<?php
$array=stat("F:/AppServ/www/PHPTest");
print_r($array);
clearstatcache();
?>
//closedir函数——关闭已打开的目录
<?php
$handle=opendir("F:/AppServ/www/PHPTest");
closedir($handle);
?>
//copy函数——对文件进行复制
<?php
copy("F:/AppServ/www/PHPTest/index.php", "F:/AppServ/www/PHPTest/gmy.php");
?>
//dir函数——将目录名转换为对象
$dir=dir("F:/AppServ/www/PHPTest");
echo "该目录标识为:".$dir->handle;
echo "
";
echo "该目录的路径为:".$dir->path;
echo "
";
echo "该目录所有子目录及文件名如下:";
while ($read=$dir->read())
echo $read."
";
$dir->rewind();
$dir->close();
?>
//dirname函数——返回目录名
<?php
echo dirname("F:/AppServ/www/PHPTest");
?>
//disk_free_space函数——返回磁盘分区可用字节数
<?php
echo disk_free_space("c:/");
?>
//disk_total_space函数——返回磁盘分区总共字节数
<?php
echo disk_total_space("/");
?>
//fclose函数——关闭文件
<?php
$fp=fopen("F:/AppServ/www/PHPTest/gmy.php", "r+");
fclose($fp);
?>
//feof函数——判断指针是否指向文件末尾
<?php
$fp=fopen("F:/AppServ/www/PHPTest/gmy.php", "r+");
fseek($fp, 3);
if(feof($fp)){
echo "文件指针未指向文件尾";
}else{
echo "文件指针已指向文件尾";
}
?>
//fgetc函数——获取文件指针处的字符
<?php
$fp=fopen("F:/AppServ/www/PHPTest/gmy.php", "r+");
fseek($fp, 3);
echo fgetc($fp);
?>
//fgetcsv函数——解析读入的行并找出CSV格式的字段
<?php
$row=1;
$handle=fopen("test.csv", "r");
while ($date=fgetcsv($handle,1000,",")){
$num=count($date);
print "

$num 在第$row 行有$num 个CVS字段:
/n";
$row++;
for($c=0;$c<$num;$c++){
print $date[$c]."
";
}
}
fclose($handle);
?>
//fgets函数——获取文件指针所在行指定长度的内容
<?php
$handle=fopen("test.txt", "r");
while (!feof($handle)){
$buffer=fgets($handle,2048);
echo $buffer;
}
fclose($handle);
?>
//fgetss函数——获取指定长度内容并去掉标记
<?php
$handle=fopen("test.txt", "r");
while (!feof($handle)){
$buffer=fgetss($handle,2048);
echo $buffer;
}
fclose($handle);
?>
//file_exists函数——判断目录或文件是否存在
<?php
echo file_exists("test.txt");
?>
//file_get_contents函数——将文件内容读入一个字符串
<?php
echo file_get_contents("test.txt");
?>
//file_put_contents函数——将指定字符串写入文件
<?php
$str="gmy";
echo file_put_contents("test.txt", $str);
?>
//file函数——读取文件内容并保存到数组中
<?php
$array=file("test.txt");
print_r($array);
?>
//fileatime函数——返回文件上次被访问的时间
<?php
$filename="test.txt";
echo "$filename was last accessed".date("Y-m-d H:i:s.",fileatime($filename));
?>
//filectime函数——返回文件上次inode被修改的时间
<?php
$filename="test.txt";
echo "$filename was last accessed".date("Y-m-d H:i:s.",filectime($filename));
?>
//filegroup函数——返回文件所属组ID
<?php
echo filegroup("test.txt");
?>
//fileinode函数——返回文件的inode节点号
<?php
echo fileinode("test.txt");
?>
//filemtime函数——返回文件上次被修改的时间
<?php
$filename="test.txt";
echo "$filename 上次被修改的时间为".date("Y-m-d H:i:s.",filemtime($filename));
?>
//fileowner函数——返回文件拥有者的ID
<?php
echo fileowner("gmy.php");
?>
//fileperms函数——返回文件的访问权限
<?php
echo fileperms("test.txt");
?>
//filesize函数——返回指定文件字节数
<?php
echo filesize("test.txt");
?>
//filetype函数——返回指定文件类型
<?php
echo filetype("test.txt");
?>
//flock函数——锁定文件
<?php
$fp=fopen("test.txt", "w+");
if(flock($fp, LOCK_EX)){
fwrite($fp, "something here/n");
flock($fp, LOCK_UN);
}else{
echo "不能锁定该文件";
}
fclose($fp);
?>ss
//fnmatch函数——判断字符串是否与通配符匹配
<?php
$str="gmy";
if (fnmatch("gmy*", $str)){
echo "匹配";
}
?>
//fopen函数——打开文件
<?php
$fp=fopen("test.txt", "r");
?>
//fpassthru函数——读取指针当前位置到文件结束内容
<?php
$imgname="test.txt";
$fp=fopen($imgname, "rb");
header("Content-Type:image/txt");
header("Content-Length:".filesize($imgname));
fpassthru($fp);
exit;
?>
//fread函数——从文件中读取指定长度的数据
<?php
$filename="test.txt";
$handle=fopen($filename, "r");
$content=fread($handle, filesize($filename));
echo $content;
fclose($handle);
?>
//fscanf函数——根据指定参数读取文件内容
<?php
$handle=fopen("test.txt", "r");
while ($info=fscanf($handle, "%s/t%s/t%s/n")){
list($first,$second,$third)=$info;
print_r($info)."
";
}
fclose($handle);
?>
//fseek函数——设置文件指针的位置
<?php
$fp=fopen("test.txt", "r");
$data=fgets($fp,4096);
fseek($fp, 0);
?>
//fstat函数——获取打开文件的统计信息
<?php
$fp=fopen("test.txt", "r");
$array=fstat($fp);
print_r($array);
?>
//ftell函数——返回文件的指针位置
<?php
$fp=fopen("test.txt", "r");
$data=fgets($fp,12);
echo ftell($fp);
fclose($fp);
?>
//ftruncate函数——根据文件尺寸进行截取
<?php
$fp=fopen("test.txt", "r");
$str="gmy";
if(fwrite($fp, 1024)){
echo "成功";
}else{
echo "失败";
}
?>
//fwrite函数——将字符串写入文件
<?php
$fp=fopen("test.txt", "r");
$str="gmy";
if(fwrite($fp, $str)){
echo "成功";
}else{
echo "失败";
}
?>
//getcwd函数——返回当前工作目录
<?php
echo getcwd();
?>
//glob函数——将字符串写入文件中
<?php
foreach (glob("*.txt") as $filename){
echo "$filename/n";
}
?>
//is_dir函数——判断目录是否存在
<?php
if(is_dir("PHPTest")){
echo "目录";
}else{
echo "不是目录";
}
?>
//is_executable函数——判断文件是否为可执行文件
<?php
if(is_executable("test.txt")){
echo "是可执行";
}else{
echo "不是可执行";
}
?>
//is_file函数——判断文件是否存在
<?php
if(is_file("test.txt")){
echo "合法文件";
}else{
echo "不合法文件";
}
?>
//is_link函数——判断文件是否为一个符号链接
<?php
if(is_link("test.txt")){
echo "是符号连接";
}else{
echo "不是符号连接";
}
?>
//is_readable函数——判断文件是否可读
<?php
if(is_readable("test.txt")){
echo "是可读";
}else{
echo "不是可读";
}
?>
//is_uploaded_file函数——判断是否为上传文件
<?php
$filename=$_POST["filename"];
if(is_uploaded_file($filename)){
echo "是POST上传";
}else{
echo "不是POST上传";
}
?>
//is_writable函数——判断文件是否可写
<?php
if(is_writable("test.txt")){
echo "可写";
}else{
echo "不可写";
}
?>
//mkdir函数——创建新目录
<?php
if(mkdir("test")){
echo "创建成功";
}else{
echo "创建失败";
}
?>
//move_uploaded_file函数——实现文件上传
<?php
if(!is_dir("test")){
mkdir("test");
}
if(move_uploaded_file("test.txt", "test.txt")){
echo "成功";
}else{
echo "失败";
}
?>
//opendir函数——打开目录
<?php
$handle=opendir("test");
while ($filename=readdir($handle)){
echo $filename;
}
?>
//parse_ini_file函数——解析ini文件
<?php
$array=parse_ini_file("test.ini");
print_r($array);
?>
//pathinfo函数——返回文件相关信息
<?php
$array=pathinfo("test.txt");
print_r($array);
?>
//pclose函数——关闭由popen()函数打开的文件指针
<?php
$fp=popen("test.txt");
pclose($fp);
?>
//popen函数——打开一个指向进程的管道
<?php
$fp=popen("test.txt");
pclose($fp);
?>
//readdir函数——读取目录指针所指的文件
<?php
$handle=opendir("test");
while($filename=readdir($handle)){
echo $filename;
}
?>
//readfile函数——读取文件内容并写入输出缓冲
<?php
$i=readfile("gmy.php");
echo "
";
echo $i;
?>
//realpath函数——返回绝对路径
<?php
$path=realpath("gmy.php");
echo $path;
?>
//rename函数——为指定文件重命名
<?php
rename("test.ini", "gmy.txt");
?>
//rewind函数——将文件指针指向文件起始位置
<?php
$handle=fopen("gmy.txt", "r");
while (!feof($handle)){
$buffer=fgets($handle,4096);
echo $buffer;
}
rewind($handle);
fclose($handle);
?>
//rewinddir函数——将目录指针移到顶端
<?php
$handle=opendir("test");
while ($filename=readdir($handle)){
echo $filename;
}
rewinddir($handle);
?>
//rmdir函数——删除指定目录
<?php
if(rmdir("test")){
echo "成功";
}else{
echo "失败";
}
?>
//scandir函数——返回目录中文件和目录组成的数组
<?php
$files=scandir("/",1);
print_r($files);
?>
//tempnam函数——在指定目录中建立文件
<?php
$tmpfname=tempnam("/", "FOO");
$handle=fopen($tmpfname,"w");
fwrite($handle, "gmy");
fclose($handle);
unlink($tmpfname);
?>
//tmpfile函数——以写模式建立临时文件并返回标识
<?php
$temp=tmpfile();
fwrite($temp, "gmy");
fclose($temp);
?>
//touch函数——将文件的访问和修改时间设为指定时间
<?php
if(touch("test.txt")){
echo "成功";
}else{
echo "失败";
}
?>
//unlink函数——删除指定文件
<?php
unlink("gmy.php");
?>
/**DOM函数库*/
//DOMAttr函数——向节点中添加属性
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$soft = $dom->appendChild(new DOMElement("gmy"));
$book = $soft->appendChild(new DOMAttr('book', 'php'));
echo $dom->saveXML();
?>
//DOMCharacterData函数——向XML节点中的文本追加字符串
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$soft = $dom->appendChild(new DOMElement("soft"));
$book = $soft->appendChild(new DOMElement("book"));
$book->appendChild(new DOMComment('book list'));
$book->setAttributeNode(new DOMAttr('book', 'php'));
$txtCont = $dom->createTextNode('php');
$txtCont->appendData(' manual.exe');
$txtCont->insertData(10,'.chm');
$txtCont->deleteData(14, 4);
$txtCont->replaceData(3,1,'_');
$txt1 = $txtCont->substringData(0, 10);
$txtCont = $dom->createTextNode($txt1);
$book->appendChild($txtCont);
echo $dom->saveXML();
?>
//DOMComment函数——向XML中添加注释
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$soft = $dom->appendChild(new DOMElement("soft"));
$book = $soft->appendChild(new DOMElement("book"));
$book->appendChild(new DOMComment('book list'));
$book->setAttributeNode(new DOMAttr('book', 'php'));
echo $dom->saveXML();
?>
//DOMDocument函数——创建XML文档
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$book = $dom->createElement('soft');
$dom->appendChild($book);
$phpbook = $dom->createElement('phpbook');
$bookname = $dom->createElementNS('my.oschina.net', 'php_book', 'php_manual');
$phpbook->appendChild($bookname);
$book->appendChild($phpbook);
echo $dom->saveXML();
?>
//DOMDocumentType函数——为XML所定义的实体提供接口
//DOMDocumentType
publicId 外部子集的公共标识符
systemId 外部子集的系统标识符
name DTD的名称
entities 一个DOMNamedNodeMap对象
notations 一个DOMNamedNodeMap对象
internalSubset 字符串形式的内部子集
//DOMElement函数——获取或设置文档元素属性值
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$soft = $dom->createElement('soft');
$dom->appendChild($soft);
$book = $soft->appendChild(new DOMElement('book'));
$phpbook = $book->appendChild(new DOMElement('php1'));
$phpbook->setAttribute('name','php_manual');
$phpbook2 = $book->appendChild(new DOMElement('php2'));
$phpbook2->setAttribute('name','program_dictionary');
if(!$phpbook->hasAttribute('name')){
}else{
$phpbook->removeAttribute('name');
}
echo $dom->saveXML();
?>
//DOMEntity函数——表示一个已知的实体
//DOMEntity
publicId 公共标识符
systemId 系统标识符
notationName 实体记号的名称
actualEncoding 属性声明编码
encoding 实体编码
version 属性说明
//DOMEntityReference函数——建立一个新的DOMEntityReference对象
//构造一个新的DOMEntityReference对象
//DOMException函数——DOM引发的异常
//DOMException
code 一个整数值
//DOMImplementation函数——可执行独立于任何文档对象模型的实例操作
<?php
DOMImplementation->_construct();
?>
//DOMNode函数——表示文档树中一个节点
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$soft = $dom->appendChild(new DOMElement('soft'));
$book = $dom->createElement('book');
$phpbook = $book->cloneNode();
$phpbook->setAttribute('php','manual');
$soft->appendChild($book);
$book->appendChild($phpbook);
echo $dom->saveXML();
?>
//DOMNodeList函数——代表一个有顺序的节点列表
<?php
$dom = new DOMDocument('1.0', 'utf-8');
$soft = $dom->appendChild(new DOMElement('soft'));
$book = $dom->createElement('book');
$phpbook = $book->cloneNode();
$phpbook->setAttribute('php','manual');
$soft->appendChild($book);
$book->appendChild($phpbook);
$items = $dom->getElementsByTagName('book');
$items->item(0)->appendChild($dom->createTextNode('book is the best!'));
echo $dom->saveXML();
?>
//DOMNotation函数——DOMNode的子类
//DOMNotation
publicId 公共id
systemId 系统id
//DOMProcessingInstruction函数——处理指令
//DOMProcessingInstruction
target 目标
data 数据
//DOMText函数——元素或属性的文本内容
//DOMText
wholeText 整个文本
//DOMXPath函数——进行XML的文档解析
<?php
DOMXPath->_construct;
?>
/**FTP文件传输函数库*/
//ftp_alloc函数——为上传文件在FTP服务器上分配空间
<?php
$file = 'index.php';
$link = ftp_connect('127.0.0.1');
$login_result = ftp_login($link, 'gmy', 'soft');
if(ftp_alloc($link, filesize($file), $result)){
echo "为文件分配空间成功,成功上传 $file.
";
ftp_put($link, 'F:/AppServ/www/PHPTest', $file, FTP_BINARY);
}else{
echo "分配空间失败,返回信息: $result
";
}
ftp_close($link);
?>
//ftp_cdup函数——在FTP服务器上切换到上级目录
<?php
$link = ftp_connect('127.0.0.1');
$login_result = ftp_login($link, 'gmy', 'soft');
ftp_chdir($link, 'myfile');
echo "当前目录为".ftp_pwd($link);
if(ftp_cdup($link)){
echo "上级目录成功";
}else{
echo "上级目录失败";
}
echo "目录名称为".ftp_pwd($link);
ftp_close($link);
?>
//ftp_chdir函数——在FTP服务器上切换目录
<?php
$link = ftp_connect('127.0.0.1');
$login_result = ftp_login($link, 'gmy', 'soft');
ftp_chdir($link, 'myfile');
echo "当前目录为".ftp_pwd($link);
ftp_close($link);
?>
//ftp_chmod函数——在FTP服务器上改变文件属性
<?php
$file = 'index.php';
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy','soft');
if(ftp_chmod($link, 0644, $file)!==false){
echo "$file 更改属性644成功";
}else{
echo "不能更改属性";
}
ftp_close($link);
?>
//ftp_close函数——关闭FTP的连接并释放资源
<?php
$file = 'index.php';
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy','soft');
ftp_chdir($link, 'myfile');
ftp_close($link);
echo ftp_pwd($link);
?>
//ftp_connect函数——建立一个新的FTP连接
<?php
$ftp_server = "127.0.0.1";
$link = ftp_connect($ftp_server) or die("不能连接FTP服务器");
if($link){
echo "连接FTP服务器成功";
}
ftp_close($link);
?>
//ftp_delete函数——删除FTP服务器上的文件
<?php
$link = "127.0.0.1";
$login_result = ftp_login($link, 'gmy', 'soft');
ftp_chdir($link, 'myfile');
if(ftp_delete($link, 'index.php')){
echo "删除成功";
}else{
echo "删除失败";
}
ftp_close($link);
?>
//ftp_exec函数——运行FTP命令
<?php
$com = 'ls -al';
$link = "127.0.0.1";
$login_result = ftp_login($link, 'gmy', 'soft');
ftp_chdir($link, 'myfile');
if(ftp_exec($link, $com)){
echo "运行成功";
}else{
echo "运行失败";
}
ftp_close($link);
?>
//ftp_fget函数——下载FTP服务器上的文件内容
<?php
$fp = fopen("gmy.txt", 'w');
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
if(ftp_fget($link, $fp,$file,FTP_BINARY)){
echo "下载成功";
}else{
echo "下载失败";
}
ftp_close($link);
?>
//ftp_fput函数——上传文件到FTP服务器
<?php
$fp = fopen("gmy.txt", 'r');
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
if(ftp_fput($link, $file, $fp,FTP_BINARY)){
echo "上传成功";
}else{
echo "上传失败";
}
ftp_close($link);
?>
//ftp_get_option函数——返回各种不同的选项设置
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$timeout = ftp_get_option($conn_id, FTP_TIMEOUT_SEC);
echo "当前设定的网络操作的超时时间是 $timeout";
ftp_close($link);
?>
//ftp_get函数——下载FTP服务器上的文件
<?php
$down = "index.php";
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
if(ftp_get($link, $down, $file, FTP_BINARY)){
echo "下载成功";
}else{
echo "下载失败";
}
ftp_close($link);
?>
//ftp_login函数——登录FTP服务器
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
if($login_result){
echo "登录成功";
}else{
echo "登录失败";
}
ftp_close($link);
?>
//ftp_mdtm函数——检查文件最后修改时间
<?php
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$result = ftp_mdtm($link, $file);
if($result == -1){
echo "查询失败";
}else{
echo $file."的最后修改时间:".date('Y-m-d H:i:s',$result);
}
ftp_close($link);
?>
//ftp_mkdir函数——在FTP服务器上建立新目录
<?php
$dirname = "test";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$result = ftp_mkdir($link, $dirname);
if($result){
echo "建立成功";
}else{
echo "建立失败";
}
ftp_close($link);
?>
//ftp_nb_continue函数——以不分块的方式发送文件
//不分块连续发送一个文件
//ftp_nb_fget函数——异步下载文件到本地文件中
<?php
$fp = fopen("index.php", "w");
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$ret = ftp_nb_fget($link, $fp, $file, FTP_BINARY);
if($ret == FTP_MOREDATA){
echo "传输中
";
$ret = ftp_nb_continue($link);
}
if($ret == FTP_FINISHED){
echo "传输完成
";
}
if($ret == FTP_FAILED){
echo "传输失败";
}
ftp_close($link);
?>
//ftp_nb_fput函数——异步上传文件到FTP服务器
<?php
$fp = fopen("index.php", "w");
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$ret = ftp_nb_fput($link, $fp, $file, FTP_BINARY);
if($ret == FTP_MOREDATA){
echo "传输中
";
$ret = ftp_nb_continue($link);
}
if($ret == FTP_FINISHED){
echo "传输完成
";
}
if($ret == FTP_FAILED){
echo "传输失败";
}
ftp_close($link);
?>
//ftp_nb_get函数——异步下载FTP服务器上的文件
<?php
$down = "index.php";
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$ret = ftp_nb_get($link, $down, $file, FTP_BINARY);
if($ret == FTP_MOREDATA){
echo "传输中
";
$ret = ftp_nb_continue($link);
}
if($ret == FTP_FINISHED){
echo "传输完成
";
}
if($ret == FTP_FAILED){
echo "传输失败";
}
ftp_close($link);
?>
//ftp_nb_put函数——异步上传文件到FTP服务器
<?php
$down = "index.php";
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
$ret = ftp_nb_put($link, $down, $file, FTP_BINARY);
if($ret == FTP_MOREDATA){
echo "传输中
";
$ret = ftp_nb_continue($link);
}
if($ret == FTP_FINISHED){
echo "传输完成
";
}
if($ret == FTP_FAILED){
echo "传输失败";
}
ftp_close($link);
?>
//ftp_nlist函数——返回给定目录的文件列表
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$result = ftp_nlist($link, "soft");
print_r($result);
ftp_close($link);
?>
//ftp_pasv函数——返回当前FTP被动模式是否打开
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$result = ftp_pasv($link, "soft");
ftp_close($link);
?>
//ftp_put函数——将本地文件上传到FTP服务器
<?php
$up = "index.php";
$file = "index.php";
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
if(ftp_put($link, $file, $up, FTP_BINARY)){
echo "上传成功";
}else{
echo "上传失败";
}
ftp_close($link);
?>
//ftp_pwd函数——返回当前目录名
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, 'gmy', 'soft');
ftp_chdir($link, "soft");
echo "当前目录名称为".ftp_pwd($link);
ftp_close($link);
?>
//ftp_raw函数——向FTP服务器发送任意命令
<?php
$link = ftp_connect("127.0.0.1");
$fp = fopen("index.php", "r");
ftp_raw($fp, "soft");
ftp_raw($fp, "gmy");
ftp_chdir($link, "gmy");
echo "当前目录名称为".ftp_pwd($link);
ftp_close($link);
?>
//ftp_rawlist函数——返回目录下文件详细列表
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$result = ftp_rawlist($link, "soft");
print_r($result);
ftp_close($link);
?>
//ftp_rename函数——将FTP服务器上的文件或目录改名
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$rename1 = ftp_rename($link, "gmy", "life");
if($rename1){
echo "更改目录成功";
}else{
echo "更改目录失败";
}
$rename2 = ftp_rename($link, "index.php", "index1.php");
if($rename2){
echo "更改文件名成功";
}else{
echo "更改文件名失败";
}
ftp_close($link);
?>
//ftp_rmdir函数——删除FTP服务器上的目录
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$result = ftp_rmdir($link, "life");
if($result){
echo "删除目录成功";
}else{
echo "删除目录失败";
}
$result = ftp_rmdir($link, "soft");
ftp_close($link);
?>
//ftp_set_option函数——控制FTP流的各种运行时选项
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
ftp_set_option($link, FTP_TIMEOUT_SEC,300);
$timeout = ftp_get_option($link, FTP_TIMEOUT_SEC);
echo "当前FTP服务器网络超时".$timeout;
ftp_close($link);
?>
//ftp_site函数——向FTP服务器发送命令
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
if(ftp_site($link, 'CHMOD 0600 /file')){
echo "属性设置成功";
}else{
die("设置失败");
}
ftp_close($link);
?>
//ftp_size函数——返回远程文件大小
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$res = ftp_size($link, "index.php");
if($res != -1){
echo "index.php的大小是$res 字节";
}else{
echo "不能获取文件大小";
}
ftp_close($link);
?>
//ftp_ssl_connect函数——建立安全的SSL-FTP连接
<?php
$ftp_server = "127.0.0.1";
$link = ftp_ssl_connect($ftp_server) or die("不能连接FTP服务器");
if($link){
echo "连接FTP服务器成功";
}
ftp_close($link);
?>
//ftp_systype函数——返回远程服务器的系统类型
<?php
$link = ftp_connect("127.0.0.1");
$login_result = ftp_login($link, "gmy", "soft");
$type = ftp_systype($link);
echo "FTP服务器的操作系统是$type";
ftp_close($link);
?>
/**HTTP相关函数库*/
//header函数——发送HTTP头部信息
<?php
header("WWW-Authenticate:Negotiate");
header("WWW-Authenticate:NTML",false);
header("Location:http://www.baidu.com");
header('Content-type:application/pdf');
?>
//headers_list函数——列出浏览器的标头信息
<?php
setcookie('php','HTTP函数');
header('Content-type: text/plain');
var_dump(headers_list());
?>
//headers_sent函数——判断是否发送了HTTP标头信息
<?php
if(!headers_sent()){
header('Location:http://www.baidu.com');
exit;
}
?>
//setcookie函数——在客户端设置cookie的值
<?php
setcookie('php','编程');
?>
/**图像函数库*/
//exif_imagetype函数——判断图像的类型
<?php
if(exif_imagetype('gmy.gif')!=IMAGETYPE_GIF){
echo "不是GIF格式";
}
?>
//getimagesize函数——获取图像信息
<?php
$imgfile = 'gmy.gif';
$size = getimagesize($imgfile);
echo "大小为".$size;
?>
//imagearc函数——绘制椭圆弧
<?php
$img = imagecreate(200, 200);
$bg = imagecolorallocate($img, 212,135,20);
$white = imagecolorallocate($img, 255,255,255);
imagearc($img, 100,100,150,150,0,360,$white);
header("Content-type:image/png");
imagepng($img);
imagedestroy($img);
?>
//imagechar函数——水平绘制一个字符
<?php
header("content-type:image/jpeg");
$im = imagecreatefromjpeg("gmy.jpg");
$textcolor = imagecolorallocate($img, 255,0,0);
$str = "Flower";
imagechar($im, 72,20,50,$str,$textcolor);
imagejpeg($im);
imagedestroy($im);
?>
//imagecharup函数——垂直地绘制一个字符
<?php
header("content-type:image/jpeg");
$im = imagecreatefromjpeg("gmy.jpg");
$textcolor = imagecolorallocate($img, 255,0,0);
$str = "Flower";
imagecharup($im, 72,20,50,$str,$textcolor);
imagejpeg($im);
imagedestroy($im);
?>
//imagecolorallocate函数——设置图像颜色
<?php
$im = imagecreate(300, 40);
$white = imagecolorallocate($im, 159,225,106);
imagegif($im);
?>
//imagecreate函数——建立一个新图像
<?php
$im = imagecreate(260,200);
$bg = imagecolorallocate($im, 205,50,199);
$green = imagecolorallocate($im, 25,80,25);
$darkgreen = imagecolorallocate($im, 0,225,205);
$blue = imagecolorallocate($im, 10,180,200);
$darkblue = imagecolorallocate($im, 10,180,200);
$red = imagecolorallocate($im, 255,0,0);
$darkred = imagecolorallocate($im, 202,10,0);
for($i=110;$i>100;$i--){
imagefilledarc($im, 130,$i,150,100,0,95,$darkgreen,IMG_ARC_PIE);
imagefilledarc($im, 130,$i,150,100,95,125,$darkblue,IMG_ARC_PIE);
imagefilledarc($im, 130,$i,150,100,125,360,$darkred,IMG_ARC_PIE);
}
imagefilledarc($im, 130,100,150,100,0,95,$green,IMG_ARC_PIE);
imagefilledarc($im, 130,100,150,100,95,125,$blue,IMG_ARC_PIE);
imagefilledarc($im, 130,100,150,100,125,360,$red,IMG_ARC_PIE);
header("Content-type:image/png");
imagepng($im);
imagedestroy($im);
?>
//imagecreatefromgif函数——从GIF文件创建图像
<?php
$im = imagecreatefromgif("gmy.gif");
imagegif($im);
?>
//imagecreatefromjpeg函数——从JPEG文件创建图像
<?php
$im = imagecreatefromjpeg("gmy.jpg");
imagegif($im);
?>
//imagecreatefrompng函数——从PNG文件创建图像
<?php
$im = imagecreatefrompng("gmy.jpg");
imagegif($im);
?>
//imagecreatetruecolor函数——新建真彩色图像
<?php
header("content-type:image/gif");
$values = array(60,120,120,120,140,60,160,120,220,120,170,160,190,220,140,180,90,220,110,160,60,120);
$image = imagecreatetruecolor(300, 300);
$bg = imagecolorallocate($image, 207,225,29);
$plane = imagecolorallocate($image, 255,0,0);
imagefilledpolygon($image, $values,10,$plane);
imagegif($image);
imagedestroy($image);
?>
//imagedestroy函数——销毁图像
<?php
$image = imagecreate(100,100);
$color = imagecolorallocate($image, 255,0,255);
imagefill($image, 100,100,$color);
imagepng($image);
imagedestroy($image);
?>
//imageellipse函数——绘制一个椭圆图形
<?php
$image = imagecreatefromjpeg("gmy.jpg");
$color = imagecolorallocate($image, 255,255,255);
imageellipse($image, 135,75,260,140, $color);
imagepng($image);
?>
//imagefill函数——区域填充
<?php
$image = imagecreate(300, 200);
$color = imagecolorallocate($image, 10,120,140);
imagefill($image, 100,100, $color);
imagepng($image);
imagedestroy($image);
?>
//imagefilledarc函数——绘制椭圆弧且填充
<?php
$image = imagecreate(300, 200);
$color = imagecolorallocate($image,255,120,140);
imagefilledarc($image, 130,3,150,100,95,125,$color,IMG_ARC_PIE);
imagepng($image);
imagedestroy($image);
?>
//imagefilledellipse函数——绘制椭圆图形并填充
<?php
$image = imagecreatefromjpeg("gmy.jpg");
$bg = imagecolorallocate($image, 0,0,0);
$col_ellipse = imagecolorallocate($image, 255,155,10);
imagefilledellipse($image, 40,100,55,55,$col_ellipse);
imagefilledellipse($image, 120,100,85,85,$col_ellipse);
header("Content-type:image/png");
imagepng($image);
?>
//imagefilledpolygon函数——绘制多边形并填充
<?php
header("content-type:image/gif");
$values = array(60,120,120,120,140,60,160,120,220,120,170,160,190,220,140,180,90,220,110,160,60,120);
$image = imagecreatetruecolor(300, 300);
$bg = imagecolorallocate($image, 207,225,29);
$plane = imagecolorallocate($image, 255,0,0);
imagefilledpolygon($image, $values,10,$plane);
imagegif($image);
imagedestroy($image);
?>
//imagefilledrectangle函数——绘制矩形并填充
<?php
$image = imagecreatefromjpeg("gmy.jpg");
$col = imagecolorallocate($image, 255,155,10);
imagefilledrectangle($image, 30,50,360,80,$col);
header("Content-type: image/png");
imagepng($image);
?>
//imagegif函数——输出GIF格式图像
<?php
$im = imagecreatefromgif("gmy.gif");
imagegif($im);
?>
//imagejpeg函数——输出JPEG格式图像
<?php
$im = imagecreatefromjpeg("gmy.gif");
imagegif($im);
?>
//imageline函数——绘制一条线段
<?php
$im = imagecreatefromjpeg("gmy.gif");
$white = imagecolorallocate($im, 255,255,255);
imageline($im, 30,22,380,22,$white);
imagejpeg($im);
?>
//imagepng函数——输出PNG格式图像
<?php
$im = imagecreatefromjpeg("gmy.gif");
imagepng($im);
imagedestroy($im);
?>
//imagerectangle函数——绘制矩形
<?php
$im = imagecreatefromjpeg("gmy.gif");
$color = imagecolorallocate($im, 255,255,255);
imagerectangle($im, 50,10,360,35, $color);
imagejpeg($im);
imagedestroy($im);
?>
//imagerotate函数——旋转图像
<?php
header("Content-type:image/jpeg");
$angle = 180;
$source = imagecreatefromjpeg("gmy.jpg");
$im = imagerotate($source, $angle, 0);
imagejpeg($im);
?>
//imagesetpixel函数——绘制像素点
<?php
$im = imagecreatefromjpeg("gmy.jpg");
$color = imagecolorallocate($im, 255,255,255);
imagesetpixel($im, 100,80,$color);
imagesetpixel($im, 100,81,$color);
imagesetpixel($im, 100,82,$color);
imagesetpixel($im, 100,83,$color);
imagesetpixel($im, 100,84,$color);
imagejpeg($im);
?>
//imagesetstyle函数——设定画线风格
<?php
$im = imagecreatefromjpeg("gmy.jpg");
$color = imagecolorallocate($im, 255,255,0);
$red = imagecolorallocate($im, 255,0,0);
$style = array($red,$color,$red,$color,$red,$color,$red,$color,$red,$color);
imagesetstyle($im, $style);
imageline($im, 190,10,190,190,IMG_COLOR_STYLED);
imagejpeg($im);
imagedestroy($im);
?>
//imagesetthickness函数——设定画线的宽度
<?php
$im = imagecreatefromjpeg("gmy.jpg");
$color = imagecolorallocate($im, 255,255,0);
$red = imagecolorallocate($im, 255,0,0);
$style = array($red,$color,$red,$color,$red,$color,$red,$color,$red,$color);
imagesetthickness($im, 5);
imagesetstyle($im, $style);
imageline($im, 190,10,190,190,IMG_COLOR_STYLED);
imagejpeg($im);
imagedestroy($im);
?>
//imagestring函数——水平绘制字符串
<?php
header("Content-type:image/png");
$im = imagecreatefromjpeg("gmy.jpg");
$bg = imagecolorallocate($im, 255,255,255);
$green = imagecolorallocate($im, 0,255,0);
imagestring($im, 5,0,0, "I Like PHP", $green);
imagepng($im);
imagedestroy($im);
?>
//imagestringup函数——垂直绘制字符串
<?php
header("Content-type:image/png");
$im = imagecreate(200, 300);
$bg = imagecolorallocate($im, 255,255,255);
$red = imagecolorallocate($im, 255,0,0);
imagestring($im, 5,0,0, "I Like PHP", $red);
imagepng($im);
imagedestroy($im);
?>
//imagesx函数——获取图像宽度
<?php
$im = imagecreatetruecolor(300, 500);
echo imagesx($im);
?>
//imagesy函数——获取图像高度
<?php
$im = imagecreatetruecolor(300, 500);
echo imagesy($im);
?>
//imagettftext函数——向图像中绘制字符串
<?php
header("content-type:image/png");
$img = imagecreate(350, 80);
$white = imagecolorallocate($img, 7,108,246);
$grey = imagecolorallocate($img, 255,255,255);
$red =imagecolorallocate($img, 255,0,0);
imagefilledrectangle($img, 0,0,imagesx($img)-1,imagesy($img)-1,$white);
$text = iconv("gb2312", "utf-8", "I Like PHP");
$font = "Fonts/FZHCJW.TTF";
imagettftext($img, 23,0,15,40,$grey,$font,$text);
imagestring($img, 5,75,50,"www.baidu.com",$red);
imagepng($img);
imagedestroy($img);
?>
//imagecopyresampled函数——将图像重新采样
<?php
$filename = "gmy.jpg";
$percent = 0.5;
header("Content-type:image/jpeg");
list($width,$height) = getimagesize($filename);
$new_width = $width * $percent;
$new_height = $height * $percent;
$image_p = imagecreatetruecolor($new_width, $new_height);
$image = imagecreatefromjpeg($filename);
imagecopyresampled($image_p,$image,0,0,0,0,$new_width,$new_height,$width,$height);
imagejpeg($image_p,null,100);
?>
/**mail函数库*/
//ezmlm_hash函数——计算邮件列表的散列值
<?php
$conn = mysql_connect("localhost","root","root");
mysql_select_db("java",$conn);
mysql_query("set name gb2312");
$user = "136697122@qq.com";
$hash = ezmlm_hash($user);
mysql_query("insert into users(hash,user)values ('$hash','$user')",$conn);
?>
//mail函数——发送邮件
<?php
if(@mail("136697122@qq.com", "邮件主题", "邮件内容")){
echo "邮件发送成功";
}else{
echo "邮件发送失败";
}
?>
/**数学函数库*/
//abs函数——返回参数的绝对值
<?php
echo abs(-8)."
";
echo abs(8)."
";
echo abs(-8.8);
?>
//acos函数——返回参数的反余弦值
<?php
echo acos(1/4)."
";
echo acos(3/4)."
";
echo acos(1/3);
?>
//asin函数——返回参数的反正弦值
<?php
echo asin(1/4)."
";
echo asin(3/4)."
";
echo asin(1/3);
?>
//atan2函数——计算两个变量的反正切值
<?php
echo atan2(1/4,1/2)."
";
echo atan2(3/4,1/3)."
";
echo atan2(1/3,1/4);
?>
//atan函数——返回参数的反正切值
<?php
echo atan(1/4)."
";
echo atan(3/4)."
";
echo atan(1/3);
?>
//base_convert函数——任意进制之间的数字转换
<?php
$number="123456";
$number2 = base_convert($number, 10, 2);
echo "十进制$number ,二进制$number2";
?>
//bindec函数——将二进制数字转换成十进制的整数
<?php
echo bindec("1111");
?>
//ceil函数——返回不小于参数值的最小整数
<?php
echo ceil(4);
echo ceil(4.2);
echo ceil(5.9);
?>
//cos函数——返回参数的余弦值
<?php
echo cos(M_PI)."
";
echo cos(90)."
";
echo cos(pi())."
";
?>
//cosh函数——返回参数的双曲余弦值
<?php
echo cosh(20)."
";
echo cosh(pi())."
";
?>
//decbin函数——将十进制转换为二进制
<?php
echo decbin("4294967295");
?>
//dechex函数——将十进制转换为十六进制
<?php
echo dechex("2147483647");
?>
//decoct函数——将十进制数字转成8进制字符串
<?php
echo decoct("2147483647");
?>
//deg2rad函数——将参数从角度转换成弧度
<?php
echo deg2rad(180);
?>
//exp函数——计算e的arg次方值
<?php
echo exp(10);
?>
//floor函数——实现舍去法取整
<?php
echo floor(6);
echo floor(7.2);
echo floor(8.9);
?>
//fmod函数——返回除法的浮点数余数
<?php
$x = 5;
$y = 1.5;
$z = fmod($x, $y);
echo $z;
?>
//getrandmax函数——获取随机数最大的可能值
<?php
rand(5, 15);
echo getrandmax();
?>
//hexdec函数——将十六进制字符串转换为十进制数
<?php
echo hexdec("7fffffff")."
";
echo hexdec("soft");
?>
//is_finite函数——判断是否为有限值
<?php
$log = log(0);
echo is_finite($log);
?>
//is_infinite函数——判断是否为无限值
<?php
echo is_infinite(log(0));
?>
//is_nan函数——判断是否为合法的数值
<?php
echo is_nan(pi());
?>
//lcg_value函数——获取一个伪随机数
<?php
echo lcg_value();
?>
//log10函数——返回以10为底的对数的值
<?php
echo log10(10);
?>
//log函数——自然对数
<?php
echo log(10,10);
?>
//max函数——返回参数中的最大值
<?php
echo max(1,2,3,4);
?>
//min函数——返回参数中的最小值
<?php
echo min(1,2,3,4);
?>
//mt_getrandmax函数——返回随机数的最大可能值
<?php
echo mt_getrandmax();
?>
//mt_rand函数——返回随机数中的一个值
<?php
echo mt_rand(20, 50);
?>
//mt_srand函数——配置随机数的种子
<?php
function make_seed(){
list($seed,$seeds) = explode('', microtime());
return (float)$seeds + ((float)$seed*100000);
}
mt_srand(make_seed());
$mt_rand = mt_rand();
echo $mt_rand;
?>
//octdec函数——将8进制转换为十进制
<?php
echo octdec("17777777777");
?>
//pi函数——返回圆周率的近似值
<?php
echo pi();
echo M_PI;
?>
//pow函数——计算次方的值
<?php
echo pow(-1, 20)."
";
echo pow(0, 0)."
";
echo pow(-1, 2.3)."
";
?>
//rad2deg函数——将弧度数转换为相应的角度数
<?php
echo rad2deg(pi());
?>
//rand函数——获取随机数
<?php
echo rand(10,50);
?>
//round函数——实现对浮点数四舍五入
<?php
echo round(1.2)."
";
echo round(1.2,4);
?>
//sin函数——获取参数的正弦值
<?php
echo sin(90)."
";
?>
//sinh函数——返回参数的双曲正弦值
<?php
echo sinh("10");
?>
//sqrt函数——返回参数的平方根
<?php
echo sqrt(5);
?>
//srand函数——配置随机数的种子
<?php
srand((double)microtime()*1000000);
$rand = rand();
echo $rand;
?>
//tan函数——返回参数的正切值
<?php
echo tan(45);
?>
//tanh函数——获取参数的双曲正切值
<?php
echo tanh("2");
?>
/**MySQL函数库*/
//mysql_affected_rows函数——获取操作所影响的行数
<?php
$link = mysql_connect("localhost","root","root");
mysql_selectdb("java");
mysql_query("delete from users where id<3");
printf("删除记录个数".mysql_affected_rows());
?>
//mysql_client_encoding函数——返回当前连接的默认字符集名称
<?php
$link = mysql_connect("localhost","root","root");
$charset = mysql_client_encoding($link);
echo "字符集$charset";
?>
//mysql_close函数——关闭MySQL连接
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
if(!$link){
die("连接失败".mysql_error());
}
echo "连接成功";
mysql_close($link);
?>
//mysql_connect函数——连接MySQL服务器
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
if(!$link){
die("连接失败".mysql_error());
}
echo "连接成功";
mysql_close($link);
?>
//mysql_create_db函数——新建一个MySQL数据库
<?php
$link = mysql_connect("localhost","root","root");
if(mysql_query("create database php")){
echo "创建成功";
}else{
echo "创建失败".mysql_error();
}
?>
//mysql_data_seek函数——将行指针移动到指定的行号
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
mysql_query("set names utf8");
$result = mysql_query("select * from users");
for($i=mysql_num_rows($result)-1;$i>=0;$i--){
if(!mysql_data_seek($result, $i)){
echo "can't seek to row $i".mysql_error()."/n";
continue;
}
if(!($row=mysql_fetch_object($result))){
continue;
}
echo "$row->id $row->name
/n";
}
mysql_free_result($result);
?>
//mysql_db_name函数——获取mysql_list_dbs()函数调用所返回的数据库名
<?php
$link = mysql_connect("localhost","root","root");
$db_list = mysql_list_dbs($link);
$i=0;
$num = mysql_num_rows($db_list);
while($i<$num){
echo mysql_db_name($db_list, $i)."
";
$i++;
}
?>
//mysql_db_query函数——发送一条MySQL查询语句
<?php
$link = mysql_connect("localhost","root","root");
$result = mysql_db_query("java", "select * from users where 1=1",$link);
if($result==true){
echo "数据检索成功";
}else{
echo "数据检索失败";
}
?>
//mysql_errno函数——返回错误信息的数字编码
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java1");
echo mysql_errno().":".mysql_error();
?>
//mysql_error函数——返回文本错误信息
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java1");
echo mysql_error();
?>
//mysql_fetch_array函数——返回从结果集生成的数组
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$result = mysql_query("select * from users");
while ($row=mysql_fetch_array($result,MYSQL_BOTH)){
printf("ID:%s NAME:%s",$row[0],$row["name"]);
echo "
";
}
mysql_free_result($result);
?>
//mysql_fetch_assoc函数——获取一行作为关联数组
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users";
$result = mysql_query($sql);
while ($row = mysql_fetch_assoc($result)){
echo $row['id'];
echo $row['name'];
}
mysql_free_result($result);
?>
//mysql_fetch_field函数——获取列信息并作为对象返回
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users";
$result = mysql_query($sql);
$i = 0;
while($i < mysql_num_fields($result)){
echo "Infromation for column $i :/n";
$meta = mysql_fetch_field($result);
if(!$meta){
echo "No information available /n";
}
echo "


name: $meta->name
table: $meta->talble
max_length: $mate->max_length
not_null: $mate->not_null
primary_key: $meta->primary_key
unique_key: $meta->unique_key
multiple_key: $meta->multiple_key
numeric: $meta->numeric
blob: $meta->blob
type: $meta->type
unsigned: $meta->unsigned
zerofill: $meta->zerofill
";
$i++;
}
mysql_free_result($result);
?>
//mysql_fetch_lengths函数——获取结果集中每个字段的长度
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users where id =3";
$result = mysql_query($sql);
print_r(mysql_fetch_row($result));
print_r(mysql_fetch_lengths($result));
mysql_close($link);
?>
//mysql_fetch_object函数——获取一行作为对象
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
while($row = mysql_fetch_object($result)){
echo $row->id;
echo $row->name;
}
mysql_free_result($result);
?>
//mysql_fetch_row函数——获取一行作为枚举数组
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
$row = mysql_fetch_row($result);
do{
printf("%s [%s]
",$row[1],$row[0]);
}while ($row=mysql_fetch_row($result));
mysql_close($link);
?>
//mysql_field_len函数——返回指定字段的长度
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
$length = mysql_field_len($result, 1);
echo $length;
mysql_close($link);
?>
//mysql_field_name函数——获取指定字段的字段名
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
echo mysql_field_name($result, 0);
echo mysql_field_name($result, 1);
?>
//mysql_field_seek函数——获取指定字段的偏移量
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
mysql_field_seek($result, 1);
$info = mysql_fetch_field($result);
printf("NAME : %s /n",$info->name."
");
printf("TABLE : %s /n",$info->table);
mysql_close($link);
?>
//mysql_field_type函数——获取指定字段的类型
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
echo mysql_field_type($result, 1);
mysql_free_result($result);
mysql_close();
?>
//mysql_free_result函数——释放结果内存
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "select * from users ";
$result = mysql_query($sql);
while ($row = mysql_fetch_array($result)){
printf("ID %s,name %s
",$row[0],$row[1]);
}
mysql_free_result($result);
?>
//mysql_get_client_info函数——返回客户端的版本
<?php
printf("版本号 %s/n",mysql_get_client_info());
?>
//mysql_get_host_info函数——获取MySQL主机信息
<?php
$link = mysql_connect("localhost","root","root");
printf("MYSQL信息 %s/n",mysql_get_host_info());
?>
//mysql_get_proto_info函数——获取MySQL协议信息
<?php
$link = mysql_connect("localhost","root","root");
printf("MYSQL协议信息 %s/n",mysql_get_proto_info());
?>
//mysql_get_server_info函数——获取MySQL服务器信息
<?php
$link = mysql_connect("localhost","root","root");
printf("MYSQL服务器信息 %s/n",mysql_get_server_info());
?>
//mysql_info函数——获取最近一条查询的信息
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "insert into users values(7,'q') ";
$result = mysql_query($sql);
$info = mysql_info($link);
echo $info;
mysql_close($link);
?>
//mysql_insert_id函数——获取INSERT操作产生的ID
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = "insert into users values(8,'f') ";
$result = mysql_query($sql);
printf("最会一条添加数据的ID号为%d",mysql_insert_id());
?>
//mysql_list_dbs函数——列出服务器中所有数据库
<?php
$link = mysql_connect("localhost","root","root");
$db_list = mysql_list_dbs($link);
while ($row = mysql_fetch_object($db_list)){
echo $row->Database."
";
}
?>
//mysql_list_fields函数——列出MySQL结果中的字段
<?php
$link = mysql_connect("localhost","root","root");
$db = mysql_list_fields("java", "users",$link);
$columns = mysql_num_fields($db);
for($i = 0;$i < $columns;$i++){
echo mysql_field_name($db, $i)."
";
}
?>
//mysql_list_tables函数——列出MySQL数据库中的表
<?php
$link = mysql_connect("localhost","root","root");
$result = mysql_list_tables("java",$link);
while ($row = mysql_fetch_row($result)){
print "$row[0]
";
}
mysql_free_result($result);
?>
//mysql_num_fields函数——返回结果集中字段的数目
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$result = mysql_query("select * from users");
$num_rows = mysql_num_fields($result);
echo "$num_rows Fileds/n";
?>
//mysql_num_rows函数——获取结果集中行的数目
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$result = mysql_query("select * from users");
$num_rows = mysql_num_rows($result);
echo "$num_rows Rows/n";
?>
//mysql_pconnect函数——持久连接到MySQL服务器
<?php
$link = mysql_pconnect("localhost","root","root");
mysql_select_db("java");
if(!$link){
die("失败".mysql_error());
}else{
echo "成功";
}
?>
//mysql_ping函数——ping一个服务器连接
<?php
$link = mysql_connect("localhost","root","root");
if(mysql_ping()){
echo "成功";
}else{
echo "失败";
}
?>
//mysql_query函数——发送一条MySQL查询
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$result = mysql_query("select * from users");
$num_rows = mysql_num_rows($result);
echo "$num_rows Rows/n";
?>
//mysql_result函数——返回结果集中一个单元的内容
<?php
$link = mysql_connect("localhost","root","root");
mysql_select_db("java");
$sql = mysql_query("select * from users");
echo mysql_result($sql, 3);
mysql_close();
?>
//mysql_select_db函数——选择MySQL数据库
<?php
$link = mysql_connect("localhost","root","root");
$db = mysql_select_db("java");
if($db){
echo "成功";
}else{
echo "失败";
}
?>
//mysql_tablename函数——获取数据表名称
<?php
$link = mysql_connect("localhost","root","root");
$result = mysql_list_tables("java");
for($i=0;$i printf("数据表名 %s",mysql_table_name($result,$i))."
";
}
mysql_free_result($result);
?>
/**MySQLi函数库*/
//mysqli_affected_rows函数——执行操作所影响的记录数
<?php
$link = mysqli_connect("localhost","root","root","java");
if (!$link){
echo "失败";
exit();
}
$result = mysqli_query($link,"delete from a");
echo "影响记录数".mysqli_affected_rows($link);
mysqli_close($link);
?>
//mysqli_autocommit函数——打开或关闭自动提交模式
<?php
$link = mysqli_connect("localhost","root","root","java");
if (!$link){
echo "失败";
exit();
}
mysqli_autocommit($link,true);
if($result = mysqli_query($link,"select * from users")){
$row = mysqli_fetch_row($result);
printf("自动提交记录数 %s",$row[0]);
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_change_user函数——更改已建立的连接
<?php
$link = mysqli_connect("localhost","root","root","java");
mysqli_query($link,"select * from users");
mysqli_change_user($link,"root","root","bank");
mysqli_query($link,"select * from admin");
mysqli_close($link);
?>
//mysqli_character_set_name函数——返回默认字符集
<?php
$link = mysqli_connect("localhost","root","root","java");
$charset = mysqli_character_set_name($link);
printf("默认字符集%s",$charset);
mysqli_close($link);
?>
//mysqli_close函数——关闭与数据库的连接
<?php
$link = mysqli_connect("localhost","root","root","java");
mysqli_close($link);
?>
//mysqli_connect_errno函数——返回连接失败的错误号
<?php
$link = mysqli_connect("localhost","root","root","java1");
if(!$link){
printf("错误号 %d",mysqli_connect_errno());
}
?>
//mysqli_connect_error函数——返回连接失败错误信息
<?php
$link = mysqli_connect("localhost","root","root","java1");
if(!$link){
printf("错误信息 %d",mysqli_connect_error($link));
}
?>
//mysqli_connect函数——建立与数据库的连接
<?php
$link = mysqli_connect("localhost","root","root","java");
mysqli_close($link);
?>
//mysqli_data_seek函数——更改记录指针的位置
<?php
$link = mysqli_connect("localhost","root","root","java");
$query = "select * from users";
if($result = mysqli_query($link,$query)){
mysqli_data_seek($result,100);
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_dump_debug_info函数——将调试信息写入日志
<?php
$link = mysqli_connect("localhost","root","root","java");
mysqli_dump_debug_info($link);
mysqli_close($link);
?>
//mysqli_errno函数——返回最后操作的错误号
<?php
$link = mysqli_connect("localhost","root","root","java");
if(!mysqli_query($link,"select * from users")){
echo mysqli_errno($link);
}
?>
//mysqli_error函数——返回最后操作的错误信息
<?php
$link = mysqli_connect("localhost","root","root","java");
if(!mysqli_query($link,"select * from users")){
echo mysqli_error($link);
}
?>
//mysqli_fetch_array函数——返回结果集组成的数组
<?php
$link = mysqli_connect("localhost","root","root","java");
$sql = 'select * from users';
$result = mysqli_query($link,$sql);
while ($info = mysqli_fetch_array($$result,MYSQL_ASSOC)){
echo $info[0]."
";
}
?>
//mysqli_fetch_assoc函数——返回结果集组成的关联数组
<?php
$link = mysqli_connect("localhost","root","root","java");
$sql = 'select * from users';
$result = mysqli_query($link,$sql);
while ($info = mysqli_fetch_assoc($result)){
echo $info['a']."
";
}
?>
//mysqli_fetch_field_direct函数——返回包含指定字段信息的对象
<?php
$link = mysqli_connect("localhost","root","root","java");
$sql = 'select * from users';
$result = mysqli_query($link,$sql);
if($result){
$finfo = mysqli_fetch_field_direct($result,1);
printf("NAME:%s
",$finfo->name);
printf("TABLE:%s
",$finfo->table);
printf("max.leng:%d
",$finfo->max_length);
printf("Flags:%d
",$finfo->flags);
printf("type:%d
",$finfo->type);
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_fetch_field函数——返回所有字段信息的对象
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
if ($result) {
while ($finfo = mysqli_fetch_field($result)) {
printf("NAME:%s
", $finfo->name);
printf("TABLE:%s
", $finfo->table);
printf("max.leng:%d
", $finfo->max_length);
printf("Flags:%d
", $finfo->flags);
printf("type:%d
", $finfo->type);
echo "
";
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_fetch_fields函数——返回某表字段的信息
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
if ($result) {
$finfo = mysqli_fetch_fields($result);
foreach ($finfo as $val){
printf("NAME:%s
", $val->name);
printf("TABLE:%s
", $val->table);
printf("max.leng:%d
", $val->max_length);
printf("Flags:%d
", $val->flags);
printf("type:%d
", $val->type);
echo "
";
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_fetch_lengths函数——返回表中所有字段长度
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
if ($result) {
$row = mysqli_fetch_row($result);
foreach (mysqli_fetch_lengths($result) as $i => $val){
printf("字段%2d 的长度为 %2/n",$i+1,$val);
echo "
";
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_fetch_object函数——返回一个字段信息对象
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
if ($result) {
while ($obj = mysqli_fetch_object($result)){
echo $obj->name;
echo "
";
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_fetch_row函数——根据获取记录生成数组
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
if ($result) {
while ($row = mysqli_fetch_row($result)){
printf("%s(%s)/n",$row[0],$row[1]);
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_field_count函数——获取最近查询返回的字段数
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
echo mysqli_field_count($link);
mysqli_close($link);
?>
//mysqli_field_seek函数——更改字段指针的位置
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
mysqli_field_seek($result,1);
$finfo = mysqli_fetch_field($result);
printf("NAME: %s/n",$finfo->name);
printf("TABLE: %s/n",$finfo->table);
printf("MAX_LENGTH: %d/n",$finfo->max_length);
printf("FLAGS: %d/n",$finfo->flags);
printf("TYPE: %d/n",$finfo->type);
mysqli_close($link);
?>
//mysqli_field_tell函数——返回当前字段指针的位置
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link, $sql);
if($result){
while ($finfo = mysqli_fetch_field($result)){
$currentfield = mysqli_field_tell($result);
printf("COLUMN: %d/n",$currentfield);
printf("NAME: %d/n",$finfo->name);
printf("TABLE: %s/n",$finfo->table);
printf("MAX_LENGTH: %d/n",$finfo->max_length);
printf("FLAGS: %d/n",$finfo->flags);
printf("TYPE: %d/n",$finfo->type);
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_free_result函数——释放记录集所占的内存
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = 'select * from users';
$result = mysqli_query($link,$sql);
while ($info = mysqli_fetch_array($result)) {
echo $info[1];
echo "
";
}
mysqli_free_result($result);
mysqli_close($link);
?>
//mysqli_get_client_info函数——返回客户端版本信息
<?php
printf("客户端信息:%s",mysqli_get_client_info());
?>
//mysqli_get_client_version函数——返回客户端版本号
<?php
printf("版本号:%s",mysqli_get_client_version());
?>
//mysqli_get_host_info函数——返回主机信息
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
printf("主机信息: %s",mysqli_get_host_info($link));
?>
//mysqli_get_proto_info函数——返回协议的版本号
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
printf("协议版本号: %d",mysqli_get_proto_info($link));
mysqli_close($link);
?>
//mysqli_get_server_info函数——返回服务端版本信息
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
printf("服务版本信息: %s",mysqli_get_server_info($link));
mysqli_close($link);
?>
//mysqli_get_server_version函数——返回服务端版本号
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
printf("服务版本号: %s",mysqli_get_server_version($link));
mysqli_close($link);
?>
//mysqli_insert_id函数——返回最近插入记录的ID号
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
mysqli_query($link,"insert into users values(9,'i')");
printf("新记录 %d",mysqli_insert_id($link));
mysqli_close($link);
?>
//mysqli_kill函数——撤销一个MySQL进程
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$thread_id = mysqli_thread_id($link);
mysqli_kill($link,$thread_id);
if(!mysqli_query($link,"select * from users")){
printf("错误 %s",mysqli_error($link));
exit;
}
mysqli_close($link);
?>
//mysqli_more_results函数——判断查询结果是否有结果集
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$sql = mysqli_query($link,"select * from users");
while($info = mysqli_fetch_array($sql)){
echo $info[1];
}
if(!mysqli_more_results($link)){
echo "没有记录可以显示";
}
mysqli_close($link);
?>
//mysqli_multi_query函数——执行查询
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
if(mysqli_multi_query($link,"select * from users")){
do{
if($result = mysqli_store_result($link)){
while ($array = mysqli_fetch_array($result)){
printf("%s/n",$array['name']);
}
}
}while (mysqli_next_result($link));
}
mysqli_close($link);
?>
//mysqli_next_result函数——获取结果集中下一条记录
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
if(mysqli_multi_query($link,"select * from users")){
do{
if($result = mysqli_store_result($link)){
while ($array = mysqli_fetch_array($result)){
printf("%s/n",$array['name']);
}
}
}while (mysqli_next_result($link));
}
mysqli_close($link);
?>
//mysqli_num_fields函数——获取查询结果中字段个数
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
if ($result = mysqli_query($link, "select * from users")){
$field_cnt = mysqli_num_fields($result);
printf("查询到字段 %d 个",$field_cnt);
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_num_rows函数——获取查询结果中记录个数
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
if ($result = mysqli_query($link, "select * from users")){
$field_cnt = mysqli_num_rows($result);
printf("查询到字段 %d 个",$field_cnt);
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_ping函数——判断连接是否可用
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
if(mysqli_ping($link)){
printf("成功");
}else{
printf("失败 %s",mysqli_error($link));
}
mysqli_close($link);
?>
//mysqli_prepare函数——预置查询
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$name = "i";
if($stmt = mysqli_prepare($link,"select id from users where name = ?")){
mysqli_stmt_bind_param($stmt, "s",$name);
mysqli_stmt_execute($stmt);
mysqli_stmt_bind_result($stmt,$id);
mysqli_stmt_fetch($stmt);
printf("%s id %s",$name,$id);
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_query函数——执行查询语句
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$result = mysqli_query($link,"select * from users",MYSQLI_USE_RESULT);
while($info = mysqli_fetch_array($result)){
echo $info[1];
}
mysqli_free_result($result);
mysqli_close($link);
?>
//mysqli_real_connect函数——建立与服务器的连接
<?php
$link = mysqli_init();
mysqli_real_connect($link,'localhost','root','root','java');
if(mysqli_connect_errno()){
printf("失败 %s",mysqli_connect_error());
exit;
}
printf("成功 %s",mysqli_get_host_info($link));
mysqli_close($link);
?>
//mysqli_real_query函数——执行查询语句
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
mysqli_real_query($link,"select * from users");
if($result = mysqli_use_result($link)){
while ($array = mysqli_fetch_array($result)){
printf("%s",$array[1]);
}
mysqli_free_result($result);
}
mysqli_close($link);
?>
//mysqli_report函数——打开或关闭错误报告
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
$result = mysqli_query($link,"select * from users");
while($info = mysqli_fetch_array($result)){
echo $info[1];
}
mysqli_close($link);
?>
//mysqli_rollback函数——实现事务回滚
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
mysqli_autocommit($link,false);
if(!mysqli_query($link,"insert into users values(11,'p')")){
mysqli_rollback($link);
}
if(!mysqli_query($link,"insert into users values(11,'p')")){
mysqli_rollback($link);
}
mysqli_commit($link);
mysqli_close($link);
?>
//mysqli_select_db函数——选择数据库
<?php
$link = mysqli_connect("localhost", "root", "root", "java");
mysqli_select_db($link,"test");
mysqli_close($link);
?>
//mysqli_sqlstate函数——返回SQLSTATE错误
<?php
$link = new mysqli("localhost", "root", "root", "java");
if(!mysqli_query($link,"create table users()")){
printf("Error -%s",mysqli_sqlstate($link));
}
mysql_close($link);
?>
//mysqli_stat函数——获取系统的当前状态
<?php
$link = new mysqli("localhost", "root", "root", "java");
mysqli_query($link,"select * from users");
printf("状态 %s",mysqli_stat($link));
mysqli_close($link);
?>
//mysqli_stmt_affected_rows函数——返回最后操作所影响的记录数
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "insert into user values(11,'y')";
if($stmt = mysqli_prepare($link,$query)){
mysqli_stmt_execute($stmt);
printf("插入记录个数 %d",mysqli_stmt_affected_rows($stmt));
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_stmt_bind_param函数——为查询语句动态提供参数
<?php
$link = new mysqli("localhost", "root", "root", "java");
$stmt = mysqli_prepare($link,"insert into users values(?,?)");
$id = 12;
$name = 'w';
mysqli_stmt_bind_param($stmt, 'ds', $id, $name);
mysqli_stmt_execute($stmt);
mysqli_stmt_close($stmt);
mysqli_close($link);
?>
//mysqli_stmt_bind_result函数——获取查询结果的返回值列表
<?php
$link = new mysqli("localhost", "root", "root", "java");
if($stmt = mysqli_prepare($link,"select * from users")){
mysqli_stmt_execute($stmt);
mysqli_stmt_bind_result($stmt,$col1,$col2);
while(mysqli_stmt_fetch($stmt)){
printf("%s %s",$col1,$col2);
echo "
";
}
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_stmt_close函数——关闭返回的查询声明
<?php
$link = new mysqli("localhost", "root", "root", "java");
if($stmt = mysqli_prepare($link,"select * from users")){
mysqli_stmt_execute($stmt);
}
mysqli_stmt_close($stmt);
mysqli_close($link);
?>
//mysqli_stmt_data_seek函数——获取查询结果的返回值列表
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "select id,name from users";
if($stmt = mysqli_prepare($link,$query)){
mysqli_stmt_execute($stmt);
mysqli_stmt_bind_result($stmt,$id,$name);
mysqli_stmt_store_result($stmt);
mysqli_stmt_data_seek($stmt,6);
mysqli_stmt_fetch($stmt);
printf("ID %d NAME %s",$id,$name);
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_stmt_execute函数——执行一条查询
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "select id,name from users";
if($stmt = mysqli_prepare($link,$query)){
mysqli_stmt_execute($stmt);
mysqli_stmt_bind_result($stmt,$id,$name);
while (mysqli_stmt_fetch($stmt)){
echo $name."-".$id."
";
}
mysqli_close($link);
}
?>
//mysqli_stmt_fetch函数——获取查询的返回值
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "select id,name from users";
if($stmt = mysqli_prepare($link,$query)){
mysqli_stmt_execute($stmt);
mysqli_stmt_bind_result($stmt,$id,$name);
while (mysqli_stmt_fetch($stmt)){
echo $name."-".$id."
";
}
mysqli_close($link);
}
?>
//mysqli_stmt_num_rows函数——返回查询记录总数
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "select id,name from users";
if($stmt = mysqli_prepare($link,$query)){
mysqli_stmt_execute($stmt);
mysqli_stmt_store_result($stmt);
printf("查询到的记录 %d",mysqli_stmt_num_rows($stmt));
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_stmt_param_count函数——返回查询语句中动态参数的个数
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "select id,name from users";
if($stmt = mysqli_prepare($link,$query)){
$marker = mysqli_stmt_param_count($stmt);
printf("动态参数 %d",$marker);
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_stmt_ prepare函数——获取查询的返回值
<?php
$link = new mysqli("localhost", "root", "root", "java");
$query = "select id,name from users";
$id = 6;
$stmt = mysqli_stmt_init($link);
if(mysqli_stmt_prepare($stmt,"select count(*) as total from users where id=?")){
mysqli_stmt_bind_param($stmt, "s",$id);
mysqli_stmt_execute($stmt);
mysqli_stmt_bind_result($stmt,$total);
mysqli_stmt_fetch($stmt);
echo "id为6的有多少个人".$total;
mysqli_stmt_close($stmt);
}
mysqli_close($link);
?>
//mysqli_stmt_result_metadata函数——获取查询结果集
<?php
$link = new mysqli("localhost", "root", "root", "java");
$stmt = mysqli_prepare($link,"select * from users");
mysqli_stmt_execute($stmt);
$result = mysqli_stmt_result_metadata($stmt);
$fields = mysqli_num_fields($result);
echo "字段".$fields."个";
mysqli_free_result($result);
mysqli_close($link);
?>
//mysqli_stmt_send_long_data函数——提交较大数据
<?php
$link = new mysqli("localhost", "root", "root", "java");
$stmt = mysqli_prepare($link,"insert into users (name)values(?)");
$null = NULL;
mysqli_stmt_bind_param($stmt, "b",$null);
$fp = fopen("message.txt", "r");
while(!feof($fp)){
mysqli_stmt_send_long_data($stmt,0,fread($fp, 8192));
}
fclose($fp);
mysqli_stmt_execute($stmt);
?>
//mysqli_store_result函数——传递最后查询的结果集
<?php
$link = new mysqli("localhost", "root", "root", "java");
if(mysqli_multi_query($link,"select * from users")){
do{
if($result = mysqli_store_result($link)){
while ($array = mysqli_fetch_array($result)){
printf("%s",$array[1]);
}
}
}while (mysqli_next_result($link));
}
mysqli_close($link);
?>
//mysqli_use_result函数——获取最近查询的结果集
<?php
$link = new mysqli("localhost", "root", "root", "java");
if(mysqli_multi_query($link,"select * from users")){
do{
if($result = mysqli_use_result($link)){
while ($row = mysqli_fetch_row($result)){
printf("%s",$row);
}
mysqli_free_result($result);
}
}while (mysqli_next_result($link));
}
mysqli_close($link);
?>
/**网络函数库*/
//closelog函数——关闭打开的系统日志
<?php
openlog('soft', LOG_PID, LOG_USER);
syslog(LOG_ERR, 'this is wrong');
closelog();
?>
//fsockopen函数——打开网络的socket连接
<?php
$fp = fsockopen("127.0.0.1",80);
if(!$fp){
echo "失败";
}else{
echo "成功";
}
fclose($fp);
?>
//gethostbyaddr函数——返回某个IP地址的机器名称
<?php
echo gethostbyaddr("127.0.0.1");
?>
//gethostbyname函数——返回某个机器名称的IP地址
<?php
echo gethostbyname("cmd");
?>
//gethostbynamel函数——返回一个机器名称的所有IP
<?php
$array = gethostbynamel("cmd");
print_r($array);
?>
//getprotobyname函数——获取协议的协议编号
<?php
$get_prot = getprotobyname("udp");
if($get_prot == false){
echo "无效";
}else{
echo "协议".$get_prot;
}
?>
//getprotobynumber函数——获取协议编号的协议名称
<?php
$get_number = getprotobynumber("6");
if($get_number == false){
echo "无效";
}else{
echo "协议:".$get_number;
}
?>
//getservbyname函数——获取参数service服务的埠号
<?php
$services = array('http','ftp','telnet','smtp','pop3','www');
foreach ($services as $service){
$port = getservbyname($service, 'tcp');
echo $service.":".$port."
";
}
?>
//getservbyport函数——获取协议名称和埠号的服务名称
<?php
$services = array('80','21','23','25','110');
foreach ($services as $service){
$port = getservbyport($service, 'tcp');
echo $service.":".$port."
";
}
?>
//ip2long函数——将IP地址转换为整数
<?php
header("Content-Type:text/html;charset=utf-8");
$ip = gethostbyname("cmd");
$integer = ip2long($ip);
if($integer == false){
echo "无线IP地址";
}else{
echo $ip."
";
echo $integer."
";
printf("%u",ip2long($ip));
}
?>
//long2ip函数——将整数形式IP地址转换为原来形式
<?php
header("Content-Type:text/html;charset=utf-8");
$address = 3231535818;
echo long2ip($address);
?>
//openlog函数——打开系统日志
<?php
header("Content-Type:text/html;charset=utf-8");
openlog('soft', LOG_PID, LOG_USER);
syslog(LOG_ERR, "this is wrong");
closelog();
?>
//pfsockopen函数——打开网络的socket持续连接
<?php
$fp = pfsockopen("127.0.0.1",80);
if(!$fp){
echo "失败";
}else{
echo "成功";
}
fclose($fp);
?>
//syslog函数——产生一个系统日志信息
<?php
openlog("soft", LOG_PID, LOG_USER);
syslog(LOG_ERR, "this is wrong");
closelog();
?>
/**ODBC函数库*/
//odbc_autocommit函数——打开或关闭数据库自动更新
//odbc_binmode函数——配置二进制资料处理方式
//odbc_close_all函数——关闭所有ODBC连接
//odbc_close函数——关闭ODBC连接
//odbc_commit函数——改动ODBC数据库并提交查询
//odbc_connect函数——与ODBC数据库建立连接
//odbc_cursor函数——获取游标名
//odbc_data_source函数——返回ODBC数据库连接信息
//odbc_do函数——执行SQL语句
//odbc_error函数——返回最后执行查询的错误号
//odbc_errormsg函数——返回最后查询的错误信息
//odbc_exec函数——执行SQL语句
//odbc_execute函数——执行预置的SQL语句
//odbc_fetch_array函数——将记录字段内容保存到数组中
//odbc_fetch_into函数——将指定列的元素保存到数组
//odbc_fetch_object函数——根据查询记录生成对象
//odbc_fetch_row函数——获取查询结果集的一列
//odbc_field_len函数——获取指定字段的长度
//odbc_field_name函数——获取指定字段的名称
//odbc_field_num函数——获取指定字段在表中的位置
//odbc_field_type函数——获取指定字段的类型
//odbc_free_result函数——释放结果集所占的内存
//odbc_gettypeinfo函数——返回数据源所支持的数据类型信息
//odbc_num_fields函数——获取结果中的字段总数
//odbc_num_rows函数——返回执行查询影响的记录数
//odbc_pconnect函数——与ODBC数据库建立持久连接
//odbc_prepare函数——预置查询
//odbc_result_all函数——将取得的信息转变为HTML表格形式
//odbc_result函数——返回从数据库中获取的信息
//odbc_rollback函数——实现事务的回滚
//odbc_setoption函数——调整ODBC设置
/**输出控制函数库*/
//flush函数——刷新PHP程序的缓存
<?php
ob_start();
ob_implicit_flush(0);
for($i=1;$i<=10;$i++){
for($j=1;$j<4000;$j++){
echo ' ';
}
echo $i;
flush();
ob_flush();
sleep(1);
}
ob_end_clean();
?>
//ob_clean函数——清除缓存内容但不关闭缓存
<?php
ob_start();
echo 'gmy';
ob_clean();
echo 'php';
ob_flush();
ob_end_clean();
?>
//ob_end_clean函数——清除缓存内容并关闭缓存
<?php
ob_start();
echo 'gmy';
ob_clean();
echo 'php';
ob_flush();
ob_end_clean();
?>
//ob_end_flush函数——输出缓存内容并关闭缓存
<?php
ob_start();
echo 'gmy';
ob_flush();
echo 'php';
ob_end_flush();
?>
//ob_flush函数——向浏览器输出缓存中内容
<?php
ob_start();
echo 'gmy';
ob_flush();
echo 'php';
ob_end_clean();
?>
//ob_get_clean函数——获取缓存内容同时清空缓存
<?php
ob_start();
echo 'gmy';
$str = ob_get_clean();
echo 'php';
ob_end_clean();
echo $str;
?>
//ob_get_contents函数——获取缓存中的内容
<?php
ob_start();
echo 'gmy';
$str1 = ob_get_contents();
echo 'php';
$str2 = ob_get_contents();
ob_end_clean();
echo $str1.'
';
echo $str2;
?>
//ob_get_flush函数——获取并输出缓存内容并关闭缓存
<?php
ob_start();
echo 'gmy';
$str = ob_get_flush();
ob_end_clean();
$handle = fopen('test.txt', 'w');
fwrite($handle, $str);
fclose($handle);
?>
//ob_get_length函数——获取缓存中内容的长度
<?php
ob_start();
echo 'gmy';
$str1 = ob_get_length();
ob_end_clean();
echo "长度 $str1";
?>
//ob_get_level函数——返回嵌套的缓存级别
<?php
ob_start();
echo 'gmy';
$str1 = ob_get_level();
ob_start();
echo "php";
$str2 = ob_get_level();
ob_end_clean();
ob_end_clean();
echo "长度 $str1 $str2";
?>
//ob_get_status函数——以数组形式返回当前缓存资料
<?php
ob_start();
echo 'gmy';
ob_start();
echo "php";
$arr = ob_get_status(true);
ob_end_clean();
ob_end_clean();
print_r($arr);
?>
//ob_gzhandler函数——向浏览器发送压缩编码的数据
<?php
ob_start(ob_gzhandler());
echo 'gmy';
ob_end_flush();
?>
//ob_implicit_flush函数——开启或关闭自动刷新缓存
<?php
ob_start();
ob_implicit_flush(0);
for($i =1; $i<=10;$i++){
for($j=1;$j<4000;$j++){
echo ' ';
}
echo $i;
ob_flush();
sleep(1);
}
ob_end_clean();
?>
//ob_list_handlers函数——以数组形式返回正在使用的缓存操作符
<?php
ob_start();
echo 'gmy';
ob_start();
echo 'php';
$arr = ob_list_handlers();
ob_end_clean();
ob_end_clean();
print_r($arr);
?>
//ob_start函数——开启缓存
<?php
ob_start();
?>
//output_add_rewrite_var函数——用给定变量名和值改写url
<?php
output_add_rewrite_var('name', 'gmy');
print_r(ob_list_handlers());
?>
//output_reset_rewrite_vars函数——还原被改写的url
<?php
output_add_rewrite_var('name', 'gmy');
output_reset_rewrite_vars();
?>
/**PDO函数库*/
//PDO:beginTransaction方法——开启一个事务
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
try{
$db = new PDO($dsn, $user, $password);
$db->beginTransaction();
$update=$db->exec("update users set name='i' where id = 12");
$delete = $db->exec("delete from users where id=11");
$db->rollBack();
}catch (PDOException $e){
echo "Connection failed".$e->getMessage();
}
?>
//PDO:commit方法——提交事务
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
try{
$db = new PDO($dsn, $user, $password);
$db->beginTransaction();
$update=$db->exec("update users set name='i' where id = 12");
$delete = $db->exec("delete from users where id=11");
$db->commit();
}catch (PDOException $e){
echo "Connection failed".$e->getMessage();
}
?>
//PDO:__construct函数——PDO构造函数
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
try{
$db = new PDO($dsn, $user, $password);
echo "连接成功";
}catch (PDOException $e){
echo "Connection failed".$e->getMessage();
}
?>
//PDO:errorInfo方法——获取错误信息
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
try{
$db = new PDO($dsn, $user, $password);
}catch (PDOException $e){
echo "Connection failed".$e->getMessage();
}
$db = new PDO($dsn, $user, $password);
$db->exec("insert into users values(13,'p')");
echo "PDO::errorInfo()";
print_r($db->errorInfo());
?>
//PDO:exec方法——执行SQL语句
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
try{
$db = new PDO($dsn, $user, $password);
$result = $db->exec("delete from users where id=9");
}catch (PDOException $e){
echo "Connection failed".$e->getMessage();
}
?>
//PDO:getAvailableDrivers方法——获取可用的驱动程序
<?php
print_r(PDO::getAvailableDrivers());
?>
//PDO:lastInsertId方法——获取最后插入记录的ID值
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
try{
$db = new PDO($dsn, $user, $password);
$db->exec("insert into users values(14,'z')");
echo $db->lastInsertId($db->exec("user (name)values('z')"));
}catch (PDOException $e){
echo "Connection failed".$e->getMessage();
}
?>
//PDO:prepare方法——执行预处理操作
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$db = new PDO($dsn, $user, $password,array(PDO::ATTR_PERSISTENT=>TRUE));
$sql = "select * from users where name = :name";
$sth = $db->prepare($sql,array(PDO::ATTR_CURSOR=>PDO::CURSOR_FWDONLY));
$sth->execute(array(':name'=>'f'));
$sth->execute(array('name'=>'f'));
$utf8=$sth->fetchAll();
print_r($utf8);
?>
//PDO:query方法——执行SQL语句
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$db = new PDO($dsn, $user, $password);
$sql = "select * from users";
foreach ($db->query($sql) as $row ){
print $row.'/t';
print $row[1]."
";
}
?>
//PDO:rollBack方法——事务回滚
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$db = new PDO($dsn, $user, $password,array(PDO::ATTR_PERSISTENT=>TRUE));
$db->beginTransaction();
$delete = $db->exec("delete from users where id = 2");
$db->rollBack();
?>
//PDOStatement:bindColumn方法——为指定数列定义变量
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$query="select * from users";
$result=$pdo->prepare($query);
$result->execute();
$result->bindColumn('id', $ids);
$result->bindColumn('name', $names);
while ($res=$result->fetch(PDO::FETCH_ASSOC)){
$data = $ids."/t".$names."/n";
echo $data;
}
?>
//PDOStatement:bindParam方法——为指定参数绑定变量值
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$id = 10;
$sth = $pdo->prepare("select * from users where id=:id");
$sth->bindParam(':id', $id,PDO::PARAM_INT);
$sth->execute();
$utf8= $sth->fetchAll();
print_r($utf8);
?>
//PDOStatement:bindValue方法——为指定参数绑定值
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$id = 10;
$sth=$pdo->prepare("select * from users where id<?");
$sth->bindValue(1, $id,PDO::PARAM_INT);
$sth->execute();
$utf=$sth->fetchAll();
print_r($utf);
?>
//PDOStatement:columnCount方法——返回结果集中的列数
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$sth = $pdo->prepare("select * from users");
$colcount = $sth->columnCount();
print("在使用前,返回结果$colcount /n");
$sth->execute();
$colcount=$sth->columnCount();
print("在使用后,返回结果$colcount /n");
?>
//PDOStatement:errorCode方法——获取错误代码
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$err=$pdo->prepare("select * from users");
$err->execute();
echo "/nPDOStatement::errorCode():";
print $err->errorCode();
?>
//PDOStatement:errorInfo方法——返回错误信息和错误代码
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$err=$pdo->prepare("select * from users");
$err->execute();
echo "/nPDOStatement::errorInfo():";
$arr = $err->errorInfo();
print_r($arr);
?>
//PDOStatement:execute方法——执行一个声明
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$err=$pdo->prepare("select * from users");
$err->execute();
echo "/nPDOStatement::errorInfo():";
$arr = $err->errorInfo();
print_r($arr);
?>
//PDOStatement:fetch方法——获取下一行的结果集
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$sth=$pdo->prepare("select * from users");
$sth->execute();
print("PDO::FETCH_BOTH:");
$result = $sth->fetch(PDO::FETCH_BOTH);
print_r($result);
?>
//PDOStatement:fetchAll方法——返回结果集的数组
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$sth=$pdo->prepare("select * from users");
$sth->execute();
$result = $sth->fetchAll();
print_r($result);
?>
//PDOStatement:fetchColumn方法——返回指定列的结果集
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$stmt=$pdo->prepare("select * from users");
$stmt->execute();
$row = $stmt->fetchColumn(1);
do{
echo $row."
";
}while ($row=$stmt->fetchColumn(1));
$stmt=null;
?>
//PDOStatement:rowCount方法——返回受影响的行数
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$insert = $pdo->prepare("insert into users values(15,'i')");
$insert->execute();
print("影响行数");
echo $insert->rowCount();
?>
//PDOStatement:setFetchMode方法——声明fetch方法的执行模式
<?php
$dsn = 'mysql:dbname=java;host=localhost';
$user = 'root';
$password = 'root';
$pdo = new PDO($dsn, $user, $password);
$stmt = $pdo->query("select * from users");
$result = $stmt->setFetchMode(PDO::FETCH_NUM);
while($row= $stmt->fetch()){
print $row[0]."/t".$row[1]."/n";
}
?>
/**PHP选项及相关信息函数库*/
//dl函数——加载PHP的扩展
<?php
if(!extension_loaded("sqlite")){
if(strtoupper(substr(PHP_OS, 0,3))=='WIN'){
dl('php_sqlite.dll');
}else{
dl('sqlite.so');
}
}
?>
//extension_loaded函数——检查扩展是否被加载
<?php
if(!extension_loaded("gd")){
if(!dl('gd.so')){
echo '失败';
}else{
echo '成功';
}
}else{
echo '已经加载';
}
?>
//get_cfg_var函数——获取PHP配置选项的值
<?php
echo '时区 '.get_cfg_var('date.timezone').'
';
echo '文件上传最大 '.get_cfg_var('upload_max_filesize').'
';
echo 'POST最大 '.get_cfg_var('post_max_size').'
';
echo 'session存储位置 '.get_cfg_var('session.save_path').'
';
?>
//get_extension_funcs函数——返回模块函数名称组成的数组
<?php
print_r(get_extension_funcs('xml'));
?>
//get_include_path函数——获取当前路径的配置选项
<?php
echo get_include_path();
echo ini_get('include_path');
?>
//get_included_files函数——返回被包含文件名的数组
<?php
include 'test.php';
require_once 'test.php';
$files = get_included_files();
foreach ($files as $name){
echo "$name";
}
?>
//get_magic_quotes_gpc函数——获取变量magic_quotes_gpc的值
<?php
if(get_magic_quotes_gpc()){
echo '1';
}else{
echo '0';
}
?>
//get_magic_quotes_runtime函数——获取变量magic_quotes_runtime的值
<?php
if(get_magic_quotes_runtime()){
echo '没开启';
}else{
echo '已开启';
}
?>
//getenv函数——获取环境变量的值
<?php
$ip = getenv('REMOTE_ADDR');
echo $ip."
";
$ip = $_SERVER['REMOTE_ADDR'];
echo $ip;
?>
//getlastmod函数——获取页面的最后修改时间
<?php
echo "最后修改时间".date("Y-m-d H:i:s",getlastmod());
?>
//ini_get函数——获取配置信息的值
<?php
echo 'display_errors = '.ini_get('display_errors')."
";
?>
//ini_restore函数——重置配置选项的值为初始值
<?php
ini_set('display_errors', '0');
echo 'display_errors='.ini_get('display_errors')."
";
ini_restore('display_errors');
echo 'display_errors='.ini_get('display_errors')."
";
?>
//ini_set函数——设置配置选项的值
<?php
ini_set('include_path', 'c:/windows');
?>
//php_sapi_name函数——返回PHP与服务器接口类型
<?php
$php_type = php_sapi_name();
if(substr($php_type, 0,3)=='cgi'){
echo "cgi 模式运行";
}else{
echo "其他模式运行";
}
?>
//php_uname函数——返回PHP所运行的系统信息
<?php
echo php_uname()."
";
echo PHP_OS."
";
echo php_uname('s')."
";
echo php_uname('n')."
";
echo php_uname('r')."
";
echo php_uname('v')."
";
echo php_uname('m')."
";
?>
//phpinfo函数——返回与PHP相关的所有信息
<?php
phpinfo();
?>
//putenv函数——设置环境变量的值
<?php
$uniqid = getmygid();
putenv("UNIQID=$uniqid");
?>
//restore_include_path函数——恢复include_path初始值
<?php
echo get_include_path()."
";
restore_include_path();
ini_restore('include_path');
echo get_include_path()."
";
?>
//set_include_path函数——改变include_path初始值
<?php
set_include_path("d://");
ini_set('include_path', 'D://');
echo '现在的路径是'.get_include_path();
?>
//set_time_limit函数——设定脚本的最大执行时间
<?php
set_time_limit(120);
?>
/**程序执行功能函数库*/
//escapeshellarg函数——删除含有潜在危险的字符
<?php
$dir = 'soft';
system('ls'.escapeshellarg($dir));
?>
//escapeshellcmd函数——删除字符串里的特殊符号
<?php
$e = escapeshellcmd($userinput);
system("echo $e");
$f = escapeshellcmd($filename);
system("touch /"/temp/$f/"; ls -l /"/temp/$f/"");
?>
//exec函数——执行服务器里的外部程序
<?php
echo exec("whoami");
?>
//passthru函数——执行服务器里的外部程序
<?php
passthru("whoami");
?>
//proc_close函数——关闭服务器的外部程序
<?php
$soft = array(
0=>array("pipe","r"),
1=>array("pipe","w"),
2=>array("pipe","w")
);
$process = proc_open("start notepad.exe", $soft, $pipes);
sleep(1);
proc_close($process);
?>
//proc_open函数——执行一个命令打开文件指针
<?php
$soft = array(
0=>array("pipe","r"),
1=>array("pipe","w"),
2=>array("pipe","w")
);
$process = proc_open("start notepad.exe", $soft, $pipes);
sleep(5);
proc_close($process);
?>
//proc_terminate函数——结束打开的进程
<?php
$soft = array(
0=>array("pipe","r"),
1=>array("pipe","w"),
2=>array("pipe","w")
);
$process = proc_open("start notepad.exe", $soft, $pipes);
proc_terminate($process);
?>
//shell_exec函数——返回所有命令执行的输出
<?php
echo shell_exec("dir c://");
?>
//system函数——执行服务器里的外部程序
<?php
$str = 'soft';
$str = escapeshellcmd($str);
system("mail $strecho "会议内容发送成功";
?>
/**正则表达式函数库*/
//preg_grep函数——用正则表达式搜索数组
<?php
header("Content-Type:text/html;charset=utf-8");
$array = array("7人"=>"PHP部门","6人"=>"JAVA部门","5人"=>"VB部门");
$result1 = preg_grep("/p+/", $array);
print_r($result1);
$result2 = preg_grep("/p+/", $array,PREG_GREP_INVERT);
print_r($result2);
?>
//preg_match_all函数——获取与正则表达式匹配的数组
<?php
header("Content-Type:text/html;charset=utf-8");
$str = "分类:php
名称函数大全";
preg_match_all("/(.*)<//strong>/", $str,$out);
print_r($out);
?>
//preg_match函数——搜索与正则表达式匹配的内容
//搜索所有与给出的正则表达式匹配的内容,如果存在则返回true,否则返回false
//preg_quote函数——在特殊字符前加反斜线
<?php
header("Content-Type:text/html;charset=utf-8");
$string = 'echo $book = php函数手册';
$result = preg_quote($string);
echo $result;
?>
//preg_replace_callback函数——利用自定义函数搜索并替换为指定字符
<?php
header("Content-Type:text/html;charset=utf-8");
function strrep($str){
$arr = array("php"=>"php函数手册","邮电"=>"人民邮电出版社");
if(isset($arr[$str[1]])){
return $arr[$str[1]];
}else{
return $str;
}
}
$string = "<书籍:php 出版社邮电";
$result = preg_replace_callback("/(.*)<//strong>/U", "strrep",$string);
echo $result;
?>
//preg_replace函数——搜索并替换为指定字符
<?php
$string1 = "百度:http://www.baidu.com";
$result1 = preg_replace("/http:////(.*)/", "", $string1);
echo $result1;
?>
//preg_split函数——用正则表达式将字符串分割为数组
<?php
header("Content-Type:text/html;charset=utf-8");
$str = "科技And图书andphp手册";
$result = preg_split("/[a|A]nd/", $str);
print_r($result);
?>
//ereg_replace函数——搜索匹配项并替换为指定字符
<?php
header("Content-Type:text/html;charset=utf-8");
$str = "百度 http://www.baidu.com";
$result = ereg_replace("http://([A-Za-z.]+)$", "//0", $str);
echo $result;
?>
//ereg函数——搜索匹配的内容
<?php
header("Content-Type:text/html;charset=utf-8");
if(ereg("([php]+)", "php参考大全")){
echo "匹配字符";
}else{
echo "不匹配";
}
?>
//eregi_replace函数——搜索匹配项并替换为指定字符
<?php
header("Content-Type:text/html;charset=utf-8");
$string = "百度: http://www.baidu.com";
$result = eregi_replace("http://([a-z]+)$", "//0", $string);
echo $result;
?>
//eregi函数——搜索匹配的内容
<?php
header("Content-Type:text/html;charset=utf-8");
if(eregi("([Php]+)", "php参考大全")){
echo "匹配字符";
}else{
echo "不匹配";
}
?>
//split函数——用正则表达式将字符串分割为数组
<?php
header("Content-Type:text/html;charset=utf-8");
$str = "科技And图书andphp手册";
$result = split("[a|A]+nd", $str);
print_r($result);
?>
//spliti函数——用正则表达式将字符串分割为数组
<?php
header("Content-Type:text/html;charset=utf-8");
$str = "科技And图书andphp手册";
$result = spliti("[a|A]+nd", $str);
print_r($result);
?>
//sql_regcase函数——返回与字符串匹配的正则表达式
<?php
header("Content-Type:text/html;charset=utf-8");
$str = "百度:http://www.baidu.com";
$result = sql_regcase($str);
echo $result;
?>
/**SESSION函数库*/
//session_cache_expire函数——设置session的过期时间
<?php
header("Content-Type:text/html;charset=utf-8");
session_cache_expire(10);
$cache_expire = session_cache_expire();
session_start();
echo "session过期时间被设置$cache_expire ";
?>
//session_destroy函数——结束当前所有会话
<?php
session_start();
header("Content-Type:text/html;charset=utf-8");
session_register("gmy");
$_SESSION['gmy']="php";
echo $_SESSION['gmy'];
session_destroy();
?>
//session_id函数——获取当前session的代号
<?php
session_start();
session_register("gmy");
echo session_id();
?>
//session_is_registered函数——判断session变量是否被注册
<?php
session_start();
session_register("gmy");
echo session_is_registered("gmy");
?>
//session_name函数——获取或重新设置session变量值
<?php
session_start();
echo session_name()."
";
session_name("gmy");
echo session_name();
?>
//session_regenerate_id函数——为session设置新的代号
<?php
session_start();
session_register("gmy");
$old_sessionid = session_id();
session_regenerate_id();
$new_sessionid = session_id();
echo $new_sessionid;
?>
//session_register函数——增加一个session变量
<?php
session_start();
header("Content-Type:text/html;charset=utf-8");
session_register("gmy");
$_SESSION['gmy']="科技";
echo $_SESSION['gmy'];
?>
//session_save_path函数——取得或重新配置session路径
<?php
session_start();
echo session_save_path();
?>
//session_set_cookie_params函数——设置cookie参数
<?php
session_start();
session_set_cookie_params(2);
?>
//session_set_save_handler函数——自定义操作session的函数
//自定义操作session
//session_start函数——初始化session变量
<?php
session_start();
echo session_save_path();
?>
//session_unregister函数——删除指定session变量
<?php
session_start();
session_register("mr");
session_unregister("mr");
?>
//session_unset函数——释放所有session变量
<?php
session_start();
session_register("mr");
session_unset();
?>
//session_write_close函数——结束session并存储session数据
<?php
session_start();
session_register("gmy");
$_SESSION['gmy']="php";
session_write_close();
?>
/**XML函数库*/
//SimpleXMLElement->asXML函数——将XML字符串格式化为XML1.0版本
//SimpleXMLElement->attributes函数——获取元素节点属性值
//SimpleXMLElement->children函数——获取给定元素节点的子节点
//SimpleXMLElement->xpath函数——标识节点的路径方法
//simplexml_import_dom函数——将DOM节点转换为SimpleXML节点
//simplexml_load_file函数——读取指定XML文档
//simplexml_load_string函数——读取XML的字符串
//xml_set_element_handler函数——建立起始和终止元素处理器
//xml_set_character_data_handler函数——建立字符数据处理器
//xml_parser_free函数——释放指定的XML解析器
//xml_parser_create函数——建立解析器并返回资源句柄
//xml_parse函数——开始解析XML文档
//xml_parse_into_struct函数——将XML解析到数组中
//xml_get_error_code函数——返回一个错误代码
//xml_error_string函数——返回与错误代码参数对应的字符串
/**socket函数库*/
//socket_accept函数——接受一个socket连接
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
@socket_write($socket, "科技",strlen("科技"));
?>
//socket_bind函数——与指定的地址进行绑定
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
$result = @socket_listen($socket);
$sp = @socket_accept($socket);
echo "接受内容".@socket_read($sp, 1024);
?>
//socket_clear_error函数——清除socket错误
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
socket_clear_error();
@socket_write($socket, "科技",strlen("科技"));
echo @socket_read($socket, 1024);
?>
//socket_close函数——关闭一个socket源
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
socket_close();
?>
//socket_connect函数——建立与socket主机的连接
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
socket_close();
?>
//socket_create_listen函数——打开一个socket监听
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$resource = @socket_create_listen(123645);
socket_close();
?>
//socket_create函数——产生一个socket
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$resource = @socket_create_listen(123645);
socket_close();
?>
//socket_getsockname函数——获取socket的IP地址
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
socket_getsockname($socket, $addr,$port);
echo $addr;
socket_close($socket);
?>
//socket_last_error函数——获取socket最后错误代码
<?php
if(false == ($socket = @socket_create(AF_INET, SOCK_STREAM, SOL_TCP))){
die("错误号".socket_last_error()."错误信息".socket_strerror(socket_last_error()));
}
?>
//socket_listen函数——监听socket的所有连接
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
$result = @socket_listen($socket);
$sp = @socket_accept($socket);
echo "接受内容".@socket_read($sp, 1024);
?>
//socket_read函数——读取指定长度的数据
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
echo @socket_read($socket, 1024);
socket_close($socket);
?>
//socket_send函数——发送数据到socket端口
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.227",12645);
socket_send($socket, "科技",strlen("科技"),0x4);
socket_close($socket);
?>
//socket_sendto函数——发送数据到socket端口
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_bind($$socket, "127.0.0.1","12645");
$buf = 'soft';
$len = strlen($buf);
socket_sendto($socket, $buf,$len,0x100,'192.168.0.2',123645);
socket_close($socket);
?>
//socket_set_block函数——设置socket为块模式
<?php
$port = 123645;
if(!$socket = socket_create_listen($port)){
echo socket_strerror(socket_last_error());
}
?>
//socket_set_nonblock函数——设置socket为非块模式
<?php
$port = 123645;
if(!$socket = socket_create_listen($port)){
echo socket_strerror(socket_last_error());
}
if(!socket_set_option($socket, SOL_SOCKET,SO_REUSEADDR,1)){
echo socket_strerror(socket_last_error());
}
if(!socket_set_nonblock($socket)){
echo socket_strerror(socket_last_error());
}
?>
//socket_shutdown函数——关闭读、写指定的socket的操作
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, 0);
socket_bind($$socket, "127.0.0.1","12645");
$result = @socket_listen($socket);
$sp = @socket_listen($socket);
socket_shutdown($socket,2);
echo "内容".@socket_read($sp, 1024);
?>
//socket_strerror函数——返回详细错误信息
<?php
$port = 123645;
if(false == ($socket = socket_create_listen($port))){
echo "创建失败".socket_strerror(socket_last_error());
}
if(false == (@socket_bind($socket, '127.0.0.1',123645))){
echo "失败".socket_strerror(socket_last_error($socket));
}
?>
//socket_write函数——写数据到socket缓存
<?php
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
$connect = @socket_connect($socket, "192.168.1.27",123645);
@socket_write($socket, "科技",strlen("科技"));
?>
/**字符串函数库*/
//addcslashes函数——将字符串中的字符进行转义
<?php
echo addcslashes("This is a example", 'a..g!');
?>
//addslashes函数——将字符串中特殊字符添加反斜线
<?php
$str = "addslashes函数可以对'// 等转译";
echo '没有使用函数'.$str;
echo "
";
echo "使用函数".addslashes($str);
?>
//bin2hex函数——将二进制字符串转换成十六进制
<?php
$str = 'apz';
echo bin2hex($str);
?>
//chr函数——将ASCII值转换成对应字符
<?php
echo chr(89).chr(111).chr(117);
?>
//chunk_split函数——将字符分隔成小段
<?php
$str = "php,asp,jsp,net";
$string = chunk_split($str,11,'
');
echo $string;
?>
//count_chars函数——计算字符串出现的字符的次数
<?php
$string = "Happy Birthday";
$result = count_chars($string,0);
for($i=0;$i if($result[$i]!=0)
echo "出现次数 $result[$i]".chr($i)."
";
}
?>
//crc32函数——计算字符串的crc32多项式
<?php
$str = crc32("编程词典");
printf("%u/n",$str);
?>
//crypt函数——对字符串进行加密
<?php
$str = "This is an example!";
echo '加密前$str的值为'.$str;
$crypttostr = crypt($str,'crypt');
echo '

加密后$str的值

'.$crypttostr;
?>
//echo函数——输出字符串
<?php
$str1 = '图书';
$str2 = '软件';
$str3 = '词典';
echo "包括".$str1.$str2.$str3;
?>
//explode函数——使用分隔符分割字符串
<?php
$strings = "苹果、香蕉、樱桃";
$string = explode("、", $strings);
print_r($string);
echo $string[0];
?>
//fprintf函数——将数据格式化并转换成字符串
<?php
if(!($fp = fopen("test.txt", 'w')))
return;
$string = "科技";
$count = fprintf($fp, '%s'.$string);
echo "将$count 个字符写入到text.txt中";
?>
//htmlentities函数——将字符转成HTML字符串
//本函数有一个弊端,在转换中文字符时,其转换后输出的汉子乱码
//htmlspecialchars函数——将特殊字符转成HTML格式
<?php
$str = '特殊字符的转换
';
echo $str;
echo htmlspecialchars($str);
?>
//implode函数——将数组内容连接成字符串
<?php
$tempArr = array('图书','软件','词典');
echo '科技='.implode('+', $tempArr);
?>
//ltrim函数——删除左侧空白字符
<?php
$str1 = "/r/t/n图书";
$str2 = 'delete软件';
echo ltrim($str1);
echo '
';
echo ltrim($str2,'delt');
?>
//md5_file函数——计算文件中的MD5散列值
<?php
$filename = "text.txt";
$md5file = md5_file($filename);
echo $md5file;
?>
//md5函数——计算字符串的MD5散列值
<?php
echo md5("科技");
?>
//metaphone函数——获取字符串的读音值
<?php
echo metaphone("metaphone");
?>
//nl2br函数——将换行字符转换成
<?php
echo nl2br("天若有情天亦老,/n人间正道是沧桑");
?>
//number_format函数——将数字字符串格式化
<?php
$number = 12325.5678;
$one_number = number_format($number);
echo $one_number;
?>
//ord函数——返回首个字节的ASCII值
<?php
echo ord('A');
?>
//parse_str函数——对获取的QUERY_STRING字符串进行解析
<?php
$string = "user=%C3%F7%C8%D5%BF%C6%BC%BC&pass=123456&Submit=%CC%E1
5DB%BB";
parse_str($string);
echo $user;
echo $pass;
echo $Submit;
?>
//print函数——输出字符串
<?php
print('词典');
?>
//printf函数——输出格式化后的字符串
<?php
$string = 17;
printf("%c",$string);
?>
//quotemeta函数——将特殊字符前加上反斜线
<?php
$string = "$_企业文化=[坚韧*创新*博学*笃行]*电话://0431-8451321 . 1354-5613131 ? ";
echo quotemeta($string);
?>
//rtrim函数——去除字符串右侧空格
<?php
$str = " 科 技 ";
var_dump("有空格".$str);
echo "
";
var_dump("无空格".rtrim($str));
?>
//setlocale函数——配置地域信息
<?php
setlocale(LC_ALL, 'C');
echo strftime("%A %d %B %Y",mktime(0,0,0,8,8,2008));
?>
//sha1_file函数——计算文件的SHA-1散列值
<?php
$string = 'text.txt';
echo sha1_file($string);
?>
//sha1函数——计算字符串的SHA-1散列值
<?php
$string = '科技';
echo sha1($string);
?>
//similar_text函数——计算两个字符串的相似度
<?php
$string = '科技';
$strs = '图书';
$similar_text = similar_text($str, $strs,$percent);
$percents=number_format($percents,2);
echo '他们之间的相识度'.$percents."%";
?>
//soundex函数——计算字符串的读音值
<?php
echo soundex("maths");
?>
//sprintf函数——将字符串进行格式化
<?php
$count = 123;
$price = 12.225;
$money = $count*$price;
echo $money;
echo sprintf("%01.2f",$money);
?>
//sscanf函数——按照指定格式对字符串进行解析
<?php
$sscanf = "January 31 2007";
list($month,$day,$year) = sscanf($sscanf, "%s%d%d");
echo "输出值 $year-".substr($month, 0,3)."-day/n";
?>
//str_ireplace函数——将指定字符串替换为另一字符串
<?php
$string = "abcdefg";
echo str_ireplace("ab", "ADS", $string);
?>
//str_pad函数——将字符串填充成指定长度的字符串
<?php
$string = "tomorrow";
echo str_pad($string, 11)."
";
echo str_pad($string, 11,"*",STR_PAD_LEFT);
?>
//str_repeat函数——按次数重复输出字符串
<?php
echo str_repeat("科技@", 4);
?>
//str_replace函数——实现字符串的替换
<?php
$str = "科技";
$str1 = array("软件","图书","论坛");
print_r($str1);
?>
//str_rot13函数——对字符串进行Rot13编码
<?php
echo str_rot13("soft");
?>
//str_shuffle函数——随机打乱字符的顺序
<?php
$str = 'soft';
$str2 = '1234567890';
$str_shuffle = str_shuffle($str);
$str_shuffle2 = str_shuffle($str2);
echo $str_shuffle;
echo $str_shuffle2;
?>
//str_split函数——将字符串转换为数组
<?php
$str = 'soft';
$str_split = str_split($str);
print_r($str_split);
?>
//str_word_count函数——计算字符串中的词数
<?php
$str = 'YOU';
echo str_word_count($str);
?>
//strcasecmp函数——对两个字符串进行比较
<?php
echo '比较结果'.strcasecmp('科技', '科')."
";
echo "不区分大小写,比较结果";
echo strcasecmp("HELLO", "hello");
?>
//strcmp函数——对两个字符串进行比较
<?php
echo '比较结果'.strcmp('科技', '科')."
";
echo "区分大小写,比较结果";
echo strcmp("HELLO", "hello");
?>
//strcspn函数——返回从start开始不符合mask的字符串长度
<?php
$string = '科技';
echo strcspn($string, '科');
?>
//strip_tags函数——去除HTML和PHP标签
<?php
$string = "HELLOworld";
echo strip_tags($string);
echo $string;
?>
//stripcslashes函数——将使用addcslashes()处理后的字符串返回原样
<?php
$str = addcslashes("How", "o");
echo $str;
?>
//stripos函数——查找指定字符串首次出现的位置
<?php
$str = "科技";
var_dump(stripos($str, "科技"));
?>
//stripslashes函数——将addslashes()处理过的字符串还原
<?php
$str = "This's an example";
$str1 = addslashes($str);
echo $str1.'
';
$str2 = stripslashes($str1);
echo $str2;
?>
//stristr函数——获取指定的字符串
<?php
$str = "科技";
$str = stristr($str, "科");
echo $str."
";
?>
//strlen函数——获取字符串的长度
<?php
$str = "科技";
echo strlen($str);
?>
//strnatcasecmp函数——用自然算法比较字符串的大小
<?php
echo strnatcasecmp("1 PHP", "2 JSP")
?>
//strncasecmp函数——比较字符串中的前n个字符
<?php
$str = "PHP";
$str1 = "Hello";
echo strncasecmp($str1, $str, 3);
?>
//strncmp函数——比较字符串中的前n个字符
<?php
$str = "PHP";
$str1 = "Hello";
echo strncmp($str1, $str, 3);
?>
//strpbrk函数——从指定字符开始截取字符串
<?php
$str = "book";
echo strpbrk($str, 'o');
?>
//strpos函数——查找指定字符串首次出现的位置
<?php
$str = "科技";
echo strpos($str, '技',3);
?>
//strrchr函数——查找指定字符串最后出现的位置
<?php
$str = "科技";
echo strrchr($str, '科');
?>
//strrev函数——将字符串倒转输出
<?php
echo strrev("book");
?>
//strripos函数——查找指定字符串最后出现的位置
<?php
echo strripos("HELLO", "LL");
?>
//strrpos函数——查找指定字符串最后出现的位置
<?php
echo strrpos("Hello", 'l');
?>
//strspn函数——获取符合参数str2的字符数量
<?php
echo strspn("abcd", 'b');
?>
//strstr函数——检索字符串
<?php
echo strstr('soft', 'o');
?>
//strtok函数——将字符串分割成小块
<?php
$string = '科技 图书 软件 论坛 ';
$token = strtok($string, " ");
while($token !== false){
echo "$token
";
$token = strtok(" ");
}
?>
//strtolower函数——将大写字母转换为小写字母
<?php
echo strtolower("PHP");
?>
//strtoupper函数——将小写字母转换为大写字母
<?php
echo strtoupper("Php");
?>
//strtr函数——将字符串中的字符转换成指定字符
<?php
echo strtr('soft', 'o', 'i');
?>
//substr_count函数——获取指定字符出现的次数
<?php
echo substr_count('PHP,PHP,PHP', 'PH');
?>
//substr_replace函数——将部分字符串替换为指定字符串
<?php
echo substr_replace("hello", "gmy", 2);
?>
//substr函数——从指定字符串中截取字符
<?php
echo substr("科技图书", 2);
?>
//trim函数——删除字符串首尾空白或其他字符
<?php
$str = " 科技";
echo trim($str);
?>
//ucfirst函数——将字符串首字母大写
<?php
$str = "soft";
echo ucfirst($str);
?>
//ucwords函数——将字符串中的每个词首字母大写
<?php
$str = "i am gmy";
echo ucwords($str);
?>
//vprintf函数——输出格式化字符串
<?php
$string = "www.baidu.com";
$tel = "121";
vprintf("百度 网址%s电话%u", array($string,$tel));
?>
//vsprintf函数——将输出格式化字符串到变量
<?php
$string = "www.baidu.com";
$tel = "121";
$array = vsprintf("百度 网址%s电话%u", array($string,$tel));
print($array);
?>
/**URL函数库*/
//base64_decode函数——将数据解码并返回原始数据
<?php
$str = "w/fI1b/GvLw=";
echo base64_decode($str);
?>
//base64_encode函数——使用base64对data进行编码
<?php
$str = "科技";
echo base64_encode($str);
?>
//http_build_query函数——产生URL编码的查询字符串
<?php
$str = array("gmy","www.baidu.com");
echo http_build_query($str);
?>
//parse_url函数——解析URL并返回数组
//解析URL字符串,并将结果返回到数组中
//rawurldecode函数——将被编码过的字符串解码
<?php
echo rawurldecode("email:qq136697122%40qq.com");
?>
//rawurlencode函数——将字符串进行编码
<?php
$str = "http://www.baidu.com";
echo rawurlencode($str);
?>
//urldecode函数——返回解码后的字符串
<?php
$str = "PHP%BA%AF%CA%FD%B2%CE%BF%BC%B4%F3%C8%AB";
echo urldecode($str);
?>
//urlencode函数——将字符串进行编码
<?php
$str = "科技";
echo urlencode($str);
?>
/**变量函数库*/
//empty函数——检查变量是否为空
<?php
$var = "";
if(empty($var)){
echo "var变量为空";
}
?>
//is_numeric函数——检查变量是否为数字类型
<?php
$a = 1227.2424;
if(is_numeric($a)){
echo "a是数组或字符串类型";
}
?>
//is_string函数——检查变量是否为字符串类型
<?php
$a = "1227.2424";
if(is_string($a)){
echo "a是字符串类型";
}
?>
//is_null函数——检查变量是否为null
<?php
$a = null;
if(is_null($a)){
echo "空";
}
?>
//is_bool函数——检查变量是否为布尔类型
<?php
$a = false;
if(is_bool($a)){
echo "布尔类型";
}
?>
//is_float函数——检查变量是否为浮点类型
<?php
$a = 12.11;
if(is_float($a)){
echo "浮点类型";
}
?>
//is_int函数——检查变量是否为整数类型
<?php
$a = 12;
if(is_int($a)){
echo "整数型";
}
?>
//is_object函数——检查变量是否为对象类型
<?php
$a = new stdClass();
if(is_object($a)){
echo "对象类型";
}
?>
//is_resource函数——检查变量是否为资源类型
<?php
$a = "php";
if(is_resource($a)){
echo "资源类型";
}else{
echo "不是资源对象";
}
?>
//is_array函数——检查变量是否为数组类型
<?php
$a = array();
if(is_array($a)){
echo "是数组类型";
}
?>
//intval函数——返回一个变量的整数类型值
<?php
$a = 1227.24;
echo intval($a)."
";
?>
//print_r函数——显示变量的易于理解的信息
<?php
$array = array("a"=>"asp","p"=>"php");
print_r($array);
?>
//settype函数——设置变量的类型
<?php
$one = "1227php";
settype($one, "integer");
echo $one;
?>
//strval函数——返回字符串的值
<?php
$string = true;
$result = strval($string);
echo $result;
?>
//unset函数——销毁指定的变量
<?php
$array = array("a"=>"asp","p"=>"php");
unset($array);
if($array==null){
echo "变量已销毁";
}
?>
//var_dump函数——显示表达式的结构信息
<?php
$array = array("a"=>"asp","p"=>"php");
var_dump($array);
?>
//floatval函数——返回变量的浮点值
<?php
$var = "253.423php";
$result = floatval($var);
echo $result;
?>
//gettype函数——返回一个变量的类型
<?php
$var = "253.423";
echo gettype($var)."
";
?>
//import_request_variables函数——将GET/POST/Cookie变量转成全局变量
//将GET POST COOKIE 变量导入到全局作用域中
//isset函数——检查变量是否被设置
<?php
$var = '';
if(isset($var)){
echo '变量被设置1';
}
?>
//var_export函数——显示表达式的结构信息
<?php
$array = array("a"=>"asp","p"=>"php");
var_export($array);
?>
//unserialize函数——将序列化的变量转换回PHP的值
<?php
$array = array("a"=>"asp","p"=>"php");
$result = serialize($array);
echo $result."
";
$result1 = unserialize($result);
print_r($result1);
?>
//serialize函数——返回表示变量值的字节流的字符串
<?php
$array = array("a"=>"asp","p"=>"php");
$result = serialize($array);
echo $result."
";
?>
//get_defined_vars函数——返回已定义变量的多维数组
<?php
$b = array(1,1,2,27,5,8);
$arr = get_defined_vars();
print_r($arr[b]);
?>
//get_resource_type函数——获取资源的类型
<?php
$c = fopen("foo", "w");
echo get_resource_type($c);
?>
//is_scalar函数——检查变量是否为标量
<?php
$a = array();
if(is_scalar($a)){
echo "a是标量型";
}else{
echo "不是标量型";
}
?>
/**压缩函数库*/
//gzclose函数——关闭打开的压缩文件
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
if(gzclose($gz)){
echo "编辑结束";
}
?>
//gzcompress函数——返回压缩的字符串
<?php
$str = "科技";
$enstr = gzcompress($str,5);
echo $enstr;
?>
//gzdeflate函数——返回以deflate编码压缩的字符串
<?php
$str = "科技";
$enstr = gzdeflate($str,5);
echo $enstr;
?>
//gzencode函数——返回以gzip编码压缩的字符串
<?php
$str = "科技";
$enstr = gzencode($str,5);
echo $enstr;
?>
//gzeof函数——判断压缩文件指针是否指到文件尾
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "r");
while(!gzeof($gz)){
echo gzgetc($gz);
}
gzclose($gz);
?>
//gzfile函数——读取压缩文件内容并解压到数组中
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$array = gzfile("soft.gz");
foreach ($array as $line){
echo $line.'
';
}
?>
//gzgetc函数——读取压缩文件并取出一个字符
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "r");
$str ='';
for($i = 1;$i <=4;$i++){
$str.=gzgetc($gz);
}
echo $str;
gzclose($gz);
?>
//gzgets函数——解压缩并取出指定长度的字符串
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "r");
$str = gzgets($gz, 5);
echo $str;
gzclose($gz);
?>
//gzgetss函数——解压缩并取出字符串并去掉HTML或PHP指令
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科 技");
gzclose($gz);
$gz = gzopen("soft.gz", "r");
$str = gzgetss($gz, 5);
echo $str;
gzclose($gz);
?>
//gzinflate函数——使经过gzdeflate()编码的字符串恢复正常
<?php
$str = '科技';
$enstr = gzdeflate($str,5);
$destr = gzinflate($enstr);
echo $destr;
?>
//gzopen函数——打开压缩文件
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
if(gzclose($gz)){
echo "编辑结束";
}
?>
//gzpassthru函数——将压缩文件指针后的内容取出
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "rb");
$files = gzpassthru($gz);
echo $files;
gzclose($gz);
?>
//gzread函数——读取指定长度的字符串
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "rb");
$str = gzread($gz,6);
echo $str;
gzclose($gz);
?>
//gzrewind函数——重设指针到文件头
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "rb");
gzrewind($gz);
$str = gzread($gz,6);
echo $str;
gzclose($gz);
?>
//gzseek函数——重设指针到指定的位置
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "rb");
gzseek($gz,6);
$str = gzpassthru($gz);
echo $str;
gzclose($gz);
?>
//gztell函数——获得压缩文件的指针在文件内的位置
<?php
$gz = gzopen("soft.gz", 'wb');
gzputs($gz,"科技");
gzclose($gz);
$gz = gzopen("soft.gz", "rb");
$str = gzread($gz, 2);
echo $str;
$handle = gztell($gz);
echo "指正在$handle 处";
gzclose($gz);
?>
//gzuncompress函数——对压缩的字符串进行解压
<?php
$str = "科技";
$enstr = gzcompress($str,5);
echo $enstr;
$destr = gzuncompress($enstr);
echo $destr;
?>
//gzwrite函数——将资料写入指定压缩文件中
<?php
$gz = gzopen("soft.gz", 'wb');
$msg = gzwrite($gz, "科技");
if($msg){
echo "压缩成功";
}else{
echo "出现错误";
}
gzclose($gz);
?>
//readgzfile函数——将压缩文件全部读出并解压缩
<?php
$gz = gzopen("soft.gz", 'wb');
$msg = gzwrite($gz, "科技");
gzclose($gz);
$files = readgzfile("soft.gz");
echo $files;
?>
/**其他常用函数库*/
//die函数——将信息输出并中断PHP程序
<?php
$filename = "/soft/";
if(!$filename=@fopen($filename, "r")){
die("无法打开");
}
?>
//constant函数——返回一个常量值
<?php
define("decree", "科技");
echo constant("decree");
?>
//define函数——定义一个常量
<?php
define("decree", "科技");
echo constant("decree");
?>
//eval函数——将字符串中的变量值带入到字符串中
<?php
$url="baidu.com";
$name="百度";
$str="$name 网址 $url";
eval("$str = $str");
echo $str."/n";
?>
//exit函数——结束PHP程序
<?php
exit;
?>
//get_browser函数——返回用户浏览器的基本属性
<?php
echo $_SERVER["HTTP_USER_AGENT"]."
";
$browser = get_browser(null,true);
print_r($browser);
?>
//php_strip_whitespace函数——获取文件的实际代码
<?php
$string = php_strip_whitespace("index.php");
echo $string;
?>
//sleep函数——指定程序暂停的秒数
<?php
sleep(2);
echo date('h:i:s').'/n';
?>
//uniqid函数——生成一个唯一的编号
<?php
echo md5(uniqid(rand(),true));
?>
//unpack函数——将数据以二进制形式解压
<?php
$data = "PHP";
print_r(unpack("C*", $data));
?>
//usleep函数——暂停网页
<?php
usleep(1000000);
echo date("h:i:s");
?>
//iconv函数——转换字符串的编码格式
<?php
setlocale(LC_TIME, "chs");
$date = strftime("%A",time());
echo iconv("gb2312", "utf-8", $date);
?>
//mb_convert_encoding()函数——实现字符编码的转换
<?php
$text = "编程词典";
$str = mb_convert_encoding($text, "utf-8","gb2312");
echo $str;
?>
//mb_substr函数——对字符串进行截取
<?php
$text = "编程词典";
$str = mb_substr($text, 2,5,"UTF-8");
echo $text;
?>
/**预定义变量*/
//SERVER——服务器变量
//ENV——获取系统环境变量中的值
//COOKIE——获取http cookie传递的变量组成的数组
//GET——获取通过get方法传递的变量组成的数组
//POST——获取通过post方法传递的变量组成的数组
//FILES——获取已上传文件项目组成的数组
//REQUEST——包含$_GET、$_POST和$_COOKIE中的全部内容
//SESSION——获取session变量中的数组
//GLOBALS——获取所有全局变量组成的数组
//$php_errormsg——获取前一个错误信息

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台