PHP-ში რა ჯადოსნური მეთოდები არსებობს და როგორ…

მაგიური მეთოდები PHP-ში - ეს სპეციალური მეთოდებია, რომლებიც იწყება ორმაგი ხაზით (მაგალითად, __construct), რომლებიც ავტომატურად იძახება გარკვეულ სიტუაციებში.

ძირითადი მაგიური მეთოდები და მათი გამოყენება:

__construct(): იძახება კლასის ობიექტის შექმნისას. გამოიყენება ობიექტის თვისებების ინიციალიზაციისა და საწყის მოქმედებების შესასრულებლად.
```
<?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' არგუმენტებით: arg1, arg2"

__callStatic(string $name, array $arguments): იძახება, როდესაც ცდილობენ დაუკავშირდნენ მიუწვდომელ ან არარსებულ სტატიკურ მეთოდს კლასის კონტექსტში. ანალოგიურია __call, მაგრამ სტატიკური გამოძახებისთვის.

<?php
class MyClass {
    public static function __callStatic($name, $arguments) {
        echo "დაუკავშირდა მიუწვდომელ სტატიკურ მეთოდს '{$name}' არგუმენტებით: " . implode(', ', $arguments);
    }
}
MyClass::nonExistentStaticMethod('static_arg'); // გამოიტანს "დაუკავშირდა მიუწვდომელ სტატიკურ მეთოდს 'nonExistentStaticMethod' არგუმენტებით: static_arg"

__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() {
        // __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' => 'რაიმე დეტალები privateProp-ის შესახებ'];
    }
}
$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()`-ის გამოყენება.	მიუწვდომელ ან არარსებულ თვისებაზე `unset()`-ის გამოყენებისას.
`__sleep()`	სერიულიალიზაციისთვის მომზადება.	`serialize()`-ის გამოყენება ობიექტზე.
`__wakeup()`	დესერიულიალიზაციის შემდეგ დამუშავება.	`unserialize()`-ის გამოყენება ობიექტზე.
`__toString()`	ობიექტის სტრიქონური წარმოდგენა.	როდესაც ობიექტი გამოიყენება როგორც სტრიქონი (მაგალითად, `echo`).
`__invoke()`	ობიექტის გამოძახება როგორც ფუნქცია.	როდესაც ცდილობენ ობიექტის გამოძახებას როგორც ფუნქცია.
`__set_state()`	ობიექტის შექმნა `var_export()`-ის შემდეგ.	კოდის შეფასებისას, რომელიც შექმნილია `var_export()`.
`__debugInfo()`	ინფორმაცია დებაგისთვის (`var_dump()`).	როდესაც `var_dump()`-ს იყენებენ ობიექტზე.
`__clone()`	კლონირების შემდეგ დამუშავება.	`clone`-ის გამოყენებისას.

PHP-ში რა ჯადოსნური მეთოდები არსებობს და როგორ გამოიყენება ისინი?