گولانگ جنرک مثالیں۔

Gwlang Jnrk Mthaly



گولانگ کی عمومی خصوصیت دوبارہ قابل استعمال کوڈ بنانا ممکن بناتی ہے جو ٹائپ کے لیے محفوظ اور مختلف اقسام کے ساتھ ہم آہنگ ہو۔ خوش قسمتی سے، گو میں جنرک کا اضافہ کوڈ کے دوبارہ استعمال اور لچک کے لیے نئی راہیں کھولتا ہے۔ گولانگ کا تازہ ترین ورژن اپنے ساتھ جنرک کے لیے انتہائی متوقع تعاون لاتا ہے۔

مزید اہم بات یہ ہے کہ جنرکس گو کی مضبوط قسم کی حفاظت کو برقرار رکھتی ہے جو مرتب وقت پر جامد قسم کی جانچ کو قابل بناتی ہے اور قسم کی درستگی کو یقینی بناتی ہے۔ وہ عام کوڈ کے اندر ایک معیاری غلطی سے نمٹنے کے لیے فراہم کرتے ہیں جو وضاحت اور برقرار رکھنے کی صلاحیت کو بہتر بناتا ہے۔ مزید برآں، وہ عام کوڈ کے اندر ایک معیاری غلطی سے نمٹنے کی سہولت فراہم کرتے ہیں جو وضاحت اور برقراری کو بہتر بناتا ہے۔ اس پوسٹ میں، ہم کئی حقیقی دنیا کی Go generics ایپلی کیشنز اور مثالوں کا جائزہ لیں گے۔

مثال 1: گولانگ جنرک فنکشن کا استعمال

جنرک کے لیے بنیادی استعمال کے معاملات میں سے ایک ایسے فنکشنز بنانا ہے جو مختلف اقسام پر کام کر سکیں۔ یہاں، ہم ان مثالوں میں سے ایک کے ساتھ جاتے ہیں جہاں عام فریم فنکشن استعمال ہوتا ہے۔







پیکج مرکزی
درآمد 'fmt'
func فریم [ r int | float32 ]( رداس r ) {
c := 3 * 2 * رداس
ایف ایم ٹی . پرنٹ ایل این ( 'عام فریم ہے:' ، c )
}
func مرکزی () {
تھا r1 int = 7
تھا r2 float32 = 7 . 5
فریم ( r1 )
فریم ( r2 )
}

پچھلے کوڈ کے شروع میں، لائن 'fmt' پیکیج کو درآمد کرتی ہے جو فارمیٹ شدہ I/O کے لیے فنکشن فراہم کرتا ہے، بشمول کنسول پر آؤٹ پٹ پرنٹ کرنا۔ پھر، ہم 'دائرہ' نامی ایک عام فنکشن کی وضاحت کرتے ہیں جو ایک عام قسم 'r' کا پیرامیٹر رداس لیتا ہے جو یا تو 'int' یا 'float32' ہوسکتا ہے۔ فنکشن کے اندر، یہ رداس کو '3' کی مستقل قدر سے اور پھر اسے '2' سے ضرب دے کر فریم کا حساب لگاتا ہے۔ آخر میں، یہ 'fmt.Println' کا استعمال کرتے ہوئے حسابی فریم پرنٹ کرتا ہے۔



اگلا، ہمارے پاس مرکزی فنکشن ہے جہاں دو متغیرات، r1 اور r2، بالترتیب 7 اور 7.5 کی قدروں کے ساتھ اعلان اور تفویض کیے گئے ہیں۔ اس کے بعد، r1 اور r2 کو آرگومینٹس کے طور پر پاس کرتے ہوئے، دو بار 'طواف' فنکشن کو پکارا جاتا ہے۔



آؤٹ پٹ دائروں کے فریم کو درج ذیل میں پرنٹ کرکے حساب دکھاتا ہے۔





مثال 2: گولانگ جنرک انٹرفیس کا استعمال

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



پیکج مرکزی
درآمد 'fmt'
قسم EmpAge انٹرفیس {
int64 | int32 | float32 | float64
}
func newGenericFunc [ عمر کی عمر ]( emp_Age کی عمر ) {
val := int ( emp_عمر ) + 1
ایف ایم ٹی . پرنٹ ایل این ( val )
}
func مرکزی () {
ایف ایم ٹی . پرنٹ ایل این ( 'ملازمین کی عمر' )
تھا عمر 1 int64 = 24
تھا عمر 2 float64 = 25 . 5
newGenericFunc ( عمر 1 )
newGenericFunc ( عمر 2 )
}

پچھلے سورس کوڈ میں، ہم نے 'EmpAge' نام کے ایک انٹرفیس کی وضاحت کی ہے جو ملازم کی عمر کے لیے ممکنہ اقسام کی وضاحت کرتا ہے۔ انٹرفیس میں int64، int32، float32، اور float64 اقسام شامل ہیں۔ یہ انٹرفیس 'عام' فنکشن کو ان میں سے کسی بھی قسم کو بطور دلیل قبول کرنے کی اجازت دیتا ہے۔ اس کے بعد، ہم newGenericFunc نامی ایک عام فنکشن استعمال کرتے ہیں جو عمر کی ایک عام قسم کا emp_Age پیرامیٹر لیتا ہے جو کسی بھی قسم کا ہو سکتا ہے جو EmpAge انٹرفیس کو مطمئن کرتا ہے۔ فنکشن کے اندر، یہ emp_Age کو ایک int میں تبدیل کرتا ہے اور اسے 1 تک بڑھاتا ہے جیسا کہ دکھایا گیا ہے۔

اگلا، ہم دو متغیرات، Age1 اور Age2 کا اعلان کرتے ہیں، اور مین فنکشن میں بالترتیب 24 اور 25.5 کی قدریں تفویض کرتے ہیں۔ اس کے بعد، Age1 اور Age2 کو پیرامیٹرز کے طور پر newGenericFunc فنکشن میں منتقل کیا جاتا ہے جس پر دو بار عمل درآمد ہوتا ہے۔ اس کے ساتھ، عمروں کو 1 تک بڑھایا جاتا ہے اور اپ ڈیٹ شدہ قدریں پیدا ہوتی ہیں۔

مندرجہ ذیل میں جو آؤٹ پٹ حاصل ہوتا ہے وہ عام فنکشن کی عمریں ہیں جو انٹرفیس کو استعمال کرتی ہیں:

مثال 3: گولانگ جنرک ڈیٹا سٹرکچر کا استعمال

مزید برآں، Go generics ہمیں اعداد و شمار کے عمومی ڈھانچے جیسے اسٹیک، قطار، اور منسلک فہرستیں بنانے کی صلاحیت بھی فراہم کرتا ہے۔ مندرجہ ذیل میں عام اسٹیک کے نفاذ پر غور کریں:

درآمد 'fmt'
قسم اسٹیک [ T کوئی بھی ] [ ] ٹی
func ( st * اسٹیک [ ٹی ]) دھکا ( آئٹم ٹی ) {
st = شامل کریں ( * st ، آئٹم )
}
func ( st * اسٹیک [ ٹی ]) پاپ () ٹی {
اگر صرف ( * st ) == 0 {
خوف و ہراس ( 'اسٹیک میں کچھ نہیں' )
}
انڈیکس := صرف ( * st ) - 1
آئٹم := ( * st )[ انڈیکس ]
* st = ( * st )[: انڈیکس ]
واپسی آئٹم
}
func مرکزی () {
اسٹیک := نئی ( اسٹیک [ int ])
اسٹیک . دھکا ( 1 )
اسٹیک . دھکا ( 2 )
اسٹیک . دھکا ( 3 )
ایف ایم ٹی . پرنٹ ایل این ( اسٹیک . پاپ ())
ایف ایم ٹی . پرنٹ ایل این ( اسٹیک . پاپ ())
ایف ایم ٹی . پرنٹ ایل این ( اسٹیک . پاپ ())
}

پچھلے کوڈ میں، 'اسٹیک' کے عنوان سے ایک عام قسم کی وضاحت کی گئی ہے جو اسٹیک کی نمائندگی کرتی ہے۔ 'T' پلیس ہولڈر اسٹیک کو کسی بھی قسم کے عناصر کو رکھنے کی اجازت دیتا ہے۔ 'اسٹیک' قسم کو 'T' قسم کے عناصر کے ٹکڑے کے طور پر لاگو کیا جاتا ہے۔ یہاں، 'اسٹیک' قسم کے لیے دو فنکشنز تعینات کیے گئے ہیں: 'پش' اور 'پاپ۔' پش() فنکشن عناصر کو اسٹیک میں شامل کرنے کا ذمہ دار ہے۔ یہ 'T' قسم کی ایک دلیل آئٹم لیتا ہے اور اسے append() فنکشن کا استعمال کرتے ہوئے بنیادی سلائس میں شامل کرتا ہے۔

جب کہ Pop() فنکشن اسٹیک سے ابتدائی جز لیتا ہے اور اسے واپس کرتا ہے، یہ سب سے پہلے اس بات کا تعین کرتا ہے کہ آیا اسٹیک خالی ہے یا نہیں۔ ایک غلطی کی اطلاع بھیجی جاتی ہے اگر اسٹیک خالی نظر آتا ہے جس سے گھبراہٹ ہوتی ہے۔ بصورت دیگر، یہ سلائس سے آخری عنصر کو بازیافت کرتا ہے، سلائس کو دوسرے سے آخری عنصر تک کاٹ کر اسے اسٹیک سے ہٹاتا ہے، اور ہٹائی گئی چیز کو واپس کرتا ہے۔

اس کے بعد، عدد کا نیا اسٹیک اس کوڈ کے مرکزی فنکشن کے اندر Stack[int] نحو کا استعمال کرتے ہوئے بنایا گیا ہے۔ اس کے بعد، اسٹیک میں عدد 1، 2، اور 3 کو شامل کرنے کے لیے 'پش' کا طریقہ تین بار کہا جاتا ہے۔ تاہم، اسٹیک سے عناصر کو بازیافت اور پرنٹ کرنے کے لیے 'پاپ' طریقہ کو بعد میں تین بار کہا جاتا ہے۔

مندرجہ ذیل آؤٹ پٹ اشارہ کرتا ہے کہ عناصر کو اسٹیک سے ریورس ترتیب میں ہٹا دیا گیا ہے:

مثال 4: گولانگ عام رکاوٹوں کا استعمال

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

پیکج مرکزی
درآمد 'fmt'
قسم عدد انٹرفیس {
int64 | float64
}
func مرکزی () {
فلوٹ ویلیو := [ ] float64 { 2 . 0 ، 4 . 0 ، 6 . 0 ، 8 . 0 ، 10 . 0 }
IntegerValue := [ ] int64 { 2 ، 4 ، 6 ، 8 ، 10 }
sum1 := genericSum ( فلوٹ ویلیو )
sum2 := genericSum ( IntegerValue
ایف ایم ٹی . پرنٹ ایل این ( 'float64 کا مجموعہ :' ، sum1 )
ایف ایم ٹی . پرنٹ ایل این ( 'int64 کا مجموعہ :' ، sum2 )

}
func genericSum [ n عددی ]( نمبرز [ ] n ) n {
تھا میں n ہوں۔
کے لیے _ ، ایک پر := رینج نمبرز {
رقم += ایک پر
}
واپسی رقم
}

پیشگی سورس کوڈ میں، ہم عددی انٹرفیس کو 'Sum' طریقہ سے بیان کرتے ہیں۔ اس کے بعد، ہم دو حسب ضرورت قسمیں بناتے ہیں، 'FloatValue' اور 'IntegerValue'، جو اپنے متعلقہ 'Sum' طریقے فراہم کر کے عددی انٹرفیس کو نافذ کرتے ہیں۔ genericSum فنکشن اب کسی بھی قسم کے ٹکڑوں کو قبول کرنے کے قابل ہے جو عددی انٹرفیس کو مطمئن کرتا ہے۔ فنکشن کے اندر، ہم عناصر پر اعادہ کرتے ہیں اور رقم کا حساب کرنے کے لیے 'Sum' طریقہ کو کال کرتے ہیں۔ آخر میں، مین فنکشن میں، ہم FloatValue اور IntegerValue کے سلائسز بناتے ہیں اور انہیں genericSum() فنکشن میں منتقل کرتے ہیں جو ہر سلائس میں عناصر کے مجموعے کا صحیح حساب لگاتا ہے۔

متوقع آؤٹ پٹ اب درج ذیل اسکرین پر نظر آتا ہے:

نتیجہ

ہم نے Go generics کی کچھ عملی مثالیں دریافت کیں جن میں ایک عام ڈیٹا ڈھانچہ اور عام فنکشن کی تخلیق، ایک عام انٹرفیس کی وضاحت، اور حسب ضرورت قسم کی رکاوٹ کا استعمال شامل ہے۔ یہ مثالیں اس طاقت اور لچک کو ظاہر کرتی ہیں جو گو پروگرامنگ لینگویج میں جنرک لاتی ہے۔ نوٹ کریں کہ تالیف کے دوران جنرک کوڈ جنریشن موثر بائنری سائز اور تالیف کے اوقات کو یقینی بناتا ہے۔