مثال 1: گولانگ خالی انٹرفیس
خالی انٹرفیس سے شروع کریں{} جسے Go میں انٹرفیس کہا جاتا ہے۔ یہ ایک ایسی قسم کی نشاندہی کرتا ہے جو کسی بھی قسم کی قدر کو محفوظ کر سکتی ہے۔ Go میں خالی انٹرفیس کا سورس کوڈ درج ذیل ہے:
پیکج مرکزیدرآمد 'fmt'
قسم مارکس کیلکولیٹر انٹرفیس {}
func مرکزی () {
تھا m مارکس کیلکولیٹر
ایف ایم ٹی . پرنٹ ایل این ( m )
}
یہاں، ہم وہ کوڈ فراہم کرتے ہیں جہاں 'MarksCalculator' انٹرفیس میں کوئی مخصوص طریقہ کے دستخط نہیں ہیں کیونکہ یہ خالی ہے۔ نتیجے کے طور پر، یہ کوئی فعالیت فراہم نہیں کرتا ہے۔ اگلا، ہمارے پاس اس خالی انٹرفیس کا مین() فنکشن ہے جہاں MarksCalculator قسم کا ایک متغیر 'm' اعلان کیا جاتا ہے۔ چونکہ انٹرفیس خالی ہے، اس لیے 'm' کسی بھی قسم کی قدر رکھ سکتا ہے۔ اس صورت میں، 'm' غیر شروع کیا جاتا ہے، لہذا اس کی اپنی قسم کے لیے صفر قدر ہے جو کہ انٹرفیس کے لیے 'nil' ہے۔ جب 'm' کو 'fmt.Println' کا استعمال کرتے ہوئے پرنٹ کیا جاتا ہے تو یہ کنسول میں 'nil' آؤٹ پٹ کرتا ہے۔
بازیافت شدہ آؤٹ پٹ 'nil' ہے جیسا کہ پچھلے سورس کوڈ سے متوقع ہے:
مثال 2: انٹرفیس کا گولانگ نفاذ
یہ سیکشن گولانگ انٹرفیس کے نفاذ کو ظاہر کرتا ہے۔ ایک قسم کو گو میں لاگو کرنے کے لیے ایک انٹرفیس میں ہر ایک مخصوص طریقہ کے لیے نفاذ کی پیشکش کرنی چاہیے۔ انٹرفیس کے نفاذ کے لیے مندرجہ ذیل سورس کوڈ دیا گیا ہے۔
پیکج مرکزی
درآمد (
'fmt'
)
قسم سر انٹرفیس {
سرچ واولز () [ ] رن
}
قسم MyStr تار
func ( • MyStr ) سرچ واولز () [ ] رن {
تھا سر [ ] رن
کے لیے _ , رن := رینج st {
اگر رن == 'a' || رن == 'یہ ہے' || رن == 'میں' || رن == 'او' || رن == 'میں' {
سر = شامل کریں ( سر , رن )
}
}
واپسی سر
}
func مرکزی () {
NewString := MyStr ( 'گو لانگ انٹرفیسز' )
تھا v1 سر
v1 = NewString
ایف ایم ٹی . پرنٹ ایف ( 'سر ہیں %c' , v1 . سرچ واولز ())
}
یہاں، کوڈ 'Vowels' نامی ایک انٹرفیس کی وضاحت کرتا ہے جو ایک واحد طریقہ SearchVowels() کی وضاحت کرتا ہے جو Rune (type int32) کا ایک ٹکڑا واپس کرتا ہے۔ ایک انٹرفیس کسی بھی قسم کو قابل بناتا ہے جو اس طریقہ کار کے دستخط کو انٹرفیس کی قسم کے متغیر کو تفویض کرنے کے لیے لاگو کرتا ہے۔ اس کے بعد، ایک نئی 'MyStr' قسم کا اعلان کیا جاتا ہے جو کہ بنیادی قسم کے سٹرنگ کا عرف ہے۔ اس کا مطلب ہے کہ 'MyStr' کو سٹرنگ کے تمام طریقے وراثت میں ملتے ہیں لیکن یہ ایک الگ قسم ہے۔
اس کے بعد، ہم 'MyStr' قسم کے لیے SearchVowels() طریقہ نافذ کرتے ہیں۔ یہ طریقہ ان پٹ سٹرنگ کیریکٹر کو کریکٹر کے لحاظ سے اسکین کرتا ہے اور چیک کرتا ہے کہ آیا ہر ایک حرف حرف ہے ('a'، 'e'، 'i'، 'o'، یا 'u')۔ اگر کوئی حرف حرف ہے، تو اسے سر کے ٹکڑوں میں جوڑ دیا جاتا ہے۔
مین () فنکشن کے اندر، 'MyStr' قسم کا 'NewString' متغیر 'GoLang Interfaces' ویلیو کے ساتھ بنایا گیا ہے۔ اس کے بعد، 'Vowels' قسم کے 'v1' متغیر کا اعلان کیا جاتا ہے۔ چونکہ 'MyStr' SearchVowels() طریقہ کو نافذ کرتا ہے جو 'Vowels' انٹرفیس میں بیان کیا گیا ہے، 'NewString' کو 'v1' کو تفویض کیا جا سکتا ہے۔
آؤٹ پٹ سروں کی تمام صفوں کو دکھاتا ہے جو مخصوص سٹرنگ میں پائے جاتے ہیں:
مثال 3: گولانگ سٹرنگر انٹرفیس
مزید برآں، گولانگ کے پاس 'fmt' پیکیج میں پہلے سے طے شدہ 'Stringer' انٹرفیس ہے۔ یہ کسٹم قسم کو اجازت دیتا ہے کہ وہ اپنی سٹرنگ کی نمائندگی کو کنٹرول کر سکے جب 'fmt' پیکیج کے پرنٹنگ فنکشنز میں '%v' فعل کے ساتھ فارمیٹ کیا جائے۔ گو کے سٹرنگر انٹرفیس کا مثالی کوڈ درج ذیل ہے:
پیکج مرکزیدرآمد (
'fmt'
)
قسم طالب علم ساخت {
نام تار
ڈگری تار
}
func ( s طالب علم ) تار () تار {
واپسی ایف ایم ٹی . سپرنٹ ایف ( '%s a(n)%s ہے' , s . نام , s . ڈگری )
}
func مرکزی () {
s1 := طالب علم { 'ایلینا گلبرٹ' , 'کمپیوٹر سائنس' }
s2 := طالب علم { 'کیرولین کینڈیس' , 'بی بی اے' }
ایف ایم ٹی . پرنٹ ایل این ( s1 )
ایف ایم ٹی . پرنٹ ایل این ( s2 )
}
یہاں، کوڈ پہلے ضروری پیکیج کو درآمد کرتا ہے جو کنسول پر پرنٹ کرنے کے لیے 'fmt' ہے۔ پھر، ہم دو شعبوں کے ساتھ ایک ڈھانچہ قسم 'طالب علم' کی وضاحت کرتے ہیں: 'نام' اور 'ڈگری'۔ یہ ڈھانچہ طالب علم کی معلومات کی نمائندگی کرتا ہے۔ مزید، 'طالب علم' قسم کے لیے ایک String() طریقہ بنایا گیا ہے۔ اس طریقہ میں 'طالب علم' قسم کا رسیور ہوتا ہے اور ایک سٹرنگ واپس کرتا ہے۔ 'String()' طریقہ گو میں ایک خاص طریقہ ہے جو کسی چیز کے پرنٹ ہونے پر اس کی سٹرنگ کی نمائندگی کو اپنی مرضی کے مطابق کرنے کے لیے استعمال ہوتا ہے۔ اس صورت میں، 'String()' طریقہ فارمیٹ کرتا ہے اور ایک سٹرنگ واپس کرتا ہے جس میں طالب علم کا نام اور ڈگری شامل ہوتی ہے۔
اس کے بعد، ہمارے پاس مین() فنکشن ہے جہاں دو متغیرات، s1 اور s2 'سٹوڈنٹ' قسم کا اعلان کیا جاتا ہے اور طالب علم کی معلومات کے ساتھ شروع کیا جاتا ہے۔ آخر میں، کوڈ s1 اور s2 کی قدروں کو پرنٹ کرنے کے لیے fmt.Println() فنکشن کا استعمال کرتا ہے۔ چونکہ String() طریقہ 'طالب علم' کی قسم کے لیے بیان کیا گیا ہے، اس لیے Go خود بخود اس طریقہ کو 'طالب علم' آبجیکٹ پرنٹ کرتے وقت کال کرتا ہے۔ String() طریقہ طالب علم کی معلومات کو 'fmt.Sprintf()' فنکشن کا استعمال کرتے ہوئے فارمیٹ کرتا ہے اور فارمیٹ شدہ سٹرنگ واپس کرتا ہے۔
درج ذیل آؤٹ پٹ سٹرنگر انٹرفیس کے 'طالب علم' قسم کے آبجیکٹ کو پرنٹ کرتا ہے:
مثال 4: گولانگ ٹائپ سوئچ انٹرفیس
پھر Go کا ٹائپ سوئچ انٹرفیس آتا ہے۔ ٹائپ سوئچ ایک کنٹرول ڈھانچہ ہے جو ہمیں انٹرفیس ویلیو کی متحرک قسم کا معائنہ کرنے کی اجازت دیتا ہے۔ قسم سوئچ انٹرفیس کے سورس کوڈ پر عمل کریں:
پیکج مرکزیدرآمد 'fmt
func MyFunction(F1 انٹرفیس{}) {
F1 سوئچ کریں۔ (قسم) {
کیس int:
fmt.Println(' قسم : int ، قدر : '، F1.(آپ))
کیس سٹرنگ:
fmt.Println(' \nٹائپ کریں۔ : تار ، قدر : '، F1.(سٹرنگ))
کیس فلوٹ 64:
fmt.Println(' \nٹائپ کریں۔ : float64 ، قدر : '، F1.(float64))
پہلے سے طے شدہ:
fmt.Println(' \nقسم درست نہیں ہے۔ ')
}
}
func main() {
مائی فنکشن (' گولانگ انٹرفیس ٹیوٹوریل ')
MyFunction(89.7)
مائی فنکشن (سچ)
}
یہاں، فراہم کردہ کوڈ ایک 'MyFunction' فنکشن کی وضاحت کرتا ہے جو 'interface{}' قسم کا 'F1' پیرامیٹر لیتا ہے۔ اس سے ظاہر ہوتا ہے کہ 'F1' کسی بھی قسم کی قدر کو قبول کر سکتا ہے۔ فنکشن کے اندر، 'F1.(type)' کے ساتھ ایک سوئچ اسٹیٹمنٹ استعمال کیا جاتا ہے تاکہ اس قدر کی قسم کو چیک کیا جا سکے جو 'MyFunction' کو بھیجی جاتی ہے۔ انٹرفیس ویلیو کی بنیادی ڈائنامک قسم حاصل کرنے کے لیے '.(type)' نحو کو ٹائپ سوئچ میں استعمال کیا جاتا ہے۔ نوٹ کریں کہ یہاں سوئچ کیسز تین مخصوص اقسام کو ہینڈل کرتے ہیں: 'int'، 'string'، اور 'float64'۔ اگر 'F1' قسم ان صورتوں میں سے کسی ایک سے مماثل ہے۔ یہ قسم کے دعوے (F1.(int), F1.(string), F1.(float64)) کا استعمال کرتے ہوئے متعلقہ قسم اور قدر کو پرنٹ کرتا ہے۔ اگر 'F1' قسم کسی بھی متعین کیس سے مماثل نہیں ہے تو، پہلے سے طے شدہ کیس پر عمل درآمد کیا جاتا ہے جو 'Type is not valid' پرنٹ کرتا ہے۔
اس کے بعد، main() فنکشن کے اندر، 'MyFunction' کو مختلف اقدار کے ساتھ تین بار کہا جاتا ہے: ایک سٹرنگ، ایک float64، اور ایک Boolean (جو سوئچ سٹیٹمنٹ میں نہیں سنبھالا جاتا ہے)۔
آؤٹ پٹ قسم کے دعووں کے ساتھ سوئچ انٹرفیس کا مظاہرہ دکھاتا ہے:
مثال 5: گولانگ ایک سے زیادہ انٹرفیس
مزید یہ کہ گو متعدد انٹرفیس پیش کرتا ہے جو اسے سیاق و سباق کے لحاظ سے طرز عمل کے مختلف سیٹ فراہم کرنے کی اجازت دیتا ہے۔ اس خصوصیت کو 'متعدد انٹرفیس' یا 'انٹرفیس کمپوزیشن' کہا جاتا ہے۔ درج ذیل کوڈ متعدد انٹرفیس کے نفاذ کو ظاہر کرتا ہے:
پیکج مرکزیدرآمد 'fmt'
قسم پرندے انٹرفیس {
سانس لینا ()
پرواز ()
}
قسم ایوینز انٹرفیس {
کھانا کھلانا ()
}
قسم کہاں ساخت {
عمر int
}
func ( ڈی کہاں ) سانس لینا () {
ایف ایم ٹی . پرنٹ ایل این ( 'کبوتر کی سانسیں' )
}
func ( ڈی کہاں ) پرواز () {
ایف ایم ٹی . پرنٹ ایل این ( 'کبوتر اڑ' )
}
func ( ڈی کہاں ) کھانا کھلانا () {
ایف ایم ٹی . پرنٹ ایل این ( 'کبوتر بچوں کی پرورش کرتا ہے' )
}
func مرکزی () {
تھا b پرندے
ڈی := کہاں {}
ب = ڈی
ب . سانس لینا ()
ب . پرواز ()
تھا ایک ایوینز
a = ڈی
a . کھانا کھلانا ()
}
یہاں، ہم دو انٹرفیس کی وضاحت کرتے ہیں: 'پرندے' اور 'ایوینز'۔ 'پرندے' انٹرفیس دو طریقوں کا اعلان کرتا ہے: سانس () اور فلائی ()۔ جبکہ 'ایوینز' انٹرفیس فیڈ() طریقہ کا اعلان کرتا ہے۔ پھر، 'کبوتر' کا ڈھانچہ 'پرندوں' اور 'ایوینز' دونوں انٹرفیس کے تمام طریقوں کو نافذ کرتا ہے۔ یہ سانس ()، فلائی()، اور فیڈ () کے لیے نفاذ فراہم کرتا ہے۔
اگلا، ہم مین() فنکشن کے اندر 'پرندوں' قسم کے متغیر 'b' کا اعلان کرتے ہیں۔ b = d اسائنمنٹ کا استعمال کرتے ہوئے 'کبوتر' کی ایک مثال بنائی گئی ہے اور 'b' کو تفویض کی گئی ہے۔ چونکہ 'کبوتر' 'پرندوں' کے انٹرفیس کے تمام طریقوں کو نافذ کرتا ہے، یہ اسائنمنٹ درست ہے۔
اس کے بعد، سانس لینے () اور فلائی () طریقوں کو 'b' پر کہا جاتا ہے جو 'پرندوں' کی قسم کا ہے۔ اسی طرح، 'ایویئنز' قسم کے ایک متغیر 'a' کو 'd' کی 'dove' مثال کے ساتھ اعلان اور تفویض کیا جاتا ہے۔ چونکہ 'کبوتر' فیڈ() طریقہ کو نافذ کرتا ہے جس کی تعریف 'ایوینز' انٹرفیس میں کی گئی ہے، اس لیے یہ اسائنمنٹ بھی درست ہے۔ فیڈ () طریقہ کو 'a' پر کہا جاتا ہے جو 'ایوینز' قسم کا ہے۔ جیسا کہ 'a' 'dove' کی مثال رکھتا ہے، فیڈ () طریقہ جو 'dove' کے ذریعہ لاگو کیا جاتا ہے اس پر عمل درآمد ہوتا ہے۔
آؤٹ پٹ سے پتہ چلتا ہے کہ انٹرفیس کے طریقے صحیح طریقے سے چلائے گئے ہیں:
نتیجہ
ہم نے Go انٹرفیس کی بنیادی باتیں سیکھیں اور ان کے استعمال کو واضح کرنے کے لیے عملی مثالیں فراہم کیں۔ انٹرفیس کی وضاحت کرکے اور انہیں مختلف اقسام کے ساتھ لاگو کرکے، ہم لچکدار اور قابل توسیع پروگرام بنا سکتے ہیں۔