Menene nau'in maɓugà na PHP?

Question

Accepted Answer

PHP ya **jituwa aiki** — maɓugà (da aka fili da `$`) ba sa bayyana nau'i kuma suna iya riƙe da kowane ƙima. PHP yana da nau'i da aka gina masu cikakke waɗanda ke rufe maɓugà, nau'in gida, da ƙimomi na musamman.

## Maɓugà da nau'in scalar

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

Maɓugà koyaushe suna farawa da `$` kuma suna iya bayyana nau'insu daga ƙimar da aka ba. Nau'i hudu na scalar ne `int`, `float`, `string`, `bool`.

## Nau'in gida da nau'in musamman

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

Arrays shine nau'in tarin PHP mai amfani (lissafi mai jeri da taswira mai vigi-ƙima), kuma akwai abubuwan halin, callables, da `null`.

## Bincike da canza nau'i

```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 — wani yadi gama gari

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

Jituwan nau'i ta atomatik na PHP yana haifar da kyakkyawan bambanci. Maganin: fifiti **bambancin tsida (`===`)** wanda ya binciki nau'i da ƙima, irindar toshe ƙofar bambancin (`==`).

## Me yasa ya mahalaci

Ganewa nau'in maɓugà na PHP gida ne na ilimi na aiki na yau.

Maɓuɓɓuka na mahimman: PHP ta jituwa aiki (maɓugà suna riƙe da kowane ƙima, nau'i da aka ƙirƙira daga sanya), tare da nau'in scalar, **array** mai amfani (yin aiki azaman lissafi da taswira — tsarin data wanda ake amfani dashi mafi yawa a PHP), abubuwan halin, da 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.

Bambancin tsakanin `+` (lambar) da `.` (tuƙi haɗi), da tsara zahiri, suma jita na yau ne.

Ilimin nau'i na zahiri wannan yana dayan tushen kodansar PHP daidai kuma yana taimakawa a irindar tudu na bambanci da aka sani na harshe.