PHP基础语法知识

特点

• php是编译型语言
• 跨平台，支持windows与linux
• 弱类型
• 在PHP中 null和NULL是一样的，不区分大小写

基本规则

• 所有用户定义的函数、类和关键词都对大小写不敏感，但是变量大小写敏感
• 变量以 $ 符号开头，其后是变量的名称
• PHP语句必须以;结尾

界定符

• 标准型

<?php
    echo 1;
?>

• 省略型

<?php
    echo 1;

• 短标记型（默认情况下不支持，需要在php配置文件中开启支持短标记）

<?
    echo 1;
    ?>

作用域

• global关键词用于在函数内访问全局变量
• 当函数完成/执行后，会删除所有变量。不过，有时我们需要不删除某个局部变量，用static关键字

注释

<?php
    //单行注释
    # 单行注释
    /*
    多行注释
    多行注释
    */
?>

输出

• echo：无返回值，可以连续输出多个值

• print：输出成功则返回1，一次只能输出一个变量，打印的值能直接赋值给一个变量

• print_r：输出数组

• var_dump：输出数据的详细信息，包括数据类型，数据长度

• 有无括号都行

• print有返回值始终为1

• echo可以返回多个字符串

<?php
echo "x1lys\n";
print "x1lys\n";
echo "x1lys1",'x1lys2','x1lys3';
//  print "x1lys1","x1lys2";

$arr = array("a" => "x1lys1", "b" => "x1lys2", "c" => "x1lys3");
print_r($arr);
var_dump("x1lys");
var_dump(1);
var_dump($arr);

常量

• 用define()函数定义常量
• 常量是自动全局的，而且可以贯穿整个脚本使用

define(常量名，值，[是否区别大小写])
    
true表示不区分大小写，默认是false
常量名前没有$符
常量名推荐使用大写

<?php
// 定义对大小写不敏感的常量
define("GREETING", "Welcome to W3School.com.cn!", true);
echo GREETING;
echo "<br>";
// 会输出常量的值
echo greeting;
?>  

• 定义常量可以用特殊字符，但是在调用的时候必须用constant关键字调用

define('%-%','tom');
echo constant('%-%');		//通过constant获取特殊字符作为常量名的常量

• 还可以使用const关键字定义常量

预定义常量

echo PHP_VERSION,'<br>';		//PHP版本号
echo PHP_OS,'<br>';				//PHP操作系统
echo PHP_INT_MAX,'<br>';		//PHP中整型的最大值

重点
PHP_EOL：系统换行符，Windows是（\r\n），Linux是（\n），MAC是（\r）

魔术常量

• 魔术常量它们的值随着它们在代码中的位置改变而改变

LINE	文件中的当前行号。
FILE	文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。自 PHP 4.0.2 起，FILE 总是包含一个绝对路径（如果是符号连接，则是解析后的绝对路径），而在此之前的版本有时会包含一个相对路径。
DIR	文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于 dirname(FILE)。除非是根目录，否则目录中名不包括末尾的斜杠。（PHP 5.3.0中新增） =
FUNCTION	函数名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该函数被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。
CLASS	类的名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该类被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。类名包括其被声明的作用区域（例如Foo\Bar）。注意自 PHP 5.4 起 CLASS 对 trait 也起作用。当用在 trait 方法中时，CLASS 是调用 trait 方法的类的名字。
TRAIT	Trait 的名字（PHP 5.4.0 新加）。自 PHP 5.4 起此常量返回 trait 被定义时的名字（区分大小写）。Trait 名包括其被声明的作用区域（例如 Foo\Bar）。
METHOD	类的方法名（PHP 5.0.0 新加）。返回该方法被定义时的名字（区分大小写）。
NAMESPACE	当前命名空间的名称（区分大小写）。此常量是在编译时定义的（PHP 5.3.0 新增）

echo __LINE__,'<br>';		//获取当前行号
echo __FILE__,'<br>';		//文件的完整路径和文件名
echo __DIR__,'<br>';		//文件所在的目录

变量

• 变量的本质就是内存中的一段空间
• 只能以下划线或数字开头
• 只能包含数字，字母，下划线
• 变量对大小写敏感

超全局变量

• $GLOBALS
• $_SERVER
• $_GET
• $_POST
• $_FILES
• $_COOKIE
• $_SESSION
• $_REQUEST
• $_ENV

数据类型

整型

• 存整数，PHP_INT_MAX能获取整形的最大值

<?php
$num1=10;		//十进制
$num2=010;		//八进制（数字前面加0）
$num3=0x10;		//十六进制（数字前面加0x）

echo $num1,'<br>';		//10
echo $num2,'<br>';		//8
echo $num3;				//16

浮点型

• 浮点数在内存中保存的是近似值

• 浮点数不能参与比较

var_dump(0.9==(1-0.1));		//bool(true) 
echo '<br>';
var_dump(0.1==(1-0.9));		//bool(false)

• 如果浮点数要比较，必须确定比较的位数

var_dump(0.9==(1-0.1));		//bool(true) 
echo '<br>';
var_dump(0.1==(1-0.9));		//bool(false) 
echo '<br>';
var_dump(bccomp(0.1,1-0.9,5));	//比较小数点后面5位   int(0)   0表示相等

字符串、整数、浮点数、逻辑、数组、对象、NULL

$a="aaa";
$a=343;
$a=3.2;
$a=true;
$a=array("bob","qwq","fsd");

<?php
class Car
{
  var $color;
  function Car($color="green") {
    $this->color = $color;
  }
  function what_color() {
    return $this->color;
  }
}
?>

• 如果一个整数超出了整形的范围，会自动的转成浮点型

布尔型

• 不能使用echo 和print输出布尔型，要使用var_dump()输出

$flag=false;
var_dump($flag);	//bool(false)

字符串型

• 在PHP中单引号字符串和双引号字符串是有区别的
• 单引号字符串是真正的字符串
• 双引号字符串要解析字符串中的变量

$name='tom';
echo '我的名字叫$name','<br>';	//我的名字叫$name
echo "我的名字叫$name",'<br>';	//我的名字叫tom

数组

• 索引数组：用整数做下标，默认从0开始，后面依次加一

• 关联数组：用字符串做下标，通过=>符号将下标和值关联起来

<?php
//1、索引数组的声明
$stu=array('tom','berry','ketty');   //索引数组
print_r($stu);	//输出数组  Array ( [0] => tom [1] => berry [2] => ketty ) 
echo '<hr>';
echo $stu[0],'<br>';	//tom
echo $stu[1],'<br>';	//berry
echo $stu[2],'<hr>';	//ketty

$stu=['tom','berry','ketty'];
print_r($stu);  //Array ( [0] => tom [1] => berry [2] => ketty )
//------------------------------------------
//2、关联数组
$emp=array('name'=>'李白','sex'=>'男','age'=>22);
print_r($emp);	//Array ( [name] => 李白 [sex] => 男 [age] => 22 ) 
echo '<hr>';
echo $emp['name'],'<br>';	//李白
echo $emp['sex'],'<br>';	//男
echo $emp['age'];			//22

类型转换

自动类型转换

• 当提供的类型和需要的类型不一致的时候会自动进行类型转换

$num=10;
if($num){   //自动将数字转成布尔型
	echo 'aa';
}else{
	echo 'bb';
}
---------------------------------
echo '20'-10;	//自动的将字符串转成数字

强制类型转换

<?php
$num1='12';
var_dump($num1,(int)$num1,(float)$num1);   //string(2) "12" int(12) float(12)

运算符

<?php 
$x=17; 
$y=8;
echo ($x + $y); // 输出 25
echo ($x - $y); // 输出 9
echo ($x * $y); // 输出 136
echo ($x / $y); // 输出 2.125
echo ($x % $y); // 输出 1
?>
    <?php 
$x=17; 
echo $x; // 输出 17

$y=17; 
$y += 8;
echo $y; // 输出 25

$z=17;
$z -= 8;
echo $z; // 输出 9

$i=17;
$i *= 8;
echo $i; // 输出 136

$j=17;
$j /= 8;
echo $j; // 输出 2.125

$k=17;
$k %= 8;
echo $k; // 输出 1
?>
<?php
$a = "Hello";
$b = $a . " world!";
echo $b; // 输出 Hello world!

$x="Hello";
$x .= " world!";
echo $x; // 输出 Hello world!
?>
<?php
$x=17; 
echo ++$x; // 输出 18

$y=17; 
echo $y++; // 输出 17

$z=17;
echo --$z; // 输出 16

$i=17;
echo $i--; // 输出 17
?>

判断

• if-else if-else
• switch

循环

• while
• do-while
• for
• foreach

<?php
$stu=['tom','berry','ketty'];
foreach($stu as $v){
	echo $v,'<br>';
}
/**
tom
berry
ketty
*/
echo '<hr>';
-----------------------------------------------------------
foreach($stu as $k=>$v){
	echo "{$k}:{$v}<br>";
}
/**
0:tom
1:berry
2:ketty
*/

函数

• 函数名对大小写不敏感

<?php
function setHeight($minheight=50) {
  echo "The height is : $minheight <br>";
}

setHeight(350);
setHeight(); // 将使用默认值 50
setHeight(135);
setHeight(80);
?>

作用域

• 全局变量：在函数外面
• 局部变量：在函数里面，默认情况下，函数内部是不会去访问函数外部的变量
• 超全局变量：可以在函数内部和函数外部访问
• $GLOBALS保存的是全局变量的所有的值
• global用于创建一个全局变量的引用
• 常量没有作用域的概念

<?php
$num=10;   
function fun() {
	echo $num;     //Notice: Undefined variable: num  
}
fun();
//函数内部默认不能访问函数外部的值
---------------------
<?php
$_POST['num']=10;   //将值付给超全局变量
function fun() {
	echo $_POST['num'];    //获取超全局的值   10
}
fun();
----------------------------
<?php
function fun() {
	$_GET['num']=10;  //将值付给超全局变量
}
fun();
echo $_GET['num'];  //打印超全局变量的值  10


<?php
$num=10;  //全局变量
function fun() {
	echo $GLOBALS['num'];	//输出全局的$num
}
fun();


<?php
$num=10;
function fun() {
	global $num;   //将全局变量的$num的地址引入到函数内部  相当于$num=&GLOBALS['num']
	echo $num;	//10
	$num=100;
}
fun();
echo '<br>';
echo $num;    //100
-----------------------------------
<?php
$num=10;
function fun() {
	global $num;
	unset($num);  //销毁的是引用，不是具体的值
}
fun();
echo $num;    //10

错误处理

• php.ini

1. error_reporting = E_ALL：报告所有的错误
2. display_errors = On：将错误显示在浏览器上
3. log_errors = On：将错误记录在日志中
4. error_log=’地址’：错误日志保存的地址

• 在项目开发过程中有两个模式，开发模式，运行模式

开发模式：错误显示在浏览器上，不要记录在日志中
运行模式：错误不显示在浏览器上，记录是日志中

• ini_set()设置PHP的配置参数

<?php
$debug=false;		//true:开发模式  false：运行模式
ini_set('error_reporting',E_ALL);	//所有的错误有报告
if($debug){
	ini_set('display_errors','on');	//错误显示是浏览器上
	ini_set('log_errors','off');	//错误不显示在日志中
}else{
	ini_set('display_errors','off');
	ini_set('log_errors','on');
	ini_set('error_log','./err.log');	//错误日志保存的地址
}

//测试
echo $num;

类的命名

1. 以字母、下划线开头，后面跟的是字母、数字、下划线
2. 不能用PHP关键字做类名
3. 类名不区分大小写（变量名区分，关键字、类名不区分大小写）
4. 类名用帕斯卡命名法（大驼峰 单词的首字母大写）

<?php
class Student {
}

对象的比较

<?php
//定义类
class Student {
	
}
//实例化对象
$stu1=new Student();
$stu2=new Student();
$stu3=$stu2; //对象传递的是地址	
//var_dump($stu1,$stu2,$stu3); //object(Student)#1 (0) { } object(Student)#2 (0) { } object(Student)#2 (0) { } 
//对象比较
var_dump($stu1==$stu2);		//bool(true) ,比较对象的结构
echo '<br>';
var_dump($stu1===$stu2);	//bool(false) $stu1和$stu2是否是同一个对象
echo '<br>';
var_dump($stu2===$stu3);	//bool(true) $stu2和$stu3是同一个对象

属性

属性本质就是变量

通过->调用对象的成员 对象名->属性名 对象名->方法名()

<?php
//定义类
class Student {
	public $name;				//属性
	public $add='地址不详';		//属性
}
//实例化对象
$stu=new Student();
//print_r($stu);	//Student Object ( [name] => [add] => 地址不详 ) 
//操作属性
//1、给属性赋值
$stu->name='tom';
$stu->add='北京';
//2、获取属性的值
echo '姓名：'.$stu->name,'<br>';	//姓名：tom
echo '地址：'.$stu->add,'<br>';		//地址：北京
//3、添加属性
$stu->age=20;
print_r($stu);	//Student Object ( [name] => tom [add] => 北京 [age] => 20 ) 
echo '<br>';
//4、删除属性
unset($stu->add);
print_r($stu);	//Student Object ( [name] => tom [age] => 20 )

方法

<?php
class Student {
	//定义方法
	public function show() {
		echo '这是show方法<br>';
	}
	//public可以省略，如果省略，默认就是public
	function test() {
		echo '这是test方法<br>';
	}
}
$stu=new Student;
$stu->show();	//调用方法
$stu->test();

1、方法前面public是可以省略的，如果省略，默认就是public的。

2、属性前面的public不能省略

访问修饰符

修饰符	描述
public（公有的）	在类的内部和外部都能访问
private（私有的）	只能在类的内部访问
protected（受保护的）	在整个继承链上访问

一般来说，属性都用私有的，通过公有的方法对私有的属性进行赋值和取值。

作用：保证数据的合法性

<?php
//访问修饰符
class Student {
	private $name;	//私有属性
	private $sex;	//私有属性
	//通过公有的方法对私有的属性进行赋值
	public function setInfo($name,$sex) {
		if($sex!='男' && $sex!='女'){
			echo '性别必须是男或女';
			exit;
		}
		$this->name=$name;   //$this表示当前对象
		$this->sex=$sex;
	}
	//显示信息
	public function getInfo() {
		echo '姓名：'.$this->name,'<br>';
		echo '性别：'.$this->sex,'<br>';
	}
}
//实例化
$stu=new Student;
$stu->setInfo('tom','男');
$stu->getInfo();
echo '<hr>';
$stu2=new Student;
$stu2->setInfo('berry','女');
$stu2->getInfo();

类和对象在内存中的分布

1. 对象的本质是一个复杂的变量
2. 类的本质是一个自定义的复杂数据类型
3. 栈区：运行速度快，体积小，保存基本类型
4. 堆区：运行速度稍慢，体积大，保存复杂类型
5. 实例化的过程就是分配内存空间的过程
6. 对象保存在堆区，将堆区的地址保存到栈区。

封装

封装就是有选择性的提供数据

通过访问修饰符来实现封装

构造方法

构造方法也叫构造函数，当实例化对象的时候自动执行。

<?php
class Student {
	public function __construct() {
		echo '这是构造方法<br>';
	}
}
new Student();	//这是构造方法
new Student();	//这是构造方法

<?php
class Student {
	private $name;
	private $sex;
	//构造函数初始化成员变量
	public function __construct($name,$sex) {
		$this->name=$name;
		$this->sex=$sex;
	}
	//显示信息
	public function show() {
		echo "姓名：{$this->name}<br>";
		echo "性别：{$this->sex}<br>";
	}
}
//实例化
$stu=new Student('tom','男');
$stu->show();
//运行结果
/*
姓名：tom
性别：男
*/

注意：构造函数可以带参数，但不能有return。

析构方法

<?php
class Student {
	private $name;
	//构造方法
	public function __construct($name) {
		$this->name=$name;
		echo "{$name}出生了<br>";
	}
	//析构方法
	public function __destruct() {
		echo "{$this->name}销毁了<br>";
	}
}
//测试
$stu1=new Student('tom');
$stu2=new Student('berry');
$stu3=new Student('ketty');
echo '<hr>';

留心：析构函数不可以带参数

继承

1. 继承使得代码具有层次结构
2. 子类继承了父类的属性和方法，实现了代码的可重用性。
3. 使用extends关键字实现继承
4. 父类和子类是相对的

<?php
//父类
class Person {
	public function show() {
		echo '这是人类<br>';
	}
}
//子类继承父类
class Student extends Person {
}
//测试
$stu=new Student;
$stu->show();			//这是人类

执行过程：

第一步：在Student类中查找show()，如果找到就调用，找不到就到父类中查找

第二步：在Person类中查询show()

<?php
//父类
class Person {
	public function show() {
		echo '这是人类<br>';
	}
}
//子类
class Student extends Person {
	public function test() {
		//方法一；
		/*
		$person=new Person();
		$person->show();		//这是人类
		*/
		//方法二
		$this->show();			//这是人类
	}
}
//测试
$stu=new Student;
$stu->test();

1、方法一：通过实例化父类调用父类的成员

2、方法二：通过$this关键字调用父类的成员

protect

//例题一：
<?php
class A {
	protected $num=10;	//在整个继承链上访问
}
class B extends A {	
	public function getNum() {
		echo $this->num;
	}
}
//测试
$obj=new B();    //整个继承链上有A和B
$obj->getNum();		//10
//例题二：
<?php
class A {
	public function getNum() {
		echo $this->num;
	}
}
class B extends A {
	protected $num=10;	
}
//测试
$obj=new B();	//整个继承链上有A和B
$obj->getNum();		//10
//例题三：
<?php
class A {
	public function getNum() {
		echo $this->num;
	}
}
class B extends A {
	protected $num=10;	
}
//测试
$obj=new A();     //整个继承链上只有A
$obj->getNum();	 //Notice: Undefined property: A::$num

1、如果子类有构造函数就调用子类的，如果子类没有就调用父类的构造函数。
2、子类的构造函数调用后，默认不再调用父类的构造函数

<?php
class Person {
    //父类的构造函数
	public function __construct() {
		echo '这是父类<br>';
	}
}
class Student extends Person {
    //子类的构造函数
	public function __construct() {
		Person::__construct();		//通过父类的名字调用父类的构造函数
		parent::__construct();		//parent表示父类的名字
		echo '这是子类<br>';
	}
}
//测试
new Student();

<?php
class Person {
	protected $name;
	protected $sex;
    //父类的构造函数
	public function __construct($name,$sex) {
		$this->name=$name;
		$this->sex=$sex;
	}
}
class Student extends Person {
	private $score;
    //子类的构造函数
	public function __construct($name,$sex,$score) {
		parent::__construct($name,$sex);  //调用父类构造函数并传递参数
		$this->score=$score;
	}
    //显示信息
	public function getInfo() {
		echo "姓名：{$this->name}<br>";
		echo "性别：{$this->sex}<br>";
		echo "成绩：{$this->score}";
	}
}
//测试
$stu=new Student('tom','男',88);
$stu->getInfo();
/*
姓名：tom
性别：男
成绩：88
*/