Վերջերս սկսեցի ուսումնասիրել Google-ի կողմից ստեղծված Go ծրագրավորման լեզուն։ Միանգամից ասեմ, որ իտարբերություն C++-ի, որի նկատմամբ հակակրանք եմ ունեցել սովորելու հենց առաջին օրվանից, սա բավականին հմայիչ լեզու է։
Ստորև բերված է քառակուսի հավասարման լուծման ծրագիրը Go լեզվով։
// ինքնուրույն կատարվող ամեն մի ծրագիր պետք է ունենա main անունով փաթեթ
package main
// այլ փաթեթների սիմվոլների ներմուծում
import (
"math/cmplx" // աշխատանք կոմպլեքս թվերի հետ
"fmt" // ֆորմատավորված ներածում/արտածում
)
// Reads one float64 number from keyboard.
// ֆունկցիայի սահմանումը սկսվում է func ծառայողական բառով,
// որին հետևում են ֆունկցիայի անունը, ապրամետրերի ցուցակը,
// վերադարձվող արժեքների տիպերը
func inputFloat(pr string) float64 {
fmt.Printf("Input %s: ", pr)
var res float64 // փոփոխականի հայտարաում
fmt.Scanf("%f", &res)
return res
}
// ծրագրի կատարումը սկսվում է main փաթեթի main ֆունկցիայից
func main() {
// input equation factors
a := inputFloat("A")
b := inputFloat("B")
c := inputFloat("C")
// analyze cases
if 0 == a {
if 0 == b {
if 0 == c {
fmt.Println("Անվերջ քանակի լուծումներ։")
} else {
fmt.Println("Հավասարումը լուծումներ չունի։")
}
} else {
fmt.Println("Հավասարումն ունի մեկ լուծում։")
x := -c / b
fmt.Printf(" x = %f\n", x)
}
} else {
discriminant := b * b - 4 * a * c
sqdiscr := cmplx.Sqrt(complex(discriminant, 0.0))
a2 := complex(2 * a, 0)
if complex(0,0) == sqdiscr {
fmt.Println("Հավասարումն ունի մեկ իրական արմատ")
fmt.Println("(կամ երկու արմատ, որոնք համընկնում են)։")
x := -b / real(a2)
fmt.Printf(" x1 = x2 = %f\n", x)
} else {
x1 := (complex(-b,0) + sqdiscr) / a2
x2 := (complex(-b,0) - sqdiscr) / a2
if 0 > discriminant {
fmt.Println("Հավասարումն ունի երկու կոմպլեքս արմատ")
fmt.Printf(" x1 = %g\n x2 = %g\n", x1, x2)
} else {
fmt.Println("Հավասարումն ունի երկու իրական արմատ։")
fmt.Printf(" x1 = %f\n x2 = %f\n", real(x1), real(x2))
}
}
}
}
ես ամենաշատը տրաքվում եմ, էս պահից := :))))) մեկ էլ ու՞ր են ; -ը ՞ չնայած մինիֆիկացիայի խնդիր չկա... տանելի ա :Ճ
; (կետ-ստորակետ) սիմվոլը բոլոր հրամաններից հետո ավելացվում է ավտոմատ՝ կոմպիլյատորի կողմից։ Ծրագրավորողը հրամանները հրամանները ; նիշով պետք է բաժանի միայն այն դեպքում, երբ մեկ տողի վրա գրված են մի քանի հրամաններ։ Փոփոխականները կարող են հայտարարվել երկու եղանակով. 1) name := value որտեղ name փոփոխականի տիպը որոշվում է ըստ նրան վերագրած արժեքի։ 2) var name type որտեղ բացահայտ տրվում է տիպը, իսկ փոփոխականին վերագրվում է տվյալ տիպի զրոյական արժեքը։ Վերագրման հրամանը (այն արտահայտություն չէ) գրվում է դասական = նիշով։
ինձ դուր է գալիս, երբ վերագրումը նշանակվում է ինչ որ անհավասար բանով, քանի որ այն հավասարում չէ, օրինակ := կամ <= ինձ դուր չի գալիս երբ հնարավոր է գրել՝ a = a + 5 ու այսպես կորցնելով = նշանը լեզվի նախագծողները արեցին հաջորդ սխալը, օգտագործելով == որպես հավասարության ստուգում։ իսկ երկու նիշ գրելիս ավելի հեշտ է սխալ անել ու գրել այսպես՝ a=1; if (a = 5) { ... //սա միշտ կկատարվի քանի որ վերագրումը միշտ կհաջողվի } ու այդպիսի սխալներ շատ բարդ է գտնել, երկու դեպք գիտեմ, երբ երկու շաբաթ կորցրել են այս սխալի պատճառով։ ու ցավոք, այս սինտաքսը անցել է սի֊ից այլ լեզուներ։ վերագրումը կարծում եմ պետք է լինի այնպես, որ հասկացվի որ այստեղ հավասարության մասին խոսք չկա։
ճիշտ ա... դա ուժեղ արգումենտ ա... իսկ այդ առումով ամենադաժանը PHP-ն ա. ընդեղ === էլ կա :D են դեպքերի համար, երբ ասենք փոփոխականների իրար հավասար են նաև հՈԳՈվ :D
ահա, ես սովոր չեմ այդ մտածողությանը։ երբ կարող է երկու փոփոխական հավասար լինեն, բայց տարբեր տիպերի, ու հավասար լինեն, ու նույն տիպի լինեն։ ես սիրում եմ երբ կոդը հնարավորին չափ լինում է ստատիկ անալիզի ժամանակ ստուգել, այսինքն կարդալով գրածդ, կամ տալով այն կոմպիլյատորին։ երբ կոմպիլյատորը չի կարողանում գտնել սխալ ու սխալները պետք է գտնել ռանթայմ, դա ոնց որ գիտական մոտեցում չլինի, իմ կարծիքով, ոնց որ փորձես «մետոդոմ տիկա» էլի։ Գրե՞լ եմ, արտահայտել ե՞մ, գրածս ինչի՞ պիտի կատարվի որ իմանամ ճիշտ է գրված թե չէ։ Այսինքն այո, շատ ժամանակ անհնար է առանց ռանթայմ ստուգելու, բայց ես հակված եմ ավելի շատ այն մտքին որ պետք է աշխատել մինիմիլիզացնել դա, քան մաքսիմալիզացնել։
Իմիջայլոց մի քիչ առաջ քոմենթները կարդացի ու երևի ենթագիտակցությանս վրա ազդեց :Դ, մի բան էի գրել ուրտեղ հենց այդպիսի ստուգման հարց էր, ու սխալ էր աշխատում :Ճ կես ժամ տանջվեցի մինջև ջոգեցի թե խնդիրը որտեղ ա, ոչինչ կպատահի :) բայց մի հատ հավասարման նշանով վերագրելը մաթեմատիկայից ա գալիս, տենց էլ անցել ա ծրագրավորման լեզուներ, հետո էլ մտածել են որ հարմար չի որոշ դեպքերում, ու բազմաթիվ հակասական մոտեցումներ են առաջացել:
հմ, իմ հիշելով մաթեմում վերագրում չկա, կա հավասարում։ հենց դա եմ ասում, դպրոցում սովորած մաթեմից հետո a = a + 5 բնավ հասկանալի չէ։ այսինքն հավասարման նշանը սովոր ենք որ հավասարման նշան է, ոչ թե վերագրման։ իսկ վերագրումը պետք է ինչ որ ուղղություն ցույց տա, ինչ որ անհավասարակշռություն։ ու այդ պատճառով ես սիրում եմ := նշանակումը։ (:
Գուգլի աջակցության պատճառով մենք վերջապես ունենք քիչ թե շատ տարածված լեզու(ու այդ լեզվի իրականացում), որն ունի մոդուլներ, ու կոմպիլիացիա է լինում, այսինքն կատարման բարձր արագություն ու հիշողության ցածր օգտագործում է ապահովվում։