php基础从入门到面向对象（大合集）
php基础复习应用大合集
1.不知道有没有人很长不是不复习基础或者一些编程思想，会忘记，博主呢秉承着温故而知新的道理把基础从到位复习了一边，其中还包括一些算法指针，统计目录，字符串，数组的方法，mvc思想，匿名函数，引用等，代码可以直接复制到php网页进行测试复习，但是什么学习都需要自己去学习，只看不练是没用的，所以，自己还是要练练的。
接下来就贴上来代码
header("Content-type: text/html; charset=utf-8");
//数学函数
// $a = -5.2; //绝对值
// echo abs($a);
// $a = 9.999; //进一法取整
// echo ceil($a);
// $a = 9.999; //舍去法取整
// echo floor($a);
// $a = 9.999; //浮点数未知
// echo fmod($a, 0.111);
//echo pow(2, 3); //（值，次方的倍数）
// echo round(1.4); // 浮点数四舍五入
// echo sqrt(9); //被开方的数平方根
// echo max(1,2,3,4,5,6,7); //求多个数字或数组，返回其中最大值
// echo min(1,2,3,4,5,6,7); //输出最小的那个值
// echo mt_rand(0,9); // 输入：最小|最大，输出：随机数随机返回范围内的值
// echo rand(0000,9999);
// echo pi(); //获取圆周率
//字符串处理
//$a = "hello world"; //求字符串长度
//echo strlen($a);
// $a = "hello world"; //返回字符串指定的字符或文本位置
// echo strpos($a, "world");
// $html = "点击会怀孕"; //将html 转换为字符串。
// $zhuan = htmlspecialchars_decode($html);
// var_dump($zhuan);
// $pwd = "小不点你真可爱"; //md5加密
// echo md5($pwd);
// $pwd = "admin"; //sha1加密
// echo sha1($pwd);
// $str = "abcdefjhigklmn"; //随机打乱字符串
// echo str_shuffle($str);
// $arr = str_split($str); //将字符串分割成数组
// var_dump($arr);
// $str = "hello world"; //截取字符串-
// echo substr($str, 3,5);
// $str = " word "; //去除字符串两侧空白字符
// var_dump(trim($str));
// $a;
// var_dump($a);
// $str ="hello word";
// echo strpos("You love php, I love php too!","php"); //后面在前面字符串的位置；
// print_r(str_split("woainiqinaideguniang"));
//时间戳！！！！
// time(); //获取本机时间戳
// date_default_timezone_set("Asia/shanghai"); //设置时区
// $date = date("Y-m-d H:i:s",mktime(21,0,0,4,9,2016)); //从时间戳转换为日期
// echo $date."
"; //输出日期
//时间戳
// $time= time();
// var_dump($time);
// var_dump($date);
// $dates = strtotime($date); //将日期转换为时间戳
// echo $dates."
"; //输出时间戳
// $datetime = "2018-8-23 22:10:23"; //将字符串转换为时间戳
// $dates = strtotime($datetime);
// echo $dates."
";
// $times = strtotime("-7000 Day"); //减去多少天的时间
// $times = date("Y-m-d H:i:s",$times);
// echo $times."
";
// echo strtotime("last week");
//使用另一个字符串填充字符串到指定长度
// $input = "Alien" ;
// // echo str_pad ( $input , 10 ); // 输出 "Alien "
// echo str_pad ( $input , 10 , "-=" , STR_PAD_LEFT ); // 输出 "-=-=-Alien"
// // echo str_pad ( $input , 10 , "_" , STR_PAD_BOTH ); // 输出 "__Alien___"
// // echo str_pad ( $input , 6 , "___" ); // 输出 "Alien_"
// $str = "Is your name \Oreilly?" ;
// // 输出： 'Is $your name O\'reilly'?
// echo addslashes ( $str );
// parse_str("id=23&name=john%20adams");
// echo $id."
";
// echo $name;
//23
//john
// 把查询字符串解析到变量中
// $str="first=value&arr[]=foo+bar&arr[]=baz"; //定义字符串
// parse_str($str); //把字符串解析为变量
// echo $first; //输出$first的值value
// echo "
";
// echo $arr[0]; //输出$arr[0]的值foo bar
// echo "
";
// echo $arr[1]; //输出$arr[1]的值baz
// echo "
";
// parse_str($str,$output); //把字符串解析的变量存储在$output中
// echo $output['first']; //输出$first的值value
// echo "
";
// echo $output['arr'][0]; //输出$arr[0]的值foo bar
// echo "
";
// echo $output['arr'][1]; //输出$arr[1]的值baz
//变量！！！！！
// header("Content-type:text/html;charset=utf8");
// $userName = "高天";
// $userAge = 19;
// echo $userName.$userAge;
//PHP 数据类型
//标量数据类型：int（整数） bool（真假） str（字符串） float（真假）
//复合数据类型： array（数组） obj（对象）
//特殊数据类型 null （空）
//资源类型 filesource
//分支结构
// $a = 5 ;
// if ($a==1) {
// echo "我";
// }elseif ($a==3) {
// echo "come";
// }elseif ($a==5) {
// echo "true";
// }else{
// echo "只能是我咯";
// }
// $a=5;
// switch($a){
// case '4':
// echo "false";
// break;
// case '5':
// echo "true";
// break;
// default:
// echo "不知道a是对少";
// break;
// }
//超全局变量
// $_GET $_POST $_SERVER $_FILE $_COOKIE $_SESSION $GLOBALS
// 声明常量
//define("SITE_URL", "http://127.0.0.1");
//echo SITE_URL;
//一维数组
// $arr = array(1,2,3);
// $arr = array(0,1,0,3,"age"=>110,"name"=>"高天");
// $arr["sex"]="男";
// var_dump($arr);
// 求出数组相同值的函数
// $arr1=array("0"=>"17","1"=>"20","2"=>"36","3"=>"48");
// $arr2=array("0"=>"17","1"=>"36","3"=>"57");
// $arr3=array_intersect($arr1,$arr2);
// // var_dump(array_unique($arr3));
// print_r($arr3);
//二维数组
//函数
// $arr = array(0,1,2,3,4,5,6,7,8,9,10);
// $arr1;
// in_array(值,数组) 判断某值是否在数组中 if
// empty（..）判断某变量，数组等是否为空值 if
// isset（）判断某变量，数组或其他是否定义 if
//unset（）销毁变量，销毁数组，销毁数组中某值 在最外面
// if (isset($arr1)) {
// echo "true";
// }else{
// echo "false";
// }
//循环
//从1加到100;
// $a = 0;
// $i = 0;
// while ($i<=99) {
// $i++;
// $a += $i;
// echo "a=".$a."____________i=".$i."
";
// }
// $a=0;
// for($i=1;$i<=100;$i++){
// $a += $i;
// echo "$a"."
";
// }
//数组函数
//返回数组中所有的值
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// print_r(array_values($arr));
//返回数组中所有的键
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// print_r(array_keys($arr));
//交换数组中的键和值 （如果有重复前面的会被后面的覆盖）
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// print_r(array_flip($arr));
//查看数组中是否存在，某个值
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// print_r(in_array("高天", $arr));
//在数组里搜索给定的值，如果成功则返回相应的键名
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// print_r(array_search("19", $arr));
//查看给的键名 是否存在于数组中
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// print_r(array_key_exists("name", $arr));
//数组的指针
//返回数组中的当前(current)单元
//将数组中的内部指针向前(next)移动一位，
//将数组中的内部指针向倒回（prev）一位，
// $arr= array("name"=>"高天","age"=>"19","size"=>"00");
// $mode = current($arr);
// $mode = next($arr);
// $mode = prev($arr);
// $mode = end($arr); //将数组内的指针指向最后一个单元
// $mode = reset($arr); //将数组中的指针指向第一个元素
// $mode = key($arr); //返回数组中当前指向元素的键名
// var_dump($mode);
//数组的分段和填充
//返回数组中的一段
// $arr= array("a","b","c","d","e","f");
// print_r(array_slice($arr,0,1));
// //把数组中的一部分去掉，并用其他值代替
// $a1=array(0=>"Dog",1=>"Cat",2=>"Horse",3=>"Bird");
//z $a2=array(0=>"Tiger",1=>"Lion");
// array_splice($a1,0,2,$a2);
// print_r($a1);
//用值将数组填补到指定长度
// $input = array( 12 , 10 , 9 );
// $result = array_pad( $input , 10 , 'a' );
// print_r($result);
//将一个或多个单元压入数组的末尾（入栈）
// $stack = array( "orange" , "banana" );
// array_push ( $stack , "apple" , "raspberry" );
// print_r ( $stack );
//将数组最后一个单元弹出（出栈）
// $stack = array( "orange" , "banana" , "apple" , "raspberry" );
// $fruit = array_pop ( $stack );
// print_r ( $stack );
//将数组开头的单元移出数组
// $stack = array( "orange" , "banana" , "apple" , "raspberry" );
// $fruit = array_shift ( $stack );
// print_r ( $stack );
//在数组开头插入一个或多个单元
// $queue = array( "orange" , "banana" );
// array_unshift ( $queue , "apple" , "raspberry" );
// print_r ( $queue );
//数组排序
//本函数对数组进行排序。当本函数结束时数组单元将被从最低到最高重新安排。 不保持索引关系
// $fruits = array( "lemon" , "orange" , "banana" , "apple" );
// sort ( $fruits );s
// print_r($fruits);
//从数组中随机取出一个或多个单元
// $input = array( "Neo" , "Morpheus" , "Trinity" , "Cypher" , "Tank" );
// $rand_keys = array_rand ( $input , 2 );
// var_dump($rand_keys);
// foreach ($input as $rand_keys) {
// $arr[]=$rand_keys;
// echo $arr;
// }
//求数组的和，还有平均值
// $arr = array(12,45,56,24,48);
// $total = $arr[0]+$arr[1]+$arr[2]+$arr[3]+$arr[4];
// $total = array_sum($arr);
// $number=count($arr);
// var_dump($total/$number);
// $sum = 0 ;
// for ($i=0; $i
// $sum += $arr[$i];
// }
// $sums=$sum/count($arr);
// var_dump($sums);
// $sum = 0 ;
// foreach ($arr as $v) {
// $sum +=$v;
// }
// $sums = $sum/count($arr);
// var_dump($sums);
//数组，多维数组
// $arr = array(1,2,3,4,5,6,7,8,9,10);
// $arr1 = array("高"=>"天","age"=>19,18,"20"=>21,22);
// var_dump($arr1);
// $arr2 = array(12,10,array(12,456,array(12,45,56)));
// echo $arr2[2][2][1];
//强制类型转换
// $a = 100;
// $a = 0;
// $a = 10.98;
// $a = NULL;
// $result = (int)$a;
// var_dump($result);
//break语句 跳出几层循环
//数组的运用题
//第一题
// $arr3 = array(101,13,1,190,526,133,18,6,3,85);
// function ArrayMax($arr3){
// $max = $arr3[0];
// for ($i=0; $i < count($arr3)-1; $i++) {
// if ( $max < $arr3[$i+1]) {
// $max = $arr3[$i+1];
// }
// }
// return $max;
// }
// function ArrayMin($arr3){
// $min= $arr3[0];
// for ($i=0; $i < count($arr3) -1 ; $i++) {
// if ($min > $arr3[$i+1]) {
// $min = $arr3[$i+1];
// }
// }
// return $min;
// }
// echo "第一题最大为".ArrayMax($arr3);
// echo "
";
// echo "第一题最小为".ArrayMin($arr3);
// echo "
";
// //第二题
// $arr = array(10,11,1,90,56,33,18,6,123,85,13);
// function ArrayOneMax($arr){
// $max = $arr[0];
// for ($i=0; $i < count($arr)-1; $i++) {
// if ( $max < $arr[$i+1]) {
// $max = $arr[$i+1];
// }
// }
// return $max;
// }
// function ArrayTwoMax($arr){
// $ArrayTwoMax = $arr[0];
// for ($i=0; $i < count($arr)-1 ; $i++) {
// if ($ArrayTwoMax < $arr[$i+1]) {
// if ($arr[$i+1] != ArrayOneMax($arr)) {
// $ArrayTwoMax=$arr[$i+1];
// }
// }
// }
// return $ArrayTwoMax;
// }
// echo "第二题第二大为".ArrayTwoMax($arr);
// echo "
";
// //第三题
// $arr6 = array(array(10,20,30,80),array(60,20,40,50),array(30,70,30,20));
// function avg($arr6){
// $num = 0 ;
// $number = 0 ;
// for ($i=0; $i < count($arr6) ; $i++) {
// for ($j=0; $j < count($arr6[$i]) ; $j++) {
// $number++;
// $num+=$arr6[$i][$j];
// }
// }
// return $num/$number;
// }
// echo "第三题平均值为".avg($arr6);
// echo "
";
// //第四题
// $arr7 = array(50,60,70,array(10,20,30,80),50,array(60,20,40,50),80,60,10,array(30,70,30,20));
// function avgTwo($arr7){
// $num = 0 ;
// $number = 0 ;
// for ($i=0; $i < count($arr7) ; $i++) {
// if (!is_array($arr7[$i])) {
// $num+=$arr7[$i];
// }
// for ($j=0; $j
// $number++;
// $num+=$arr7[$i][$j];
// }
// }
// return $num/$number;
// }
// echo "第四题平均值为".avgTwo($arr7);
// echo "
";
// // each list
// $arr = array("name"=>1,"age"=>19);
// $keystr = "";
// $valstr= "";
// while (list($key,$val)=each($arr)) {
// $keystr.=$key;
// $valstr.=$val;
// }
// echo $keystr,$valstr;
//GD库 制作验证码（1）
// header("Content-type:image/png"); //创建一个GD画布
// $image = imagecreatetruecolor(100, 50); //创建一个真彩画布
// $gray = imagecolorallocate($image, 200, 200, 200); //创建一个颜色
// imagefill($image, 0, 0, $gray); //给画布添加颜色
// $arr1 = range("0","9");
// $arr2 = range("a","z");
// $bigarr = array_merge($arr1,$arr2);
// $randStrArr = array_rand($bigarr,4);
// $string = "";
// foreach ($randStrArr as $v) {
// $string.=$bigarr[$v];
// };
// $font=5;
// $imageWidth = imagesx($image); //获取图像的宽
// $imageHeight = imagesy($image); //获取图像的高
// $fontWidth = imagefontwidth($font)*strlen($string);
// $fontHeight = imagefontheight($font);
// $x =($imageWidth-$fontWidth)/2;
// $y =($imageHeight-$fontHeight)/2;
// for ($i=0; $i < 10 ; $i++) {
// $linecolor = imagecolorallocate($image, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
// $imageline = imageline($image, mt_rand(0,100), mt_rand(0,100), mt_rand(0,100), mt_rand(0,100), $linecolor);
// }
// $blue = imagecolorallocate($image, 0, 0, 255);
// imagestring($image,$font,$x,$y,$string,$blue);
// imagepng($image); //输出画布
// imagedestroy($image); //销毁画布
//GD库制作验证码（2）
// $str = "0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"; //创建一个字符串
// $strr = null; //设置一个空的变量
// for ($i=0; $i < 4; $i++) { // 循环 字符串任意一个，循环出四个
// $strr .= $str{rand(0,strlen($str)-1)};
// }
// header("content-type:image/png");
// $width = 100; //设置 宽100；
// $height = 50; //设置 高50；
// $img = imagecreatetruecolor($width,$height); //创建一个真彩画布
// $color = imagecolorallocate($img,200,220,220); //创建一个颜色
// imagefill($img,0,0,$color); //填充画布
// for ($a=1; $a < 100; $a++) { // 循环出100个点
// imagesetpixel($img, rand(0,$width), rand(0,$height), imagecolorallocate($img,rand(150,255),rand(150,255),rand(150,255)));
// }
// for ($a=1; $a < 11; $a++) { //循环出11条干扰先
// imageline($img, rand(0,$width), rand(0,$height), rand(0,$width), rand(0,$height),imagecolorallocate($img,rand(150,255),rand(150,255),rand(150,255)));
// }
// for ($f=0; $f < 4; $f++) { //每一个字符的位置和颜色
// $s = $strr{$f}; //imagechar 将字符串画在image的指定图像中。
// imagechar($img, 15, rand($f*22,20*($f+1)), rand(10,30), $s, imagecolorallocate($img,rand(0,100),rand(0,100),rand(0,100)));
// }
// ob_clean(); //去除缓存
// imagepng($img); //输出图像
// imagedestroy($img); //销毁图像
// $k=0;
// function fbnqs($n){ //传入数列中数字的个数 //非递归写法
// global $k;
// if($n <= 0){
// return 0;
// }
// if($n==1||$n==2){
// return 1;
// }
// $array[1] = $array[2] = 1; //设第一个值和第二个值为1
// for($i=3;$i<=$n;$i++){ //从第三个值开始
// $array[$i] = $array[$i-1] + $array[$i-2];
// //后面的值都是当前值的前一个值加上前两个值的和
// $k++;
// }
// return $array;
// }
// // $num = fbnqs(8);
// // print_r($num);
// $s=0;
// function fbnq($n){ //递归写法 方法自己调用自己
// global $s;
// $s++;
// if($n<=0) return 0;
// if($n==1||$n==2) return 1;
// return fbnq($n-1)+fbnq($n-2);
// }
// $num = fbnq(10);
// $nums = fbnqs(100);
// echo "递归执行 ".$s." 次
";
// echo "普通非递归执行 ".$k." 次";
//函数定义
/*
*PHP函数和类都具有全局作用域
*不支持函数重载
*任何有效的代码都可能出现 在函数内部
*/
// hanshu1();
// function hanshu1(){
// echo "hanshu1";
// function hanshu2(){
// echo "hanshu2";
// }
// }
// hanshu2();
//函数参数（引用传参）
//不适用引用传参，如果形参的值改变，不会影响实参，
//使用引用传参，如果形参值改变，实参的值也会改变
//参数默认值必须是常量表达式
// function honggang(&$girl1,$girl2,$girl3,$girl4="高天天"){
// $girl1 = "天天棒";
// echo $girl1."
";
// echo $girl2."
";
// echo $girl3."
";
// echo $girl4."
";
// }
// $c1 ="天天";
// $c2 = "酷天天";
// $c3 = "天天天";
// honggang($c1,$c2,$c3);
// echo $c1;
//函数返回值 return + 数组参数传递
// function honggang($girl1,$girl2="高天天"){
// foreach ($girl1 as $key => $value) {
// echo $value."
";
// }
// echo $girl2;
// return $girl1;
// }
// $js = ["python","c#","java"];
// $res = honggang($js);
// print_r($res);
// $arr = [0=>"love",1=>"is","no","love"];
// list($baby,$shi,$bu,$ai) = $arr;
// echo $bu;
//引用变量
// $a = "啊啊啊啊";
// $b = &$a;
// echo $b;
//引用函数
// function & returns_reference(){
// $someref = "宁宁mua";
// return $someref;
// }
// $newref = & returns_reference();
/*
* 正则表达式(文本处理) 参考 https://www.cnblogs.com/vania/p/4422083.html
* 用途：
* 1.服务器网站配置路由重写
* 2.匹配邮箱格式
* 3.匹配电话号码格式
* 打印字符
* 1.打印字符（a-z A-Z 0-9 ！@#￥%……&*（）+*-）和非打印字符
* 2. \ 反斜杠是转义字符
2.1.正则表达式，就是一个匹配的“模式”
2.2正则表达式本身，就是一个字符串（中有一些语法规则，特殊字符）
* 一.可以将有意义
* 的字符转成没有意义的原子字符（将有意义的变成原子）
* 二.可以将没有意义的字符转成有意义的原子
* 三.a-z A-Z 0-9 _ 所有没有意义的字符，加上转义字符也没有意义，\@可加可不加
* 教学视频：https://www.bilibili.com/video/av3571918?spm_id_from=333.338.__bofqi.12
*
*
*
*/
// $str = "this383333388333312222s settext";
// $reg = "/\bset\B/";
// if (preg_match($reg, $str,$matches )) {
// echo "正则表达式{$reg} 和字符串 {$str}匹配成功";
// }else{
// echo "匹配失败";
// }
// print_r($matches);
//PHP文件系统
//判断文件类型
// echo "文件类型".filetype("0816.php");
// echo "文件类型".filetype("../project");
//is_dir()判断是不是一个目录
// if (is_dir("../project")) {
// echo "它是一个目录";
// }else{
// echo "不是目录
";
// }
//is_executable(艾克斯q它bo) --判断是否可执行，返回类型：如果文件存在且可是执行返回true，否则返回false
// if (is_executable("路径")) { //得是exe文件才能判断是否可执行
// echo "文件可执行";
// }else{
// echo "不能执行";
// }
//is_file 判断是否是一个文件
// if (is_file("文件名")) {
// echo "它是一个文件";
// }
//is_readable() 判断给的文件名是否可读 如果文件存在，且可读返回true
// if (is_readable("0816.php")) {
// echo "文件可读";
// }
//is_writable() 判断给的文件是否可写
// if (is_writable("0816.php")) {
// echo "文件可写";
// }
//file_exists
// if (file_exists("0816.php")) {
// echo "文件|目录存在
";
// }
//获取文件大小
// echo "文件大小为：".filesize("0816.php")."
";
// //文件创建时间 （简便记忆：create modify access）
// echo "文件创建时间:".date("Y-m-d H-i-s",filectime("0816.php"))."
";
// //修改navicat.lnk
// echo "文件修改时间:".date("Y-m-d H-i-s",filemtime("0816.php"))."
";
// //访问
// echo "文件访问时间:".date("Y-m-d H-i-s",fileatime("0816.php"))."
";
//stat 获取文件大部分属性 atime mtime ctime size..
// $stat = stat("0816.php");
// print_r($stat);
// echo "
";
//几的几次方
// echo pow(2, 20);
// rewinddir() //返回文件木有
//opendir() 打开目录句柄
//closedir() 关闭目录句柄
//遍历目录
// echo "
";
// $res = opendir("../project");
// echo "
";
// $a=0;
// while ($file = readdir($res)) {
// $a++;
// echo $file."
";
// echo $a;
// }
//文件系统(判断是文件还是目录)
// $dir=opendir("phpmyadmin4.1.14");
// while($filename=readdir($dir))
// {
// if($filename!="."&&$filename!="..")
// {
// $filename="./phpmyadmin4.1.14/".$filename;//一定记得文件夹的名字得加上原来的啊
// if(is_dir($filename))
// echo "目录：".$filename."
";
// else
// echo "文件：".$filename."
";
// }
// }
// rewinddir($dir);//返回
// echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
";
// while($filename = readdir($dir)) {
// //不要操作.和..
// if($filename!="." && $filename!="..") {
// //一定要注意路径， 找对才可以
// $filename = "./phpmyadmin/".$filename;
// if(is_dir($filename)) {
// echo "目录:".$filename."
";
// } else {
// echo "文件:".$filename."
";
// }
// }
// }
// //关闭这个资源
// closedir($dir);
//文件系统(统计目录的个数)
#统计目录的个数
// $dirn=0;
// $filen=0;
// function getdirnum($file)
// {
// global $dirn;
// global $filen;
// if(is_dir($file))
// {
// $dir=opendir($file); //把打开目录后的文件名给 $dird
// echo "打开句柄:".$file."
d";
// while($filename=readdir($dir)) //把读取到的一个目录名称给到文件名的变量里
// {
// if($filename!='.'&&$filename!='..') //去除..
// {
// $filename=$file."/".$filename;
// if(is_dir($filename))
// {
// echo "文件夹:".$filename."
";
// $dirn++;
// getdirnum($filename);
// }
// else{
// $filen++;
// echo "文件:".$filename."
";
// }
// }
// }
// echo "关闭句柄：".$dir."
";
// closedir($dir);
// echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@";
// }else{
// echo "return!";
// return 1;
// }
// }
// getdirnum("./2018-09-29");
// echo $dirn;
// echo "
";
// echo $filen;
//递归
#4 递归函数
// function recursion ( $a )
// {
// if ( $a < 20 ) {
// echo " $a \n" ;
// recursion ( $a + 1 );
// }
// }
// 递归函数实现功能
// function fileall($fname){
// $sum = 0;
// if(is_dir($fname)){
// $dir = opendir($fname);
// while($name = readdir($dir)){
// if($name != "." && $name != ".."){
// $wzpath = $fname."/".$name;//将文件拼接成完整的路径
// if(is_file($wzpath)){
// //如果是文件+1
// $sum++;
// }else{
// //如果是文件夹调用本身函数查找所有文件
// $sum += fileall($wzpath);
// }
// }
// }
// closedir($dir);
// return $sum;
// }else{
// return 1;
// }
// }
// 面向对象OOP
// 1.概念
// 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；
// 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
// #人生
// 面向过程
// 某同学的人生规划
// 姓名: XX
// 性别:
// 特征:爱说话,爱睡觉
// 学校学习
// 找一个稳定的工作
// 有一份稳定的事业
// 搞一个女朋友
// 结婚
// 生孩子
// 找工作
// 离婚
// 搞一个白富美
// 二婚
// 走向人生巅峰~!
// 面向过程
// 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
// 缺点：没有面向对象易维护、易复用、易扩展
// 面向对象
// 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统(重用性,灵活性,扩展性)，使系统 更加灵活、更加易于维护
// 缺点：性能比面向过程低
// 面向对象三大特征:封装,继承,多态
// 类和对象关系
// 什么是类 组成:成员属性(变量) 成员方法(自定义函数)
// 什么是对象 客观事物一个实体
// class rensheng{
// public $name;
// public $like;
// public function start($_name,$_like){
// //$this->$name = $_name;
// //$this->$like = $_like;
// echo "我叫 ".$this->$name;
// echo "我喜欢".$this->$like;
// echo "我希望我的一生是这样度过:";
// }
// public function gongzuo($type){
// swith
// }
// public funciton hun($type){
// swith
// }
// public function shengzi($type){
// }
// public funciton pengyou($type){
// }
// public function dianfeng(){
// }
// }
// 对象引用:$this 类里边:调用自己属性和方法
// 对象调用结构:
// 对象->成员
// 属性的作用域
// 1.类外的变量不能作用到类内
// 2.类中的属性可以作用到类方法中
// 3.类中变量不能作用到类方法中
// 4.类中方法中变量可以给属性赋值
// 构造和析构
// 析构(进栈出栈)
// 栈 堆
// $c=3; 3
// $b=2; 2
// $a=1; 1
// 先进后出 3 2 1
// 对象链
// .dog{
// with:256px;
// height:256px;
// background:#ccc;
// border-radius:128px;
// overflow:hidden;
// cursor:point;
// }
//
// 
//
// $('.dog').click(function(){
// var s = 0;
// var v = 10;
// setInterval(funciton(){
// s +=v;
// document.title=s;
// $('.dog').find('img').parent().css('background','#aff').css('transform','rotate('+s+'deg)');
// },1000);
// });
// jq对象链
// $('.dog').find('img').parent().css('background','#aff').css('transform','rotate('+s+'deg)');
// php对象链
// $dog->find()->css()->css();
// 2.继承,封装
// 类继承的特性
// parent::__construct($a,$b);
// 子类可以访问父类的成员,继承关键字extends,提高代码的重用性, 子类覆盖父类同名方法
// 1>重用性
// 2>扩展性
// 3>灵活性
// 类封装的特性(更加灵活)
// public 公开
// 类外可以访问,子类可以访问,本类可以访问
// protected 受保护的
// 类外不能访问,子类可以访问,本类可以访问
// private 私有的
// 类外不能访问,子类不能访问,本类可以访问
// 类封装级别:
// 子类的修饰词权限要小于等于父类同名方法前的修饰词
// 保守 private < protected < public 开放
// 静态关键字~！！~~！！
// 4.实力:分页类 thinkphp 分页 扒过来明天(!)
// 5.实力:数据操作类
// 链接数据库
// 增删改查
// 6.抽象类
// 含有抽象方法的类就是抽象类,抽象类中必须要有抽象方法,但可以有非抽象方法
// abstract class lei{}
// 抽象方法:
// 定义未被实现的方法的方法叫做抽象发放
// abstract public function start();
// 7.接口
// 只含有抽象方法的类,类中的所有方法都没有被实现;
// 一旦被定义为接口,体内不能有普通方法
// interface class lei{
// public function action1();
// public function action2();
// }
// 接口需要实现不是继承(一个都没实现,需要实现)
// class lei2 implements lei1{
// 接口定义的方法必须全部实现(lei1)
// }
// 一个类实现多个接口
// class lei3 implements lei1,lei2{
// 接口定义的方法必须全部实现(lei1和lei2)
// }
// 接口继承
// interface jk1{
// }
// interface jk2{
// }
// interface jk3 extends jk1,jk2{
// }
// class lei implements jk3{
// }
// 8.多态
// 区分不同的种类就是多态
// interface jk1{
// public funciton gongneng1();
// public funciton gongneng2();
// public funciton gongneng3();
// }
// class lei implements jk1{
// 实现功能123
// }
// abstract class lei2 implements jk1{
// 实现一部分
// 实现功能1
// }
// class lei3 extends lei2{
// 实现功能2和3
// }
// class daoban{
// 实现功能123
// }
// function useUsb(Usb $o){
// $o->load();
// $o->start();
// $o->unload();
// echo "
";
// }
// static关键字
// 上节课复习————————————————
// 概念
// $this = new 对象
// 构造和析构
// __construct 创建对象时调用
// __destruct 对象使用后一次结束后
// 对象链
// class duixianglian{
// public function a(){
// return $this;
// }
// public function b(){
// }
// }
// $obj = new duixianglian();
// $obj->a()->b();
// 析构(进栈出栈)
// 栈 堆
// $c=3; 3
// $b=2; 2
// $a=1; 1
// 先进后出 3 2 1
// 继承
// class duixiangb extends duixianglian{
// public function b(){
// }
// }
// $obj2 = new duixiangb();
// $ojb2->b();
// 封装
// public 公有的
// 类外：可以 类内：可以 子类：可以
// protected 保护的
// 类外：不可以 类内：可以 子类：可以
// private 私有的
// 类外：不可以 类内：可以 子类：不可以
// 保守 private < protected < public 开放
// 静态关键字
// 抽象类：
// 含有抽象方法的类叫做抽象类
// 接口：
// 类里所有的方法都是抽象方法的类
//spl_autoload_register(); 的参数可以是匿名函数，自定义函数名，静态方法
//类不存在,自动调用魔术方法,类的自动调用 __autoload
// function __autoload($class_name){
// echo "没有类可调用,魔术方法autoload被调用. $class_name .";
// $classfile = $class_name.".class.php";
// require_once($classfile);
// }
// $new = new School();
// $new->p();
//自定义函数名
// spl_autoload_register("my_autoload");
// function my_autoload($class_name){
// echo "string";
// $classfile=$class_name.".class.php";
// require_once($classfile);
// }
// $new = new School();
// $new->p();
//匿名函数 类的自动加载
// spl_autoload_register(function($classname){
// echo "未找到类文件";
// $classfile = $classname.".class.php";
// require_once($classfile);
// });
// $new = new School();
// $new->p();
//静态方法
// class load{
// public static function loadapp($classname){
// echo "找不到类文件，自动调用类的自动加载文件";
// $classfile = $classname.".class.php";
// require_once($classfile);
// }
// }
// spl_autoload_register("load::loadapp");
// $new = new School();
// $new->p();
// 魔术方法
// __construct()，类的构造函数!
// __destruct()，类的析构函数!
// __call()，在对象中调用一个不可访问方法时调用1
// __callStatic()，用静态方式中调用一个不可访问方法时调用1
// __get()，获得一个类的成员变量时调用
// __set()，设置一个私有的类的成员变量时调用
// __isset()，当对不可访问属性调用isset()或empty()时调用
// __unset()，当对不可访问属性调用unset()时被调用。
// __sleep()，执行serialize()时，先会调用这个函数
// __wakeup()，执行unserialize()时，先会调用这个函数
// __clone()，当对象复制完成时调用 对象复制vs对象引用
//魔术方法
// __call()，在对象中调用一个不可访问方法时调用1
// 在对象中调用一个不可访问方法时，__call() 会被调用。
// 为了避免当调用的方法不存在时产生错误，而意外的导致程序中止，可以使用 __call() 方法来避免。
// 该方法在调用的方法不存在时会自动调用，程序仍会继续执行下去。
// __callStatic()，用静态方式中调用一个不可访问方法时调用
// class per{
// public $name;
// public function start(){
// echo "start";
// }
// /**
// * 在对象中调用一个不可访问方法时，__call() 会被调用。
// * @param string $name 调用的方法名称
// * @param array $params 方法传入的参数
// */
// public function __call($name,$params=""){
// echo $name."方法不可访问";
// print_r($params);
// }
// public static function __callStatic($name,$params=""){
// echo "静态方法:".$name."不存在";
// }
// }
// // $p = new per();
// // $p->per(array('232'));
// per::jingtai(array('jingtai'));
// 读取不可访问属性的值时，__get() 会被调用。
// 在 php 面向对象编程中，类的成员属性被设定为 private 后，如果我们试图在外面调用它则会出现“不能访问某个私有属性”的错误。那么为了解决这个问题，我们可以使用魔术方法 __get()。
// class per{
// public $name;
// private $age;
// /**
// * __get在调用一个私有的或者不存在的属性时调用
// * @param string $name 调用的方法名称
// * @param array $params 方法传入的参数
// */
// public function __get($name){
// echo "属性：".$name."不存在或没有权限, __get 魔术方法被调用";
// }
// *
// * __set给一个私有的属性赋值时调用
// * @param string $name 属性名
// * @param string $params 属性赋值的参数
// public function __set($name,$param){
// echo "__set:".$param."#".$name;
// $this->age = $param;
// }
// public function echoVal(){
// echo $this->age;
// }
// }
// $p = new per();
// // echo $p->age;
// // //给一个对象复制
// $p->name = "王境";
// echo $p->name;
// //给私有属性赋值
// $p->age = 20;
// $p->echoVal();
// __isset()
// 当对不可访问属性调用 isset() 或 empty() 时，__isset() 会被调用。
// 分两种情况，如果对象里面成员是公有的，我们就可以使用这个函数来测定成员属性，如果是私有的成员属性，这个函数就不起作用了，原因就是因为私有的被封装了，在外部不可见。那么我们就不可以在对象的外部使用isset()函数来测定私有成员属性是否被设定了呢？当然是可以的，但不是一成不变。你只要在类里面加上一个__isset()方法就可以了，当在类外部使用isset()函数来测定对象里面的私有成员是否被设定时，就会自动调用类里面的__isset()方法了帮我们完成这样的操作。
// __isset()的作用：当对不可访问属性调用 isset() 或 empty() 时，__isset() 会被调用。
// echo isset($person->sex),"
";
// class per{
// private $name;
// public $age;
// private $sex;
// *
// * 当对不可访问属性调用 isset() 或 empty() 时，__isset() 会被调用
// * @param string $name 调用的属性名称
// public function __isset($name){
// echo "__isset";
// }
// }
// $p = new per();
// echo isset($p->age);
// echo isset($p->name);
// echo empty($p->age);
// echo empty($p->sex);
#############################################
// __unset()
// 当对不可访问属性调用 unset() 时，__unset() 会被调用。
// 这里自然也是分两种情况：
// 1、 如果一个对象里面的成员属性是公有的，就可以使用这个函数在对象外面删除对象的公有属性。
// 2、 如果对象的成员属性是私有的，我使用这个函数就没有权限去删除。
// 虽然有以上两种情况，但我想说的是同样如果你在一个对象里面加上__unset()这个方法，就可以在对象的外部去删除对象的私有成员属性了。在对象里面加上了__unset()这个方法之后，在对象外部使用“unset()”函数删除对象内部的私有成员属性时，对象会自动调用__unset()函数来帮我们删除对象内部的私有成员属性。
// class per{
// private $name;
// private $age;
// public $sex = "人妖";
// public function __unset($name){
// echo "属性：".$name."是私有的不能被卸载";
// //类内卸载自己的属性
// unset($this->name);
// }
// public function echoVal(){
// echo $this->name;
// }
// }
// $p = new per();
// // echo $p->sex;
// // unset($p->sex);
// // echo $p->sex; //属性sex已被删除： Undefined property: per::$sex
// unset($p->name); //unset私有name属性时调用 __unset 魔术方法
// $p->echoVal(); // Undefined property: per::$name
// // serialize
// //做序列化
// //mysql 字段里边不可以存入数组
// $arr = [
// '如来佛组',
// '吴彦组',
// '光宗耀组',
// '天马行空组',
// '超越1组',
// '超越2组',
// '龙骑士组'
// ];
// serialize() 返回字符串，此字符串包含了表示 value 的字节流，可以存储于任何地方。
// 序列化 把变量和他们的值编码成文本形式
//反序列化 恢复原先变量
// serialize unserialize
// $str = serialize($arr);
// var_dump($str);
// // //反序列化unserialize
// $arr_ser = unserialize($str);
// print_r($arr_ser);
// 如果该方法未返回任何内容，则 NULL 被序列化，并产生一个 E_NOTICE 级别的错误
// 不能返回父类的私有成员的名字。这样做会产生一个 E_NOTICE 级别的错误
// class per{
// private $name,$sex,$age;
// public function __construct($_name,$_sex,$_age){
// $this->name = $_name;
// $this->sex = $_sex;
// $this->age = $_age;
// }
// public function __sleep(){
// return array();
// }
// public function __wakeup(){
// echo "__wakeup被调用";
// }
// }
// $p = new per('李磊','女',18);
// //序列化对象的时候回调用类里的 __sleep 清理对象
// var_dump(serialize($p));
// //序列化后的对象 被反序列化 调用 __wakeup 重新连接数据库
// unserialize(serialize($p));
// echo $p->sex;
// echo $p->age;
// __toString()，类被当成字符串时的回应方法
// __invoke()，调用函数的方式调用一个对象时的回应方法
// __autoload()，尝试加载未定义的类
// __debugInfo()，打印所需调试信息
// __set_state()，调用var_export()导出类时，此静态方法会被调用。
// 常用的包括 __set() __get() __autoload() 等应该熟悉，其他的了解也没有关系
// __call()
// 在对象中调用一个不可访问方法时，__call() 会被调用。
// 为了避免当调用的方法不存在时产生错误，而意外的导致程序中止，可以使用 __call() 方法来避免。
// 该方法在调用的方法不存在时会自动调用，程序仍会继续执行下去。
// __callStatic()
// 用静态方式中调用一个不可访问方法时，__callStatic() 会被调用。
// __set()
// 在给不可访问属性赋值时，__set() 会被调用。
// __set( $property, $value )` 方法用来设置私有属性， 给一个未定义的属性赋值时，此方法会被触发，传递的参数是被设置的 属性名和值。
// $Person->name = "小红"; //赋值成功。如果没有__set()，则出错。
// __get()
// 读取不可访问属性的值时，__get() 会被调用。
// 在 php 面向对象编程中，类的成员属性被设定为 private 后，如果我们试图在外面调用它则会出现“不能访问某个私有属性”的错误。那么为了解决这个问题，我们可以使用魔术方法 __get()。
// /**
// * 在类中添加__get()方法，在直接获取属性值时自动调用一次，以属性名作为参数传入并处理
// * @param $propertyName
// *
// * @return int
// */
// public function __get($propertyName)
// __isset()
// 当对不可访问属性调用 isset() 或 empty() 时，__isset() 会被调用。
// 分两种情况，如果对象里面成员是公有的，我们就可以使用这个函数来测定成员属性，如果是私有的成员属性，这个函数就不起作用了，原因就是因为私有的被封装了，在外部不可见。那么我们就不可以在对象的外部使用isset()函数来测定私有成员属性是否被设定了呢？当然是可以的，但不是一成不变。你只要在类里面加上一个__isset()方法就可以了，当在类外部使用isset()函数来测定对象里面的私有成员是否被设定时，就会自动调用类里面的__isset()方法了帮我们完成这样的操作。
// __isset()的作用：当对不可访问属性调用 isset() 或 empty() 时，__isset() 会被调用。
// echo isset($person->sex),"
";
// __unset()
// 当对不可访问属性调用 unset() 时，__unset() 会被调用。
// 这里自然也是分两种情况：
// 1、 如果一个对象里面的成员属性是公有的，就可以使用这个函数在对象外面删除对象的公有属性。
// 2、 如果对象的成员属性是私有的，我使用这个函数就没有权限去删除。
// 虽然有以上两种情况，但我想说的是同样如果你在一个对象里面加上__unset()这个方法，就可以在对象的外部去删除对象的私有成员属性了。在对象里面加上了__unset()这个方法之后，在对象外部使用“unset()”函数删除对象内部的私有成员属性时，对象会自动调用__unset()函数来帮我们删除对象内部的私有成员属性。
// __sleep()
// __sleep()，执行serialize()时，先会调用这个方法.
// serialize() 函数会检查类中是否存在一个魔术方法 __sleep()。如果存在，该方法会先被调用，然后才执行序列化操作。
// 此功能可以用于清理对象，并返回一个包含对象中所有应被序列化的变量名称的数组。
// 如果该方法未返回任何内容，则 NULL 被序列化，并产生一个 E_NOTICE 级别的错误。
// 注意：
// __sleep() 不能返回父类的私有成员的名字。这样做会产生一个 E_NOTICE 级别的错误。可以用 Serializable 接口来替代。
// __sleep() 方法常用于提交未提交的数据，或类似的清理操作。同时，如果有一些很大的对象，但不需要全部保存，这个功能就很好用。
// 例子：
// public function __sleep() {
// echo "当在类外部使用serialize()时会调用这里的__sleep()方法
";
// $this->name = base64_encode($this->name);
// return array('name', 'age'); // 这里必须返回一个数值，里边的元素表示返回的属性名称
// }
// 与之相反， unserialize() 会检查是否存在一个 __wakeup() 方法。如果存在，则会先调用 __wakeup 方法，预先准备对象需要的资源。 __wakeup() 经常用在反序列化操作中，例如重新建立数据库连接，或执行其它初始化操作。
// public function __wakeup() {
// echo "当在类外部使用unserialize()时会调用这里的__wakeup()方法
";
// $this->name = 2;
// $this->sex = '男';
// // 这里不需要返回数组
// }
// __toString() 方法用于一个类被当成字符串时应怎样回应。例如 echo $obj; 应该显示些什么。此方法必须返回一个字符串，否则将发出一条 E_RECOVERABLE_ERROR 级别的致命错误。
// $person = new Person('小明'); // 初始赋值
// echo $person;
// __invoke()，调用函数的方式调用一个对象时的回应方法
// $person();
// 当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用。
// class per{
// public function say(){
// echo "say hello ";
// }
// public function __invoke($par){
// echo $par;
// }
// }
// $per1 = new per();
// $per1('abc');
// __clone()，当对象复制完成时调用
// $person2 = clone $person;
// class Person
// {
// public $sex;
// public $name;
// public $age;
// public function __construct($name="", $age=25, $sex='男')
// {
// $this->name = $name;
// $this->age = $age;
// $this->sex = $sex;
// }
// public function __clone()
// {
// echo __METHOD__."你正在克隆对象
";
// }
// }
// $person = new Person('小明'); // 初始赋值
// $person2 = clone $person;
// // var_dump('persion1:');
// // var_dump($person);
// // echo '
';
// // var_dump('persion2:');
// // var_dump($person2);
// $person->age = 20;
// echo $person -> age;
// echo $person2 -> age;
// 对象引用：$b=&$a;
// $person = new Person('小明');
// $person2 =& $person;
// $person->age = 20;
// echo $person -> age;
// echo $person2 -> age;
// PHP对象的浅复制与深复制
// 对象复制和对象引用比较
// __clone()，当对象复制完成时调用
// $person2 = clone $person;
// class per{
// public $num = 20;
// public function say(){
// }
// public function __clone(){
// echo "对象已被clone";
// }
// }
// $p = new per();
// //复制对象 相当于复制一个盗版出来
// // $q = clone $p;
// // $q->num = 50;
// // echo $q->num."
";
// // echo $p->num."
";
// //对象引用 借东西一样
// $q =& $p;
// $p->num = 50;
// echo $p->num;
// echo $q->num;
// __autoload
// 在魔术函数 __autoload() 方法出现以前，如果你要在一个程序文件中实例化100个对象，那么你必须用include或者require包含进来100个类文件，或者你把这100个类定义在同一个类文件中 —— 相信这个文件一定会非常大，然后你就痛苦了
// 这是一个自动加载函数，在PHP5中，当我们实例化一个未定义的类时，就会触发此函数。
// spl_autoload_register自动加载类
// spl_autoload_register() 提供了一种更加灵活的方式来实现类的自动加载。因此，不再建议使用 __autoload() 函数，在以后的版本中它可能被弃用。
// Final 关键字
// PHP 5 新增了一个 final 关键字。
// 如果父类中的方法被声明为 final，则子类无法覆盖该方法。
// 如果一个类被声明为 final，则不能被继承。
// 手册：
// ——————————————————
//参数绑定
// stmt_init //创建一个预处理实例
// prepare 呸 呸儿 //准备查询语句
// bind_param //绑定参数
// execute //执行sql
// affected_rows9 //回最后一条倍执行的语句改变，删除或插入的总行数
// close //关闭预处理
// bind_result /* 绑定返回的字段 */
//具体请到 [2018.10.31日查找]
// 后期静态绑定
// 命名空间
// http协议
// PHP操作数据库的三种方式(pdo预留)
// pdo的使用
// pdo类封装(常用sql封装);
//数组的运用题
// $a=[
// 'colthes'=>'t-shirt',
// 'size'=>'medium',
// 'color'=>'blue'
// ];
// extract($a);
// echo $colthes;
// $number = [20,-3,50,-99,55];
// function test_odd($var)
// {
// return($var > 0);
// }
// print_r(array_filter($number,"test_odd"));
// $a=array("A","Cat","Dog","A","Dog");
// print_r(array_count_values($a));
// $cities = ['Berlin', 'KYIV', 'Amsterdam', 'Riga'];
// foreach ($cities as $v) {
// print_r(array_change_key_case($cities,CASE_LOWER));
// }
// $arr=range(20, 30);
// var_dump($arr);
// echo "
";
// $values = ['say', ' bye', '', ' to', ' spaces ', ' '];
// function tests($v){
// return trim($v);
// }
// print_r(array_filter($values,'tests'));
// 面向对象基本概念
//命名空间 函数 类 常量
// mysql参数绑定 PDO操作数据库 http协议 tcp
//mvc思想架构
//所谓的mvc思想，就是在显示和逻辑相分离的基础之上，再把逻辑中的所有数据处理模块单独的提取出来
//在需要的功能上进行调度即可！
// m：Model，模型，项目中的数据处理单元，专门负责和数据库进行交互（增删改查）
// v：View，视图，项目中用于结果展示的单元，（以前的模板文件）
// c：Controller，控制器，项目中负责某个功能整体流程调用的单元
//mvc架构的优点
//1.代码结构分工明确，可都性强。
//2.项目开发效率很高，更有利于团队的合作
//3.后期项目的维护和升级变得非常容易
//mvc架构的缺点
//降低了代码运行的效率
//强调
//mvc项目架构思想，指的是项目中代码间的组织关系，不决定语法形式，面向过程和面向对象都可以使用mvc的架构思想！
//mvc模型类
//所谓的模型类，就是把mvc中的数据处理单元的功能，封装到一个类中！
//由于数据处理单元都是和数据库进行交互，而数据表要是数据库的基本单元，所以，典型的，我们一般将一张数据表的所有操作，封装到模型类当中，
//也就是说，一张数据表就对应着PHP项目开发中的一个模型类！
//基础模型类
//所谓的基础模型类，其实就是其他模型类的父类，需要在里面定义一些公共的代码！被其他的模型类所继承。
//模型类的单列模式// 如果在一个功能(控制器)
//中，需要使用某个表的多次操作，应该使用该表的一个模型就可以完成全部的任务