php基础
php学习笔记
语法基础
以**** 结束
变量的命名
-
$开头
-
变量名必须以字母或者下划线字符开始
-
变量名只能包含字母数字字符以及下划线（A-z、0-9 和 _ ）
-
变量名不能包含空格
static的关键字的使用
-
当一个函数完成时，它的所有变量通常都会被删除。
-
在第一次声明变量时使用 static 关键字，让局部变量不被删除。
数据类型、常量以及字符串
数据类型
有5种
String（字符串）, Integer（整型）, Float（浮点型）, Boolean（布尔型）
Array（数组）, Object（对象）, NULL（空值）。
数组和字典要用print_r输出
$a1=array('1',1,'aaa');
$a4=array('x'=>1,'b'=>'2');
print_r($a1);
print_r($a4);
常量
-
常量是一个简单值的标识符。该值在脚本中不能改变。（在整个脚本中都能使用）
-
一个常量由英文字母、下划线和数字组成,但数字不能作为首字母出现。 (常量名不需要加 $ 修饰符)。
-
使用 define() 函数设置常量
使用 const 关键字来定义
预定义常量
这些常量无需使用define()函数定义，可直接在程序中使用
-
FILE(FILE前后分别是两个下画线)：当前正在处理的脚本文件名，若使用在一个被引用的文件中（include或require），那么 它的值就是被引用的文件，而不是引用它的那个文件。（脚本的位置）
-
LINE(LINE前后分别是两个下画线)：正在处理的脚本文件的当前行数。（行数）
-
PHP_VERSION：当前PHP预处理器的版本，如5.4.16。
-
PHP_OS: PHP所在的操作系统的类型。如Linux。
-
TRUE：表示逻辑真。FALSE：表示逻辑假。NULL：表示没有值或值不确定。
-
DIRECTORY_SEPARATOR: 表示目录分隔符，UNIX或Linux操作系统环境时的值为“ / ”, Window操作系统环境时的值为 “ ** ”。
整型
整数类型：保存整数数值（范围限制），4个字节存储数据。PHP中默认为有符号。
在PHP中提供四种整形的定义方式，十进制定义，二进制定义，八进制定义和十六进制定义
进制转换
$age=18;
echo decbin($age);//二进制
$a=0b10010;//二进制变整型（在外面加0b）
echo $a;
$a = 120 //十进制
$a = 0b110 //二进制
$a = 0120 //八进制
$a = 0x120 //十六进制
decbin() // 十进制转二进制
decoct() // 十进制转八进制
dechex() // 十进制转十六进制
bindec() // 二进制转十进制
bin2hex() //二进制转十六进制
字符串
字符串变量用于存储并处理文本。
单双区别
双引号里面可以插入变量
单引号里面不行
$name='你好';
$str='我是小学生 $name 今年10岁';
$str2="$name你是谁";
echo $str;
echo $str2;
点号
点号作用是把字符串连接
strlen()：计算字符串长度
echo "一共有".strlen($str)."字符";
去除空格
trim():去除两边空格
echo trim($str);
查找字符串
strpos:查找字符串
substr:查找字符串（有头有尾）
echo strpos($str,'字符串');
echo substr($str,strpos($str,'字符串'),strpos($str,'字符串'));
加密
md5：将数字md5加密
echo md5($a);
取字符
[]:取字符（起始是0）
$a='12132';
echo $a[0];
for循环
for ($i=0;$i<strlen($a);$i++){
echo $a[$i];
}
替换
替换（把1替换0）
$str='123 ';
echo str_replace('1','0',$str);
数组
类别
数值数组 - 带有数字 ID 键的数组（正常数组）
关联数组 - 带有指定的键的数组，每个键关联一个值（array2）
多维数组 - 包含一个或多个数组的数组（数组里加数组）
array() 函数用于创建数组
用[]的形式也可以
$array4=['a','b','c'];
$array1=array('a','b','c');
$array2=array('a1'=>'php','a2'=>'java','a3'=>'python',$array1);
print_r($array1);
print_r($array2);
count——数组的数量
echo count($array1);
遍历
foreach ($array1 as $value){
// echo $key.'----'.$value.'
';
echo $value;
}
for($i=0;$i<=count($array1);$i++){
echo $array1[$i].'';
}
排列
sort() - 对数组进行升序排列
rsort() - 对数组进行降序排列
asort() - 根据关联数组的值，对数组进行升序排列
ksort() - 根据关联数组的键，对数组进行升序排列
arsort() - 根据关联数组的值，对数组进行降序排列
krsort() - 根据关联数组的键，对数组进行降序排列
echo输出不了
sort($array1);
rsort($array1);
print_r($array1);
合并
$array2=array('a1'=>'php','a2'=>'java','a3'=>'python');
$array1=array('a','b','c');
$array3=array($array1,$array2);
print_r($array3);
增加和更改
$array1['a']='d';//增加
print_r($array1);
$array1[0]='e';//更改数值
print_r($array1);
删除和增加
array_splice(数组，位置，删除几个，增加元素）
array_splice($array1,1,0,'ddd');
print_r($array1);
指定删除
unset($array1[0]);//删除指定位置
array_pop($array2);//删除最后一个
print_r($array2);
查找key
echo array_search('php',$array2);//寻找对应的key
echo array_key_exists('a1',$array2);//寻找key是否存在，是返回1
array_unique() 去掉相同的值
print_r(array_unique($array1));
in_array — 检查数组中是否存在某个值 如果找到指定的值则返回 TRUE，否则返回 FALSE 。区分大小写
echo in_array('a1',$array1);
运算符（太简单了不写）
三元运算符
var_dump(1==2?'xxx':'zzz');
控制语句
控制语法的语句结构和其他大多数语言结构相同，有以下两类：
条件控制语句
if 语句 - 在条件成立时执行代码
$a=1;
$b=2;
if($a>$b){
echo 'a';
}else{
echo 'b';
}
if…else语句 - 在条件成立时执行一块代码，条件不成立时执行另一块代码
if…elseif…else 语句 - 在若干条件之一成立时执行一个代码块
if($a==3){
echo 'a';
}elseif($a==4) {
echo 'b';
}elseif($a==5){
echo 'c';
}else{
echo 'd';
}
switch 语句 - 在若干条件之一成立时执行一个代码块
break停止，否则继续执行
switch ($a) {
case 1;
echo 2;
case 2;
echo 1;
break;
default;
echo 3;
}
循环控制语句
while - 只要指定的条件成立，则循环执行代码块
$i=0;
while(true){
echo $i++.'';
if($i>=999){
continue;
}
}
do…while - 首先执行一次代码块，然后在指定的条件成立时重复这个循环
for - 循环执行代码块指定的次数
foreach - 根据数组中每个元素来循环代码块
break语句*用于终止本次循环
continue语句的作用是跳出本次循环，接着执行下一次循环
函数
函数名能够以字母或下划线开头（非数字）。
PHP 默认参数值
echo优先级比name高
function a($name='a')
{
echo $name;
}
echo a(111);
匿名函数
要将匿名函数"赋值"给变量
$a=function (){
return 1;
};
echo $a();
回调函数
call_user_func（调用函数，输入的参数）
function get_name($name)
{
return $name;
}
echo call_user_func('get_name','a');
PHP 变量作用域
PHP 有三种不同的变量作用域：
local（局部）
global（全局）
static（静态）
Local 和 Global 作用域
函数和全局之间不能互相访问，
但是用global之后可以访问
$a='全局变量';
function getName()
{
global $a;
echo $a;
}
getName();
用**$GLOBALS**变量也可以
$a='全局变量';
function getName()
{
// global $a;
echo $GLOBALS['a'];
}
getName();
静态
当函数完成后，会删除所有变量。static会保留变量
function getName()
{
static $a=1;
echo $a;
$a++;
}
getName();
getName();
类与对象
PHP 面向对象
对象的主要三个特性：
l 对象的行为：可以对对象施加那些操作，开灯，关灯就是行为。
l 对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。
l 对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。
class Person{
var $name;
var $age;
var $gender;
function setName($name)
{
$this->name = $name;
}
function getName(){
return $this->name;
}
}
$p1=new Person();
$p1->setName("John");
echo $p1->name;
echo $p1->getName();
构造函数
- 构造函数的作用：当创建实例对象时，构造函数会被自动调用，
__construct($name)接收一个参数$name，并将其赋值给当前对象的name属性。
现在可以在对象创建的同时完成属性的初始化（在创造对象的同时加入值John）
class Person{
var $name;
var $age;
var $gender;
function __construct($name)
{
$this->name = $name;
}
function getName(){
return $this->name;
}
}
$p1= new Person('aaaaa');
echo $p1->getName();
析构函数
当PHP 脚本执行到最后一行时：
-
系统会自动进行 “舞台清理”：
- 所有变量（包括对象）都会被 “请出舞台”
- 此时对象
$p2会被销毁
-
析构函数
__destruct自动运行：
- 就像演员 John 退场时自动说：“再见，我是 John”（输出名字）
-
当对象删除时，destruct自动执行
class Person{
var $name;
var $age;
var $gender;
function __construct($name)
{
$this->name = $name;
}
function __destruct(){
echo $this->name;
}
}
$p2=new Person('John');
继承
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。（复制上一个类）
父类=基类
P1=Person
class Person{
var $name;
var $age;
function __construct($name,$age){
$this->name=$name;
$this->age=$age;
}
function getUser()
{
return "名字 $this->name 年龄 $this->age 岁";
}
}
/*$p1=new Person('John','20');
echo $p1->getUser();*/
class P1 extends Person
{
}
$p2=new P1('a','1');
echo $p2->getUser();
方法重写
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
（重写父类）
在P1里面可以修改父类的函数
class P1 extends Person
{
function getUser()
{
return "名字 $this->name ";
}
function run()
{
echo" $this->name 在睡觉";
}
}
访问控制
PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。
**public（**公有）：公有的类成员可以在任何地方被访问。
public $name;
echo $p1->name;
protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
P1可以访问Person里的变量
class Person{
protected $name;
protected $age;
public function __construct($name,$age){
$this->name=$name;
$this->age=$age;
}
protected function getUser()
{
return "名字 $this->name 年龄 $this->age 岁";
}
}
class P1 extends Person
{
public function a1(){
echo $this->name."保护";
echo $this->getUser();
echo parent::getUser()
}
}
$p2=new P1('a','1');
$p2->a1();
用parent访问父类
echo parent::getUser()
private（私有）：私有的类成员则只能被其定义所在的类访问。
（私有的只能在类里自己使用）
例子（三种类）
class Person{
//在类中三种都可以访问
public $a="publid";
protected $b="protected";
private $c="private";
public function print1(){
echo $this->a.'';
echo $this->b.'';
echo $this->c.'';
}
public function a1(){
echo 'public';
$this->a2();
$this->a3();
}
protected function a2(){
echo 'protected';
}
private function a3(){
echo 'private';
}
}
$p1=new Person();
$p1->a1();
属性的访问控制
类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。
接口
使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是公有，这是接口的特性。
要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。
implements 的作用
implements 关键字用于让一个类去实现一个或多个接口。当一个类使用 implements 实现某个接口时，这个类就必须实现该接口中定义的所有方法，否则该类必须被声明为抽象类。
interface Person{
const NAME='常量';
public function getName();
public function setName($name);
}
interface Person2{
public function setName2($name);
}
class p1 implements Person,Person2 {
public function setName($name){
echo "set_name".$name;
}
public function getName(){
echo "get_name";
}
public function setName2($name){
echo "set_name2".$name;
//一个类里可以有多个接口，但是少声明一个函数就会报错
}
}
$a = new p1();
echo $a->setName('df');
echo $a->getName('df');
常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。
抽象类
任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。
抽象类不能实例化。
被定义为抽象的方法只是声明了其调用方式（参数），不能定义具体的功能。
继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。
当抽象方法受保护时，子类可以是受保护或公有，而不是私有
abstract class Person{
abstract protected function get_name();
abstract protected function set_name($name);
public function run(){
echo 'run';
}
}
class p1 extends Person{
public $name;
function __construct($name){
$this->name = $name;
}
public function get_name(){
echo 'get_name'.$this->name;
}
public function set_name($name){
return 'set_name'.$name;
}
public function run(){
parent::run();
}
}
$a = new p1('a');
$a->get_name('a');
echo $a->set_name('a');
$a->run();
常量
可以把在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号。
Static 关键字
声明类属性或方法为 static(静态)，就可以不实例化类直接访问。
静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
由于静态方法不需要对象即可调用，所以伪变量 $this 在静态方法中不可用。
静态属性不可以由对象通过 -> 操作符来访问。
自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。
直接用Person::$name;
class Person{
public static $name='aa';
public static function getString(){
return 'getString'.self::$name;
}
}
echo Person::getString();
echo Person::$name;
Final 关键字
PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。（父类函数唯一）
调用父类构造方法
要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct()
class Person{
public $name='aa';
public function getString(){
return 'getString';
}
public function __construct()
{
echo "父类构造";
}
}
class c1 extends Person{
public function getString(){
echo parent::getString();
return 'getString';
}
public function __construct()
{
parent::__construct();
echo "子类构造";
}
}
$a = new c1();
超级全局变量
u $GLOBALS 一个包含了全部变量的全局组合数组。变量的名字就是数组的键。
输出所有变量
$a='name';
print_r($GLOBALS);
$_SERVER 一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组
输出所有信息的数组
foreach ($_SERVER as $key => $value) {
echo "[$key]=> $value ";
}
$_REQUEST 用于收集HTML表单提交的数据。
它可以获取 cookie get post
<form method="post">
<input name="username" type="text">
<input name="sub" value="sub" type="submit">
</form>
<?php
print_r($
$_POST 广泛应用于收集表单数据，在HTML form标签的指定该属性："method=“post”。
同上
$_GET 广泛应用于收集表单数据，在HTML form标签的指定该属性："method=“get”。
enctype="multipart/form-data" 是专门为文件上传设计的编码方式，它允许表单数据以二进制形式进行传输，确保文件能够正确地被上传到服务器。当表单中包含文件上传字段时，必须使用这种编码方式。
$_FILES
<form method="post" enctype="multipart/form-data">
<input name="file" type="file"/>
<input name="sub" value="sub" type="submit"/>
</form>
<?php
print_r($_FILES["file"]["name"]);
?>
u $_ENV
u $_COOKIE
u $_SESSION
Include 文件
插入php文件
include 'functions.php';
include 和 require 语句是相同的，除了错误处理方面：
require 会生成致命错误（E_COMPILE_ERROR）并停止脚本
include 只生成警告（E_WARNING），并且脚本会继续
文件处理
文件打开/读取/关闭
$myfile=fopen('a.txt','r');
echo fread($myfile,filesize('a.txt'));
fclose($myfile);
fgetc() 函数用于从文件中读取单个字符。
fgets() 函数用于从文件读取单行
$myfile=fopen('a.txt','r');
echo fgets($myfile);//只能取一行
feof() 函数检查是否已到达文件末尾
$myfile=fopen('a.txt','r');
while(!feof($myfile)){
echo md5(fgets($myfile))."";
}
php文件重命名：函数rename()
rename('a.txt', 'b.txt');
php文件复制：函数copy()
copy('b.txt', 'a.txt');
php文件删除：函数unlink()
unlink('a.txt')
文件的判断
file_exists() 判断文件是否存在
if(file_exists('1.txt')){
echo 'yes';
}else{
echo 'no';
}
is_file() 是否为文件
is_file('1.txt')
获取文件属性
$myfile="1.txt";
file_exists($myfile) or die("no");
echo $myfile."存在大小".filesize($myfile)."kb ";
if (is_readable($myfile)) {
echo "文件可读";
}else{
echo "文件不可读";
}
if (is_executable($myfile)) {
echo "文件可执行";
}else{
echo "文件不可执行";
}
if (is_writable($myfile)) {
echo "文件可写";
}else{
echo "文件不可写";
}
echo "创作时间".date("Y-m-d H:i:s",filemtime($myfile))."";
echo "修改时间".date("Y-m-d H:i:s",filemtime($myfile))."";
echo "访问时间".date("Y-m-d H:i:s",filemtime($myfile))."";
目录操作
目录操作
新建目录：mkdir(路径，权限，递归创建)
$name="myhack";
mkdir($name);
删除目录：rmdir()
rmdir('file3');
移动（改名）：rename()
rename($name,'file3');
获取目录内容：
目录句柄 = opendir() //打开目录
文件名 = readdir(目录句柄)
依次读取文件名，读取不到则返回//打开目录
closedir() //关闭目录
当前目录**.** 上级目录用**…**
递归读取目录内容**：**
遍历C盘文件
$path="C:/";
function tree($path)
{
$dh = opendir($path);
while(($file = readdir($dh)) !== false){
$dirpath="$path$file";
if(is_dir($dirpath) && $file != "." && $file != ".."){
echo "目录$dirpath ";
if (is_readable($dirpath)){
tree($dirpath);
}
}else{
if($file != "." && $file != ".."){
echo "文件$dirpath ";
}
}
}
closedir($dh);
}
命名空间
PHP 命名空间可以解决以下两类问题：
1.代码与PHP内部的类/函数/常量之间的名字冲突。
2.为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，以提高源代码的可读性。
命名空间（可以理解为创建文件夹）
定义：命名空间namespace，是指人为的将内存进行分隔，让不同内存区域的同名结构共存，从而解决在大型项目中可能出现的重名结构的问题
语法：namespace 空间名
作用：不同的空间可以有同名的结构，如：类
空间元素：函数，常量，类，不包括变量！！
子空间（子文件夹）
定义：命名空间内部再划分一个命名空间，让每个小空间独立起来
语法:
namespace 空间名
namespace 空间名\子空间
命名空间访问 （url）
*非限定名称访问*：访问自己命名空间的元素
*限定名称访问*：使用自己当前的子空间名字+ \ + 元素名字
*完全限定名称访问*：\ + 全局空间 + \ + 元素名字
注：任何空间元素访问，只针对函数，类，常量
php//本空间
namespace mydemo;
include '4.php';
const NAME="a.";
function getName(){
return 'getName.';
}
class Dog{
static function run(){
return 'dog.';
}
}
echo NAME;
echo getName();
echo dog::run();//非限定名称（本空间）
echo a\NAME;//限定名称（子空间）
echo \mydemo\NAME;//完全限定名称
php//子空间
namespace mydemo\a;
const NAME="a_a";
function getName(){
return 'getName_a';
}
class Dog{
static function run(){
return 'dog_a';
}
}
全局空间（C盘）
如果定义了命名空间，非限定名称的寻找系统常量的方式：
首先：在自己的空间内找
然后：如果找不到元素
系统常量–>进入全局空间寻找
系统类 --> 不会自动进入全局空间寻找，而是会报错（看不懂）
命名空间的引入
1.空间引入方式：use关键字
引入类：use 空间名\类名
引入函数：use function 空间名\函数名
引入常量：use const 空间名\常量名
2.当引入元素时重名，通过 as 来起别名
use 空间名\类名 as 别名
3.引入多个元素
use 空间名{
类名，
function 函数名，
const 常量
}
引入空间
use 空间名
namespace one;
include '4.php';
//use引用整个命名空间
use mydemo\b as aa;
echo aa\NAME;
//引入类
use mydemo\b\Dog;
$a=new Dog();
echo $a->say();
//引入常量
use const mydemo\b\NAME;
echo NAME;
//引入函数
use function mydemo\b\getName;
echo getName();
$b=new \mydemo\b\Dog();
echo $b->say();
正则表达式
正则表达式有三个作用：
匹配，也常常用于从字符串中析取信息。
用新文本代替匹配文本。
将一个字符串拆分为一组更小的信息块。
基本语法
PCRE库函数中，正则匹配模式使用分隔符与元字符组成，分隔符可以是非数字、非反斜线、非空格的任意字符。经常使用的分隔符是正斜线(/)、hash符号(#) 以及取反符号(~)
元字符是用于构造规则表达式的具有特殊含义的字符。如果要在正则表达式中包含元字符本身，必须在其前加上”\”进行转义
进行正则表达式匹配，并且只匹配一次
preg_match('/a/', $name)
preg_match() |
匹配一次（找到就停） |
|---|
preg_match_all() |
匹配所有符合条件的内容 |
|---|
-
*- 说明: 匹配前面字符的 0 次或多次出现。
- 通俗解释: 就是说，它匹配前面那个字符出现零次或者多次。比如
a*会匹配空字符串（因为零次出现）或者多个连续的a（比如 “aa”、“aaa” 等）。（任何字符都会匹配） - 例子:
a*可以匹配""、a、aa、aaa等。
-
+- 说明: 匹配前面字符的 1 次或多次出现。
- 通俗解释: 它要求前面那个字符至少出现一次，如果出现次数多也可以。（不能为空）
- 例子:
a+只能匹配a、aa、aaa等，不能匹配空字符串。
-
?- 说明: 匹配前面字符的 0 次或 1 次出现。
- 通俗解释: 这是“可有可无”的意思。前面的字符要么出现一次，要么不出现。
- 例子:
a?可以匹配""或a。
-
|- 说明: 匹配两个或多个选择中的一个。
- 通俗解释: 它就像“或者”的意思。匹配这个模式中的“左边”或者“右边”部分。（有其中一个就可以匹配）
- 例子:
a|b可以匹配a或b。
-
^- 说明: 匹配字符串的开头。
- 通俗解释: 它要求匹配的内容在字符串的开始部分出现。
- 例子:
^a只会匹配以a开头的字符串。
-
$- 说明: 匹配字符串的结尾。
- 通俗解释: 它要求匹配的内容出现在字符串的最后部分。
- 例子:
a$只会匹配以a结尾的字符串。
-
[]- 说明: 匹配方括号中的任一字符。
- 通俗解释: 就是括号里的“选择”，可以是一个字符，也可以是一个字符范围。（任意一个字符就能匹配）
- 例子:
[abc]会匹配a、b或c。 -
/[a-z0-9]{32}/
可以结合{}使用，代表查找32次
-
[^]- 说明: 匹配方括号外的任一字符。
- 通俗解释: 如果方括号里的第一个字符是
^，表示“不是里面的字符”。 - 例子:
[^abc]会匹配除了a、b、c之外的任何字符。
-
{m}- 说明: 匹配前面字符恰好出现
m次。 - 通俗解释: 要求前面那个字符出现刚好
m次。 - 例子:
a{3}会匹配aaa。
- 说明: 匹配前面字符恰好出现
-
{m,n}- 说明: 匹配前面字符至少出现
m次，最多出现n次。 - 通俗解释: 要求前面那个字符出现的次数介于
m和n之间。 - 例子:
a{2,4}会匹配aa、aaa或aaaa。
- 说明: 匹配前面字符至少出现
-
{m,}- 说明: 匹配前面字符至少出现
m次。 - 通俗解释: 要求前面那个字符出现次数至少为
m次。 - 例子:
a{2,}会匹配aa、aaa、aaaa等。
- 说明: 匹配前面字符至少出现
-
()- 说明: 将多个字符或模式组合成一个整体。
- 通俗解释: 圆括号用来“包裹”一部分正则，表示它们是一个整体，通常用于提取或分组。
- 例子:
(abc)+会匹配abc重复一次或多次。
-
.- 说明: 匹配除了换行符以外的任何一个字符。
- 通俗解释: 它匹配任何单个字符，只要不是换行符。
- 例子:
a.b会匹配aab、acb等。
preg_match() 的第三个参数 $p 是一个数组，用于存储匹配的详细信息
边界限制
^ag$（必须以a开头以g结尾）
/i（不区分大小写）
$name='aahjg';
if (preg_match('/A/i', $name,$p)
-
\d：匹配一个数字字符 -
\D：匹配一个非数字字符 -
\f：匹配一个换页符 -
\n：匹配一个换行符 -
\r：匹配一个回车符 -
\s：匹配任何空白字符 -
\S：匹配任何非空白字符 -
\t：匹配一个制表符 -
\v 匹配一个垂直制表符
-
\w 匹配所有单词字符加下划线
-
\W 匹配所有不是单词字符和下划线
模式匹配的顺序（从高到低）
顺序 元字符 说明
1 （） 模式单元
2 ？ +{}* 重复匹配
3 ^$ 边界限制
4 | 模式选择
php连接mysql（不懂）
$conn->query("SQL语句") 表示调用 $conn 对象的 query() 方法执行 SQL。
- JavaScript：用
.操作符（如obj.method()）。 - Python：同样用
.操作符（如obj.method()）。 - PHP：为了明确区分对象操作和普通变量，使用
->。
$servername = "localhost";
$username = "root";
$password = "root";
$conn = new mysqli($servername, $username, $password);
//servername代表连接位置
创建数据库
connect_error) {
die("Connection failed: " . $conn->connect_error);
}
// Create database
$sql = "CREATE DATABASE myDB";
if ($conn->query($sql) === TRUE) {
echo "Database created successfully";
} else {
echo "Error creating database: " . $conn->error;
}
$conn->close();
?>
创建数据表
$servername = "localhost";
$username = "root";
$password = "root";
$dbname="mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
}else{
echo 'Connected successfully';
}
$sql = "CREATE TABLE users (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(30) NOT NULL,
password VARCHAR(30) NOT NULL,
email VARCHAR(50)
);";
if ($conn->query($sql) === TRUE) {
echo "table created successfully";
} else {
echo "Error creating database: " . $conn->error;
}
插入数据
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "INSERT INTO users (username, password, email) VALUES ('asdf', '122', 'ads')";
if ($conn->query($sql) === TRUE) {
echo "insert successfully";
} else {
echo "Error insert: " . $conn->error;
}
查询数据
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "select * from users where id=".$_GET['id'];
$result = $conn->query($sql);
if ($conn->query($sql)==true) {
}else{
echo "mysqli error",$conn->error;
}
if ($result->num_rows > 0) {
while($row = $result->fetch_assoc()) {
echo "id: ". $row["id"]. " - Name: ". $row["username"]. " " . $row["password"]." ".$row["email"]."
";
}
} else {
echo "0 results";
}
删除数据
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "DELETE FROM users where id=".$_GET['id'];
$result = $conn->query($sql);
if ($conn->query($sql)==true) {
echo "删除成功";
}else{
echo "删除失败";
}
更新数据
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "update users set username='a' where id=2";
if ($conn->query($sql) === TRUE) {
echo "update successfully";
} else {
echo "Error update: " . $conn->error;
}
$conn->close();
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "select * from users where id=".$_GET['id'];
$result = $conn->query($sql);
if ($conn->query($sql)==true) {
}else{
echo "mysqli error",$conn->error;
}
if ($result->num_rows > 0) {
while($row = $result->fetch_assoc()) {
echo "id: ". $row["id"]. " - Name: ". $row["username"]. " " . $row["password"]." ".$row["email"]."
";
}
} else {
echo "0 results";
}
删除数据
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "DELETE FROM users where id=".$_GET['id'];
$result = $conn->query($sql);
if ($conn->query($sql)==true) {
echo "删除成功";
}else{
echo "删除失败";
}
更新数据
$servername = "localhost";
$username = "root";
$password = "root";
$dbname = "mydatabase";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
echo "Connection failed: " . $conn->connect_error;
} else {
echo 'Connected successfully';
}
$sql = "update users set username='a' where id=2";
if ($conn->query($sql) === TRUE) {
echo "update successfully";
} else {
echo "Error update: " . $conn->error;
}
$conn->close();