PHP
जादू के तरीके

__get (), __set (), __isset () और __unset ()

जब भी आप एक वर्ग से एक निश्चित क्षेत्र को पुनः प्राप्त करने का प्रयास करते हैं जैसे:

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

PHP इस मामले में "height" बराबर $name साथ, जादू पद्धति __get($name) आमंत्रित करती है। एक वर्ग क्षेत्र के लिए लेखन जैसे:

$animal->height = 10;

"height" बराबर $name और 10 बराबर $value साथ जादू पद्धति __set($name, $value) आह्वान करेगा।

पीएचपी भी दो में निर्मित कार्य करता है 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() कॉल करना __isset() को आमंत्रित करेगा क्योंकि PHP मैनुअल स्टेट्स के अनुसार:

खाली () अनिवार्य रूप से संक्षिप्त (isset ($ var)) के बराबर है || $ वर == असत्य

__construct () और __dructruct ()

__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() विधि कहा जाता है। इस पद्धति को कक्षा का एक स्ट्रिंग प्रतिनिधित्व वापस करना चाहिए।

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

__callStatic() __call() और __callStatic() उस समय कहे जाते हैं जब कोई व्यक्ति ऑब्जेक्ट या स्थिर संदर्भ में कोई भी __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() द्वारा बुलाया जाता है जब किसी ऑब्जेक्ट को डंप करने के लिए गुण दिखाया जाना चाहिए। यदि विधि को किसी वस्तु पर परिभाषित नहीं किया जाता है, तो सभी सार्वजनिक, संरक्षित और निजी गुण दिखाए जाएंगे। - PHP मैनुअल

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