რა არის PHP-ის ცვლადების ტიპები?

Question

Accepted Answer

PHP **დინამიურად აკრეფილი** — ცვლადები (რომლებიც წინ დგინს `$`) არ აცხადებენ ტიპს და შეიძლება შეიცავდეს ნებისმიერ მნიშვნელობას. PHP-ს აქვს რამდენიმე ჩაშენებული ტიპი, რომელიც მოიცავს სკალარული ტიპებს, შედგენილ ტიპებს და სპეციალურ მნიშვნელობებს.

## Variables and the scalar types

```php
<?php
$count = 42;          // int
$price = 9.99;        // float
$name = "Ann";        // string
$active = true;       // bool

$count = "now a string";   // dynamically typed — the same variable can change type
```

ცვლადები ყოველთვის იწყება `$`-ით და ჩამოწერენ მათ ტიპს მინიჭებული მნიშვნელობიდან. ოთხი სკალარული ტიპი არის `int`, `float`, `string`, `bool`.

## Compound and special types

```php
$list = [1, 2, 3];               // array (PHP's all-purpose collection)
$map = ["name" => "Ann"];        // associative array (key → value)
$obj = new User();                // object (instance of a class)
$fn = fn($x) => $x * 2;           // callable (closure/function)
$nothing = null;                  // null — "no value"
```

მასივები არის PHP-ის მრავალფეროვანი კოლექციის ტიპი (ორივე ინდექსირებული სიები და გასაღებ-მნიშვნელობის რუკები), და არსებობს ობიექტები, callables და `null`.

## Checking and converting types

```php
gettype($count);        // "integer"
is_int($count);          // true
is_string($name);        // true

(int) "42";              // 42 — explicit cast
(string) 42;             // "42"
intval("42px");          // 42
```

## Type juggling — a common gotcha

```php
// PHP automatically converts types in operations ("type juggling")
"5" + 3;        // 8  (string "5" coerced to int)
"5" . 3;         // "53" (. concatenates → both become strings)

// loose vs strict comparison
0 == "hello";    // historically true in old PHP (now false in PHP 8) — type juggling traps
0 === "0";       // false — STRICT comparison checks type too (preferred!)
"1" == 1;        // true (loose) — but "1" === 1 is false
```

PHP-ის ავტომატური **ტიპის ჟონგლირება** იწვევს გასაკვირი შედარებებს. გამოსავალი: სასურველია **მკაცრი შედარება (`===`)**, რომელიც ამოწმებს ტიპს და მნიშვნელობას, თავიდან აიცილოს loose შედარების (`==`) პრობლემები.

## რატომ არის ეს მნიშვნელოვანი

PHP-ის ცვლადების ტიპების გაცნობა ფундამენტური ყოველდღიური ცოდნაა.

მთავარი პუნქტები: PHP დინამიურად აკრეფილი (ცვლადები ნებისმიერ მნიშვნელობას ატარებენ, ტიპები ჩამოწერილია დავალებიდან), სკალარული ტიპებით, მრავალფეროვანი **მასივი** (რომელიც დამსახურებელი როგორც სია, ასევე რუკა — PHP-ის ყველაზე გამოყენებული მონაცემთა სტრუქტურა), ობიექტები და null.

ყველაზე მნიშვნელოვანი, იმის ცოდნა **ტიპის ჟონგლირების** შესახებ — PHP-ის ავტომატური ტიპის კონვერტაცია ოპერაციებში და შედარებებში, რომელიც იწვევს ცნობილ გასაკვირ შედეგებს — და **მკაცრი შედარების (`===`)** loose-ის ნაცვლად (`==`) გამოყენების პრაქტიკა აუცილებელია სწორი, ხარვეზის გარეშე PHP-ის დასაწერად.

`+` (რიცხვითი) და `.` (სტრიქონის შერთება) შორის განსხვავება, და აშკარა casting, ასევე ყოველდღიური საფუძვლები.

ეს ფუნდამენტური ტიპის ცოდნა უდევს საფუძველს სწორი PHP კოდის და ეხმარება ენის ცნობილი შედარების პრობლემებიდან თავის დაშორებას.