Cad iad na cineálacha athróg i PHP?

Question

Accepted Answer

Tá PHP **dinimiciúil clóscríofa** — ní bhraistintear cineál ar athróga (a thosaíonn le `$`) agus is féidir leo aon luach a bheith ann. Tá roinnt cineálacha ionsuite ag PHP a chlúdaíonn scálir, cineálacha cumtha agus luachanna speisialta.

## Athróga agus na cineálacha scálir

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

Tosnítear athróga i gcónaí le `$` agus infhéadtar a gcineál ó an luach a shanntar. Is iad na ceithre chineál scálir `int`, `float`, `string`, `bool`.

## Cineálacha cumtha agus cineálacha speisialta

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

Is é arrays cineál bailiúcháin versatile PHP (liostaí innéacsaithe agus léarscáileanna eochair-luach), agus tá réada, callables, agus `null` ann.

## Cineál a sheiceáil agus a thiontú

```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 — gotcha coitianta

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

Braistintear **type juggling** uathoibríoch PHP ag cur isteach ar comparáidí iontas. An socrú: a bheith i bhfabhar **comparáid dhocht (`===`)** a sheiceálann cineál agus luach, ag seachaint faillí comparáide scaoilte (`==`).

## Cén fáth a bhfuil sé tábhachtach

Tá tuiscint ar chineálacha athróg PHP ina eolas bunúsach laethúil.

Na príomhphointe: tá PHP dinimiciúil clóscríofa (sealbhaíonn athróga aon luach, cineálacha infhéadta ó shannú), le cineálacha scálir, an **array** versatile (ag fónamh mar liosta agus map araon — an struchtúr sonraí is minice a úsáidtear i PHP), réada, agus null.

Most importantly, knowing about **type juggling** — PHP's automatic type conversion in operations and comparisons, which causes notorious surprising results — and the practice of using **strict comparison (`===`)** over loose (`==`) to avoid those traps is essential for writing correct, bug-free PHP.

An t-idirdhealú idir `+` (uimhriúil) agus `.` (teaghrán comhchaitsithe), agus caitheamh sainráite, freisin ná bunúsacha laethúla.

Tá an eolas bunúsach seo ar chineálacha mar bhunús don chód PHP ceart agus cabhraíonn sé seachaint ar thramhaigí comparáide an teanga a bhí ar eolas.