PHP இல் மாறிகளின் வகைகள் என்ன?

Question

Accepted Answer

PHP **இயக்க முறையில் தைப் செய்யப்பட்ட** — மாறிகள் (`$` முன்னொட்டு கொண்ட) ஒரு வகையை பிரகடனம் செய்யாது மற்றும் எந்த மதிப்பையும் வைத்திருக்கலாம். PHP ஸ்கேலார் வகைகள், கூட்டு வகைகள் மற்றும் சிறப்பு மதிப்புகளை உள்ளடக்கிய பல உள்ளமைக்கப்பட்ட வகைகளைக் கொண்டுள்ளது.

## மாறிகள் மற்றும் ஸ்கேலார் வகைகள்

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

மாறிகள் எப்போதும் `$` உடன் தொடங்கும் மற்றும் அதன் வகையை ஒதுக்கப்பட்ட மதிப்பிலிருந்து பெறுகின்றன. நான்கு ஸ்கேலார் வகைகள் `int`, `float`, `string`, `bool` ஆகும்.

## கூட்டு மற்றும் சிறப்பு வகைகள்

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

অ্যারেগুলি PHP இன் বহুমুখী সংগ্রহ வகை (সূচী তালিকা மற்றும் কुंजी-मान मानचित्र উভয়ই), மற்றும் வस्तु, callables, மற்றும் `null` உள்ளன.

## வகைகளை சரிபார்ப்பு மற்றும் மாற்றுதல்

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

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

## வகை juggling — ஒரு பொதுவான க덫

```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 இன் தானியங்கி **வகை juggling** ஆச்சரியமான ஒப்பீடுகளை ஏற்படுத்தும். சரி: **கடுமையான ஒப்பீடு (`===`)** விரும்புங்கள் இது வகை மற்றும் மதிப்பை சரிபார்க்கிறது,느슨한 ஒப்பீடு (`==`) பொறிகளைத் தவிர்க்கிறது.

## இது ஏன் முக்கியம்

PHP இன் மாறி வகைகளைப் புரிந்துகொள்வது அடிப்படை தினசரி ज्ञान ஆகும்.

मुख्य बिन्दु: PHP動態रूप से टाइप किया जाता है (मत्याएं कोई भी मान रख सकती हैं, प्रकार असाइनमेंट से निकाले जाते हैं), अदिश प्रकार, बहुमुखी **array** (सूची और मानचित्र दोनों के रूप में काम करता है — PHP का सबसे अधिक उपयोग किया जाने वाला डेटा संरचना), वस्तु, और शून्य।

सबसे महत्वपूर्ण, **प्रकार juggling** का ज्ञान — PHP का स्वचालित प्रकार रूपांतरण संचालन और तुलनाओं में, जो कुख्यात आश्चर्यजनक परिणाम का कारण बनता है — और **कठोर तुलना (`===`)** के ऊपर ढीली (`==`) का उपयोग करने का अभ्यास इन पालन से बचने के लिए सही, बग-मुक्त PHP लिखने के लिए आवश्यक है।

`+` (संख्यात्मक) और `.` (स्ट्रिंग concatenation) के बीच का अंतर, और स्पष्ट casting, भी दैनिक आधार हैं।

यह आधारभूत प्रकार ज्ञान सही PHP कोड को आधार देता है और भाषा के well-known तुलना पालन से बचने में मदद करता है।