Vilka är PHP:s variabeltyper?

Question

Accepted Answer

PHP är **dynamiskt typad** — variabler (med prefixet `$`) deklarerar inte en typ och kan innehålla vilket värde som helst. PHP har flera inbyggda typer som omfattar skalära typer, sammansatta typer och särskilda värden.

## Variabler och skalära typer

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

Variabler börjar alltid med `$` och härledas sin typ från det tilldelade värdet. De fyra skalära typerna är `int`, `float`, `string`, `bool`.

## Sammansatta och särskilda typer

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

Arrayer är PHP:s mångsidiga samlingstyp (både indexerade listor och nyckel-värde-mappningar), och det finns objekt, callables och `null`.

## Kontrollering och konvertering av typer

```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 — en vanlig fallgrop

```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:s automatiska **type juggling** orsakar överraskande jämförelser. Lösningen: föredra **strikt jämförelse (`===`)** som kontrollerar typ och värde, och undvik fallgropparna med lös jämförelse (`==`).

## Varför det är viktigt

Att förstå PHP:s variabeltyper är grundläggande vardagskunskap.

Nyckelpoäng: PHP är dynamiskt typad (variabler innehåller vilket värde som helst, typer härledas från tilldelning), med skalära typer, den mångsidiga **array** (som fungerar både som lista och mappning — PHP:s mest använd datastruktur), objekt och null.

Viktigast är kunskap om **type juggling** — PHP:s automatiska typkonvertering i operationer och jämförelser, vilket orsakar notoriska överraskande resultat — och praktiken att använda **strikt jämförelse (`===`)** istället för lös (`==`) för att undvika dessa fallgropar är väsentlig för att skriva korrekt, felfri PHP.

Skillnaden mellan `+` (numerisk) och `.` (strängkonkatenering), och explicit casting, är också dagliga grunder.

Denna grundläggande typkunskap ligger till grund för korrekt PHP-kod och hjälper till att undvika språkets välkända jämförelsefall.