PHP学习笔记

php注释

<?php
// 单行注释
/* 多行注释
echo "hello world";
echo "hello world";
*/
?>

多行注释不可嵌套。

php变量

<?php
$x = 5;
$y = 7;
$z = $x + $y;
echo $z;
?>

$+变量名。

常规格式，下划线/字母开头， 不包含空格，只包含A-z、0-9、_

弱类型，和python类似。

$txt = "i love you";
$x = 5;
$y = 7;

作用域，和python类似

• global 关键字

    <?php
    $x = 5;
    $y = 10;
  
    function myFun()
    {
        global $x, $y; // 函数内调用，函数外的全局变量，使用global关键字声明即可。
        $y = $x + $y;
    }
    myFun();
    echo $y; // 值变为15；
    ?>

• $GLOBALS 数组

  存放所有全局变量的数组，在函数内部可以直接访问和修改

  <?php
    $x = 5;
    $y = 10;
  
    function myFun()
    {
        $GLOBALS['y'] = $GLOBALS['x'] + $GLOBALS['y'];
    }
    myFun();
    echo $y;
    ?>

php echo 和 print语句

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

• echo

  <?php
  echo "<h1> php 真是一个好东西</h1>";
  echo "PHP 是全世界最好的语言<br>";
  echo "全世界的人都在学php<br>";
  echo "第一个字符串 ", "第二个字符串 ", "第三个字符串 " , " echo 可以返回多个字符串";
  ?>

  进阶

  <?php
  $x = "我爱你";
  $girlfriend = array("aaa", 'bbb', 'ccc');
  
  echo "{$girlfriend[0]} , $x , 哈哈哈。";
  ?>

• print

  <?php
  print "<h2>php 真有趣 </h2>";
  print "我爱学习";
  ?>

  进阶

  <?php
  $x = "我爱你";
  $girlFriends = array('aaa', 'bbb', 'ccc');
  
  print $x;
  print "$x , {$girlFriends[0]} ";
  ?>

php EOF(heredoc)

<?php
echo <<<EOF
    <h1> 我的第一个标题</h1>
    <p>我的第一个段落</p>
EOF;
// 结束符独立一行，且前后不能有空格

$name = "lizishi";
// 开始表示不加引号或加双引号的效果一样，会对内部的变量进行解释，加单引号不会对双引号进行解释
$a = <<<EOF
"abc"$name
"123"
EOF;

echo $a;
?>

php 数据类型

• 字符串

  <?php
  $x = "hello world";
  echo $x;
  ?>

• php 整数

  <?php
  $x = 521;
  var_dump($x); // 返回变量的数据类型和值
  echo "<br>";
  $x = -100;
  var_dump($x);
  echo "<br>";
  $x = 0x8C; // 16进制
  var_dump($x);
  echo "<br>";
  $x = 047; // 8进制
  var_dump($x);
  ?>

• php 浮点型

  <?php
  $x = 10.212;
  var_dump($x);
  echo "<br>";
  $x = 2.4e2;
  var_dump($x);
  echo "<br>";
  $x = 8E-5;
  var_dump($x);
  ?>

• php 布尔型

  <?php
  $x = true;
  if($x){
      echo "true", "<br>";
  }
  $y = false;
  if(!$y){
      echo "false";
  }
  ?>

• php 数组

  <?php
  $cars = array("aaa", "bbb", "ccc");
  var_dump($cars);
  ?>

• php 对象

  class Car
  {
      var $color;
      function __construct($color="green"){
          $this -> color = $color;
      }
      function what_color(){
          return $this -> color;
      }
  }
  $car = new Car("blue");
  echo $car->what_color();
  ?>

• php null值

  <?php
  $x = "";
  var_dump($x);
  echo "<br>";
  $x = null; // 没有类型，可以用来将变量置空。
  var_dump($x);
  ?>

php 类型比较

php 是弱类型语言， 松散比较 == 只比较值，严格比较=== 比较值和类型

<?php
if(42 == "42"){
    echo '1、值相等';
}
echo PHP_EOL;// 换行符

if(42 === "42"){
    echo "2、类型相等";
}else{
    echo "3、不相等";
}
?>

php常量

简单值的标识符，该值在脚本中不可改变。一个常量名和普通变量的命名一样，没有$标识。

全局变量，在整个运行脚本的任何地方都可以调用。

• 设置常量

  bool define(string $name, mixed $value [,bool $case_insensitive = false])

  $case_insensitive 表示常量名是否区分大小写，当为true 时常量名不区分大小写。

• 举例

  <?php
  define("welcome", "欢迎来到我的php页面^_^");
  echo welcome;
  ?>

php 字符串变量的操作

• php 字符串并置运算符

  <?php
  $txt1 = "How are you?";
  $txt2 = "I'm fine, And you?";
  
  echo $txt1 . " " . $txt2;
  ?>

• strlen() 函数

  返回字符串长度

  <?php
  $txt2 = "I'm fine, And you?";
  echo strlen($txt2);
  ?>

• strpos() 函数

  在字符串中查找一个字符或一段指定的文本。

  如果在字符串中找到匹配，该函数会返回第一个匹配的字符位置。如果未找到匹配，则返回 FALSE。

  <?php
  echo strpos("welcome come to GuangDong", "come");
  // 返回3
  ?>

菜鸟教程中的string 操作手册](https://www.runoob.com/php/php-ref-string.html)

php 运算符

常规操作，支持 ++ ，– 等。

整除intdiv(10, 3)

• 三元操作符

  (expr1) ? (expr2) : (expr3) 

  对 expr1 求值为 TRUE 时的值为 expr2，在 expr1 求值为 FALSE 时的值为 expr3。

php if…else 语句

和C++的一样

<?php
if(1 == 1){
    echo "我是你爹";
}else if(1 != 1){
    echo "我是你娘";
}else{
    echo "我是你哥";
}
?>

php switch 语句

和C++一样

<?php
$x = "red";
switch ($x){
    case "red": echo "red"; break;
    case "blue": echo "blue"; break;
    default: echo "啥都不是";
}
?>

php 数组

• php 数值数组

  简单的以数值为key

  <?php
  $a = array('a', 'b', 'c');
  echo $a[1]."<br>";
  echo count($a); // 返回数组的元素数量。
  ?>

  数组的遍历

  <?php
  $a = array('a', 'b', 'c');
  for($x = 0; $x < count($a); $x ++){
      echo $a[$x]."<br>";
  }
  ?>

• php 关联数组

  <?php
  $a = array('a'=>1, 'b'=>2, 'c'=>3);
  foreach($a as $x=>$x_value){
      echo "key= " . $x . " , value= " . $x_value . "<br>";
  }
  ?>
  返回：
      key= a , value= 1
      key= b , value= 2
      key= c , value= 3

php 数组排序

• sort() 对数组进行升序排列

• rsort() 对数组进行降序排列

• asort() 跟据数组的值，对数组进行升序排列

  <?php
  $a = array('Peter'=>24, 'Ben'=>33, 'Joe'=>12);
  asort($a);
  print_r($a); // Array ( [Joe] => 12 [Peter] => 24 [Ben] => 33 )
  ?

• ksort() 根据数组的键，对数组进行升序排列

  <?php
  $a = array('Peter'=>24, 'Ben'=>33, 'Joe'=>12);
  ksort($a);
  print_r($a); Array ( [Ben] => 33 [Joe] => 12 [Peter] => 24 )
  ?>

• arsort() 根据数组的值，对数组进行降序排列

• krsort() - 根据数组的键，对数组进行降序排列

php 超级全局变量

超级全局变量	作用
$GLOBALS	包含全部变量的全局组合数组，变量的面名字就是数组的键
$_SERVER	包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组，有web服务器创建
$_REQUEST	用于收集HTML表单提交的数据，表单提交的数据名就是数组的键
$_POST	用来收集post类型的表单提交的数据
$_GET	用来收集get类型的表单提交的数据

php 循环

• while 循环

  <?php
  $x = 1;
  while($x < 5){
      echo "number " . $x . "<br>";
      $x ++;
  }
  // do while
  $x = 1;
  do{
      echo "number " . $x . "<br>";
      $x ++;
  }while($x < 5);
  ?>

• for 循环

  <?php
  for($x = 1;$x < 5; $x ++){
      echo "number " . $x . "<br>";
  }
  ?>

• foreach 循环

  <?php
  $x = array(1, 2, 3, 4);
  foreach($x as $value){
      echo $value . "<br>";
  }
  ?>

php 函数

<?php
function Sum($x, $y){
    return $x + $y;
}
echo Sum(1, 2);
?>

php 魔术常量

__LINE__	当前所处的行数
__FILE__	文件的完整路径和文件名。如果用在被包含的文件中，则返回被包含的文件名。
__DIR__	文件所在目录，如果在被包含文件中，则返回被包含文件所在的目录
__FUNCTION__	返回函数定义时的名字，用在函数内部
__CLASS__	常量返回该类被定义时的名字
__TRAIT__	用来进行代码复用，
__METHOD__	返回该方法被定义时的名字（区分大小写）
__NAMESPACE__	当前命名空间的名称（区分大小写）

php 命名空间

• 定义命名空间

  如果一个文件包含命名空间，它必须在其他所有代码之前声明命名空间

  <?php
  declare(encoding='utf-8'); // 在声明命名空间之前的唯一合法代码。
  namespace MyProject { // 命名空间之前不能有任何代码，包括html代码。
      const CONNECT_OK = 1;
      class Connection { /* ... */ }
      function connect() { /* ... */  }
  }
  
  namespace AnotherProject {
      const CONNECT_OK = 1;
      class Connection { /* ... */ }
      function connect() { /* ... */  }
  }
  // 将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法。全局代码必须用一个不带名称的 namespace 语句加上大括号括起来
  namespace {
      session_start();
      $a = MyProject\connect();
      echo MyProject\Connection::start();
      echo "asdf";
  }
  ?>

• 子命名空间

  <?php
  namespace MyProject\Sub\Level;
  const CONNECT_OK = 1;
  class  Connection{ /*...*/ }
  function Connect() { /*...*/ }
  
  //创建了常量 MyProject\Sub\Level\CONNECT_OK，类 MyProject\Sub\Level\Connection 和函数 MyProject\Sub\Level\Connect。
  ?>

• 命名空间的使用

  test1.php

  <?php
  namespace Foo\Bar\subnamespace;
  
  const FOO = 1;
  function foo() {
      echo "test1"."<br>";
  }
  class foo
  {
      static function staticmethod() {
          echo "test1" . "<br>";
      }
  }
  ?>

  test2.php

  <?php
  namespace FOO\Bar;
  include 'test1.php';
  
  const FOO = 2;
  function foo() {
      echo "test2" . "<br>";
  }
  class foo
  {
      static function staticmethod() {
          echo "test2" . "<br>";
      }
  }
  
  // 非限定名称
  foo(); // 解析函数为 Foo\Bar\foo
  foo::staticmethod(); // 解析为类 Foo\Bar\foo, 方法为staticmethod
  echo FOO; // 解析常量为 Foo\Bar\FOO
  echo '<br>';
  // 限定名称
  subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
  subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
  echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
  echo '<br>';
  // 完全限定名称
  \Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo;
  \Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
  echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO

• 命名空间和动态语言特征

• namespace关键字和__NAMESPACE__常量

• 使用命名空间：别名/导入

• 使用命名空间：后备全局函数/常量

php 面向对象

• 类的定义

  <?php
  class Site{
      // 成员变量
      var $url;
      var $title;
      // 成员函数
      function setUrl($par){
          $this -> url = $par;
      }
      function getUrl(){
          echo $this -> url . '<br>';
      }
      function  setTitle($par){
          $this -> title = $par;
      }
      function  getTitle(){
          echo $this -> title . '<br>';
      }
  }
  $site = new Site();
  $site -> setTitle("mysite");
  $site -> setUrl("https://ainiya.xyz");
  $site -> getTitle();
  $site -> getUrl();
  ?>

• 构造函数

  // 构造函数
  function __construct($par1, $par2)
  {
      $this -> title = $par1;
      $this -> url = $par2;
  }

• 析构函数

  <?php
  class MyClass{
      function __construct()
      {
          echo "构造函数<br>";
          $this->name = __CLASS__;
      }
      function __destruct()
      {
          echo "销毁 " . $this->name . '<br>';
      }
  }
  $obj = new MyClass();
  ?>

• 继承

  class Child_Site extends Site{
      var $category;
      function setCate($par){
          $this->category = $par;
      }
      function getCate(){
          echo $this->category . '<br>';
      }
  }

• 方法重写

  class Child_Site extends Site{
      /*....*/
      // 对getUrl方法进行重写
      function getUrl() {
         echo $this->url . PHP_EOL;
         return $this->url;
      }
  }

• 访问控制

  1. public（公有）：公有的类成员可以在任何地方被访问
  2. protected （受保护）：受保护的类成员则可以背鳍自身异界子类和父类访问
  3. private（私有）：是由的类成员只能被其定义所在的类访问

  <?php
  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(); // 正常
  
  echo '<br>';
  
  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->protected; // 报错
  //echo $obj2->private; // 未定义private
  $obj2 -> printHello(); // 不会输出private
  ?>

• 方法的访问控制

  和属性的基本一样，也是public，protected，private三个关键字。不加关键字默认为公有。

  protected function MyProtected() {}

• 接口(interface)

  定义public 的空的方法，实现接口必须实现接口中的所有方法

  <?php
  // 定义接口
  interface  iTemplate
  {
      public function setVariable($name, $var);
      public function getHtml($template);
  }
  
  // 实现接口
  class Template implements iTemplate
  {
      private $var = array();
      public function setVariable($name, $var)
      {
          $this->var[$name] = $var;
      }
      public function getHtml($template)
      {
          foreach($this->var as $name => $value){
              // 把$template 中的 {$name} 替换成 $value;
              $template = str_replace('{' . $name . '}', $value, $template);
          }
          return $template;
      }
  }
  ?>

• 常量

  常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用

  <?php
  class MyClass
  {
      const constant = '常量值';
      function showConstant(){
          echo self::constant . '<br>';
      }
  }
  
  echo MyClass::constant . '<br>';
  $classname = 'MyClass';
  echo $classname::constant . '<br>';  // php5.3以后可以使用变量来动态调用类，但变量的值不能为关键字。
  
  $class = new MyClass();
  $class -> showConstant();
  
  echo $class::constant;
  ?>

• 抽象类

  <?php
  // 抽象类不可实例化
  abstract class AbstractClass
  {
      // 强制要求子类定义这些方法
      abstract protected function getValue();
      abstract protected function prefixValue($prefix);
  
      // 普通方法
      public function printOut(){
          print $this -> getValue() . '<br>';
      }
  }
  class ConcreteClass1 extends AbstractClass
  {
      // 访问控制必须和父类中一样（或者更为宽松）
      protected function getValue()
      {
          return 'ConcreteClass1';
      }
      // 子类中的参数必须包含抽象类中已定义的，可以进行拓展
      public function prefixValue($prefix)
      {
          return "{$prefix}ConcreteClass2";
      }
  }
  $class1 = new ConcreteClass1();
  $class1 -> printOut();
  echo $class1 -> prefixValue('FOO_');
  ?>

• Static 关键字

  <?php
  class FOO
  {
      // 声明静态属性或方法可以不实例化类而直接访问
      public static $mystatic = 'foo'; // 静态属性不能通过类的实例化访问
      public function staticValue(){
          return self::$mystatic; // 静态属性要用self访问，应为静态属性没有调用构造函数初始化
      }
  
      public static function Giao(){   // 静态方法可以通过类的实例化访问
          return "Giao";
      }
  }
  print Foo::$mystatic . '<br>';
  echo FOO::Giao() . '<br>';
  $foo = new FOO();
  print $foo->staticValue();
  ?>

• Final 关键字

  父类中的方法声明为 final 则子类中无法对此方法进行重写

• 调用父类的构造方法

  <?php
  class BaseClass
  {
      function __construct()
      {
          print '父类中的构造方法被调用<br>';
      }
  }
  class SubClass extends BaseClass
  {
      function __construct()
      {
          // 子类重写构造方法不会自动调用父类的构造方法，必须写这个才会调用。
          parent::__construct();
          print "子类中的构造方法被调用<br>";
      }
  }
  class OtherClass extends BaseClass{
      // 继承 BaseClass 的构造方法
  }
  $obj1 = new BaseClass();
  $obj2 = new SubClass();
  $obj3 = new OtherClass();
  ?>