PHP学习随笔

20180624
变量名称不能以数字开头
没有单独创建变量的命令,会在首次赋值的时候被创建
作用域: local(局部) global(全局) static(静态)

函数内部,global 修饰函数内变量,可以访问函数内全局变量 global $x;

超级全局变量:

$x = 75;
$y = 25;
function addition()
{
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y'];
}
addition();
echo $z;//函数外调用z变量,输出结果为100

static:

function myTest(){
    $x=0;
    echo $x;
    $x++;
}

myTest();
myTest();
myTest(); //第二行,不加static,每次函数执行后会删除所有变量,加了static后这个局部变量不会被删除,保存的都是最后一次执行的值
//默认输出结果为1,static修饰$x后输出为3

单双引号都可以修饰字符串 var_dump() 返回数据类型和值, 显示为 int(-123) 数组:

$cars=array(BMW,123,2131);
var_dump()的结果:
array(3) { [0]=> string(3) BMW [1]=> string(5) Volvo [2]=> string(4) saab }
$arrlength=count($cars); //求数组长度

关联数组:

$age=array(Peter=>35,Ben=>37,Joe=>43);等价于:
$age['Peter']=35;
$age['Ben']=37;
$age['Joe']=43;

遍历关联数组:

foreach($age as $x=>$x_value){ //$x是变量,$_x_value是变量值
    echo Key=.$x.,Value=.$x_value;
}

数组排序:

$cars=array(BMW,123,2131);
sort($cars); 按照字母/数字升序排列
rsort($cars); ------------降序排列

$age=array(Peter=>35,Ben=>37,Joe=>43);
asort($age); //按照数组的值升序
ksort($age); //按照数组的键升序
//对应的降序则是arsort和krsort

0625 字符串操作:

strlen(Hello world!);//求长度

并置运算符:

echo $text1. .$text2; //连接字符串

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

echo strpos(Hello world!,world); //结果为6

x===y 绝对等于,等于且类型相同 xy 不等于

两种表单信息获取:

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>
 
<?php 
$name = $_REQUEST['fname']; //$name = $_POST['fname']; 
echo $name; 
?>

魔术常量:

echo '函数名为:' . __FUNCTION__ ; //返回类名
echo '这是第  ' . __LINE__ . '  行';//某个php文件里面的
echo '该文件位于  ' . __FILE__ . '  '; //完整路径,直到文件E:\PHP\TEST\index.php
echo '该文件位于  ' . __DIR__ . '  ';//该文件在E:\PHP\TEST

function test() {
        echo '函数名为:' . __FUNCTION__ ;  //返回函数名
}


class a{
    function test(){
        echo '函数名为:' . __METHOD__ ; //返回的是a::test
  }
}

namespace MyProject;
echo '命名空间为:', __NAMESPACE__, ''; // 输出 MyProject

0626 晚上时间用于整理博客和家人视频聊天了,睡觉前闲预习面向对象,明天搞定,后天命名空间。 0627

PHP 面向对象:

类:

定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。比如动物 Animal 就是一个抽象类。

对象:

在现实世界里我们所面对的事情都是对象,如计算机、狗、自行车等。狗和羊就是类的实例,它们有行为、形态。

类的定义、创建对象、实例化:

class Animal{
    /*成员变量*/
    var $animal;
    public $animal2 = 'i am an animal !'; //类中变量用var或者public定义,var默认为公有属性

    /*成员函数*/
    public function display(){
        echo $this->animal2;    //$this在php中称作为伪变量,用于访问成员变量
    }

    public function get_display($arr)
    {
        $this->animal = $arr;
        echo i am a .$this->animal. !;
    }

}

/*对象实例化*/
$sheep = new Animal;
$Dog = new Animal;

/*调用成员方法*/
$sheep->display();
$Dog->get_display('Dog');

构造函数:

>具有构造函数的类会在每次创建新对象时先调用此方法,所以非常适合在使用对象之前做一些初始化工作。
class Animal{
    /*成员变量*/
    var $animal = 'Pig';

    /*构造函数*/
    function __construct($ani1){
        $this->animal = $ani1;
    }

    function Shout(){
        echo i am .$this->animal;
        echo <br></br>;
    }
}

//$pig = new Animal();
//$pig->Shout();

/*自动调用了__construct()进行了初始化*/
$dog = new Animal('Dog');
$sheep = new Animal('Sheep');

$dog->Shout();
$sheep->Shout();

析构函数:

对象结束其生命周期时(例如对象所在的函数已调用完毕),系统自动执行析构函数。

class Animal{
    /*成员变量*/
    var $animal = 'Pig';

    /*构造函数*/
    function __construct($ani1){
        $this->animal = $ani1;
        echo 在构造函数中初始化成功,动物为.$this->animal.<br></br>;
    }

    function Shout(){
        echo i am a .$this->animal.<br></br>;
    }
    /*析构函数*/
    function __destruct(){
        echo 析构函数被调用;
    }


}

$dog = new Animal('Dog');
$dog->Shout();

继承:

extends 来继承一个类,PHP 不支持多继承

方法重写:

父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

class Animal{
    var $animal;

    function __construct($ani1){
        $this->animal = $ani1;
        echo I am .$this->animal.<br></br>;
    }

    function Shout(){
            echo I can shout !<br></br>;
    }

    function Action(){
        echo I can move !<br></br>;
    }
}

/*继承父类*/
Class Dog extends Animal {
    /*重写父类方法*/
    function Action(){
        echo I can run !<br></br>;
    }
}

$animal = new Animal('Animal'); //输出: I am Animal
$animal->Shout();//输出: I am Animal
$animal->Action();//输出: I can action.
echo <br></br>;

$dog = new Dog('Dog');//输出:I am Dog !,证明父类构造函数自动被继承(PHP5及以后版本,PHP4不会自动继承父类构造方法)
$dog->Shout();//输出:I can shout !,父类方法被继承
$dog->Action('run'); //输出: I can run !,父类方法被重写

访问控制:

通过在前面添加关键字 public(公有),protected(受保护)或 private(私有)来实现访问控制。

  1. public(公有): 公有的类成员可以在任何地方被访问。
  2. protected(保护): 受保护的类成员则可以被其自身以及其子类和父类访问。
  3. private(私有): 私有的类成员则只能被其定义所在的类访问。
class MyClass{
        public $public = '公有、';
        protected $protected = '受保护、';
        private $private = '私有<br></br>';
        
        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 函数。

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();//public、protect、private都可以执行

对于子类继承:

class MyClass2 extends MyClass{
    //公有方法
    function Foo2(){
        $this->MyPublic();
        $this->MyProtected();
        //$this->Myprivate();致命错误,子类不能继承父类的私有方法
    }
}

继承然后重写:

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

    public function testPublic(){
        echo Bar::testPublic<br></br>;
    }

    private function testPrivate(){
        echo Bar::testPrivate<br></br>;
    }
}

class Foo extends Bar
{
    public function testPublic() {
        echo Foo::testPublic<br></br>;
    }

    private function testPrivate() {
        echo Foo::testPrivate<br></br>;
    }
}

$myFoo = new foo();
$myFoo->test(); // 输出: 父类::testPrivate换行 子类::testPublic 换行 子类::testPublic
// 可见,重写父类函数,对private无效,对protected、public有效。

接口:

使用接口(interface),可以指定某个类必须实现哪些方法,但不需要定义这些方法的具体内容。

接口是通过 interface 定义,就像定义一个标准的类,但其中定义所有的方法都是空的。 接口中定义的所有方法 都必须是公有,这是接口的特性。 要实现一个接口,使用 implements操作符。类中必须 实现接口中定义的所有方法 ,否则会报一个致命错误。类 可以实现多个接口 ,用逗号来分隔多个接口的名称。

抽象类

任何一个类,如果它里面至少有一个方法是被声明为抽象的,那么这个类就必须被声明为抽象的。
定义为抽象的类不能被实例化。 被定义为抽象的方法只是声明了其调用方式(参数),不能定义其具体的功能实现。 继承一个抽象类的时候,子类必须定义父类中的所有抽象方法;另外,这些方法的访问控制必须和父类中一样(或者更为宽松)。例如某个抽象方法被声明为受保护的,那么子类中实现的方法就应该声明为受保护的或者公有的,而不能定义为私有的。 首先定义两个接口,动物运动 (走和跑) 和活动 (运动和活动)。

先放图:牧羊犬 Bitzer 和小羊 Shaun—《Shaun the Sheep》很喜欢这部漫画

定义了一个抽象类 Animal,包含 Run 和 color 两个方法 (Dog 和 Sheep 本身都具有的属性)。 定义了两个接口,分别是 Write(Dog 具有的功能) 和 Run_faster(Sheep 具有的功能)。

abstract class Animal{
    //强制要求Dog类和Sheep类定义这些方法
    abstract protected function run();
    abstract protected function color($colors);
}

interface Write{//狗可以写字
    public function write();
}

interface Run_faster{//羊可以跑得更快
    public function run_faster();
}

定义 Dog 类继承动物类,实现 Write 接口。

class Dog extends Animal implements Write {
    private $Dog ;
    private $Colors;
    public function __construct(){
        $this->Dog = 'Dog';
    }

    protected function run(){
        echo $this->Dog. can run.<br></br>;
    }
    protected function color($color){
        $this->Colors=$color;
        echo $this->Dog. is .$this->Colors.. <br></br>;
    }
    public function write(){
        echo $this->Dog. can write. <br></br>;
    }
    public function Show(){
        $this->run();
        $this->color('yellow');
        $this->write();
    }
}

定义 Sheep 类继承动物类和实现 Run_faster 接口。

class Sheep extends Animal implements Run_faster {
    private $Sheep;
    private $Colors;
    public function __construct(){
        $this->Sheep = 'Sheep';
    }
    protected function run(){
        echo $this->Sheep. can run.<br></br>;
    }
    protected function color($color){
        $this->Colors=$color;
        echo $this->Sheep. is .$this->Colors.. <br></br>;
    }
    public function run_faster(){
        echo $this->Sheep. can run faster. <br></br>;
    }
    public function Show(){
        $this->run();
        $this->color('white');
        $this->run_faster();
    }
}

实例化 Dog 和 Sheep

$dog = new Dog();
$sheep = new Sheep();

$dog->Show();
echo <br></br>;
$sheep->Show();

/**
 * 输出结果:
 *Dog can run.
 *Dog is yellow.
 *Dog can write.

 *sheep can run.
 *sheep is white.
 *sheep can run faster.
 */

一直以来对接口和抽象类两者概念没完全搞清楚。今天把两者放到一起对比和思考,有了更为深刻的理解。 这篇帖子:深入理解 Java 的接口和抽象类 给了启迪。

接口:

大白话式解释 -

接口和抽象类理解

一句话总结,抽象类是对一种事物的抽象,而接口是对行为的抽象。

抽象的继承体现的“是不是” Dog 和 Sheep 继承 Animal 这个抽象类,它们就属于这个动物这个种类了,可以 run 和具有 color。

接口的实现体现的“有没有” Dog 实现了 Write 这个接口,它就有了 write 这个功能。没有实现 Run_faster 接口,就没有 run_faster 的功能。 Sheep 实现了 Run_faster 接口,它就可以 run_faster。没有实现 Write 接口,也就没有 write 的功能。

常量:

常量: 类中始终保持不变的值。定义和使用常量的时候不需要使用 $ 符号。 常量的值必须是一个定值,不能是变量,类属性,数学运算的结果或函数调用。 自 PHP 5.3.0 起,可以用一个变量来动态调用类。但该变量的值不能为关键字(如 self,parent 或 static)。

class MyClass{
    const str = '常量值';
    function showConstant(){
        echo self::str.<br></br>;
    }
}

echo MyClass::str.<br></br>;

$classname = MyClass;
echo $classname::str . <br></br>; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::str . <br></br>; // 自 PHP 5.3.0 起
//输出四次常量值

卫冕冠军德国队输了,剩下一点面向对象明天了结然后开始选择性地学习相应知识了。Cookie、Session 等。

Static 关键字:

声明类属性或方法为 static(静态),就可以 不实例化类而直接访问 。 静态属性不能通过一个类已实例化的对象来访问(但静态方法可以)。 由于静态方法不需要通过对象即可调用,所以伪变量 $this 在静态方法中 不可用 。 静态属性 不可以 由对象通过 ->操作符来访问。 自 PHP 5.3.0 起,可以用一个变量来动态调用类。但该变量的值不能为关键字 self,parent 或 static。

class Foo{
    public static $my_static = 'foo';

    public function staticValue(){
        return self::$my_static;
    }
}
echo Foo::$my_static.<br></br>;//输出foo,无需实例化直接访问
$foo = new Foo();
echo $foo->staticValue().<br></br>;//输出foo

Final 关键字

PHP5 新增。如果父类中的方法被声明为 final,则子类无法覆盖该方法。如果一个类被声明为 final,则不能被继承。
写的时候直接摆错,提示 final 方法不可被覆盖(重写)-

(子类) 调用父类构造方法

PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法,需要在子类的构造方法中调用 parent::__construct()

class BaseClass{
    function __construct(){
        echo 主类构造方法<br></br>;
    }
}

class ChildClass extends BaseClass{
    function __construct(){
        parent::__construct();
        echo 子类构造方法<br></br>;
    }
}
class OtherSubClass extends BaseClass {
    // 继承 主类 的构造方法
}

$obj = new BaseClass();//echo主类
$obj = new ChildClass();//echo主类换行echo子类
$obj = new OtherSubClass();//echo主类

$_GET 和 $_POST

$_GET 变量用于收集来自 method=get 的表单中的值。 $_POST 变量用于收集来自 method=post 的表单中的值。

前端表单:

<form action="chuli.php" method="post"><!--method="get"-->
姓名:<input type="text" name="name">
年龄:<input type="text" name="age">
    <input type="submit" value="提交">
</form>

chuli.php

$name = $_POST["name"];// 获取到之后直接放入变量
$age = $_POST["age"];
echo "欢迎:".$name."
";
echo "年龄为:".$age."
";



点击提交按钮后: post方式的URL: 

http://127.0.0.1/phpstudy/file.php


get方式的URL: 

http://127.0.0.1/phpstudy/file.php?name=Aris&age=20


两者本质都是TCP链接: 从带有 POST 方法的表单发送的信息,对任何人都是不可见的,并且对发送信息的量也没有限制。 然而,由于变量不显示在 URL 中,所以无法把页面加入书签。

在 HTML 表单中使用 method=get 时,所有的变量名和值都会显示在 URL 中。 注释:所以在发送密码或其他敏感信息时,不应该使用这个方法! 然而,正因为变量显示在 URL 中,因此可以在收藏夹中收藏该页面。在某些情况下,这是很有用的。 

本文链接:https://ariser.cn/index.php/archives/6/
本站文章采用 知识共享署名4.0 国际许可协议进行许可,请在转载时注明出处及本声明!