php基础语法

===PHP基础语法====

【变量，常量】
   
    严格区分大小写，但内置结构或关键字无所谓(echo)

    命名：不能以数字，空格，.来开头，但是可以有汉字，eg：$变量="aa";

    可变变量：$a='aa';$$a="bb";则 $aa="bb";

    引用赋值：$a="aa"; $b=&$a; 则改变$a的值，$b也变化。不同：存储结构是分开的，即使unset($a),$b还在(区分C语言)

    变量类型：int str array bool object float resource null

    全局变量：全局变量本身就是静态存储方式,所有的全局变量都是静态变量

            $_SESSION,  $_COOKIE,  $_POST,  $_GET,  $_REQUEST, $_FILES,$_EVN

    静态变量：static  
             
    静态方法：静态方法不需要所在类被实例化就可以直接使用。Math::Max($a,$b);（未实例化Math类直接调用静态方法Max）

    常量：
        define("NAME",$value,[TRUE]);//如果第三个参数为true，则不区分大小写，默认是区分大小写的
        预定义常量：
              PHP_OS="WINDOWS";  PHP_VERSION="版本";
              E_ERROR=1,错误，导致脚本终止;  E_WARNING=2，警告，脚本不终止 ；E_NOTICE=8,非关键性错误
        魔术常量：【全是返回物理路径，即使被包含输出，输出的也是源头代码的信息，非当前包含文件的信息，和$_SERVER区分】
              __FILE__     当前文件名称
              __CLASS__    当前类名称
              __FUNCTION__ 当前函数名称
              __METHOD__   当前方法名称
              __LINE__     当前行数名称

总结：
   
 (全局)常量：（默认常量就是全局的）存储在(静态)数据段

【变量】
   
全局变量：存储在静态数据段
   
局部变量：存储在栈中
   
静态变量：(不管全局/局部)存储在静态数据段中

【类型转换】

    1.setType($a);//获取变量的类型

    2.$b=(int)$a;//把$a转换为整形
       $b=intval($a);

    3.is_int($b);//判断$b是否为整形，返回bool值

    类型转换：(int),(bool),(float),(),(string),(),(array),(),(object);
             intval(),floatval();strval()
    判断类型：
             is_bool/int/float/string/array/object/resource/null
             is_numberic();'//判断是否为任何类型的数字或者数组字符串
             is_callable();//判断是否为有效函数名称
【运算符】

     算数运算符：+ - * / % ++ --

     连接运算符： .

     赋值运算符： =, +=,-=,*=,/=,%=,.=

     比较运算符：>,<,==,===,!= <>,!==

     逻辑运算符： and,&&  ;   or,||   ;   not,!  ;  xor(逻辑异或，两边不同返回TRUE，相同返回FALSE)

     位运算符    ： & ；|；^(异或，不同返回1)；~(非运算符，1.0取反)；<<左移，右边空出的补0；>>右移左边空出的补0

     其他运算符：
                ?:  三目运算符    举例：$a=$bool?$b:$c; //若$bool成立，$a=$b;否则$a=$c
                @ 忽略错误
                =>数组下标用
                ->调用对象值用
                ``反引号为执行运算符
               instanceof 类型运算符  class ClassOne{} $a=new ClassOne(); var_dump(  $a instanceof ClassOne  );//返回true

【流程控制】

        1.if(){}else{}
        2.while(){};
        3.do{}while();$
        4.for($a=1;$a<10;$a++){}
        5.switch($a){
            case 1:echo 1; break;
            case 2:echo 2;break;
            default: echo "this is defaut value";
            }
        continue,break;exit   
    区别：
        continue跳过当前循环，循环还在继续
        break 跳出当前循环，循环终止
        exit;   终止当前脚本，这行代码后边的代码不执行了就
【函数】
   命名：遵循变量命名规则即可，函数不可一被重载、
   作用：函数实现了结构化编程，提高了代码的可维护性
   
    全局变量：整个脚本中皆可以使用

    局部变量：只有在函数体内使用，执行完函数自动释放
       |---> 分为静态存储类型和动态存储类型；  static $a为静态变量，函数执行完后，不会被释放

    函数内局部变量编程全局变量：1.global ; 2.$GLOBAL['']使用全局数组   

    几种类型函数
    1.引用参数的函数：function(&$a){}//函数内对形参$a的操作，会对实参也造成影响 eg:sort()
    2.默认参数的函数：function($a=0){}//没有参数传入的话，默认$a=0
    3.可变参数个数的函数：function($a,$b$c,...){}
        //原理：通过fun_get_args()函数，接受所有参数并返回一个数组来使用，所以可以有多个参数  EG: echo(),array_merge()
    4.回调函数：$fun="one"; function one(){}  当调用$fun()的时候，就是再调用one()函数，call_user_func_array()
    5.递归函数：function test(){ test()}//在函数中再次调用函数，但注意死循环的问题，要有执行结束跳出

【PHP 面向对象详解】

对象的主要三个特性

对象的行为：可以对 对象施加那些操作，开灯，关灯就是行为。
对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。
对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。

【面向对象模型】

面向对象的概念：oop(面向对象的编程)它能是其代码更加简洁易于维护并且具有更强的可重性

什么是类：类是具有相同属性和服务的一组对象的集合比如说人，书，轮船，车都属于类，他为属于该类的对象做了一个统一的抽象描述，在编程的语言中类是一个单独的程序，它应该有一个类名包括属性的说明和服务两个部分。

什么是对象：对象是系统中描述客观事件的一个实体，他是构成系统的一个基本单位。*数据与代码都被捆绑在一个实体当中*，一个对象由一组属性和对这组属性进行操作的一组行为组成。

从抽象的角度来说，对象是问题域或实现域中某些事物的一个抽象。他反映该事物在系统中保存的信息和发挥的作用：它是一组属性和有权对这些属性进行操作的一个封装体。客观世界是由对象和对象之间的联系组成的。

类和对象的关系：类与对象的关系就如模具和铸件的关系，类的实力化的结果就是对象，而对对象的抽象就是类，类描述了一组有相同特性（属性）和相同行为的对象。

【类与属性和方法】

PHP中定义类语法格式：

class classname [可选属性]{
public $property [=value];… //用public声明一个公共标识 然后给予一个变量 变量也可以赋值
function functionname ( args ){ //类的方法里的成员函数
代码} …
//类的方法（成员函数）
}

生成对象(类的实例化): $对象名=new classname( );

【使用对象的属性】

在一个类中，可以访问一个特殊指针$this当在该类中通过一个操作设置或访问该变量时,使用$this->name来引用.

【对象的生成】

定义好类后用一个new来声明，由于对象资料的封装特性，对象是无法由主程序区块直接访问的须通过对象来调用类中所定义的属性和行为函数，间接地达成存取控制类中资料的目的。

【对象和类的关系】

对象是实际存在的，占有动态资源。
类是对象的蓝图，可能占有静态资源。
对象属性占有动态资源
类（静态）属性实际上是有类名字空间上的"全局变量"

性能考虑:
每个对象要单独占用数据空间
增加的调用层次可能消耗执行时间
方法的参数形式和传递方式
方法的参数可以是基本数据类型、数组和类对象。
基本数据类型：值参传递
数组：值参传递
类对象：引用传递

【构造函数】

构造函数是在类中起到初始化的作用
构造函数的生成方法与其他函数一样只是其名称必须是__construct().
语法格式：
function __construct(参数){
。。。。。。。。
}
范例：
代码如下:
class Person{
public $name;
public $sex;
public $age;
function __construct($name,$sex,$age){
echo "我是构造函数<br>";
$this->name=$name;
$this->sex=$sex;
$this->age=$age;
}

输出结果：初始化

【析构函数】

当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。应在退出前在析构函数中用释放内存。
析构函数__destruct 析构函数没有任何参数
范例：
代码如下:

class person{
function _ _destruct( )
{ echo "bye bye !"; }
}
$a=new person();

【访问类型】
public 公共的（公共修饰符） 类内部与类外部都可以访问的
private 私有的（私有修饰符） 只能在类内部访问
protected 受保护的（保护成员修饰符） 子类可以访问 类外部不可以访问

【oop的三个重要特性】

封装，继承，多态

封装性：封装性就是把对象的属性和行为结合成一个独立的单位。

封装一个类需要两步 第一步是私有化一个类 第二步是用set和get 做出读取赋值的操作
他的好处是：隐藏类的实现细节，可以方便加入逻辑控制性，限制对属性的不合理操作，便于修改增强代码的可维护性。

__get与__set

一般说把类私有话更符合现实的逻辑。

预定义两种函数来进行获取与敷值操作。
__get 获取值通常是域的值
__set 设置值通常是域的值
__call 调用一个对象中不存在的方法时，就会产生错误call()这个方法来处理这种情况。

【静态属性和方法】

static关键字 来声明静态方法
static静态变量 在类的内部生成一个静态变量 就是能够被所有类的实力化共想 也就是说静态成员则放到了"初始化静态段"，在类第一次被加载的时候放入的，可以让堆内存里面的每个对象所共享
使用方法：self::$静态属性、self::静态方法
static function p(){
echo self::$country;
echo self::PI;//访问常量
//echo $this->name;在静态方法中只能操作静态属性
//self::p();
}
外部调用：类::$静态属性、类::静态方法

const关键字：用来生成常量 常量是唯一的不能改变的 惯例常量为大写
const CONSTANT = 'constant value'; 生成一个常量
echo self::CONSTANT;//类内部访问
echo ClassName::CONSTANT;//类外部访问

继承性

B类的对象拥有A类的全部属性与行为，称作B对A类的继承。
假如一个类从多个类中继承了属性与服务，这称为多继承，通常我们成为继承类为子类被继承类为父类，在PHP中只有单继承，但一个父类可以被多个类继承，但是一个子类只能有一个父类，但是允许关联继承，通过继承可以减化类的定义。
extende声明继承关系
语法格式：class B extends A 此范例指明 B继承了A
类的外部访问对子类是有效的
子类与父类的属性与方法
子类继承父类的所有内容，但父类中的private部分不能直接访问
子类中新增加的属性和方法是对父类的扩展
子类中定义的与父类同名的属性是对父类属性的覆盖，同名的方法也是对父类方法的覆盖

重写的方法

在子类中，使用parent访问父类中的被覆盖的属性和方法

parent::__construce();
parent::$name;
parent::fun();

覆盖父类原有属性
clone克窿对象 语法格式$c=clone $p; $c克窿的对象$p 输出echo $c->name;

对象比较
===两个比较运算符。
==是比较两个对象的内容。
===是比较对象的句柄，即引用地址。

instanceof操作符用于检测对象实力是否属于某一个类的类型 属于返回true 不属于返回false
__clone()如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法
function __clone(){
$this->name="我是一个克隆人";
}

final表示一个类是最终版本 也就是说它不能在被子类调用

多态性

多态性是指在父类中定义的属性或行为被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及其各个子类中具有不同的语义。
就是说同一种方法在子类与父类中执行的结果不同。
代码如下:

class A {
function info(){
echo "A INFO";
}
}
class B extends A {
function info(){
echo "B INFO";
}
}
class C extends A {
function info(){
echo "C INFO";
}
}
function printinfo($obj){
function printinfo(A $obj){
if($obj instanceof A)
$obj->info();
$obj->info();
}
}
$a=new A(); $b=new B(); $c=new C();
printinfo($a); //输出A INFO
printinfo($b); //输出B INFO
printinfo($c); //输出C INFO


抽象方法和抽象类

抽象方法是作为子类摸版使用的。
复制代码 代码如下:

abstract class Person{
public $name;
abstract function getInfo();
}

抽象类不能被实力话，一个抽象类中，必须有一个抽象方法。但是抽象类中可以定义动态函数。
【接口】
当一个类继承了一个接口之后，它要覆盖接口的所有方法，接口只能声明常量，接口的方法必须定义为共有否则无法继承，接口可以与多个接口间继承
语法：
代码如下:

interface PCI{
const TYPE="PCI";
//public $name; error
function start();
function stop();
}

接口中的方法可以声明为static
代码如下:

interface A{ function a();}
interface B{ function b();}
interface C extends A{ function c();}
class D implements B,C{
function a(){}
function b(){}
function c(){}
}

【类】
类的声明:
代码如下:

<?php
　　　　权限修饰符 class 类名{ //权限修士符号:public,protected,private 或者省略3者.
　　　　　　//类体;　　　　　　　　//class 是建类关键字
　　　　}　　　　　　　　　　　　　//类名必须跟在class 后面,且跟上{}.{}之间放类的成员.
　　?>
//ps:在class关键字前可以加权限修饰符外,还可以加static,abstract等关键字.一个类,即一对大括号之间的全部内容都要在一段代码段中,不允许将类中的内容分割成对块.
<?php
　　class ConnDB{
　　　　//....
?>
<?
　　　　//...
　　};
?>

成员属性:
　　在类中直接声明的变量称为成员属性/变量.其类型可以为php中的标量类型和复合类型,使用资源类型和空类型是无效的.
此外,成员属性的声明时,必须要有关键字来修饰:有特定意义的关键字:public,protected,private ;不需要特定意义:var.声明成员属性时,没有必要赋初始值.

成员常量:

　　以const常量修饰,例如:const PI = 3.1415926;
　　常量的输出不需要实例化,直接由类名+常量名调用即可,格式为: 类名::常量名
ps. 特殊的访问方法:--------"$this" 和 "::"
1) $"this" 存在于每个成员方法当中,它是一个特殊的对象以用方法.成员方法属于那个对象,$this应用就代表那个对象,其作用就是专门完成对象内部成员之间的访问.
2) "::"成为作用域操作符,使用这个操作符可以在不创建对象的情况下调用类中的常量,变量和方法.　其语法格式如下:

　　关键字::变量名/常量名/方法名

　　关键字:parent,可以调用父类成员中的成员变量,成员方法和常量;
　　　　　 self,可以调用当前类中的静态成员和常量;
　　　　　 类名,可以调用类中的常量,变量和方法;　　　
　　
成员方法:

　　在类中声明的函数成为成员方法,在一个类中可以声明多个函数,即对象可以拥有多个成员方法.成员方法的声明和函数的声明相同,唯一特殊之处就是成员方法可以有关键字对它进行修饰,从而控制其访问权限.
类的实例化

　　创建对象:

　　　　$变量名 = new 类名称([参数]); //类的实例化.
　　访问类成员:
　　　　$变量名 -> 成员属性 = 值;
构造方法和析构方法
构造方法是对象创建完成后第一个呗对象自动调用的方法.它存在每个类的声明当中,是一个特殊的成员方法,一般用来完成一些初始化操作.如果类中没有构造方法,系统会默认自动生成一个没有参数的构造方法.
　　格式:
复制代码 代码如下:

function _construct(形参列表){
　　　　　　//方法体
　　　　};

析构方法则如构造方法相反,它是在对象被销毁前最后一个调用的方法.它将完成一个特定的操作,如关闭文件和释放内存.
　　格式:
复制代码 代码如下:

function _destruct(){
　　　　　　//方法体　
　　　　};

面向对象特点:封装性,抽象性,多态性.

封装:
　　将类中的成员属性和方法结合成一个独立的相同单位,并且尽可能的隐藏对象的内容细节.其目的是确保类以外的部分不能随意存取类的内部数据(成员属性和成员方法),从而避免外部错误对内部数据的影响.
　　类的封装是通过关键字public,private,protected,static和final实现的.各关键字的作用请查看php相关文档.
继承性:
　　使一个类继承并拥有另一个已存在的类的成员属性和成员方法,其中被继承的类成为父类,继承的类成为子类.通过继承能够提高代码的重用性和可维护性.类的继承用 extends 关键字.
　　格式:
代码如下:

class 子类名称 extends 父类名称{
　　　　　　//子类方法体.
　　　　}

通过parent::关键字也可以在子类方法中调用父类的成员方法,格式如下:
　　parent::父类的成员方法(参数);

覆盖父类的方法:

　　所谓的覆盖父类的方法,也就是使用子类中的方法替换从父类中继承的方法,也叫方法的重写.重写的关键就在与子类中创建与父类中相同的方法,g包括方法名称,参数和返回类型.

多态性:
　　多态性是指一段程序能够处理多种类型对象的能力.php多态有两种实现方法,即通过继承实现多态和通过接口实现多态.
通过继承实现多态,即通过重写继承的成员方法来达到多态的效果.
代码如下:


<?php
abstract class ParentClass{
abstract function printMessage();
}
class SubClassA extends ParentClass{
function printMessage(){
echo "i am message from class A";
}
}
class SubClassB extends ParentClass{
function printMessage(){
echo "i am message from class B";
}
}
function printMSG($object){
if( $object instanceof ParentClass){
$object->printMessage();
}else{
echo "error!";
}
}
$objectA=new SubClassA();
printMSG($objectA);
$objectB=new SubClassB();
printMSG($objectB);
?>

通过接口实现多态,通过定义接口,与空方法.然后类继承接口.
代码如下:


<?php
interface interfaceInfo{
function printMessage();
}
class ClassA implements interfaceInfo{
function printMessage(){
echo "message form class A";
}
}
class ClassB implements interfaceInfo{
function printMessage(){
echo "message form class B";
}
}
function printMSG($object){
if($object instanceof interfaceInfo){
$object -> printMessage();
}else{
echo "error !";
}
}
$objectA =new ClassA();
printMSG($objectA);
$objectB =new ClassB();
printMSG($objectB);
?>

ps. 抽象类和接口.
抽象类和接口都是不能被实例化的特殊类.他们都是能够配合面向对象多态性一起使用.
抽象类:
　　抽象类是一种不能实例化的类,只能作为其他类的父类来使用.抽象类使用abstract 关键字来声明,其格式如下:
复制代码 代码如下:

abstract class 抽象类名{
　　　　　　abstract function 成员方法(参数);//
　　　　}

抽象类和普通类相似,包含成员变量,成员方法.两者区别在于抽象类至少要包含一个抽象方法.抽象方法没有方法体,其功能的实现只能在子类中完成.抽象方法也使用关键字 abstract 来修饰.

接口:
　　继承特性简化了对象和类的创建,增强了代码的可重用性.但php只支持单继承,如果想实现多重继承,就要使用接口.
接口的声明:通过interface 关键字来实现,接口中声明的方法必须是抽象方法,接口中不能声明变量,只能使用const 关键字声明为常量的成员属性,并且接口中所有成员都必须具备puclic 的访问权限.ainterface 声明接口格式如下:
复制代码 代码如下:

inerface 接口名称{
　　 //常量成员;//成员只能是常量.
　　 //抽象方法;
　　}

由于接口不能实现实例化操作,因此只能借助子类继承接口的形式来实现.实现的格式是:
复制代码 代码如下:

Class 子类名 implements 接口名1[,接口名2,接口名3,.....]{
　　//子类方法体.
}

常用关键字:
　　1) final:final之意为最终的,最后的.这就以为着通过final 关键字修饰的类和方法都为最终版本.不能被继承,也不能有子类.不能重写,也不能被覆盖.
　　2) static: 通过static 关键字修饰的成员属性和成员方法称为静态属性和静态方法.静态成员属性和方法不需要被实例化就能直接使用.
　　　静态属性:它属于类本身,而不属于类的任何实例.它相当于存储在类中的全局变量,可以在任何位置通过类来访问.访问格式为:
　　　　　　类名称::$静态属性名称;
　　　　　　如果你要在类内部的成员方法中访问静态属性,那么在静态属性的名称前加上操作符: "self::" 即可.
　　　静态方法:由于其不受任何对象限制,因此可以不通过类的实例化而直接引用类中的静态方法.引用格式如下:
　　　　　　类名称::静态方法名(参数);
　　　　　　如果你要在类内部的成员方法中调用静态方法,那么在静态方法的名称前加上操作符: "self::" 即可.在静态方法中只能调用静态变量,而不能调用普通变量;而普通方法中则可以调用静态变量.
使用静态成员除了不需要实例化外,另一个作用是在对象被销毁后,仍然保留呗修改的静态数据,以便下次调用.
　　3) clone.对象的克隆可以通过关键字来实现.使用clone对象与原对象没有任何关系,即克隆对象会重新申请一份存储空间来存放原对象内容.格式如下:
　　　　　　$克隆对象 = clone $原克隆对象名称;
　　　　克隆成功后,他们的n成员方法,属性以及值完全相等.如果要对副本重新初始化,就要用到 _clone().
　　　　　魔术方法_clone()可以对克隆后的副本对象重新初始化.它不需要任何参数,其中自动包含$this (副本对象)和 $that (原对象) 对象的引用.
对象的比较:
　　"==" 表示比较两个对象的内容,"==="表示比较两个对象的引用地址相等.
对象类型的检测: instanceof 操作符可以检测当前对象属于那个对象.

【面向对象---常用魔术方法】

以上我们已经了解的常用魔术方法有:_construct(),_destruct(),_clone.下面我们再接着介绍几个常用魔术方法.
_get(),_set();
　　以上两个方法用于对私有成员精细复制或者获取值的操作.
　　_set()在程序运行中为私有的成员属性设置值,它不需要任何返回值._set()方法包括两个不可省略的参数:变量名和变量值.这个方法不需要主动调用,可在方法钱加上prive关键字.
　　_get():在程序运行中,在对象的外部获取私有成员的属性的值.他有一个参数:私有成员属性名称.他返回一个允许对象在外部使用的值.此方法同样不许主动调用.

_isset(),_unset():
　　isset()函数用于检测变量是否存在.而在面向对象中可以通过isset()函数对公有的成员属性进行检测,但对私有成员属性,此函数则不起作用.因此,_isset()函数正是为了起到此作用而创建.格式如下:
　　bool _isset(string name);
　　_unset()则同样为了删除制定的变量和对象的私有成员属性.格式如下:
　　void _unset(string name);//
_call():
　　_call()方法的作用是当程序试图调用不存在或不可见的成员方法时,php会先调用_call()方法来存储方法名及其参数(方法名和方法参数).其中方法参数是以数组的形式存在.
_toString()方法:
　　其作用是当使用echo 或者print输出对象时,将对象转化为字符串.
　　如果没有_toString()方法,直接输出对象时将会发生致命错误.
　　输出对象时应注意的是,echo 或print 语句后面直接跟要输出的对象,中间不要加多余的字符,否则_toSting()将不会被执行.
_autoload()方法:
　　将一个独立的,完整的类保存到一个php页中,并且文件名和类名保持一致,这是每个开发人员都需要养成的良好习惯.这样下次在使用的时候就能够轻松的找到它.但有一种情况:如果要在一个页面中引进很多的类,就需要使用include_once()函数或者require_once()函数一个个地引入.php5中引入_autoload()方法可以自动实例化需要使用的类.当一个类还没实例化时,_autoload()会自动到指定的路径下面自动查找和类名相同的文件.找到则继续执行,否则报错.
代码如下:


<?php
　　function _autoload($class_name){
　　　　$class_path = $class_name.'.class.php';
　　　　if(file_exists($class_path)){
　　　　　　include_once($class_path);
　　　　}else{
　　　　　　echo '类不存在或者类路径错误';
　　　　}
}
　　$class = new Class(); //将会自动加载.
　　echo $class; //输出类内容.如自定义了_toString()方法;则会输出_toString()中定义的内容.
?>


[PHP常用函数总结]

数学函数

【1.abs(): 求绝对值】

$abs = abs(-4.2); //4.2 数字绝对值数字

【2.ceil(): 进一法取整】

echo ceil(9.999); // 10 浮点数进一取整

【3.floor(): 舍去法取整】

    echo floor(9.999); // 9 浮点数直接舍去小数部分

【4.fmod(): 浮点数取余】

$x = 5.7;
$y = 1.3; // 两个浮点数,x>y 浮点余数
$r = fmod($x, $y);
// $r equals 0.5, because 4 * 1.3 + 0.5 = 5.7

【5.pow(): 返回数的n次方】

    echo pow(-1, 20); // 1 基础数|n次方乘方值

【6.round(): 浮点数四舍五入】

    echo round(1.95583, 2); // 1.96, 一个数值|保留小数点后多少位,默认为0 舍入后的结果

【7.sqrt(): 求平方根】

    echo sqrt(9); //3 被开方的数平方根

【8.max(): 求最大值】

    echo max(1, 3, 5, 6, 7); // 7

多个数字或数组 返回其中的最大值

    echo max(array(2, 4, 5)); // 5

【9.min(): 求最小值】

输入: 多个数字或数组

输出: 返回其中的最小值

【10.mt_rand(): 更好的随机数】

输入: 最小|最大, 输出: 随机数随机返回范围内的值

    echo mt_rand(0,9);//n
【11.rand(): 随机数 输入: 最小|最大, 输出: 随机数随机返回范围内的值】

【12.pi(): 获取圆周率值】

去空格或或其他字符:

【13.trim(): 删除字符串两端的空格或其他预定义字符】
    
$str = "\r\nHello World!\r\n";
echo trim($str);

输入: 目标字符串 返回值: 清除后的字符串

【14.rtrim(): 删除字符串右边的空格或其他预定义字符】

    
$str = "Hello World!\n\n";
echo rtrim($str);

【15.chop(): rtrim()的别名】

【16.ltrim(): 删除字符串左边的空格或其他预定义字符】


$str = "\r\nHello World!";
echo ltrim($str);

【17.dirname(): 返回路径中的目录部分】

    echo dirname("c:/testweb/home.php");  //c:/testweb
输入: 一个包含路径的字符串 返回值: 返回文件路径的目录部分

字符串生成与转化：　　

【18.str_pad(): 把字符串填充为指定的长度】
    
$str = "Hello World";
echo str_pad($str,20,".");

输入: 要填充的字符串|新字符串的长度|供填充使用的字符串, 默认是空白

输出: 完成后的字符串

【19.str_repeat(): 重复使用指定字符串】

    echo str_repeat(".",13); // 要重复的字符串|字符串将被重复的次数13个点
【20.str_split(): 把字符串分割到数组中】

print_r(str_split("Hello"));
输入: 要分割的字符串|每个数组元素的长度，默认1

输出: 拆分后的字符串数组

【21.strrev(): 反转字符串】

    echo strrev("Hello World!"); // !dlroW olleH
输出: 目标字符串颠倒顺序后的字符串

【22.wordwrap(): 按照指定长度对字符串进行折行处理】
    
$str = "An example on a long word is:
Supercalifragulistic";
echo wordwrap($str,15);

输入: 目标字符串|最大宽数

输出: 折行后的新字符串

【23.str_shuffle(): 随机地打乱字符串中所有字符】

    echo str_shuffle("Hello World");
输入: 目标字符串顺序 输出: 打乱后的字符串

【24.parse_str(): 将字符串解析成变量】

    
parse_str("id=23&name=John%20Adams", $myArray);
print_r($myArray);

输入: 要解析的字符串|存储变量的数组名称

输出: 返回Array( [id] => 23 [name] => John Adams)

【25.number_format(): 通过千位分组来格式化数字 输入: 要格式化的数字|规定多少个小数|规定用作小数点的字符 串|规定用作千位分隔符的字符串】

输出: 1,000,000 1,000,000.00 1.000.000,00

大小写转换：

【26.strtolower(): 字符串转为小写】

    echo strtolower("Hello WORLD!");
目标字符串 小写字符串

【27.strtoupper(): 字符串转为大写】

    echo strtoupper("Hello WORLD!");
输出: 大写字符串

【28.ucfirst(): 字符串首字母大写】

    echo ucfirst("hello world"); //　Hello world
【29.ucwords(): 字符串每个单词首字符转为大写】

    echo ucwords("hello world"); //　Hello World
html标签关联:

【30.htmlentities(): 把字符转为HTML实体】
    
$str = "John & 'Adams'";
echo htmlentities($str, ENT_COMPAT); // John & 'Adams'

【31.htmlspecialchars(): 预定义字符转html编码】

【32.nl2br(): \n转义为<br>标签】

    echo nl2br("One line.\nAnother line.");
输出: 处理后的字符串

【33.strip_tags(): 剥去 HTML、XML 以及 PHP 的标签】

    echo strip_tags("Hello <b>world!</b>"); 　
【34.addcslashes():在指定的字符前添加反斜线转义字符串中字符】

    
$str = "Hello, my name is John Adams.";
echo $str;
echo addcslashes($str,'m');

输入: 目标字符串|指定的特定字符或字符范围

【35.stripcslashes(): 删除由addcslashes()添加的反斜线】

    echo stripcslashes("Hello, \my na\me is Kai Ji\m.");
    // 目标字符串 Hello, my name is Kai Jim.
【36.addslashes(): 指定预定义字符前添加反斜线】

    $str = "Who's John Adams?";
echo addslashes($str);
输出: 把目标串中的' " \和null进行转义处理

【37.stripslashes(): 删除由addslashes()添加的转义字符】

    echo stripslashes("Who\'s John Adams?"); // 清除转义符号Who's John Adams?
【38.quotemeta(): 在字符串中某些预定义的字符前添加反斜线】
    
$str = "Hello world. (can you hear me?)";
echo quotemeta($str);
 //　Hello world\. \(can you hear me\?\)

【39.chr(): 从指定的 ASCII 值返回字符】

    echo chr(052); // ASCII 值返回对应的字符
【40.ord(): 返回字符串第一个字符的ASCII值】

    echo ord("hello"); 字符串第一个字符的 ASCII 值
字符串比较：

【41.strcasecmp(): 不区分大小写比较两字符串】

    echo strcasecmp("Hello world!","HELLO WORLD!");
输入: 两个目标字符串 输出: 大1|等0|小 -1

【42.strcmp(): 区分大小写比较两字符串】

【43.strncmp(): 比较字符串前n个字符,区分大小写】

调用: int strncmp ( string $str1 , string $str2 , int $len) 　

【44.strncasecmp(): 比较字符串前n个字符,不区分大小写】

调用: int strncasecmp ( string $str1 , string $str2 , int $len )

【45.strnatcmp(): 自然顺序法比较字符串长度,区分大小写】

调用: int strnatcmp ( string $str1 , string $str2 )

输入: 目标字符串　

【46.strnatcasecmp(): 自然顺序法比较字符串长度, 不区分大小写】

调用: int strnatcasecmp ( string $str1 , string $str2 )

字符串切割与拼接：

【47.chunk_split()：将字符串分成小块】

调用: str chunk_split(str $body[,int $len[,str $end]])

输入: $body目标字串, $len长度, $str插入结束符 输出: 分割后的字符串

【48.strtok(): 切开字符串】

调用: str strtok(str $str,str $token)

目标字符串$str，以$token为标志切割返回切割后的字符串

【49.explode(): 使用一个字符串为标志分割另一个字符串】

调用: array explode(str $sep,str $str[,int $limit])

输入: $sep为分割符,$str目标字符串,$limit返回数组最多包含元素数 输出: 字符串被分割后形成的数组

【50.implode(): 同join,将数组值用预订字符连接成字符串】

调用: string implode ( string $glue , array $pieces )

$glue默认, 用''则直接相连

【51.substr(): 截取字符串】

调用: string substr ( string $string , int $start [, int $length ] )

字符串查找替换：

【52.str_replace(): 字符串替换操作,区分大小写】

调用mix str_replace(mix $search,mix $replace, mix $subject[,int &$num])

输入: $search查找的字符串,$replace替换的字符串,$subject被查找字串, &$num 输出: 返回替换后的结果

【53.str_ireplace() 字符串替换操作,不区分大小写】

调用: mix str_ireplace ( mix $search , mix $replace , mix $subject [, int &$count ] )

输入: $search查找的字符串,$replace替换的字符串,$subject被查找字串,&$num 输出: 返回替换后的结果

【54.substr_count(): 统计一个字符串,在另一个字符串中出现次数】

调用: int substr_count ( string $haystack , string $needle[, int $offset = 0 [, int $length ]] )

【55.substr_replace(): 替换字符串中某串为另一个字符串】

调用: mixed substr_replace ( mixed $string, string $replacement,int $start [, int $length ] )

【56.similar_text(): 返回两字符串相同字符的数量】

调用: int similar_text(str $str1,str $str2)
输入: 两个比较的字符串

输出: 整形,相同字符数量

【57.strrchr(): 返回一个字符串在另一个字符串中最后一次出现位置开始到末尾的字符串】

调用: string strrchr ( string $haystack , mixed $needle )

【58.strstr(): 返回一个字符串在另一个字符串中开始位置到结束的字符串】

调用: string strstr ( string $str, string $needle , bool $before_needle ) 　　

【59.strchr(): strstr()的别名,返回一个字符串在另一个字符串中首次出现的位置开始到末尾的字符串】

调用: string strstr ( string $haystack , mixed $needle [, bool $before_needle = false ] ) 　　

【60.stristr(): 返回一个字符串在另一个字符串中开始位置到结束的字符串，不区分大小写】

调用:string stristr ( string $haystack , mixed $needle [, bool $before_needle = false ] )

【61.strtr(): 转换字符串中的某些字符】

调用: string strtr ( string $str , string $from , string $to )

【62.strpos(): 寻找字符串中某字符最先出现的位置】

调用: int strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )

【63.stripos(): 寻找字符串中某字符最先出现的位置,不区分大小写 调用: int stripos ( string $haystack , string $needle [, int $offset ] )】

【64.strrpos(): 寻找某字符串中某字符最后出现的位置】

调用: int strrpos ( string $haystack , string $needle [, int $offset = 0 ] )

【65.strripos(): 寻找某字符串中某字符最后出现的位置,不区分大小写】

调用: int strripos ( string $haystack , string $needle [, int $offset ] )

【66.strspn(): 返回字符串中首次符合mask的子字符串长度 调用: int strspn ( string $str1 , string $str2 [, int $start [, int $length ]] )】

【67.strcspn(): 返回字符串中不符合mask的字符串的长度】

调用: int strcspn ( string $str1 , string $str2 [, int $start [, int $length ]] )

输入: $str1被查询,$str2查询字符串，$start开始查询的字符，$length是查询长度 输出: 返回从开始到第几个字符

字符串统计：

【68.str_word_count(): 统计字符串含有的单词数】

调用: mix str_word_count(str $str,[])

输入: 目标字符串 输出: 统计处的数量

【69.strlen(): 统计字符串长度int strlen(str $str)】

输入: 目标字符串 输出:整型长度

【70.count_chars(): 统计字符串中所有字母出现次数(0..255) 调用: mixed count_chars ( string $string [, int $mode ] )】

字符串编码：

【71.md5(): 字符串md5编码】

$str = "Hello";
echo md5($str);

数组函数

数组创建：

【72.array(): 生成一个数组】
    
$a=array("Dog","Cat","Horse");
print_r($a);


数组值或,键=>值一个数组型变量

【73.array_combine(): 生成一个数组,用一个数组的值 作为键名,另一个数组值作为值】

    $a1=array("a","b","c","d");
    $a2=array("Cat","Dog","Horse","Cow");
    print_r(array_combine($a1,$a2));
$a1为提供键,$a2提供值合成后的数组

【74.range(): 创建并返回一个包含指定范围的元素的数组。】

    $number = range(0,50,10);
    print_r ($number);
输入: 0是最小值,50是最大值,10是步长 输出: 合成后的数组

【75.compact(): 创建一个由参数所带变量组成的数组】
    
$firstname = "Peter";
$lastname = "Griffin";
$age = "38";
$result = compact("firstname", "lastname",
"age");
print_r($result);

变量或数组

返回由变量名为键,变量值为值的数组,变量也可以为多维数组.会递归处理

【76.array_fill(): 用给定的填充(值生成)数组】

    
$a=array_fill(2,3,"Dog");
print_r($a);

2是键,3是填充的数量,'Dog'为填充内容返回完成的数组

数组合并和拆分：　　　　

【77.array_chunk(): 把一个数组分割为新的数组块】
    
$a=array("a"=>"Cat","b"=>"Dog","c"=>"Horse","d"=>"Cow");
print_r(array_chunk($a,2));

一个数组分割后的多维数组，规定每个新数组包含2个元素

【78.array_merge(): 把两个或多个数组合并为一个数组。】

$a1=array("a"=>"Horse","b"=>"Dog");
$a2=array("c"=>"Cow","b"=>"Cat");
print_r(array_merge($a1,$a2));

输入: 两个数组 输出: 返回完成后的数组

【79.array_slice(): 在数组中根据条件取出一段值，并返回。】
    
$a=array(0=>"Dog",1=>"Cat",2=>"Horse",3=>"Bird");
print_r(array_slice($a,1,2));

输入: 一个数组 输出: 1为从'Cat'开始，2为返回两个元素

数组比较：

【80.array_diff(): 返回两个数组的差集数组】
    
$a1=array(0=>"Cat",1=>"Dog",2=>"Horse");
$a2=array(3=>"Horse",4=>"Dog",5=>"Fish");
 print_r(array_diff($a1,$a2)); //返回'Cat'

输入: 两个或多个数组 输出: $a1与$a2的不同之处

【81.array_intersect(): 返回两个或多个数组的交集数组 输出: 返回'Dog'和'Horse',$a1与$a2的相同之处】

数组查找替换： 　　　　

【82.array_search(): 在数组中查找一个值，返回一个键，没有返回返回假】
    
$a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse");
echo array_search("Dog",$a);

输入: 一个数组 输出: 成功返回键名,失败返回false

【83.array_splice(): 把数组中一部分删除用其他值替代】
    
$a1=array(0=>"Dog",1=>"Cat",2=>"Horse",3=>"Bird");
$a2=array(0=>"Tiger",1=>"Lion");
array_splice($a1,0,2,$a2);
print_r($a1);

输入: 一个或多个数组 输出: $a1被移除的部分由$a2补全

【84.array_sum(): 返回数组中所有值的总和】

$a=array(0=>"5",1=>"15",2=>"25");
echo array_sum($a);

输入: 一个数组 输出: 返回和

【85.in_array(): 在数组中搜索给定的值,区分大小写】
    
$people = array("Peter", "Joe", "Glenn", "Cleveland");
if (in_array("Glenn",$people) {
echo "Match found";
}
else{
echo "Match not found";
}

输入: 需要搜索的值|数组 输出: true/false

【86.array_key_exists(): 判断某个数组中是否存在指定的 key】

输入: 需要搜索的键名|数组

数组指针操作：

【87.key(): 返回数组内部指针当前指向元素的键名】 　　　

【88.current(): 返回数组中的当前元素(单元).】 　　　

【89.next(): 把指向当前元素的指针移动到下一个元素的位置,并返回当前元素的值】 　　　

【90.prev(): 把指向当前元素的指针移动到上一个元素的位置,并返回当前元素的值】 　　　

【91.end(): 将数组内部指针指向最后一个元素，并返回该元素的值(如果成功)】 　　　

【92.reset(): 把数组的内部指针指向第一个元素，并返回这个元素的值】 　　　

【93.list(): 用数组中的元素为一组变量赋值】
    
$my_array=array("Dog","Cat","Horse");
list($a, $b, $c) = $my_array;


输入: $a, $b, $c为需要赋值的变量 输出: 变量分别匹配数组中的值

【94.array_shift(): 删除数组中的第一个元素，并返回被删除元素的值】
    
$a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse");
echo array_shift($a);
print_r ($a);

【95.array_unshift(): 在数组开头插入一个或多个元素】

$a=array("a"=>"Cat","b"=>"Dog");
array_unshift($a,"Horse");
print_r($a);

【96.array_push(): 向数组最后压入一个或多个元素】
    
$a=array("Dog","Cat");
array_push($a,"Horse","Bird");
print_r($a);

输入: 目标数组|需要压入的值 返回值: 返回新的数组

【97.array_pop(): 取得（删除）数组中的最后一个元素】
    
$a=array("Dog","Cat","Horse");
array_pop($a);
print_r($a);

输入: $a为目标数组 输出: 返回数组剩余元素

数组键值操作: 　　　　

【98.shuffle(): 将数组打乱,保留键名】
    
$my_array = array("a" => "Dog", "b" => "Cat");
shuffle($my_array);
print_r($my_array);

输入: 一个或多个数组 输出: 顺序打乱后的数组

【99.count(): 计算数组中的单元数目或对象中的属性个数】

    
$people = array("Peter", "Joe", "Glenn",
"Cleveland");
$result = count($people);
echo $result;


输入: 数组 输出: 输出元素个数

【100.array_flip(): 返回一个键值反转后的数组】
    
$a=array(0=>"Dog",1=>"Cat",2=>"Horse");
print_r(array_flip($a));


输出: 返回完成后的数组 101.array_keys(): 返回数组所有的键,组成一个数组

    
$a=array("a"=>"Horse","b"=>"Cat","c"=>"Dog");
print_r(array_keys($a));

输出: 返回由键名组成的数组

【102.array_values(): 返回数组中所有值，组成一个数组】

输出: 返回由键值组成的数组

【103.array_reverse(): 返回一个元素顺序相反的数组 元素顺序相反的一个数组，键名和键值依然匹配】

【104.array_count_values(): 统计数组中所有的值出现的次数】

    
$a=array("Cat","Dog","Horse","Dog");
print_r(array_count_values($a));

输出: 返回数组原键值为新键名，次数为新键值

【105.array_rand(): 从数组中随机抽取一个或多个元素,注意是键名!!!】
    
$a=array("a"=>"Dog","b"=>"Cat","c"=>"Horse");
print_r(array_rand($a,1));

$a为目标数组, 1为抽取第几个元素的键名返回第1个元素的键名b

【106.each(): 返回数组中当前的键／值对并将数组指针向前移动一步 调用array each ( array &$array )】

在执行 each() 之后，数组指针将停留在数组中的下一个单元或者当碰到数组结尾时停留在最后一个单元。如果要再用 each 遍历数组，必须使用 reset()。

返回值: 数组中当前指针位置的键／值对并向前移动数组指针。键值对被返回为四个单元的数组，键名为0，1，key和 value。单元 0 和 key 包含有数组单元的键名，1 和 value 包含有数据。 如果内部指针越过了数组的末端，则 each() 返回 FALSE。

【107.array_unique(): 删除重复值，返回剩余数组】
    
$a=array("a"=>"Cat","b"=>"Dog","c"=>"Cat");
print_r(array_unique($a));

输入: 数组 输入: 返回无重复值数组，键名不变

数组排序: 　　

【108.sort(): 按升序对给定数组的值排序,不保留键名】

$my_array = array("a" => "Dog", "b" => "Cat",
"c" => "Horse");
sort($my_array);
print_r($my_array);

输出: true/false 　
【109.rsort(): 对数组逆向排序,不保留键名】　　
【110.asort(): 对数组排序,保持索引关系】　　　
【111.arsort(): 对数组逆向排序,保持索引关】　
【112.ksort(): 系按键名对数组排序】　
【113.krsort(): 将数组按照键逆向排序】
【114.natsort(): 用自然顺序算法对数组中的元素排序】 　　　
【115.natcasesort(): 自然排序,不区分大小写】　　　 　　

文件系统函数

【116.fopen(): 打开文件或者 URL】

    $handle = fopen("ftp://user:password@example.com/somefile.txt", "w");
调用: resource fopen ( string filename, string mode [, bool use_include_path [, resource zcontext]] )

返回值: 如果打开失败，本函数返回 FALSE

【117.fclose(): 关闭一个已打开的文件指针】
    
$handle = fopen('somefile.txt', 'r');
fclose($handle);
bool fclose(resource handle)


输出: 如果成功则返回 TRUE，失败则返回 FALSE

文件属性

【118.file_exists(): 检查文件或目录是否存在】
    
$filename = '/path/to/foo.txt';
if (file_exists($filename)) {
echo "exists";
} else {
echo "does not exist";
}

调用: bool file_exists ( string filename ) 输入: 指定的文件或目录 输出: 存在则返回 TRUE，否则返回 FALSE

【119.filesize(): 取得文件大小】
    
$filename = 'somefile.txt';
echo $filename . ': ' . filesize($filename) .'bytes';

调用: int filesize ( string $filename )

输出: 返回文件大小的字节数，如果出错返回 FALSE 并生成一条 E_WARNING 级的错误

【120.is_readable(): 判断给定文件是否可读】
    
$filename = 'test.txt';
if (is_readable($filename)) {
echo '可读';
} else {
echo '不可读';
}

调用: bool is_readable ( string $filename ) 输出: 如果由 filename指定的文件或目录存在并且可读则返回 TRUE

【121.is_writable(): 判断给定文件是否可写】
    
$filename = 'test.txt';
if (is_writable($filename)) {
echo '可写';
} else {
echo '不可写';
}

调用: bool is_writable ( string $filename ) filename 参数 可以是一个允许进行是否可写检查的目录名

输出: 如果文件存在并且可写则返回 TRUE。

【122.is_executable(): 判断给定文件是否可执行】
    
$file = 'setup.exe';
if (is_executable($file)) {
echo '可执行';
} else {
echo '不可执行';
}

调用: bool is_executable ( string $filename ) 输出: 如果文件存在且可执行则返回 TRUE

【123.filectime(): 获取文件的创建时间】
    
$filename = 'somefile.txt';
echo filectime($filename);

调用: int filectime ( string $filename ) 输出: 时间以 Unix 时间戳的方式返回，如果出错则返回FALSE

【124.filemtime(): 获取文件的修改时间】

$filename = 'somefile.txt';
echo filemtime($filename);

    int filemtime ( string $filename )
输出: 返回文件上次被修改的时间，出错时返回 FALSE。时间以 Unix时间戳的方式返回

【125.fileatime(): 获取文件的上次访问时间】

    
$filename = 'somefile.txt';
echo fileatime($filename);

调用: int fileatime (string $filename)

输出: 返回文件上次被访问的时间, 如果出错则返回FALSE. 时间以Unix时间戳的方式返回.

【126.stat(): 获取文件大部分属性值】
    
$filename = 'somefile.txt';
var_dump(fileatime($filename));

调用: array stat (string $filename 输出: 返回由 filename 指定的文件的统计信息

文件操作

【127.fwrite(): 写入文件】
    
$filename = 'test.txt';
$somecontent = "添加这些文字到文件\n";
$handle = fopen($filename, 'a');
fwrite($handle, $somecontent);
fclose($handle);

调用: int fwrite ( resource handle, string string [, int length] )

输出: 把 string 的内容写入 文件指针 handle 处。如果指定了 length,当写入了length个字节或者写完了string以后，写入就会停止, 视乎先碰到哪种情况

【128.fputs(): 同上】　 　　

【129.fread(): 读取文件】
    
$filename = "/usr/local/something.txt";
$handle = fopen($filename, "r");
$contents = fread($handle, filesize($filename));
 fclose($handle);

调用: string fread ( int handle, int length ) 从文件指针handle，读取最多 length 个字节

【130.feof(): 检测文件指针是否到了文件结束的位置】

    
$file = @fopen("no_such_file", "r");
while (!feof($file)) {
}
fclose($file);

调用: bool feof ( resource handle ) 输出: 如果文件指针到了 EOF 或者出错时则返回TRUE，否则返回一个错误（包括 socket 超时），其它情况则返回 FALSE

【131.fgets(): 从文件指针中读取一行】

    
$handle = @fopen("/tmp/inputfile.txt", "r");
if ($handle) {
while (!feof($handle)) {
$buffer = fgets($handle, 4096);
echo $buffer;
}
fclose($handle);
}

调用: string fgets ( int handle [, int length] ) 输出: 从handle指向的文件中读取一行并返回长度最多为length-1字节的字符串.碰到换行符（包括在返回值中）、EOF 或者已经读取了length -1字节后停止(看先碰到那一种情况). 如果没有指定 length,则默认为1K, 或者说 1024 字节.

【132.fgetc(): 从文件指针中读取字符】
    
$fp = fopen('somefile.txt', 'r');
if (!$fp) {
echo 'Could not open file somefile.txt';
}
while (false !== ($char = fgetc($fp))) {
echo "$char\n";
}

输入: string fgetc ( resource $handle ) 输出: 返回一个包含有一个字符的字符串，该字符从 handle指向的文件中得到. 碰到 EOF 则返回 FALSE.

【133.file(): 把整个文件读入一个数组中】

    
$lines = file('http://www.example.com/');
// 在数组中循环，显示 HTML 的源文件并加上行号。
 
 foreach ($lines as $line_num => $line) {
 echo "Line #<b>{$line_num}</b> : " .
 htmlspecialchars($line) . "<br />\n";
 }
// 另一个例子将 web 页面读入字符串。参见 file_get_contents()。
 
 $html = implode('', file('http://www.example.com/'));

调用: array file ( string $filename [, int $use_include_path [, resource $context ]] )

输出: 数组中的每个单元都是文件中相应的一行，包括换行符在内。如果失败 file() 返回 FALSE

【134.readfile(): 输出一个文件　 调用: int readfile ( string $filename [, bool $use_include_path [, resource $context ]] )】

输出: 读入一个文件并写入到输出缓冲。返回从文件中读入的字节数。如果出错返回 FALSE

【135.file_get_contents(): 将整个文件读入一个字符串】

    echo file_get_contents('http://www.baidu.com');
调用: string file_get_contents ( string $filename [, bool $use_include_path [, resource $context [, int $offset [, int $maxlen ]]]] ) 　 136.file_put_contents():将一个字符串写入文件

    file_put_contents('1.txt','aa');
调用: int file_put_contents ( string $filename , string $data [, int $flags [, resource $context ]] )

输出: 该函数将返回写入到文件内数据的字节数

【137.ftell(): 返回文件指针读/写的位置】
    
$fp=fopen('tx.txt','r');
fseek($fp,10);
echo ftell($fp);
fread($fp,4);
echo ftell($fp);

调用: int ftell ( resource $handle ) 输出: 返回由 handle 指定的文件指针的位置，也就是文件流中的偏移量

【138.fseek(): 在文件指针中定位】
    
$fp=fopen('tx.txt','r');
fseek($fp,10);
echo ftell($fp);
fread($fp,4);
echo ftell($fp);

调用: int fseek ( resource $handle , int $offset [, int $whence ] ) 输出: 成功则返回 0；否则返回 -1

【139.rewind(): 倒回文件指针的位置】
    
$fp=fopen('tx.txt','r');
fseek($fp,3);
echo ftell($fp);
fread($fp,4);
rewind($fp);
echo ftell($fp);

调用: bool rewind ( resource $handle ) 返回值: 如果成功则返回 TRUE，失败则返回 FALSE

【140.flock(): 轻便的执行文件锁定】
    
$fp=fopen('tx.txt','r');
flock($fp, LOCK_SH);//共享锁
//flock($fp, LOCK_EX);//独立锁，写文件时用它打开
//flock($fp, LOCK_NB);//附加锁
flock($fp, LOCK_UN);//释放锁
fclose($fp);

调用: bool flock ( int $handle , int $operation [, int &$wouldblock ] ) 输出: 如果成功则返回 TRUE，失败则返回 FALSE

目录

【141.basename(): 返回路径中的文件名部分】
    
path = "/home/httpd/html/index.php";
$file = basename($path);
$file = basename($path,".php");

调用: string basename ( string $path [, string $suffix ]) 输出: 给出一个包含有指向一个文件的全路径的字符串，本函数返回基本的文件名。如果文件名是以 suffix 结 束的，那这一部分也会被去掉

【142.dirname(): 返回路径中的目录部分】
    
$path = "/etc/passwd";
$file = dirname($path);

调用: string dirname ( string $path ) 输出: 给出一个包含有指向一个文件的全路径的字符串，本函数返回去掉文件名后的目录名

【143.pathinfo(): 返回文件路径的信息】
    
echo '<pre>';
print_r(pathinfo("/www/htdocs/index.html"));
echo '</pre>';

调用: mixed pathinfo ( string $path [, int $options ] ) 返回一个关联数组包含有 path 的信息

【144.opendir(): 打开目录句柄】
    
$fp=opendir('E:/xampp/htdocs/php/study/19');
echo readdir($fp);
closedir($fp);

调用: resource opendir ( string $path [, resource $context ] ) 返回值: 如果成功则返回目录句柄的 resource，失败则返回FALSE

【145.readdir(): 从目录句柄中读取条目】

$fp=opendir('E:/xampp/htdocs/php/study/19');
echo readdir($fp);
closedir($fp);

调用: string readdir ( resource $dir_handle ) 返回值: 返回目录中下一个文件的文件名。文件名以在文件系统中的排序返回

【146.closedir(): 关闭目录句柄】

$fp=opendir('E:/xampp/htdocs/php/study/19');
echo readdir($fp);
closedir($fp);

调用: void closedir ( resource $dir_handle ) 关闭由 dir_handle 指定的目录流。流必须之前被opendir() 所打开 【147.rewinddir() : 倒回目录句柄】

$fp=opendir('E:/xampp/htdocs/php/study/19');
echo readdir($fp).'<br />';
echo readdir($fp).'<br />';
echo readdir($fp).'<br />';
rewinddir($fp);
echo readdir($fp).'<br />';
closedir($fp);

调用: void rewinddir ( resource $dir_handle ) 输出: 将 dir_handle 指定的目录流重置到目录的开头
【148.mkdir(): 新建目录】

    mkdir('123');
调用: bool mkdir ( string $pathname [, int $mode [, bool $recursive [, resource $context ]]] ) 输出: 尝试新建一个由 pathname 指定的目录

【149.rmdir(): 删除目录】

    rmdir('123');
调用: bool rmdir ( string $dirname ) 输出: 尝试删除 dirname 所指定的目录。目录必须是空的，而且要有相应的权限。如果成功则返回TRUE，失败则返回 FALSE

【150.unlink(): 删除文件】

unlink('123/1.txt');
rmdir('123');

调用: bool unlink ( string $filename ) 输出: 删除 filename 。和 Unix C 的 unlink() 函数相似。如果成功则返回 TRUE，失败则返回 FALSE

【151.copy(): 拷贝文件】

    copy('index.php','index.php.bak');
调用: bool copy ( string $source , string $dest ) 输出: 将文件从 source 拷贝到 dest. 如果成功则返回TRUE，失败则返回 FALSE

【152.rename(): 重命名一个文件或目录】

    rename('tx.txt','txt.txt');
调用: bool rename ( string $oldname , string $newname [, resource $context ] ) 输出: 如果成功则返回 TRUE，失败则返回 FALSE

文件的上传与下载

【153.is_uploaded_file():判断文件是否是通过 HTTP POST上传的】
    
if(is_uploaded_file($_FILES['bus']['tmp_name'])){
if( move_uploaded_file($_FILES['bus']['tmp_name'],
$NewPath) ){
echo '上传成功<br /><img src="'.$NewPath.'">';
}else{
exit('失败');
}
}else{
exit('不是上传文件');
}

调用: bool is_uploaded_file ( string $filename ) 　

【154.move_uploaded_file(): 将上传的文件移动到新位置】
    
if(is_uploaded_file($_FILES['bus']['tmp_name'])){
if( move_uploaded_file($_FILES['bus']['tmp_name'],
$NewPath) ){
echo '上传成功<br /><img src="'.$NewPath.'">';
}else{
exit('失败');
}
}else{
exit('不是上传文件');
}

调用: bool move_uploaded_file ( string $filename , string

时间函数

【155.time(): 返回当前的 Unix 时间戳time(); 调用: int time ( void ) 输出: 返回自从 Unix 纪元（格林威治时间 1970 年 1 月 1 日 00:00:00）到当前时间的秒数】

【156.mktime(): 取得一个日期的 Unix 时间戳】

    mktime(0, 0, 0, 4, 25, 2012);
调用: int mktime ([ int $hour [, int $minute [, int $second [, int $month [, int $day [, int $year [, int $is_dst ]]]]]]] ) 　 156.date(): 格式化一个本地时间／日期

date('Y年m月d日 H:i:s');
调用: string date ( string $format [, int $timestamp ] )

输出: 2016年09月10日 20:45:54

【157.checkdate(): 验证一个格里高里日期 调用: bool checkdate ( int $month , int $day , int $year) 输出: 如果给出的日期有效则返回 TRUE，否则返回 FALSE】
    
if(checkdate(6,31,2012)){
echo '成立';
}else{
echo '不成立';
}

【158.date_default_timezone_set(): 设定用于一个脚本中所有日期时间函数的默认时区】

    date_default_timezone_set('PRC');
调用: bool date_default_timezone_set ( string $timezone_identifier)

返回值: 如果 timezone_identifier 参数无效则返回 FALSE，否则返回 TRUE。

【159.getdate(): 取得日期／时间信息 调用: array getdate ([ int $timestamp ] )】

输出: 返回一个根据timestamp得出的包含有日期信息的关联数组。如果没有给出时间戳则认为是当前本地时间
    
$t=getdate();
var_dump($t);

【160.strtotime(): 将任何英文文本的日期时间描述解析为 Unix 时间戳】

echo strtotime("now");
int strtotime ( string $time [, int $now ] ) 　
echo strtotime("10 September 2000");
echo strtotime("+1 day");
echo strtotime("+1 week");
echo strtotime("+1 week 2 days 4 hours 2 seconds");
echo strtotime("next Thursday");
echo strtotime("last Monday");

【161.microtime(): 返回当前 Unix 时间戳和微秒数 调用: mixed microtime ([ bool $get_as_float ] )】
    
$start=microtime(true);
sleep(3);
$stop=microtime(true);
echo $stop-$start;

其他常用:

【162.intval(): 获取变量的整数值 调用: int intval ( mixed $var [, int $base = 10 ] ) 通过使用指定的进制 base 转换（默认是十进制），返回变量 var 的 integer 数值。 intval() 不能用于 object，否则会产生 E_NOTICE 错误并返回 1。】

var: 要转换成 integer 的数量值

base: 转化所使用的进制

返回值: 成功时返回 var 的 integer 值，失败时返回 0。 空的 array 返回 0，非空的 array 返回 1。

PDO类的相关函数
prepare()
execute()
fetch()

    
<?php
$driver = 'mysql';
$database = "dbname=CODINGGROUND";
$dsn = "$driver:host=localhost;unix_socket=/home/cg/mysql/mysql.sock;$database";
 
$username = 'root';
$password = 'root';
 
try {
 $conn = new PDO($dsn, $username, $password);
 echo "<h2>Database CODINGGROUND Connected<h2>";
}catch(PDOException $e){
 echo "<h1>" . $e->getMessage() . "</h1>";
}
$sql = 'SELECT * FROM users';
$stmt = $conn->prepare($sql);
$stmt->execute();
 
echo "<table style='width:100%'>";
while($row = $stmt->fetch(PDO::FETCH_ASSOC)){
 echo "<tr>";
 foreach($row as $value)
 {
 echo sprintf("<td>%s</td>", $value);
 }
 echo "</tr>";
}
echo "</table>";
?>