PHP의 __construct() 및 __destory()에 대해 참고할 사항

기본적으로 모든 프로그래밍 언어에는 클래스에 생성자와 소멸자의 개념이 있습니다. 생성자는 함수 인스턴스가 생성될 때 일부 초기화 작업을 수행하는 데 사용될 수 있는 반면 소멸자는 인스턴스가 삭제되기 전에 일부 정리 작업을 수행할 수 있습니다. 상대적으로 말하면 생성자를 많이 사용하는 반면 소멸자는 일반적으로 데이터베이스 링크, 파일 읽기 및 쓰기 핸들 등과 같은 리소스를 해제하는 데 사용됩니다.

생성자와 소멸자의 사용법

먼저 일반 생성자와 소멸자의 사용법을 살펴보겠습니다.

class A
{
    public $name;
    public function __construct($name)
    {
        $this->name = $name;
        echo "A：构造函数被调用，{$this->name}", PHP_EOL;
    }
    public function __destruct()
    {
        echo "A：析构函数被调用，{$this->name}", PHP_EOL;
    }
}
$a = new A('$a');
echo '-----', PHP_EOL;
class B extends A
{
    public function __construct($name)
    {
        $this->name = $name;
        parent::__construct($name);
        echo "B：构造函数被调用，{$this->name}", PHP_EOL;
    }
    public function __destruct()
    {
        parent::__destruct();
        echo "B：析构函数被调用，{$this->name}", PHP_EOL;
    }
}
class C extends A
{
    public function __construct($name)
    {
        $this->name = $name;
        echo "C：构造函数被调用，{$this->name}", PHP_EOL;
    }
    public function __destruct()
    {
        echo "C：析构函数被调用，{$this->name}", PHP_EOL;
    }
}
class D extends A
{
}
// unset($a); // $a的析构提前
// $a = null; // $a的析构提前
$b = new B('$b');
$c = new C('$c');
$d = new D('$d');
echo '-----', PHP_EOL;exit;
// A：构造函数被调用，$a
// -----
// A：构造函数被调用，$b
// B：构造函数被调用，$b
// C：构造函数被调用，$c
// A：构造函数被调用，$d
// -----
// A：析构函数被调用，$d
// C：析构函数被调用，$c
// A：析构函数被调用，$b
// B：析构函数被调用，$b
// A：析构函数被调用，$a

위 코드에 우리가 예상한 것과 다른 부분이 있나요? 괜찮습니다. 하나씩 살펴보겠습니다.

하위 클래스가 상위 클래스의 생성자 또는 소멸자를 재정의하고 상위 클래스의 생성자가 parent::__constuct()를 사용하여 명시적으로 호출되지 않으면 다음의 생성자는 예를 들어, C 클래스의 하위 클래스가 생성자 또는 소멸자를 재정의하지 않으면 변수가 명시적으로 NULL로 설정되지 않거나 설정되지 않은 경우 기본적으로 부모 클래스의 소멸자가 호출됩니다. ()를 사용하면 스크립트 실행이 완료됩니다. 테스트 코드의 호출 순서는 선입후출(C->B->A, C는)과 유사합니다. 먼저 파괴됨), 그러나 서버 환경에서는 반드시 그런 것은 아닙니다. 즉, 순서가 반드시 고정되지는 않습니다

소멸자의 참조 문제

객체가 자신에 대한 상호 참조를 포함하는 경우 다음과 같은 경우 문제가 발생할 수 있습니다. 소멸자를 NULL 또는 unset()으로 설정하여 호출하려고 합니다.

class E
{
    public $name;
    public $obj;
    public function __destruct()
    {
        echo "E：析构函数被调用，" . $this->name, PHP_EOL;
        echo '-----', PHP_EOL;
    }
}
$e1 = new E();
$e1->name = 'e1';
$e2 = new E();
$e2->name = 'e2';
$e1->obj = $e2;
$e2->obj = $e1;

이 코드와 유사하게 $e1과 $e2는 모두 클래스 E의 개체이며 각각 서로에 대한 참조를 보유합니다. 사실, 간단히 말해서 자신의 레퍼런스를 보유하고 있으면 비슷한 문제가 발생합니다.

$e1 = new E();
$e1->name = 'e1';
$e2 = new E();
$e2->name = 'e2';
$e1->obj = $e2;
$e2->obj = $e1;
$e1 = null;
$e2 = null;
// gc_collect_cycles();
$e3 = new E();
$e3->name = 'e3';
$e4 = new E();
$e4->name = 'e4';
$e3->obj = $e4;
$e4->obj = $e3;
$e3 = null;
$e4 = null;
echo 'E destory', PHP_EOL;

gc_collect_cycles() 행의 주석을 열지 않으면 소멸자의 실행 순서는 다음과 같습니다.

// 不使用gc回收的结果
// E destory
// E：析构函数被调用，e1
// -----
// E：析构函数被调用，e2
// -----
// E：析构函数被调用，e3
// -----
// E：析构函数被调用，e4
// -----

gc_collect_cycles()에서 주석을 열면 소멸자의 실행 순서는 다음과 같습니다.

// 使用gc回收后结果
// E：析构函数被调用，e1
// -----
// E：析构函数被调用，e2
// -----
// E destory
// E：析构函数被调用，e3
// -----
// E：析构函数被调用，e4
// -----

알겠습니다. PHP는 gc를 사용하여 한 번 재활용해야 하며 클래스의 소멸자는 객체에 대한 모든 참조가 해제될 때까지 실행되지 않습니다. 참조가 해제되지 않으면 소멸자는 실행되지 않습니다.

낮은 버전 생성자의 호환성 문제

PHP5 이전에는 PHP의 생성자가 클래스 이름과 동일한 이름을 가진 메서드였습니다. 즉, F 클래스가 있으면 함수 F(){} 메서드가 해당 클래스의 생성자입니다. 하위 버전과의 호환성을 위해 PHP는 이 기능을 계속 유지합니다. PHP7 이후에는 클래스 이름과 동일한 이름을 가진 메소드가 있는 경우 시간 초과 경고가 보고되지만 프로그램 실행에는 영향을 미치지 않습니다.

class F
{
    public function f() 
    {
        // Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; F has a deprecated constructor 
        echo "F：这也是构造函数，与类同名，不区分大小写", PHP_EOL;
    }
    // function F(){
    //     // Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; F has a deprecated constructor 
    //     echo "F：这也是构造函数，与类同名", PHP_EOL;
    // }
    // function __construct(){
    //     echo "F：这是构造函数，__construct()", PHP_EOL;
    // }
}
$f = new F();

__construc()와 동일한 이름의 클래스 메서드가 동시에 존재하는 경우 __construct()가 먼저 사용됩니다. 주목해야 할 또 다른 점은 함수 이름은 대소문자를 구분하지 않으므로 F() 및 f() 메서드는 동일하며 생성자가 된다는 것입니다. 마찬가지로, 대소문자를 구분하지 않기 때문에 f()와 F()는 동시에 존재할 수 없습니다. 물론 생성자와 동일한 이름을 가진 함수를 사용하는 것은 권장하지 않습니다. 결국 오래된 기능이므로 언젠가는 취소될 수도 있습니다.

생성자 오버로드

PHP는 메서드 오버로드를 실행하지 않습니다. 즉, 하위 클래스가 상위 클래스 메서드를 재정의하지만 이름은 같지만 매개 변수가 다른 여러 메서드를 정의할 수는 없습니다. Java와 같은 언어에서는 메소드 오버로딩이 매우 편리하며, 특히 클래스를 인스턴스화할 때 다형성 기능을 쉽게 구현할 수 있습니다.

$r1 = new R(); // 默认构造函数
$r2 = new R('arg1'); // 默认构造函数 一个参数的构造函数重载，arg1
$r3 = new R('arg1', 'arg2'); // 默认构造函数 两个参数的构造函数重载，arg1，arg2

위 코드와 마찬가지로 여러 개의 __construct()를 정의하려고 하면 PHP는 실행할 수 없다고 직접 알려줍니다. 위 코드의 기능을 달성하는 다른 방법이 있습니까? 물론 있습니다. 그렇지 않으면 우리는 그것을 쓰지 않을 것입니다.

class R
{
    private $a;
    private $b;
    public function __construct()
    {
        echo '默认构造函数', PHP_EOL;
        $argNums = func_num_args();
        $args = func_get_args();
        if ($argNums == 1) {
            $this->constructA(...$args);
        } elseif ($argNums == 2) {
            $this->constructB(...$args);
        }
    }
    public function constructA($a)
    {
        echo '一个参数的构造函数重载，' . $a, PHP_EOL;
        $this->a = $a;
    }
    public function constructB($a, $b)
    {
        echo '两个参数的构造函数重载，' . $a . '，' . $b, PHP_EOL;
        $this->a = $a;
        $this->b = $b;
    }
}
$r1 = new R(); // 默认构造函数
$r2 = new R('arg1'); // 默认构造函数 一个参数的构造函数重载，arg1
$r3 = new R('arg1', 'arg2'); // 默认构造函数 两个参数的构造函数重载，arg1，arg2

Java와 같은 언어에 비해 상대적으로 더 까다롭지만 동일한 기능을 구현합니다.

생성자 및 소멸자에 대한 액세스 제한

생성자와 소멸자는 기본적으로 공개되며 클래스의 다른 메서드와 동일한 기본값을 갖습니다. 물론 비공개로 설정하여 보호할 수도 있습니다. 생성자를 비공개로 설정하면 클래스를 인스턴스화할 수 없습니다. 이는 싱글턴 모드에서 널리 사용됩니다. 싱글턴 모드의 코드를 직접 살펴보겠습니다.

class Singleton
{
    private static $instance;
    public static function getInstance()
    {
        return self::$instance == null ? self::$instance = new Singleton() : self::$instance;
    }
    private function __construct()
    {
    }
}
$s1 = Singleton::getInstance();
$s2 = Singleton::getInstance();
echo $s1 === $s2 ? 's1 === s2' : 's1 !== s2', PHP_EOL;
// $s3 = new Singleton(); // Fatal error: Uncaught Error: Call to private Singleton::__construct() from invalid context

$s3을 인스턴스화하려고 하면 오류가 직접 보고됩니다. 싱글턴 패턴이 외부 인스턴스화를 불가능하게 만드는 이유에 대해서는 이전 디자인 패턴 시스템 기사에서 싱글턴 패턴을 살펴볼 수 있습니다.

요약

우리가 매일 사용하는 생성자가 이렇게 많은 트릭을 사용할 수 있을 거라고는 예상하지 못했습니다. 일상적인 개발에서 우리가 더 주의해야 할 것은 하위 클래스가 상속될 때 생성자를 다시 작성할 때 상위 클래스 생성자입니다. 참조할 때 문제와 파괴 문제를 호출합니다.

추천 튜토리얼: "PHP 튜토리얼"

위 내용은 PHP의 __construct() 및 __destory()에 대해 참고할 사항의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!