گولینگ نام کاری کنوینشنز میں مہارت: ایک عملی رہنما

1. نامکاری کے اصولوں کی سمجھ

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

1.1. نام رکھنے کا اہمیت

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

1.2. نام رکھنے کے عام اصولوں

Go کے نام رکھنے کے اصول سیدھے لیکن موثر ہیں:

• چھوٹے، مختصر نام استعمال کریں: Go چھوٹے ناموں کا استعمال سراحت کرتی ہے، خاص طور پر چھوٹے حد کے متغیرات کے لیے۔ مثال کے طور پر، i کو لوپ میں استعمال کیا جا سکتا ہے، لیکن اگر زیادہ واضحیت کی ضرورت ہو تو index یا counter کا استعمال کیا جا سکتا ہے۔

• ملٹی ورڈ ناموں کے لیے CamelCase استعمال کریں: جب بھی نام میں ملٹی ورڈ ہوں، تو CamelCase کی مرضی ہوتی ہے۔ (جو وہ ہیں جو پیکیج کے باہر قابل رسائی ہوں) کو ایک بڑے حرف سے شروع کرنا چاہئے (MyFunction)، جبکہ اندرونی نام کو ایک چھوٹے حرف سے شروع کرنا چاہئے (myFunction)۔

• معنی خیز نام استعمال کریں: نام مطلب بیان کرنے کیلئے کافی واضح ہوں جو بغیر بے جملہ ہو۔ مثال کے طور پر، CalculateNetIncome کو CNI کے بجائے استعمال کیا جائے۔

• Under_scores سے بچیں: کچھ زبانوں کے برعکس، Go کے اصول ناموں میں underscore کا استعمال نہیں کرتے۔ record_count کے بجائے، recordCount کا استعمال کریں۔

• Abbreviations کو یکساں رکھیں: ناموں میں Abbreviations کا استعمال کرتے وقت، ان کو یکساں چیزو کے طور پر رکھیں۔ بازار میں آئے ناموں کے لیے، تمام حروف بڑے ہوں (HTTPServer)، اور اندرونی ناموں کے لیے، تمام حروف چھوٹے ہوں (httpServer) ہے۔

• پیکیج ناموں کو سادہ رکھیں: Go میں پیکیج نام سادہ اور چھوٹے حروف میں ہوتے ہیں، کہیں بھی underscore یا mixedCaps نہیں ہوتے ہیں۔ یہ ایک ایسا لفظ ہوتا ہے جو پیکیج کا مقصد صاف طریقے سے ظاہر کرتا ہے (net، os، json)۔

• Variable naming type پر مبنی ہوتا ہے: Structs کی نمائندگی کرنے والے متغیرات کے لیے، معمولی ہے کہ متغیر کا نام چھوٹے حرفوں میں استعمال کیا جاتا ہے (var user User)۔

یہاں Go کے کوڈ کا ایک مثال ہے جس میں نام رکھنے کے فیصلوں کی وضاحت کرتے ہوئے تبصرے شامل ہیں:

package main

import "fmt"

type User struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    var currentUser User // Using struct name in lowercase as the variable name.
    currentUser.FirstName = "John"
    currentUser.LastName = "Doe"
    currentUser.Age = 30

    fmt.Println(formatUserDetails(currentUser))
}

// formatUserDetails takes a User struct as input and returns a formatted string.
// The function name starts with a lowercase letter since it's unexported (private).
func formatUserDetails(u User) string {
    return fmt.Sprintf("Name: %s %s, Age: %d", u.FirstName, u.LastName, u.Age)
}

ان نامکاری کے اصولوں کی پاسداری کرنے سے آپ کے Go کوڈ کی معیار میں بہتری آئے گی، چونکہ یہ اسے زیادہ قابل پڑھنے اور رکھنے کے بناؤ کی طرف دھکیلتے ہیں۔

2. Go میں شناختیاں

Go کے ساتھ آپ کی آغاز کی سفر شروع کرنے کا وقت ہوتا ہے، ہر مختصر کی شناخت کا کردار سمجھنا ضروری ہے۔ شناختیں، وہ نام ہیں جو آپ اپنے کوڈ میں متغیرات، فنکشنز، اور مستقل کیلئے رکھتے ہیں۔ معنی خیز اور یکساں ناموں کا استعمال آپکے کوڈ کو زیادہ قابل پڑھنے اور رکھنے کیلئے مدد فراہم کرتا ہے۔

2.1. متغیرات کی نام رکھنے کے اصول

Go میں، متغیر کے نام کا آغاز یا نشان یا کوئی بھی حروف سے ہوتا ہے، جس کے بعد کسی بھی ترتیب میں حروف، ہانم، یا underscore کا استعمال کیا جا سکتا ہے۔ البتہ، عین میں ایک underscore کا استعمال متنوع استعمالات کے لیے مخصوص کرنا نہیں مشورہ کیا جاتا ہے۔

بہتری کی مثالیں:

• مختصر اور معنی خیز نام استعمال کریں۔
• پیکیج سطح پر چھوٹے حرف سے شروع ہوں۔
• ملٹی ورڈ ناموں کے لیے camelCase استعمال کریں (مثال کے طور پر، totalAmount)۔
• ناموں کے لیے (پیکیج کے باہر قابل رسائی) بڑے حرف سے شروع ہوں۔

مثال:

var userName string // غیر ایکسپورٹ کیا گیا متغیر
var UserAge int     // ایکسپورٹ کی گئی متغیر

کوڈ میں تبصرے غیر ایکسپورٹ کیے گئے اور ایکسپورٹ کیے گئے متغیرات کے درمیان فرق کو واضح کرتے ہیں۔

2.2. فعل ناموں کی روایتی نامک نگاری

Go میں فعل ناموں کے نام متغیروں کی طرح ہی ہوتے ہیں۔ نام کا اظہار فعل کا مقصد دکھانا چاہئے، اور اس کی دائرہ کار پہلا حرف کیس کا فیصلہ کرتا ہے۔

بہتر عمل:

• مقصد کو دکھانے والے تفصیلی نام استعمال کریں۔
• اندرونی فعلوں کے لئے پہلا حرف چھوٹا لکھیں۔
• نکالے گئے فعلوں کے لئے PascalCase (بڑے حرف سے شروع ہونے والا) استعمال کریں۔
• فعل نام مختصر لیکن معنی خیز رکھیں۔

مثال:

func calculateTotal(price int, quantity int) int { // اندرونی فعل
    return price * quantity
}

func CalculateDiscount(totalPrice int) float64 { // دکھائی گئی فعل
    return totalPrice * 0.1
}

تبصرے کی وضاحت کرتی ہیں کہ کس کیس کے اساس پر فعل کی دسترسی کو بیان کیا گیا ہے اور اس کا مقصد کے ایک مختصر دخل دیتی ہیں۔

2.3. مستقل نامک نگاری کی روایتی نامک نگاری

مستقل امیوتی لۓ قابل تبدیل قیمتیں ہیں جو ایک بار تعین کردی جاتی ہیں۔ Go میں، مستقل کو const کلیدی سے اعلان کیا جا سکتا ہے اور یہ حروف، رشتے، بولین یا عددی قیمتیں ہو سکتی ہیں۔

بہتر عمل:

• تمام بڑے حروف یونڈر اسکور کے ساتھ استعمال کریں (مثلاً MAX_LIMIT۔)
• اضافی کنستینٹس کے لئے iotaانمریٹر کا استعمال کریں۔
• نکالے گئے مستقل ہونے کی صورت میں بڑے حرف سے شروع ہونا چاہئے۔

مثال:

const MAX_RETRY_COUNT int = 3 // بہتر عمل کا مستقل

type ByteSize float64
const (
    _           = iota // پہلی قیمت کو نکالنے کے لئے خالی شناخت کو تفویض کرتے ہوئے
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
)

مثال اس کا ظاہر کرتی ہے کہ سادہ مستقل کو کیسے تعین کیا جاتا ہے اور iota کا استعمال کرتے ہوئے متعلقہ مستقلوں کا سلسلہ کو چھپانے والا ہے۔

3. قسم کے نامک نگاری کی روایت

اس باب میں تمام اقسام مثلاً سٹرکٹس اور انٹرفیس کے لئے نام کی مناسبت پر توجہ ہوگی۔

3.1. سٹرکٹس کی نامک نگاری کے ہدایات

جامعہ بین القاعدہ: Go میں سٹرکٹس مجموعی ڈیٹا اقسام کو ظاہر کرتے ہیں۔ جب سٹرکٹس کے نام کا استعمال کریں،PascalCase میں وضاحت سے بڑے حروف سے شروع کریں۔

• بہتر عمل: سٹرکٹس کے ناموں کو اسم نیما یا اسم نیما فراہم کرنے والے الفاظ سے نامک نگاری کریں جو واضح طور پر بیان کرتے ہیں کہ وہ کیا ظاہر کرتے ہیں۔ مثال کے طور پر:

// بہتر عمل
type Employee struct {
    ID        int
    FirstName string
    LastName  string
    Position  string
}

• خود سے باز رہیں: دوہرے یا عمومی ناموں کا استعمال نہ کریں جو سٹرکٹ کی مقصد کو پیش نہیں کرتے۔

// اجتناب
type Data struct {
    ID        int
    FirstName string
    LastName  string
    Position  string
}

3.2. انٹرفیس کی نامک نگاری کے ہدایات

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

• بہتر عمل: انٹرفیس کو ان کی تناسب کا عملچہ پیش کرنے لئے اس کے بعد کے 'er' لاحقے کے ساتھ نام نامک نگاری کریں۔ عام طور پر، اگر ایک انٹرفیس میں صرف ایک میتھڈ ہوتا ہے تو نام کو اس میتھڈ کے عمل کا عمل اور الف لاحقے کے ساتھ بیان کرنا چاہئے۔

// بہتر عمل
type Reader interface {
    Read(p []byte) (n int, err error)
}

• نامک نگاری کے بہار درجات: اگر ایک انٹرفیس مقصد کی سلسلہ کاروں کا مظاہرہ کرتا ہے، تو ایک ایسے نام کا انتخاب کریں جو بغیر 'er' کے لاحقے کے اپنے مقصد کو صحیح طریقہ سے ظاہر کرتا ہے۔

// بہار درجات کا نمونہ
type Filesystem interface {
    ReadFile(path string) ([]byte, error)
    WriteFile(path string, data []byte) error
}

4. کیس سینسٹویٹی اور دکھائی گئی معیار کے نام

4.1. دکھائی گئی معیار کے خلاف این اور غیر دکھائی گئی نام

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

Examples:

package geometry

// دکھائی گئی شناخت
type Rectangle struct {
    Length, Width float64
}

// دکھائی نہیں ہونے شناخت
type point struct {
    x, y float64
}

اس مثال میں، Rectangle ایک دکھائی گئی قسم ہے کیونکہ یہ بڑے حرف سے شروع ہوتی ہے اور geometry پیکج کو درآمد کرنے والے دوسرے پیکجز کے ذریعے استعمال کی جاسکتی ہے۔ الٹا، ٹائپ point نجی ہے اور صرف geometry پیکج کے اندر استعمال کیا جاسکتا ہے۔

4.2. بہترین تجاویز برائے برآمد کردہ شناختیں

برآمد شدہ شناختیں کے نام رکھتے وقت، دوسروں کے لئے آپ کے کوڈ کو قابل پڑھنے اور سمجھنے کے لئے کچھ بہترین تجاویز کا اتباع ضروری ہے:

• وضاحت بھرپورتر اہم ہے: کم لمبائی اور رازکارانہ ناموں کی بجائے واضح اور تفصیلی ناموں کا انتخاب کریں۔ مثال کے طور پر، حساب_لو کو CalcA کے بجائے ترجیح دی جاتی ہے۔
• استمرار: اپنے کوڈ بیس میں نام رکھنے کے فارم کے ساتھ استمرار برقرار رکھیں۔ اگر آپ مماثل موجودہ چیزوں کے ناموں کو کچھ خصوصی پیٹرن کے ساتھ نام رکھنا شروع کرتے ہیں، تو اُنہیں مضبوطی سے اتباع کریں۔
• ضائع فائدہ سے بچیں: شناختیں کے ناموں میں پیکیج کے ناموں کو دہرانے سے بچیں۔ مثال کے طور پر، geometry.GeometryRectangle کی بجائے geometry.Rectangle استعمال کریں۔
• حالت کو مد نظر رکھیں: شناختیں کے ناموں کا استعمال کیے جانے والے مواقع میں معقول ہونا چاہئے۔ ایسے ناموں سے بچیں جو سمجھنے میں گمراہ کن ہوں یا ابہام زدہ ہوں۔
• تفصیلی تبصرے: برآمد کردہ شناختیں کو تفصیلی تبصروں کا استعمال کریں، جو بیان کرتے ہیں کہ یہ کیا کرتے ہیں اور وہ کس طرح استعمال ہونی چاہئیں۔

مثال:

package geometry

// CalculateArea وتاریخ: مستطیل کا رقبہ واپس کرتا ہے۔
func (r Rectangle) CalculateArea() float64 {
    return r.Length * r.Width
}

اس مثال میں، CalculateArea ایک برآمد کردہ فعل ہے جس کا واضح، تفصیلی نام ہے جس میں اس کا مقصد بیان کرنے والا ایک تفصیلی تبصرہ شامل ہے۔

5. عمل میں نامک کے معیار

اس باب میں ہم گو نامک کے معیارات کو واقعی دنیا کے سیناریوز میں لاگو کریں گے۔ ان معیارات کو سمجھنا اور ان کا اتباع کرنا اہم ہے کیونکہ یہ یقینی بناتا ہے کہ آپ کا کوڈ Idiomatic ہے، پڑھنے میں آسان ہے، اور اس کا صرف رکھا جا سکتا ہے۔

5.1. عام بھول اور ان سے کیسے بچا جائے

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

• عام نام استعمال کرنا: data یا info جیسے نام غیر وضاحت اور الجھن کا باعث بن سکتے ہیں۔
• بہت زیادہ لمبے نام: وضاحت بھرپور ناموں کی برکی، بہت لمبے نام مشکل ہو سکتے ہیں۔ میں ایک توازن برقرار رکھیں۔
• زیادہ بر زیر خط شناختیں کے لئے ان سے اجتناب کریں: گو کم واریبل ناموں کے لئے camelCase کو پسند کرتا ہے اور برآمد فعل اور قسم کے لئے PascalCase کو۔
• غیر متشاکل نام رکھنے کے پیٹرنز: نامک کے فارم کی استمرار کی بنا پر شناختیں کی یکسانیت میں مدد ملتی ہے۔

ان چاریوں سے بچنے کے ليے ٹپس:

• مختصر لیکن تفصیلی نام استعمال کریں۔ مثال کے طور پر، data کی بجائے اگر یہ صارفین کے بارے میں معلومات رکھتا ہے تو userData کا استعمال کریں۔
• عبارتوں کے ساتھ گو کے معیار کا اتباع کریں؛ انہیں بڑے حروف میں رکھیں، مثلاً HTTPServer بجائے HttpServer۔
• برآمد پیکیج سطحی متغیرات اور مستقلات کے لئے ناموں کو مختصر رکھیں کیوں کے یہ کم scope رکھتے ہیں۔

5.2. بہتر ناموں کے لئے دوبارہ وضاحت

شناختیں کے ناموں کو بہتر بنانے کے لئے کوڈ کو دوبارہ ترتیب دینے سے کوڈ کے پڑھنے میں بہتری آ سکتی ہے۔ یہاں ہیں کچھ ترتیب دینے کے طریقے:

1. وضاحت بھرپور ناموں کا استعمال: ناموں کو وضاحت انداز سے دوبارہ ترتیب دیں تاکہ وہ وضح کریں کہ وہ کیا کوشش کرتے ہیں یا کرتے ہیں۔ مثال کے طور پر، اگر یہ کام کروائی جاتی ہے تو ایک فعل کو ProcessUserInput سے Process تک دوبارہ نام دیں۔
2. اوزار کا استعمال: اوزاروں کا استعمال کریں جیسے کہ gorename جو Go کوڈ کی تشخیصی طریقے سے دبارہ نامک کرنے کی اجازت دیتا ہے بجائے آخری ترتیب کی۔
3. ساتھیوں کے ساتھ جائزہ: کبھی کبھار وہ چیز جو آپ کے لئے مناسب ہو سکتی ہے وہ دوسروں کے لئے واضح نہیں ہوتی۔ ساتھی کی جائزہ لینے میں مدد مل سکتی ہے۔
4. تبدیلیوں پر نظر ثانی کریں: تبدیلیاں کرنے کے بعد، کوڈ کے صارفوں سے رائے حاصل کریں اور ضرورت پڑھنے پر ناموں کو ڈھونڈ کر ترتیب دیں۔

ان تقنیکوں کا اتباع کرتے ہوئے، آپ یقینی بنائیں گے کہ آپ کے گو کوڈ پیسے کا بنا ہوا رہتا ہے، سمجھنے میں آسان، اور اسے برقرار رکھنے کے قابل ہوتا ہے۔