Գոլանգով մաքուր ծածկագիր գրելու 10 կարևոր խորհուրդ

Մաքուր կոդ գրելը վճռորոշ է ցանկացած ծրագրային նախագծի հաջողության համար: Դա ոչ միայն հեշտացնում է կոդը կարդալը և հասկանալը, այլև այն դարձնում է ավելի պահպանելի և նվազեցնում սխալների հավանականությունը: Այս հոդվածում մենք կքննարկենք Go (golang) մաքուր կոդ գրելու 10 կարևոր խորհուրդ, որոնք կօգնեն ձեզ ստեղծել բարձրորակ, պահպանվող կոդ:

1. Օգտագործեք հստակ և հակիրճ փոփոխականների անուններ

Փոփոխականների անունները պետք է լինեն հստակ և հակիրճ՝ նշելով, թե ինչ է ներկայացնում փոփոխականը: Խուսափեք միատառ փոփոխականների անուններից կամ չափազանց ընդհանուր անուններից: Լավ օրինակելի կանոն է օգտագործել փոփոխականների անունները, որոնք նկարագրական են, բայց ոչ շատ երկար: Օրինակ:

// bad
var x int
// good
var numEmployees int

2. Օգտագործեք իմաստալից ֆունկցիաների և մեթոդների անուններ

Ֆունկցիաների և մեթոդների անվանումները պետք է լինեն նկարագրական և ճշգրիտ նկարագրեն, թե ինչ է անում գործառույթը կամ մեթոդը: Գործառույթի կամ մեթոդի կատարած գործողությունը նկարագրելու համար օգտագործեք բայեր: Օրինակ:

// bad
func x() {}
// good
func calculateAverage(nums []float64) float64 {}

3. Հետևեք Միասնական պատասխանատվության սկզբունքին

Յուրաքանչյուր գործառույթ կամ մեթոդ պետք է ունենա միայն մեկ պատասխանատվություն: Եթե ​​ֆունկցիան կամ մեթոդը մեկից ավելի բան է անում, այն ավելի դժվար է դառնում կարդալը և հասկանալը: Այն նաև ավելի է դժվարացնում փորձարկումն ու պահպանումը: Օրինակ:

// bad
func calculateAverageAndSum(nums []float64) (float64, float64) {}
// good
func calculateAverage(nums []float64) float64 {}
func calculateSum(nums []float64) float64 {}

Եթե ​​դուք հետաքրքրված եք ավելին իմանալով devops, golang, kubernetes և ավելի հետաքրքիր դասընթացների մասին: Ես կխնդրեի ձեզ միանալ KODEKLOUD-ին, որը պարզապես #1 Devops դասընթացների լավագույն մատակարարն է: Դա մեկ կանգառ վայր է բոլոր վերջին տեխնոլոգիական կարիքների համար, հետագայում նրանք շարունակում են ավելացնել նոր դասընթացներ: Միացեք ներքևի հղումից՝ ինձ նույնպես աջակցելու համար.

4. Օգտագործեք մեկնաբանությունները խնայողաբար

Մեկնաբանությունները պետք է օգտագործվեն բացատրելու համար, թե ինչու է արվում ինչ-որ բան, այլ ոչ թե ինչպես է դա արվում: Կոդը պետք է լինի ինքնըստինքյան, և մեկնաբանությունները պետք է օգտագործվեն միայն անհրաժեշտության դեպքում: Խուսափեք մեկնաբանություններից բացատրելու համար, թե ինչ է անում կոդը: Օրինակ:

// bad
// loop through the array
for i := 0; i < len(arr); i++ {}
// good
for index := 0; index < len(array); index++ {}

5. Խուսափեք գլոբալ փոփոխականների օգտագործումից

Գլոբալ փոփոխականները կարող են դժվարացնել կոդը փորձարկելը և պահպանելը, քանի որ դրանք կարող են փոփոխվել կոդի ցանկացած կետից: Փոխարենը, օգտագործեք տեղական փոփոխականներ կամ փոխանցեք փոփոխականները որպես ֆունկցիաների կամ մեթոդների պարամետրեր: Օրինակ:

// bad
var count int
func incrementCount() {
    count++
}
// good
func incrementCount(count int) int {
    return count + 1
}

Դուք արդեն շատ բան սովորե՞լ եք: Ինձ հետաքրքիր է թեմաների այն կարևոր շարքը, որոնց մենք կհանդիպենք ստորև: Շարունակենք մեր ճանապարհը հետագա։

6. Սխալների հետ ճիշտ վարվել

Միշտ կարգավորեք ձեր կոդի սխալները: Սխալների անտեսումը կարող է հանգեցնել անսպասելի վարքագծի և ձեր կոդը ավելի դժվարացնել վրիպազերծումը: Օգտագործեք Go-ի ներկառուցված սխալների մշակման մեխանիզմը՝ ձեր կոդի սխալները կարգավորելու համար: Օրինակ:

// bad
f, err := os.Open("filename.txt")
if err == nil {
    // do something with f
}
// good
f, err := os.Open("filename.txt")
if err != nil {
    log.Fatal(err)
}
defer f.Close()
// do something with f

7. Օգտագործեք ինտերֆեյսներ՝ կախվածությունները անջատելու համար

Ինտերֆեյսների օգտագործումը կարող է օգնել անջատել ձեր կոդի կախվածությունը: Սա հեշտացնում է ձեր կոդը փորձարկելն ու պահպանելը: Օրինակ:

// bad
func calculateAverage(nums []float64) float64 {
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    return sum / float64(len(nums))
}
// good
type Calculator interface {
    Calculate(nums []float64) float64
}
type AverageCalculator struct {}
func (c *AverageCalculator) Calculate(nums []float64) float64 {
    sum := 0.0
    for _, num := range nums {
      sum += num
    }
   return sum / float64(len(nums))
}

8. Օգտագործեք ճիշտ ձևաչափում

Ճիշտ ձևաչափումը ձեր կոդը դարձնում է ավելի ընթեռնելի և ավելի հեշտ հասկանալի: Օգտագործեք Go-ի ներկառուցված ձևաչափման գործիքները՝ համոզվելու համար, որ ձեր կոդը ճիշտ ձևաչափված է: Օրինակ:

// bad
func calculateAverage(nums []float64) float64 {
sum := 0.0
for _, num := range nums {
sum += num
}
return sum / float64(len(nums))
}
// good
func calculateAverage(nums []float64) float64 {
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    return sum / float64(len(nums))
}

9. Կարճ պահեք գործառույթներն ու մեթոդները

Գործառույթները և մեթոդները պետք է լինեն կարճ և հակիրճ: Սա հեշտացնում է նրանց կարդալը և հասկանալը: Լավ օրինակելի կանոնն այն է, որ գործառույթներն ու մեթոդները 50 տողից պակաս ծածկագրով պահվեն: Եթե ​​գործառույթը կամ մեթոդը դրանից ավելի երկար է, մտածեք այն բաժանել ավելի փոքր, ավելի կառավարելի գործառույթների կամ մեթոդների: Օրինակ:

// bad
func calculateAverageAndSum(nums []float64) (float64, float64) {
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    average := sum / float64(len(nums))
    return average, sum
}
// good
func calculateAverage(nums []float64) float64 {
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    return sum / float64(len(nums))
}
func calculateSum(nums []float64) float64 {
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    return sum
}

10. Գրել փորձարկվող կոդը

Գրեք կոդ, որը հեշտ է փորձարկել: Սա հեշտացնում է ձեր կոդի սխալների հայտնաբերումը և ուղղումը: Օգտագործեք Go-ի տրամադրած «փորձարկման» փաթեթը՝ ձեր կոդի համար թեստեր գրելու համար: Օրինակ:

// bad
func calculateAverage(nums []float64) float64 {
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    return sum / float64(len(nums))
}
// good
func calculateAverage(nums []float64) float64 {
    if len(nums) == 0 {
        return 0.0
    }
    sum := 0.0
    for _, num := range nums {
        sum += num
    }
    return sum / float64(len(nums))
}
func TestCalculateAverage(t *testing.T) {
    nums := []float64{1.0, 2.0, 3.0, 4.0}
    expected := 2.5
    result := calculateAverage(nums)
    if result != expected {
        t.Errorf("Expected %f but got %f", expected, result)
    }
}

Եզրակացություն

Մաքուր կոդ գրելը կարևոր է բարձրորակ և սպասարկվող ծրագրակազմ ստեղծելու համար: Հետևեք այս 10 խորհուրդներին՝ Go-ում մաքուր կոդ գրելու համար, որը հեշտ է կարդալ, հասկանալ և պահպանել: Դրանով դուք կբարելավեք ձեր կոդի որակը, կնվազեցնեք սխալները և կդարձնեք ձեր կոդը ավելի ստուգելի:

Հուսով եմ, որ այս 10 խորհուրդներն օգտակար են գտել Go-ում մաքուր կոդ գրելու համար: Հետևելով այս ուղեցույցներին՝ դուք կարող եք արտադրել կոդ, որը հեշտ է կարդալ, պահպանել և փորձարկել, ինչը, ի վերջո, կխնայի ձեր ժամանակն ու ջանքերը երկարաժամկետ հեռանկարում: Հիշեք, որ մաքուր կոդ գրելը շարունակական գործընթաց է, և այն պահանջում է մշտական ​​ջանք և ուշադրություն: Այսպիսով, հիշեք այս խորհուրդները և ձգտեք ձեր կոդը հնարավորինս մաքուր և ընթեռնելի դարձնել:

Եթե ​​ձեզ դուր եկավ այս հոդվածը, խնդրում եմ, ծափ տվեք այն և թողեք մեկնաբանություն ձեր մտքերով կամ հարցերով: Ձեր հետադարձ կապը միշտ գնահատելի է, և դա օգնում է ինձ ապագայում ավելի լավ բովանդակություն ստեղծել: Եվ եթե ցանկանում եք ավելի շատ նման բովանդակություն տեսնել, համոզվեք, որ հետևեք ինձ հետագա թարմացումների համար: Շնորհակալություն կարդալու և ուրախ կոդավորման համար: