Програмният език на Google е наблизо от 2009 г., а през 2012 г. езикът достигна официалния си статус v1.0. През тези години се промени много, включително и начина на инсталиране на езика. Още в началната си фаза не са имали официални двоични дистрибуции и е трябвало да създадете Go от изходния код, който е препоръчителният метод, тъй като езикът се променя често или използвате предварително инсталиран пакет за вашата Linux дистрибуция. Тогава подкрепата на Windows беше ограничена, както и подкрепата за CPU архитектури, различни от Intel.

Оттогава нещата се подобриха значително. За Linux има два лесни начина да инсталирате Go. Изтеглете официалната двукомпонентна версия на Linux от страницата "Изтеглени файлове" или изберете предварително инсталиран пакет за вашата Linux дистрибуция. Най-лесният начин да инсталирате Go on Ubuntu е да използвате apt-get :

 sudo apt-get инсталирате golang

След като Go е инсталиран, можете да започнете да разработвате програми. Една от най-простите програми на Go е класическата програма "Hello World!". С помощта на текстов редактор създайте файл, наречен " hellomte.go ", със следния кратък код Go:

 пакет основен импорт "fmt" func main () {fmt.Println ("Здравейте, направи това по-лесно!")}

Тъй като v1.0 от Go, необходимостта от отделни компилационни и линкови команди е премахната и старите 8g и 8l команди са заменени с командата go .

За да стартирате hellomte.go, отворете терминал и сменете директорията в папката, която съдържа файла с изходния код, след което въведете:

 стартирайте hellomte.go

Това ще компилира и стартира програмата Go, но няма да създаде изпълнима двоична програма. За да създадете двоичен и след това го стартирайте, използвайте командата go build :

 отидете изграждане hellomte.go ./hellomte

Силата на конкуренцията

Една от характеристиките на програмния език Go е нейната подкрепа за едновременност, която позволява на програмата да работи с множество задачи наведнъж. Паралелизмът, който е подобен на съпротивлението, позволява на програмата да изпълнява много задачи едновременно, но едновременността продължава една крачка по-нататък, тъй като позволява на тези отделни задачи да комуникират и взаимодействат. В резултат на това Go позволява на програмистите да използват цялото разнообразие от различни съпътстващи проекти, включително работни басейни, тръбопроводи (където една задача се случва една след друга) и синхронни или асинхронни фонови задачи. Основата на тази едновременност е goroutine съчетан с channels и изявлението на Go's select .

Ето една проста програма, която отпечатва низ няколко пъти, като използва съпътстващ горутин:

 основен импорт на пакета ("fmt" "time") func say (и низ) {за i: = 0; i <5; i ++ {fmt.Println (s)}} func main () {go say ("Здравейте, направете по-лесно!") fmt.Println ("Спий малко ...") time.Sleep (100 * time.Millisecond)}

Функцията say() просто изпълнява проста линия за отпечатване на низа (параметър s ) пет пъти. Интересното е как се нарича тази функция. Вместо просто да say("Hello Make Tech Easier!") Ключовата дума go се поставя пред функционалното повикване. Това означава, че функцията ще се изпълнява като отделна задача. Останалата част от main() функция след това просто спи малко, за да даде време на goroutine да завърши.

Резултатът може да ви изненада:

Както можете да видите, функцията say() се изпълнява като goroutine и докато се настройва, останалата част от main() функция продължава, отпечатването на Sleep a little... и след това заспиване. Дотогава goroutine е активен и започва да отпечатва низа пет пъти. Накрая програмата завършва след достигането на ограничението за изчакване.

Канали

goroutines могат да комуникират, като използват канали. Канал отваря линия за комуникация между две различни части на програмата Go. Обикновено функцията ще се нарича " goroutine и ако трябва да изпрати обратно данни (например от мрежова операция), тя може да използва канал, за да премине по тези данни. Ако друга част от програмата "Го" чака тези данни, тя ще заспи, докато данните не са готови. Каналите се създават с помощта на функцията make() и могат да бъдат предавани като параметри на goroutines .

Помислете за този код:

 пакет основен импорт ("fmt") func say (и низ, c chan int) {var i int за i = 0; i <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) go say ("Hello Make Tech Easier!", c) sts: = <- c fmt.Println sts)}

Функцията say() е много подобна на първия пример, с изключение на това, че вторият параметър е канал и след отпечатването на низа броят на повторенията ще бъде изпратен надолу по канала чрез кода на кода c <- i .

Основната функция създава канал, започва функцията say() като goroutine и след това чака данните да слизат по канала, sts := <- c преди отпечатването на резултата.

заключение

Езикът "Go" е напреднал значително през последните няколко години, ако не сте го погледнали наскоро, може би сега е добро време!