Առաջին ծրագիրս Go լեզվով
Վերջերս սկսեցի ուսումնասիրել 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))
}
}
}
}
Կարդացեք ավելին
Հաշվարկիչ վերագրման և արտածման հրամաններով
Go. Օբյեկտներին կողմնորոշված ծրագրավորում
Ինտերպրետատոր։ Համեմատում, ճյուղավորում, կրկնություն
“VMware”, կամ համակարգիչ համակարգչի մեջ 2 (ինչպես օգտվել)
“VMware”, կամ համակարգիչ համակարգչի մեջ 1 (տեղադրում)
Տվյալների տարրական կառուցվածքներ։ Երկկապակցված գծային ցուցակ (doubly linked list)
Բաժին: Go
ես ամենաշատը տրաքվում եմ, էս պահից
:=
:))))) մեկ էլ ու՞ր են ; -ը ՞
չնայած մինիֆիկացիայի խնդիր չկա… տանելի ա :Ճ
; (կետ-ստորակետ) սիմվոլը բոլոր հրամաններից հետո ավելացվում է ավտոմատ՝ կոմպիլյատորի կողմից։ Ծրագրավորողը հրամանները հրամանները ; նիշով պետք է բաժանի միայն այն դեպքում, երբ մեկ տողի վրա գրված են մի քանի հրամաններ։
Փոփոխականները կարող են հայտարարվել երկու եղանակով.
1) name := value որտեղ name փոփոխականի տիպը որոշվում է ըստ նրան վերագրած արժեքի։
2) var name type որտեղ բացահայտ տրվում է տիպը, իսկ փոփոխականին վերագրվում է տվյալ տիպի զրոյական արժեքը։ Վերագրման հրամանը (այն արտահայտություն չէ) գրվում է դասական = նիշով։
ինձ դուր է գալիս, երբ վերագրումը նշանակվում է ինչ որ անհավասար բանով, քանի որ այն հավասարում չէ, օրինակ := կամ <=
ինձ դուր չի գալիս երբ հնարավոր է գրել՝ a = a + 5
ու այսպես կորցնելով = նշանը լեզվի նախագծողները արեցին հաջորդ սխալը, օգտագործելով == որպես հավասարության ստուգում։ իսկ երկու նիշ գրելիս ավելի հեշտ է սխալ անել ու գրել այսպես՝
a=1;
if (a = 5) {
… //սա միշտ կկատարվի քանի որ վերագրումը միշտ կհաջողվի
}
ու այդպիսի սխալներ շատ բարդ է գտնել, երկու դեպք գիտեմ, երբ երկու շաբաթ կորցրել են այս սխալի պատճառով։ ու ցավոք, այս սինտաքսը անցել է սի֊ից այլ լեզուներ։
վերագրումը կարծում եմ պետք է լինի այնպես, որ հասկացվի որ այստեղ հավասարության մասին խոսք չկա։
ճիշտ ա… դա ուժեղ արգումենտ ա…
իսկ այդ առումով ամենադաժանը PHP-ն ա. ընդեղ === էլ կա 😀
են դեպքերի համար, երբ ասենք փոփոխականների իրար հավասար են նաև հՈԳՈվ 😀
ահա, ես սովոր չեմ այդ մտածողությանը։ երբ կարող է երկու փոփոխական հավասար լինեն, բայց տարբեր տիպերի, ու հավասար լինեն, ու նույն տիպի լինեն։
ես սիրում եմ երբ կոդը հնարավորին չափ լինում է ստատիկ անալիզի ժամանակ ստուգել, այսինքն կարդալով գրածդ, կամ տալով այն կոմպիլյատորին։
երբ կոմպիլյատորը չի կարողանում գտնել սխալ ու սխալները պետք է գտնել ռանթայմ, դա ոնց որ գիտական մոտեցում չլինի, իմ կարծիքով, ոնց որ փորձես «մետոդոմ տիկա» էլի։ Գրե՞լ եմ, արտահայտել ե՞մ, գրածս ինչի՞ պիտի կատարվի որ իմանամ ճիշտ է գրված թե չէ։ Այսինքն այո, շատ ժամանակ անհնար է առանց ռանթայմ ստուգելու, բայց ես հակված եմ ավելի շատ այն մտքին որ պետք է աշխատել մինիմիլիզացնել դա, քան մաքսիմալիզացնել։
Իմիջայլոց մի քիչ առաջ քոմենթները կարդացի ու երևի ենթագիտակցությանս վրա ազդեց :Դ, մի բան էի գրել ուրտեղ հենց այդպիսի ստուգման հարց էր, ու սխալ էր աշխատում :Ճ կես ժամ տանջվեցի մինջև ջոգեցի թե խնդիրը որտեղ ա, ոչինչ կպատահի 🙂
բայց մի հատ հավասարման նշանով վերագրելը մաթեմատիկայից ա գալիս, տենց էլ անցել ա ծրագրավորման լեզուներ, հետո էլ մտածել են որ հարմար չի որոշ դեպքերում, ու բազմաթիվ հակասական մոտեցումներ են առաջացել:
հմ, իմ հիշելով մաթեմում վերագրում չկա, կա հավասարում։
հենց դա եմ ասում, դպրոցում սովորած մաթեմից հետո a = a + 5 բնավ հասկանալի չէ։
այսինքն հավասարման նշանը սովոր ենք որ հավասարման նշան է, ոչ թե վերագրման։ իսկ վերագրումը պետք է ինչ որ ուղղություն ցույց տա, ինչ որ անհավասարակշռություն։ ու այդ պատճառով ես սիրում եմ := նշանակումը։ (:
Գուգլի աջակցության պատճառով մենք վերջապես ունենք քիչ թե շատ տարածված լեզու(ու այդ լեզվի իրականացում), որն ունի մոդուլներ, ու կոմպիլիացիա է լինում, այսինքն կատարման բարձր արագություն ու հիշողության ցածր օգտագործում է ապահովվում։