PHP
매직 방법

__get (), __set (), __isset () 및 __unset ()

다음과 같이 클래스에서 특정 필드를 검색하려고 할 때마다 :

$animal = new Animal();
$height = $animal->height;

PHP는 magic method __get($name) 호출합니다.이 경우 $name 은 "height" 와 같습니다. 다음과 같은 클래스 필드에 쓰기 :

$animal->height = 10;

$name 이 "height" 이고 $value 가 10 마법 메서드 __set($name, $value) 호출합니다.

PHP에는 또한 변수가 존재하는지 확인하는 두 가지 기본 제공 함수 isset() 과 변수를 삭제하는 unset() 이 있습니다. 객체 필드가 ​​다음과 같이 설정되어 있는지 확인 :

isset($animal->height);

해당 개체에 대해 __isset($name) 함수를 호출합니다. 다음과 같이 변수를 삭제합니다.

unset($animal->height);

해당 객체에 대해 __unset($name) 함수를 호출합니다.

일반적으로 클래스에서이 메소드를 정의하지 않으면 PHP는 클래스에 저장된 필드를 검색 만합니다. 그러나 이러한 메소드를 재정 의하여 배열과 같은 데이터를 보유 할 수 있지만 객체처럼 사용할 수있는 클래스를 만들 수 있습니다.

class Example {
    private $data = [];

    public function __set($name, $value) {
        $this->data[$name] = $value;
    }

    public function __get($name) {
        if (!array_key_exists($name, $this->data)) {
            return null;
        }

        return $this->data[$name];
    }

    public function __isset($name) {
        return isset($this->data[$name]);
    }

    public function __unset($name) {
        unset($this->data[$name]);
    }
}

$example = new Example();

// Stores 'a' in the $data array with value 15
$example->a = 15;

// Retrieves array key 'a' from the $data array
echo $example->a; // prints 15

// Attempt to retrieve non-existent key from the array returns null
echo $example->b; // prints nothing

// If __isset('a') returns true, then call __unset('a')
if (isset($example->a)) {
    unset($example->a));
}

empty () 함수와 매직 메소드

class 속성에서 empty() 를 호출하면 __isset() 이 호출됩니다. 왜냐하면 PHP 매뉴얼에 다음과 같이 나와 있기 때문입니다.

empty ()는 기본적으로 ! isset ($ var)에 대한 간결한 표현입니다 . $ var == false

__construct () 및 __destruct ()

__construct() 는 초기화 될 때 클래스를 설정하는 데 사용되므로 PHP에서 가장 일반적인 방법입니다. __construct() 메서드의 반대는 __destruct() 메서드입니다. 이 메서드는 작성한 객체에 대한 참조가 없거나 강제로 삭제할 때 호출됩니다. PHP의 가비지 컬렉션은 먼저 소멸자를 호출 한 다음 메모리에서 제거하여 객체를 정리합니다.

class Shape {
    public function __construct() {
        echo "Shape created!\n";
    }
}

class Rectangle extends Shape {
    public $width;
    public $height;

    public function __construct($width, $height) {
        parent::__construct();

        $this->width = $width;
        $this->height = $height;
        echo "Created {$this->width}x{$this->height} Rectangle\n"; 
    }

    public function __destruct() {
        echo "Destroying {$this->width}x{$this->height} Rectangle\n";
    }
}

function createRectangle() {
    // Instantiating an object will call the constructor with the specified arguments
    $rectangle = new Rectangle(20, 50);

    // 'Shape Created' will be printed
    // 'Created 20x50 Rectangle' will be printed
}

createRectangle();
// 'Destroying 20x50 Rectangle' will be printed, because
// the `$rectangle` object was local to the createRectangle function, so
// When the function scope is exited, the object is destroyed and its
// destructor is called.

// The destructor of an object is also called when unset is used:
unset(new Rectangle(20, 50));

__toString ()

객체가 문자열로 처리 될 때마다 __toString() 메서드가 호출됩니다. 이 메소드는 클래스의 문자열 표현을 리턴해야합니다.

class User {
    public $first_name;
    public $last_name;
    public $age;

    public function __toString() {
        return "{$this->first_name} {$this->last_name} ($this->age)";
    }
}

$user = new User();
$user->first_name = "Chuck";
$user->last_name = "Norris";
$user->age = 76;

// Anytime the $user object is used in a string context, __toString() is called

echo $user; // prints 'Chuck Norris (76)'

// String value becomes: 'Selected user: Chuck Norris (76)'
$selected_user_string = sprintf("Selected user: %s", $user);

// Casting to string also calls __toString()
$user_as_string = (string) $user;

__invoke ()

이 마법 메서드는 사용자가 객체를 함수로 호출하려고 할 때 호출됩니다. 가능한 유스 케이스에는 함수형 프로그래밍이나 콜백과 같은 접근법이 포함될 수 있습니다.

class Invokable
{
    /**
     * This method will be called if object will be executed like a function:
     *
     * $invokable();
     *
     * Args will be passed as in regular method call.
     */
    public function __invoke($arg, $arg, ...)
    {
        print_r(func_get_args());
    }
}

// Example:
$invokable = new Invokable();
$invokable([1, 2, 3]);

// optputs:
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
)

__call () 및 __callStatic ()

__call() 및 __callStatic() 은 객체 또는 정적 컨텍스트에서 존재하지 않는 객체 메서드를 호출 할 때 호출됩니다.

class Foo
{
    /**
     * This method will be called when somebody will try to invoke a method in object
     * context, which does not exist, like:
     *
     * $foo->method($arg, $arg1);
     *
     * First argument will contain the method name(in example above it will be "method"),
     * and the second will contain the values of $arg and $arg1 as an array.
     */
    public function __call($method, $arguments)
    {
        // do something with that information here, like overloading
        // or something generic.
        // For sake of example let's say we're making a generic class,
        // that holds some data and allows user to get/set/has via
        // getter/setter methods. Also let's assume that there is some
        // CaseHelper which helps to convert camelCase into snake_case.
        // Also this method is simplified, so it does not check if there
        // is a valid name or
        $snakeName = CaseHelper::camelToSnake($method);
        // Get get/set/has prefix
        $subMethod = substr($snakeName, 0, 3);

        // Drop method name.
        $propertyName = substr($snakeName, 4);

        switch ($subMethod) {
            case "get":
                return $this->data[$propertyName];
            case "set":
                $this->data[$propertyName] = $arguments[0];
                break;
            case "has":
                return isset($this->data[$propertyName]);
            default:
                throw new BadMethodCallException("Undefined method $method");
        }
    }

    /**
     * __callStatic will be called from static content, that is, when calling a nonexistent
     * static method:
     *
     * Foo::buildSomethingCool($arg);
     *
     * First argument will contain the method name(in example above it will be "buildSomethingCool"),
     * and the second will contain the value $arg in an array.
     *
     * Note that signature of this method is different(requires static keyword). This method was not
     * available prior PHP 5.3
     */
    public static function __callStatic($method, $arguments)
    {
        // This method can be used when you need something like generic factory
        // or something else(to be honest use case for this is not so clear to me).
        print_r(func_get_args());
    }
}

예:

$instance = new Foo();

$instance->setSomeState("foo");
var_dump($instance->hasSomeState());      // bool(true)
var_dump($instance->getSomeState());      // string "foo"

Foo::exampleStaticCall("test");
// outputs:
Array
(
    [0] => exampleCallStatic
    [1] => test
)

__sleep () 및 __wakeup ()

__sleep 및 __wakeup 은 직렬화 프로세스와 관련된 메서드입니다. 클래스에 __sleep 메서드가 있으면 함수 확인을 serialize 합니다. 그렇다면 모든 직렬화 이전에 실행됩니다. __sleep 은 직렬화되어야하는 객체의 모든 변수 이름 배열을 반환합니다.

__wakeup 은 클래스에 있으면 unserialize 해제하여 실행됩니다. 비 직렬화시 초기화 될 필요가있는 자원 및 기타 사항을 재설정하는 것이 의도입니다.

class Sleepy {
    public $tableName;
    public $tableFields;
    public $dbConnection;

    /**
     * This magic method will be invoked by serialize function.
     * Note that $dbConnection is excluded.
     */
    public function __sleep()
    {
        // Only $this->tableName and $this->tableFields will be serialized.
        return ['tableName', 'tableFields'];
    }

    /**
     * This magic method will be called by unserialize function.
     *
     * For sake of example, lets assume that $this->c, which was not serialized,
     * is some kind of a database connection. So on wake up it will get reconnected.
     */
    public function __wakeup()
    {
        // Connect to some default database and store handler/wrapper returned into
        // $this->dbConnection
        $this->dbConnection = DB::connect();
    }
}

__디버그 정보()

이 메소드는 표시해야 할 특성을 얻기 위해 오브젝트를 덤프 할 때 var_dump() 의해 호출됩니다. 메서드가 객체에 정의되어 있지 않으면 모든 public, protected 및 private 속성이 표시됩니다. - PHP Manual

class DeepThought {
    public function __debugInfo() {
        return [42];
    }
}

var_dump(new DeepThought());

class DeepThought#1 (0) {
}

var_dump(new DeepThought());

class DeepThought#1 (1) {
  public ${0} =>
  int(42)
}

__clone ()

__clone 은 clone 키워드를 사용하여 호출됩니다. 객체가 실제로 복제 된 후 복제시 객체 상태를 조작하는 데 사용됩니다.

class CloneableUser
{
    public $name;
    public $lastName;

    /**
     * This method will be invoked by a clone operator and will prepend "Copy " to the
     * name and lastName properties.
     */
    public function __clone()
    {
        $this->name = "Copy " . $this->name;
        $this->lastName = "Copy " . $this->lastName;
    }
}

예:

$user1 = new CloneableUser();
$user1->name = "John";
$user1->lastName = "Doe";

$user2 = clone $user1; // triggers the __clone magic method

echo $user2->name;     // Copy John
echo $user2->lastName; // Copy Doe