Control Flow — بہاؤ کا کنٹرول

Control flow statements decide which code runs and how many times. This document covers all branching and looping constructs in the Urdu Programming Language.

اردو: بہاؤ کنٹرول کے بیانات فیصلہ کرتے ہیں کہ کون سا کوڈ چلے اور کتنی بار۔ یہ دستاویز اردو پروگرامنگ لینگویج کے تمام شاخ بندی اور حلقہ کے تعمیرات کا احاطہ کرتی ہے۔

---

Table of Contents

1. اگر / ورنہ_اگر / ورنہ — if / else if / else
2. منتخب / صورت / بصورت_دیگر — switch / case / default
3. جبکہ — while loop
4. do…جبکہ — do…while loop
5. کے_لیے...میں — for...in
6. کے_لیے...کا — for...of
7. ٹوٹنا — break
8. جاری — continue
9. Labeled Statements
10. Loop with حد — range
11. Loop with گنو — enumerate
12. Nested Loops
13. Practical Examples

---

اگر / ورنہ_اگر / ورنہ

Syntax:

اگر (شرط) {
    // اگر شرط سچ ہو
} ورنہ_اگر (دوسری_شرط) {
    // اگر دوسری شرط سچ ہو
} ورنہ {
    // اگر کوئی شرط سچ نہ ہو
}

اردو: شرط والے بیانات سب سے بنیادی فیصلہ سازی ہے۔ اگر سے شروع کریں، ورنہ_اگر سے مزید شرطیں لگائیں، اور ورنہ آخری متبادل ہے جو تب چلتا ہے جب کوئی شرط سچ نہ ہو۔

Basic example:

متغیر درجہ_حرارت = 35;

اگر (درجہ_حرارت > 40) {
    لکھو("بہت زیادہ گرم ہے");
} ورنہ_اگر (درجہ_حرارت > 30) {
    لکھو("گرم ہے");
} ورنہ_اگر (درجہ_حرارت > 20) {
    لکھو("مناسب ہے");
} ورنہ {
    لکھو("ٹھنڈا ہے");
}
// گرم ہے

Multiple conditions with logical operators:

متغیر عمر = 22;
متغیر طالب_علم = سچ;

اگر (عمر >= 18 اور عمر <= 25 اور طالب_علم) {
    لکھو("نوجوان طالب علم رعایت ملے گی");
}

اردو: منطقی آپریٹرز اور، یا، نہیں استعمال کر کے کئی شرطیں ایک ساتھ لگائی جا سکتی ہیں۔

Checking equality:

متغیر رنگ = "نیلا";

اگر (رنگ === "سرخ") {
    لکھو("خطرہ");
} ورنہ_اگر (رنگ === "پیلا") {
    لکھو("احتیاط");
} ورنہ_اگر (رنگ === "نیلا" یا رنگ === "سبز") {
    لکھو("محفوظ");
} ورنہ {
    لکھو("نامعلوم رنگ");
}
// محفوظ

Single-line if (no braces — only for one statement):

متغیر سکور = 85;
اگر (سکور >= 90) لکھو("ممتاز");
ورنہ لکھو("کامیاب");
// کامیاب

Nested if:

متغیر نام = "احمد";
متغیر پاس_ورڈ = "1234";

اگر (نام === "احمد") {
    اگر (پاس_ورڈ === "1234") {
        لکھو("لاگ ان کامیاب");
    } ورنہ {
        لکھو("پاس ورڈ غلط ہے");
    }
} ورنہ {
    لکھو("صارف نہیں ملا");
}

اردو: اندرونی اگر بیان سے مزید مخصوص جانچ ہوتی ہے — پہلے نام جانچا، پھر صحیح نام کی صورت میں پاس ورڈ جانچا۔

---

منتخب / صورت / بصورت_دیگر

منتخب matches an expression against multiple صورت labels. Use ٹوٹنا to prevent fall-through. بصورت_دیگر is the default.

اردو: منتخب ایک اظہار کو متعدد صورت لیبلوں سے ملاتا ہے۔ ٹوٹنا استعمال کریں ورنہ کوڈ اگلی صورت میں بھی گرتا رہے گا۔ بصورت_دیگر پہلے سے طے متبادل ہے۔

Syntax:

منتخب (اظہار) {
    صورت قدر1:
        // ...
        ٹوٹنا;
    صورت قدر2:
        // ...
        ٹوٹنا;
    بصورت_دیگر:
        // ...
}

Day of week example:

متغیر دن = 3;
متغیر دن_نام;

منتخب (دن) {
    صورت 1:
        دن_نام = "پیر";
        ٹوٹنا;
    صورت 2:
        دن_نام = "منگل";
        ٹوٹنا;
    صورت 3:
        دن_نام = "بدھ";
        ٹوٹنا;
    صورت 4:
        دن_نام = "جمعرات";
        ٹوٹنا;
    صورت 5:
        دن_نام = "جمعہ";
        ٹوٹنا;
    صورت 6:
        دن_نام = "ہفتہ";
        ٹوٹنا;
    صورت 7:
        دن_نام = "اتوار";
        ٹوٹنا;
    بصورت_دیگر:
        دن_نام = "نامعلوم";
}

لکھو(دن_نام);   // بدھ

Fall-through (intentional — no break):

متغیر ماہ = 4;
متغیر دن_کی_تعداد;

منتخب (ماہ) {
    صورت 1:
    صورت 3:
    صورت 5:
    صورت 7:
    صورت 8:
    صورت 10:
    صورت 12:
        دن_کی_تعداد = 31;
        ٹوٹنا;
    صورت 4:
    صورت 6:
    صورت 9:
    صورت 11:
        دن_کی_تعداد = 30;
        ٹوٹنا;
    صورت 2:
        دن_کی_تعداد = 28;
        ٹوٹنا;
    بصورت_دیگر:
        دن_کی_تعداد = -1;
}

لکھو(`ماہ ${ماہ} میں ${دن_کی_تعداد} دن ہیں`);
// ماہ 4 میں 30 دن ہیں

اردو: جان بوجھ کر "گرنا" (fall-through) — جب کئی صورتیں ایک ہی کوڈ چلائیں تو ٹوٹنا چھوڑ دیں۔ یہاں مہینوں کی مثال ہے — 31 دن والے مہینوں کی فہرست، پھر 30 والے، پھر فروری۔

Switch on strings:

متغیر حکم = "شروع";

منتخب (حکم) {
    صورت "شروع":
        لکھو("پروگرام شروع ہو رہا ہے...");
        ٹوٹنا;
    صورت "روکو":
        لکھو("پروگرام رک گیا");
        ٹوٹنا;
    صورت "باہر":
        لکھو("پروگرام بند ہو رہا ہے");
        ٹوٹنا;
    بصورت_دیگر:
        لکھو(`نامعلوم حکم: ${حکم}`);
}

---

جبکہ — while loop

جبکہ repeats a block as long as the condition remains true. The condition is checked before each iteration.

اردو: جبکہ حلقہ اس وقت تک ایک بلاک دہراتا ہے جب تک شرط سچ رہے۔ ہر بار سے پہلے شرط جانچی جاتی ہے — اگر پہلی بار ہی شرط جھوٹ ہو تو حلقہ بالکل نہیں چلتا۔

متغیر i = 0;
جبکہ (i < 5) {
    لکھو(`تکرار: ${i}`);
    i++;
}
// تکرار: 0
// تکرار: 1
// تکرار: 2
// تکرار: 3
// تکرار: 4

Accumulate sum:

متغیر عدد = 1;
متغیر مجموع_قدر = 0;

جبکہ (عدد <= 10) {
    مجموع_قدر += عدد;
    عدد++;
}

لکھو(`1 سے 10 کا مجموع: ${مجموع_قدر}`);   // 55

Input loop:

متغیر جواب = "";
جبکہ (جواب !== "ہاں" اور جواب !== "نہیں") {
    جواب = پڑھو("کیا آپ جاری رکھنا چاہتے ہیں؟ (ہاں/نہیں): ");
}
لکھو(`آپ نے ${جواب} کہا`);

اردو: ان پٹ حلقہ ایک عام نمونہ ہے — جب تک صحیح جواب نہ آئے پوچھتے رہیں۔

---

do…جبکہ — do…while loop

The body executes at least once before the condition is checked.

اردو: کرو...جبکہ حلقے میں بلاک کم از کم ایک بار ضرور چلتا ہے — شرط بعد میں جانچی جاتی ہے۔ یہ جبکہ سے مختلف ہے جہاں پہلے جانچ ہوتی ہے۔

متغیر گنتی = 0;

کرو {
    لکھو(`گنتی: ${گنتی}`);
    گنتی++;
} جبکہ (گنتی < 3);

// گنتی: 0
// گنتی: 1
// گنتی: 2

// Menu loop — always show at least once
متغیر انتخاب;
کرو {
    لکھو("1. نئی فائل");
    لکھو("2. کھولیں");
    لکھو("3. بند کریں");
    انتخاب = عدد(پڑھو("انتخاب: "));
} جبکہ (انتخاب < 1 یا انتخاب > 3);
لکھو(`آپ نے ${انتخاب} منتخب کیا`);

اردو: مینو دکھانے کے لیے کرو...جبکہ بہت مناسب ہے — مینو ہمیشہ پہلے دکھائیں، پھر جانچیں کہ صحیح انتخاب ہوا یا نہیں۔

---

کے_لیے...میں — for...in

کے_لیے...میں iterates over the keys of an object (or indices of an array, though کے_لیے...کا is preferred for arrays).

اردو: کے_لیے...میں کسی شے کی کلیدوں پر چلتا ہے (یا فہرست کے اشاریوں پر، لیکن فہرست کے لیے کے_لیے...کا بہتر ہے)۔

// Object keys
مستقل ملازم = { نام: "سارہ", عہدہ: "مینیجر", تنخواہ: 80000 };

کے_لیے (متغیر کلید میں ملازم) {
    لکھو(`${کلید}: ${ملازم[کلید]}`);
}
// نام: سارہ
// عہدہ: مینیجر
// تنخواہ: 80000

// Iterate own properties only
مستقل ڈیٹا = { x: 1, y: 2, z: 3 };

کے_لیے (متغیر کلید میں ڈیٹا) {
    اگر (کلید میں_ہے ڈیٹا) {
        لکھو(`${کلید} = ${ڈیٹا[کلید]}`);
    }
}

// Array indices (use for...of instead when possible)
مستقل رنگ = ["سرخ", "سبز", "نیلا"];
کے_لیے (متغیر اشاریہ میں رنگ) {
    لکھو(`[${اشاریہ}]: ${رنگ[اشاریہ]}`);
}
// [0]: سرخ
// [1]: سبز
// [2]: نیلا

Note: کے_لیے...میں on arrays iterates over index strings ("0", "1", …) not numeric indices. Use کے_لیے...کا to iterate array values directly.

اردو: نوٹ: فہرست پر کے_لیے...میں استعمال کرنے سے اشاریے متن کے طور پر ملتے ہیں ("0"، "1" وغیرہ)، اعداد کے طور پر نہیں۔ فہرست کی قدروں پر چلنے کے لیے کے_لیے...کا استعمال کریں۔

---

کے_لیے...کا — for...of

کے_لیے...کا iterates over the values of any iterable: arrays, strings, sets, maps, generators.

اردو: کے_لیے...کا کسی بھی قابلِ تکرار چیز کی قدروں پر چلتا ہے: فہرستیں، متن، مجموعے، نقشے، جنریٹرز — سب کے ساتھ کام کرتا ہے۔

// Array values
مستقل پھل = ["سیب", "آم", "کیلا"];

کے_لیے (متغیر پھل_شے کا پھل) {
    لکھو(پھل_شے);
}
// سیب
// آم
// کیلا

// String characters
کے_لیے (متغیر حرف کا "اردو") {
    لکھو(حرف);
}
// ا
// ر
// د
// و

// Set values
مستقل منفرد = مجموعہ([1, 2, 3, 2, 1]);
کے_لیے (متغیر قدر کا منفرد) {
    لکھو(قدر);
}
// 1
// 2
// 3

// Object entries with for...of
مستقل شخص = { نام: "علی", عمر: 30 };
کے_لیے (متغیر [کلید, قدر] کا شخص.entries()) {
    لکھو(`${کلید}: ${قدر}`);
}
// نام: علی
// عمر: 30

اردو: .entries() کے ساتھ کے_لیے...کا استعمال کر کے شے کی کلیدیں اور قدریں دونوں ایک ساتھ ملتی ہیں — بہت صاف اور پڑھنے میں آسان۔

---

ٹوٹنا — break

ٹوٹنا exits the current loop or منتخب immediately.

اردو: ٹوٹنا موجودہ حلقے یا منتخب سے فوری طور پر باہر نکلتا ہے۔ جب آپ کو معلوم ہو کہ مزید تکرار کی ضرورت نہیں تو ٹوٹنا استعمال کریں — یہ پروگرام کو تیز کرتا ہے۔

// Find first even number
مستقل اعداد = [1, 3, 7, 4, 9, 2];
متغیر پہلا_جفت = خالی;

کے_لیے (متغیر n کا اعداد) {
    اگر (n % 2 === 0) {
        پہلا_جفت = n;
        ٹوٹنا;
    }
}
لکھو(پہلا_جفت);    // 4

// Stop while loop early
متغیر گنتی = 0;
جبکہ (سچ) {          // infinite loop
    گنتی++;
    اگر (گنتی >= 5) ٹوٹنا;
}
لکھو(گنتی);    // 5

اردو: لامتناہی حلقے (جبکہ (سچ)) میں ٹوٹنا خروج کا واحد راستہ ہوتا ہے — مخصوص شرط پوری ہونے پر باہر نکلیں۔

---

جاری — continue

جاری skips the rest of the current iteration and moves to the next one.

اردو: جاری موجودہ تکرار کا باقی حصہ چھوڑ دیتا ہے اور اگلی تکرار پر چلا جاتا ہے۔ ٹوٹنا سے مختلف — جاری حلقہ جاری رکھتا ہے، بس اس تکرار کو چھوڑتا ہے۔

// Print only odd numbers
کے_لیے (متغیر i کا حد(10)) {
    اگر (i % 2 === 0) جاری;
    لکھو(i);
}
// 1 3 5 7 9

// Skip nulls
مستقل ڈیٹا = [1, خالی, 3, غیر_معرف, 5, خالی, 7];
کے_لیے (متغیر قدر کا ڈیٹا) {
    اگر (قدر === خالی یا قدر === غیر_معرف) جاری;
    لکھو(قدر);
}
// 1 3 5 7

اردو: خالی اور غیر_معرف قدریں چھوڑنے کی عملی مثال — ڈیٹا صاف کرتے وقت بہت کام آتا ہے۔

---

Labeled Statements — لیبل والے بیانات

Labels allow ٹوٹنا and جاری to target an outer loop.

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

// Break outer loop from inner loop
بیرونی: کے_لیے (متغیر i کا حد(5)) {
    کے_لیے (متغیر j کا حد(5)) {
        اگر (i + j === 5) {
            لکھو(`i=${i}, j=${j} پر رکا`);
            ٹوٹنا بیرونی;
        }
    }
}
// i=0, j=5 پر رکا  (first combination where i+j=5)

// Continue outer loop from inner
بیرونی: کے_لیے (متغیر i کا حد(3)) {
    کے_لیے (متغیر j کا حد(3)) {
        اگر (j === 1) جاری بیرونی;
        لکھو(`(${i}, ${j})`);
    }
}
// (0, 0)
// (1, 0)
// (2, 0)

اردو: جاری بیرونی بیرونی حلقے کی اگلی تکرار پر چلا جاتا ہے — اندرونی حلقے کی باقی تکرارات چھوڑ دیتا ہے۔

---

Loop with حد — range

حد(n) generates integers from 0 to n-1. حد(شروع, آخر, قدم) is also supported.

اردو: حد(n) صفر سے n-1 تک کے اعداد بناتا ہے۔ حد(شروع, آخر, قدم) سے شروع، آخر اور مرحلہ مخصوص کر سکتے ہیں — منفی قدم سے الٹی گنتی بھی ہو سکتی ہے۔

// حد(n) — 0 to n-1
کے_لیے (متغیر i کا حد(5)) {
    لکھو(i);     // 0 1 2 3 4
}

// حد(شروع, آخر)
کے_لیے (متغیر i کا حد(1, 6)) {
    لکھو(i);     // 1 2 3 4 5
}

// حد(شروع, آخر, قدم)
کے_لیے (متغیر i کا حد(0, 20, 5)) {
    لکھو(i);     // 0 5 10 15
}

// Count down with negative step
کے_لیے (متغیر i کا حد(10, 0, -2)) {
    لکھو(i);     // 10 8 6 4 2
}

// Sum of first 100 natural numbers
متغیر مجموع_قدر = 0;
کے_لیے (متغیر i کا حد(1, 101)) {
    مجموع_قدر += i;
}
لکھو(مجموع_قدر);    // 5050

اردو: 1 سے 100 تک کا مجموع ایک مشہور مثال ہے — جواب 5050 ہے!

---

Loop with گنو — enumerate

گنو(اشیاء) yields [اشاریہ, قدر] pairs, just like Python's enumerate().

اردو: گنو() ہر قدر کے ساتھ اس کا اشاریہ بھی دیتا ہے — جیسے پائتھن کا enumerate()۔ جب فہرست پر چلتے وقت اشاریہ بھی چاہیے ہو تو یہ بہترین ہے۔

مستقل رنگ_جات = ["سرخ", "سبز", "نیلا", "پیلا"];

کے_لیے (متغیر [i, رنگ] کا گنو(رنگ_جات)) {
    لکھو(`${i}: ${رنگ}`);
}
// 0: سرخ
// 1: سبز
// 2: نیلا
// 3: پیلا

// Start enumeration at 1
کے_لیے (متغیر [i, نام] کا گنو(["احمد", "فاطمہ", "علی"], 1)) {
    لکھو(`${i}. ${نام}`);
}
// 1. احمد
// 2. فاطمہ
// 3. علی

// Find index of max value
مستقل اعداد = [3, 7, 2, 9, 1, 5];
متغیر زیادہ_اشاریہ = 0;

کے_لیے (متغیر [i, n] کا گنو(اعداد)) {
    اگر (n > اعداد[زیادہ_اشاریہ]) {
        زیادہ_اشاریہ = i;
    }
}
لکھو(`سب سے بڑی قدر ${اعداد[زیادہ_اشاریہ]} اشاریہ ${زیادہ_اشاریہ} پر ہے`);
// سب سے بڑی قدر 9 اشاریہ 3 پر ہے

---

Nested Loops — گھنے حلقے

Loops can be nested to any depth.

اردو: حلقوں کو ایک دوسرے کے اندر رکھا جا سکتا ہے — یہ دو جہتی ڈھانچوں جیسے میٹرکس، جدول اور گرڈ کے لیے بہت مفید ہے۔

Multiplication table:

کے_لیے (متغیر i کا حد(1, 6)) {
    متغیر سطر = "";
    کے_لیے (متغیر j کا حد(1, 6)) {
        سطر += متن(i * j).padStart(4, " ");
    }
    لکھو(سطر);
}

Star pattern:

کے_لیے (متغیر i کا حد(1, 6)) {
    لکھو("*".دہراؤ(i));
}
// *
// **
// ***
// ****
// *****

Search in 2D grid:

مستقل گرڈ = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

مستقل ہدف = 6;
متغیر ملا = جھوٹ;

بیرونی: کے_لیے (متغیر [r, سطر] کا گنو(گرڈ)) {
    کے_لیے (متغیر [c, قدر] کا گنو(سطر)) {
        اگر (قدر === ہدف) {
            لکھو(`${ہدف} ملا: سطر ${r}، کالم ${c}`);
            ملا = سچ;
            ٹوٹنا بیرونی;
        }
    }
}
اگر (!ملا) لکھو("نہیں ملا");

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

---

Practical Examples — عملی مثالیں

FizzBuzz — فزبز

کے_لیے (متغیر i کا حد(1, 101)) {
    اگر (i % 15 === 0) {
        لکھو("فزبز");
    } ورنہ_اگر (i % 3 === 0) {
        لکھو("فز");
    } ورنہ_اگر (i % 5 === 0) {
        لکھو("بز");
    } ورنہ {
        لکھو(i);
    }
}

اردو: فزبز ایک مشہور پروگرامنگ مسئلہ ہے: 1 سے 100 تک گنو، جو 3 سے تقسیم ہو وہاں "فز"، جو 5 سے تقسیم ہو وہاں "بز"، اور جو دونوں سے ہو وہاں "فزبز" لکھو۔

Process items until done — کام مکمل ہونے تک

مستقل قطار = ["کام 1", "کام 2", "کام 3"];

جبکہ (قطار.لمبائی > 0) {
    متغیر کام = قطار.پہلا_نکالو();
    لکھو(`کررہا ہوں: ${کام}`);
}
لکھو("تمام کام مکمل");

Collect unique characters — منفرد حروف جمع کریں

متغیر متن_شے = "اردو پروگرامنگ";
متغیر منفرد_حروف = مجموعہ();

کے_لیے (متغیر حرف کا متن_شے) {
    اگر (حرف !== " ") {
        منفرد_حروف.add(حرف);
    }
}

لکھو(`منفرد حروف: ${[...منفرد_حروف].جوڑو(", ")}`);

اردو: متن میں سے منفرد حروف نکالنا — مجموعہ دہرے حروف خودبخود ہٹا دیتا ہے!

Grade report — گریڈ رپورٹ

مستقل طلباء = [
    { نام: "احمد", نمبرات: [75, 82, 90, 68] },
    { نام: "فاطمہ", نمبرات: [95, 88, 92, 97] },
    { نام: "علی", نمبرات: [50, 55, 48, 60] }
];

کے_لیے (متغیر طالب_علم کا طلباء) {
    مستقل { نام, نمبرات } = طالب_علم;
    مستقل اوسط = مجموع(نمبرات) / نمبرات.لمبائی;

    متغیر درجہ;
    اگر (اوسط >= 90)       درجہ = "A+";
    ورنہ_اگر (اوسط >= 80) درجہ = "A";
    ورنہ_اگر (اوسط >= 70) درجہ = "B";
    ورنہ_اگر (اوسط >= 60) درجہ = "C";
    ورنہ                   درجہ = "F";

    لکھو(`${نام}: اوسط ${گول(اوسط, 1)} — درجہ ${درجہ}`);
}
// احمد: اوسط 78.8 — درجہ B
// فاطمہ: اوسط 93.0 — درجہ A+
// علی: اوسط 53.3 — درجہ F

اردو: یہ مثال کئی چیزیں ایک ساتھ دکھاتی ہے: شے توڑنا، اوسط نکالنا، شرطی بیانات سے گریڈ دینا۔ یہ اسکول کے نظام کا ایک آسان اردو پروگرام ہے۔