Golang, който също се нарича език за програмиране Go, е език за програмиране с отворен код, проектиран от Google през 2007 г. Версия 1.0 на този език беше пусната през 2012 г. Това е структуриран език за програмиране като C и различни видове приложения като мрежови услуги, облак приложения, уеб приложения и т.н. могат да бъдат разработени от езика Golang. Той съдържа много видове пакети като Python. Много е лесен за научаване, което го прави популярен за начинаещи програмисти. 30 примера за програмиране на Golang са обяснени в този урок, за да научите Golang от основите.
Предпоставки:
Golang се поддържа от различни типове операционни системи. Начинът за инсталиране на Golang на Ubuntu е показан в тази част на урока. Изпълнете следните команди, за да актуализирате системата и да инсталирате Golang в системата, преди да практикувате примерите в този урок.
$ sudo подходяща актуализация
$ sudo ап Инсталирай растат до
Изпълнете следната команда, за да проверите инсталираната версия на Golang.
$ go версия
- Здравей здравей свят
- Голанг низови променливи
- Golang int към низ
- Golang низ към в T
- Конкатенация на низове на Golang
- Многоредов низ на Golang
- Golang разделен низ
- Golang спринтф
- Golang enum
- Голанг структура
- Голански масив
- Голанг комплекти
- Голанг за цикъл
- Golang за обхват
- Golang докато цикъл
- Голанг продължи
- Калъф за превключвател Golang
- Golang случайно число
- Golang сън
- златно време
- Golang uuid
- Golang прочете файл
- Golang чете файл ред по ред
- Golang пише във файл
- Golang проверява дали файлът съществува
- Golan csv
- Голанг ямл
- Golang http заявка
- Аргументи на командния ред на Golang
- Обработка на грешки в Golang
Здравей здравей свят
The основен пакетът на Golang съдържа всички необходими пакети за програмиране на Golang и е необходим за стартиране на изпълнението на скрипта Golang. The fmt пакетът е необходим за импортиране за отпечатване на форматирания низ в терминала. Създайте Golang файл със следния скрипт. Стойността на низа „Hello World.“ ще бъде отпечатана в терминала след изпълнение на скрипта.
//Импортирайте fmt пакета, за да отпечатате изхода
импортиране 'fmt'
//Дефинирайте функцията main(), за да стартирате изпълнението
функ основен () {
//Отпечатайте просто съобщение с новия ред
fmt . Println ( 'Здравей свят.' )
}
Изпълнете следната команда, за да изпълните скрипта. Тук скриптът е записан във файла example1, go.
$ отидете стартирайте example1.goИзпълнете следната команда, за да създадете двоичния файл на файла Golang.
$ отидете изграждане example1.go
Изпълнете следната команда, за да стартирате изпълнимия файл.
$ . / пример1Следният изход ще се появи след изпълнение на горните команди,,
Голанг низови променливи
Низовите променливи могат да се използват без дефиниране на типа данни и с типа данни в Golang. Създайте Golang файл със следния скрипт, който ще отпечата прости низови данни и низови данни с низови променливи. Използването на Printf() и Println() функции са показани в скрипта.
пакет основен//Импортирайте fmt пакета, за да отпечатате изхода
импортиране 'fmt'
//Дефинирайте функцията main().
функ основен () {
//Отпечатайте стойност на низ с нов ред
fmt . Printf ( „Научете Golang от LinuxHint.com. \н ' )
//Дефинирайте първата низова променлива
беше str1 = „Програмиране на Golang.“
//Отпечатайте променливата без нов ред
fmt . Printf ( „Научете %s“ , str1 )
//Дефинирайте втората низова променлива
беше str2 = 'лесен за научаване.'
//Отпечатайте променливата с нов ред
fmt . Println ( 'То е' , str2 )
}
Следният изход ще се появи след изпълнение на горния скрипт. Резултатът от двата свързани низа се отпечатва тук.
Golang int към низ
The strconv.Choke() и strconv.FormatInt() функциите могат да се използват за преобразуване на цялото число в низова стойност в Golang. The strconv.Choke() се използва за преобразуване на целочислената стойност в низ от числа. The strconv.FormatInt() се използва за преобразуване на десетични цели числа в низ. Създайте Golang файл със следния скрипт, който показва начина за преобразуване на цяло число в низ в Golang с помощта на функциите, споменати по-горе. Ще бъде взето число от потребителя и съответната стойност на низа на числото ще бъде отпечатана като изход.
//Добавете основния пакетпакет основен
//Импортирайте пакетите fmt и strconv
импортиране (
'fmt'
'strconv'
)
//Дефинирайте основната функция
функ основен () {
//Деклариране на целочислена променлива
беше н вътр
//Отпечатване на съобщение
fmt . Printf ( „Въведете номер:“ )
//Вземете информация от потребителя
fmt . Сканиране ( и н )
//Преобразуване на цяло число в низ с помощта на функцията Itoa().
конвертирам1 := strconv . удавени ( н )
fmt . Printf ( „Преобразуване на цяло число в низ с помощта на Itoa(): %s \н ' , конвертирам1 )
//Преобразуване на цяло число в низ с помощта на функцията FormatInt().
преобразувам2 := strconv . FormatInt ( int64 ( н ), 10 )
fmt . Printf ( „Преобразуване на цяло число в низ чрез FormatInt(): %s \н ' , преобразувам2 )
}
Следният изход ще се появи след изпълнение на скрипта. Броя. 45 е преобразувано в низ. „45“.
Golang низ към int
The strconv.Atoi() се използва за преобразуване на низа в цяло число в Golang. Той приема низова стойност, която ще бъде преобразувана в цяло число и връща два типа стойности. Една стойност е цяло число, ако разговорът е успешен, а друга стойност е грешката, ако разговорът е неуспешен в противен случай нула стойността ще бъде върната. Създайте Golang файл със следния скрипт, който ще преобразува редица низови стойности в цяло число чрез използване strconv.Atoi() функция. Стойността на низа „342“ ще бъде преобразувана в число 342 и ще бъде отпечатана след изпълнението.
//Добавете основния пакетпакет основен
//Импортирайте пакетите fmt и strconv
импортиране (
'fmt'
'strconv'
)
//Дефинирайте основната функция
функ основен () {
//Деклариране на низова променлива
ул := '342'
//Преобразуване на низ в цяло число с помощта на функцията Atoi().
цена , грешка := strconv . ремарке ( ул )
//проверка за грешка
ако грешка == нула {
//Отпечатайте преобразуваната стойност
fmt . Printf ( „Цената на книгата е %d \н ' , цена )
} друго {
//Отпечатайте съобщението за грешка
fmt . Println ( грешка )
}
}
Следният изход ще се появи след изпълнение на скрипта. Стойността на низа „342“ тук е преобразувана в 342.
Конкатенация на низове на Golang
Създайте Golang файл със следния скрипт, който ще свърже низовете с оператора „+“, като използва функцията Printf(). Функцията Println() е използвана тук за отпечатване на стойността на свързания низ чрез използване на оператора „+“, а функцията Printf() е използвана тук за отпечатване на стойността на свързания низ чрез използване на спецификатора „%s“. В скрипта са декларирани две низови променливи, които се свързват по-късно.
//Добавете основния пакетпакет основен
//Импортирайте fmt пакета, за да отпечатате изхода
импортиране 'fmt'
//Дефинирайте основната функция
функ основен () {
//Деклариране на две низови променливи
беше str1 , str2 низ
//Присвояване на низови стойности
str1 = 'Голан'
str2 = 'Програмиране'
//Свързване на низ чрез оператор '+'.
fmt . Println ( „Свързана низова стойност с помощта на оператор „+“:“ , str1 + str2 )
//Свързване на низ чрез спецификатор '%s'
fmt . Printf ( „Свързана стойност на низ, използваща спецификатор на формат: %s%s \н ' , str1 , str2 )
}
Следният изход ще се появи след изпълнение на скрипта.
Голанг многоредов низ
В следващия пример са показани три различни начина за отпечатване на многоредов текст с помощта на скрипта Golang. Знакът „\n“ е използван в първата низова променлива за генериране на многоредов текст. Обратните отметки (`) са използвани във втория низ за отпечатване на многоредовия текст. Обратните отметки (`) със спецификатори са използвани в третия низ за отпечатване на многоредов текст.
пакет основен//Импортиране на fmt пакета
импортиране 'fmt'
//Дефинирайте основната функция
функ основен () {
//Деклариране на стойност на многоредов низ със знак '\n'
str1 := „Програмирането на Golang е много лесно \н да науча. \н \н '
fmt . Printf ( str1 )
//Деклариране на многоредова низова стойност с backticks(`)
str2 := `Научете
Голанг
от
LinuxHint
Блог.`
fmt . Printf ( '%с \н \н ' , str2 )
//Деклариране на две низови стойности
език := 'голан'
разработчик := 'гугъл'
//Деклариране на стойност на низ с променливи и обратни точки
str3 := `%s
е
развити
от
%s.`
fmt . Printf ( str3 , език , разработчик )
//Добавяне на нов ред
fmt . Println ()
}
Следният изход ще се появи след изпълнение на скрипта. Резултатът от трите низови променливи, които съдържат многоредови низови стойности, е отпечатан тук.
Golang разделен низ
Функцията strings.Split() е използвана за разделяне на низовите данни въз основа на разделителя. Следният скрипт ще вземе низова стойност от потребителя и ще раздели низовата стойност въз основа на двоеточието (:). Общият брой на разделените стойности и първите две разделени стойности ще бъдат отпечатани след изпълнението.
пакет основен//Импортиране на пакетите fmt и низове
импортиране (
'fmt'
'струни'
)
//Дефинирайте основната функция
функ основен () {
//Деклариране на низова променлива
беше ул низ
//Отпечатайте подканващо съобщение
fmt . Printf ( 'Въведете низ с двоеточие(:)- ' )
//Вземете информация от потребителя
fmt . Сканиране ( и ул )
//Дефиниране на разделителя
сепаратор := ':'
//Разделяне на стойността на низа
разделена_стойност := струни . Сплит ( ул , сепаратор )
//Преброяване на броя на разделените стойности
дължина := само ( разделена_стойност )
//Отпечатайте броя на разделените стойности
fmt . Printf ( „Общият брой на разделените стойности е %d \н ' , дължина )
//Отпечатайте разделените стойности
fmt . Println ( „Първата разделена стойност е“ , разделена_стойност [ 0 ])
fmt . Println ( „Втората разделена стойност е“ , разделена_стойност [ 1 ])
}
Следният изход ще се появи след изпълнение на скрипта. Въведената стойност „golang:google“ е разделена на две части въз основа на двоеточието (:).
Golang спринтф
Функцията Sprintf() се използва в Golang за съхраняване на форматираните низови стойности в променлива като други стандартни езици за програмиране. В следния скрипт са декларирани низ и целочислена променлива. Стойностите на тези променливи са форматирани и съхранени в променлива с помощта на функцията Sprintf().
пакет основен//Импортиране на fmt пакета
импортиране 'fmt'
//Дефинирайте основната функция
функ основен () {
//Деклариране на две променливи
беше ул низ
беше никой вътр
//Присвояване на стойност на низ
ул = 'голан'
//Присвояване на числова стойност
никой = 2012 г
//Съхранява стойността на комбинирания низ в променлива
комбиниран_str := fmt . Sprintf ( „Първата версия на %s е пусната през %d.“ , ул , никой )
//Отпечатайте променливата
fmt . Printf ( „Резултатът от Sprintf(): \н %с \н ' , комбиниран_str )
}
Следният изход ще се появи след изпълнение на скрипта.
Golang enum
Enum или enumerator се използва в Golang за деклариране на тип данни на група от свързани постоянни стойности. Декларацията на типа enum в Golang е различна от другите езици за програмиране. Беше деклариран тип enum от 12 стойности и числовата стойност на конкретната стойност на enum беше отпечатана по-късно.
пакет основен//Импортиране на fmt пакета
импортиране 'fmt'
//Декларирайте типа за съхраняване на стойността на месеца в число (1-12)
Тип месец вътр
//Деклариране на константи за стойността на всеки месец, като се започне от 1
конст (
януари месец = йота + 1
февр
март
апр
Може
юни
юли
авг
септ
окт
ноем
дек
)
//Деклариране на основна функция
функ основен () {
//Деклариране на променлива с месечна стойност
беше M_num = Може
//Отпечатайте съответната числова стойност на месеца
fmt . Println ( 'Стойността на месеца в число е ' , M_num )
}
Следният изход ще се появи след изпълнение на скрипта. Съответстващата числова стойност на май е 5.
Голанг структура
Структурата или структурата се използва в Golang за деклариране на тип, който съдържа различни типове променливи. Полезно е за съхраняване на таблични данни или множество записи. В следния скрипт е декларирана структурна променлива от четири елемента. След това са добавени два записа с помощта на дефинираната структурна променлива. Начинът за отпечатване на стойностите на структурата по различни начини е показан в последната част на скрипта.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
//Дефиниране на структура от четири елемента
Тип Продукт структура {
документ за самоличност низ
име низ
размер низ
цена вътр
}
функ основен () {
//Деклариране на първата структурна променлива
продукт1 := Продукт { 'p-1209' , 'HDD' , '5TB' , 80 }
//Деклариране на втората структурна променлива
продукт2 := Продукт { 'p-7342' , 'мишка' , '' , петнадесет }
//Отпечатване на структурните променливи
fmt . Println ( 'Първи продукт: ' , продукт1 )
fmt . Println ( „Втори продукт:“ , продукт2 )
//Отпечатайте четири стойности на първата структурна променлива отделно
fmt . Println ( „Подробности за първия продукт:“ )
fmt . Println ( 'ДОКУМЕНТ ЗА САМОЛИЧНОСТ: ' , продукт1 . документ за самоличност )
fmt . Println ( „Име:“ , продукт1 . име )
fmt . Println ( 'Размер: ' , продукт1 . размер )
fmt . Println ( 'Цена: ' , продукт1 . цена )
}
Следният изход ще се появи след изпълнение на скрипта.
Голански масив
Променливата масив се използва в Golang за съхраняване на множество стойности от конкретния тип данни, подобно на други стандартни езици за програмиране. Начинът за деклариране и достъп до масив от низови стойности и масив от числови стойности е показан в скрипта.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
//Деклариране на масив от низови стойности
str_arr := [ 4 ] низ { „Google com“ , 'ask.com' , 'bing.com' , 'you.com' }
//Отпечатване на масива от низ
fmt . Println ( 'Стойностите на низовия масив са: ' , str_arr )
//Отпечатване на 3-тия елемент от масива
fmt . Println ( „Третата стойност на масива е“ , str_arr [ 2 ])
//Деклариране на масив от числови стойности
int_arr := [ 6 ] вътр { 65 , 3. 4 , 12 , 81 , 52 , 70 }
//Отпечатване на масива от цели числа
fmt . Println ( 'Стойностите на масива с цели числа са: ' , int_arr )
//Отпечатване на 4-тия елемент от масива
fmt . Println ( „Четвъртата стойност на масива е“ , int_arr [ 3 ])
}
Следният изход ще се появи след изпълнение на скрипта.
Голанг комплекти
Наборът е друга структура от данни на Golang за съхраняване на колекция от отделни стойности. Използва се за съхраняване на уникални стойности в обект. Golang няма вградена структура на набор от данни, както другите езици за програмиране. Но тази функция може да бъде реализирана чрез използване на празна структура{} и карта. В следния скрипт променлива set от низове е декларирана чрез използване на карта с празна структура. След това са добавени три стойности, една стойност е изтрита и една стойност е добавена отново в набора. Стойностите на комплекта са отпечатани заедно и поотделно.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
//Дефинирайте набор от низове
просто := карта [ низ ] структура {}{}
//Вмъкнете три елемента в набора, като използвате празна структура
просто [ 'Отивам' ] = структура {}{}
просто [ 'баш' ] = структура {}{}
просто [ 'Python' ] = структура {}{}
//Отпечатване на текущите съществуващи елементи от набора
fmt . Println ( просто )
//Премахване на елемент от набора
Изтрий ( просто , 'Python' )
//Добавяне на нов елемент към набора
просто [ 'Java' ] = структура {}{}
//Отпечатване на зададените стойности след премахване и добавяне на елемент
fmt . Println ( просто )
fmt . Printf ( ' \н Зададените стойности са: \н ' )
//Отпечатайте всеки елемент от набора отделно
за л := диапазон просто {
fmt . Println ( л )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Голанг за цикъл
Цикълът for може да се използва по различни начини и за различни цели в Golang. Използването на три израза за цикъл е показано в следния скрипт. Цикълът ще бъде повторен 5 пъти, за да вземе 5 входни стойности и сумата от тези входни стойности ще бъде отпечатана по-късно.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
//Деклариране на целочислена променлива
беше номер вътр
//Деклариране на променлива за съхраняване на стойността на сумата
беше сума = 0
//Дефиниране на for цикъл
за н := 1 ; n < = 5 ; н ++ {
//Отпечатайте подканващо съобщение
fmt . Printf ( „Въведете номер:“ )
//Вземете информация от потребителя
fmt . Сканиране ( и номер )
//Добавяне на входното число с променливата сума
сума = сума + номер
}
//Отпечатване на резултата от сумирането
fmt . Printf ( „Сумата от пет входни стойности е %d \н ' , сума )
}
Следният изход ще се появи след изпълнение на скрипта. Сборът от 6, 3, 4, 7 и 9 е 29.
Golang за обхват
Диапазонът се използва с for цикъла в Golang за достъп до низ, масив и карта. Начинът за достъп до масив от низове чрез използване на for цикъл с диапазон е показан в следния скрипт. Първият for цикъл ще отпечата само стойностите на масива, а вторият for цикъл ще отпечата индексите и стойностите на масива.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
//Деклариране на масив от низове
цветя := [ 4 ] низ { 'Роза' , 'Лили' , 'Далия' , 'Слънчево цвете' }
fmt . Println ( „Стойностите на масива са:“ )
//Отпечатайте стойностите на масива
за _ , вал := диапазон цветя {
fmt . Println ( вал )
}
fmt . Println ( 'Индексите и стойностите на масива са:' )
//Отпечатайте стойностите на масива въз основа на индекс
за в , вал := диапазон цветя {
fmt . Printf ( „%d := %s \н ' , в + 1 , вал )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Golang докато цикъл
Golang няма цикъл while като другите езици за програмиране. Въпреки това функцията на цикъла while може да бъде реализирана в Golang чрез използване на цикъла for. Начинът за внедряване на цикъл while чрез използване на цикъл for е показан в следния скрипт. Цикълът for ще бъде повторен 4 пъти и ще вземе четири числа. Сумата от тези числа с дробната стойност ще бъде отпечатана по-късно.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
брояч := 1
сума := 0 . 0
беше номер float64
за брояч < = 4 {
//Отпечатайте подканващо съобщение
fmt . Printf ( „Въведете номер:“ )
//Вземете информация от потребителя
fmt . Сканиране ( и номер )
//Добавяне на входното число с променливата сума
сума = сума + номер
//Увеличете брояча с 1
брояч ++
}
//Отпечатайте резултата от сумирането
fmt . Printf ( „Сумата от четири входни стойности е %0,2f \н ' , сума )
}
Следният изход ще се появи след изпълнение на скрипта. Сборът от 6,8, 3,2, 8,5 и 4,9 е 23,40.
Голанг продължи
Операторът continue се използва във всеки цикъл, за да се пропуснат конкретни оператори въз основа на условие. В следващия скрипт цикълът for е използван за повторение на цикъла, който ще пропусне стойностите на 2-ра и четвърта стойност на масива чрез използване на оператора continue.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
брояч := 1
сума := 0 . 0
беше номер float64
за брояч < = 4 {
//Отпечатайте подканващо съобщение
fmt . Printf ( „Въведете номер:“ )
//Вземете информация от потребителя
fmt . Сканиране ( и номер )
//Добавяне на входното число с променливата сума
сума = сума + номер
//Увеличете брояча с 1
брояч ++
}
//Отпечатайте резултата от сумирането
fmt . Printf ( „Сумата от четири входни стойности е %0,2f \н ' , сума )
}
Следният изход ще се появи след изпълнение на скрипта.
Калъф за превключвател Golang
Операторът switch-case в Golang е подобен на другите езици за програмиране, но не се изисква оператор break с всеки оператор case в Golang. Начинът за дефиниране на множество регистрационни стойности вътре в блока за превключване е показан в следния пример.
пакет основен//Импортиране на fmt пакет
импортиране 'fmt'
функ основен () {
беше н вътр
//Отпечатайте подканващо съобщение
fmt . Printf ( 'Въведете стойността на месеца в число: ' )
//Вземете информация от потребителя
fmt . Сканиране ( и н )
//Отпечатване на съобщение въз основа на съвпадащата стойност на регистъра
превключвател н {
случай 1 , 2 , 3 , 4 :
fmt . Println ( „Зимен семестър“. )
случай 5 , 6 , 7 , 8 :
fmt . Println ( 'Летен семестър.' )
случай 9 , 10 , единадесет , 12 :
fmt . Println ( 'Есенен семестър.' )
по подразбиране :
fmt . Println ( „Месечната стойност е извън обхвата.“ )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Golang случайно число
Пакетът math/rand е използван в Golang за генериране на произволни числа. Начинът за генериране на четири вида произволни числа е показан в следния скрипт. Функцията rand.Int() се използва за генериране на случайно число с дълго цяло число. Функцията rand.Intn(n) се използва за генериране на цяло число на случаен принцип от конкретния диапазон и най-високата стойност ще бъде предадена като стойност на аргумента на функцията. 999 е зададено като стойност на аргумента в скрипта. Функцията rand.Float32() се използва за генериране на кратко дробно случайно число, а функцията rand.Float64() се използва за генериране на дълго дробно случайно число.
//Добавяне на основен пакетпакет основен
//Импортирайте необходимите модули
импортиране (
'fmt'
'време'
'математика/ранд'
)
функ основен () {
//Задайте семе за генериране на произволно число
ранд . семена ( време . Сега () . UnixNano ())
//Отпечатване на генерирано произволно цяло число
fmt . Println ( 'Случайна цяло число: ' , ранд . Вътр ())
//Отпечатайте произволното цяло число в рамките на 999
fmt . Println ( 'Произволна цяло число с диапазон: ' , ранд . Вътр ( 999 ))
//Отпечатване на произволни 32 бита с плаваща единица
fmt . Println ( 'Произволна 32-битова плаваща стойност: ' , ранд . Float32 ())
//Отпечатайте произволните 64 бита с плаваща единица
fmt . Println ( 'Произволна 64-битова плаваща стойност: ' , ранд . Float64 ())
}
Следният изход ще се появи след изпълнение на скрипта.
Golang сън
Функцията time.Sleep() се използва в Golang за спиране на изпълнението на скрипта за определен период. Следният скрипт ще изчисли средната стойност на три числа и ще изчака 3 секунди, преди да прекрати скрипта.
//Добавяне на основен пакетпакет основен
//Импортирайте необходимите пакети
импортиране (
'fmt'
'време'
)
функ основен () {
fmt . Println ( „Започнете да изпълнявате скрипта...“ )
//Дефинирайте три променливи
а := 40
b := 30
° С := 29
//Отпечатване на променливите
fmt . Printf ( „Три числа са: %d, %d, %d \н ' , а , b , ° С )
fmt . Println ( „Изчисляване на средната стойност на три числа...“ )
ср := ( а + b + ° С ) / 3
//Забавяне за 3 секунди
време . сън ( 3 * време . Второ )
//Отпечатайте резултатите
fmt . Printf ( „Средната стойност е %d \н ' , ср )
fmt . Println ( „Програмата е прекратена.“ )
}
Следният изход ще се появи след изпълнение на скрипта.
златно време
Пакетът за време се използва в Golang за четене на текущата дата и час. Този пакет има много методи и свойства за четене на датата и часа по различни начини. Датата и часът „Mon Jan 2 15:04:05 -0700 MST 2006“ се използват като референтна стойност в Golang за достъп до датата и часа. Употребите на времевия пакет са показани в следния пример.
пакет основен//Импортирайте необходимите пакети
импортиране (
'fmt'
'време'
)
функ основен () {
//Прочетете текущата дата и час
днес := време . Сега ()
//Отпечатайте текущата дата
fmt . Printf ( „Днес е %s. \н ' , днес . формат ( '02-Януари-2006' ))
//Отпечатване на текущата дата и час
fmt . Printf ( „Текущата дата и час са %s \н .' , днес . формат ( време . RFC1123 ))
}
Следният изход ще се появи след изпълнение на скрипта.
Golang uuid
UUID или универсално уникален идентификатор може да бъде генериран от Golang скрипт. Това е 128-битова уникална стойност за идентифициране на компютърната система. Трябва да изтеглите uuid от github.com/google/uuid преди да изпълните следния скрипт.
Отидете в началната директория и изпълнете следните команди, за да изтеглите необходимия пакет за генериране на uuid от Golang скрипт.
$ go mod init uuid$ вземете github.com / google / uuid
В следващия скрипт първият uuid се генерира чрез използване на функцията uuid.New(), която връща уникален идентификатор. Вторият uuid се генерира от функцията uuid.NewUUID(), която връща две стойности. Стойността съдържа уникалния идентификатор, а втората стойност съдържа съобщението за грешка, ако съществува.
пакет основен//Импортирайте необходимите пакети
импортиране (
'fmt'
'github.com/google/uuid'
)
функ основен () {
//Генериране на уникален идентификатор с помощта на функцията New().
newID := uuid . Нов ()
fmt . Printf ( „Генерираният първи UUID е %s. \н ' , newID )
//Генериране на уникален идентификатор с помощта на функцията NewUUID().
newID , грешка := uuid . НовUUID ()
//Проверка за грешка
ако грешка == нула {
fmt . Printf ( „Генерираният втори UUID е %s. \н ' , newID )
} друго {
fmt . Println ( грешка )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Golang прочете файл
The io/ioutil пакетът на Golang се използва за четене на съдържанието на файл. Функцията ReadFile() на този пакет чете цялото съдържание на файл. Тази функция връща пълното съдържание на файла в променлива, ако файлът съществува, в противен случай ще бъде върнато съобщение за грешка. Начинът за четене на пълното съдържание на съществуващ текстов файл е показан в следния скрипт.
//Добавяне на основен пакетпакет основен
//Импортирайте необходимите пакети
импортиране (
'io/ioutil'
'fmt'
'дневник'
)
функ основен () {
//Прочетете текстов файл
текст , грешка := ioutil . ReadFile ( 'Languages.txt' )
//Проверка за грешка
ако грешка == нула {
fmt . Printf ( „Съдържание на файла: \н \н ' )
fmt . Println ( низ ( текст ))
} друго {
дневник . Фаталф ( „Грешка при четене на файл: %v“ , грешка )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Golang чете файл ред по ред
Пакетът “bufio” на Golang се използва за четене на съдържанието на файл ред по ред. В следващия скрипт bufio.NewScanner() е използван за създаване на обект за четене на файла. След това функцията Scan() е използвана с цикъла за четене и отпечатване на всеки ред от файла.
//Добавяне на основен пакетпакет основен
//Импортирайте необходимите пакети
импортиране (
'fmt'
'Вие'
'буфио'
)
функ основен () {
//Отворете текстов файл за четене
fh , грешка := Вие . Отворете ( 'Languages.txt' )
//Проверка за грешка
ако грешка == нула {
//Сканирайте съдържанието на файла
Прочети := буфио . NewScanner ( fh )
//Прочетете файла ред по ред
за Прочети . Сканиране () {
fmt . Println ( Прочети . Текст ())
}
} друго {
fmt . Println ( грешка )
}
//Затваряне на файла
отлагам fh . Близо ()
}
Следният изход ще се появи след изпълнение на скрипта.
Golang пише във файл
The Вие пакетът на Golang се използва за отваряне на файл за писане и WriteString() функция се използва за запис на съдържание във файл. Начинът за създаване и писане на текстов файл от три реда е чрез използване на Вие пакет.
пакет основен//Импортирайте необходимите пакети
импортиране (
'fmt'
'Вие'
)
функ основен () {
//Отворете файл за писане
fh , грешка1 := Вие . Създавайте ( 'items.txt' )
//Проверка за грешка при създаване на файл
ако грешка1 == нула {
//Запис във файла
_ , грешка2 := fh . WriteString ( 'Химилка \н Молив \н Владетел \н ' )
//Проверете за грешка при запис на файл
ако грешка2 != нула {
fmt . Println ( „Възникна грешка при запис на файл. \н ' )
}
} друго {
fmt . Println ( „Възникна грешка при създаването на файл. \н ' )
}
//Затваряне на файла
отлагам fh . Близо ()
}
Следният изход ще се появи след изпълнение на скрипта. Резултатът показва, че файлът items.txt е създаден успешно.
Golang проверява дали файлът съществува
The Вие пакетът на Golang може да се използва за проверка на съществуването на файла. В следващия скрипт пътят на файла ще бъде взет от скрипта. Ако пътят не съществува, тогава функцията os.State() ще върне an os.ErrNotExist грешка.
пакет основен//Импортирайте необходимия модул
импортиране (
'грешки'
'fmt'
'Вие'
)
функ основен () {
беше файлова пътека низ
fmt . Printf ( „Въведете съществуващо име на файл:“ )
//Вземете пътя на файла от потребителя
fmt . Сканиране ( и файлова пътека )
//Проверете пътя на файла
_ , грешка := Вие . статистика ( файлова пътека )
//Проверете изхода на os.Stat
ако ! грешки . Е ( грешка , Вие . ErrNotExist ) {
fmt . Println ( „Файлът е намерен.“ )
} друго {
fmt . Println ( „Файлът не е намерен.“ )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Golan csv
The „кодиране/csv“ пакет се използва в Golang за четене на съдържанието на CSV файла. The csv.NewReader() функция се използва за четене на CSV файла. Създайте CSV файл, преди да изпълните скрипта от този пример. Ето, клиенти.csv файл е използван за показване на начина на четене на CSV файла.
пакет основен//Импортирайте необходимите пакети
импортиране (
'кодиране/csv'
'fmt'
'Вие'
)
функ основен () {
//Отворете CSV файл за четене
fh , грешка := Вие . Отворете ( 'customers.csv' )
//Проверете за грешка
ако грешка != нула {
fmt . Println ( грешка )
} друго {
//Създайте обект за четене на CSV файла
скенер := csv . NewReader ( fh )
//Прочетете всички записи на CSV файла
записи , _ := скенер . ReadAll ()
//Прочетете CSV файла ред по ред
за _ , r := диапазон записи {
за _ , ° С := диапазон r {
fmt . Printf ( '%с,' , ° С )
}
fmt . Println ()
}
}
//Затваряне на файла
отлагам fh . Близо ()
}
Следният изход ще се появи след изпълнение на скрипта.
Golang yaml
The yaml.Marshal() функцията се използва в Golang за четене на съдържанието на данните на yaml. Трябва да изтеглите ямл пакет за използване на yaml.Marshal() . Отидете в началната директория и изпълнете следната команда, за да изтеглите ямл пакет.
$ иди вземи < а href = 'http://gopkg.in/yaml.v2' > gopkg.in / yaml.v2 а >В следващия скрипт е декларирана структурна променлива от четири елемента, която е била използвана по-късно за дефиниране на yaml обект с данни. След това функцията yaml.Marshal() е използвана за достъп до данните на yaml.
пакет основен//Импортирайте необходимите пакети
импортиране (
'fmt'
'gopkg.in/yaml.v2'
)
//Деклариране на структура от 4 елемента
Тип Книга структура {
Заглавие низ
Автор низ
Публикация низ
Цена низ
}
функ основен () {
//Създаване на обект от структурата
книга1 := Книга {
Заглавие : „Learning Go“ ,
Автор : 'Джон Боднър' ,
Публикация : 'О'Рели' ,
Цена : '$39' ,
}
//Прочетете yaml данните въз основа на структурата
y_данни , грешка := ямл . Маршал ( &книга1 )
//Проверете за грешка
ако грешка == нула {
//Отпечатайте yaml данните
fmt . Println ( низ ( y_данни ))
} друго {
fmt . Printf ( „Грешка при маршалинг. %v“ , грешка )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Golang http заявка
The net/http пакетът на Golang се използва за изпращане на http заявки към уебсайт. Функцията http.Get() се използва за изпращане на заявката. Връща отговора от сайта или съобщението за грешка. Начинът за изпращане на http заявката към уебсайта, https://example.com е показано в следния скрипт.
пакет основен//Импортирайте необходимите пакети
импортиране (
'fmt'
'net/http'
)
функ основен () {
//Изпратете GET заявка до уебсайт
рез , грешка := http . Вземете ( 'https://example.com' )
//Проверка за грешка
ако грешка == нула {
//Отпечатайте отговора, изпратен от уебсайта
fmt . Println ( рез )
} друго {
//Отпечатайте съобщението за грешка
fmt . Println ( грешка )
}
}
Следният изход ще се появи след изпълнение на скрипта.
Аргументи на командния ред на Golang
Стойностите, които се предават по време на изпълнение на скрипта, се наричат стойности на аргументи на командния ред. Пакетът os се използва за четене на стойностите на аргументите на командния ред в Golang. Стойностите на аргументите се съхраняват в масива Args[]. Цикълът for с диапазона е използван в скрипта за отпечатване на стойностите на аргумента без името на скрипта във всеки ред.
пакет основен//Импортира необходимите пакети
импортиране (
'fmt'
'Вие'
)
функ основен () {
fmt . Println ( „Всички стойности на аргументи са:“ )
//Отпечатайте всички стойности на аргументи с името на скрипта
fmt . Println ( Вие . Args )
fmt . Println ( „Стойности на аргумента:“ )
//Отпечатване на всички стойности на аргументи без име на скрипт
за в , _ := диапазон Вие . Args {
ако в == 0 {
продължи
}
fmt . Println ( Вие . Args [ в ])
}
}
Следният изход ще се появи след изпълнение на скрипта.
Обработка на грешки в Golang
Golang няма блок try-catch като другите езици за програмиране. както и да е грешки може да се използва в Golang за обработка на грешки в скрипта. В следващия скрипт цяло число ще бъде взето от потребителя. Ако потребителят вземе отрицателно число, ще се отпечата съобщение за грешка. The грешки.Ново() функцията е използвана тук за генериране на съобщение за грешка.
пакет основен//Импортирайте необходимите пакети
импортиране (
'грешки'
'fmt'
)
функ основен () {
беше н вътр
fmt . Printf ( „Въведете номер:“ )
fmt . Сканиране ( и н )
//Проверете въведената стойност
резултат , грешка := Положителен ( н )
//Проверка за грешка
ако грешка != нула {
fmt . Println ( грешка )
} друго {
fmt . Printf ( „%d %s \н ' , н , резултат )
}
}
///Дефиниране на функция за проверка на положително число
функ Положителен ( никой вътр ) ( низ , грешка ) {
ако номер < 0 {
връщане '' , грешки . Нов ( „Въведете положително число.“ )
} друго {
връщане 'числото е положително.' , нула
}
}
Следният изход ще се появи след изпълнение на скрипта.
Заключение:
Golang сега е популярен език за програмиране, който има много полезни пакети като езика за програмиране Python. Всеки начинаещ потребител може да научи Golang като първи език за програмиране, защото е много лесен за научаване. Основните 30 примера на Golang са обяснени в този урок, за да научите Golang от самото начало и обучаемите ще могат да пишат програми на Golang. Едно от основните ограничения на този език е, че той не съдържа характеристиките на обектно-ориентираното програмиране, но е добър за изучаване на структурирано програмиране.