Kokie yra PHP kintamųjų tipai?

Question

IT Interview Practice · Accepted Answer

PHP yra **dinamiškai tipuojama** — kintamieji (pradedami `$`) nededklaruoja tipo ir gali laikyti bet kokią reikšmę. PHP turi kelis integruotus tipus, apimančius skaliarinius, sudėtinius tipus ir specialias reikšmes.

## 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
```

Kintamieji visada prasideda nuo `$` ir nustato jų tipą iš priskirtos reikšmės. Keturi skaliariniai tipai yra `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"
```

Masyvai yra PHP universalus rinkinys tipas (indeksuoti sąrašai ir raktų-reikšmių žemėlapiai), ir yra objektai, callable ir `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 automatinis **tipo žonglirimas** sukelia nuostabius palyginimus. Sprendimas: naudoti **griežtą palyginimą (`===`)**, kuris patikrina tipą ir reikšmę, išvengiant loose palygintimo (`==`) spąstų.

## Kodėl tai svarbu

Supratimas PHP kintamųjų tipų yra pagrindinės kasdienės žinios.

Pagrindiniai punktai: PHP yra dinamiškai tipuojama (kintamieji turi bet kokią reikšmę, tipai nustatomi iš priskyrimo), su skaliariniais tipais, universaliu **masyvu** (tarnaujančiu kaip sąrašas ir žemėlapis — PHP dažniausiai naudojama duomenų struktūra), objektais ir null.

Svarbiausiai žinoti apie **tipo žonglirizmą** — PHP automatinę tipo konversiją operacijose ir palyginimuose, kuri sukelia žinomus nuostabius rezultatus — ir praktiką naudoti **griežtą palyginimą (`===`)** vietoj loose (`==`), kad išvengti šių spąstų, yra būtina rašyti teisingą, be klaidų PHP.

Skirtumas tarp `+` (skaitinis) ir `.` (eilutės sujungimas), ir aiškus casting, taip pat yra kasdienes pagrindai.

Šios pagrindinės tipo žinios suteikia pagrindą teisingam PHP kodui ir padeda išvengti žinomų kalbos palyginimo spąstų.

Variables and the scalar types

Compound and special types

Checking and converting types

Type juggling — a common gotcha

Kodėl tai svarbu

Susiję klausimai