Go (програмски језик)

Гоу
Go
Оригинални назив	енгл. Go
Изговара се	гоу
Модел	императивни, конкурентни
Појавио се	10. новембар 2009. (2009-11-10)
Аутор(и)	Google Inc., доприносиоци из заједнице отвореног кода
Дизајнер(и)	Роберт Грисемер Роб Пајк Кен Томпсон
Актуелна верзија	1.15
Датум актуелне верзије	11. август 2020. (2020-08-11)
Систем типова	статички, номинални, структурни
Имплементације	gc (главна имплементација), gccgo (у оквиру ГНУ колекције компилатора), gopherjs (преводи Гоу програме у JavaScript)
Утицаји	Alef, APL, C, CSP, Limbo, Modula-2, Newsqueak, Oberon, Паскал, Пајтон, Smalltalk
Оперативни системи	Линукс, Mac OS X, Microsoft Windows, OpenBSD, FreeBSD, NetBSD, Plan 9, Solaris
Лиценца	Модификована BSD лиценца + патент
Веб-сајт	http://golang.org/
Документација	http://golang.org/doc/

Гоу (енгл. Go) је програмски језик отвореног кода настао у Гуглу 2007. године. Језик су осмислили Роберт Грисемер, Роб Пајк и Кен Томпсон, а намењен је првенствено системском програмирању. Ослањајући се на традицију језика C и Паскал, језик је компилиран, са статичким типовима података, ограниченим структурним типовима, садржи аутоматско управљање меморијом и функционалности за конкурентно програмирање инспирисане комуницирајућим секвенцијалним процесима.

Почетак рада на језику је септембар 2007. године. Званично је промовисан новембра 2009. године под модификованом BSD лиценцом. Данас се користи за мрежне програме, најпре у оквиру Гуглових система, али и у другим компанијама. Постоје две главне имплементације језика: gc, који је главна имплементација коју је развио Гугл и gccgo из ГНУ колекције компајлера. До верзије 1.5, gc имплементација је била написана у мешавини C, асемблер и Гоу кода, а од верзије 1.5, C код је преведен у Гоу.

Историја

Језик је настао као експеримент тројице Гуглових запослених—Роберт Грисемер, Роб Пајк и Кен Томпсон. Идеја је била да се осмисли нови језик за системско програмирање који би решио главне проблеме постојећих језика такве врсте а притом задржао њихове позитивне особине. Нови језик би имао следеће особине:

• био би статички компилиран и могао би да се се користи за велике системе (као Java и C++),
• брз развој читљивих програма, без превише обавезних кључних речи (као код динамичких језика),
• не би захтевао компликоване алате, већ би подржао шири скуп једноставних алата
• подржавао би мрежно и конкурентно програмирање

У интервјуима, тројица дизајнера су изразила да нису љубитељи сложености C++-а, и да је то била главна мотивација за дизајнирање новог језика.

Дизајн језика

Највећи утицај на дизајн језика су језици из породице C и Паскал. Они се од ових језика разликују по додацима који побољшавају концизност, једноставност и безбедност програма.

Кратак преглед особина које карактеришу Гоу:

• Синтакса и окружење које прихвата идеје које се чешће срећу у динамичким језицима.
  • Опциона скраћена декларација и иницијализација променљивих кроз локално закључивање типова података (енгл. local type inference; i := 0 уместо int i = 0;).
  • Брза компилација програма у извршну датотеку.
  • Једноставно управљање пакетима (go get)., као и једноставна и читљива документација пакета на интернету
• Јединствени приступи проблемима:
  • Уграђене функционалности за конкурентно програмирање: лаки процеси (корутине - goroutines), канали за ток података између процеса, и select кључна реч за управљање каналима.
  • Систем интерфејса и уграђивања типова уместо уместо виртуалног и невиртуалног наслеђивања.
  • Скуп алата који производи статичке извршне датотеке које не зависе од динамичких библиотека.
• Тежња ка једноставности језика - спецификација је довољно кратка да програмери могу целу да је запамте.
• Изворне датотеке са кодом су увек кодиране као UTF-8, што омогућује локализовање коментара и документације, али и имена типова, функција, променљивих и константи.

Гоу је често мета следећих критика:

• Недостатак генеричких типова доводи до дупликације кода. Може се симулирати уз помоћ метапрограмирања и рефлексије, али се тада губи на перформансама и провери тачности типова. Стандардна библиотека из тог разлога не нуди генеричке алгоритме.
• Нема могућности проширивања језика (на пример, кроз додавање оператора за корисничке типове), па одређени задаци захтевају више кода.
• Једноставан систем типова који није базиран на Хиндли-Милнер систему смањује безбедност и једноставност програма.
• Аутоматско управљање меморијом узрокује паузе у раду програма, па то умањује могућност примене у системским програмима, у поређењу са језицима у којима се ручно управља меморијом.

Дизајнери језика тврде да су ови недостаци важни за успех језика, и детаљно објашњавају зашто су одређене одлуке донесене. Упркос томе, отворени су за додавање могућности за генеричко програмирање у будућности, као и по питању побољшања у областима генерације кода и смањења трајања паузе приликом аутоматског ослобађања меморије.

Синтакса

Синтакса је најсличнија језицима из C породице језика, али је знатно измењена како би програми били концизнији и читљивији, као и да би подржала нове додатке језику.

Гоу уводи комбиновани оператор := за декларацију и иницијализацију променљивих. Уз помоћ овог оператора могуће је написати скраћен облик декларације и иницијализације који не захтева прецизирање типа података, већ то ради сам компилатор. Ово је супротно од декларације и иницијализације у C-у, где је обавезно увек навести тип променљиве. Постоји и проширена синтакса за декларацију и иницијализацију променљивих, али се она ређе јер је скраћени облик лакши за читање; често се користи само проширена декларација, када је потребно само резервисати име, а компајлер ће сам доделити нулту вредност (нпр. var broj int има вредност 0). Оператор = се користи за додељивање нове вредности променљивој која је већ декларисана.

// Гоу (скраћено) i := 3 s := "tekst" n := [3]float64{1.0, 2.0, 3.0}

// Гоу (продужено) var i int = 3 var s string = "tekst" var n [3]float64 = [3]float64{1.0, 2.0, 3.0}

// C int i = 3; const char * s = "tekst"; double n[3] = {1.0, 2.0, 3.0};

Искази се завршавају са симболом тачка-зарез, али се он не мора наћи у изворном коду на местима где се завршава ред. Алат go fmt из основне дистрибуције избацује овај симбол са места на којима је сувишан.

Функције могу враћати више вредности, па је шаблон враћања пара result, error главни метод индикације постојања грешке настале током позива дате функције. Сличан шаблон се примењује за приступ мапама и за локално проверавање типа податка, са тим што је тада пар који се враћа result, bool, где други параметар указује на тачност операције.

Гоу такође додаје синтаксу за иницијализацију параметара у struct типу по имену, као и за иницијализацију мапа и низова.

Као замену за C-ове for, while и do/while петље, Гоу уводи комбиновану for петљу која заједно са range изразом омогућује једноставну итерацију низова, одсечака, мапа, канала, и ниски.

Типови података

Основни типови података, који су уграђени у језик, су у првом реду нумерички типови. Ту спада и Булов тип података као и цели бројеви int, int8 (byte), int16, int32 (rune), int64, неозначени цели бројеви: uint, uint8, uint16, uint32, uint64, uintptr, бројеви у облику са покретним зарезом float32, float64 и комплексни бројеви complex64, complex128. Такође и ниске (string) спадају у уграђене типове. Ниске су непроменљиве, а помоћу уграђених оператора и кључних речи могуће је спајање, поређење и кодирање из и у UTF-8.

Слогови (енгл. record type) се могу дефинисати уз помоћ кључне речи struct.

Типом податка T и бројем елемената n се дефинише низ означен са [n]T; пошто је број елемената део типа податка, низови којима су типови елемената исти али им је број елемената различит, су различитог типа.

Динамички низови се зову одсечци (енгл. slice); за тип податка T, одсечак који садржи вредности тог типа се означава са []T. Ови низови имају дужину и капацитет којим се означава када треба заузети нови део меморије за проширење одсечка. Неколико одсечака може да дели одређени меморијски простор.

За пар типова података K, V, тип map[K]V означава тип мапе (хеш табела) која мапира кључеве типа K на вредности типа V. Хеш табеле су уграђене у језик, имају посебну синтаксу, и над њима се операције врше уграђеним функцијама.

Канали (енгл. channel) служе за комуникацију између конкурентских процеса и такође имају своју синтаксу. За тип податка T, тип канала се означава са chan T. Језик поседује и скуп уграђених операција којима се вредности могу примати и слати преко канала.

Показивачи постоје за све типове података; за тип податка T, показивач се означава са *T. За разлику од C-а, нема показивачке аритметике, осим кроз тип Pointer из пакета unsafe у стандардној библиотеци.

Поред подршке за интерфејсе, систем типова је номиналан, односно заснива се на експлицитном именовању типова података. Кључна реч type ствара нови тип податка, који представља нови тип (а не алијас као у C-у) и који се разликује од осталих типова података који могу имати исти распоред у меморији (а у случају struct типа, и исти редослед поља). Неке конверзије између типова су уграђене, а додавањем новог типа се могу дефинисати додатне конверзије. Конверзије између типова су увек експлицитне; примера ради, сабирање два броја од којих је један int32 а други float64 захтева да један од два броја буде преведен у тип другог броја.

На пример, помоћу кључне речи type се може дефинисати тип за IPv4 адресе, које су 32-битни цели бројеви без предзнака:

type ipv4addr uint32

Са овом дефиницијом типа ipv4addr(x) интерпретира uint32 вредност у ИП адресу. Просто додељивање вредности x променљивој чији је тип ipv4addr није могуће јер, иако имају исту структуру у меморији, нису исти типови.

Константни изрази могу имати или немати типове; ако немају тип податка, он им се додељује када се њихова вредност додели некој променљивој, под условом да је конверзија могућа током компилације.

Функције такође имају типове. Могу да прихватају ниједан или више аргумената и да врате ниједну или више вредности; све ове вредности имају своје типове, а заједно они одређују потпис, односно тип функције. На пример, func(string, int32) (bool, error) је тип функције која као аргументе прима текст и 32-битни број са предзнаком (редом, string и int32), а враћа бул и грешку (редом, bool и error).

Сваки именовани тип може имати сет метода који је са њим повезан. Претходни пример се може проширити тако да има методе којим се врши штампање у читљивом формату, проверава да ли се налази у одређеном опсегу и слично, зависно од функционалности коју тип треба да има. Типу се метода додаје тако што се између кључне речи func и имена функције дода прималац (енгл. receiver), који се састоји од имена које представља референцу (слично речима this и self у језицима као што су Јава и Пајтон) и типа на који се метода односи.

// Is this the zero broadcast address 255.255.255.255?
func (addr ipv4addr) ZeroBroadcast() bool {
    return addr == 0xFFFFFFFF
}

Због номиналног система типова, ова метода је додата типу ipv4addr, али не и типу uint32.

Иако за њихово дефинисање и позивање постоји посебна синтакса, методе немају засебан тип. Сама синтакса је заправо "синтаксни шећер" (енгл. syntactic sugar), па ако је x променљива којој је додељена вредност чији је тип горепоменути ipv4addr, следеће две линије имају исто значење:

x.ZeroBroadcast()
ZeroBroadcast(x)

Интерфејси

Гоу поседује две особине којима замењује систем наслеђивања из класичног објектно-оријентисаног програмирања. Прво је уграђивање, које представља форму композиције или делегације. Други део су интерфејси, који омогућују полиморфизам у току извршавања програма.

Интерфејси омогућују ограничен облик структурних типова података у оквиру номиналног система типова података. Сваки тип података над којим су дефинисане све методе из интерфејса имплицитно задовољава тај интерфејс. Сам систем интерфејса заснован је на систему протокола из језика Smalltalk. Интерфејс групише типове података у скуп, тако што сам представља листу метода које ти типови морају садрже. Типови који задовољавају одређени интерфејс не морају експлицитно то да нагласе, већ се та провера врши током компилације програма.

Типови Kvadrat и Krug се могу груписати помоћу интерфејса Oblik који од својих типова захтева да садрже методе Obim и Povrsina.

import "math"

type Oblik interface {
    Obim() float64
    Povrsina() float64
}

type Kvadrat struct {
    stranica float64
}
func (kv Kvadrat) Obim() float64 {
    return 4 * kv.stranica
}
func (kv Kvadrat) Povrsina() float64 {
    return kv.stranica * kv.stranica
}

type Krug struct {
    poluprecnik float64
}
func (k Krug) Obim() float64 {
    return math.Pi * k.poluprecnik * 2
}
func (k Krug) Povrsina() float64 {
    return math.Pi * math.Pow(k.poluprecnik, 2)
}

Сада се може дефинисати функција SaberiPovrsine која тражи два аргумента који задовољавају интерфејс Oblik и сабира њихове површине:

func SaberiPovrsine(o1, o2 Oblik) float64 {
    return o1.Povrsina() + o2.Povrsina()
}

SaberiPovrsine(Krug{4}, Kvardrat{2.7})

Пошто је задовољење интерфејса имплицитно, додавање нових типова (нпр. Троугао или Трапез) се своди на дефинисање структуре типа и имплементације одређених метода, а то се може извршити и у оквиру другог пакета.

Стандардна библиотека језика користи интерфејсе у оквиру неколико библиотека. Један од примера је Stringer интерфејс из пакета fmt, који захтева методу String() string; задовољењем овог интерфејса, сваки тип може да одреди како ће његова вредност изгледати приликом штампе. Други пример су интерфејси Reader и Writer, којима се дефинише протокол за улаз и излаз података помоћу метода Read и Write, а користи код пакета за рад са датотекама, мрежним сокетима, стандардним улазом и излазом, баферима бајтова, токовима, , и слично.

Празан интерфејс (interface{}) представља важан случај у оквиру система типова, јер се односи на било који тип податка. Сличан је типу Object у језицима Јава и C#; разликује се од њих по томе што је то интерфејс који задовољавају сви типови укључујући и уграђене као што је int, док Object може држати само инстанце објеката јер представља надтип (енгл. supertype). Податак који је сачуван под типом interface{} се не може користити као аргумент при позиву функција или са уграђеним операторима без конверзије у конкретан тип помоћу наговештавања типа (енгл. type assertion), гранања по типу (енгл. type switch), или испитивањем рефлексијом уз помоћ reflect пакета. Зато што може да држи било који тип податка, interface{} представља један од начина за имплементацију генеричких алгоритама.

Систем пакета

Сваки пакет је дефинисан са два податка: својом путањом (нпр. "compress/bzip2" или "golang.org/x/net/html") и својим именом (нпр. bzip2 или html). Путања пакета је обична ниска, па може имати било какав садржај; пакети које корисници објављују на интернету садрже адресу са које пакет може бити преузет помоћу команде go get, чиме је олакшано управљање пакетима. Позив на други пакет увек садржи и име тог пакета, а да би нека вредност из пакета била видљива, њено мора почињати великим словом (нпр. функција Printf из пакета fmt је видљива у свим другим пакетима који позивају тај пакет, док је функција printf видљива само у оквиру fmt пакета).

Конкурентно програмирање

Језик поседује уграђене функционалности, као и скуп библиотека, који помажу писање конкурентних програма. Овде се конкурентност не односи само на паралелно извршавање програма, већ и на асинхронију: пуштање спорих операција као што је читање података са мреже или из базе података док програм извршава друге послове.

Главна структура за формирање конкурентних процеса је горутина (енгл. goroutine, игра речи са корутина), која представља лаган процес. Када се приликом позива функције испред имена функције нађе кључна реч go, та функција се позива у оквиру нове горутине. Спецификација језика не садржи начин имплементације горутина, а трентутне имплементације користе нити, слично као код језика Ерланг.

Иако стандардна библиотека садржи пакете са класичним структурама за контролу конкурентних процеса, идиоматски начин контроле укључује канале (енгл. channels), који омогућавају размену вредности између горутина. Канали имају своје типове података, па се канал типа chan T може користити само за слање вредности типа T. Операције над каналима користе посебну синтаксу; <-ch је израз који блокира тренутну горутину док не стигне вредност са канала ch, док ch <- x шаље вредност x преко канала ch (при чему може доћи до блокирања док друга горутина не прими ту вредност). Уграђена структура за гранање select (слична структури switch) омогућује имплементирање комуникације без блокирања преко више канала. Гоу има модел меморије који описује начин употребе канала и горутина за безбедно дељење меморије.

Тиме што поседује канале, Гоу се разликује од језика који користе модел учесника (енгл. actor model) као што је Ерланг, где се поруке шаљу директно учесницима (који одговарају горутинама). Модел учесника се може симулирати при чему се уводи кореспонденција између горутина и канала, иако језик дозвољава да више горутина дели један канал, или да једна горутина прихвата и шаље вредности на више канала.

Структурна правила за конкурентност су изведене из Тони Хоровог модела комуницирајућих секвенцијалних процеса. За разлику од претходних језика који користе овај модел, као што су occam и Лимбо, Гоу не поседује механизме за безбедну и провериву конкурентност. Све горутине деле адресни простор, па се променљиви објекти и показивачи могу делити између горутина.

Изостављене особине

Гоу намерно изоставља одређене особине присутне у другим језицима, укључујући наслеђивање, генеричко програмирање, асертивност, аритметику са показивачима, и имплицитне конверзије између типова. Од ових особина, аутори језика су изразили отвореност ка додавању могућности за генеричко програмирање, а бранили су одлуке против додавања осталих особина. Уместо наслеђивања, препоручују коришћење интерфејса за динамичко позивање и композицију типова за поновно коришћење кода.

Што се тиче генеричког програмирања, неке од уграђених функција јесу генеричке (нпр. make/new, append), али се третирају као посебни случајеви; Роб Пајк сматра да је ово слабост језика и да постоји могућност промене. Тим који у оквиру Гугла развија језик је у једном тренутку направио компилатор за експериментални дијалекат језика који има генеричке типове, али га нису пустили у јавност.

Пошто су првобитно изузеци изостављени из језика, додат је panic/recover механизам, који се користи за грешке од којих систем не може да се опорави и које заустављају цео програм, или као пречицу за пропагирање грешака у оквиру пакета (не и између пакета; тада се користи пар result, error који је стандардан начин сигнализирања грешке).

Правила и стил

• Форматирање програма, укључујући индентацију, размаке, положаје заграда и други детаљи визуелног дела кода су стандардизовани уз помоћ алатке gofmt; програм golint врши додатне стилске провере кода.
• Алати и пакети из стандардне библиотеке сугеришу стандардан начин приступа различитим проблемима као што су документација (godoc), тестирање (go test), компилација програма (go build),управљање пакетима (go get) итд.
• Компилатор уводи стриктно поштовање правила која у другим језицима постоје само у облику препорука. Неки од примера укључују забрану кружних зависности (два пакета не могу зависити један од другог), забрану неискориштених пакета и променљивих, и недостатак имплицитних конверзија типова.
• Изостављање неких од особина, као што је map функција из функционалних језика и try/catch/finally структура из објектних језика захтева стил програмирања који је експлцитан, конкретан и императиван.

Алати

Стандардна Гоу дистрибуција садржи следеће алате:

• go build, који компилира изворни код у извршне датотеке
• go run, који покреће програм без компилације, као скрипту
• go test, који покреће систем за тестирање и мерење перформанси програма
• go fmt, који форматира датотеке са изворним кодом сходно договореним правилима
• go get, који служи за управљање спољашњим пакетима помоћу различитих система контроле верзија
• go vet, који проналази грешке помоћу статичке анализе програма
• godoc, који приказује документацију пакета у командној линији или веб читачу
• gorename, који служи за безбедно преименовање типова, функција и променљивих
• go generate, који служи за покретање генеришућих програма као што је Yacc

Поред ових алата, корисници су допринели пишући своје програме који допуњују овај скуп алата. Неки од примера су goimports који проверава које пакете програм користи или не користи, па их додаје или брише са списка, gocode, који у оквиру различитих уређивача текста нуди информације о доступним типовима података и функцијама, и golint, који указује на честе грешке у програмима и на недостатак документације.

Писање пакета је знатно олакшано постојањем go пакета у стандардној библиотеци, који нуди различите механизме за управљање и анализу датотека са изворним кодом.

Примери

Здраво свете

Следећи Гоу програм исписује „Здраво свете!":

package main

import "fmt"

func main() {
    fmt.Println("Здраво свете!")
}

Декларација променљивих

var пром int // Декларација без иницијализације.
var пром int = 42 // Декларација и иницијализација.
var пр1, пр2 int = 42, 1302 // Декларација и иницијализација више пормењивих.
var променљива = 42 // Тип се одрећује на основу вредности која се додељује.
промељива := 42 // Сажетији запис. Могуће једино у телу функције.
const константа = "Ово је константа"

Функције

Једноставна функција која не ради ништа:

func имеФункције() {}

Функција са два параметра:

func имеФункције(параметар1 string, параметар2 int) {}

Краћи запис функције са више параметара истог типа:

func имеФункције(параметар1, параметар2 int) {}

Декларација типа повратне вредности:

func имеФункције() int {
    return 42
}

Функција може да врати више вредности (одједном):

func вратиДва() (int, string) {
    return 42, "друга вредност"
}
var број, ниска = вратиДва()

Враћање више именованих резултата употребом једино return:

func вратиТри() (број1 int, број2 float32, ниска string) {
    број1 = 42
    број2 = 42.0
    ниска = "Вредност ниске"
    return                  // Враћа се број1, број2 и ниска
}
var бр1, бр2, ниска = вратиТри()

Функција као вредност

Функција може да буде додељена променљивој као вредност:

func main() {
    // Функција се додељује променљивој као вредност
    сабери := func(сабирак1, сабирак2 int) int {
        return сабирак1 + сабирак2
    }
    // Позив функције која је додељена променљивој сабери
    fmt.Println(сабери(3, 4))
}

Конкурентно програмирање

Следећи програм показује употребу конкурентних особина за писање асинхроних програма. Програм покреће две горутне: једна чека да корисник упише неки текст, а друга шаље сигнал након пет секунди. select гранање чека да било која од горутина достави поруку функцији main, и извршава се зависно од прве вредности која је стигла (пример адаптиран из књиге Давида Чизнала).

package main

import (
    "fmt"
    "time"
)

func readword(ch chan string) {
    fmt.Println("Упиши реч и притисни Enter.")
    var word string
    fmt.Scanf("%s", &word)
    ch <- word
}

func timeout(t chan bool) {
    time.Sleep(5 * time.Second)
    t <- true
}

func main() {
    t := make(chan bool)
    go timeout(t)

    ch := make(chan string)
    go readword(ch)

    select {
    case word := <-ch:
        fmt.Println("Примио", word)
    case <-t:
        fmt.Println("Истекло време.")
    }
}

HTTP сервер

Код једноставног програма који локално покреће HTTP сервер на адреси: localhost:8080/било шта...

package main

import (
    "fmt"
    "net/http"
)

func поздрав(писац http.ResponseWriter, захтев *http.Request) {
    fmt.Fprintf(писац, "Здраво, тражио си адресу: %s", захтев.URL.Path)
}

func main() {
    http.HandleFunc("/", поздрав)
    http.ListenAndServe(":8080", nil)
}

Литература

• Chisnall, David (2012). The Go Programming Language Phrasebook. Addison-Wesley. ISBN 978-0-13-291900-5. 

Спољашње везе

• Званични веб-сајт
• Незванични извори за Гоу језик