编辑代码

<?php 
//php运行工具：http://php.jsrun.net/
//php教程：https://www.runoob.com/php/php-types-comparisons.html

//global 关键字
    $x=5;
    $y=10;
    function myTest()
    {
    global $x,$y; //调用全局变量
    $y=$x+$y;
    }
    myTest(); //运行一次函数
    echo $y;

//当一个函数完成时，它的所有变量通常都会被删除。然而，有时候您希望某个局部变量不要被删除
    function myTest()
    {
        static $x=0;
        echo $x;
        $x++;
        echo PHP_EOL;    // 换行符
    }
    myTest();  //0
    myTest();  //1
    myTest();  //2

//echo输出可以带html代码，执行echo会先解析html代码，然后输出
    $txt2="xx.COM";
    $cars=array("Volvo","BMW","Toyota");
    echo "在 ".$txt2." 学习 PHP "; //可以输出:在 xx.COM 学习 PHP
    echo "在 $txt2 学习 PHP "; //可以输出:在 xx.COM 学习 PHP
    echo "在 {$txt2} 学习 PHP "; //花括号是引号内的变量解析。可以输出:在 xx.COM 学习 PHP
    echo "我车的品牌是 {$cars[0]}"; //花括号是引号内的变量解析。可以输出:我车的品牌是 Volvo

//print输出可以带html代码，执行print会先解析html代码，然后输出
    $txt1="学习 PHP";
    $txt2="RUNOOB.COM";
    $cars=array("Volvo","BMW","Toyota");
    print $txt1; //学习 PHP
    print "<br>";
    print "在 $txt2 学习 PHP "; //在 RUNOOB.COM 学习 PHP
    print "<br>";
    print "我车的品牌是 {$cars[0]}"; //我车的品牌是 Volvo
    //echo 输出的速度比 print 快， echo 没有返回值，print有返回值1。

print() //只能打印出简单类型变量的值(如int,string)
print_r() //可以打印出复杂类型变量的值(如数组,对象)
echo() //输出一个或者多个字符串
var_dump() //检查变量的结构信息和声明信息，比如是数组类型、string类型有几个字符等。比print_r更详细

//EOF符
    $name="runoob";
    $a= <<<EOF
            "abc"$name //"abc"runoob
            "abc".$name //"abc".runoob
            <br> //编译html输出为换行
            "abc"'$name' //"abc"'runoob'
            "123" //"123"
            <p>我的第一个段落。</p> //编译html输出为一个p段落，文本为：我的第一个段落。
            function(){}; //函数不编译，原样输出：function(){};
    EOF;
    echo $a; //EOF里面的换行也会被输出

//var_dump() 函数只用于输出变量和常量的相关信息。变量比如自己声明的，常量比如数据类型小数型等
    $a = array(1, 2);
    var_dump($a);
    //上面的var_dump输出如下：
    array(2) {
    [0]=>
    int(1)
    [1]=>
    int(2)
    }

//php类的使用案例
    class Car
    {
        var $color;
        function __construct($color="green") {
        $this->color = $color;
        }
        function what_color() {
        return $this->color;
        }
    }
    function print_vars($obj) {
    foreach (get_object_vars($obj) as $prop => $val) {
        echo "\t$prop = $val\n";
    }
    }
    // 实例一个对象
    $herbie = new Car("white");
    // 显示 herbie 属性
    echo "\therbie: Properties\n";
    print_vars($herbie);

//松散比较：使用两个等号 == 比较，只比较值，不比较类型。
//严格比较：用三个等号 === 比较，除了比较值，也比较类型。
    0 == false: bool(true)
    0 === false: bool(false)

    0 == null: bool(true)
    0 === null: bool(false)

    false == null: bool(true)
    false === null: bool(false)

    "0" == false: bool(true)
    "0" === false: bool(false)

    "0" == null: bool(false)
    "0" === null: bool(false)

    "" == false: bool(true)
    "" === false: bool(false)

    "" == null: bool(true)
    "" === null: bool(false)

//设置常量
define("GREETING", "欢迎访问 Runoob.com"); //区分大小写，常量大写，则输出大写
echo GREETING;    // 输出 "欢迎访问 Runoob.com" 。常量的输出不用大引号
define("GREETING", "欢迎访问 Runoob.com", true); //不区分大小写，大小写都可以输出
echo greeting;  // 输出 "欢迎访问 Runoob.com"

echo strlen("Hello world!"); //返回字符串的长度
echo strpos("Hello world!","world"); //在字符串内查找一个字符或一段指定的文本。返回第一个匹配的字符位置

$username = isset($test) ? $test : 'nobody'; //三元运算符的写法
$username = $test ?: 'nobody'; //php5.3之后的简写方法
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; //php老版本的写法
$username = $_GET['user'] ?? 'nobody'; //php7新功能。
//取最大值的三元运算
$a=4;
$b=2;
$c=$a>$b?$a:$b;

//echo换行的两种写法
echo "<br>";
echo "\n";

//switch的写法
$Fruit=["apple","orange","banana"];
echo count($Fruit);
$yourLikedFruit = $Fruit[2];
switch($yourFruit){
    case("apple"):echo "apple";break;
    case("orange"):echo "orange";break;
    default:echo "banana";
}

//几种数组的声明方式
$a=["a1","a2"]; //只能声明索引数组
$cars=array("Volvo","BMW","Toyota"); //也可以声明索引数组
$b=array(0=>"b1",1=>"b2"); //与下面等效
$b=array("0"=>"b1","1"=>"b2"); //可以声明键值对关联数组，关联数组可以用键调用。当键是数字的时候就是索引数组

//数组的合并运算符+。更适合关联数组，因为索引数组的后入的同键会跳过。
$c=$a+$b; //输出的数组只有a1和a2。同索引数组会被运算符前者覆盖

//PHP循环遍历的两种语法
//索引数组的for循环
$a=["a1","a2"];
$b=array("2"=>"b1","3"=>"b2");
$c=$b+$a;
$clen=count($c);
for($i=0;$i<$clen;$i++){   //for循环的i为索引，所以不能用for循环输出关联数组
    echo $c[$i]."\n";
}

//索引数组的while循环
$b=array("0"=>"b1","1"=>"b2");
$clen=count($b);
$i=0;
while($i<$clen){
    echo $b[$i]."\n";
    $i=$i+1;
}

//索引数组的do/while循环
$b=array("0"=>"b1","1"=>"b2");
$clen=count($b);
$i=0;
do{
    echo $b[$i]."\n";
    $i=$i+1;
}
while($i<$clen);

//索引数组和关联数组的foreach循环
$d=["d1","d2"];
$e=array("3"=>"e2","4"=>"e3"); //$name = $_POST['fname'];实际是关联数组
$f=$d+$e;
foreach($f as $g=>$h){
    echo $g."=>".$h."\n";
}
foreach($d as $dvalue){
    echo $dvalue;
}

//超全局变量数组
$x = 75; 
$y = 25;
(function() 
{ 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; //$GLOBALS 是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。
})();
echo $z; //输出100
echo $GLOBALS['z']; //输出100

//函数计算器返回值
function add($x,$y)
{
    $total=$x+$y;
    return $total;
}
echo add(1,16);

declare(encoding='UTF-8'); //定义源文件编码方式的 declare 语句
namespace MyProject\Sub\Level; //子命名空间使用反斜杠

//同一个文件里面命名了两个空间
namespace mm\s{
    function add(){echo "1+1"."\n";} //命名空间内的函数
    function max(){echo "1*1"."\n";} //命名空间内的函数
    class myCls{function _min(){echo "1-1"."\n";}} //命名空间内类的方法
}
//使用命名空间的函数
namespace mm\a{
    use mm\s\myCls as inC; //引入命名空间的myCls类作为inC类
    $newCls=new inC(); //实例化。实例化类可以带括号也可以不带括号。inC
    $newCls->_min(); //输出1-1。实例类调用类内的方法
}
//使用命名空间的层级
namespace sss{
    use mm\s as mmS; //引入命名空间作为mmS名称
    mmS\add(); //输出1+1。执行命名空间mmS里面的函数
    use mm\s; //引入命名空间mm\s
    s\max(); //输出1*1。使用mm\s里面的函数之前用最后一层的名字打头
}
//也可以同时引入命名空间和命名空间的类
namespace sss{
    use mm\s,mm\s as mmS; //引入命名空间作为mmS名称
    mmS\add(); //输出1+1。执行命名空间mmS里面的函数
    s\max(); //输出1*1。使用mm\s里面的函数之前用最后一层的名字打头
}

//namespace操作符执行当前命名空间的函数
namespace mm\s{
    function add(){echo "1+1";}
}
//使用命名空间的函数
namespace mm\a{
    function add(){echo "2+2";}
    use mm\s as mmS;
    namespace\add(); //输出2+2
}

//php的类
class Site {
  /* 成员变量 */
  var $url; //url是成员属性
  /* 成员函数 */
  function setUrl($par){
     $this->url = $par; //将此对象的属性设置为传入的值
  }
  function getUrl(){
     echo $this->url; //将此对象的属性设置为传入的值
  }
}
$taobao = new Site; //实例化对象
$taobao->setUrl("taobaocom"); //对象调用自身内部的方法
$taobao->getUrl();

//构造函数=实例化的时候自动执行此函数来初始化对象属性
class Site {
  var $url; //url是成员属性,$url是成员变量
  function __construct($par){ //构造函数主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值
      $this->url=$par;
  }
  function getUrl(){
     echo $this->url; //将此对象的属性设置为传入的值
  }
}
$taobao = new Site("taobaocom"); //有构造函数的实例化对象传值
$taobao->getUrl();

//创建加法计算器的类
class addmethod{
    var $a;
    var $b;
    function add($pa1,$pa2){
        $this->a=$pa1;
        $this->b=$pa2;
        echo $this->a+$this->b;
    }
}
$a=new addmethod;
$a->add(1,2);
//用构造函数改写的加法计算器的类
class addmethod{
    var $a;
    var $b;
    function __construct($par1,$par2){
        $this->a=$par1;
        $this->b=$par2;
    }
    function add(){
        echo $this->a+$this->b;
    }
}
$a=new addmethod(1,2);
$a->add();

//对类里面的属性变量函数的理解和实例化调用的测试
class addmethod{
    var $a;
    var $b;
    var $c;
    var $d=4;
    function add($pa1,$pa2){
        $a=$pa1;
        $b=$pa2;
        $this->c=$pa2;
        echo $a+$b."\n";
    }
}
$a=new addmethod;
$a->add(1,2); //输出3
var_dump($a->a); //输出null
var_dump($a->c); //输出int(2)
var_dump($a->d); //输出int(4)

//析构函数
class addmethod{
    var $a;
    var $b;
    function __construct($par1,$par2){
        $this->a=$par1;
        $this->b=$par2;
    }
    function add(){
        echo $this->a+$this->b;
    }
    function __destruct(){
        $this->a;
    }
}
$c=new addmethod(1,2);
$c->add();  //输出3
echo $c->a;  //输出1

//类的继承
class addmethod{
    var $a;
    var $b;
    const c=88; //定义一个常量
    function __construct($par1,$par2){
        $this->a=$par1;
        $this->b=$par2;
    }
    function add(){ 
        echo $this->a+$this->b; //在子类里面重写可以覆盖：function add(){echo $this->a+$this->b+"10"."\n";}
        echo self::c; //输出自身的常量
    }
}
class childsmalls extends addmethod{

} //在这里smalls继承了上面addmethod类的方法
$c=new childsmalls(1,2);  //子类继承了父类的方法和属性
$c->add();  //输出3 、子类重写后输出13
echo $c->a;  //输出1

//PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。如果用 var 定义，则被视为公有。
public（公有）：公有的类成员可以在任何地方被访问。
protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
private（私有）：私有的类成员则只能被其定义所在的类访问。

//接口 interface

//静态类的调用$this->和self::
class addmethod{
    var $a;
    var $b;
    const c=88;
    var $d=55;
    function __construct($par1,$par2){
        $this->a=$par1;
        $this->b=$par2;
    }
    function time(){
        echo "*\n";
    }
    function add(){
        echo $this->a+$this->b."\n";
        echo self::c."\n"; //输出88
        //echo self::d."\n"; //无法输出，不能对变量引用
        $this->time(); //输出*
        self::time(); //输出*
    }
}
$c=new addmethod(1,2);
$c->add();  //输出3

//抽象类的使用案例
abstract class AbstractClass
{
    function __construct(){
        echo "5";
    }
    // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);
    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}
//新建一个类继承自抽象类
class ConcreteClass1 extends AbstractClass
{
    function __construct(){
        parent::__construct(); //在子类里面调用父类的构造函数
        echo "4";
    }
    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(); //输出ConcreteClass1
echo $class1->prefixValue('FOO_'); //FOO_ConcreteClass1

//静态方法可以不用实例化就直接调用
class pig{
    var $whos;
    function __construct($par1){
        $this->whos=$par1;
    }
    static function run(){
        echo "runing 2 mins";
    }
    function sleep(){
        echo "sleeped 5 mins\n";
    }
}
$mypig=new pig("my");
$mypig->sleep();  //sleeped 5 mins
pig::run();  //runing 2 mins

//PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

//多选框提交数据给php
<form action="b.php" method="post"> 
    <input type="checkbox" name="q[]" value="RUNOOB"> Runoob<br> 
    <input type="checkbox" name="q[]" value="GOOGLE"> Google<br> 
    <input type="checkbox" name="q[]" value="TAOBAO"> Taobao<br>
    <input type="submit" value="提交">
</form>
//php代码如下
$q = isset($_POST['q'])? $_POST['q'] : '';
if(is_array($q)) {
    foreach($q as $sentval){
        echo $sentval; //循环输出多选的值
    }
}