PHP
Magiska metoder

__get (), __set (), __isset () och __unset ()

När du försöker hämta ett visst fält från en klass som så:

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

PHP åberopar den magiska metoden __get($name) , med $name lika med "height" i detta fall. Att skriva till ett klassfält så:

$animal->height = 10;

Anropar den magiska metoden __set($name, $value) , med $name lika med "height" och $value lika med 10 .

PHP har också två inbyggda funktioner isset() , som kontrollerar om en variabel finns, och unset() , som förstör en variabel. Kontrollera om ett fält är inställt så:

isset($animal->height);

__isset($name) funktionen __isset($name) på det objektet. Förstör en variabel så:

unset($animal->height);

__unset($name) funktionen __unset($name) på det objektet.

Normalt, när du inte definierar dessa metoder i din klass, hämtar PHP bara fältet som det är lagrat i din klass. Du kan dock åsidosätta dessa metoder för att skapa klasser som kan innehålla data som en matris, men som är användbara som ett objekt:

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));
}

tomma () -funktioner och magiska metoder

Observera att att ringa empty() på ett __isset() kommer att åberopa __isset() eftersom som PHP-manualen anger:

tom () är i huvudsak den kortfattade ekvivalent med ! isset ($ var) || $ var == falsk

__construct () och __destruct ()

__construct() är den vanligaste magiska metoden i PHP, eftersom den används för att ställa in en klass när den initieras. Det motsatta av __construct() metoden __destruct() . Den här metoden kallas när det inte finns fler referenser till ett objekt som du skapade eller när du tvingar bort det. PHP: s sopsamling kommer att rensa upp objektet genom att först ringa sin förstörare och sedan ta bort det från minnet.

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));

__att stränga()

Närhelst ett objekt behandlas som en sträng __toString() metoden __toString() . Denna metod ska returnera en strängrepresentation av klassen.

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;

__åberopa()

Denna magiska metod kallas när användaren försöker åberopa objekt som en funktion. Möjliga användningsfall kan inkludera vissa metoder som funktionell programmering eller vissa återuppringningar.

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 () och __callStatic ()

__call() och __callStatic() kallas när någon kallar obefintlig objektmetod i objekt eller statisk kontext.

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());
    }
}

Exempel:

$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 () och __wakeup ()

__sleep och __wakeup är metoder som är relaterade till serialiseringsprocessen. serialize kontrollerar om en klass har en __sleep metod. Om så är fallet kommer den att köras innan någon seriellisering. __sleep är tänkt att returnera en matris med namnen på alla variabler för ett objekt som bör vara serialiserade.

__wakeup i sin tur kommer att utföras genom att unserialize om det finns i klassen. Det är avsikten att återupprätta resurser och andra saker som behövs för att initieras vid unserialisering.

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();
    }
}

__Felsöknings information()

Den här metoden kallas av var_dump() när du dumpar ett objekt för att få de egenskaper som ska visas. Om metoden inte definieras på ett objekt visas alla offentliga, skyddade och privata egenskaper. - 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)
}

__klona()

__clone åberopas med användning av clone nyckelordet. Det används för att manipulera objekttillstånd efter kloning, efter att objektet faktiskt har klonats.

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;
    }
}

Exempel:

$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