Katere so vrste spremenljivk v PHP-ju?

Question

Accepted Answer

PHP je **dinamično tipiziran** — spremenljivke (s predpono `$`) ne deklarirajo tipa in lahko vsebujejo katero koli vrednost. PHP ima več vgrajenih tipov, ki pokrivajo skalarje, sestavljene tipe in posebne vrednosti.

## Spremenljivke in skalarne vrste

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

Spremljivke se vedno začnejo s `$` in njihov tip izhaja iz dodeljene vrednosti. Štiri skalarne vrste so `int`, `float`, `string`, `bool`.

## Sestavljeni in posebni tipi

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

Matrike so PHP-jeva vsestranska zbirka (tako indeksirani seznami kot ključ-vrednost preslikave), ter obstajajo objekti, callables in `null`.

## Preverjanje in pretvarjanje tipov

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

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

## Tipska manipulacija — pogosta past

```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-jeva avtomatska **tipska manipulacija** povzroča presenetljive primerjave. Rešitev: raje uporabite **strogo primerjavo (`===`)**, ki preverja tip in vrednost, ter se izognete pastim ohlapne primerjave (`==`).

## Zakaj je to pomembno

Razumevanje vrst spremenljivk v PHP-ju je temeljno vsakodnevno znanje.

Ključne točke: PHP je dinamično tipiziran (spremenljivke vsebujejo katero koli vrednost, tipi se izpeljujejo iz dodelitve), s skalarnimi tipi, vsestranska **matrika** (ki služi kot seznam in preslikava — PHP-jeva najbolj uporabljena podatkovna struktura), objekti in null.

Najpomembneje je poznavanje **tipske manipulacije** — PHP-jeve avtomatske pretvorbe tipov pri operacijah in primerjavah, ki povzroča znane presenetljive rezultate — in praksa uporabe **stroge primerjave (`===`)** namesto ohlapne (`==`) za izogibanje tem pastim je bistvena za pisanje pravilne, brezhibne PHP kode.

Razlikovanje med `+` (numerično) in `.` (strnjevanje nizov) ter eksplicitno pretvarjanje so tudi vsakodnevne osnove.

To temeljno znanje o tipih je osnova za pravilno PHP kodo in pomaga izogniti se dobro znanim pastim primerjav tega jezika.