# Type Juggling i PHP: comparáidí scaoilte mar riosca slándála

> PHP Type Juggling a thuiscint: conas a dhéanann == comparáid, cad a d'athraigh PHP 8.0 agus cén fáth a gcuirtear comharthaí, hashanna agus róil i gcomparáid go docht.

Foinse: https://phpsos.de/ga/blog/type-juggling-php/  
Staid: 25/10/2026  
Soláthraí: PHP SOS, Cabhair éigeandála PHP agus slándáil freastalaí. Cabhair láithreach trí WhatsApp: https://wa.me/491736494914?text=Dia%20duit%2C%20a%20PHP%20SOS%2C%20t%C3%A1%20cabhair%20de%20dh%C3%ADth%20orainn%20len%C3%A1r%20bhfreastala%C3%AD%20PHP.%20Cuideachta%3A%20%E2%80%A6%20Su%C3%ADomh%20gr%C3%A9as%C3%A1in%3A%20%E2%80%A6

**Go achomair:** Is éard is PHP Type Juggling ann ná an t-athrú cineáil uathoibríoch a chinneann an toradh i gcomparáid scaoilte le `==`. Ó PHP 8.0 tá na rialacha níos déine, ach déantar teaghráin uimhriúla a chur i gcomparáid mar uimhreacha fós, agus leanann `true`, `false` agus `null` rialacha dá gcuid féin. Dá bhrí sin, le haghaidh seiceálacha a bhaineann le slándáil: `===`, `in_array(..., true)`, `match` in ionad `switch`, `hash_equals()` do chomharthaí agus `password_verify()` do phasfhocail.

## Comparáid atá fíor cé nár cheart di a bheith

Ní i bhfeidhmeanna casta atá a lán leochaileachtaí slándála i bhfeidhmchláir PHP, ach in aon charachtar amháin: `==` san áit ar cheart `===` a bheith. Tá cuma cheart ar an gcód, ritheann tástálacha le gnáthionchuir, agus fós ligeann an tseiceáil rud éigin tarlú faoi choinníollacha áirithe a bhí le stopadh aici.

Is é an chúis ná saintréith de PHP atá áisiúil sa saol laethúil: athraítear luachanna go cineál eile nuair is gá. Mar sin is féidir teaghrán ó fhoirm a chur i gcomparáid go díreach le huimhir ón mbunachar sonraí. Le logálacha isteach, comharthaí, róil nó réimsí stádais, is féidir leis an flaithiúlacht sin go beacht a bheith contúirteach.

## Conas a dhéanann PHP comparáid le ==

Déanann lámhleabhar PHP cur síos mionsonraithe ar na rialacha le haghaidh comparáidí scaoilte. Maidir le slándáil, is iad na cásanna seo go príomha atá tábhachtach:

| Comparáid | PHP 7 | PHP 8 | Cúis |
|---|---|---|---|
| `0 == "a"` | fíor | bréagach | cuirtear i gcomparáid mar theaghráin ó PHP 8.0 |
| `"1" == "01"` | fíor | fíor | an dá cheann uimhriúil, comparáid mar uimhir |
| `"10" == "1e1"` | fíor | fíor | tá nodaireacht easpónantúil uimhriúil |
| `100 == "1e2"` | fíor | fíor | uimhir i gcoinne teaghráin uimhriúil |
| `null == false` | fíor | fíor | comparáid mar luach boole |
| `"abc" == true` | fíor | fíor | meastar teaghrán nach bhfuil folamh a bheith fíor |

Chuir an t-athrú i PHP 8.0 aicme iomlán earráidí faoi smacht: roimhe sin, bhí teaghrán neamhuimhriúil ina `0` i gcomparáid le huimhir. Bhí tionchar aige sin ar ráitis `switch` freisin. Ach léiríonn na línte eile sa tábla go bhfuil iontais i gcomparáidí scaoilte fós.

Leanann na hoibreoirí `<`, `>` agus an t-oibreoir comparáide `<=>` na rialacha seo freisin. Le sórtálacha is minic nach ndéanann sé dochar, ach le seiceálacha ar nós „méid níos lú ná teorainn“ le luachanna ón iarratas, ba cheart go mbeadh an cineál socraithe roimh ré.

Tá an líne le nodaireacht easpónantúil go háirithe lúbarnach. Is minic a bhíonn luachanna hash agus comharthaí comhdhéanta d'fhigiúirí agus de litreacha. Má bhíonn cuma uimhir i nodaireacht easpónantúil ar a leithéid de luach de thaisme, d'fhéadfadh `==` dhá hash éagsúla a chur i gcomparáid mar chomhionann. Sin cúlra a lán tuairiscí ar sheachbhóthar logála isteach i seanfheidhmchláir PHP.

## PHP Type Juggling i seiceálacha tipiciúla slándála

Folaíonn comparáidí scaoilte in níos mó áiteanna ná an t-oibreoir `==` amháin:

1. **`in_array()` agus `array_search()`** déanann siad comparáid scaoilte gan an tríú paraiméadar. Mar sin bíonn liosta ceadaithe le róil nó ID níos boige ná mar a cheaptar.
2. **`switch`** déanann sé comparáid scaoilte. Déanann an nath `match`, atá ar fáil ó PHP 8.0, comparáid shábháilte ó thaobh cineáil le `===` de réir an lámhleabhair agus caitheann sé earráid mura n-oireann aon bhrainse.
3. **Ionchuir JSON** tugann siad fíorchineálacha. Is féidir le réimse a bhfuil teaghrán ag súil leis teacht mar `true` nó mar uimhir agus teacht le `==` ar bhealach gan choinne.
4. **`strcmp()` do rúin** níl sé oiriúnach, mar braitheann an t-am rite ar an ábhar agus déantar cásanna earráide a mheas go héasca go mícheart.
5. **Luachanna ar ais a sheiceáil**: Tugann feidhmeanna ar nós `strpos()` `0` ar ais d'aimsiú ag an tús agus `false` mura bhfuil aimsiú ann. Meascann `if (!strpos(...))` an dá cheann.

## Comparáidí slána: an taobh le taobh

Taispeánann na samplaí seo a leanas an leagan neamhshlán agus an leagan slán i ngach cás:

```php
<?php
declare(strict_types=1);

// Ról a sheiceáil
$erlaubteRollen = ['admin', 'redaktion'];
in_array($rolle, $erlaubteRollen);          // neamhshlán: scaoilte
in_array($rolle, $erlaubteRollen, true);    // slán: docht

// Stádas a mheas
$aktion = match ($status) {                 // docht, earráid le luach anaithnid
    'offen'      => 'bearbeiten',
    'erledigt'   => 'archivieren',
};

// Comhartha ó nasc a sheiceáil
if ($tokenAusLink == $gespeichertesToken) { /* neamhshlán */ }
if (is_string($tokenAusLink) && hash_equals($gespeichertesToken, $tokenAusLink)) { /* slán */ }

// Pasfhocal a sheiceáil
if (md5($eingabe) == $hash) { /* neamhshlán: modh lag agus comparáid scaoilte */ }
if (password_verify($eingabe, $hash)) { /* slán */ }

// Fotheaghrán a chuardach
if (strpos($text, 'abc') !== false) { /* ceart: aimsiú ag seasamh 0 freisin */ }
```

Tá `hash_equals()` ag súil, de réir an lámhleabhair, leis an rún aitheanta mar chéad pharaiméadar agus le luach an úsáideora mar dhara paraiméadar agus déanann sé comparáid in am seasta. Conas comharthaí a ghiniúint go slán ar chor ar bith, déanann [Uimhreacha randamacha slána agus comharthaí i PHP](https://phpsos.de/ga/blog/sichere-tokens-php/) cur síos air.

> **Tábhachtach:**
> Ní dhéanann `declare(strict_types=1)` comparáidí docht. Ní bhaineann an ráiteas ach leis an athrú cineáil i nglaonna feidhme agus i luachanna ar ais. Caithfidh tú comparáidí scaoilte a chur in ionad sa chód féin.

Tá cúl eile ar chomparáidí dochta: teipeann orthu nuair nach n-oireann na cineálacha dá chéile. Tá `'42' === 42` bréagach. Tagann luachanna ó fhoirmeacha agus ó URLanna in PHP mar theaghráin, luachanna ón mbunachar sonraí mar theaghráin nó mar uimhreacha ag brath ar an tiománaí agus ar an socrú. An té a thugann isteach `===` i ngach áit gan na cineálacha a ailíniú, cruthaíonn sé earráidí a thagann chun solais le linn oibriúcháin mar dhiúltú d'úsáideoirí dlisteanacha.

Is é an réiteach teorainn shoiléir: bailíochtaítear ionchuir ag an nglacadh agus tugtar go dtí an cineál ceart iad, mar shampla le `filter_var($wert, FILTER_VALIDATE_INT)`, agus ina dhiaidh sin ní láimhseáiltear sa chód iad ach le dearbhuithe cineáil agus comparáidí dochta. Cabhraíonn dearbhuithe cineáil ar pharaiméadair, ar luachanna ar ais agus ar airíonna leis sin, mar tugtar na cineálacha mícheart faoi deara go luath le teachtaireacht earráide, in ionad imeacht go ciúin i gcomparáid.

## Cód atá ann cheana a sheiceáil go córasach

I dtionscadail atá tagtha chun cinn go nádúrtha, faightear comparáidí scaoilte de na céadta. Ní fadhb gach ceann. Dírigh ar na háiteanna ina ndéantar cinneadh faoi rochtain:

```bash
# Comparáidí scaoilte i línte le téarmaí a bhaineann le slándáil
grep -rnE "[^=!]==[^=]" src/ --include="*.php" | grep -iE "token|hash|pass|role|rolle|admin|auth|sign"
# in_array gan comparáid dhocht
grep -rnE "in_array\([^)]*\)" src/ --include="*.php" | grep -v ", true)"
```

Is féidir le huirlisí anailíse statach ar nós PHPStan nó Psalm comparáidí scaoilte a thuairisciú go buan ar iarratas. Mar sin ní shroicheann cásanna nua an príomhbhrainse ar chor ar bith. Tá bunús cineálacha le fáil ag [An córas cineálacha de chuid PHP](https://phpsos.de/ga/php/typsystem/); conas ionchuir a thabhairt go dtí an cineál ceart roimh ré, léiríonn [Ionchuir i PHP a bhailíochtú agus a scagadh](https://phpsos.de/ga/blog/eingaben-validieren-php/).

## Cad is brí leis seo do sheanchórais

Tá feidhmchláir a ritheann ar PHP 7 fós buailte ag na seanrialacha comparáide níos scaoilte. Ina theannta sin tá dara fadhb ann: do PHP 8.1 agus níos sine níl nuashonruithe slándála oifigiúla ó thionscadal PHP ann a thuilleadh, ná i gcoinne PHP2Shell. Déanann [PHP 8.1 agus níos sine: cad atá i bhfeidhm anois](https://phpsos.de/ga/php2shell/php-8-1-und-aelter/) cur síos ar an staid.

Nuair a dhéantar imirce go PHP 8 athraíonn roinnt torthaí comparáide. Is feabhsú é sin de ghnáth, ach d'fhéadfadh sé cód a bhriseadh a bhí ag brath ar an seaniompar. Dá bhrí sin pleanáil tástálacha a chlúdaíonn go sonrach comparáidí le huimhreacha, le luachanna folamha agus le `null`.

## Conas a chabhraíonn PHP SOS go nithiúil?

- Cuardaímid do chód le haghaidh comparáidí scaoilte in áiteanna a chinneann logáil isteach, ceadanna nó íocaíochtaí.
- Cuirimid comparáidí dochta, nathanna `match` agus feidhmeanna seiceála cuí ina n-ionad.
- Socraímid anailís statach ionas go dtugtar comparáidí scaoilte nua faoi deara sa tógáil.
- Tacaímid le himirce go leaganacha PHP reatha le tástálacha do rialacha comparáide athraithe.

Déanann [Iniúchadh slándála agus tástáil threáite](https://phpsos.de/ga/leistungen/sicherheitsaudit-penetrationstest/) cur síos ar sheiceáil do bhogearraí.


## Ceisteanna coitianta

**Cad is Type Juggling ann i PHP?**  
Athraíonn PHP luachanna de chineálacha éagsúla go huathoibríoch i roinnt oibríochtaí, mar shampla teaghrán go uimhir. Le comparáid scaoilte le == cinneann an t-athrú seo an toradh. Tá sé áisiúil, ach is féidir leis comparáidí a chruthú atá fíor cé nach bhfuil na luachanna cosúil lena chéile.

**An réitigh PHP 8 an fhadhb?**  
Go páirteach. Ó PHP 8.0 déantar uimhir a chur i gcomparáid le teaghrán neamhuimhriúil mar theaghrán, mar sin níl 0 == 'a' fíor a thuilleadh. Ach déantar dhá theaghrán uimhriúla a chur i gcomparáid mar uimhreacha fós, agus leanann comparáidí le true, false agus null rialacha dá gcuid féin.

**An gcabhraíonn declare(strict_types=1) i gcoinne comparáidí scaoilte?**  
Ní chabhraíonn. Rialaíonn strict_types an n-athraítear cineálacha scalacha go huathoibríoch i nglaonna feidhme agus i luachanna ar ais. Níl tionchar aige ar na hoibreoirí comparáide == agus !=.

**Conas a dhéanaim comparáid chearta ar phasfhocail agus ar chomharthaí?**  
Seiceálann tú pasfhocail le password_verify, comharthaí agus sínithe le hash_equals. Déanann an dá cheann comparáid chruinn agus, i gcás hash_equals, in am seasta. Níl comparáid le == nó strcmp oiriúnach chuige sin.

## Foinsí

- [Lámhleabhar PHP: oibreoirí comparáide](https://www.php.net/manual/de/language.operators.comparison.php)
- [Lámhleabhar PHP: match](https://www.php.net/manual/de/control-structures.match.php)
- [OWASP Cheat Sheet Series](https://cheatsheetseries.owasp.org/)