Data Types — ڈیٹا کی اقسام

The Urdu Programming Language supports a rich set of data types. This document covers every built-in type, how to create and manipulate values, and how to convert between types.

اردو: اردو پروگرامنگ لینگویج ڈیٹا کی بھرپور اقسام کی حمایت کرتی ہے۔ یہ دستاویز ہر بلٹ-ان قسم، قدریں بنانے اور سنبھالنے کا طریقہ، اور اقسام کے درمیان تبدیلی کا احاطہ کرتی ہے۔

Numbers — اعداد

Numbers can be integers or floating-point values. Both are the same number type internally.

اردو: اعداد یا تو پوری تعداد (integer) ہو سکتے ہیں یا اعشاری (floating-point)۔ دونوں اندرونی طور پر ایک ہی number قسم ہیں۔

Two numeral systems — دو عددی نظام

The Urdu Programming Language accepts both Western (Roman) digits and native Urdu/Arabic-Indic digits anywhere a number appears. The lexer automatically normalises them to the same value before execution — they are completely interchangeable.

System	Digits	Example
Western (Roman)	`0 1 2 3 4 5 6 7 8 9`	`42`, `3.14`, `1_000`
Urdu native (Extended Arabic-Indic)	`۰ ۱ ۲ ۳ ۴ ۵ ۶ ۷ ۸ ۹`	`۴۲`, `۳.۱۴`, `۱_۰۰۰`
Arabic-Indic	`٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩`	`٤٢`, `٣.١٤`

// These are identical — all produce the same integer 42
متغیر الف = 42;
متغیر ب   = ۴۲;
متغیر ج   = ٤٢;

لکھو(الف == ب);   // true
لکھو(ب == ج);     // true

// Mix freely within the same expression
متغیر نتیجہ = ۱۰ + 5 + ٥;
لکھو(نتیجہ);      // 20

// Floats work the same way
متغیر پائی = ۳.۱۴۱۵۹;
لکھو(پائی);       // 3.14159

// Urdu digits in a loop
کے_لیے (متغیر i = ۰; i < ۵; i++) {
    لکھو(i);      // 0 1 2 3 4
}

اردو: اردو پروگرامنگ لینگویج دو عددی نظام قبول کرتی ہے: مغربی (رومن) اعداد 0-9 اور مقامی اردو اعداد ۰-۹۔ لیکسر دونوں کو خودبخود ایک جیسا سمجھتا ہے — آپ دونوں کو آزادانہ ملا سکتے ہیں۔

Integer literals — پوری تعداد

متغیر گنتی = 42;
متغیر منفی = -7;
متغیر صفر = 0;
متغیر بڑا = 1_000_000;   // underscores for readability

لکھو(گنتی + منفی);   // 35
لکھو(بڑا);           // 1000000

Float literals — اعشاری اعداد

متغیر قیمت = 19.99;
متغیر تناسب = 0.75;
متغیر سائنسی = 1.5e3;    // 1500.0
متغیر چھوٹا = 2.5e-4;    // 0.00025

لکھو(قیمت * تناسب);     // 14.9925

اردو: بڑے اعداد میں _ لگا کر پڑھنا آسان بنا سکتے ہیں (جیسے 1_000_000)۔ سائنسی اندازِ اظہار میں e کا مطلب "10 کی قوت" ہے۔

عدد() — Convert to integer

عدد() truncates a float or parses a string as an integer.

لکھو(عدد("42"));       // 42
لکھو(عدد(3.99));       // 3
لکھو(عدد("0xFF", 16)); // 255  (hex string)
لکھو(عدد(سچ));         // 1
لکھو(عدد(جھوٹ));       // 0

اردو: عدد() کسی متن یا اعشاری عدد کو پوری تعداد میں بدلتا ہے۔ اعشاری حصہ کاٹ دیا جاتا ہے (گول نہیں کیا جاتا)۔

اعشاریہ() — Convert to float

لکھو(اعشاریہ("3.14"));   // 3.14
لکھو(اعشاریہ("1e2"));    // 100.0
لکھو(اعشاریہ(7));        // 7.0

ریاضی — Math object

لکھو(ریاضی.PI);              // 3.141592653589793
لکھو(ریاضی.جذر(16));         // 4.0
لکھو(ریاضی.طاقت(2, 10));     // 1024
لکھو(ریاضی.چھت(4.1));        // 5
لکھو(ریاضی.فرش(4.9));        // 4
لکھو(گول(4.567, 2));          // 4.57   (global گول supports precision)
لکھو(ریاضی.مطلق(-99));       // 99
لکھو(ریاضی.کم(3, 7, 1));     // 1
لکھو(ریاضی.زیادہ(3, 7, 1));  // 7

اردو: ریاضی شے میں تمام ریاضیاتی فنکشن موجود ہیں: PI (پائی)، جذر (مربع جذر)، قوت، چھت (ceiling)، فرش (floor)، گول کرنا، مطلق قدر، کم ترین اور زیادہ ترین۔

Special numeric values — خاص عددی قدریں

// نوٹ: صفر سے تقسیم اردو پروگرامنگ لینگویج میں غلطی دیتی ہے
// Note: Division by zero throws a runtime error in Urdu PL
لکھو(ریاضی.عددہے(42)); // true
لکھو(ریاضی.عددہے(NaN));// false

اردو: صفر سے تقسیم Infinity یا -Infinity دیتی ہے۔ NaN (عدد نہیں) اس وقت آتا ہے جب حساب ناممکن ہو، جیسے 0/0۔

Strings — متن

Strings hold text. They can use single quotes, double quotes, or backtick template literals.

اردو: متن (string) حروف کا مجموعہ ہے۔ اسے اکہری قوسین، دہری قوسین یا بیک ٹک سے لکھ سکتے ہیں۔

متغیر الف = 'ایک قوسین';
متغیر ب = "دوہری قوسین";
متغیر ج = `بیک ٹک — ٹیمپلیٹ`;

لکھو(الف);
لکھو(ب);
لکھو(ج);

Template literals with ${} allow embedded expressions:

متغیر نام = "علی";
متغیر عمر = 30;

لکھو(`میرا نام ${نام} ہے اور میں ${عمر} سال کا ہوں۔`);
// میرا نام علی ہے اور میں 30 سال کا ہوں۔

لکھو(`2 + 2 = ${2 + 2}`);
// 2 + 2 = 4

اردو: بیک ٹک والی سٹرنگ میں ${...} کے اندر کوئی بھی اظہار لکھ سکتے ہیں — متغیر، حساب، فنکشن کال سب۔ یہ متن میں خودبخود ضم ہو جاتا ہے۔

See the dedicated Strings document (04-strings.md) for all string methods.

Booleans — بولین

A boolean holds one of two values: سچ (true) or جھوٹ (false).

اردو: بولین صرف دو قدریں رکھتا ہے: سچ (true) یا جھوٹ (false)۔ یہ شرطوں اور منطقی فیصلوں میں استعمال ہوتا ہے۔

متغیر درست = سچ;
متغیر غلط = جھوٹ;

لکھو(5 > 3);    // true
لکھو(5 < 3);    // false
لکھو(نہیں درست);   // false

Truthy and falsy values — سچ اور جھوٹ جیسی قدریں

Falsy values	Truthy values
`جھوٹ`	`سچ`
`0`, `-0`	Any non-zero number
`""` (empty string)	Any non-empty string
`خالی`	Any object or array
`غیر_معرف`	Functions
`NaN`

اگر (0) { لکھو("کبھی نہیں"); } ورنہ { لکھو("صفر جھوٹ ہے"); }
اگر ("اردو") { لکھو("خالی نہیں تار سچ ہے"); }
اگر ([]) { لکھو("خالی فہرست بھی سچ ہے"); }

اردو: کچھ قدریں شرط میں خودبخود جھوٹ کی طرح برتاؤ کرتی ہیں: جھوٹ، 0، خالی متن، خالی، غیر_معرف، NaN۔ باقی سب سچ کی طرح ہیں — خالی فہرست اور خالی شے بھی سچ ہے!

بولین() — Convert to boolean

لکھو(بولین(1));         // true
لکھو(بولین(0));         // false
لکھو(بولین(""));        // false
لکھو(بولین("کچھ"));     // true
لکھو(بولین(خالی));      // false
لکھو(بولین({}));        // true

Null and Undefined — خالی اور غیر_معرف

خالی — Null

خالی represents an intentional absence of any value. Use it when a variable deliberately has no value.

اردو: خالی جان بوجھ کر کوئی قدر نہ ہونے کی نمائندگی کرتا ہے۔ جب آپ چاہتے ہیں کہ متغیر خالی ہو تو خالی استعمال کریں۔

متغیر نتیجہ = خالی;
لکھو(نتیجہ);              // null
لکھو(نتیجہ === خالی);     // true

// Checking for null
اگر (نتیجہ === خالی) {
    لکھو("کوئی نتیجہ نہیں ہے");
}

غیر_معرف — Undefined

غیر_معرف is the value of a variable that has been declared but not yet assigned, or a missing object property.

اردو: غیر_معرف اس متغیر کی قدر ہے جو ڈکلیئر تو کیا گیا ہو لیکن ابھی تک کوئی قدر نہ دی گئی ہو، یا کسی شے کی غیر موجود خاصیت ہو۔ یہ خالی سے مختلف ہے — یہ "ابھی طے نہیں" کا مطلب رکھتا ہے۔

متغیر ڈیٹا;
لکھو(ڈیٹا);                // undefined
لکھو(ڈیٹا === غیر_معرف);   // true

مستقل شخص = { نام: "زید" };
لکھو(شخص.عمر);             // undefined

Nullish coalescing `??` — خالی پن کا آپریٹر

Returns the right-hand side if the left side is خالی or غیر_معرف.

اردو: ?? آپریٹر: اگر بائیں طرف خالی یا غیر_معرف ہو تو دائیں طرف کی قدر واپس کرتا ہے۔ یہ || سے مختلف ہے کیونکہ 0 اور "" کو نہیں بدلتا۔

متغیر ان_پٹ = خالی;
متغیر قدر = ان_پٹ ?? "پہلے سے طے";
لکھو(قدر);    // پہلے سے طے

متغیر تعداد = 0;
لکھو(تعداد ?? 99);    // 0  (0 is NOT null/undefined)

Arrays / Lists — فہرستیں

Arrays store ordered sequences of values. They use square brackets []. Elements can be of any type.

اردو: فہرستیں ترتیب شدہ قدروں کا مجموعہ ہیں۔ مربع بریکٹ [] استعمال ہوتی ہیں۔ عناصر کسی بھی قسم کے ہو سکتے ہیں۔

Creating arrays — فہرست بنانا

متغیر خالی_فہرست = [];
متغیر اعداد = [1, 2, 3, 4, 5];
متغیر نام_جات = ["احمد", "فاطمہ", "علی"];
متغیر ملایا = [1, "دو", سچ, خالی, [3, 4]];

فہرست() — Create from iterable

متغیر ف = فہرست(حد(5));
لکھو(ف);    // [0, 1, 2, 3, 4]

Accessing elements — عناصر تک رسائی

مستقل پھل = ["سیب", "آم", "کیلا", "انار"];

لکھو(پھل[0]);     // سیب
لکھو(پھل[2]);     // کیلا
لکھو(پھل[-1]);    // انار  (negative index — last element)
لکھو(پھل.لمبائی); // 4

اردو: اشاریہ (index) صفر سے شروع ہوتا ہے۔ -1 سے آخری عنصر، -2 سے آخر سے دوسرا عنصر ملتا ہے۔

Array methods — فہرست کے طریقے

Urdu name	Action
`شامل(قدر)`	Push value to end
`نکالو()`	Pop value from end
`پہلے_شامل(قدر)`	Unshift — add to front
`پہلا_نکالو()`	Shift — remove from front
`ترتیب_دو()`	Sort in place
`پلٹاؤ()`	Reverse in place
`چھانو(فنکشن)`	Filter — return new array
`تبدیل(فنکشن)`	Map — transform each element
`اکٹھا(فنکشن, شروع)`	Reduce to single value
`تلاش(فنکشن)`	Find first match
`تلاش_مقام(فنکشن)`	Find index of first match
`شامل_ہے(قدر)`	Includes — boolean check
`جوڑو(جداکار)`	Join elements into string
`حصہ(شروع, آخر)`	Slice — return sub-array
`جوڑ_دو(...فہرست)`	Concat — merge arrays
`ہر_ایک(فنکشن)`	forEach — loop each element
`سب(فنکشن)`	Every — all match?
`کوئی(فنکشن)`	Some — any match?
`پھیلاؤ()`	Flat — flatten nested arrays
`مقام(قدر)`	indexOf

اردو: اردو پروگرامنگ لینگویج میں تمام فہرست طریقے اردو ناموں میں دستیاب ہیں۔ شامل سے آخر میں ڈالیں، نکالو سے آخر سے نکالیں، چھانو سے فلٹر کریں، تبدیل سے نقشہ بنائیں اور کم_کرو سے ایک قدر میں تبدیل کریں۔

متغیر اعداد = [3, 1, 4, 1, 5, 9, 2, 6];

// push and pop
اعداد.شامل(7);
لکھو(اعداد);             // [3, 1, 4, 1, 5, 9, 2, 6, 7]
لکھو(اعداد.نکالو());     // 7

// ترتیب_دو اور پلٹاؤ نئی فہرست واپس کرتے ہیں (اصل نہیں بدلتی)
// Sort and reverse return a new array — the original is unchanged
متغیر مرتب = اعداد.ترتیب_دو();   // sort naturally
لکھو(مرتب);             // [1, 1, 2, 3, 4, 5, 6, 9]
لکھو(اعداد);             // [3, 1, 4, 1, 5, 9, 2, 6]  (unchanged)

متغیر پلٹا = اعداد.پلٹاؤ();
لکھو(پلٹا);             // [6, 2, 9, 5, 1, 4, 1, 3]
لکھو(اعداد);             // [3, 1, 4, 1, 5, 9, 2, 6]  (unchanged)

مستقل اعداد = [1, 2, 3, 4, 5, 6, 7, 8];

// filter
مستقل جفت = اعداد.چھانو(n => n % 2 === 0);
لکھو(جفت);    // [2, 4, 6, 8]

// map
مستقل مربع = اعداد.تبدیل(n => n ** 2);
لکھو(مربع);   // [1, 4, 9, 16, 25, 36, 49, 64]

// reduce
مستقل مجموع_قدر = اعداد.کم_کرو((جمع, n) => جمع + n, 0);
لکھو(مجموع_قدر);   // 36

مستقل الفاظ = ["اردو", "پروگرامنگ", "زبان"];

لکھو(الفاظ.جوڑو(" "));        // اردو پروگرامنگ زبان
لکھو(الفاظ.شامل_ہے("اردو"));  // true
لکھو(الفاظ.اشاریہ("زبان"));   // 2

// Spread to clone or merge
مستقل الف = [1, 2, 3];
مستقل ب = [4, 5, 6];
مستقل ج = [...الف, ...ب];
لکھو(ج);    // [1, 2, 3, 4, 5, 6]

// Flat
مستقل ملا = [[1, 2], [3, [4, 5]]];
لکھو(ملا.چپٹا_کرو());       // [1, 2, 3, [4, 5]]
لکھو(ملا.چپٹا_کرو(2));      // [1, 2, 3, 4, 5]

Objects / Dictionaries — اشیاء / لغتیں

Objects store key-value pairs. Keys are strings (or Symbols); values can be any type.

اردو: اشیاء (objects) کلید-قدر جوڑے رکھتی ہیں۔ کلیدیں متن (یا Symbols) ہوتی ہیں؛ قدریں کسی بھی قسم کی ہو سکتی ہیں۔ یہ لغت کی طرح کام کرتی ہیں — ہر لفظ (کلید) کا ایک مطلب (قدر) ہوتا ہے۔

Creating objects — شے بنانا

مستقل شخص = {
    نام: "مریم",
    عمر: 25,
    شہر: "لاہور"
};

Accessing properties — خاصیتوں تک رسائی

// Dot notation
لکھو(شخص.نام);     // مریم

// Bracket notation (required for dynamic or Urdu-script keys with special chars)
لکھو(شخص["عمر"]);  // 25

// Dynamic key
متغیر کلید = "شہر";
لکھو(شخص[کلید]);   // لاہور

اردو: نقطے کے ذریعے (شخص.نام) یا بریکٹ کے ذریعے (شخص["نام"]) خاصیت تک پہنچ سکتے ہیں۔ متحرک کلید (جو متغیر میں ہو) کے لیے بریکٹ ضروری ہے۔

Modifying objects — شے تبدیل کرنا

متغیر ملازم = { نام: "طارق", تنخواہ: 50000 };

ملازم.عہدہ = "سینیر انجینیر";    // add new property
ملازم.تنخواہ = 65000;             // update existing
حذف ملازم.نام;                    // delete property

لکھو(ملازم);
// { تنخواہ: 65000, عہدہ: "سینیر انجینیر" }

Object shorthand — مختصر اظہار

متغیر نام = "عائشہ";
متغیر عمر = 29;

مستقل شخص = { نام, عمر };   // same as { نام: نام, عمر: عمر }
لکھو(شخص);

Computed property names — متحرک خاصیت کے نام

متغیر کلید = "رنگ";
مستقل شے = { [کلید]: "نیلا", [`${کلید}2`]: "سرخ" };
لکھو(شے);    // { رنگ: "نیلا", رنگ2: "سرخ" }

لغت() — Create dictionary from entries

مستقل جوڑے = [["الف", 1], ["ب", 2], ["ج", 3]];
مستقل لغت_شے = لغت(جوڑے);
لکھو(لغت_شے);    // { الف: 1, ب: 2, ج: 3 }

Object utility methods — شے کے مددگار طریقے

مستقل شخص = { نام: "علی", عمر: 30, شہر: "کراچی" };

لکھو(Object.مفاتیح(شخص));    // ["نام", "عمر", "شہر"]
لکھو(Object.اقدار(شخص));    // ["علی", 30, "کراچی"]
لکھو(Object.اندراج(شخص));   // [("نام","علی"), ("عمر",30), ("شہر","کراچی")]

// Spread to merge/clone
مستقل تازہ = { ...شخص, ملک: "پاکستان" };
لکھو(تازہ);

اردو: Object.keys() کلیدوں کی فہرست، Object.values() قدروں کی فہرست اور Object.entries() کلید-قدر جوڑوں کی فہرست دیتا ہے۔ ... سپریڈ سے شے کو کاپی یا ملانا بہت آسان ہے۔

Optional chaining `?.` — اختیاری زنجیر

مستقل صارف = { پروفائل: { ای_میل: "a@b.com" } };

لکھو(صارف.پروفائل?.ای_میل);        // a@b.com
لکھو(صارف.پتہ?.شہر);              // undefined  (no error)
لکھو(صارف.پتہ?.شہر ?? "نامعلوم"); // نامعلوم

اردو: ?. اختیاری زنجیر سے اگر کوئی خاصیت موجود نہ ہو تو غلطی نہیں آتی بلکہ غیر_معرف ملتا ہے۔ ?? کے ساتھ ملا کر نامعلوم کی صورت میں پہلے سے طے قدر دے سکتے ہیں۔

Sets — مجموعہ

A Set stores unique values of any type. Duplicates are automatically removed.

اردو: مجموعہ (Set) منفرد قدروں کا ذخیرہ ہے — دہری قدریں خودبخود ہٹا دی جاتی ہیں۔ جب آپ کو یقینی بنانا ہو کہ ہر قدر صرف ایک بار آئے تو مجموعہ استعمال کریں۔

متغیر اعداد = مجموعہ([1, 2, 3, 2, 1, 4]);
لکھو(اعداد);            // Set {1, 2, 3, 4}
لکھو(لمبائی(اعداد));      // 4

// Add and delete
اعداد.add(5);
اعداد.discard(1);
لکھو(اعداد.شامل_ہے(2));  // true
لکھو(اعداد.شامل_ہے(1));  // false

// Remove duplicates from array
مستقل ملایا = [1, 2, 2, 3, 3, 3, 4];
مستقل منفرد = [...مجموعہ(ملایا)];
لکھو(منفرد);    // [1, 2, 3, 4]

اردو: فہرست سے دہری قدریں ہٹانے کا آسان طریقہ: مجموعہ میں ڈالو اور واپس فہرست میں لاؤ!

// Set operations
مستقل الف = مجموعہ([1, 2, 3, 4]);
مستقل ب = مجموعہ([3, 4, 5, 6]);

// Union
مستقل اتحاد = مجموعہ([...الف, ...ب]);
لکھو(اتحاد);    // Set {1, 2, 3, 4, 5, 6}

// Intersection
مستقل مشترک = مجموعہ([...الف].چھانو(x => ب.شامل_ہے(x)));
لکھو(مشترک);    // Set {3, 4}

// Difference
مستقل فرق = مجموعہ([...الف].چھانو(x => !ب.شامل_ہے(x)));
لکھو(فرق);      // Set {1, 2}

اردو: مجموعوں پر ریاضیاتی عمل: اتحاد (union) دونوں کا ملاپ، مشترک (intersection) دونوں میں مشترک قدریں، فرق (difference) صرف پہلے میں موجود قدریں۔

Tuples — ٹپل

Tuples are immutable ordered sequences, similar to arrays but fixed in size and content after creation.

اردو: ٹپل غیر قابلِ تبدیل ترتیب شدہ سلسلہ ہے — فہرست جیسا لیکن بنانے کے بعد اس کا سائز اور مواد نہیں بدلا جا سکتا۔ جب آپ چاہیں کہ ڈیٹا محفوظ رہے تو ٹپل بہتر ہے۔

مستقل نکتہ = ٹپل([3, 4]);
لکھو(نکتہ);         // (3, 4)
لکھو(نکتہ[0]);      // 3
لکھو(نکتہ.لمبائی);  // 2

// Tuples as dictionary keys
مستقل نقشہ_نکات = لغت();
مستقل نکتہ_الف = ٹپل([0, 0]);
مستقل نکتہ_ب = ٹپل([1, 1]);

نقشہ_نکات[نکتہ_الف] = "اصل";
نقشہ_نکات[نکتہ_ب] = "بعد";

لکھو(نقشہ_نکات);

// Unpacking a tuple
مستقل رنگ = ٹپل(["سرخ", 255, 0, 0]);
متغیر [نام_رنگ, سرخ, سبز, نیلا] = رنگ;
لکھو(`${نام_رنگ}: rgb(${سرخ}, ${سبز}, ${نیلا})`);
// سرخ: rgb(255, 0, 0)

Type Checking — قسم جانچنا

قسم() — typeof

قسم() returns the type name of a value as a string.

اردو: قسم() کسی قدر کی قسم کا نام بطور متن واپس کرتا ہے۔ کسی متغیر کی قسم جاننے کے لیے یہ استعمال کریں۔

لکھو(قسم(42));           // "عدد"
لکھو(قسم(3.14));         // "عدد"
لکھو(قسم("اردو"));       // "متن"
لکھو(قسم(سچ));           // "بولین"
لکھو(قسم(غیر_معرف));     // "خالی"
لکھو(قسم(خالی));         // "خالی"
لکھو(قسم([]));            // "فہرست"
لکھو(قسم({}));            // "شے"
لکھو(قسم(فنکشن() {}));   // "فنکشن"

مثال — instanceof

مثال checks whether an object is an instance of a class.

اردو: مثال جانچتا ہے کہ آیا کوئی شے کسی کلاس کی مثال (instance) ہے یا نہیں۔

مستقل فہرست_شے = [1, 2, 3];
مستقل تاریخ_شے = نیا Date();

لکھو(فہرست_شے مثال Array);    // true
لکھو(فہرست_شے مثال Object);   // true
لکھو(تاریخ_شے مثال Date);     // true
لکھو(تاریخ_شے مثال Array);    // false

Array.ہے() — فہرست ہے؟

Because قسم([]) returns "object", use Array.ہے() to distinguish arrays.

اردو: چونکہ قسم([]) کا نتیجہ "object" ہے، اس لیے فہرست الگ پہچاننے کے لیے Array.ہے() استعمال کریں۔

لکھو(Array.ہے([1, 2, 3]));    // true
لکھو(Array.ہے({ a: 1 }));     // false
لکھو(Array.ہے("مرحبا"));      // false

Checking for null vs undefined — خالی اور غیر_معرف کی جانچ

فنکشن قسم_چیک(قدر) {
    اگر (قدر === خالی) {
        واپس "null";
    } ورنہ_اگر (قدر === غیر_معرف) {
        واپس "undefined";
    } ورنہ_اگر (Array.ہے(قدر)) {
        واپس "array";
    } ورنہ {
        واپس قسم(قدر);
    }
}

لکھو(قسم_چیک(خالی));       // null
لکھو(قسم_چیک(غیر_معرف));   // undefined
لکھو(قسم_چیک([1,2]));      // array
لکھو(قسم_چیک(99));          // number
لکھو(قسم_چیک("ہیلو"));      // string

اردو: یہ فنکشن مکمل قسم جانچ کی عملی مثال ہے — پہلے خالی، پھر غیر_معرف، پھر فہرست، پھر عام قسم جانچتا ہے۔

Type Conversion — قسم تبدیلی

Function	Converts to	Example
`عدد(x)`	Integer	`عدد("5")` → `5`
`اعشاریہ(x)`	Float	`اعشاریہ("3.14")` → `3.14`
`متن(x)`	String	`متن(42)` → `"42"`
`بولین(x)`	Boolean	`بولین(0)` → `false`
`فہرست(x)`	Array/List	`فہرست("abc")` → `["a","b","c"]`

اردو: قسم تبدیلی کے فنکشن: عدد() پوری تعداد بناتا ہے، اعشاریہ() اعشاری عدد، متن() سٹرنگ، بولین() بولین، اور فہرست() فہرست میں تبدیل کرتا ہے۔

// Number conversions
لکھو(عدد("100"));       // 100
لکھو(عدد("0b1010"));    // 10   (binary)
لکھو(عدد("0o17"));      // 15   (octal)
لکھو(عدد("0xFF"));      // 255  (hex)
لکھو(عدد(جھوٹ));        // 0
لکھو(عدد(سچ));           // 1
لکھو(عدد("ناقص"));      // NaN

// String conversion
لکھو(متن(3.14));        // "3.14"
لکھو(متن(سچ));          // "True"
لکھو(متن(خالی));        // "None"
لکھو(متن([1,2,3]));     // "[1, 2, 3]"
لکھو(متن({ a: 1 }));    // "[object Object]"

// Template literal — implicit conversion
متغیر عدد_شے = 42;
لکھو(`قدر: ${عدد_شے}`);    // "قدر: 42"

// Practical example — user input is always a string
متغیر ان_پٹ = پڑھو("اپنی عمر درج کریں: ");
متغیر عمر = عدد(ان_پٹ);

اگر (ریاضی.عددہے(عمر) اور عمر > 0) {
    لکھو(`آپ ${عمر} سال کے ہیں`);
} ورنہ {
    لکھو("غلط ان پٹ");
}

اردو: آخری مثال بہت اہم ہے — صارف کا ان پٹ ہمیشہ متن (string) ہوتا ہے، اس لیے عدد() سے تبدیل کرنا نہ بھولیں۔ پھر ریاضی.عددہے() سے جانچیں کہ یہ واقعی عدد ہے یا نہیں۔