PHP一些注意点

1. PHP变量作用域
变量的作用域是脚本中变量可被引用/使用的部分。
PHP有四种不同的变量作用域：

  • local
  • global
  • static
  • parameter

局部和全局最作用域
在所有函数外部定义的变量，拥有全局作用域。除了函数外，全局变量可以被脚本中的任何部分访问，要在一个函数中访问一个全局变量，需要使用global关键字
在PHP函数内部声明的变量是局部变量，仅能在函数内部访问：
实例

<?php
$x=5;
$y=10;

function myTest()
{
    global $x,$y;
    $y=$x+$y;
}

myTest();
echo $y;//输出15
?>

PHP将所有的全局变量存储在一个名为$GLOBAL[index]是数组中。index保存变量的名称。这个数组可以在函数内部访问，也可以直接用来更新全局变量。
上面的实例可以写成如下形式：

<?php
$x=5;
$y=10;

function myTest()
{
    $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
}

myTest();
echo $y;
?>

Static作用域
当一个函数完成时，它的所有变量通常都会被删除。然而，有时候希望某个局部变量不要被删除。要做到这一点，可以在第一次声明变量时使用static关键字：
实例：

<?php
function myTest()
{
    static $x=0;
    echo $x;
    $x++;
    echo PHP_EOL;     //换行符
}

myTest();
myTest();
myTest();
//每次调用该函数时，该变量将会保留着函数前一次被调用时的值
//输出0 1 2
?>

注意:该变量仍然时函数的局部变量。

参数作用域
参数是通过调用代码将值传递给函数的局部变量，参数是在参数列表中声明的，作为函数声明的一部分：
实例：

<?php
function myTest()
{
    echo $x;
}
myTest(5);
?>

2. PHP echo和print语句
echo和print区别：

  • echo可以输出一个或者多个字符串
  • print只允许输出一个字符串，返回值总为1

提示：echo输出的速度比print快，echo没有返回值，print有返回值1。

var_dump()函数返回变量的数据类型和值

PHP类型比较：

  • 松散比较：使用两个等号==比较，只能比较值，不比较类型。
  • 严格比较：用三个等号===比较，除了比较值，也比较类型。

使用define()函数设置常量
实例：

<?php
define("GREETING","欢迎光临！");
echo GREETING;  //输出欢迎光临！
?>

在PHP中，使用（.）号开连接两个字符串。
实例：

<?php
$txt1="Hello world!";
$txt2="what a nice day!";
echo $txt1." ".$txt2;  //输出 Hello world! What a nice day! 
?>

strlen()函数返回字符串的长度
实例：

<?php
echo strlen("Hello world!");  //输出 12
?>

PHP strpos()函数
strpos()函数用于在字符串内查找一个字符或者一段指定的文本。如果在字符串中找到匹配，该函数会返回第一个字符的位置。如果未找到匹配，则返回FALSE。

<?php
echo strpos("Hello world!","world");
//输出 6
//解析：之所以是6而不是7的原因是，字符串中第一个字符的位置是0，而不是1。
?>

PHP7+版本新增整除运算符intdiv(),该函数返回值为第一个参数除以第二个参数的值（向下取整）
实例：

<?php
var_dump(intdiv(10,3));
//输出 int(3)
?>

三元运算符
语法格式
(expr1) ? (expr2) : (expr3)
对exp1求值为TRUE时的值为exp2,在expr1求值为FALSE时的值为expr3。自PHP5.3起，可以省略三元运算符中间那部分。表达式expr1 ?：expr3在expr1求值为TRUE时返回expr1，否则返回expr3。
实例：

<?php
//判断$_GET请求中含有user值，如果有,返回$_GET['user'],否则返回nobody;
$username = isset($_GET['user'])?$_GET['user']:'nobody';
echo $username,PHP_EOL;

//PHP5.3+版本写法
$username =  $_GET['USER']?:'nobody';
echo $username,PHP_EOL;
?>

在PHP7+版本多了一个NULL合并运算符??
实例：

<?php
// 如果 $_GET['user'] 不存在返回 'nobody'，否则返回 $_GET['user'] 的值
$username = $_GET['user'] ?? 'nobody';
// 类似的三元运算符
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';
?>

PHP数组
在PHP中，array()函数用于创建数组，在PHP中，有三种类型的数组：

  • 数值数组：带有数字ID键的数组
  • 关联数组：带有指定的键的数组，每个键关联一个值
  • 多维数组：包含一个或者多个数组的数组
    count()函数用于返回数组的长度（元素的数量）
    PHP创建关联数组的方法：
<?php
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
//或者
$age['Peter']="35";
$age['Ben']="37";
$age['Joe']="43"; 
?>

遍历并打印关联数组中所有的值，可以使用foreach循环
实例：

<?php
$age = array("Peter"=>"35","Ben"=>"37","Joe"=>"43");

foreach($age as $x=>$x_value)
{
    echo "Key=" .$x . ",Value=" .$x_value;
    echo "<br>";
}
?>

PHP数组排序函数

  • sort():对数组解析升序排序
  • rsort():对数组进行降序排序
  • asort():根据关联数组的值，对数组进行升序排序
  • arsort():根据关联数组的值，对数组进行降序排序
  • ksort():根据关联数组的键，对数组进行升序排序
  • krsort()：根据关联数组的键，对数组进行降序排序

PHP超级全局变量

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

$GLOBALS是PHP的一个超级全局变量组，在一个PHP脚本的全部作用域中都可以访问。$GLOBALS是一个包含了全部变量的全局组合数组，变量的名字就是数组的键。

$_SERVER是一个包含了诸如头信息、路径、脚本位置等等信息的数组，这个数组中的项目由WEB服务器创建。不能保证每个服务器都提供全部项目；服务器可能会忽略一些，或者提供一些没有的项目。

$_REQUEST 用于收集HTML表单提交的数据。$_POST 被广泛应用于收集表单数据，在HTML form标签的指定该属性："method="post"。PHP $_GET 同样被广泛应用于收集表单数据，在HTML form标签的指定该属性："method="get"。

PHP魔法常量

  1. _LINE_
    文件中的当前行号。
    实例：
<?php
echo '这是第 " '  . __LINE__ . ' " 行';
//输出 这是第"2"行
?>
  1. _FILE_
    文件的完整路径和文件名。如果用在被包含的文件中，则返回被包含的文件名。
<?php
echo '"该文件位于 " '. __FILE__ . '"';
//输出 /var/www/html/index.php
?>
  1. _DIR_
    文件所在的目录。如果用在被包含文件中，则返回被包含的文件所在目录。
<?php
echo '该文件位于"' .__DIR__ .'"';
//输出 该文件位于"/var/www.html"
?>
  1. _FUNCTION_
    返回函数名称
  2. _CLASS_
    返回类的名称
  3. _TRAIT_
  4. _METHOD_
    返回该方法被定义时的名字（区分大小写）。
  5. _NAMESPACE_
    当前命名空间的名称。

PHP命名空间(namespace)
PHP命名空间可以解决以下两类问题：

  1. 用户编写的代码与PHP内部的类/函数/常量或者第三方类/函数/常量之间的名字冲突。
  2. 为很长的标识符名称创建一个别名，提高代码的可读性。
    命名空间通过关键字namespace来声明。如果一个文件中包含命名空间，它必须在其他代码之前声明命名空间。
    语法：
<?php
namespace MyProject;
//....代码....
?>

在单个文件中定义多个命名空间，建议使用大括号形式的语法。

<?php
namespace MyProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}

namespace AnotherProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}
?>

将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法，全局代码必须用一个不带名称的namespace语句加上大括号：

namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }
}

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

注意：在声明命名空间之前唯一合法的代码是用于定义源文件编码方式的declare语句。所有非PHP代码包括空字符都不能出现在命名空间的声明之前。

PHP面向对象
对象的主要三个特性：

  • 对象的行为：对象可以执行的操作，比如：开灯，关灯就是行为
  • 对象的形态：对大学不同的行为是如何响应的，比如：颜色，尺寸，外观
  • 对象的表示：对象的表示就相当于身份证，具有区分在相同行为与状态下有声明不同、

面向对象编程的三个主要特性：

  • 封装：指将对象的属性和方法封装在一起，使得外部无法直接访问和修该对象的内部状态，通过使用访问修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。
  • 继承：指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加直接的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的复用。
  • 多态：指可以使用一个父类型的变量来引用不同的子类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在PHP中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。

面向对象内容

  • 类：定义了一件事情的抽象特点。类的定义包含了数据的形式以及对数据的操作。
  • 对象：是类的实例
  • 成员变量：定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数来访问，在类被实例化为对象后，该变量即可成为对象的属性
  • 成员函数：定义在类的内部，可用于访问对象的数据
  • 继承：继承是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上，把这个已经存在的类所定义的内容作为之间的内容，并加入若干新的内容
  • 父类：一个类被其他类继承，可将该类称为父类，或者基类、超类
  • 子类：一个继承其他的类称为子类人，也可称为派生类
  • 多态：多态性是指相同的函数或者方法可作为多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性
  • 重载：就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称为重载函数或者方法
  • 抽象性：是指将具有一致的数据类型的对象抽象称类。一个类就是这样的一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分但是主观的，但是必须与具体的应用有关
  • 封装：封装是指将现实世界中存在的某个客观的属性与行为绑定在一起，并放置在一个逻辑单元内
  • 构造函数：主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中
  • 析构函数：与构造函数相反，当对象结束其生命周期时，系统自动执行析构函数。析构函数往往用来做清理的工作例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

PHP类定义
实例：

<?php
class phpClass{
    var $var1;
    var $var2 = "constant string";
    
    function myfunc($arg1,$arg2){
        //.....
    }
    //...
}
?>

解析如下：

  • 类使用class关键字后加上类名定义
  • 类名后的一对大括号内可以定义变量和方法
  • 类的变量使用var来声明，变量也可以初始化值
  • 函数定义类似PHP函数的定义，但函数只能通过该类及其实例化的对象访问
    实例：
<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;
  
  /* 成员函数 */
  function setUrl($par){
     $this->url = $par;
  }
  
  function getUrl(){
     echo $this->url . PHP_EOL;
  }
  
  function setTitle($par){
     $this->title = $par;
  }
  
  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}
?>

变量$this代表自身的对象。
PHP中创建对象
类创建后，使用new运算符来实例化该类对象：

<?php
$taobao = new Site;
$baidu = new Site;
$google = new Site;

//调用成员方法
$taobao->setTitle("淘宝");
$baidu->setTitle("百度一下");
$google->setTitle("谷歌一下");

//调用成员函数，获取标题和URL
$taobao->getTitle();
$baidu->getTitle();

$taobao->getUrl();
$baidu->getUrl();
?>

PHP构造函数
构造函数时一种特殊的方法。主要用来在创建对象时的初始化对象，即为对象成员变量赋初始值，在创建对象的语句中与new运算符一起使用。

function __construct($par1,$par2){
    $this->url = $par1;
    $this->title = $par2;
}

实例：

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;

  function __construct( $par1, $par2 ) {
    $this->url = $par1;
    $this->title = $par2;
  }
  /* 成员函数 */
  function setUrl($par){
     $this->url = $par;
  }
  
  function getUrl(){
     echo $this->url . PHP_EOL;
  }
  
  function setTitle($par){
     $this->title = $par;
  }
  
  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}

$taobao = new Site('www.taobao.com', '淘宝');
$google = new Site('www.google.com', 'Google 搜索');

// 调用成员函数，获取标题和URL
$taobao->getTitle();
$google->getTitle();

$taobao->getUrl();
$google->getUrl();
?>

析构函数与构造函数相反，当对象结束其生命周期时，系统自动执行析构函数。
实例：

<?php
class MyDestructableClass {
   function __construct() {
       print "构造函数\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "销毁 " . $this->name . "\n";
   }
}

$obj = new MyDestr
?>

PHP使用关键字extends来继承一个类，PHP不支持多继承，格式如下：

class Child extends Parent{
    //代码部分
}

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法覆盖。

访问控制
PHP对属性或者方法的访问控制，是通过在前面添加关键字public(共有),protected(受保护)或者private(私有)来实现的。

  • public（共有）：共有的类成员可以在任何对方被访问
  • protected（受保护）：受保护的类成员则可以被其自身以及子类和父类访问
  • private（私有）：私有的类成员则只能被其定义的类中访问

实例1：

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以对 public 和 protected 进行重定义，但 private 而不能
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined

?>

实例2：

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 声明一个公有的构造函数
    public function __construct() { }

    // 声明一个公有的方法
    public function MyPublic() { }

    // 声明一个受保护的方法
    protected function MyProtected() { }

    // 声明一个私有的方法
    private function MyPrivate() { }

    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 此方法为公有
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 这行会产生一个致命错误
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行

class Bar 
{
    public function test() {
        $this->testPrivate();
        $this->testPublic();
    }

    public function testPublic() {
        echo "Bar::testPublic\n";
    }
    
    private function testPrivate() {
        echo "Bar::testPrivate\n";
    }
}

class Foo extends Bar 
{
    public function testPublic() {
        echo "Foo::testPublic\n";
    }
    
    private function testPrivate() {
        echo "Foo::testPrivate\n";
    }
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate 
                // Foo::testPublic
?>

接口
使用接口（interface），可以指定某个指定的类必须实现那些方法，但不需要定义这些方法的具体内容，接口时通过interface关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。接口中定义的所有方法都必须是共有，这是接口的特性。要实现一个接口，使用implements操作符，类中必须实现接口中定义的所有方法，否则会报一个致命的错误，类可以实现多个接口，用逗号来分隔多个接口名称。
实例：

<?php
interface iTemplate
{
    public function setVariable($name,$var);
    public function getHtml($template);
}

//实现接口
class Template implements iTemplate
{
    private $vars = array();

    public function setVariable($name,$var)
    {
        $this->vars[$name] = $var;
    }

    public function getHtml($template)
    {
        foreach($this->vars ad $name=> $value)
        {
            $template = str_replace('{' .$name .'}',$value,$template);
        }
        return $template;
    }
}>

抽象类
任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的，定义为抽象的类不能被实例化，被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现，继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外这些方法的访问控制必须和父类中一样，例如某个抽象方法被声明为受保护的，那么子类中实现的方法应该声明为受保护的或者共有的，而不能定义为私有的。

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
//输出
// ConcreteClass1
// FOO_ConcreteClass1
// ConcreteClass2
// FOO_ConcreteClass2
?>

此外，子类方法可以包含父类抽象方法中不存在的可选参数。例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则也是可以正常运行的。

<?php
abstract class AbstractClass
{
    // 我们的抽象方法仅需要定义需要的参数
    abstract protected function prefixName($name);

}

class ConcreteClass extends AbstractClass
{

    // 我们的子类可以定义父类签名中不存在的可选参数
    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
//输出 Mr. Pacman
//输出 Mrs. Pacwoman
?>

Final关键字，如果父类中的方法被声明为final，则子类无法覆盖该方法。如果应该类被声明为final，则不能被继承。
PHP不会再子类的构造方法中自动调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用parent:__construct()。

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();

//输出 
// BaseClass 类中构造方法
// BaseClass 类中构造方法
// SubClass 类中构造方法
// BaseClass 类中构造方法
?>

子类继承调用带有参数的父类构造方法

<?php
class students{
    var $name,$age,$sex;
    function __construct($name,$age,$sex){
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }
}

class master extends students{
    var $hobby,$address;
    function __construct($name, $age, $sex,$hobby,$address){
        parent::__construct($name, $age, $sex);
        $this->hobby = $hobby;
        $this->address = $address;
    }
}
?>
posted @   kalixcn  阅读(22)  评论(0)  编辑  收藏  举报
相关博文：
· PHP重要知识点
· PHP连接MYSQL的一些操作
· PHP笔记
· PHP基础之面向对象讲解
· 3-php学习笔记之类与对象（面向对象）
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛