Ի՞նչ կախարդական մեթոդներ կան PHP-ում և ինչպես են…

Մոգական մեթոդները PHP-ում՝ դա հատուկ մեթոդներ են, որոնք սկսվում են կրկնակի ստորակետից (օրինակ՝ __construct), և որոնք ավտոմատ կերպով կանչվում են որոշակի իրավիճակներում:

Հիմնական մոգական մեթոդները և դրանց օգտագործումը:

__construct(): Կոչվում է երբ ստեղծվում է դասի օբյեկտը: Օգտագործվում է օբյեկտի հատկությունները inicialիզելու և սկզբնական գործողություններ կատարելու համար:
```
<?php
class MyClass {
    public function __construct() {
        echo "Օբյեկտը ստեղծվեց!";
    }
}
$obj = new MyClass(); // Դրան կհայտնվի "Օբյեկտը ստեղծվեց!"
```
__destruct(): Կոչվում է երբ օբյեկտը ոչնչացվում է (օրինակ՝ երբ սցենարը ավարտվում է կամ օբյեկտը հեռացվում է հիշողությունից): Օգտագործվում է ռեսուրսների ազատման համար (ֆայլերի փակումը, տվյալների բազայի կապերը):
```
<?php
class MyClass {
    public function __destruct() {
        echo "Օբյեկտը ոչնչացվեց!";
    }
}
$obj = new MyClass();
unset($obj); // Դրան կհայտնվի "Օբյեկտը ոչնչացվեց!"
```

__call(string $name, array $arguments): Կոչվում է երբ փորձում եք կանչել մատչելի չլինող կամ չպատկանող մեթոդ՝ օբյեկտի կոնտեքստում: $name պարունակում է մեթոդի անունը, իսկ $arguments - արգումենտների զանգվածը:

<?php
class MyClass {
    public function __call($name, $arguments) {
        echo "Կոչվեց մատչելի չլինող մեթոդ '{$name}' արգումենտներով: " . implode(', ', $arguments);
    }
}
$obj = new MyClass();
$obj->nonExistentMethod('arg1', 'arg2'); // Դրան կհայտնվի "Կոչվեց մատչելի չլինող մեթոդ 'nonExistentMethod' արգումենտներով:"

__callStatic(string $name, array $arguments): Կոչվում է երբ փորձում եք կանչել մատչելի չլինող կամ չպատկանող ստատիկ մեթոդ՝ դասի կոնտեքստում: Դրանով նման է __call, բայց՝ ստատիկ կանչերի համար:

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "Կոչվեց մատչելի չլինող ստատիկ մեթոդ '{$name}' արգումենտներով: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // Դրան կհայտնվի "Կոչվեց մատչելի չլինող ստատիկ մեթոդ 'nonExistentStaticMethod' արգումենտներով:"

__get(string $name): Կոչվում է երբ փորձում եք ստանալ մատչելի չլինող կամ չպատկանող հատկության արժեքը: $name պարունակում է հատկության անունը:

<?php
class MyClass {
    private $data = ['key' => 'value'];
    public function __get($name) {
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }
        return null;
    }
}
$obj = new MyClass();
echo $obj->key; // Դրան կհայտնվի "value"
echo $obj->nonExistentKey; // Դրան կհայտնվի դատարկ տող (կախված վերադարձվող null-ից)

__set(string $name, mixed $value): Կոչվում է երբ փորձում եք սահմանել մատչելի չլինող կամ չպատկանող հատկության արժեքը: $name պարունակում է հատկության անունը, իսկ $value - սահմանված արժեքը:

<?php
class MyClass {
    private $data = [];
    public function __set($name, $value) {
        $this->data[$name] = $value;
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
$obj->newKey = 'newValue';
print_r($obj->getData()); // Դրան կհայտնվի Array ( [newKey] => newValue )

__isset(string $name): Կոչվում է երբ օգտագործում եք isset() կամ empty() մատչելի չլինող կամ չպատկանող հատկության համար: Վերադարձնում է բուլյան արժեք:

<?php
class MyClass {
    private $data = ['present' => 'value'];
    public function __isset($name) {
        return array_key_exists($name, $this->data);
    }
}
$obj = new MyClass();
var_dump(isset($obj->present));     // Դրան կհայտնվի bool(true)
var_dump(isset($obj->absent));      // Դրան կհայտնվի bool(false)

__unset(string $name): Կոչվում է երբ օգտագործում եք unset() մատչելի չլինող կամ չպատկանող հատկության համար:

<?php
class MyClass {
    private $data = ['remove_me' => 'value_to_remove'];
    public function __unset($name) {
        if (array_key_exists($name, $this->data)) {
            unset($this->data[$name]);
            echo "Հատկությունը '{$name}' հեռացվեց.\n";
        }
    }
    public function getData() {
        return $this->data;
    }
}
$obj = new MyClass();
print_r($obj->getData());
unset($obj->remove_me); // Դրան կհայտնվի "Հատկությունը 'remove_me' հեռացվեց." և տվյալը կհեռացվի $data-ից
print_r($obj->getData());

__sleep(): Կոչվում է նախքան օբյեկտի սերիալիզացիան serialize()-ի միջոցով: Պետք է վերադարձնի հատկությունների անունների զանգված, որոնք պետք է սերիալիզացվեն:

<?php
class MyClass {
    public $prop1 = 'value1';
    public $prop2 = 'value2';
    public function __sleep() {
        return ['prop1']; // Սերիալիզացվում է միայն prop1
    }
}
$obj = new MyClass();
$serialized = serialize($obj); // Սերիալիզացնում է միայն prop1
echo $serialized; // Դրան կհայտնվի մոտավորապես O:7:"MyClass":1:{s:5:"prop1";s:6:"value1";}

__wakeup(): Կոչվում է հետո unserialize()-ի միջոցով օբյեկտի դեսերիալիզացիայի: Օգտագործվում է կապերի վերականգնման համար կամ այլ գործողությունների, որոնք անհրաժեշտ են վերականգնումից հետո:

<?php
class MyClass {
    public $prop1;
    public $resource; // Օրինակ՝ կապի ռեսուրս
    public function __wakeup() {
        // Վերականգնել ռեսուրսը, օրինակ՝ կապի բացում տվյալների բազայի հետ
        $this->resource = fopen('/tmp/my_file.txt', 'w'); // Օրինակ
        echo "Օբյեկտը վերարթնացվեց և ռեսուրսը վերականգնվեց!\n";
    }
    public function __sleep() {
        // Ռեսուրսը չենք սերիալիզացնում
        return ['prop1'];
    }
    public function __destruct() {
        if (is_resource($this->resource)) {
            fclose($this->resource);
            echo "Ռեսուրսը փակվեց.\n";
        }
    }
}
$obj = new MyClass();
$obj->prop1 = 'deserialized value';
$serialized = serialize($obj);
unset($obj);

$deserialized_obj = unserialize($serialized); // Կոչվում է __wakeup()
var_dump($deserialized_obj->prop1);

__toString(): Կոչվում է երբ օբյեկտը օգտագործվում է որպես տող (օրինակ՝ echo կամ կոնկատենացիա): Պետք է վերադարձնի տողային ներկայացում:

<?php
class MyClass {
    public $name = "MyObject";
    public function __toString() {
        return "Օբյեկտ տեսակի MyClass, անունով: " . $this->name;
    }
}
$obj = new MyClass();
echo $obj; // Դրան կհայտնվի "Օբյեկտ տեսակի MyClass, անունով: MyObject"

__invoke(...): Կոչվում է երբ փորձում եք կանչել օբյեկտը որպես ֆունկցիա: Կարող է ընդունել ցանկացած քանակությամբ արգումենտ:

<?php
class MyCallableClass {
    public function __invoke(...$args) {
        echo "Օբյեկտը կանչվեց որպես ֆունկցիա, արգումենտներով: " . implode(', ', $args);
    }
}
$obj = new MyCallableClass();
$obj('arg1', 123); // Դրան կհայտնվի "Օբյեկտը կանչվեց որպես ֆունկցիա, արգումենտներով: arg1, 123"

__set_state(array $properties): Կոչվում է ստատիկ կերպով var_export()-ի միջոցով արտահանված դասերի համար: Ստանում է արտահանված հատկությունների զանգվածը: Պետք է ստեղծի նոր օբյեկտ և վերադարձնի այն:

<?php
class MyClass {
    public $prop;
    public static function __set_state(array $properties) {
        $obj = new MyClass();
        $obj->prop = $properties['prop'];
        return $obj;
    }
}
$obj = new MyClass();
$obj->prop = 'exported value';
$exported = var_export($obj, true); // Արտահանվում է օբյեկտը
// $exported կպարունակի կոդ, որը ստեղծում է օբյեկտ, օգտագործելով __set_state()
eval('$restored_obj = ' . $exported . ';');
var_dump($restored_obj); // Դրան կհայտնվի MyClass օբյեկտ, որի `prop` հատկությունը `'exported value'`

__debugInfo(): Կոչվում է երբ օգտագործվում է var_dump()-ի նման ֆունկցիան օբյեկտի համար: Պետք է վերադարձնի օբյեկտի հատկությունների ինֆորմացիայի զանգված, որը պետք է ցուցադրվի:

<?php
class MyClass {
    public $publicProp = 'public';
    private $privateProp = 'private';
    public function __debugInfo() {
        return ['publicProp' => $this->publicProp, 'private_info' => 'մասնավոր տվյալներ'];
    }
}
$obj = new MyClass();
var_dump($obj); // Դրան կհայտնվի այն ինֆո, որը վերադարձնում է __debugInfo()

__clone(): Կոչվում է երբ կատարվում է օբյեկտի կլոնավորում (clone): Օգտագործվում է խորքային պատճենավորման համար:

<?php
class SubObject {
    public $value;
    public function __construct($value) {
        $this->value = $value;
    }
}
class MyClass {
    public $object;
    public $anotherProp;
    public function __construct() {
        $this->object = new SubObject('initial');
        $this->anotherProp = 'original';
    }
    public function __clone() {
        // Կլոնավորում ենք ներքին օբյեկտը խորքային պատճենավորման համար
        $this->object = clone $this->object;
    }
}
$obj = new MyClass();
$cloned_obj = clone $obj;

// Այժմ $obj->object և $cloned_obj->object տարբեր օրինակներ են SubObject-ների
$cloned_obj->object->value = 'modified';

var_dump($obj->object->value);       // Դրան կհայտնվի "initial"
var_dump($cloned_obj->object->value); // Դրան կհայտնվի "modified"

Տախտակամատյան՝ կարճ նկարագրությամբ:

Մեթոդ	Նկարագրություն	Կոչվում է...
`__construct()`	Կոնստրուկտոր։	Երբ ստեղծվում է նոր օբյեկտ։
`__destruct()`	Դեստրուկտոր։	Օբյեկտի ոչնչացման կամ սցենարի ավարտի ժամանակ։
`__call()`	Չպատկանող կամ մատչելի չլինող մեթոդների մշակումը։	Երբ կանչվում է մատչելի չլինող կամ չպատկանող մեթոդ։
`__callStatic()`	Չպատկանող կամ մատչելի չլինող ստատիկ մեթոդների մշակումը։	Երբ կանչվում է մատչելի չլինող կամ չպատկանող ստատիկ մեթոդ։
`__get()`	Չպատկանող կամ մատչելի չլինող հատկության արժեքի ստացումը։	Երբ փորձում եք ստանալ մատչելի չլինող կամ չպատկանող հատկություն։
`__set()`	Չպատկանող կամ մատչելի չլինող հատկության սահմանումը։	Երբ փորձում եք սահմանել մատչելի չլինող կամ չպատկանող հատկություն։
`__isset()`	`isset()` կամ `empty()`-ի մշակումը։	Երբ օգտագործվում է `isset()` կամ `empty()`։
`__unset()`	Չպատկանող կամ մատչելի չլինող հատկության հեռացումը։	Երբ օգտագործվում է `unset()`։
`__sleep()`	Սերիալիզացիայի նախապատրաստում։	Երբ կանչվում է `serialize()`։
`__wakeup()`	Սերիալիզացիայի հետո վերականգնում։	Երբ կանչվում է `unserialize()`։
`__toString()`	Օբյեկտի տողային ներկայացում։	Օբյեկտի օգտագործում տողային կոնտեքստում։
`__invoke()`	Օբյեկտի կանչում որպես ֆունկցիա։	Երբ փորձում եք կանչել օբյեկտը որպես ֆունկցիա։
`__set_state()`	Օբյեկտի ստեղծում `var_export()`-ից հետո։	Երբ eval-ով վերականգնում եք օբյեկտը։
`__debugInfo()`	Օբյեկտի տվյալների ցուցադրում `var_dump()`-ի ժամանակ։	Երբ կանչվում է `var_dump()`։
`__clone()`	Կլոնավորման հետո մշակումը։	Երբ կատարվում է `clone`։

Ի՞նչ կախարդական մեթոդներ կան PHP-ում և ինչպես են դրանք օգտագործվում: