Golang, care se mai numește și limbajul de programare Go, este un limbaj de programare open-source conceput de Google în 2007. Versiunea 1.0 a acestui limbaj a fost lansată în 2012. Este un limbaj de programare structurat precum C și diferite tipuri de aplicații, cum ar fi servicii de rețea, cloud aplicațiile, aplicațiile web etc. pot fi dezvoltate prin limbajul Golang. Conține multe tipuri de pachete precum Python. Este foarte ușor de învățat, ceea ce face acest limbaj popular pentru programatorii noi. 30 de exemple de programare Golang au fost explicate în acest tutorial pentru a învăța Golang din elementele de bază.
Cerințe preliminare:
Golang este suportat de diferite tipuri de sisteme de operare. Modul de instalare a Golang pe Ubuntu a fost prezentat în această parte a tutorialului. Rulați următoarele comenzi pentru a actualiza sistemul și instalați Golang pe sistem înainte de a exersa exemplele din acest tutorial.
$ sudo actualizare apt
$ sudo apt instalare să crească până la
Rulați următoarea comandă pentru a verifica versiunea instalată a Golang.
$ versiunea go
- Bună ziua, lume
- Variabile de șir Golang
- Golang int la șir
- Coarda Golang la in t
- Concatenarea șirurilor Golang
- Golang șir multilinie
- Snur despicat Golang
- Golang sprintf
- Golang enum
- Golang struct
- matrice Golan
- Golang setează
- Golang pentru buclă
- Golang pentru gamă
- Golang while bucla
- Golang continuă
- Carcasa comutatorului Golang
- Număr aleatoriu Golang
- Somnul Golang
- epocă de aur
- Golang uuid
- Golang citiți fișierul
- Golang a citit fișierul linie cu linie
- Golang scrie în fișier
- Golang verifica dacă fișierul există
- Golan csv
- Golang yaml
- Golang http cerere
- Argumente ale liniei de comandă Golang
- Tratarea erorilor Golang
Bună ziua, lume
The principal pachetul Golang conține toate pachetele necesare pentru programarea Golang și este necesar pentru a începe execuția scriptului Golang. The fmt pachetul este necesar pentru import pentru imprimarea șirului formatat în terminal. Creați un fișier Golang cu următorul script. Valoarea șirului, „Hello World.” va fi tipărită în terminal după executarea scriptului.
//Importă pachetul fmt pentru a imprima rezultatul
import 'fmt'
//Definește funcția main() pentru a începe execuția
func principal () {
//Tipărește un mesaj simplu cu noua linie
fmt . Println ( 'Salut Lume.' )
}
Rulați următoarea comandă pentru a executa scriptul. Aici, scriptul a fost salvat în fișierul example1, go.
$ go run example1.goRulați următoarea comandă pentru a construi fișierul binar al fișierului Golang.
$ du-te construi example1.go
Rulați următoarea comandă pentru a rula fișierul executabil.
$ . / exemplu1Următoarea ieșire va apărea după executarea comenzilor de mai sus,,
Variabile de șir Golang
Variabilele șir pot fi utilizate fără a defini tipul de date și cu tipul de date în Golang. Creați un fișier Golang cu următorul script care va tipări date șir simple și datele șir cu variabilele șir. Utilizările de Printf() și Println() funcțiile au fost afișate în script.
pachet principal//Importă pachetul fmt pentru a imprima rezultatul
import 'fmt'
//Definește funcția main().
func principal () {
//Tipărește o valoare șir cu o linie nouă
fmt . Printf ( „Învățați Golang de la LinuxHint.com. \n ' )
//Definește prima variabilă șir
a fost str1 = 'Programare Golang.'
//Tipărește variabila fără o nouă linie
fmt . Printf ( „Învățați %s” , str1 )
//Definește a doua variabilă șir
a fost str2 = 'usor de invatat.'
//Tipărește variabila cu o linie nouă
fmt . Println ( 'Este' , str2 )
}
Următoarea ieșire va apărea după executarea scriptului de mai sus. Ieșirea celor două șiruri concatenate este tipărită aici.
Golang int la șir
The strconv.Choke() și strconv.FormatInt() funcțiile pot fi folosite pentru a converti întregul într-o valoare șir în Golang. The strconv.Choke() este folosit pentru a converti valoarea întreagă într-un șir de numere. The strconv.FormatInt() funcția este utilizată pentru a converti valorile întregi bazate pe zecimale în șir. Creați un fișier Golang cu următorul script care arată modul de conversie a întregului într-un șir în Golang utilizând funcțiile menționate mai sus. Un număr va fi luat de la utilizator și valoarea șirului corespunzătoare numărului va fi tipărită ca rezultat.
//Adăugați pachetul principalpachet principal
//Importă pachetele fmt și strconv
import (
'fmt'
'strconv'
)
//Definește funcția principală
func principal () {
//Declară o variabilă întreagă
a fost n int
//Tipărește un mesaj
fmt . Printf ( „Introduceți un număr:” )
//Preia intrare de la utilizator
fmt . Scanează ( & n )
//Conversia întregului în șir folosind funcția Itoa().
converti1 := strconv . înecat ( n )
fmt . Printf ( „Conversia întregului în șir folosind Itoa(): %s \n ' , converti1 )
//Conversia întregului în șir folosind funcția FormatInt().
converti 2 := strconv . FormatInt ( int64 ( n ), 10 )
fmt . Printf ( „Conversia întregului în șir folosind FormatInt(): %s \n ' , converti2 )
}
Următoarea ieșire va apărea după executarea scriptului. Numarul. 45 a fost convertit în șir. „45”.
Golang șir la int
The strconv.Atoi() funcția este utilizată pentru a converti șirul într-un număr întreg în Golang. Este nevoie de o valoare șir care va fi convertită într-un număr întreg și returnează două tipuri de valori. O valoare este numărul întreg dacă conversația are succes și o altă valoare este eroarea dacă conversația nu are succes în caz contrar zero valoarea va fi returnată. Creați un fișier Golang cu următorul script care va converti un număr de valori de șir într-un număr întreg utilizând strconv.Atoi() funcţie. Valoarea șirului, „342” va fi convertită în număr 342 și tipărită după execuție.
//Adăugați pachetul principalpachet principal
//Importă pachetele fmt și strconv
import (
'fmt'
'strconv'
)
//Definește funcția principală
func principal () {
//Declară o variabilă șir
str := '342'
// Convertiți șirul în întreg folosind funcția Atoi().
Preț , a greșit := strconv . remorcă ( str )
//verificați erorile
dacă a greșit == zero {
//Tipărește valoarea convertită
fmt . Printf ( „Prețul cărții este %d \n ' , Preț )
} altfel {
//Tipărește mesajul de eroare
fmt . Println ( a greșit )
}
}
Următoarea ieșire va apărea după executarea scriptului. Valoarea șirului, „342” a fost convertită la 342 aici.
Concatenarea șirurilor Golang
Creați un fișier Golang cu următorul script care va concatena șirurile cu operatorul „+” utilizând funcția Printf(). Funcția Println() a fost folosită aici pentru a tipări valoarea șirului concatenat folosind operatorul „+”, iar funcția Printf() a fost folosită aici pentru a tipări valoarea șirului concatenat folosind specificatorul „%s”. Două variabile șir au fost declarate în script care sunt concatenate ulterior.
//Adăugați pachetul principalpachet principal
//Importă pachetul fmt pentru a imprima rezultatul
import 'fmt'
//Definește funcția principală
func principal () {
//Declară două variabile șir
a fost str1 , str2 şir
//Atribuiți valori de șir
str1 = 'Golan'
str2 = 'Programare'
//Concatenarea șirului folosind operatorul „+”.
fmt . Println ( „Valoare șir concatenat folosind operatorul „+”:” , str1 + str2 )
//Concatenarea șirului folosind specificatorul „%s”.
fmt . Printf ( „Valoarea șirului concatenat folosind specificatorul de format: %s%s \n ' , str1 , str2 )
}
Următoarea ieșire va apărea după executarea scriptului.
Golang șir cu mai multe linii
În exemplul următor au fost prezentate trei moduri diferite de a imprima textul cu mai multe linii utilizând scriptul Golang. Caracterul „\n” a fost folosit în prima variabilă șir pentru a genera textul cu mai multe linii. Tacurile înapoi (`) au fost folosite în al doilea șir pentru a tipări textul cu mai multe rânduri. Backtick-urile (`) cu specificatori au fost folosite în al treilea șir pentru a imprima text pe mai multe rânduri.
pachet principal//Importă pachetul fmt
import 'fmt'
//Definește funcția principală
func principal () {
//Declară o valoare de șir cu mai multe linii cu caracterul „\n”.
str1 := „Programarea Golang\este foarte ușoară \n a invata. \n \n '
fmt . Printf ( str1 )
//Declară o valoare de șir cu mai multe linii cu backticks(`)
str2 := „Învățați
Golang
din
LinuxHint
Blog.`
fmt . Printf ( „%s \n \n ' , str2 )
//Declară două valori de șir
limba := 'golan'
dezvoltator := 'Google'
//Declară o valoare șir cu variabile și backtick-uri
str3 := `%s
este
dezvoltat
de
%s.`
fmt . Printf ( str3 , limba , dezvoltator )
//Adăugați o linie nouă
fmt . Println ()
}
Următoarea ieșire va apărea după executarea scriptului. Ieșirea celor trei variabile șir care conțin valori de șir de mai multe linii a fost tipărită aici.
Snur despicat Golang
Funcția strings.Split() a fost folosită pentru a împărți datele șirurilor pe baza separatorului. Următorul script va prelua o valoare șir de la utilizator și va împărți valoarea șirului pe baza punctelor (:). Numărul total de valori împărțite și primele două valori împărțite vor fi tipărite după execuție.
pachet principal//Importă pachetele fmt și strings
import (
'fmt'
'siruri de caractere'
)
//Definește funcția principală
func principal () {
//Declară o variabilă șir
a fost str şir
//Tipărește un mesaj prompt
fmt . Printf ( 'Introduceți un șir cu două puncte(:)-' )
//Preia intrare de la utilizator
fmt . Scanează ( & str )
//Definește separatorul
separator := ':'
//Se împarte valoarea șirului
valoare_divizată := siruri de caractere . Despică ( str , separator )
//Contorizează numărul de valori împărțite
lungime := numai ( valoare_divizată )
//Tipărește numărul de valori împărțite
fmt . Printf ( „Numărul total de valori împărțite este %d \n ' , lungime )
//Tipărește valorile împărțite
fmt . Println ( „Prima valoare împărțită este” , valoare_divizată [ 0 ])
fmt . Println ( „A doua valoare împărțită este” , valoare_divizată [ 1 ])
}
Următoarea ieșire va apărea după executarea scriptului. Valoarea de intrare, „golang:google” a fost împărțită în două părți în funcție de două puncte (:).
Golang sprintf
Funcția Sprintf() este utilizată în Golang pentru a stoca valorile șirurilor formatate într-o variabilă, ca și alte limbaje de programare standard. Un șir și o variabilă întreagă au fost declarate în următorul script. Valorile acestor variabile au fost formatate și stocate într-o variabilă folosind funcția Sprintf().
pachet principal//Importă pachetul fmt
import 'fmt'
//Definește funcția principală
func principal () {
//Declară două variabile
a fost str şir
a fost pe unu int
//Atribuiți valoare șirului
str = 'golan'
//Atribuiți valoare numărului
pe unu = 2012
//Stochează valoarea șirului combinat într-o variabilă
combinate_str := fmt . Sprintf ( „Prima versiune de %s este lansată în %d.” , str , pe unu )
//Tipărește variabila
fmt . Printf ( „Ieșirea Sprintf(): \n %s \n ' , combinate_str )
}
Următoarea ieșire va apărea după executarea scriptului.
Golang enum
Enum sau enumeratorul a fost folosit în Golang pentru a declara un tip de date dintr-un grup de valori constante asociate. Declarația de tip enum în Golang este diferită de alte limbaje de programare. A fost declarat un tip de enumerare de 12 valori, iar valoarea numerică a unei anumite valori de enumerare a fost tipărită ulterior.
pachet principal//Importă pachetul fmt
import 'fmt'
//Declarați tipul pentru a stoca valoarea lunii în număr (1-12)
tip Lună int
//Declară constante pentru valoarea fiecărei luni începând de la 1
const (
luna ianuarie = iotă + 1
feb
Mar
Aprilie
Mai
Iunie
iul
aug
sept
oct
nov
Dec
)
//Declară funcția principală
func principal () {
//Declară variabila cu o valoare lunară
a fost M_num = Mai
//Tipărește valoarea numerică corespunzătoare a lunii
fmt . Println ( „Valoarea lunii în număr este” , M_num )
}
Următoarea ieșire va apărea după executarea scriptului. Valoarea numerică corespunzătoare a mai este 5.
Golang struct
Structura sau structura este folosită în Golang pentru a declara un tip care conține diferite tipuri de variabile. Este util pentru stocarea datelor tabelare sau a înregistrărilor multiple. În scriptul următor, a fost declarată o variabilă de structură de patru elemente. Apoi, două înregistrări au fost adăugate utilizând variabila struct definită. Modul de imprimare a valorilor structurii în diferite moduri a fost prezentat în ultima parte a scriptului.
pachet principal//Import pachet fmt
import 'fmt'
//Definește o structură de patru elemente
tip Produs struct {
id şir
Nume şir
mărimea şir
Preț int
}
func principal () {
//Declară prima variabilă de structură
produs1 := Produs { 'p-1209' , „HDD” , „5TB” , 80 }
//Declară a doua variabilă de structură
produs2 := Produs { „p-7342” , 'Mouse' , '' , cincisprezece }
//Tipărește variabilele de structură
fmt . Println ( 'Primul produs:' , produs1 )
fmt . Println ( 'Al doilea produs: ' , produs2 )
//Tipărește separat patru valori ale primei variabile de structură
fmt . Println ( 'Detalii primul produs:' )
fmt . Println ( 'ID:' , produs1 . id )
fmt . Println ( 'Nume: ' , produs1 . Nume )
fmt . Println ( 'Mărimea: ' , produs1 . mărimea )
fmt . Println ( 'Preț: ' , produs1 . Preț )
}
Următoarea ieșire va apărea după executarea scriptului.
matrice Golan
Variabila matrice este folosită în Golang pentru a stoca mai multe valori ale unui anumit tip de date, ca și alte limbaje de programare standard. Modul de declarare și accesare a unui tablou de valori șir și a unui tablou de valori numerice a fost afișat în script.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
//Declară o matrice de valori șir
str_arr := [ 4 ] şir { „Google com” , „ask.com” , „bing.com” , „tu.com” }
//Tipărește matricea șirului de caractere
fmt . Println ( 'Valorile matricei de șiruri sunt: ' , str_arr )
//Tipărește al 3-lea element al matricei
fmt . Println ( „A treia valoare a matricei este” , str_arr [ 2 ])
//Declară o matrice de valori numerice
int_arr := [ 6 ] int { 65 , 3. 4 , 12 , 81 , 52 , 70 }
//Tipărește matricea întregului
fmt . Println ( 'Valorile matricei întregi sunt: ' , int_arr )
//Tipărește al 4-lea element al matricei
fmt . Println ( „A 4-a valoare a matricei este” , int_arr [ 3 ])
}
Următoarea ieșire va apărea după executarea scriptului.
Golang setează
Setul este o altă structură de date a Golang pentru a stoca o colecție de valori distincte. Este folosit pentru a stoca valori unice într-un obiect. Golang nu are o structură de date set încorporată ca alte limbaje de programare. Dar această caracteristică poate fi implementată folosind struct{} goale și map. În următorul script, o variabilă setată de șiruri de caractere a fost declarată folosind o hartă cu structura goală. Apoi, trei valori au fost adăugate, o valoare a fost ștearsă și o valoare a fost adăugată din nou în set. Valorile setului au fost tipărite împreună și separat.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
//Definește un set de șiruri de caractere
doar := Hartă [ şir ] struct {}{}
//Inserați trei elemente în set folosind o structură goală
doar [ 'Merge' ] = struct {}{}
doar [ 'Bash' ] = struct {}{}
doar [ 'Piton' ] = struct {}{}
//Tipărește elementele curente existente ale setului
fmt . Println ( doar )
//Elimină un element din set
șterge ( doar , 'Piton' )
//Adăugați un nou element la set
doar [ 'Java' ] = struct {}{}
//Tipărește valorile setate după eliminarea și adăugarea unui element
fmt . Println ( doar )
fmt . Printf ( ' \n Valorile stabilite sunt: \n ' )
//Tipărește fiecare element al setului separat
pentru l := gamă doar {
fmt . Println ( l )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Golang pentru buclă
Bucla for poate fi folosită în diferite moduri și în scopuri diferite în Golang. Utilizarea a trei expresii pentru buclă a fost prezentată în scriptul următor. Bucla va fi repetată de 5 ori pentru a lua 5 valori de intrare, iar suma acestor valori de intrare va fi tipărită mai târziu.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
//Declară o variabilă întreagă
a fost număr int
//Declară o variabilă pentru a stoca valoarea sumei
a fost sumă = 0
//Definește o buclă for
pentru n := 1 ; n < = 5 ; n ++ {
//Tipărește un mesaj prompt
fmt . Printf ( „Introduceți un număr:” )
//Preia intrare de la utilizator
fmt . Scanează ( & număr )
//Adăugați numărul de intrare cu variabila sumă
sumă = sumă + număr
}
//Tipărește rezultatul însumării
fmt . Printf ( „Suma a cinci valori de intrare este %d \n ' , sumă )
}
Următoarea ieșire va apărea după executarea scriptului. Suma 6, 3, 4, 7 și 9 este 29.
Golang pentru gamă
Intervalul este utilizat cu bucla for din Golang pentru a accesa șir, matrice și hartă. Modul de accesare a unei matrice de șiruri de caractere prin utilizarea unei bucle for cu interval a fost prezentat în următorul script. Prima buclă for va tipări numai valorile matricei, iar a doua buclă for va tipări indecșii și valorile matricei.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
//Declară o matrice de șir
flori := [ 4 ] şir { 'Trandafir' , 'Crin' , 'Dalia' , „Floarea soarelui” }
fmt . Println ( „Valorile matricei sunt:” )
//Tipărește valorile matricei
pentru _ , val := gamă flori {
fmt . Println ( val )
}
fmt . Println ( „Indici și valori ale matricei sunt:” )
//Tipărește valorile matricei pe baza indexului
pentru în , val := gamă flori {
fmt . Printf ( „%d := %s \n ' , în + 1 , val )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Golang while bucla
Golang nu are buclă while ca alte limbaje de programare. Cu toate acestea, caracteristica buclei while poate fi implementată în Golang folosind bucla for. Modul de implementare a unei bucle while prin utilizarea unei bucle for a fost prezentat în următorul script. Bucla for va fi repetată de 4 ori și va lua patru numere. Suma acestor numere cu valoarea fracționată va fi tipărită ulterior.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
tejghea := 1
sumă := 0 . 0
a fost număr float64
pentru contor < = 4 {
//Tipărește un mesaj prompt
fmt . Printf ( „Introduceți un număr:” )
//Preia intrare de la utilizator
fmt . Scanează ( & număr )
//Adăugați numărul de intrare cu variabila sumă
sumă = sumă + număr
//Măriți contorul cu 1
tejghea ++
}
//Tipărește rezultatul însumării
fmt . Printf ( „Suma a patru valori de intrare este %0,2f \n ' , sumă )
}
Următoarea ieșire va apărea după executarea scriptului. Suma 6,8, 3,2, 8,5 și 4,9 este 23,40.
Golang continuă
Instrucțiunea continue este folosită în orice buclă pentru a omite anumite instrucțiuni bazate pe o condiție. În următorul script, bucla for a fost folosită pentru a repeta bucla care va omite valorile celei de-a 2-a și a patra valori ale matricei folosind instrucțiunea continue.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
tejghea := 1
sumă := 0 . 0
a fost număr float64
pentru contor < = 4 {
//Tipărește un mesaj prompt
fmt . Printf ( „Introduceți un număr:” )
//Preia intrare de la utilizator
fmt . Scanează ( & număr )
//Adăugați numărul de intrare cu variabila sumă
sumă = sumă + număr
//Măriți contorul cu 1
tejghea ++
}
//Tipărește rezultatul însumării
fmt . Printf ( „Suma a patru valori de intrare este %0,2f \n ' , sumă )
}
Următoarea ieșire va apărea după executarea scriptului.
Carcasa comutatorului Golang
Declarația switch-case din Golang este similară cu celelalte limbaje de programare, dar nu este necesară nicio instrucțiune break cu fiecare instrucțiune case din Golang. Modul de definire a mai multor valori de caz în interiorul blocului de comutare a fost prezentat în exemplul următor.
pachet principal//Import pachet fmt
import 'fmt'
func principal () {
a fost n int
//Tipărește un mesaj prompt
fmt . Printf ( 'Introduceți valoarea lunii în număr: ' )
//Preia intrare de la utilizator
fmt . Scanează ( & n )
//Tipărește mesajul pe baza valorii majuscule potrivite
intrerupator n {
caz 1 , 2 , 3 , 4 :
fmt . Println ( „Semestrul de iarnă”. )
caz 5 , 6 , 7 , 8 :
fmt . Println ( „Semestrul de vară”. )
caz 9 , 10 , unsprezece , 12 :
fmt . Println ( 'Semetrul din toamnă.' )
Mod implicit :
fmt . Println ( „Valoarea lunii este în afara intervalului.” )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Număr aleatoriu Golang
Pachetul math/rand a fost folosit în Golang pentru a genera numere aleatorii. Modul de generare a patru tipuri de numere aleatorii a fost prezentat în următorul script. Funcția rand.Int() este utilizată pentru a genera un număr întreg lung aleatoriu. Funcția rand.Intn(n) este utilizată pentru a genera un număr întreg aleatoriu din domeniul particular și cea mai mare valoare va fi transmisă ca valoare argument a funcției. 999 este setat ca valoare a argumentului în script. Funcția rand.Float32() este folosită pentru a genera un număr aleator fracționar scurt, iar funcția rand.Float64() este folosită pentru a genera un număr aleator fracțional lung.
//Adăugați pachetul principalpachet principal
//Importați modulele necesare
import (
'fmt'
'timp'
'matematică/rand'
)
func principal () {
//Setați sămânța pentru a genera un număr aleatoriu
rand . Sămânță ( timp . Acum () . UnixNano ())
//Tipărește un întreg aleator generat
fmt . Println ( „Valoare întreagă aleatorie:” , rand . Int ())
//Tipărește întregul aleatoriu în 999
fmt . Println ( 'Valoare întreagă aleatorie cu interval: ' , rand . Int ( 999 ))
//Tipărește float aleatoriu de 32 de biți
fmt . Println ( „Valoare variabilă aleatorie pe 32 de biți:” , rand . Plutitor32 ())
//Tipărește float aleatoriu de 64 de biți
fmt . Println ( „Valoare variabilă aleatorie pe 64 de biți:” , rand . Float64 ())
}
Următoarea ieșire va apărea după executarea scriptului.
Somnul Golang
Funcția time.Sleep() este folosită în Golang pentru a întrerupe execuția scriptului pentru o anumită perioadă. Următorul script va calcula media a trei numere și va aștepta 3 secunde înainte de a termina scriptul.
//Adăugați pachetul principalpachet principal
//Importați pachetele necesare
import (
'fmt'
'timp'
)
func principal () {
fmt . Println ( „Începeți să executați scriptul...” )
//Definește trei variabile
A := 40
b := 30
c := 29
//Tipărește variabilele
fmt . Printf ( „Trei numere sunt: %d, %d, %d \n ' , A , b , c )
fmt . Println ( „Calculul mediei a trei numere...” )
medie := ( A + b + c ) / 3
//Întârziere 3 secunde
timp . Dormi ( 3 * timp . Al doilea )
//Tipărește rezultatele
fmt . Printf ( „Valoarea medie este %d \n ' , medie )
fmt . Println ( „Programul s-a încheiat”. )
}
Următoarea ieșire va apărea după executarea scriptului.
epocă de aur
Pachetul de timp este folosit în Golang pentru a citi data și ora curente. Acest pachet are multe metode și proprietăți pentru a citi data și ora în moduri diferite. Data și ora, „Lun 2 ian 15:04:05 -0700 MST 2006” sunt folosite ca valoare de referință în Golang pentru a accesa data și ora. Utilizările pachetului de timp au fost prezentate în exemplul următor.
pachet principal//Importați pachetele necesare
import (
'fmt'
'timp'
)
func principal () {
//Citiți data și ora curente
astăzi := timp . Acum ()
//Tipărește data curentă
fmt . Printf ( „Astăzi este %s. \n ' , astăzi . Format ( '02-ian-2006' ))
//Tipărește data și ora curente
fmt . Printf ( „Data și ora curente sunt %s \n .' , astăzi . Format ( timp . RFC1123 ))
}
Următoarea ieșire va apărea după executarea scriptului.
Golang uuid
UUID-ul sau identificatorul unic universal poate fi generat de scriptul Golang. Este o valoare unică de 128 de biți pentru a identifica sistemul informatic. Trebuie să descărcați uuid-ul din github.com/google/uuid înainte de a executa următorul script.
Accesați directorul principal și rulați următoarele comenzi pentru a descărca pachetul necesar pentru a genera scriptul uuid by Golang.
$ go mod init uuid$ mergeți să obțineți github.com / Google / uuid
În următorul script, primul uuid este generat utilizând funcția uuid.New() care returnează un identificator unic. Al doilea uuid este generat de funcția uuid.NewUUID() care returnează două valori. Valoarea conține identificatorul unic, iar a doua valoare conține mesajul de eroare dacă acesta există.
pachet principal//Importați pachetele necesare
import (
'fmt'
„github.com/google/uuid”
)
func principal () {
//Generează un ID unic folosind funcția New().
ID nou := uuid . Nou ()
fmt . Printf ( „Primul UUID generat este %s. \n ' , ID nou )
//Generează un ID unic folosind funcția NewUUID().
ID nou , a greșit := uuid . NouUUID ()
//Verificați erorile
dacă a greșit == zero {
fmt . Printf ( „Al doilea UUID generat este %s. \n ' , ID nou )
} altfel {
fmt . Println ( a greșit )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Golang citiți fișierul
The io/ioutil pachetul Golang este folosit pentru a citi conținutul unui fișier. Funcția ReadFile() a acestui pachet citește întregul conținut al unui fișier. Această funcție returnează întregul conținut al fișierului într-o variabilă dacă fișierul există, altfel va fi returnat un mesaj de eroare. Modul de citire a întregului conținut al unui fișier text existent a fost prezentat în următorul script.
//Adăugați pachetul principalpachet principal
//Importați pachetele necesare
import (
'io/ioutil'
'fmt'
'Buturuga'
)
func principal () {
//Citește un fișier text
text , a greșit := ioutil . Citiți fișierul ( „Languages.txt” )
//Verificați erorile
dacă a greșit == zero {
fmt . Printf ( „Conținutul fișierului: \n \n ' )
fmt . Println ( şir ( text ))
} altfel {
Buturuga . Fatalf ( „Eroare de citire a fișierului: %v” , a greșit )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Golang a citit fișierul linie cu linie
Pachetul „bufio” al lui Golang este folosit pentru a citi conținutul unui fișier linie cu linie. În următorul script, bufio.NewScanner() a fost folosit pentru a crea un obiect pentru a citi fișierul. Apoi, funcția Scan() a fost folosită împreună cu bucla pentru a citi și tipări fiecare linie a fișierului.
//Adăugați pachetul principalpachet principal
//Importați pachetele necesare
import (
'fmt'
'tu'
'bufio'
)
func principal () {
//Deschideți un fișier text pentru citire
fh , a greșit := tu . Deschis ( „Languages.txt” )
//Verificați erorile
dacă a greșit == zero {
//Scanați conținutul fișierului
citit := bufio . NewScanner ( fh )
//Citiți fișierul linie cu linie
pentru citit . Scanează () {
fmt . Println ( citit . Text ())
}
} altfel {
fmt . Println ( a greșit )
}
//Închide fișierul
amâna fh . Închide ()
}
Următoarea ieșire va apărea după executarea scriptului.
Golang scrie în fișier
The tu pachetul Golang este folosit pentru a deschide un fișier pentru scriere și WriteString() funcția este folosită pentru a scrie conținut într-un fișier. Modul de a crea și de a scrie un fișier text de trei linii este prin utilizarea fișierului tu pachet.
pachet principal//Importați pachetele necesare
import (
'fmt'
'tu'
)
func principal () {
//Deschideți un fișier pentru scriere
fh , err1 := tu . Crea ( „items.txt” )
//Verificați eroarea de creare a fișierului
dacă err1 == zero {
//Scrieți în fișier
_ , err2 := fh . WriteString ( 'Pix \n Creion \n Rigla \n ' )
//Verificați eroarea de scriere a fișierului
dacă err2 != zero {
fmt . Println ( „A apărut o eroare de scriere a fișierului. \n ' )
}
} altfel {
fmt . Println ( „A apărut o eroare la crearea fișierului. \n ' )
}
//Închide fișierul
amâna fh . Închide ()
}
Următoarea ieșire va apărea după executarea scriptului. Rezultatul arată că fișierul items.txt a fost creat cu succes.
Golang verifică dacă fișierul există
The tu pachetul Golang poate fi folosit pentru a verifica existența fișierului. În următorul script, calea fișierului va fi preluată din script. Dacă calea nu există, atunci funcția os.State() va returna un os.ErrNotExist eroare.
pachet principal//Importa modulul necesar
import (
'erori'
'fmt'
'tu'
)
func principal () {
a fost calea fișierului şir
fmt . Printf ( 'Introduceți un nume de fișier existent: ' )
//Ia calea fișierului de la utilizator
fmt . Scanează ( & calea fișierului )
//Verificați calea fișierului
_ , eroare := tu . Stat ( calea fișierului )
//Verificați ieșirea os.Stat
dacă ! erori . Este ( eroare , tu . ErrNuExist ) {
fmt . Println ( „Fișierul a fost găsit”. )
} altfel {
fmt . Println ( „Fișierul nu a fost găsit”. )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Golan csv
The „codificare/csv” pachetul este folosit în Golang pentru a citi conținutul fișierului CSV. The csv.NewReader() funcția este utilizată pentru a citi fișierul CSV. Creați un fișier CSV înainte de a executa scriptul din acest exemplu. Aici clienti.csv fișierul a fost folosit pentru a arăta modul de citire a fișierului CSV.
pachet principal//Importați pachetele necesare
import (
„codificare/csv”
'fmt'
'tu'
)
func principal () {
//Deschideți un fișier CSV pentru citire
fh , a greșit := tu . Deschis ( „clienți.csv” )
//Verificați eroarea
dacă a greșit != zero {
fmt . Println ( a greșit )
} altfel {
//Creează un obiect pentru a citi fișierul CSV
scaner := csv . NewReader ( fh )
//Citiți toate înregistrările fișierului CSV
înregistrări , _ := scaner . Citeste tot ()
//Citiți fișierul CSV linie cu linie
pentru _ , r := gamă înregistrări {
pentru _ , c := gamă r {
fmt . Printf ( „%s,” , c )
}
fmt . Println ()
}
}
//Închide fișierul
amâna fh . Închide ()
}
Următoarea ieșire va apărea după executarea scriptului.
Golang yaml
The yaml.Marshal() funcția este utilizată în Golang pentru a citi conținutul datelor yaml. Trebuie să descărcați yaml pachet pentru a utiliza yaml.Marshal() . Accesați directorul principal și rulați următoarea comandă pentru a descărca yaml pachet.
$ du-te și ia < A href = „http://gopkg.in/yaml.v2” > gopkg.in / yaml.v2 A >În următorul script, a fost declarată o variabilă de structură de patru elemente care a fost folosită ulterior pentru a defini un obiect yaml cu date. Apoi, funcția yaml.Marshal() a fost folosită pentru a accesa datele yaml.
pachet principal//Importați pachetele necesare
import (
'fmt'
„gopkg.in/yaml.v2”
)
//Declară o structură de 4 elemente
tip Carte struct {
Titlu şir
Autor şir
Publicare şir
Preț şir
}
func principal () {
//Creează un obiect al structurii
cartea 1 := Carte {
Titlu : „Învățați să mergeți” ,
Autor : „John Bodner” ,
Publicare : 'O'Relly' ,
Preț : „39 USD” ,
}
//Citiți datele yaml pe baza structurii
y_data , a greșit := yaml . Marshall ( &cartea1 )
//Verificați eroarea
dacă a greșit == zero {
//Tipărește datele yaml
fmt . Println ( şir ( y_data ))
} altfel {
fmt . Printf ( „Eroare la triaj. %v” , a greșit )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Golang http cerere
The net/http pachetul Golang este folosit pentru a trimite cererile http către un site web. Funcția http.Get() este utilizată pentru a trimite cererea. Returnează răspunsul de la site sau mesajul de eroare. Modul de trimitere a solicitării http către site-ul web, https://example.com a fost arătat în următorul script.
pachet principal//Importați pachetele necesare
import (
'fmt'
'net/http'
)
func principal () {
//Trimiteți o solicitare GET către un site web
res , a greșit := http . obține ( „https://example.com” )
//Verificați erorile
dacă a greșit == zero {
//Tipărește răspunsul trimis de site-ul web
fmt . Println ( res )
} altfel {
//Tipărește mesajul de eroare
fmt . Println ( a greșit )
}
}
Următoarea ieșire va apărea după executarea scriptului.
Argumente ale liniei de comandă Golang
Valorile care sunt transmise în momentul execuției scriptului sunt numite valori ale argumentului din linia de comandă. Pachetul os este folosit pentru a citi valorile argumentului liniei de comandă în Golang. Valorile argumentelor sunt stocate în matricea Args[]. Bucla for cu interval a fost folosită în script pentru a imprima valorile argumentului fără numele scriptului în fiecare linie.
pachet principal//Importă pachetele necesare
import (
'fmt'
'tu'
)
func principal () {
fmt . Println ( „Toate valorile argumentelor sunt:” )
//Tipărește toate valorile argumentului cu numele scriptului
fmt . Println ( tu . Args )
fmt . Println ( „Valorile argumentului:” )
//Tipărește toate valorile argumentului fără un nume de script
pentru în , _ := gamă tu . Args {
dacă în == 0 {
continua
}
fmt . Println ( tu . Args [ în ])
}
}
Următoarea ieșire va apărea după executarea scriptului.
Tratarea erorilor Golang
Golang nu are un bloc try-catch ca alte limbaje de programare. Însă erori pachetul poate fi folosit în Golang pentru a gestiona erorile din script. În următorul script, un număr întreg va fi luat de la utilizator. Dacă utilizatorul ia un număr negativ, va fi tipărit un mesaj de eroare. The erori.Nou() funcția a fost folosită aici pentru a genera mesajul de eroare.
pachet principal//Importați pachetele necesare
import (
'erori'
'fmt'
)
func principal () {
a fost n int
fmt . Printf ( „Introduceți un număr:” )
fmt . Scanează ( & n )
//Verificați valoarea de intrare
rezultat , a greșit := Pozitiv ( n )
//Verificați erorile
dacă a greșit != zero {
fmt . Println ( a greșit )
} altfel {
fmt . Printf ( „%d %s \n ' , n , rezultat )
}
}
///Definește funcția pentru a verifica numărul pozitiv
func Pozitiv ( pe unu int ) ( şir , eroare ) {
dacă num < 0 {
întoarcere '' , erori . Nou ( „Tastați un număr pozitiv”. )
} altfel {
întoarcere „numărul este pozitiv”. , zero
}
}
Următoarea ieșire va apărea după executarea scriptului.
Concluzie:
Golang este un limbaj de programare popular acum, care are multe pachete utile, cum ar fi limbajul de programare Python. Orice utilizator începător poate învăța Golang ca prim limbaj de programare deoarece este foarte ușor de învățat. Cele 30 de exemple de bază Golang au fost explicate în acest tutorial pentru a învăța Golang de la început, iar cursanții vor putea scrie programe în Golang. Una dintre limitările majore ale acestui limbaj este că nu conține caracteristicile programării orientate pe obiecte, dar este bun pentru învățarea programarii structurate.