Functions — فنکشن

Functions are reusable blocks of code that accept inputs and return outputs. The Urdu Programming Language supports all modern function forms including arrow functions, generators, closures, and async functions.

اردو: فنکشن دوبارہ قابلِ استعمال کوڈ کے بلاک ہیں جو ان پٹ قبول کرتے اور آؤٹ پٹ واپس کرتے ہیں۔ اردو پروگرامنگ لینگویج تمام جدید فنکشن اشکال کی حمایت کرتی ہے — تیر فنکشن، جنریٹرز، بندش (closures) اور غیر_متزامن (async) فنکشن سمیت۔

Basic Function Declaration
Parameters and Arguments
Default Parameters
Rest Parameters
واپس — Return Values
Multiple Return Values
Arrow Functions
Anonymous Functions
First-Class Functions
Callbacks
Closures
Recursive Functions
Generator Functions
Immediately Invoked Functions (IIFE)
Variable Number of Arguments
Practical Examples

Basic Function Declaration — بنیادی فنکشن اعلان

Syntax:

فنکشن نام(پیرامیٹر1, پیرامیٹر2) {
    // فنکشن کا جسم
    واپس نتیجہ;
}

اردو: فنکشن بنانے کے لیے فنکشن کلیدی لفظ، پھر نام، پھر قوسین میں پیرامیٹرز، اور آخر میں گھنگھریالی قوسین میں جسم لکھیں۔ واپس سے قدر واپس کریں۔

فنکشن سلام(نام) {
    واپس `مرحبا، ${نام}!`;
}

لکھو(سلام("احمد"));    // مرحبا، احمد!
لکھو(سلام("فاطمہ"));   // مرحبا، فاطمہ!

// Function with no return — returns undefined implicitly
فنکشن اطلاع_دو(پیغام) {
    لکھو(`[اطلاع] ${پیغام}`);
}

اطلاع_دو("سرور شروع ہو گیا");
// [اطلاع] سرور شروع ہو گیا

// Functions are hoisted — can be called before declaration
لکھو(مربع(5));    // 25

فنکشن مربع(n) {
    واپس n * n;
}

اردو: فنکشنز "اٹھائے" (hoisted) جاتے ہیں — یعنی فنکشن اعلان سے پہلے بھی کال کیا جا سکتا ہے۔ اگر واپس نہ لکھیں تو فنکشن غیر_معرف واپس کرتا ہے۔

Parameters and Arguments — پیرامیٹرز اور دلائل

Parameters are the names in the function definition. Arguments are the values passed when calling.

اردو: پیرامیٹرز فنکشن کی تعریف میں نام ہیں — یہ خالی جگہیں ہیں۔ دلائل وہ قدریں ہیں جو کال کرتے وقت بھیجی جاتی ہیں — یہ اصل قدریں ہیں۔

فنکشن جمع(الف, ب) {
    واپس الف + ب;
}

لکھو(جمع(3, 7));      // 10
لکھو(جمع(100, 200));  // 300

Extra arguments are ignored; missing ones become غیر_معرف:

فنکشن معلومات(نام, عمر, شہر) {
    لکھو(`${نام}, ${عمر}, ${شہر}`);
}

معلومات("علی", 25, "کراچی");     // علی, 25, کراچی
معلومات("فاطمہ", 30);             // فاطمہ, 30, undefined
معلومات("زید", 22, "لاہور", "extra");  // زید, 22, لاہور

اردو: زیادہ دلائل نظرانداز ہو جاتے ہیں؛ جو نہ دیے جائیں وہ غیر_معرف ہو جاتے ہیں۔ یہ سمجھنا ضروری ہے کیونکہ یہ غلطی نہیں دیتا بلکہ خاموشی سے غیر_معرف رکھتا ہے۔

Default Parameters — پہلے سے طے پیرامیٹرز

If an argument is not provided or is غیر_معرف, the default value is used.

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

فنکشن سلام(نام = "دوست", وقت = "صبح") {
    واپس `${وقت} بخیر، ${نام}!`;
}

لکھو(سلام());                    // صبح بخیر، دوست!
لکھو(سلام("مریم"));              // صبح بخیر، مریم!
لکھو(سلام("طارق", "شام"));       // شام بخیر، طارق!

// Default can reference earlier parameters
فنکشن آئتہ(چوڑائی, اونچائی = چوڑائی) {
    واپس چوڑائی * اونچائی;
}

لکھو(آئتہ(5));       // 25  (5 × 5 square)
لکھو(آئتہ(4, 6));    // 24

// Default can be an expression or function call
فنکشن ٹائم_اسٹامپ(وقت = وقت()) {
    واپس `تخلیق: ${وقت}`;
}

اردو: پہلے سے طے قدر ایک اظہار یا فنکشن کال بھی ہو سکتی ہے — یہ ہر بار فنکشن کال پر چلتی ہے۔

Rest Parameters — باقی پیرامیٹرز

... before the last parameter collects all remaining arguments into an array.

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

فنکشن مجموع_قدر(...اعداد) {
    واپس اعداد.کم_کرو((جمع, n) => جمع + n, 0);
}

لکھو(مجموع_قدر(1, 2, 3));           // 6
لکھو(مجموع_قدر(10, 20, 30, 40));    // 100
لکھو(مجموع_قدر());                  // 0

// Rest after regular parameters
فنکشن لاگ(سطح, ...پیغامات) {
    کے_لیے (متغیر پیغام کا پیغامات) {
        لکھو(`[${سطح}] ${پیغام}`);
    }
}

لاگ("معلومات", "سرور شروع", "پورٹ 3000");
// [معلومات] سرور شروع
// [معلومات] پورٹ 3000

اردو: باقی پیرامیٹر کو ہمیشہ آخر میں لکھیں۔ اس سے پہلے عام پیرامیٹرز ہو سکتے ہیں — جیسے لاگ(سطح, ...پیغامات) میں سطح پہلا پیرامیٹر ہے اور باقی سب پیغامات میں جاتے ہیں۔

واپس — Return Values

واپس immediately exits the function and returns a value. Without واپس, the function returns غیر_معرف.

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

فنکشن درجہ(سکور) {
    اگر (سکور >= 90) واپس "A+";
    اگر (سکور >= 80) واپس "A";
    اگر (سکور >= 70) واپس "B";
    اگر (سکور >= 60) واپس "C";
    واپس "F";
}

لکھو(درجہ(95));    // A+
لکھو(درجہ(72));    // B
لکھو(درجہ(45));    // F

Multiple Return Values — متعدد واپسی قدریں

Return an array or object to send back more than one value.

اردو: فنکشن سے ایک سے زیادہ قدریں واپس کرنے کے لیے فہرست یا شے استعمال کریں، پھر پانے والی طرف توڑ کر الگ متغیرات میں رکھیں۔

// Via array destructuring
فنکشن کم_زیادہ(اعداد) {
    واپس [کم(...اعداد), زیادہ(...اعداد)];
}

متغیر [سب_سے_کم, سب_سے_زیادہ] = کم_زیادہ([4, 8, 2, 9, 1]);
لکھو(سب_سے_کم);      // 1
لکھو(سب_سے_زیادہ);   // 9

// Via object destructuring
فنکشن شماریات(اعداد) {
    مستقل n = اعداد.لمبائی;
    مستقل مجموع_قدر = مجموع(اعداد);
    مستقل اوسط_قدر = مجموع_قدر / n;
    واپس { مجموع_قدر, اوسط_قدر, n, کم: کم(...اعداد), زیادہ: زیادہ(...اعداد) };
}

متغیر { مجموع_قدر, اوسط_قدر } = شماریات([1, 2, 3, 4, 5]);
لکھو(مجموع_قدر);    // 15
لکھو(اوسط_قدر);     // 3

Arrow Functions — تیر فنکشن

Arrow functions provide a compact syntax. They are always anonymous expressions.

اردو: تیر فنکشن مختصر نحو فراہم کرتے ہیں۔ یہ ہمیشہ گمنام اظہار ہوتے ہیں۔ چھوٹے فنکشن اور کال بیک کے لیے بہت مفید ہیں۔

Syntax forms:

// Single expression — implicit return
مستقل مربع = n => n * n;

// Multiple parameters
مستقل جمع = (الف, ب) => الف + ب;

// No parameters
مستقل ہیلو = () => "مرحبا!";

// Block body — explicit return required
مستقل مطلق = n => {
    اگر (n < 0) واپس -n;
    واپس n;
};

لکھو(مربع(6));       // 36
لکھو(جمع(3, 4));     // 7
لکھو(ہیلو());        // مرحبا!
لکھو(مطلق(-5));      // 5

اردو: اگر تیر فنکشن میں صرف ایک اظہار ہو تو واپس ضمنی ہے — کرلی قوسین بھی نہیں چاہیے۔ ایک پیرامیٹر کے لیے قوسین بھی ضروری نہیں۔ بلاک جسم والے فنکشن میں واپس لکھنا پڑتا ہے۔

Arrow functions with arrays:

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

مستقل مربعات = اعداد.تبدیل(n => n ** 2);
مستقل جفت = اعداد.چھانو(n => n % 2 === 0);
مستقل مجموع_قدر = اعداد.کم_کرو((acc, n) => acc + n, 0);

لکھو(مربعات);      // [1, 4, 9, 16, 25, 36, 49, 64]
لکھو(جفت);         // [2, 4, 6, 8]
لکھو(مجموع_قدر);   // 36

Anonymous Functions — گمنام فنکشن

Functions without names, assigned to variables or passed directly.

اردو: گمنام فنکشن وہ ہیں جن کا کوئی نام نہیں — انہیں متغیر میں رکھا جاتا ہے یا سیدھا کسی اور فنکشن کو بھیجا جاتا ہے۔

// Assigned to variable
مستقل خوش_آمدید = فنکشن(نام) {
    واپس `خوش آمدید، ${نام}!`;
};

لکھو(خوش_آمدید("احمد"));    // خوش آمدید، احمد!

// Passed directly
[1, 2, 3].ہر_ایک(فنکشن(n) {
    لکھو(n * 10);
});
// 10 20 30

First-Class Functions — اوّل درجہ فنکشن

Functions are values — they can be stored, passed, and returned.

اردو: اردو پروگرامنگ لینگویج میں فنکشن "اوّل درجہ" قدریں ہیں — انہیں متغیر میں رکھا، دوسرے فنکشن کو بھیجا اور فنکشن سے واپس کیا جا سکتا ہے۔ یہ فنکشنل پروگرامنگ کی بنیاد ہے۔

// Store in object
مستقل کیلکولیٹر = {
    جمع: (الف, ب) => الف + ب,
    تفریق: (الف, ب) => الف - ب,
    ضرب: (الف, ب) => الف * ب,
    تقسیم: (الف, ب) => الف / ب
};

لکھو(کیلکولیٹر.جمع(10, 5));      // 15
لکھو(کیلکولیٹر.تقسیم(20, 4));    // 5

// Store in array
مستقل تبدیلیاں = [
    n => n + 1,
    n => n * 2,
    n => n ** 2
];

متغیر قدر = 3;
کے_لیے (مستقل تبدیلی کا تبدیلیاں) {
    قدر = تبدیلی(قدر);
}
لکھو(قدر);    // ((3+1)*2)^2 = 64

// Return a function from a function (factory)
فنکشن ضرب_ساز(عامل) {
    واپس n => n * عامل;
}

مستقل دو_گنا = ضرب_ساز(2);
مستقل تین_گنا = ضرب_ساز(3);

لکھو(دو_گنا(7));    // 14
لکھو(تین_گنا(7));   // 21

اردو: "فنکشن فیکٹری" — ایک فنکشن جو دوسرے فنکشن بناتا ہے۔ ضرب_ساز(2) ایسا فنکشن واپس کرتا ہے جو کسی بھی عدد کو دو سے ضرب دیتا ہے۔

Callbacks — کال بیک

A callback is a function passed to another function to be called later.

اردو: کال بیک وہ فنکشن ہے جو کسی دوسرے فنکشن کو بھیجا جاتا ہے تاکہ بعد میں بلایا جائے۔ فہرست کے طریقے جیسے چھانو، تبدیل، کم_کرو سب کال بیک استعمال کرتے ہیں۔

فنکشن پروسیس_کرو(ڈیٹا, کال_بیک) {
    لکھو("پروسیسنگ...");
    مستقل نتیجہ = کال_بیک(ڈیٹا);
    لکھو(`نتیجہ: ${نتیجہ}`);
}

پروسیس_کرو(5, n => n * n);
// پروسیسنگ...
// نتیجہ: 25

پروسیس_کرو("اردو", s => s.بڑے_حروف());
// پروسیسنگ...
// نتیجہ: اردو

// Array method callbacks
مستقل طلباء = [
    { نام: "احمد", سکور: 75 },
    { نام: "بیا",  سکور: 92 },
    { نام: "ثمر",  سکور: 55 },
    { نام: "دانیہ", سکور: 88 }
];

مستقل پاس = طلباء.چھانو(ط => ط.سکور >= 60);
مستقل ترتیب_شدہ = طلباء.ترتیب_دو(ط => -ط.سکور);
مستقل نام_جات = طلباء.تبدیل(ط => ط.نام);

لکھو(پاس.لمبائی);         // 3
لکھو(ترتیب_شدہ[0].نام);   // بیا   (highest score first)
لکھو(نام_جات);             // ["احمد", "بیا", "ثمر", "دانیہ"]

Closures — بندش

A closure is a function that "remembers" variables from the outer scope where it was created.

اردو: بندش (closure) وہ فنکشن ہے جو اپنے بنائے جانے کی جگہ کے بیرونی دائرے (outer scope) کے متغیرات "یاد" رکھتا ہے — چاہے وہ بیرونی فنکشن ختم ہو گیا ہو۔ یہ نجی حالت (private state) بنانے کا طریقہ ہے۔

فنکشن گنتی_ساز() {
    متغیر گنتی = 0;

    واپس {
        اضافہ: () => ++گنتی,
        کمی:   () => --گنتی,
        دیکھو: () => گنتی
    };
}

مستقل گنتی = گنتی_ساز();
گنتی.اضافہ();
گنتی.اضافہ();
گنتی.اضافہ();
لکھو(گنتی.دیکھو());    // 3
گنتی.کمی();
لکھو(گنتی.دیکھو());    // 2

// Closure for private state
فنکشن بینک_کھاتہ(ابتدائی_رقم = 0) {
    متغیر رقم = ابتدائی_رقم;

    واپس {
        جمع_کرو: (n) => { رقم += n; لکھو(`جمع: ${n}، بقیہ: ${رقم}`); },
        نکالو:   (n) => {
            اگر (n > رقم) { لکھو("ناکافی رقم"); واپس; }
            رقم -= n;
            لکھو(`نکالا: ${n}، بقیہ: ${رقم}`);
        },
        بقیہ: () => رقم
    };
}

مستقل کھاتہ = بینک_کھاتہ(1000);
کھاتہ.جمع_کرو(500);      // جمع: 500، بقیہ: 1500
کھاتہ.نکالو(200);        // نکالا: 200، بقیہ: 1300
لکھو(کھاتہ.بقیہ());     // 1300

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

Recursive Functions — بازگشت فنکشن

A recursive function calls itself. Every recursion needs a base case to stop.

اردو: بازگشت (recursive) فنکشن خود کو بلاتا ہے۔ ہر بازگشت کو رکنے کے لیے ایک بنیادی صورت (base case) چاہیے — ورنہ لامتناہی چلتا رہے گا۔

// Factorial
فنکشن فیکٹوریل(n) {
    اگر (n <= 1) واپس 1;
    واپس n * فیکٹوریل(n - 1);
}

لکھو(فیکٹوریل(5));    // 120
لکھو(فیکٹوریل(10));   // 3628800

// Fibonacci
فنکشن فبوناچی(n) {
    اگر (n <= 1) واپس n;
    واپس فبوناچی(n - 1) + فبوناچی(n - 2);
}

کے_لیے (متغیر i کا حد(8)) {
    لکھو(فبوناچی(i));
}
// 0 1 1 2 3 5 8 13

اردو: فیکٹوریل: n! = n × (n-1)! — بنیادی صورت n <= 1 پر واپس 1۔ فبوناچی: ہر عدد پچھلے دو کا مجموع — بنیادی صورت n <= 1۔

// Flatten nested array recursively
فنکشن چپٹا_کرو(فہرست) {
    مستقل نتیجہ = [];
    کے_لیے (مستقل شے کا فہرست) {
        اگر (Array.ہے(شے)) {
            کے_لیے (مستقل عنصر کا چپٹا_کرو(شے)) {
                نتیجہ.شامل(عنصر);
            }
        } ورنہ {
            نتیجہ.شامل(شے);
        }
    }
    واپس نتیجہ;
}

لکھو(چپٹا_کرو([1, [2, [3, [4]], 5]]));
// [1, 2, 3, 4, 5]

// Binary search (recursive)
فنکشن بائنری_تلاش(فہرست, ہدف, شروع = 0, آخر = فہرست.لمبائی - 1) {
    اگر (شروع > آخر) واپس -1;

    مستقل درمیان = شروع + ریاضی.فرش((آخر - شروع) / 2);

    اگر (فہرست[درمیان] === ہدف) واپس درمیان;
    اگر (فہرست[درمیان] < ہدف)   واپس بائنری_تلاش(فہرست, ہدف, درمیان + 1, آخر);
                                  واپس بائنری_تلاش(فہرست, ہدف, شروع, درمیان - 1);
}

مستقل اعداد = [1, 3, 5, 7, 9, 11, 13];
لکھو(بائنری_تلاش(اعداد, 7));    // 3
لکھو(بائنری_تلاش(اعداد, 6));    // -1

Generator Functions — جنریٹر فنکشن

Generator functions use فنکشن* syntax and produce values one at a time with پیداوار.

اردو: جنریٹر فنکشن فنکشن* نحو استعمال کرتے ہیں اور پیداوار سے قدریں ایک ایک کر کے بناتے ہیں۔ یہ بڑے ڈیٹا سیٹس کے لیے موزوں ہیں — سب کچھ یاداشت میں نہیں رکھتے۔

فنکشن* گنتی_کار(شروع, آخر) {
    کے_لیے (متغیر i کا حد(شروع, آخر + 1)) {
        پیداوار i;
    }
}

مستقل جنریٹر = گنتی_کار(1, 5);

لکھو(جنریٹر.اگلا());    // { value: 1, done: false }
لکھو(جنریٹر.اگلا());    // { value: 2, done: false }
لکھو(جنریٹر.اگلا());    // { value: 3, done: false }

// Or iterate with for...of
کے_لیے (متغیر n کا گنتی_کار(1, 5)) {
    لکھو(n);
}
// 1 2 3 4 5

// Infinite generator
فنکشن* لامتناہی_گنتی(n = 0) {
    جبکہ (سچ) {
        پیداوار n++;
    }
}

مستقل جنریٹر = لامتناہی_گنتی();
کے_لیے (متغیر _ کا حد(5)) {
    لکھو(جنریٹر.اگلا().value);
}
// 0 1 2 3 4

// Generator with return value
فنکشن* پیداوار_دو() {
    پیداوار "پہلا";
    پیداوار "دوسرا";
    واپس "مکمل";
}

مستقل g = پیداوار_دو();
لکھو(g.اگلا());    // { value: "پہلا",  done: false }
لکھو(g.اگلا());    // { value: "دوسرا", done: false }
لکھو(g.اگلا());    // { value: "مکمل",  done: true  }

اردو: done: true آنے پر جنریٹر ختم ہو گیا۔ واپس والی آخری قدر done: true کے ساتھ آتی ہے۔

Immediately Invoked Functions (IIFE) — فوری چلنے والے فنکشن

An IIFE is defined and called in one expression. Useful for creating a private scope.

اردو: IIFE فنکشن کو بنانے اور فوری چلانے کا طریقہ ہے — ایک ہی اظہار میں۔ یہ نجی دائرہ بنانے کے لیے مفید ہے۔

// Arrow IIFE
مستقل نتیجہ = (() => {
    متغیر x = 10;
    متغیر y = 20;
    واپس x + y;
})();

لکھو(نتیجہ);    // 30

// Named IIFE for async initialization
(غیر_متزامن فنکشن ابتدائیہ() {
    لکھو("ایپلیکیشن شروع ہو رہی ہے...");
    انتظار تاخیر(100);
    لکھو("ابتدائیہ مکمل");
})();

Variable Number of Arguments — متغیر تعداد دلائل

Three patterns for handling a flexible number of arguments:

اردو: لچکدار تعداد کے دلائل سنبھالنے کے تین طریقے ہیں — باقی پیرامیٹرز، سپریڈ، یا فہرست پیرامیٹر۔

1. Rest parameters (recommended):

فنکشن اوسط(...اعداد) {
    اگر (اعداد.لمبائی === 0) واپس 0;
    واپس مجموع(اعداد) / اعداد.لمبائی;
}

لکھو(اوسط(10, 20));           // 15
لکھو(اوسط(1, 2, 3, 4, 5));    // 3

2. Spread to pass array as args:

مستقل اعداد = [3, 1, 4, 1, 5, 9, 2];
لکھو(زیادہ(...اعداد));    // 9
لکھو(کم(...اعداد));      // 1

3. Array parameter:

فنکشن جدول_بنائیں(عنوانات, سطریں) {
    لکھو(عنوانات.جوڑو(" | "));
    لکھو("-".دہراؤ(40));
    کے_لیے (مستقل سطر کا سطریں) {
        لکھو(سطر.جوڑو(" | "));
    }
}

جدول_بنائیں(
    ["نام", "عمر", "شہر"],
    [["احمد", "25", "کراچی"], ["فاطمہ", "30", "لاہور"]]
);

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

Memoization — یاداشت (cache function results)

فنکشن میمو(فنکشن_شے) {
    مستقل کیش = {};
    واپس (...پیرامیٹر) => {
        مستقل کلید = JSON_لکھو(پیرامیٹر);
        اگر (کلید میں_ہے کیش) {
            لکھو("کیش سے ملا");
            واپس کیش[کلید];
        }
        مستقل نتیجہ = فنکشن_شے(...پیرامیٹر);
        کیش[کلید] = نتیجہ;
        واپس نتیجہ;
    };
}

مستقل تیز_فبوناچی = میمو(فنکشن f(n) {
    اگر (n <= 1) واپس n;
    واپس تیز_فبوناچی(n - 1) + تیز_فبوناچی(n - 2);
});

لکھو(تیز_فبوناچی(40));    // very fast

اردو: یاداشت (memoization) نتائج محفوظ کرتی ہے — اگر وہی پیرامیٹر پہلے سے حساب ہو چکے ہوں تو دوبارہ حساب نہیں کرتی، کیش سے واپس کرتی ہے۔ فبوناچی جیسے مہنگے حسابات کے لیے بہت مفید!

Pipe / compose — پائپ / ترکیب

// pipe — left to right
فنکشن پائپ(...فنکشن_جات) {
    واپس (قدر) => فنکشن_جات.کم_کرو((acc, fn) => fn(acc), قدر);
}

مستقل پروسیس = پائپ(
    n => n * 2,
    n => n + 10,
    n => n ** 2
);

لکھو(پروسیس(5));    // ((5*2)+10)^2 = 400

اردو: پائپ فنکشن قدر کو بائیں سے دائیں تمام فنکشنوں سے گزارتا ہے — پہلے دو سے ضرب، پھر 10 جمع، پھر مربع۔ فنکشنل پروگرامنگ کا طاقتور نمونہ!

Debounce — تاخیر

فنکشن ڈیبونس(فنکشن_شے, تاخیر_قدر = 300) {
    متغیر ٹائمر;
    واپس (...پیرامیٹر) => {
        clearTimeout(ٹائمر);
        ٹائمر = setTimeout(() => فنکشن_شے(...پیرامیٹر), تاخیر_قدر);
    };
}

مستقل تلاش = ڈیبونس((سوال) => لکھو(`تلاش: ${سوال}`), 500);
// Only fires 500ms after the last call

اردو: ڈیبونس فنکشن کو صرف آخری کال کے بعد مقررہ وقت (500ms) گزرنے پر چلاتا ہے۔ سرچ باکس میں ٹائپنگ کے دوران ہر حرف پر سرور کال نہ کرنے کے لیے یہ بہت مفید ہے۔