Go е един от модерните езици за програмиране, който набира популярност в много проучвания като предпочитан от разработчиците език. Go има лесен за използване и разбиране синтаксис, като същевременно осигурява производителност от най-високо ниво.
Можете да използвате Go за създаване на различни приложения, от уеб приложения до приложения за команден ред, облачни услуги и работа в мрежа. Екосистемата на Go от пакети на трети страни поддържа много други случаи на употреба.
Go има повечето от функциите, които бихте очаквали в модерен език: генерични кодове, паралелност, извеждане на типа, събиране на боклук и много други.
Първи стъпки с Go
Можете да стартирате Go на повечето операционни системи. Насочете се към страницата за инсталации и изтеглете предпочитана версия на Go за вашата операционна система.
След като изтеглите и инсталирате Go, можете започнете да пишете и изпълнявате Go код във файлове с a .отивам разширение на файл.
Ще откриете, че Go има повечето функции и голяма част от функционалността на други езици за програмиране. Ако имате предишен опит в програмирането, трябва да намерите Go straightforward.
Променливи в Go
Го е доста изразителен на основно ниво. Има два начина, по които можете да декларирате променливи в Go. Можете да използвате вар ключова дума за деклариране на променливи от различни типове данни. След като посочите идентификатора, ще трябва да зададете типа данни на променливата.
вар а низ
вар b вътр
вар c всякакви
вар възраст низ = "пет години"
вар възраст = 5// еквивалентно на променлива възраст int = 5
fmt. Println (възраст)
Можеш да използваш всякакви като тип данни, ако не сте сигурни за типа данни на променливата.
Можете също така да декларирате константи с конст ключова дума по начин, подобен на декларирането на променливи.
конст възраст = "пет години"
Невъзможно е да се променят константи след тяхната декларация.
Go предоставя алтернативен начин за деклариране на променливи във функции. Обърнете внимание на използването на двоеточие преди знака за равенство:
функосновен() {
възраст := "пет години" // еквивалентно на var age = "пет години"
}Условни изрази в Go
Go също има условия за вземане на решения в програмите. Можете да използвате ако и друго изявления във вашия код за обработка на решения.
Ето един пример ако израз, който сравнява две цели числа за равенство:
вар а вътр = 12
ако а == 12 {
fmt. Println("a е равно на дванадесет")
}
Можете да използвате само друго изявления след посочване на an ако изявление и трябва да посочите друго блок след затваряне ако блок:
вар а вътр = 12
ако а == 12 {
fmt. Println("a е равно на дванадесет")
} друго {
fmt. Println("a не е равно на дванадесет")
}
The друго блокът се изпълнява само когато ако изявлението се оценява на невярно. Go не предоставя оператори else-if, но можете да използвате превключвател изрази за сложни условни оператори.
Ето анатомията на a превключвател изявление в Go.
възраст := 7
превключвател възраст {
случай1:
fmt. Println("едно")
случай2:
fmt. Println("две")
случай3:
fmt. Println("три")
по подразбиране:
fmt. Println("нула")
}
Можете да създавате изрази за превключване с превключвател ключова дума, след което можете да посочите различни случаи с случай ключова дума. Можете да управлявате случая по подразбиране, като използвате a по подразбиране ключова дума.
За цикли в Go
Go предоставя for-цикли за повтарящи се задачи и за разлика от повечето езици, в Go няма цикли while или do-while.
Можете да използвате популярния for-цикъл в стил C или диапазон for-цикъл, който поддържат определени структури от данни.
Ето пример за използване на C-style for цикъл в програма Go:
функпринтер() {
за аз := 0; аз <= 3; i++ {
fmt. Println (i)
}
}
Можете да използвате вградения диапазон for-loop на Go върху съставни структури от данни като срезове, карти и масиви. The диапазон функцията връща индекса и елемента от индекса, докато обхожда структурата на данните.
за индекс, стойност := диапазон структура на данни {
}Масиви в Go
Масивите са един от съставните типове данни в Go. Go масивите са подобни на масивите в стил C и имат определена дължина при деклариране и инстанциране.
Ето как можете да декларирате масиви в Go:
вар пристигане [5]низ
arr := [7]вътр{0, 1, 2, 3, 4, 5, 6}
Можете да използвате индексиране за достъп, присвояване и актуализиране на елементи в позиция на масива:
пристигане [3] = "три"
Кодът по-горе актуализира или вмъква низа като четвъртия запис на обр променлива масив.
Срезове в Go
Go предоставя срезове като алтернатива на масивите за работа с данни с неопределена дължина. Срезовете са подобни на масивите, с изключение на това, че можете да промените дължината на срезовете.
Ще трябва да използвате вградения направи функция за създаване на срез. Предайте типа данни и първоначалната дължина на среза към функцията make.
парче := направи([]низ, 9)
парче [2] = "две"
Можете да използвате функцията за добавяне, за да вмъкнете елементи в срезове. По подразбиране, добавям функция вмъква елементи в края на среза.
парче = добавям(парче, "десет")
Операциите за добавяне на срезове може да са скъпи за работа, тъй като Go създава нов масив при всяка операция за добавяне.
Карти в Go
Картите са вграденият асоциативен (двойка ключ-стойност) тип данни в Go. Можете да използвате направи функция за създаване на карта или проста декларация, където ще трябва да създадете картата.
карти := направи(карта[низ]вътр) // използвайки функцията make
карти := карта[низ]вътр{"едно": 1, "две": 2, "три": 3} // деклариране и инстанциране на карта
Можете да получите достъп до стойности в карта, като посочите ключовете. Освен това можете да вмъкнете стойности в карта, като посочите двойка ключ-стойност.
карти ["един"] = 1// вмъкване в картата
едно := карти ["едно"] // достъп до елемент от картата
Можете да използвате Изтрий функция за премахване на двойки ключ-стойност от картите. The Изтрий функцията приема идентификатора на картата и ключа на двойката, която искате да премахнете:
Изтрий(карти, "един")
Функции в Go
Функциите са инструментът за повторна употреба на код в Go. Можете да декларирате функции с функ ключова дума, последвана от идентификатора на функцията:
функосновен() {
}
Функциите могат да приемат аргументи и да връщат стойности. Ще трябва да посочите типа аргумент заедно с идентификатора за аргументи.
функдобавете(х низ, г вътр)вътр {
връщане x + y
}
Ще укажете типа на връщане преди кодовия блок на функцията и ще върнете стойност от посочения тип за функции, които връщат стойности.
Структури в Go
Go не е обектно-ориентиран език по замисъл, но можете да внедрите обектно-ориентирани функции в Go използване на структури.
Структурите са дефинирани от потребителя типове за групиране на други типове данни в един обект. Go структурите могат да съдържат стойности от всякакви поддържани от Go типове, а функциите могат да реализират структури.
Ето как можете да декларирате структура в Go:
Тип Игра структура {
Име низ
година вътр
Време за игра float64
Играчи всякакви
Държави карта[низ]низ
}
The Игра struct има полета с типове карта, низ, цяло число и плаваща запетая. Можете да създадете инстанции на структури със стойности по подразбиране или да им присвоите стойности.
вар mko игра // инстанциране на стойност по подразбиране
// инстанциране със стойности
mko := Игра{
Име: "Стойност",
Година: 1231,
Време за игра: 1345412,
Играчи: [2]низ{"9", "неща"},
данни: карта[низ]вътр{"едно": 1, "две": 2, "три": 2},
}
Функциите могат да имплементират и имат достъп до структурни типове. Ще трябва да посочите параметъра struct преди идентификатора на функцията.
функ(g игра)FindGame(име низ) {
a := g. година // достъп до структурни полета
вар b = g. Държави // достъп до структурни полета
}
Когато предадете структура на функция, функцията има достъп до полетата на структурата и функцията става структурен метод.
Go има много случаи на употреба
Научихте основите на езика за програмиране Go и синтаксиса, за да започнете да пишете програми на Go.
Има много полета и приложения, където можете да използвате Go. Go е широко използван като сървърен език и винаги можете да изследвате изграждането на уеб базирани приложения с него.
