PHP基础 第三天

循环结构

for循环

for(初始化条件；条件判定；条件变更){

　　//要重复执行的代码（循环体）

}

例：

<?php

//输出1-100之间的整数

for( $i = 1 ; $i <= 100 ; $i++ ){

　　echo $i , '  ' ;

}

echo $i ;

?>

while循环

while( 循环条件 ){

　　//循环体

}

例：

<?php

//输出1-100的整数

$i = 1 ;

while( $i <= 100 ){

　　echo $i ;

　　$i++ ;

}

?>

 

do-while循环

do{

//循环体

}while( 条件 ) ;

例：

<?php

//求100以内的奇数和

$i = 1;

$res = 0;

do{

　　$res += $i ;

　　$i++ ;

}while( $i <= 100 ) ;

?>

 

foreach循环

专门针对数组遍历，能方便的将数组的下标和值挨个取出来，从而实现对数组的所有元素的访问

语法：

foreach( 数组变量 as [ 存储下标的变量 => ] 存储值的变量 ){

　　//访问存储下标的变量和存储值的变量

}

<?php

//遍历数组中所有的元素下标和值

$arr = array( ' name ' => ' 张三 ' , ' age ' => 30 , ' genter ' => ' 男 ' ) ;

foreach( $arr as $k => $v ){

　　//$k 代表取出的数组元素的下标（变量名可以随便取）

　　//$v 代表取出的数组元素的值（变量名可以随便取）

　　echo $k . ' : ' . $v . ' <br/> ' ;

}

//循环外访问内部变量

echo $k . ' : ' . $v . ' <br/> ' ;　　//最后一个元素值：gender：男

?>

foreach遍历原理：每一个PHP数组内部有一个指针，默认指向数组元素第一个

二维数组遍历：二维数组通常是第一维为索引(下标为数字)，第二维为关联（下标为字母），所以在遍历的时候，通常只需要进行一层foreach即可：即遍历出第一维，然后第二维可以通过下标访问

例：

<?php

//遍历二维数组

$info = array(

　　array( ' name ' => ' 张三 ' , ' age ' => 75 , ' genter ' => ' 女 ' ) ,

　　array( ' name ' => ' 张三 ' , ' age ' => 75 , ' genter ' => ' 女 ' ) ,

　　array( ' name ' => ' 张三 ' , ' age ' => 75 , ' genter ' => ' 女 ' ) ,

　　) ;　　//二维数组：第一维为索引，第二维为关联

foreach( $info as $p ){

　　//第一维为索引：所以通常下标无具体含义，因此不需要下标

　　//$p就是数组$info中具体的每个元素：一个一维的关联数组

　　echo ' 姓名： ' . $p[ ' name ' ] . ' 年龄： ' .  $p[ ' age ' ] . ' 性别 ' . $p[ ' genter ' ] . ' <br/> ' ;

}

?>

 

循环控制：

在循环进行后，在内部（循环体）使用特定的语法来选择让循环按照某种特定的方式去执行或者终结执行。

循环控制分类：分为continue和break

continue

例：

<?php

//求1-100的奇数和

for($i=1 , $res=0 ; $i<=100 ; $i++){
if($i%2==0){
continue ;
}
$res+=$i ;
}
?>

 

break：

例：

<?php

//求出立方数 > 10000最小整数：N ^ 3 > 1000

$i=1 ;

$min=0 ;

while( true ){

　　//计算判定

　　if( $i * $i * $i <10000 ){

　　　　$i++ ;

　　　　continue ;

　　}

　　//能执行到这，说明$i * $i * $i的值 > 或 = 10000

　　$min=$i ;

　　//但此时循环无法终止，会一直运行，因为while条件是true，所以要内部结束

　　break;

}

echo $i, '~', $i * $i * $i ;

?>

循环控制的特点：在PHP中，循环控制不只是能够控制本层循环，而且可通过指定循环层次控制其他循环，具体特点就是在continue/break后跟上指定要控制的循环层数，默认是1，即本层循环（可不写）

例：

<?php

//控制两层循环：求1到100的所有值相乘的结果，但是第一个乘数比第二个乘数大

for($i=1;$i<100;$i++){

　　//外层循环

　　for($j=1;$j<100;$j++){

　　　　//$i是第一个乘数，$j是第二个乘数：判断

　　　　if($j>$i){

　　　　　　continue 2;　　//表示当前循环的外层重新执行：即改变$i

　　　　}

　　　　echo $i . '*' . $j . '=' . $i*$j . '<br/>';　　//输出1 * 1 = 1

　　}

}

?>

 

标签语法：为了让代码容易看

if：原方式是if( ){ }，标签语法编程if( ): 和endif;

for：原方式是for( ){ }，标签语法编程for( ): 和endfor;

while：原方式是while( ){ }，标签语法编程while( ): 和endwhile;

foreach：原方式是foreach( ){ }，标签语法编程foreach( ): 和endforeach;

例：

<?php

//在PHP中定义获取一个数组

$info=array(

　　array('name'=>'恭弥','age'=>18,'gender'=>'男'),

　　array('name'=>'银时','age'=>20,'gender'=>'男'),

　　array('name'=>'晋助','age'=>20,'gender'=>'男')

);

?>

<!--在HTML中显示数据-->

<html> 

<body> 

　　<table>

　　　　<th>

　　　　　　<td>序号</td>

　　　　　　<td>姓名</td>

　　　　　　<td>年龄</td>

　　　　　　<td>性别</td>

　　　</th>

　　<?php foreach($info as $k =>$v):?>

　　<tr>

　　　　<td><?php echo $k+1;?></td>

　　　　<td><?php echo $v['name'];?></td>

　　　　<td><?php echo $v['age'];?></td>

　　　　<td><?php echo $v['gender'];?></td>

　　</tr>

　　<?php endforeach;?>

　　</table>

</body> 

</html>

 

PHP函数

函数概念（掌握）

1. 函数结构：包含多个要素：关键字function，自定义函数名，参数结构，函数体和返回值5部分

  • function关键字：PHP内置的一种关键字，用来申明结构的本质
  • 自定义函数名：紧跟function关键字，是一种见名知意的字符串，有字母，数字和下划线组成，不能用数字开头（和变量一样），不区分大小写
  • 参数结构：是一种外部对函数内部数据进行调整的机制（数据输入），分为形参（定义结构时使用的参数）和实参（调用函数时传入的实际数据），可以没有参数
  • 函数体：函数的核心逻辑部分，用来实现某个功能的具体代码，在函数体中可以写普通的业务逻辑实现代码
  • 返回值：return+数据，将函数得到的结果对外返回，谁调用返回给谁（数据输出），可以没有返回值，系统默认返回NULL

2. 函数基本语法

function 函数名(形参列表){

　　//函数体

　　return 返回值;

}

例：

//定义的函数是不会运行的

<?php
function drive(){
　　echo ' drive ' ;
}
?>

3. 函数调用：指的是通过找到函数对应的内存地址（函数名寻找），然后实现函数内部代码执行的过程。调用方式是通过 函数名+() 的形式实现

<?php

　　//调用函数：函数名必须能找到函数定义的结构

　　drive();　　//没有 +() 会被系统当成常量

?>

 

<?php
function display(){
echo 'Hello World! ';
}
display();　　//Hello World! 
$return=display();　　//加了$号说明是变量　　//Hello World! 
var_dump($return);　　//NULL
?>

 

<?php

//定义一个函数

function drive(){
　　echo 'Hello World!<br/>';
}
drive();　　//Hello World! 
$return=drive();　　//加了$号说明是变量　　//Hello World! 
var_dump($return);　　//NULL

//复杂函数
function getFood($connect,$food,$position){
　　//$connect代表联系方式
　　//$food代表要获取的食物
　　//$position代表送餐的位置

　　//实现用户点餐，送到指定位置
　　echo '拿到用户点餐的内容：<br/>';　　//拿到用户点餐的内容：
　　echo '去到指定餐厅获取食物：' . $food . '<br/>';　　//去到指定餐厅获取食物：三明治
　　echo '送到指定地点：' . $position . '<br/>';　　//送到指定地点：天安门

　　echo '联系客户：' . $connect . '<br/>';　　//联系客户：010-011100


　　//返回值
　　return $food;
}

//张三想吃三明治（肯德基）
$zhangsan=getFood('010-011100','三明治','天安门');
?>

 

4. 函数内存原理

  •  函数不会自动执行，必须通过调用才会执行函数内部的代码块
  • 函数是一种结构，PHP会先编译结构加载到内存（代码段），然后才会从第一行开始执行代码（函数的定义与调用没有顺序关系：PHP特殊）

 例：

<?php
//先调用函数

driver();　　//错误，未定义函数
display(); //可以调用，但不建议这样做

//后定义函数
function display(){
　　echo ' 云雀恭弥 ';
}
?>

  •  函数的调用是在栈中开辟内存运行
  • 函数结束后，会自动释放函数所占用的所有内存（即函数内部的数据变量不能在函数外访问）

 栈虽小，但效率高

 

 参数说明（掌握）

1. 定义：函数的参数，是指函数在定义过程中所要考虑的外部数据的变化来影响最终结果而定义的虚拟变量（不代表任何真实数据：形参），以及实际调用过程中外部传入主导数据运行的实际数据（实参）

例：

<?php
//定义一个函数
function cube($n){
//$n是在函数定义时作为数据代表的一种虚拟形式（没有任何值）
echo $n*$n*$n . '<br/>';
}
//调用函数
cube(5); //125，5是真实参与运算的数据
cube(7); //343
?>

2. 函数形参与实参的关系和工作原理

  • 形参：是一种形式，是用来保存函数调用时外部出来的实际数据在函数内部运行的变量
  • 实参：是一种数据，可以是数据值也可以是变量代表的数据
  • 工作原理：实参在函数调用时，将数据或变量代表的数据传递给形参，而函数一旦运行结束，内部的形参所代表的实际数据就会消失

3. 函数一定在定义时设定了形参，那么调用时就必须传入对应的实际参数，否则会报错；但是实参可以比形参多，系统会自动忽略（本质没有忽略，接收了但是不用而已）

例：

<?php
//定义一个函数
function cube($n){
//$n是在函数定义时作为数据代表的一种虚拟形式（没有任何值）
echo $n*$n*$n . '<br/>';
}
//调用函数
cube(); 　　//错误，没有传入实参
cube(6,7,8); 　　//216，取第一个参数（因为只有一个形参）
?>

参数默认值（掌握）

指定方式：在定义时给定默认值

例：

<?php
//定义一个函数
function square($n=1){
//$n是在函数定义时作为数据代表的一种虚拟形式（没有任何值）
　　echo $n**2 . '<br/>'; 　　//**代表指数；***代表3次方
}
//调用函数
square(10); 　　//100
square(); 　　//1，不会报错，正常执行：使用了默认值
?>

3. 默认值使用注意事项：

  • 函数形参可以没有默认值可以有多个默认值
  • 函数有默认值的参数必须定义在所有参数的最后（系统把实参传递给形参是按顺序给）

例：

<?php
//定义求最大值,默认值参数必须在没有默认值参数的后面

//function getMax($a=10,$b=15,$c){
function getMax($a,$b=10,$c=15){
　　//判定
　　$a=$a>$b?$a:$b;//$a最终保存a和b中较大的值
　　echo $a>$c?$a:$c;
}
//调用函数
getMax(12); //不会赋值给$c,只会赋值给第一个参数
?>

参数传值方式（了解）

1. 默认的传值方式是值传递，就是将变量的值传递给形参，从而是两个不同变量；引用传值，就是将实参的内存地址传递给形参，2个变量指向同一个地址（引用传值，传的是内存地址）

<?php
function changeValue($a,&$b){
　　//&就是地址符号，表示获取的是外部参数的地址

　　//a是值传递，b是引用传递
　　$a++;
　　$b++;
}
$a=10;　　//注意：形参的名字与外部定义的变量名字没有冲突关系，只是“恰巧”同名而已
$b=10;

 

echo $a,$b;　　//10,10,++在后（先输出再运算）

changeValue($a,$b);
echo $a,'<br/>';　　//10，值传递，所以不改变外部变量本身
echo $b;　　//11，引用传递，所以内部修改影响外部变量

changeValue(100,$b);　　//值传递要的是值，引用传递要的是地址，所以可以传值给$a，不能传值给$b，只能传变量(值是没有地址的，只有是变量时才有对应的内存地址)

changeValue(100,100);　　//系统报错：函数第二个参数是引用传值，必须是变量
?>

函数体（了解）

可使用的代码或结构

  • 可定义变量保存数据
  • 可使用分支结构进行逻辑判断
  • 可使用循环实现数据迭代
  • 可调用函数（与外部调用方式一样）
  • 可定义函数（匿名函数）
  • 可调用类（高级）

函数返回值（掌握）

1. 函数一定有返回值：如果用户指定就会返回指定结果，否则返回NULL

例：

<?php
function display(){
　　echo 'hello','<br/>';　　//该函数目标是数据输出，所以不需要返回值
}
var_dump(display());　　//NULL，说明函数最终还是返回了结果NULL
function getBack(){
　　return 100;
}
var_dump(getBack());　　//100

 

//接收返回值
$res=getBack();
echo $res;　　//100

?>

2. 接收返回值：返回值是返回到函数调用处，因此可以通过变量来接收函数的返回值

3. return关键字功能：return虽然在函数中使用的多，但它拥有多种功能

  • 在函数内部使用return+数据，可以返回数据结果
  • 在函数内部使用return代表函数体执行到这行结束（如果后面还有代码都不再执行）
  • return可以代表文档返回值

例：

<?php
/*
* return ：false代表错误，传入的数据不对；否则返回一个字符串
*/
function getDay($day){
　　//通过输入的数字得出周几
　　if($day>7||$day<1) return false;

　　//根据有效结果进行判定
　　//$res='';　　//字符串，空
　　switch($day){
　　case 1:
　　//$res='星期一';
　　//break;
　　　　return '星期一';
　　case 2:
　　　　return '星期二';
　　case 3:
　　　　return '星期三';
　　case 4:
　　　　return '星期四';
　　case 5:
　　　　return '星期五';
　　case 6:
　　　　return '星期六';
　　case 7:
　　　　return '星期日';
　　default:
　　　　return false;
}
//返回运算结果
//return $res;
}
$res=getDay(7);
if(!$res) echo '数据有问题';

echo $res;
?>

静态变量（掌握）

定义：即在函数内部使用static关键字修饰的变量，这种变量是在函数第一次调用时执行，而且只执行一次，在函数再次调用时，会自动跳过这一行（不会再次执行），这种变量能够在同一个函数多次调用共享数据的变化。

1. 基础语法：使用static关键字修饰变量，通常静态变量都会定义的时候进行初始化（即给定值）

例：

<?php

function getStatic(){

　　static $c=0;　　//静态变量

　　$var=0;　　//普通变量

}

?>

2. 静态变量与函数内定义的普通变量的区别在于，初始化那行只会执行一次

 例：

<?php
function getStatic(){
　　static $c=0; 　　//静态变量
　　$var=0; 　　//普通变量

　　//自增输出
　　echo $c++,$var++ . '<br/>';
}

//调用
getStatic();　　//0，0：第一次调用，$c初始化，2个都是0开始，输出后都变成1
getStatic();　　//1，0：第二次调用，$c不再初始化，所以是1，而$var继续初始化为0，所以最终输出变成1，0
getStatic();　　//2，0：第三次调用，$c不再初始化，所以是2，而$var继续初始化为0，所以最终输出变成2，0
?>

 

<?php
//函数计数器：最后看看当前脚本中一共调用了多少次函数
function getCount(){


　　$number=0; 　　 //普通变量
　　static $count=0; 　　//静态变量
　　//$count=0;　　三次输出的值都会变成1：普通变量$number的值为：1，静态变量$count的值为：1


　　　　　　　　　　　　　　　　//$numer是整型，用了.连接符把它变成了字符串
　　echo '普通变量$number的值为：' . (String)++$number . '，静态变量$count的值为：' . (String)++$count . '<br/>';
}


getCount();　　//普通变量$number的值为：1，静态变量$count的值为：1

getCount();　　//普通变量$number的值为：1，静态变量$count的值为：2

getCount();　　//普通变量$number的值为：1，静态变量$count的值为：3
?>

 

3. 静态变量的作用范围：虽然静态变量允许跨函数共享数据，但是静态变量只允许在当前函数内部使用，其他任何地方都用不了

静态变量是函数内部的一种特殊变量，它允许同一个函数

 

作用域（掌握）

 定义：指的是变量所定义的环境决定的能够被访问的工作区域。在PHP中变量的作用域分为3种：全局作用域，局部作用域和超全局作用域

全局作用域：用户自定义全局变量，但是是在函数外部定义的变量。全局作用域的变量能够在函数外部的任何地方使用，其生命周期是从定义直到脚本运行结束( 手动释放除外 )

局部作用域：用户在函数内部定义的局部变量，局部变量只能在函数内部访问，函数外部不能够访问，其生命周期是函数运行时

超全局作用域：能在PHP脚本的任何地方使用，包括函数内部（以后还包含在类内部），是系统定义的超全局变量，生命周期是脚本周期

例：

<?php

//作用域

$a=100;　　//全局变量，在全局作用域中访问

//为超全局变量增加元素

$_GET[ ' age ' ]=1;　　//超全局变量：借助系统变量$_GET；给系统变量$_GET加了一个元素age，我们针对的是这个变量本身而不是针对元素，这就是超全局变量

function display(){

　　$b=50;　　//局部变量，只能在局部作用域访问（函数自身内部）

 

　　//echo $a;　　//错误：系统会提示该变量未定义

 

　　echo $_GET[ ' age ' ];　　//1；能访问

}

function show(){

　　//定义变量

　　$show=_FUNCTION_;

　　//echo $number;　　//局部作用域无法访问全局变量

　　echo $_GET[ ' age ' ];　　//1；超全局变量能在任何地方访问

}

 

//echo $b;　　//错误：系统会提示该变量未定义

 

echo $_GET[ ' age ' ];　　//1；能访问

 

display();

show();

?>

 作用域的划分是为了更好的管理变量的访问，如果想要在局部作用域（函数内部）访问全局变量的解决方案如下：

1.所有用户定义的全局变量都会放到$GLOBALS，而$GLOBALS是一个超全局变量，可以在任意地方访问

 例：

<?php

$global='全局变量';

function getGlobal(){

　　//echo $global;　　//错误

　　echo $GLOBALS[ ' global ' ];　　//全局变量：使用超全局变量可以访问所有全局变量

}

?>

2.(不常用)可以通过函数的参数将外部变量传递到函数内部，如果想要函数内部访问且改变的话，可以采用引用传值

例：

<?php

$number=100;

function changeNumber($number){　　//若在$number前面加上地址符号‘ & ’；即改成function changeNumber(&$number){

$number= '局部变量' ;

echo $number;

}

changeNumber($number);　　//局部变量

echo $number;　　//100；changeNumber里面对number的修改没影响，这是变量的特性：值传递； 

//echo $number;　　//局部变量

?>

 3.(不常用)可使用global关键字在函数内部进行引入：global关键字是一个全局引用/定义变量，如果引入全局变量，必须使用global定义一个外部同名变量（global只能声明变量，不能赋值）

 例：

<?php
$number=100;
function globalVar(){

　　//建立全局局部变量索引
　　global $number;　　//外部已存在变量
　　global $local;　　//外部不存在变量
　　$number=$local='global';
}
echo $number . '<br/>';　　//100；没调用函数之前
globalVar();
echo $number . '<br/>';　　//global；调用函数之后
echo $local;　　//global
?>

 如果函数内部定义的局部变量想在外部全局作用域访问，解决方案如下：

引用传值：内部能访问外部，固然外部也能访问内部

使用global关键字：global关键字的特性是如果全局作用域存在同名变量，则引入；否则创建一个对应的全局变量

 <?php

function getIn(){

　　//声明全局变量

　　global $out;　　//global修饰时不能赋值，只能声明（在声明全局跟局部的关系），赋值要另起一行

　　$out='out';

　　$in='in';　　//局部变量

}

//echo $out;　　//错，未定义变量

getIn();

echo $out;　　//out

?>

 

 php强制类型（了解）

 php7中针对函数的强制类型分为两种：强类型参数和强类型返回值

1.强类型参数：就是在定义函数给定形参的时候，根据函数功能的需求，强制要求参数是对应的类型

例：

<?php

//弱类型操作

function getSum($a,$b){
　　return $a+$b;
}
$a='1';
$b='b';
echo getSum($a,$b);　　//1，有警告；$a,$b都是字符串，但用了+运算符；系统会自动转换

 

//强类型操作

function getSun1(int $a,int $b){

　　return $a+$b;

}

echo getSum1($a,$b);　　//致命错误：类型不符；强制类型会规范我们的数据，一旦数据不达标，就会报错

?>

2.强类型返回值：同样是在定义函数结构的时候指定返回值的类型

<?php　　　　//虽然采用了强制类型转换，但$a，$b的类型还不确定

function get1(int $a,int $b){

　　return $a+$b; 　　//没有强调返回值

}　　　　　　　　　　//确定$a , $b类型的方式：在函数的（）后面，{ } 之前加上" :指定类型 "；例：function get2(int $a,int $b):float{

function get2(int $a,int $b):float{

　　return $a+$b;

}

var_dump(get1(1,1));　　//int(2)

var_dump(get2(1,1));　　//float(2)

?>

 

<?php
function get2(int $a,int $b):float{
　　return $a+$b;
}
$a=1;
$b=2;
var_dump(get2($a,$b));　　//float(3)；系统会根据我们想要的类型，自动转换；这就是强制类型转换
?>

3.通常在进行强制类型控制的时候，会在最上面（所有代码都没有写之前，注释不在代码的运算范畴中，它不会执行，可以写）顶格写上一行代码，表示后续使用强制类型。declare(strict_types=1)，但这句话实用价值不高，即使没有这句，声明的强制类型依然有效

<?php

//使用强制类型

declare(strict_types=1);

//定义函数

?>

 

 可变函数（了解）

定义：可变函数，是函数名具有不确定性，是通过变量来保存函数名字，然后也是通过变量+()的方式来实现函数的访问

1. 基本语法：

<?php

//定义函数

function display(){

echo 'hello world';

}

//定义一个变量：保存一个字符串与函数名同名

$var='display';

//使用可变函数访问函数

$var();　　//hello world；display：$var代表的结果就是display，然后与()结合就是display()，所以运行display函数

?>

2.可变函数通常不是看到一个函数，然后刻意用变量去访问，而是在不确定函数名叫什么的时候才用这种方式。

<?php

//定义一个函数：获取N的3次方

function cube($n){

 return $n**3;

}

 

//定义函数:函数内部需要通过调用一个外部的函数来辅助操作

function getCube($n,$func_name){

//系统认定$func_name一定要是一个函数（回掉函数）

echo $func_name($n);　　//调用外部函数，同时传入参数

}

getCube(10,'cube');　　//1000,将cube这个外部函数名传入给一个函数，函数在内部调用cube（回调函数的原理就是如此）

?>

 

<?php

//可变函数

//定义函数

function show(){

echo _FUNCTION_;

}

//定义函数

/*

@param1 string 自定义函数名字

*/

function getShow($func_name){

//因为不确定外面的函数名叫什么，但函数名已经知道了，所以 直接取出函数名就好了

$func_name();

}

//这个函数名可直接给他一个值show

 getshow(' show ');　　//show

 可变函数一般不会用，但是在一些大的函数（实现功能比较复杂，需要多个函数执行）或者系统函数对外提供接口时，会用到这个知识

 

 

 PHP常用系统函数（掌握）

 

 1.操作手册

BC 数学函数  精度

Math函数

abs   绝对值

number：包含整型和浮点型

number abs(mixed $number):返回number的绝对值

 sort：对数组排序

 bool sort( array &$array[ , int $sort_flags=SORT_REGULAT ] )：排序，从低到高重新安排

 出现 & 符号，表示引用传值，会改改变传入数据本身

[ ] 中括号代表该参数可以不给，有默认值

array：要排序的数组

sort_flags:可用改变排序的行为

2.常见输出类：帮助程序员进行数据输出或调试数据

echo：一种语法结构

print_r：输出变量的结构，方便查看

var_dump：也是一种语法结构，详细打印变量的结构和数据

exit / die：输出消息并中止脚本的执行

3.时间日期类：进行时间操作管理

time：获取当前时间的时间戳

date：按照指定格式输出时间，可以是当前时间也可以是指定时间戳　　//时间戳：秒数的整数

strtotime：将任何英文文本日期时间描述转换成时间戳

microtime：获取时间戳和微秒数（精度高）

JS:返回毫秒数　　time:返回秒　　microtime:微秒数

 

4.数字类：进行数学操作

max：获取多个数中最大的（可以是数组）

min：获取多个数中最小的（可以是数组）

floor：舍去法取整（向下取整），获取不大于当前数值的最大整数

ceil：进一法取整（向上取整），获取不小于当前数值的最小整数

mt_rand：获取指定区间或者0到最大数之间的一个随机整数

round：根据指定的小数位进行四舍五入

 

5. 字符串类：对字符串进行基本操作

addslashes：对ASCII中的特殊字符进行转义，通常对用户输入的内容进行特殊处理

htmlsmpecialchars：将HTML特殊符号转换成实体

 htmlspecialchars_decode：将实体符号转换成普通字符

chr：将ASCII对应的数值转换成对应的符号

ord：将ASCII字符转换成对应的数值

explode：将字符串按照指定的符号分隔，得到一个数组

implode：将一个数组按照指定的符号连成一个字符串

md5：使用md5算法对数据进行加密

str_repeat：将字符串重复指定次数

str_replace：字符串替换

str_shuffle：随机打乱一个字符串

str_split：按照指定长度将数组分割，返回数组

strip_tags：去除HTML和PHP标记

strlen：获取字符串的长度（字节长度）

stripos/strpos：查找字符串中首次出现目标字符串的位置

substr：从字符串中截取指定位置和长度的子字符串

trim：去除字符串两边的空格（默认是空格，也可以是其他字符）

ucfirst：将字符串首字母大写

strtolower：将所有字母小写

strtoupper：将所有字母大写

strstr：获取字符串中某个字符首次出现到最后的字符串

例：

<?php 
echo '<pre>';
echo mt_rand(),'<br/>';
echo mt_rand(1,10),'<br/>';

echo '<hr/>';

echo chr(100),'<br/>'; //d
echo ord('A'); //65

$info='中国|广东|广州|天河';
var_dump(explode('|',$info));
/*
array(4) {
[0]=>
string(6) "中国"
[1]=>
string(6) "广东"
[2]=>
string(6) "广州"
[3]=>
string(6) "天河"
}
*/
echo md5('123456'),'<br/>';　　//e10adc3949ba59abbe56e057f20f883e

echo '<hr/>';

echo strlen($info),'<br/>';　　//27

$username=' test ';
echo strlen($username),'<br/>';　　//12
echo strlen(trim($username));　　//4

echo '<hr/>';

$file='C:/windows/ec/josys.sc';
echo strstr($file,'.');　　// .sc ;获取文件名后缀
?>

 

6. 数组函数：对数据进行操作

 array_key_exists：判断下标是否在数组中存在

array_key：获取数组全部下标，或某个确定值的下标

array_merge：合并数组元素（相同字符串下标元素是覆盖）

 

array_pop：从数组最后弹出一个元素（原数组元素减少）

array_push：从数组最后加入一个元素（原数组元素增加）

array_unshift：从数组最前面入一个元素（原数组元素增加）

array_shift：从数组最前面弹出一个元素（原数组元素减少）

//这四个函数可模拟数据结构

//队列数据结构：元素从后面入（array_push），从前面出（array_shift）：先进先出

//栈（内存那个栈）：元素从哪边进就从哪边出：例从后面进array_push,后面出array_pop：先进先出

 

shuffle：将原始数组打乱（引入传值）

range：生成一个规则数值数字（常用于做性能测试）

<?php
var_dump(range(1,10));　　//生成1到10的数组
var_dump(range(1,10,2));　　//2  代表隔两位
?>

输出：

 

array(10) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(3)
  [3]=>
  int(4)
  [4]=>
  int(5)
  [5]=>
  int(6)
  [6]=>
  int(7)
  [7]=>
  int(8)
  [8]=>
  int(9)
  [9]=>
  int(10)
}
array(5) {
  [0]=>
  int(1)
  [1]=>
  int(3)
  [2]=>
  int(5)
  [3]=>
  int(7)
  [4]=>
  int(9)
}

 

current：获取当前数组指针所在位置的值

next：将数组指针向后移动一位，并获取元素值

prev：与next相反，向前移动

end：指针移动到最后一个元素，并获取元素值

reset：重置数组指针（回到第一个元素）

list：语法结构，从数组中获取数据，并且将数据赋值给变量

<?php
$array=range(1,10);  //默认指针在首位
echo current($array);  //1
echo '<br/>';
echo next($array);  //2
echo '<br/>';
echo current($array);  //2
echo '<br/>';
echo prev($array);  //1
echo '<br/>';
var_dump(prev($array));  //bool(false)
echo '<br/>';
var_dump(current($array));  //bool(false)

 

/*

这个操作与指针无关，因为没有依赖指针，所以是从第0个元素开始取

*/

list($a,$b,$c)=$array;
echo $a,$b,$c;  //123

?>

 

文件包含（掌握）

定义：文件包含，就是在一个要运行的PHP脚本中，去将另一个PHP脚本中的代码拿过来，并且可以使用其被包含的文件里的内容，或者说将自己的内容能在另一个被包含的文件中使用

PHP中提供四种文件包含的方法，分别是include和include_once,require和require_once,其中四种方式的用法完全一样

include / include_once / require / require_once '文件所在路径及文件名';

include / include_once / require / require_once('文件所在路径及文件名');

例：

<?php
include 'index.php'; //包含index.php文件（当前PHP文件同级目录）
?>

 文件包含的意义：2个

向上包含：即先包含某个文件，目的为了使用某个文件中的代码或者数据（使用公共代码）

为了用别人的东西

index.php
<?php
function show(){
echo 'hello world';
}
?>

include.php
<?php
//包含index.php文件
include_once 'index.php';
//调用index.php文件中的函数
show();  //输出hello world
?>

 

向下包含：即先写好代码，后包含文件，目的是为了在被包含文件中使用当前的数据（使用已产生数据）

为了让别人用我的东西

<html>
<body>
<b>
<?php
echo $username; //张三（PS：加了粗体的）
?>
</b>
</body>
</html>

<?php
//定义数据
$username='张三';

//包含一个不存在的文件

include_once '30.html';  //虽然错误但不影响代码执行

require_once '33.html';//致命错误，后面的代码不再执行

 

//已有数据想要让模板（HTML文件）能够很好的显示数据
include 'include.php';
?>

 

index.php
<?php 
function show(){
//获取数据
$info= 'hello world';
//包含文件
include_once 'include.php';
}
?> 

include.php
<html> 
<head></head>
<body> 
<?php
echo $info;   //输出hello world
?>
</body> 
</html>

 

 文件包含的语法区别：4种方式都能包含文件并使用

include和require的区别在于，如果包含的文件不存在时，include只是报警告错误，而不影响自身代码执行；而require会报致命错误，而且中断代码执行

include和include_once区别：include不论如何都会执行包含操作，而include_once会记录是否已经包含过对应文件，对同一文件多次包含只操作一次（对于函数/类这种结构不允许重复的，是个好方法）

include1.php
<?php
//被包含文件
function show(){
echo _FUNCTION_;
}
//数据
$function ='show';
define('PI',3.14);
?>

include2.php
<?php
//包含文件：向上包含
include 'include1.php';
//像调用show函数和访问数据
show();  //show
echo '<br/>';
echo PI;  //3.14

//再次包含
//include 'include1.php';　　//错误：前面已经包含过了（函数/类都会重名）
//解决方法：一次包含
include_once 'include1.php';

?>

 

文件包含原理：文件包含本质就是将被包含文件的所有代码，在进行包含操作那一行全部引入并运行，但文件包含语句是在运行时才会执行，因此不能先访问被包含文件中的内容，后包含文件

index.php
<?php
function show(){
echo _FUNCTION_;
}
?>


include.php
<?php
show();//错误：系统找不到函数
//引入
include_once 'index.php';

show(); //show：正确，先引入后使用
?>

总结：文件包含是一种真正意义上方便我们进行模块化开发（代码功能分开到不同的文件中使用函数进行管理维护），同时又可以实现代码复用的功能，能帮助开发者节省大量时间和工作量

 

路径问题（掌握）

定义：是指PHP在文件包含的时候，采用什么样的方式去寻找文件的问题，在系统中，路径通常分为两种：绝对路径和相对路径

绝对路径：包含2种，一种是本地绝对路径，还有一种是互联网绝对路径

本地绝对路径：从盘符根目录到文件的路径

互联网绝对路径：URL，如www.taobao.com/index.php

相对路径：被包含文件相对于当前文件所在的路径，通常有3种：

./：同级目录（当前文件所属文件夹）

../：上级目录（当前文件所属文件夹的上级文件夹）

什么都没有：就是表示同级目录，区别在于./会自动匹配任意目录下的.文件夹，而什么都没有则只会从自身文件所在目录开始（比./安全）

绝对路径和相对路径的区别：

  • 相对路径效率高：相对路径只要按照当前文件位置偏移寻找即可
  • 相对路径不安全：相对路径一旦嵌套，./这个当前目录就会发生改变
  • 绝对路径效率低：因为一定要从根目录开始逐层寻找
  • 绝对路径安全：不会因为嵌套而出现路径变化

D:/server/Web/parent/son/son.php

<?php

echo _DIR_,'son';

?>

 

D:/server/Web/parent/parent.php

<?php

echo _DIR_,'parent';

include_once './son/son.php';　　//包含son.php

//此时，单独访问parent.php没有问题

?>

 

D:/server/Web/index.php

<?php

include_once './parent/parent.php';　　//会报错，parent.php被另外一个文件夹里的文件（不同层）包含，就会出现嵌套错误的问题

//解决方案：1.不使用./；2.使用绝对路径

?>

绝对路径建议使用DIR魔术常量，可保证代码迁移不会被操作系统和磁盘限制

 

 

 

 

 

 

 

 

 

 

posted @ 2018-11-05 11:15  糖分控  阅读(217)  评论(0)  编辑  收藏  举报