dexblog.ro
GO

Învață Go: comenzi explicate cu exemple

526 de comenzi 52 de categorii

Go (sau Golang) este limbajul creat la Google pentru servere, unelte de linie de comandă și servicii în cloud. Este simplu, compilat, foarte rapid și are concurența integrată prin goroutine și canale.

Mai jos găsești cuvintele cheie, funcțiile predefinite (len, append, make), comenzile go run, go build, go mod și funcțiile celor mai folosite pachete standard: fmt, strings, os, time, slices, sync, net/http, encoding/json și altele.

Toate exemplele au fost verificate cu go vet, compilate și rulate; rezultatul afișat este cel real. Un program Go începe din funcția main() a pachetului main.

Cuvinte cheie și controlul execuției 8 comenzi

Variabile, constante și tipuri 9 comenzi

Funcții, pachete și vizibilitate 10 comenzi

Array-uri, slice-uri, map-uri și struct-uri 4 comenzi

Metode, interfețe și generics 6 comenzi

Erori, panic și recover 2 comenzi

Goroutine și canale 3 comenzi

Funcții predefinite (builtin) 10 comenzi

Tipuri predefinite 8 comenzi

Comanda go, module și teste 18 comenzi

Afișare și formatare (fmt) 11 comenzi

Căutare și comparare în texte (strings) 9 comenzi

Împărțire, înlocuire și transformare (strings) 15 comenzi

strings.Builder și strings.Reader 3 comenzi

Conversii între text și numere (strconv) 13 comenzi

Octeți: pachetul bytes și bytes.Buffer 10 comenzi

Caractere Unicode și UTF-8 (unicode, unicode/utf8) 8 comenzi

Expresii regulate (regexp) 7 comenzi

Fișiere și directoare (os) 28 de comenzi

Variabile de mediu (os) 7 comenzi

Procesul, utilizatorul și sistemul (os) 9 comenzi

Fișiere deschise (os.File) 15 comenzi

Cititori și scriitori (io) 17 comenzi

Citire și scriere cu buffer (bufio) 13 comenzi

Căi de fișiere (path/filepath) 19 comenzi

Comenzi externe și semnale (os/exec, os/signal) 11 comenzi

Argumente din linia de comandă (flag) 11 comenzi

Fișiere încorporate în program (embed) 1 comandă

Jurnalizare simplă (log) 8 comenzi

Jurnalizare structurată (log/slog) 19 comenzi

Teste și benchmark-uri (testing) 12 comenzi

Matematică: pachetul math 22 de comenzi

Numere aleatorii: math/rand/v2 8 comenzi

Sortare: pachetul sort 4 comenzi

Slice-uri: pachetul slices 22 de comenzi

Map-uri: pachetul maps 6 comenzi

Comparare și iteratori: cmp, iter 4 comenzi

Heap, listă înlănțuită și unsafe 7 comenzi

Data și ora (time.Time) 19 comenzi

Durate, pauze și temporizatoare 10 comenzi

Sincronizare (sync) 13 comenzi

Operații atomice (sync/atomic) 9 comenzi

Context, anulare și limite de timp 10 comenzi

Erori (errors) 6 comenzi

Server HTTP (net/http) 17 comenzi

Client HTTP (net/http) 5 comenzi

Adrese URL (net/url) 6 comenzi

JSON (encoding/json) 11 comenzi

CSV (encoding/csv) 4 comenzi

Codări: Base64 și hex 4 comenzi

Hash-uri și numere aleatorii sigure (crypto) 7 comenzi

Șabloane (text/template, html/template) 8 comenzi

Toate funcțiile

Lista completă a cuvintelor cheie, a comenzilor go și a funcțiilor din biblioteca standard incluse în această secțiune, cu pachetul din care fac parte. Cele cu link au o pagină dedicată.

Limbajul Go, funcții predefinite și comanda go (110)

Funcție Ce face
break Oprește imediat bucla for, switch-ul sau select-ul curent; cu etichetă, o buclă exterioară.
case O ramură dintr-un switch, type switch sau select, cu una sau mai multe valori.
chan Tipul canal (chan T): transmite valori între goroutine în siguranță.
const Declară constante: valori fixe, calculate la compilare.
continue Sare la următoarea iterație a buclei for.
default Ramura dintr-un switch sau select executată când nicio altă ramură nu se potrivește.
defer Amână un apel până la ieșirea din funcție; folosit pentru Close, Unlock și curățenie.
else Ramura lui if executată când condiția este falsă; else if adaugă alte condiții.
fallthrough Trece din ramura curentă a unui switch în următoarea, fără a-i verifica condiția.
for Singura buclă din Go: clasică, de tip while, infinită sau cu range.
func Declară funcții, metode și funcții anonime; acceptă mai multe rezultate.
go Pornește un apel de funcție într-o goroutine nouă, care rulează în paralel.
goto Sare la o etichetă din aceeași funcție; rar folosit.
if Execută un bloc doar dacă o condiție bool este adevărată; acceptă o instrucțiune scurtă.
import Aduce pachete din biblioteca standard sau din alte module în fișierul curent.
interface Definește un set de metode; orice tip care le are o implementează automat.
map Tipul dicționar map[K]V: legături cheie-valoare cu căutare rapidă.
package Primul rând al fiecărui fișier Go: numele pachetului din care face parte.
range Parcurge în for slice-uri, map-uri, texte, canale, numere și iteratori.
return Încheie funcția și trimite apelantului valorile rezultat.
select Așteaptă mai multe operații pe canale și o execută pe prima pregătită.
struct Tip compus din câmpuri cu nume și tipuri proprii.
switch Alege o ramură după o valoare sau după prima condiție adevărată, fără break.
type Definește un tip nou (struct, interfață, funcție) sau un alias pentru unul existent.
var Declară variabile, cu tip sau cu valoare inițială; valoarea implicită este zero.
main și pachetul main Pachetul main cu funcția main() devine program executabil; execuția începe în main().
variabile și := Declararea variabilelor cu var sau scurt cu := (tip dedus), doar în funcții.
tipuri de bază bool, string, întregi, numere reale și complexe, byte și rune; conversii explicite.
zero values Variabilele fără valoare primesc valoarea zero: 0, „”, false sau nil.
pointeri *T ține adresa unei variabile; &x dă adresa, *p citește sau modifică valoarea.
slice-uri Lista dinamică []T: fereastră peste un array, cu len, cap și append.
array-uri Șir cu lungime fixă [n]T; lungimea face parte din tip, atribuirea copiază tot.
map-uri Lucrul cu map-uri: adăugare, citire cu v, ok, ștergere, parcurgere în ordine sortată.
struct-uri Definirea și folosirea struct-urilor: literale, câmpuri, copii, tag-uri JSON.
metode Funcții legate de un tip prin receptor (valoare sau pointer).
interfețe Comportament descris prin metode, implementat implicit; io.Writer, fmt.Stringer.
embedding Încorporarea unui tip în altul: câmpurile și metodele lui devin accesibile direct.
generics Funcții și tipuri cu parametri de tip [T constrângere] (Go 1.18).
erori (error) Erorile sunt valori: funcțiile returnează error, verificat cu if err != nil.
panic și recover panic oprește execuția normală; recover dintr-un defer îl poate opri.
goroutine Fire de execuție ușoare pornite cu go; așteptate cu sync.WaitGroup.
canale (channels) Canale cu sau fără buffer pentru comunicarea și sincronizarea goroutinelor.
closures Funcții anonime care țin minte variabilele din jurul lor.
funcții variadice Funcții care primesc oricâte argumente prin …T; un slice se trimite cu s….
type assertion x.(T) scoate valoarea concretă dintr-o interfață; forma cu ok evită panic.
type switch switch v := x.(type) alege ramura după tipul concret dintr-o interfață.
iota Contor pentru blocurile const: 0, 1, 2…; folosit pentru enumerări.
init() Funcție rulată automat la pornire, înainte de main().
for range peste funcții (iteratori) Iteratori iter.Seq parcurși direct cu for range (Go 1.23).
string-uri și rune Text UTF-8: len dă octeți, range dă rune; conversii []rune și []byte.
constante netipizate Constantele fără tip se adaptează tipului necesar și au precizie mare.
vizibilitate (exportat/neexportat) Majusculă = exportat din pachet; literă mică = vizibil doar în pachet.
module și pachete Pachet = director cu fișiere .go; modul = proiect cu go.mod și dependențe.
teste (testing) Teste în fișiere _test.go, funcții TestXxx(t *testing.T), rulate cu go test.
go run Compilează și rulează imediat un program, fără să lase executabil.
comanda go
go build Compilează pachetele și creează executabilul; și pentru alte sisteme (GOOS/GOARCH).
comanda go
go test Rulează testele, exemplele și benchmark-urile; -v, -run, -cover, -race.
comanda go
go mod init Creează go.mod și transformă directorul într-un modul.
comanda go
go mod tidy Adaugă dependențele lipsă și le șterge pe cele nefolosite din go.mod și go.sum.
comanda go
go get Adaugă, actualizează sau elimină dependențe ale modulului.
comanda go
go install Compilează un program și îl pune în GOBIN sau GOPATH/bin.
comanda go
go fmt Formatează codul în stilul standard Go (gofmt).
comanda go
go vet Găsește greșeli probabile: formate Printf greșite, mutex copiat, wg.Add în goroutine.
comanda go
go doc Afișează documentația unui pachet, funcții sau tip, direct în terminal.
comanda go
go env Afișează și salvează setările uneltei go: GOPATH, GOOS, GOPROXY etc.
comanda go
go version Afișează versiunea Go sau versiunea cu care a fost compilat un executabil.
comanda go
go work Workspace (go.work) pentru lucrul pe mai multe module locale deodată.
comanda go
go generate Rulează comenzile din comentariile //go:generate, pentru cod generat.
comanda go
go clean Șterge executabilele și, la cerere, cache-ul de build, teste sau module.
comanda go
go list Listează pachete sau module și informații despre ele, în text sau JSON.
comanda go
clear Golește un map sau pune pe zero elementele unui slice (Go 1.21).
import "builtin"
close Închide un canal: range se oprește, primirea dă ok == false.
import "builtin"
delete Șterge o cheie dintr-un map; nu face nimic dacă cheia lipsește.
import "builtin"
max Cea mai mare valoare dintre argumente: numere sau texte (Go 1.21).
import "builtin"
min Cea mai mică valoare dintre argumente: numere sau texte (Go 1.21).
import "builtin"
panic Oprește execuția normală a goroutinei; programul se încheie dacă nu există recover.
import "builtin"
print Scrie argumentele pe stderr, fără separatori; doar pentru depanare.
import "builtin"
println Scrie argumentele pe stderr, cu spații și rând nou; doar pentru depanare.
import "builtin"
complex Construiește un număr complex din partea reală și cea imaginară.
import "builtin"
imag Partea imaginară a unui număr complex.
import "builtin"
real Partea reală a unui număr complex.
import "builtin"
append Adaugă elemente la finalul unui slice și returnează slice-ul rezultat.
import "builtin"
make Creează slice-uri, map-uri și canale gata de folosit.
import "builtin"
new Alocă o variabilă și returnează un pointer la ea; din Go 1.26 acceptă și o expresie.
import "builtin"
recover Oprește un panic când este apelat într-o funcție amânată cu defer.
import "builtin"
cap Capacitatea unui slice, array sau canal.
import "builtin"
copy Copiază elemente dintr-un slice în altul și returnează câte a copiat.
import "builtin"
len Lungimea unui slice, array, map, canal sau numărul de octeți ai unui text.
import "builtin"
any Alias pentru interface{}: poate ține orice valoare; constrângere în generics.
import "builtin"
bool Tipul logic, cu valorile true și false.
import "builtin"
byte Alias pentru uint8: un octet.
import "builtin"
comparable Constrângere pentru tipurile care se pot compara cu == (chei de map).
import "builtin"
complex128 Număr complex cu părți float64; tipul implicit pentru literale ca 3+4i.
import "builtin"
complex64 Număr complex cu părți float32.
import "builtin"
error Interfața predefinită pentru erori: are metoda Error() string.
import "builtin"
float32 Număr real în precizie simplă (circa 7 cifre).
import "builtin"
float64 Număr real în precizie dublă (circa 15 cifre); tipul implicit pentru zecimale.
import "builtin"
int Întreg cu semn de 64 de biți pe sistemele actuale; tipul întreg implicit.
import "builtin"
int16 Întreg cu semn pe 16 biți: -32768…32767.
import "builtin"
int32 Întreg cu semn pe 32 de biți: circa ±2,1 miliarde.
import "builtin"
int64 Întreg cu semn pe 64 de biți: circa ±9,2·10^18.
import "builtin"
int8 Întreg cu semn pe 8 biți: -128…127.
import "builtin"
rune Alias pentru int32: un caracter Unicode, scris între apostroafe (‘ș’).
import "builtin"
string Text: secvență de octeți UTF-8 nemodificabilă.
import "builtin"
uint Întreg fără semn, de 64 de biți pe sistemele actuale.
import "builtin"
uint16 Întreg fără semn pe 16 biți: 0…65535.
import "builtin"
uint32 Întreg fără semn pe 32 de biți: 0…circa 4,3 miliarde.
import "builtin"
uint64 Întreg fără semn pe 64 de biți: 0…circa 1,8·10^19.
import "builtin"
uint8 Întreg fără semn pe 8 biți: 0…255; byte este alias pentru el.
import "builtin"
uintptr Întreg fără semn cât o adresă de memorie; folosit cu unsafe și syscall.
import "builtin"

Text, formatare și expresii regulate (203)

Funcție Ce face
fmt.Append Formatează valorile ca Sprint și adaugă rezultatul la un []byte.
import "fmt"
fmt.Appendf Formatează după un șablon ca Sprintf și adaugă rezultatul la un []byte.
import "fmt"
fmt.Appendln Formatează ca Sprintln (spații, rând nou) și adaugă rezultatul la un []byte.
import "fmt"
fmt.Errorf Creează o eroare cu mesaj formatat; %w împachetează o eroare existentă.
import "fmt"
fmt.FormatString Reconstruiește directiva (ex. „%8.2f”) în metoda Format a unui fmt.Formatter.
import "fmt"
fmt.Fprint Scrie valorile într-un io.Writer, cu regulile lui Print.
import "fmt"
fmt.Fprintf Scrie text formatat (%d, %s, %.2f) într-un io.Writer: fișier, buffer, răspuns HTTP.
import "fmt"
fmt.Fprintln Scrie valorile într-un io.Writer, cu spații între ele și rând nou la final.
import "fmt"
fmt.Fscan Citește valori separate prin spații dintr-un io.Reader în variabile.
import "fmt"
fmt.Fscanf Citește valori dintr-un io.Reader după un format cu verbe.
import "fmt"
fmt.Fscanln Citește valori dintr-un io.Reader până la capătul rândului.
import "fmt"
fmt.Print Afișează valorile; pune spații doar între valorile care nu sunt texte, fără rând nou.
import "fmt"
fmt.Printf Afișează text formatat cu verbe: %v, %d, %s, %q, %.2f, %T, %x.
import "fmt"
fmt.Println Afișează valorile separate prin spații și trece la rând nou.
import "fmt"
fmt.Scan Citește de la tastatură valori separate prin spații sau rânduri noi.
import "fmt"
fmt.Scanf Citește de la tastatură după un format cu verbe (%d, %s, %f).
import "fmt"
fmt.Scanln Citește de la tastatură valori de pe un singur rând.
import "fmt"
fmt.Sprint Returnează valorile transformate în text, fără să afișeze nimic.
import "fmt"
fmt.Sprintf Returnează textul formatat cu verbe, fără să-l afișeze.
import "fmt"
fmt.Sprintln Returnează valorile ca text, cu spații între ele și rând nou la final.
import "fmt"
fmt.Sscan Citește valori separate prin spații dintr-un string în variabile.
import "fmt"
fmt.Sscanf Citește valori dintr-un string după un format, de ex. „%d-%d-%d” pentru o dată.
import "fmt"
fmt.Sscanln Citește valori dintr-un string până la primul rând nou.
import "fmt"
fmt.Stringer Interfața cu metoda String() string, folosită de fmt la afișarea valorilor.
import "fmt"
strings.Clone Returnează o copie nouă a textului, în memorie separată.
import "strings"
strings.Compare Compară două texte octet cu octet: -1, 0 sau +1.
import "strings"
strings.Contains Verifică dacă un text conține alt text.
import "strings"
strings.ContainsAny Verifică dacă textul conține măcar unul dintre caracterele date.
import "strings"
strings.ContainsFunc Verifică dacă vreun caracter din text respectă o condiție (ex. unicode.IsDigit).
import "strings"
strings.ContainsRune Verifică dacă textul conține un anumit caracter (rune).
import "strings"
strings.Count Numără aparițiile, fără suprapuneri, ale unui text în alt text.
import "strings"
strings.Cut Taie textul în două la prima apariție a separatorului; spune dacă l-a găsit.
import "strings"
strings.CutLast Taie textul în două la ultima apariție a separatorului (Go 1.27).
import "strings"
strings.CutPrefix Scoate prefixul dat și spune dacă textul îl avea.
import "strings"
strings.CutSuffix Scoate sufixul dat și spune dacă textul îl avea.
import "strings"
strings.EqualFold Compară două texte fără să conteze literele mari și mici (Unicode).
import "strings"
strings.Fields Împarte textul în cuvinte după spații albe, fără bucăți goale.
import "strings"
strings.FieldsFunc Împarte textul acolo unde caracterele respectă o condiție.
import "strings"
strings.FieldsFuncSeq Iterator peste bucățile pe care le-ar da FieldsFunc, fără slice.
import "strings"
strings.FieldsSeq Iterator peste cuvintele pe care le-ar da Fields, fără slice.
import "strings"
strings.HasPrefix Verifică dacă textul începe cu un anumit text.
import "strings"
strings.HasSuffix Verifică dacă textul se termină cu un anumit text (ex. extensia „.txt”).
import "strings"
strings.Index Poziția în octeți a primei apariții a unui text sau -1.
import "strings"
strings.IndexAny Poziția primului caracter din setul dat sau -1.
import "strings"
strings.IndexByte Poziția primei apariții a unui octet sau -1.
import "strings"
strings.IndexFunc Poziția primului caracter care respectă o condiție sau -1.
import "strings"
strings.IndexRune Poziția în octeți a primei apariții a unui caracter (rune) sau -1.
import "strings"
strings.Join Lipește textele dintr-un slice, cu un separator între ele.
import "strings"
strings.LastIndex Poziția în octeți a ultimei apariții a unui text sau -1.
import "strings"
strings.LastIndexAny Poziția ultimului caracter din setul dat sau -1.
import "strings"
strings.LastIndexByte Poziția ultimei apariții a unui octet sau -1.
import "strings"
strings.LastIndexFunc Poziția ultimului caracter care respectă o condiție sau -1.
import "strings"
strings.Lines Iterator peste rândurile textului; fiecare rând își păstrează „\n”.
import "strings"
strings.Map Transformă fiecare caracter cu o funcție; -1 șterge caracterul.
import "strings"
strings.Repeat Returnează textul repetat de n ori.
import "strings"
strings.Replace Înlocuiește primele n apariții ale unui text (n = -1: toate).
import "strings"
strings.ReplaceAll Înlocuiește toate aparițiile unui text cu altul.
import "strings"
strings.Split Împarte textul după un separator exact; păstrează bucățile goale.
import "strings"
strings.SplitAfter Împarte textul după separator, păstrând separatorul la capătul bucăților.
import "strings"
strings.SplitAfterN Ca SplitAfter, dar cel mult n bucăți.
import "strings"
strings.SplitAfterSeq Iterator peste bucățile pe care le-ar da SplitAfter.
import "strings"
strings.SplitN Împarte textul după separator în cel mult n bucăți.
import "strings"
strings.SplitSeq Iterator peste bucățile pe care le-ar da Split, fără slice.
import "strings"
strings.ToLower Returnează textul cu litere mici, inclusiv diacriticele.
import "strings"
strings.ToLowerSpecial Litere mici după regulile unei limbi (ex. unicode.TurkishCase).
import "strings"
strings.ToTitle Transformă toate literele în forma de titlu (aproape mereu ca ToUpper).
import "strings"
strings.ToTitleSpecial Forma de titlu după regulile unei limbi (ex. unicode.TurkishCase).
import "strings"
strings.ToUpper Returnează textul cu litere mari, inclusiv diacriticele (ș → Ș).
import "strings"
strings.ToUpperSpecial Litere mari după regulile unei limbi (ex. turcă: i → İ).
import "strings"
strings.ToValidUTF8 Înlocuiește octeții UTF-8 invalizi cu un text la alegere.
import "strings"
strings.Trim Scoate de la ambele capete caracterele dintr-un set.
import "strings"
strings.TrimFunc Scoate de la ambele capete caracterele care respectă o condiție.
import "strings"
strings.TrimLeft Scoate de la început caracterele dintr-un set (nu un prefix exact).
import "strings"
strings.TrimLeftFunc Scoate de la început caracterele care respectă o condiție.
import "strings"
strings.TrimPrefix Scoate o dată prefixul exact, dacă există.
import "strings"
strings.TrimRight Scoate de la sfârșit caracterele dintr-un set (nu un sufix exact).
import "strings"
strings.TrimRightFunc Scoate de la sfârșit caracterele care respectă o condiție.
import "strings"
strings.TrimSpace Scoate spațiile albe (spațiu, tab, rând nou) de la ambele capete.
import "strings"
strings.TrimSuffix Scoate o dată sufixul exact, dacă există.
import "strings"
strings.NewReader Creează un *strings.Reader care citește din textul dat, fără copiere.
import "strings"
strings.NewReplacer Creează un *strings.Replacer care face mai multe înlocuiri vechi-nou într-o singură trecere.
import "strings"
strings.Builder Construiește eficient un text din multe bucăți, fără copieri repetate.
import "strings"
strings.Builder.Cap Capacitatea bufferului unui Builder, în octeți.
import "strings"
strings.Builder.Grow Rezervă loc pentru cel puțin n octeți în plus.
import "strings"
strings.Builder.Len Numărul de octeți scriși în Builder.
import "strings"
strings.Builder.Reset Golește Builder-ul (renunță la buffer).
import "strings"
strings.Builder.String Returnează textul construit.
import "strings"
strings.Builder.Write Adaugă un []byte la Builder.
import "strings"
strings.Builder.WriteByte Adaugă un octet la Builder.
import "strings"
strings.Builder.WriteRune Adaugă un caracter (rune) în UTF-8 la Builder.
import "strings"
strings.Builder.WriteString Adaugă un text la Builder.
import "strings"
strings.Reader Sursă de citire (io.Reader, io.Seeker) dintr-un text; se creează cu strings.NewReader.
import "strings"
strconv.AppendBool Adaugă „true” sau „false” la un []byte.
import "strconv"
strconv.AppendFloat Adaugă un număr cu zecimale, formatat ca la FormatFloat, la un []byte.
import "strconv"
strconv.AppendInt Adaugă un întreg, în baza dată, la un []byte.
import "strconv"
strconv.AppendQuote Adaugă textul între ghilimele, ca în codul Go, la un []byte.
import "strconv"
strconv.AppendQuoteRune Adaugă caracterul între apostrofuri, ca în codul Go, la un []byte.
import "strconv"
strconv.AppendQuoteRuneToASCII Ca AppendQuoteRune, cu caracterele non-ASCII scrise ca \u….
import "strconv"
strconv.AppendQuoteRuneToGraphic Ca AppendQuoteRune, păstrând toate caracterele grafice Unicode.
import "strconv"
strconv.AppendQuoteToASCII Ca AppendQuote, cu caracterele non-ASCII scrise ca \u….
import "strconv"
strconv.AppendQuoteToGraphic Ca AppendQuote, păstrând toate caracterele grafice Unicode.
import "strconv"
strconv.AppendUint Adaugă un întreg fără semn, în baza dată, la un []byte.
import "strconv"
strconv.Atoi Transformă un text în int (baza 10); returnează eroare dacă nu este număr.
import "strconv"
strconv.CanBackquote Verifică dacă textul poate fi scris neschimbat între backticks, pe un rând.
import "strconv"
strconv.FormatBool Returnează „true” sau „false”.
import "strconv"
strconv.FormatComplex Transformă un număr complex în text de forma „(a+bi)”.
import "strconv"
strconv.FormatFloat Transformă un float în text, cu formatul (‘f’, ‘e’, ‘g’) și precizia dorite.
import "strconv"
strconv.FormatInt Transformă un int64 în text, în baza 2–36.
import "strconv"
strconv.FormatUint Transformă un uint64 în text, în baza 2–36.
import "strconv"
strconv.IsGraphic Verifică dacă un caracter este grafic Unicode (inclusiv spațiile speciale).
import "strconv"
strconv.IsPrint Verifică dacă un caracter poate fi afișat neschimbat de Quote.
import "strconv"
strconv.Itoa Transformă un int în text (baza 10).
import "strconv"
strconv.ParseBool Citește un bool din „1”, „t”, „true”, „0”, „f”, „false” și variante.
import "strconv"
strconv.ParseComplex Citește un număr complex dintr-un text ca „3+4i”.
import "strconv"
strconv.ParseFloat Citește un număr cu zecimale (cu punct) dintr-un text.
import "strconv"
strconv.ParseInt Citește un întreg în orice bază, cu verificarea dimensiunii (bitSize).
import "strconv"
strconv.ParseUint Citește un întreg fără semn în orice bază.
import "strconv"
strconv.Quote Pune textul între ghilimele și scrie caracterele speciale ca \n, \t, \u….
import "strconv"
strconv.QuoteRune Scrie un caracter între apostrofuri, ca în codul Go.
import "strconv"
strconv.QuoteRuneToASCII Ca QuoteRune, cu caracterele non-ASCII scrise ca \u….
import "strconv"
strconv.QuoteRuneToGraphic Ca QuoteRune, păstrând toate caracterele grafice Unicode.
import "strconv"
strconv.QuoteToASCII Ca Quote, cu toate caracterele non-ASCII scrise ca \u….
import "strconv"
strconv.QuoteToGraphic Ca Quote, păstrând toate caracterele grafice Unicode (și spațiile speciale).
import "strconv"
strconv.QuotedPrefix Returnează textul citat corect de la începutul unui string.
import "strconv"
strconv.Unquote Scoate ghilimelele și interpretează secvențele \n, \u… dintr-un text citat.
import "strconv"
strconv.UnquoteChar Decodează primul caracter sau prima secvență escape dintr-un text citat.
import "strconv"
bytes.Equal Verifică dacă două []byte au același conținut.
import "bytes"
bytes.Contains Verifică dacă un []byte conține o secvență de octeți.
import "bytes"
bytes.Split Împarte un []byte după un separator în mai multe slice-uri.
import "bytes"
bytes.Join Lipește mai multe []byte cu un separator între ele.
import "bytes"
bytes.TrimSpace Scoate spațiile albe de la capetele unui []byte.
import "bytes"
bytes.ToUpper Returnează o copie a []byte cu literele mari (UTF-8).
import "bytes"
bytes.Compare Compară două []byte octet cu octet: -1, 0 sau +1.
import "bytes"
bytes.Buffer Buffer de octeți care crește singur, în care poți scrie și din care poți citi.
import "bytes"
bytes.Buffer.Available Câți octeți mai încap în buffer fără o nouă alocare.
import "bytes"
bytes.Buffer.AvailableBuffer Slice gol cu spațiul liber, pentru Append* urmat imediat de Write.
import "bytes"
bytes.Buffer.Bytes Partea necitită ca []byte (împarte memoria cu bufferul).
import "bytes"
bytes.Buffer.Cap Capacitatea bufferului, în octeți.
import "bytes"
bytes.Buffer.Grow Rezervă loc pentru cel puțin n octeți în plus.
import "bytes"
bytes.Buffer.Len Numărul de octeți necitiți din buffer.
import "bytes"
bytes.Buffer.Next Returnează următorii n octeți și îi consumă.
import "bytes"
bytes.Buffer.Peek Returnează următorii n octeți fără să-i consume (Go 1.26).
import "bytes"
bytes.Buffer.Read Citește octeți din buffer într-un slice.
import "bytes"
bytes.Buffer.ReadByte Citește un octet din buffer.
import "bytes"
bytes.Buffer.ReadBytes Citește până la un delimitator (inclusiv) și returnează []byte.
import "bytes"
bytes.Buffer.ReadFrom Citește tot dintr-un io.Reader și adaugă în buffer.
import "bytes"
bytes.Buffer.ReadRune Citește un caracter UTF-8 din buffer.
import "bytes"
bytes.Buffer.ReadString Citește până la un delimitator (inclusiv) și returnează text.
import "bytes"
bytes.Buffer.Reset Golește bufferul și păstrează memoria pentru refolosire.
import "bytes"
bytes.Buffer.String Partea necitită a bufferului, ca text.
import "bytes"
bytes.Buffer.Truncate Păstrează doar primii n octeți necitiți.
import "bytes"
bytes.Buffer.UnreadByte Pune înapoi ultimul octet citit.
import "bytes"
bytes.Buffer.UnreadRune Pune înapoi ultimul caracter citit cu ReadRune.
import "bytes"
bytes.Buffer.Write Adaugă un []byte în buffer.
import "bytes"
bytes.Buffer.WriteByte Adaugă un octet în buffer.
import "bytes"
bytes.Buffer.WriteRune Adaugă un caracter în UTF-8 în buffer.
import "bytes"
bytes.Buffer.WriteString Adaugă un text în buffer.
import "bytes"
bytes.Buffer.WriteTo Scrie toată partea necitită într-un io.Writer și golește bufferul.
import "bytes"
unicode.IsLetter Verifică dacă un caracter este literă, în orice alfabet (inclusiv ș, ț).
import "unicode"
unicode.IsDigit Verifică dacă un caracter este cifră zecimală.
import "unicode"
unicode.IsNumber Verifică dacă un caracter este numeric (cifre, ², ½, Ⅻ).
import "unicode"
unicode.IsSpace Verifică dacă un caracter este spațiu alb (spațiu, tab, rând nou, U+00A0).
import "unicode"
unicode.IsUpper Verifică dacă un caracter este literă mare.
import "unicode"
unicode.IsLower Verifică dacă un caracter este literă mică.
import "unicode"
unicode.IsPunct Verifică dacă un caracter este semn de punctuație.
import "unicode"
unicode.ToUpper Transformă un caracter în literă mare.
import "unicode"
unicode.ToLower Transformă un caracter în literă mică.
import "unicode"
unicode.ToTitle Transformă un caracter în forma de titlu.
import "unicode"
unicode/utf8.AppendRune Adaugă codarea UTF-8 a unui caracter la un []byte.
import "unicode/utf8"
unicode/utf8.DecodeLastRune Decodează ultimul caracter dintr-un []byte și dă mărimea lui.
import "unicode/utf8"
unicode/utf8.DecodeLastRuneInString Decodează ultimul caracter dintr-un text și dă mărimea lui.
import "unicode/utf8"
unicode/utf8.DecodeRune Decodează primul caracter dintr-un []byte și dă mărimea lui în octeți.
import "unicode/utf8"
unicode/utf8.DecodeRuneInString Decodează primul caracter dintr-un text și dă mărimea lui în octeți.
import "unicode/utf8"
unicode/utf8.EncodeRune Scrie codarea UTF-8 a unui caracter într-un []byte.
import "unicode/utf8"
unicode/utf8.FullRune Verifică dacă []byte începe cu un caracter UTF-8 complet.
import "unicode/utf8"
unicode/utf8.FullRuneInString Verifică dacă textul începe cu un caracter UTF-8 complet.
import "unicode/utf8"
unicode/utf8.RuneCount Numărul de caractere dintr-un []byte UTF-8.
import "unicode/utf8"
unicode/utf8.RuneCountInString Numărul de caractere dintr-un text; len() dă octeții (Iași: 5 octeți, 4 litere).
import "unicode/utf8"
unicode/utf8.RuneLen Câți octeți ocupă un caracter în UTF-8 (1–4) sau -1.
import "unicode/utf8"
unicode/utf8.RuneStart Verifică dacă un octet poate fi începutul unui caracter UTF-8.
import "unicode/utf8"
unicode/utf8.Valid Verifică dacă un []byte este UTF-8 valid.
import "unicode/utf8"
unicode/utf8.ValidRune Verifică dacă o valoare rune este un caracter Unicode valid.
import "unicode/utf8"
unicode/utf8.ValidString Verifică dacă un text este UTF-8 valid.
import "unicode/utf8"
regexp.Match Verifică dacă un []byte se potrivește cu o expresie regulată.
import "regexp"
regexp.MatchReader Verifică dacă textul dintr-un io.RuneReader se potrivește cu o expresie regulată.
import "regexp"
regexp.MatchString Verifică dacă un text se potrivește cu o expresie regulată (compilată la fiecare apel).
import "regexp"
regexp.QuoteMeta Pune backslash înaintea caracterelor speciale, pentru căutare exactă.
import "regexp"
regexp.Compile Compilează o expresie regulată; returnează *Regexp și eroarea dacă e greșită.
import "regexp"
regexp.CompilePOSIX Compilează o expresie POSIX ERE, cu potrivirea cea mai lungă (leftmost-longest).
import "regexp"
regexp.MustCompile Ca Compile, dar oprește programul cu panic dacă expresia e greșită.
import "regexp"
regexp.MustCompilePOSIX Ca CompilePOSIX, dar oprește programul cu panic dacă expresia e greșită.
import "regexp"
regexp.Regexp Expresie regulată compilată (Compile, MustCompile), refolosibilă.
import "regexp"
regexp.Regexp.MatchString Verifică dacă textul conține o potrivire a expresiei compilate.
import "regexp"
regexp.Regexp.FindString Textul primei potriviri sau „” dacă nu există.
import "regexp"
regexp.Regexp.FindAllString Toate potrivirile (sau primele n), ca []string.
import "regexp"
regexp.Regexp.FindStringSubmatch Prima potrivire împreună cu textele grupurilor din paranteze.
import "regexp"
regexp.Regexp.FindAllStringSubmatch Toate potrivirile, fiecare cu grupurile ei.
import "regexp"
regexp.Regexp.ReplaceAllString Înlocuiește potrivirile cu un text care poate folosi $1, ${nume}.
import "regexp"
regexp.Regexp.ReplaceAllStringFunc Înlocuiește fiecare potrivire cu rezultatul unei funcții.
import "regexp"
regexp.Regexp.Split Împarte textul acolo unde se potrivește expresia.
import "regexp"
regexp.Regexp.FindStringIndex Pozițiile în octeți [început, sfârșit] ale primei potriviri sau nil.
import "regexp"
regexp.Regexp.SubexpNames Numele grupurilor (?P<nume>…), în ordinea parantezelor.
import "regexp"
regexp.Regexp.String Textul expresiei din care a fost compilat obiectul.
import "regexp"

Fișiere, sistem, linia de comandă și jurnalizare (208)

Funcție Ce face
os.Chdir Schimbă directorul curent al programului.
import "os"
os.Chmod Schimbă drepturile de acces ale unui fișier (de exemplu 0o644, 0o755).
import "os"
os.Chown Schimbă proprietarul (uid) și grupul (gid) unui fișier.
import "os"
os.Chtimes Schimbă data ultimului acces și data ultimei modificări ale unui fișier.
import "os"
os.Clearenv Șterge toate variabilele de mediu ale procesului.
import "os"
os.CopyFS Copiază un întreg fs.FS (director, fișiere încorporate) într-un director de pe disc.
import "os"
os.DirFS Transformă un director de pe disc într-un fs.FS.
import "os"
os.Environ Returnează toate variabilele de mediu, ca listă de texte NUME=valoare.
import "os"
os.Executable Returnează calea executabilului care rulează acum.
import "os"
os.Exit Oprește imediat programul cu codul de ieșire dat; defer-urile nu mai rulează.
import "os"
os.Expand Înlocuiește $nume și ${nume} dintr-un text folosind o funcție proprie.
import "os"
os.ExpandEnv Înlocuiește $NUME și ${NUME} dintr-un text cu valorile variabilelor de mediu.
import "os"
os.Getegid Returnează ID-ul efectiv al grupului procesului.
import "os"
os.Getenv Returnează valoarea unei variabile de mediu sau textul gol dacă lipsește.
import "os"
os.Geteuid Returnează ID-ul efectiv al utilizatorului (0 = root).
import "os"
os.Getgid Returnează ID-ul real al grupului care rulează programul.
import "os"
os.Getgroups Returnează lista ID-urilor grupurilor suplimentare ale utilizatorului.
import "os"
os.Getpagesize Returnează dimensiunea paginii de memorie a sistemului, în octeți.
import "os"
os.Getpid Returnează ID-ul procesului curent (PID).
import "os"
os.Getppid Returnează ID-ul procesului părinte.
import "os"
os.Getuid Returnează ID-ul real al utilizatorului care rulează programul.
import "os"
os.Getwd Returnează calea absolută a directorului curent.
import "os"
os.Hostname Returnează numele calculatorului.
import "os"
os.IsExist Spune dacă o eroare înseamnă „fișierul există deja”.
import "os"
os.IsNotExist Spune dacă o eroare înseamnă „fișierul nu există”.
import "os"
os.IsPathSeparator Spune dacă un caracter este separator de cale pe sistemul curent.
import "os"
os.IsPermission Spune dacă o eroare a apărut din lipsa drepturilor de acces.
import "os"
os.IsTimeout Spune dacă o eroare înseamnă că a expirat timpul de așteptare.
import "os"
os.Lchown Schimbă proprietarul unei legături simbolice, nu al fișierului spre care arată.
import "os"
os.Link Creează o legătură hard: un al doilea nume pentru același fișier.
import "os"
os.LookupEnv Citește o variabilă de mediu și spune separat dacă există.
import "os"
os.Mkdir Creează un singur director nou.
import "os"
os.MkdirAll Creează un director împreună cu toți părinții care lipsesc (ca mkdir -p).
import "os"
os.MkdirTemp Creează un director temporar cu nume unic și returnează calea lui.
import "os"
os.NewSyscallError Împachetează o eroare de apel de sistem, adăugând numele apelului.
import "os"
os.Pipe Creează un pipe al sistemului: ce scrii la un capăt citești la celălalt.
import "os"
os.ReadFile Citește tot conținutul unui fișier într-un []byte.
import "os"
os.Readlink Returnează ținta unei legături simbolice.
import "os"
os.Remove Șterge un fișier sau un director gol.
import "os"
os.RemoveAll Șterge un fișier sau un director cu tot conținutul (ca rm -rf).
import "os"
os.Rename Redenumește sau mută un fișier ori un director.
import "os"
os.SameFile Spune dacă două FileInfo descriu același fișier de pe disc.
import "os"
os.Setenv Setează o variabilă de mediu pentru procesul curent și copiii lui.
import "os"
os.Symlink Creează o legătură simbolică (scurtătură) spre alt fișier.
import "os"
os.TempDir Returnează directorul pentru fișiere temporare al sistemului.
import "os"
os.Truncate Schimbă dimensiunea unui fișier: îl taie sau îl completează cu zero.
import "os"
os.Unsetenv Șterge o variabilă de mediu.
import "os"
os.UserCacheDir Returnează directorul standard pentru datele de cache ale utilizatorului.
import "os"
os.UserConfigDir Returnează directorul standard pentru fișierele de configurare ale utilizatorului.
import "os"
os.UserHomeDir Returnează directorul personal al utilizatorului.
import "os"
os.WriteFile Scrie octeți într-un fișier, creându-l sau înlocuindu-i conținutul.
import "os"
os.ReadDir Returnează conținutul unui director, sortat după nume.
import "os"
os.Create Creează un fișier (sau îl golește pe cel existent) și îl deschide pentru scriere.
import "os"
os.CreateTemp Creează și deschide un fișier temporar cu nume unic.
import "os"
os.NewFile Creează un *os.File dintr-un descriptor de fișier numeric.
import "os"
os.Open Deschide un fișier existent doar pentru citire.
import "os"
os.OpenFile Deschide un fișier cu opțiuni: citire/scriere, adăugare la final, creare, golire.
import "os"
os.OpenInRoot Deschide un fișier strict în interiorul unui director, fără ieșire prin .. sau legături.
import "os"
os.Lstat Ca os.Stat, dar descrie legătura simbolică însăși, fără s-o urmeze.
import "os"
os.Stat Returnează informațiile unui fișier: dimensiune, drepturi, dată, director sau nu.
import "os"
os.FindProcess Returnează un *os.Process pentru un PID, ca să-i trimiți semnale sau să-l oprești.
import "os"
os.StartProcess Pornește un proces nou la nivel scăzut (de obicei se folosește os/exec).
import "os"
os.OpenRoot Deschide un director ca rădăcină (*os.Root) din care căile nu pot ieși.
import "os"
os.File Tipul unui fișier deschis, obținut cu os.Open, os.Create sau os.OpenFile.
import "os"
os.File.Close Închide fișierul și eliberează resursele.
import "os"
os.File.Read Citește din fișier cel mult len(b) octeți.
import "os"
os.File.ReadDir Citește intrările unui director deschis.
import "os"
os.File.Write Scrie octeți în fișier, la poziția curentă.
import "os"
os.File.WriteString Scrie un text în fișier, la poziția curentă.
import "os"
os.File.Name Returnează numele cu care a fost deschis fișierul.
import "os"
os.File.Stat Returnează informațiile fișierului: dimensiune, drepturi, data modificării.
import "os"
os.File.Seek Mută poziția curentă de citire/scriere din fișier.
import "os"
os.File.Sync Forțează scrierea pe disc a datelor din fișier.
import "os"
os.File.Truncate Schimbă dimensiunea unui fișier deschis.
import "os"
io.Copy Copiază toate datele dintr-un Reader într-un Writer, pe bucăți.
import "io"
io.CopyBuffer Ca io.Copy, dar folosește buffer-ul dat de tine.
import "io"
io.CopyN Copiază exact n octeți dintr-un Reader într-un Writer.
import "io"
io.Pipe Creează un pipe în memorie între o goroutine care scrie și una care citește.
import "io"
io.ReadAll Citește tot ce oferă un Reader, până la final.
import "io"
io.ReadAtLeast Citește din Reader cel puțin min octeți.
import "io"
io.ReadFull Citește din Reader exact cât încape în buffer.
import "io"
io.WriteString Scrie un text în orice io.Writer.
import "io"
io.NewOffsetWriter Creează un Writer care scrie într-o destinație cu acces direct, de la o poziție dată.
import "io"
io.NopCloser Transformă un Reader într-un ReadCloser cu un Close care nu face nimic.
import "io"
io.LimitReader Învelește un Reader astfel încât să poată fi citiți cel mult n octeți.
import "io"
io.MultiReader Leagă mai multe Reader-e unul după altul într-o singură sursă.
import "io"
io.TeeReader Returnează un Reader care copiază tot ce citești și într-un Writer.
import "io"
io.NewSectionReader Creează un Reader limitat la o porțiune dintr-o sursă cu acces direct.
import "io"
io.MultiWriter Creează un Writer care scrie aceleași date în mai multe destinații.
import "io"
io.Reader Interfața pentru orice sursă din care se poate citi (metoda Read).
import "io"
io.Writer Interfața pentru orice destinație în care se poate scrie (metoda Write).
import "io"
io.Closer Interfața pentru resursele care trebuie închise (metoda Close).
import "io"
io.ReadWriter Interfața pentru tipurile care sunt și Reader, și Writer.
import "io"
bufio.NewReader Învelește un io.Reader într-un bufio.Reader cu buffer.
import "bufio"
bufio.NewWriter Învelește un io.Writer într-un bufio.Writer cu buffer.
import "bufio"
bufio.NewScanner Creează un Scanner pentru citirea rând cu rând sau cuvânt cu cuvânt.
import "bufio"
bufio.Scanner Tipul care împarte o sursă în bucăți (rânduri, cuvinte) pentru citire simplă.
import "bufio"
bufio.Scanner.Buffer Setează buffer-ul și dimensiunea maximă a unei bucăți citite de Scanner.
import "bufio"
bufio.Scanner.Bytes Returnează bucata curentă ca []byte, fără copiere.
import "bufio"
bufio.Scanner.Err Returnează eroarea care a oprit scanarea, sau nil la sfârșit normal.
import "bufio"
bufio.Scanner.Scan Trece la următoarea bucată; returnează false la final sau la eroare.
import "bufio"
bufio.Scanner.Split Alege cum se împart datele: rânduri, cuvinte, caractere sau regulă proprie.
import "bufio"
bufio.Scanner.Text Returnează bucata curentă ca string.
import "bufio"
bufio.Reader Tipul de citire cu buffer, cu metode ca ReadString, ReadRune, Peek.
import "bufio"
bufio.Reader.ReadString Citește până la delimitator (inclusiv) și returnează un string.
import "bufio"
bufio.Reader.ReadLine Citește un rând fără caracterul de final (nivel scăzut).
import "bufio"
bufio.Reader.ReadRune Citește un singur caracter Unicode (rune).
import "bufio"
bufio.Reader.ReadBytes Citește până la delimitator (inclusiv) și returnează un []byte.
import "bufio"
bufio.Writer Tipul de scriere cu buffer; datele ajung la destinație la Flush.
import "bufio"
bufio.Writer.WriteString Adaugă un text în buffer-ul Writer-ului.
import "bufio"
bufio.Writer.Flush Trimite la destinație datele rămase în buffer.
import "bufio"
bufio.Writer.WriteRune Adaugă un caracter Unicode în buffer, codat UTF-8.
import "bufio"
path/filepath.Abs Transformă o cale relativă în cale absolută.
import "path/filepath"
path/filepath.Base Returnează ultimul element al unei căi (numele fișierului).
import "path/filepath"
path/filepath.Clean Simplifică o cale: elimină // și ., rezolvă .. din text.
import "path/filepath"
path/filepath.Dir Returnează partea de director a unei căi.
import "path/filepath"
path/filepath.EvalSymlinks Returnează calea reală, după ce urmează legăturile simbolice.
import "path/filepath"
path/filepath.Ext Returnează extensia fișierului, cu punct (.jpg).
import "path/filepath"
path/filepath.FromSlash Înlocuiește / cu separatorul sistemului.
import "path/filepath"
path/filepath.Glob Returnează fișierele de pe disc care se potrivesc unui model cu * și ?.
import "path/filepath"
path/filepath.IsAbs Spune dacă o cale este absolută.
import "path/filepath"
path/filepath.IsLocal Spune dacă o cale rămâne în directorul curent (fără .., fără / la început).
import "path/filepath"
path/filepath.Join Unește bucăți într-o cale, cu separatorul corect.
import "path/filepath"
path/filepath.Localize Transformă o cale cu / într-o cale locală sigură, refuzând căile nevalide.
import "path/filepath"
path/filepath.Match Verifică dacă un nume se potrivește unui model de tip shell.
import "path/filepath"
path/filepath.Rel Calculează calea relativă de la un director la altă cale.
import "path/filepath"
path/filepath.Split Împarte o cale în director și numele fișierului.
import "path/filepath"
path/filepath.SplitList Împarte o listă de căi precum $PATH.
import "path/filepath"
path/filepath.ToSlash Înlocuiește separatorul sistemului cu /.
import "path/filepath"
path/filepath.VolumeName Returnează litera de disc sau serverul de la începutul unei căi Windows.
import "path/filepath"
path/filepath.Walk Parcurge recursiv un director, cu FileInfo pentru fiecare intrare.
import "path/filepath"
path/filepath.WalkDir Parcurge recursiv un director, mai rapid, cu DirEntry pentru fiecare intrare.
import "path/filepath"
flag.String Definește o opțiune text de linie de comandă.
import "flag"
flag.Int Definește o opțiune număr întreg de linie de comandă.
import "flag"
flag.Bool Definește o opțiune da/nu de linie de comandă (-v).
import "flag"
flag.Float64 Definește o opțiune număr cu zecimale de linie de comandă.
import "flag"
flag.Duration Definește o opțiune de durată (-timeout=30s).
import "flag"
flag.Parse Citește opțiunile din os.Args și completează variabilele definite.
import "flag"
flag.Args Returnează argumentele obișnuite rămase după opțiuni.
import "flag"
flag.Arg Returnează argumentul obișnuit cu numărul dat, sau textul gol.
import "flag"
flag.NArg Returnează numărul argumentelor obișnuite rămase după opțiuni.
import "flag"
flag.StringVar Definește o opțiune text care scrie într-o variabilă existentă.
import "flag"
flag.IntVar Definește o opțiune întreagă care scrie într-o variabilă existentă.
import "flag"
flag.BoolVar Definește o opțiune da/nu care scrie într-o variabilă existentă.
import "flag"
flag.Usage Variabila cu funcția care afișează ajutorul; o poți înlocui.
import "flag"
flag.PrintDefaults Afișează toate opțiunile, cu descrierea și valoarea implicită.
import "flag"
flag.NewFlagSet Creează un set separat de opțiuni, de exemplu pentru subcomenzi.
import "flag"
log.Println Scrie un mesaj în jurnal, cu dată și oră, ca fmt.Println.
import "log"
log.Printf Scrie în jurnal un mesaj formatat, ca fmt.Printf.
import "log"
log.Print Scrie un mesaj în jurnal, cu dată și oră, ca fmt.Print.
import "log"
log.Fatal Scrie mesajul în jurnal și oprește programul cu codul 1.
import "log"
log.Fatalf Scrie un mesaj formatat și oprește programul cu codul 1.
import "log"
log.Fatalln Scrie mesajul ca Println și oprește programul cu codul 1.
import "log"
log.Panic Scrie mesajul în jurnal și declanșează un panic.
import "log"
log.Panicf Scrie un mesaj formatat și declanșează un panic.
import "log"
log.SetFlags Alege antetul rândurilor din jurnal: dată, oră, fișier și linie.
import "log"
log.SetPrefix Setează un text pus la începutul fiecărui rând din jurnal.
import "log"
log.SetOutput Schimbă destinația jurnalului implicit.
import "log"
log.New Creează un jurnal separat cu destinație, prefix și opțiuni proprii.
import "log"
log/slog.Info Scrie un mesaj structurat de nivel INFO, cu perechi cheie-valoare.
import "log/slog"
log/slog.Warn Scrie un mesaj structurat de nivel WARN.
import "log/slog"
log/slog.Error Scrie un mesaj structurat de nivel ERROR, de obicei cu eroarea.
import "log/slog"
log/slog.Debug Scrie un mesaj de depanare (DEBUG), ascuns implicit.
import "log/slog"
log/slog.New Creează un *slog.Logger peste un handler.
import "log/slog"
log/slog.NewTextHandler Creează un handler care scrie rânduri cheie=valoare.
import "log/slog"
log/slog.NewJSONHandler Creează un handler care scrie un obiect JSON pe rând.
import "log/slog"
log/slog.SetDefault Face un logger jurnalul implicit, folosit și de pachetul log.
import "log/slog"
log/slog.String Creează un atribut cu valoare text.
import "log/slog"
log/slog.Int Creează un atribut cu valoare număr întreg.
import "log/slog"
log/slog.Bool Creează un atribut cu valoare booleană.
import "log/slog"
log/slog.Any Creează un atribut cu o valoare de orice tip.
import "log/slog"
log/slog.Group Grupează mai multe atribute sub un nume comun.
import "log/slog"
log/slog.Duration Creează un atribut cu o durată (time.Duration).
import "log/slog"
log/slog.Time Creează un atribut cu o dată și oră (time.Time).
import "log/slog"
log/slog.Logger Tipul jurnalului structurat, cu metodele Debug, Info, Warn, Error, With.
import "log/slog"
log/slog.Logger.Info Scrie un mesaj INFO prin acest logger, cu atributele lui.
import "log/slog"
log/slog.Logger.With Returnează un logger care adaugă atributele date la fiecare mesaj.
import "log/slog"
log/slog.Logger.WithGroup Returnează un logger care pune atributele următoare într-un grup.
import "log/slog"
log/slog.Level Tipul nivelului unui mesaj: DEBUG (-4), INFO (0), WARN (4), ERROR (8).
import "log/slog"
log/slog.HandlerOptions Opțiunile handler-elor: nivel minim, fișierul sursă, ReplaceAttr.
import "log/slog"
os/exec.Command Pregătește rularea unui program extern cu argumentele date.
import "os/exec"
os/exec.CommandContext Ca Command, dar procesul este oprit când contextul expiră.
import "os/exec"
os/exec.LookPath Caută un program executabil în PATH.
import "os/exec"
os/exec.Cmd Structura unei comenzi externe: program, argumente, director, mediu, intrare, ieșiri.
import "os/exec"
os/exec.Cmd.Run Pornește comanda și așteaptă să se termine.
import "os/exec"
os/exec.Cmd.Output Rulează comanda și returnează ce a scris pe stdout.
import "os/exec"
os/exec.Cmd.CombinedOutput Rulează comanda și returnează împreună stdout și stderr.
import "os/exec"
os/exec.Cmd.Start Pornește comanda fără să aștepte terminarea ei.
import "os/exec"
os/exec.Cmd.Wait Așteaptă terminarea unei comenzi pornite cu Start.
import "os/exec"
os/exec.Cmd.StdoutPipe Returnează un Reader legat de ieșirea comenzii.
import "os/exec"
os/signal.Notify Trimite semnalele primite de program (Ctrl+C, SIGTERM) pe un canal.
import "os/signal"
os/signal.NotifyContext Returnează un context anulat când programul primește un semnal.
import "os/signal"
os/signal.Stop Oprește trimiterea semnalelor pe un canal.
import "os/signal"
embed.FS Fișiere încorporate în executabil la compilare cu //go:embed.
import "embed"
testing.T Tipul primit de funcțiile de test, pentru raportarea erorilor.
import "testing"
testing.T.Error Marchează testul ca eșuat, scrie mesajul și continuă.
import "testing"
testing.T.Errorf Marchează testul ca eșuat cu un mesaj formatat și continuă.
import "testing"
testing.T.Fatal Marchează testul ca eșuat, scrie mesajul și oprește testul.
import "testing"
testing.T.Fatalf Marchează testul ca eșuat cu un mesaj formatat și oprește testul.
import "testing"
testing.T.Run Rulează o funcție ca subtest cu nume propriu.
import "testing"
testing.T.Helper Marchează o funcție ca ajutătoare, ca erorile să arate linia apelantului.
import "testing"
testing.T.Skip Sare peste testul curent, cu un motiv.
import "testing"
testing.T.Parallel Permite testului să ruleze în paralel cu alte teste paralele.
import "testing"
testing.T.Cleanup Înregistrează o funcție care rulează după terminarea testului.
import "testing"
testing.T.TempDir Creează un director temporar șters automat la finalul testului.
import "testing"
testing.B Tipul primit de funcțiile benchmark, care măsoară performanța.
import "testing"
testing.B.Loop Condiția buclei unui benchmark modern: for b.Loop() { … }.
import "testing"
testing.B.ResetTimer Pune la zero timpul măsurat, ca pregătirea să nu fie inclusă.
import "testing"

Colecții, sortare și matematică (170)

Funcție Ce face
math.Abs Valoarea absolută (modulul) unui float64.
import "math"
math.Acos Arccosinus: unghiul (în radiani, între 0 și π) al cărui cosinus este x.
import "math"
math.Acosh Arccosinus hiperbolic; definit pentru x ≥ 1.
import "math"
math.Asin Arcsinus: unghiul (în radiani, între -π/2 și π/2) al cărui sinus este x.
import "math"
math.Asinh Arcsinus hiperbolic.
import "math"
math.Atan Arctangentă: unghiul (în radiani) a cărui tangentă este x.
import "math"
math.Atan2 Unghiul punctului (x, y) față de axa Ox, între -π și π; primește întâi y, apoi x.
import "math"
math.Atanh Arctangentă hiperbolică; definită pentru x între -1 și 1.
import "math"
math.Cbrt Rădăcina cubică; funcționează și pentru numere negative.
import "math"
math.Ceil Rotunjește în sus, la cel mai mic întreg ≥ x.
import "math"
math.Copysign Returnează valoarea lui f cu semnul lui sign.
import "math"
math.Cos Cosinusul unui unghi dat în radiani.
import "math"
math.Cosh Cosinusul hiperbolic.
import "math"
math.Dim Diferența pozitivă: x-y dacă este pozitivă, altfel 0.
import "math"
math.Erf Funcția de eroare din statistică (legată de distribuția normală).
import "math"
math.Erfc Funcția de eroare complementară, 1 – Erf(x), precisă pentru x mare.
import "math"
math.Erfcinv Inversa lui Erfc.
import "math"
math.Erfinv Inversa funcției de eroare Erf.
import "math"
math.Exp e la puterea x.
import "math"
math.Exp2 2 la puterea x.
import "math"
math.Expm1 e^x – 1, calculat precis pentru x aproape de 0.
import "math"
math.FMA Calculează x*y + z cu o singură rotunjire (fused multiply-add).
import "math"
math.Float32bits Biții IEEE 754 ai unui float32, ca uint32.
import "math"
math.Float32frombits Construiește un float32 din biții lui IEEE 754 (uint32).
import "math"
math.Float64bits Biții IEEE 754 ai unui float64, ca uint64.
import "math"
math.Float64frombits Construiește un float64 din biții lui IEEE 754 (uint64).
import "math"
math.Floor Rotunjește în jos, la cel mai mare întreg ≤ x.
import "math"
math.Frexp Desparte un număr în mantisă (între 0.5 și 1) și exponent al lui 2.
import "math"
math.Gamma Funcția Gamma: factorialul extins la numere reale, Gamma(n) = (n-1)!.
import "math"
math.Hypot Ipotenuza: rădăcina din p² + q², fără depășiri.
import "math"
math.Ilogb Exponentul binar al lui x, ca int.
import "math"
math.Inf Plus infinit (sign ≥ 0) sau minus infinit (sign < 0).
import "math"
math.IsInf Verifică dacă un float64 este infinit (cu semnul cerut).
import "math"
math.IsNaN Verifică dacă un float64 este NaN („nu este un număr”).
import "math"
math.J0 Funcția Bessel de speța întâi, ordinul 0.
import "math"
math.J1 Funcția Bessel de speța întâi, ordinul 1.
import "math"
math.Jn Funcția Bessel de speța întâi, ordinul n.
import "math"
math.Ldexp Calculează frac × 2^exp (inversa lui Frexp).
import "math"
math.Lgamma Logaritmul natural al lui |Gamma(x)| și semnul lui Gamma(x).
import "math"
math.Log Logaritmul natural (baza e).
import "math"
math.Log10 Logaritmul în baza 10.
import "math"
math.Log1p ln(1 + x), calculat precis pentru x aproape de 0.
import "math"
math.Log2 Logaritmul în baza 2.
import "math"
math.Logb Exponentul binar al lui x, ca float64.
import "math"
math.Max Cel mai mare dintre două numere float64.
import "math"
math.Min Cel mai mic dintre două numere float64.
import "math"
math.Mod Restul împărțirii pentru float64; are semnul lui x.
import "math"
math.Modf Desparte un număr în parte întreagă și parte zecimală.
import "math"
math.NaN Returnează valoarea specială NaN („nu este un număr”).
import "math"
math.Nextafter Următorul float64 reprezentabil după x, în direcția lui y.
import "math"
math.Nextafter32 Următorul float32 reprezentabil după x, în direcția lui y.
import "math"
math.Pow x la puterea y.
import "math"
math.Pow10 10 la puterea n (n întreg).
import "math"
math.Remainder Restul IEEE 754: x – n*y, cu n câtul rotunjit la cel mai apropiat întreg.
import "math"
math.Round Rotunjește la cel mai apropiat întreg; jumătățile se duc departe de zero.
import "math"
math.RoundToEven Rotunjește la cel mai apropiat întreg; jumătățile se duc spre numărul par.
import "math"
math.Signbit Spune dacă un număr are semn minus (inclusiv -0).
import "math"
math.Sin Sinusul unui unghi dat în radiani.
import "math"
math.Sincos Returnează deodată sinusul și cosinusul unui unghi.
import "math"
math.Sinh Sinusul hiperbolic.
import "math"
math.Sqrt Rădăcina pătrată; pentru numere negative dă NaN.
import "math"
math.Tan Tangenta unui unghi dat în radiani.
import "math"
math.Tanh Tangenta hiperbolică, cu valori între -1 și 1.
import "math"
math.Trunc Taie partea zecimală (rotunjire spre zero).
import "math"
math.Y0 Funcția Bessel de speța a doua, ordinul 0.
import "math"
math.Y1 Funcția Bessel de speța a doua, ordinul 1.
import "math"
math.Yn Funcția Bessel de speța a doua, ordinul n.
import "math"
math/rand/v2.ExpFloat64 Număr aleatoriu cu distribuție exponențială (rata 1).
import "math/rand/v2"
math/rand/v2.Float32 float32 aleatoriu uniform în [0.0, 1.0).
import "math/rand/v2"
math/rand/v2.Float64 float64 aleatoriu uniform în [0.0, 1.0).
import "math/rand/v2"
math/rand/v2.Int int aleatoriu nenegativ.
import "math/rand/v2"
math/rand/v2.Int32 int32 aleatoriu nenegativ.
import "math/rand/v2"
math/rand/v2.Int32N int32 aleatoriu în [0, n).
import "math/rand/v2"
math/rand/v2.Int64 int64 aleatoriu nenegativ.
import "math/rand/v2"
math/rand/v2.Int64N int64 aleatoriu în [0, n).
import "math/rand/v2"
math/rand/v2.IntN int aleatoriu în [0, n); de exemplu rand.IntN(6)+1 pentru un zar.
import "math/rand/v2"
math/rand/v2.N Valoare aleatorie în [0, n) de orice tip întreg, inclusiv time.Duration (generică).
import "math/rand/v2"
math/rand/v2.NormFloat64 Număr aleatoriu cu distribuție normală (media 0, abaterea 1).
import "math/rand/v2"
math/rand/v2.Perm Permutare aleatorie a numerelor 0..n-1, ca []int nou.
import "math/rand/v2"
math/rand/v2.Shuffle Amestecă aleatoriu n elemente printr-o funcție swap(i, j).
import "math/rand/v2"
math/rand/v2.Uint uint aleatoriu.
import "math/rand/v2"
math/rand/v2.Uint32 uint32 aleatoriu.
import "math/rand/v2"
math/rand/v2.Uint32N uint32 aleatoriu în [0, n).
import "math/rand/v2"
math/rand/v2.Uint64 uint64 aleatoriu.
import "math/rand/v2"
math/rand/v2.Uint64N uint64 aleatoriu în [0, n).
import "math/rand/v2"
math/rand/v2.UintN uint aleatoriu în [0, n).
import "math/rand/v2"
math/rand/v2.NewChaCha8 Sursă ChaCha8 cu seed de 32 de octeți, pentru rand.New.
import "math/rand/v2"
math/rand/v2.NewPCG Sursă PCG rapidă, cu două seed-uri uint64, pentru rand.New.
import "math/rand/v2"
math/rand/v2.New Creează un generator propriu (*rand.Rand) dintr-o sursă; cu seed fix, secvența se repetă.
import "math/rand/v2"
math/rand/v2.NewZipf Generator de valori în [0, imax] cu distribuție Zipf (valorile mici sunt mult mai frecvente).
import "math/rand/v2"
sort.Ints Sortează crescător, pe loc, un []int (azi echivalent cu slices.Sort).
import "sort"
sort.Strings Sortează crescător, pe loc, un []string (ordine după octeți).
import "sort"
sort.Float64s Sortează crescător, pe loc, un []float64.
import "sort"
sort.Slice Sortează un slice după o funcție less(i, j) care primește indici; nu este stabilă.
import "sort"
sort.SliceStable Ca sort.Slice, dar păstrează ordinea elementelor egale.
import "sort"
sort.Search Căutare binară: primul indice din [0, n) pentru care f(i) este true.
import "sort"
sort.SearchInts Poziția unui int într-un []int sortat (sau unde s-ar insera).
import "sort"
sort.Sort Sortează orice colecție care are metodele Len, Less și Swap.
import "sort"
sort.Stable Ca sort.Sort, dar stabilă: păstrează ordinea elementelor egale.
import "sort"
sort.IntsAreSorted Verifică dacă un []int este sortat crescător.
import "sort"
slices.All Iterator peste perechile (indice, valoare) ale unui slice.
import "slices"
slices.AppendSeq Adaugă valorile unui iterator la finalul unui slice.
import "slices"
slices.Backward Iterator peste perechile (indice, valoare), de la ultimul element la primul.
import "slices"
slices.BinarySearch Căutare binară într-un slice sortat; returnează poziția și dacă a găsit.
import "slices"
slices.BinarySearchFunc Căutare binară cu o funcție de comparare (de exemplu după un câmp).
import "slices"
slices.Chunk Împarte un slice în bucăți de câte n elemente, ca iterator.
import "slices"
slices.Clip Elimină capacitatea nefolosită a unui slice (cap = len).
import "slices"
slices.Clone Copie superficială a unui slice, cu memorie proprie.
import "slices"
slices.Collect Strânge valorile unui iterator într-un slice nou.
import "slices"
slices.Compact Înlocuiește șirurile de elemente egale vecine cu un singur element.
import "slices"
slices.CompactFunc Ca Compact, cu o funcție proprie de egalitate.
import "slices"
slices.Compare Compară lexicografic două slice-uri; returnează -1, 0 sau +1.
import "slices"
slices.CompareFunc Compară lexicografic două slice-uri cu o funcție de comparare.
import "slices"
slices.Concat Lipește mai multe slice-uri într-unul nou.
import "slices"
slices.Contains Spune dacă un slice conține o valoare.
import "slices"
slices.ContainsFunc Spune dacă vreun element îndeplinește o condiție.
import "slices"
slices.Delete Șterge elementele s[i:j] și returnează slice-ul nou.
import "slices"
slices.DeleteFunc Șterge toate elementele care îndeplinesc o condiție.
import "slices"
slices.Equal Verifică dacă două slice-uri au aceleași elemente, în aceeași ordine.
import "slices"
slices.EqualFunc Ca Equal, cu o funcție proprie de egalitate (tipurile pot diferi).
import "slices"
slices.Grow Mărește capacitatea ca să încapă încă n elemente fără realocare.
import "slices"
slices.Index Indicele primei apariții a unei valori, sau -1.
import "slices"
slices.IndexFunc Indicele primului element care îndeplinește o condiție, sau -1.
import "slices"
slices.Insert Inserează valori la poziția i și returnează slice-ul nou.
import "slices"
slices.IsSorted Verifică dacă un slice este sortat crescător.
import "slices"
slices.IsSortedFunc Verifică ordinea după o funcție de comparare.
import "slices"
slices.Max Cel mai mare element (panic pe slice gol).
import "slices"
slices.MaxFunc Elementul maxim după o funcție de comparare (primul, la egalitate).
import "slices"
slices.Min Cel mai mic element (panic pe slice gol).
import "slices"
slices.MinFunc Elementul minim după o funcție de comparare (primul, la egalitate).
import "slices"
slices.Repeat Slice nou cu x repetat de count ori.
import "slices"
slices.Replace Înlocuiește s[i:j] cu valorile date.
import "slices"
slices.Reverse Inversează ordinea elementelor, pe loc.
import "slices"
slices.Sort Sortează crescător, pe loc, un slice de numere sau texte.
import "slices"
slices.SortFunc Sortează după o funcție de comparare (negativ, 0, pozitiv); nu este stabilă.
import "slices"
slices.SortStableFunc Sortare stabilă după o funcție de comparare.
import "slices"
slices.Sorted Strânge valorile unui iterator într-un slice nou, sortat.
import "slices"
slices.SortedFunc Ca Sorted, cu o funcție de comparare.
import "slices"
slices.SortedStableFunc Ca SortedFunc, dar stabilă.
import "slices"
slices.Values Iterator peste valorile unui slice.
import "slices"
maps.All Iterator peste perechile (cheie, valoare) ale unui map.
import "maps"
maps.Clone Copie superficială a unui map.
import "maps"
maps.Collect Construiește un map nou din perechile unui iterator.
import "maps"
maps.Copy Copiază toate perechile din src în dst, suprascriind cheile existente.
import "maps"
maps.DeleteFunc Șterge perechile pentru care o funcție returnează true.
import "maps"
maps.Equal Verifică dacă două map-uri au aceleași chei cu aceleași valori.
import "maps"
maps.EqualFunc Ca Equal, cu o funcție proprie de egalitate pentru valori.
import "maps"
maps.Insert Adaugă perechile unui iterator într-un map existent.
import "maps"
maps.Keys Iterator peste cheile unui map (ordine aleatorie; sortează cu slices.Sorted).
import "maps"
maps.Values Iterator peste valorile unui map (ordine aleatorie).
import "maps"
cmp.Compare Compară două valori ordonate: -1, 0 sau +1 (NaN este cel mai mic).
import "cmp"
cmp.Less Spune dacă x < y (NaN este mai mic decât orice număr).
import "cmp"
cmp.Or Primul argument diferit de valoarea zero; util pentru valori implicite și sortări pe mai multe criterii.
import "cmp"
iter.Pull Transformă un iter.Seq în funcțiile next() și stop(), ca să ceri singur valorile.
import "iter"
iter.Pull2 Ca Pull, pentru un iter.Seq2 (perechi).
import "iter"
iter.Seq Tipul unui iterator care produce valori; se parcurge cu for range.
import "iter"
iter.Seq2 Tipul unui iterator care produce perechi (cheie, valoare).
import "iter"
container/heap.Fix Refă ordinea heap-ului după ce elementul de la indicele i s-a schimbat.
import "container/heap"
container/heap.Init Organizează datele ca heap (coadă de priorități).
import "container/heap"
container/heap.Pop Scoate și returnează elementul minim din heap.
import "container/heap"
container/heap.Push Adaugă un element în heap.
import "container/heap"
container/heap.Remove Scoate și returnează elementul de la indicele i din heap.
import "container/heap"
container/list.New Creează o listă dublu înlănțuită goală.
import "container/list"
container/list.List Tipul listei dublu înlănțuite; valoarea zero este o listă goală gata de folosit.
import "container/list"
container/list.List.PushBack Adaugă o valoare la sfârșitul listei și returnează elementul nou.
import "container/list"
container/list.List.PushFront Adaugă o valoare la începutul listei și returnează elementul nou.
import "container/list"
container/list.List.Remove Scoate un element din listă și returnează valoarea lui.
import "container/list"
container/list.List.Front Primul element al listei, sau nil dacă lista este goală.
import "container/list"
container/list.List.Len Numărul de elemente din listă.
import "container/list"
unsafe.Sizeof Câți octeți ocupă o valoare de tipul dat, fără memoria spre care trimite.
import "unsafe"

Timp, concurență și erori (142)

Funcție Ce face
errors.As Caută în lanțul de erori prima eroare de un anumit tip și o copiază în țintă.
import "errors"
errors.AsType Varianta generică a lui errors.As: returnează direct eroarea de tipul E și true dacă există.
import "errors"
errors.Is Verifică dacă o eroare este sau conține (prin %w sau Join) eroarea căutată.
import "errors"
errors.Join Unește mai multe erori într-una; nil-urile sunt ignorate.
import "errors"
errors.New Creează o eroare simplă cu mesajul dat; folosită pentru erori-santinelă.
import "errors"
errors.Unwrap Returnează eroarea împachetată direct în err sau nil.
import "errors"
time.After Canal care primește un semnal după durata dată; folosit în select pentru timeout.
import "time"
time.Sleep Oprește goroutine-ul curent pentru durata dată.
import "time"
time.Tick Canal care primește câte un semnal la fiecare interval.
import "time"
time.ParseDuration Citește o durată din text, de exemplu „1h30m” sau „250ms”.
import "time"
time.Since Cât timp a trecut de la un moment până acum.
import "time"
time.Until Cât timp mai este până la un moment.
import "time"
time.FixedZone Fus orar cu decalaj fix față de UTC, fără oră de vară.
import "time"
time.LoadLocation Încarcă un fus orar după numele IANA, de exemplu „Europe/Bucharest”.
import "time"
time.LoadLocationFromTZData Creează un fus orar din conținutul unui fișier IANA.
import "time"
time.NewTicker Creează un ticker care trimite un semnal la fiecare interval.
import "time"
time.Date Construiește un moment din an, lună, zi, oră și fus orar; normalizează valorile.
import "time"
time.Now Momentul curent, în fusul orar local, cu citire a ceasului monoton.
import "time"
time.Parse Citește o dată din text după un model (UTC dacă textul nu are fus).
import "time"
time.ParseInLocation Ca Parse, dar interpretează ora în fusul orar dat.
import "time"
time.Unix Momentul corespunzător unui timestamp Unix în secunde (și nanosecunde).
import "time"
time.UnixMicro Momentul corespunzător unui timestamp în microsecunde.
import "time"
time.UnixMilli Momentul corespunzător unui timestamp în milisecunde.
import "time"
time.AfterFunc Rulează o funcție într-un goroutine nou după o durată; returnează *Timer.
import "time"
time.NewTimer Creează un temporizator care trimite un semnal pe canalul C după o durată.
import "time"
time.Time Un moment în timp: dată, oră, nanosecunde și fus orar.
import "time"
time.Time.Format Formatează momentul după un model scris cu data de referință 2006-01-02 15:04:05.
import "time"
time.Time.Add Returnează momentul mutat cu o durată (poate fi negativă).
import "time"
time.Time.Sub Diferența dintre două momente, ca time.Duration.
import "time"
time.Time.AddDate Adaugă ani, luni și zile din calendar și normalizează data.
import "time"
time.Time.Before Spune dacă momentul este strict înaintea altuia.
import "time"
time.Time.After Spune dacă momentul este strict după altul.
import "time"
time.Time.Equal Spune dacă două momente sunt aceleași, indiferent de fusul orar.
import "time"
time.Time.Compare Compară două momente și returnează -1, 0 sau +1.
import "time"
time.Time.Year Anul momentului.
import "time"
time.Time.Month Luna momentului, ca time.Month.
import "time"
time.Time.Day Ziua din lună (1-31).
import "time"
time.Time.Weekday Ziua săptămânii (duminică = 0).
import "time"
time.Time.YearDay A câta zi din an este (1-366).
import "time"
time.Time.Hour Ora (0-23).
import "time"
time.Time.Minute Minutul (0-59).
import "time"
time.Time.Second Secunda (0-59).
import "time"
time.Time.Unix Secundele trecute de la 1 ianuarie 1970 UTC.
import "time"
time.Time.UnixMilli Milisecundele trecute de la 1 ianuarie 1970 UTC.
import "time"
time.Time.Truncate Rotunjește momentul în jos la un multiplu de durată.
import "time"
time.Time.Round Rotunjește momentul la cel mai apropiat multiplu de durată.
import "time"
time.Time.In Același moment, afișat în alt fus orar.
import "time"
time.Time.UTC Același moment, afișat în UTC.
import "time"
time.Time.Local Același moment, afișat în fusul orar al calculatorului.
import "time"
time.Time.IsZero Spune dacă momentul este valoarea zero (1 ianuarie anul 1).
import "time"
time.Time.Date Anul, luna și ziua deodată.
import "time"
time.Time.Clock Ora, minutul și secunda deodată.
import "time"
time.Time.ISOWeek Anul și numărul săptămânii după ISO 8601.
import "time"
time.Duration O durată în nanosecunde (int64); se scrie ca 90*time.Minute.
import "time"
time.Duration.Hours Durata în ore, ca float64.
import "time"
time.Duration.Minutes Durata în minute, ca float64.
import "time"
time.Duration.Seconds Durata în secunde, ca float64.
import "time"
time.Duration.Milliseconds Durata în milisecunde întregi, ca int64.
import "time"
time.Duration.String Textul duratei, de exemplu „1h30m0s”.
import "time"
time.Duration.Round Rotunjește durata la cel mai apropiat multiplu.
import "time"
time.Duration.Truncate Rotunjește durata în jos la un multiplu.
import "time"
time.Timer Temporizator care trimite un singur semnal pe canalul C după o durată.
import "time"
time.Timer.Stop Oprește temporizatorul; true dacă era încă activ.
import "time"
time.Timer.Reset Repornește temporizatorul cu o durată nouă.
import "time"
time.Ticker Ceas care trimite câte un semnal pe canalul C la fiecare interval.
import "time"
time.Ticker.Stop Oprește bătăile ticker-ului.
import "time"
time.Ticker.Reset Schimbă intervalul ticker-ului.
import "time"
time.Month Tipul pentru luni: time.January (1) … time.December (12).
import "time"
time.Month.String Numele englezesc al lunii, de exemplu „October”.
import "time"
time.Weekday Tipul pentru zilele săptămânii: time.Sunday (0) … time.Saturday (6).
import "time"
time.Weekday.String Numele englezesc al zilei, de exemplu „Monday”.
import "time"
sync.OnceFunc Returnează o funcție care rulează f o singură dată.
import "sync"
sync.OnceValue Returnează o funcție care calculează valoarea o dată și o păstrează.
import "sync"
sync.OnceValues Ca OnceValue, pentru funcții cu două rezultate (de obicei valoare și eroare).
import "sync"
sync.NewCond Creează o variabilă de condiție legată de un lacăt.
import "sync"
sync.Mutex Lacăt de excludere reciprocă: un singur goroutine pe rând în secțiunea critică.
import "sync"
sync.Mutex.Lock Încuie mutexul, așteptând dacă este ocupat.
import "sync"
sync.Mutex.TryLock Încearcă să încuie fără să aștepte; false dacă e ocupat.
import "sync"
sync.Mutex.Unlock Descuie mutexul.
import "sync"
sync.RWMutex Lacăt cu mai mulți cititori simultan sau un singur scriitor.
import "sync"
sync.RWMutex.Lock Blochează pentru scriere (exclusiv).
import "sync"
sync.RWMutex.RLock Blochează pentru citire (partajat cu alți cititori).
import "sync"
sync.RWMutex.RLocker Returnează un sync.Locker care folosește RLock/RUnlock.
import "sync"
sync.RWMutex.RUnlock Eliberează o blocare pentru citire.
import "sync"
sync.RWMutex.TryLock Încearcă blocarea pentru scriere fără să aștepte.
import "sync"
sync.RWMutex.TryRLock Încearcă blocarea pentru citire fără să aștepte.
import "sync"
sync.RWMutex.Unlock Eliberează blocarea pentru scriere.
import "sync"
sync.WaitGroup Așteaptă ca un grup de goroutine să termine.
import "sync"
sync.WaitGroup.Add Mărește contorul de sarcini (înainte de a porni goroutine-ul).
import "sync"
sync.WaitGroup.Done Scade contorul cu 1 când o sarcină s-a terminat.
import "sync"
sync.WaitGroup.Go Pornește f într-un goroutine nou și îl adaugă în grup (Go 1.25).
import "sync"
sync.WaitGroup.Wait Blochează până când contorul ajunge la zero.
import "sync"
sync.Once Garantează că o funcție rulează o singură dată.
import "sync"
sync.Once.Do Rulează funcția doar la primul apel; celelalte apeluri așteaptă și nu fac nimic.
import "sync"
sync.Map Map sigur pentru folosire concurentă, fără mutex extern.
import "sync"
sync.Map.Clear Șterge toate perechile din sync.Map.
import "sync"
sync.Map.CompareAndDelete Șterge cheia doar dacă are valoarea așteptată.
import "sync"
sync.Map.CompareAndSwap Înlocuiește valoarea doar dacă este cea așteptată.
import "sync"
sync.Map.Delete Șterge o cheie.
import "sync"
sync.Map.Load Citește valoarea unei chei și dacă există.
import "sync"
sync.Map.LoadAndDelete Șterge cheia și returnează valoarea pe care o avea.
import "sync"
sync.Map.LoadOrStore Returnează valoarea existentă sau o salvează pe cea dată, atomic.
import "sync"
sync.Map.Range Parcurge perechile până când funcția returnează false.
import "sync"
sync.Map.Store Salvează o valoare pentru o cheie.
import "sync"
sync.Map.Swap Salvează valoarea nouă și o returnează pe cea veche.
import "sync"
sync.Pool Rezervă de obiecte temporare refolosibile, pentru mai puține alocări.
import "sync"
sync.Pool.Get Ia un obiect din rezervă sau creează unul cu New.
import "sync"
sync.Pool.Put Pune un obiect înapoi în rezervă.
import "sync"
sync.Cond Variabilă de condiție: goroutine-urile așteaptă un semnal despre o stare comună.
import "sync"
sync.Cond.Broadcast Trezește toate goroutine-urile care așteaptă.
import "sync"
sync.Cond.Signal Trezește un singur goroutine care așteaptă.
import "sync"
sync.Cond.Wait Eliberează lacătul și așteaptă un semnal, apoi îl reia.
import "sync"
sync/atomic.AddInt64 Adună atomic la un int64 și returnează valoarea nouă.
import "sync/atomic"
sync/atomic.LoadInt64 Citește atomic un int64.
import "sync/atomic"
sync/atomic.StoreInt64 Scrie atomic un int64.
import "sync/atomic"
sync/atomic.CompareAndSwapInt64 Scrie atomic doar dacă valoarea curentă este cea așteptată.
import "sync/atomic"
sync/atomic.SwapInt64 Scrie atomic și returnează valoarea veche.
import "sync/atomic"
sync/atomic.Int64 Tip int64 cu operații atomice ca metode; recomandat pentru contoare.
import "sync/atomic"
sync/atomic.Int64.Add Adună atomic și returnează valoarea nouă.
import "sync/atomic"
sync/atomic.Int64.And ȘI pe biți atomic; returnează valoarea veche.
import "sync/atomic"
sync/atomic.Int64.CompareAndSwap Scrie doar dacă valoarea curentă este cea așteptată.
import "sync/atomic"
sync/atomic.Int64.Load Citește valoarea atomic.
import "sync/atomic"
sync/atomic.Int64.Or SAU pe biți atomic; returnează valoarea veche.
import "sync/atomic"
sync/atomic.Int64.Store Scrie valoarea atomic.
import "sync/atomic"
sync/atomic.Int64.Swap Scrie valoarea nouă și o returnează pe cea veche.
import "sync/atomic"
sync/atomic.Int32 Tip int32 cu operații atomice (Add, Load, Store, Swap, CompareAndSwap).
import "sync/atomic"
sync/atomic.Bool Valoare bool citită și scrisă atomic.
import "sync/atomic"
sync/atomic.Value Ține o valoare de orice tip, înlocuită și citită atomic.
import "sync/atomic"
sync/atomic.Pointer Pointer *T generic, citit și înlocuit atomic.
import "sync/atomic"
context.AfterFunc Programează o funcție să ruleze când contextul este anulat.
import "context"
context.Cause Motivul pentru care contextul a fost anulat.
import "context"
context.WithCancel Context copil cu funcție cancel pentru anulare manuală.
import "context"
context.WithCancelCause Ca WithCancel, dar cancel primește motivul anulării.
import "context"
context.WithDeadline Context care se anulează singur la un moment fix.
import "context"
context.WithDeadlineCause Ca WithDeadline, cu motiv raportat de Cause la expirare.
import "context"
context.WithTimeout Context care se anulează singur după o durată.
import "context"
context.WithTimeoutCause Ca WithTimeout, cu motiv raportat de Cause la expirare.
import "context"
context.Background Contextul rădăcină, gol: fără anulare, termen sau valori.
import "context"
context.TODO Context gol pus temporar unde încă nu există un context real.
import "context"
context.WithValue Context copil care poartă o pereche cheie-valoare.
import "context"
context.WithoutCancel Context copil cu valorile părintelui, dar care nu se anulează odată cu el.
import "context"
context.Context Transmite anularea, termenul limită și valori de cerere prin program.
import "context"

Web, JSON, codări și criptografie (113)

Funcție Ce face
net/http.Get Trimite o cerere GET și returnează răspunsul; corpul trebuie închis.
import "net/http"
net/http.Post Trimite o cerere POST cu un corp și tipul de conținut dat.
import "net/http"
net/http.PostForm Trimite un formular (url.Values) ca cerere POST codată.
import "net/http"
net/http.Head Trimite o cerere HEAD: doar antetele, fără corp.
import "net/http"
net/http.ListenAndServe Pornește un server HTTP pe adresa dată cu handler-ul dat.
import "net/http"
net/http.HandleFunc Înregistrează o funcție ca handler pentru o rută în routerul global.
import "net/http"
net/http.Handle Înregistrează un http.Handler pentru o rută în routerul global.
import "net/http"
net/http.NewRequest Construiește o cerere HTTP (metodă, URL, corp) pentru Client.Do.
import "net/http"
net/http.NewRequestWithContext Construiește o cerere legată de un context care o poate anula.
import "net/http"
net/http.Error Răspunde cu un cod de eroare și un mesaj text.
import "net/http"
net/http.Redirect Redirecționează clientul la altă adresă cu un cod 3xx.
import "net/http"
net/http.ServeFile Răspunde cu conținutul unui fișier anume.
import "net/http"
net/http.StatusText Textul standard al unui cod de stare (404 = Not Found).
import "net/http"
net/http.NotFound Răspunde cu 404 page not found.
import "net/http"
net/http.FileServer Handler care servește fișierele dintr-un director.
import "net/http"
net/http.StripPrefix Taie un prefix din calea cererii înainte de handler.
import "net/http"
net/http.NewServeMux Creează un router (ServeMux) nou, gol.
import "net/http"
net/http.SetCookie Adaugă un antet Set-Cookie în răspuns.
import "net/http"
net/http.MaxBytesReader Limitează mărimea corpului unei cereri.
import "net/http"
net/http.TimeoutHandler Împachetează un handler cu limită de timp (503 la depășire).
import "net/http"
net/http.Client Client HTTP configurabil: limită de timp, redirecționări, cookie-uri.
import "net/http"
net/http.Client.Do Trimite o cerere construită și returnează răspunsul.
import "net/http"
net/http.Client.Get Trimite o cerere GET cu acest client.
import "net/http"
net/http.Request O cerere HTTP: metodă, URL, antete, corp, context.
import "net/http"
net/http.Request.FormValue Prima valoare a unui câmp din formular sau din query.
import "net/http"
net/http.Request.PathValue Valoarea unui parametru {nume} din ruta potrivită.
import "net/http"
net/http.Request.Context Contextul cererii, anulat când clientul pleacă.
import "net/http"
net/http.Request.Cookie Cookie-ul cu numele dat trimis de client.
import "net/http"
net/http.Request.ParseForm Citește query-ul și formularul în r.Form și r.PostForm.
import "net/http"
net/http.ResponseWriter Interfața prin care handler-ul scrie antetele, codul și corpul.
import "net/http"
net/http.ServeMux Router care alege handler-ul după metoda și calea cererii.
import "net/http"
net/http.ServeMux.HandleFunc Adaugă o rută tratată de o funcție.
import "net/http"
net/http.ServeMux.Handle Adaugă o rută tratată de un http.Handler.
import "net/http"
net/http.Server Server HTTP configurabil: adresă, handler, limite de timp.
import "net/http"
net/http.Server.ListenAndServe Pornește serverul și blochează până la oprire.
import "net/http"
net/http.Server.Shutdown Oprește serverul curat, așteptând cererile în curs.
import "net/http"
net/http.Header Antetele HTTP: map de la nume la valori.
import "net/http"
net/http.Header.Get Prima valoare a unui antet (nume fără diferență de litere).
import "net/http"
net/http.Header.Set Setează un antet, înlocuind valorile existente.
import "net/http"
net/http.Header.Add Adaugă încă o valoare unui antet.
import "net/http"
net/http.Header.Del Șterge un antet.
import "net/http"
net/http.Handler Interfața cu metoda ServeHTTP, implementată de orice handler.
import "net/http"
net/http.HandlerFunc Tip care transformă o funcție obișnuită în http.Handler.
import "net/http"
net/http.Response Răspunsul primit de client: cod, antete, corp.
import "net/http"
net/http.Cookie Descrierea unui cookie HTTP: nume, valoare, durată, opțiuni.
import "net/http"
net/url.Parse Desface o adresă URL în părțile ei.
import "net/url"
net/url.QueryEscape Codează un text pentru o valoare din query string.
import "net/url"
net/url.QueryUnescape Decodează un text codat pentru query string.
import "net/url"
net/url.PathEscape Codează un text pentru un segment de cale.
import "net/url"
net/url.ParseQuery Desface un text a=1&b=2 în url.Values, cu eroare.
import "net/url"
net/url.JoinPath Adaugă segmente la calea unei adrese, cu o singură bară între ele.
import "net/url"
net/url.URL Structura unei adrese: schemă, host, cale, query, fragment.
import "net/url"
net/url.URL.Query Parametrii din query, ca url.Values (copie).
import "net/url"
net/url.URL.String Adresa completă, reconstruită și codată.
import "net/url"
net/url.URL.JoinPath URL nou cu segmente adăugate la cale.
import "net/url"
net/url.Values Parametri query sau formular: map de la nume la valori.
import "net/url"
net/url.Values.Get Prima valoare a unui parametru.
import "net/url"
net/url.Values.Set Setează un parametru, înlocuind valorile.
import "net/url"
net/url.Values.Add Adaugă încă o valoare unui parametru.
import "net/url"
net/url.Values.Del Șterge un parametru.
import "net/url"
net/url.Values.Has Spune dacă parametrul există.
import "net/url"
net/url.Values.Encode Textul codat, cu cheile sortate.
import "net/url"
encoding/json.Marshal Transformă o valoare Go în JSON; etichetele json aleg numele.
import "encoding/json"
encoding/json.MarshalIndent Ca Marshal, dar indentat pe mai multe rânduri.
import "encoding/json"
encoding/json.Unmarshal Citește JSON într-o valoare Go dată prin pointer.
import "encoding/json"
encoding/json.Valid Spune dacă un text este JSON valid.
import "encoding/json"
encoding/json.NewEncoder Creează un Encoder care scrie JSON într-un io.Writer.
import "encoding/json"
encoding/json.NewDecoder Creează un Decoder care citește JSON dintr-un io.Reader.
import "encoding/json"
encoding/json.Indent Reformatează un text JSON existent, indentat.
import "encoding/json"
encoding/json.Compact Elimină spațiile inutile dintr-un text JSON.
import "encoding/json"
encoding/json.Encoder Scriitor de JSON peste un io.Writer.
import "encoding/json"
encoding/json.Encoder.Encode Scrie o valoare ca JSON, urmată de rând nou.
import "encoding/json"
encoding/json.Encoder.SetIndent Face ca valorile scrise să fie indentate.
import "encoding/json"
encoding/json.Decoder Cititor de JSON dintr-un flux.
import "encoding/json"
encoding/json.Decoder.Decode Citește următoarea valoare JSON din flux.
import "encoding/json"
encoding/json.Decoder.DisallowUnknownFields Dă eroare pentru chei JSON fără câmp în structură.
import "encoding/json"
encoding/json.Decoder.More Spune dacă mai urmează un element în lista sau obiectul curent.
import "encoding/json"
encoding/json.RawMessage Fragment JSON păstrat ca text brut, decodat mai târziu.
import "encoding/json"
encoding/json.Marshaler Interfață pentru o formă JSON proprie la scriere (MarshalJSON).
import "encoding/json"
encoding/json.Unmarshaler Interfață pentru citire JSON proprie (UnmarshalJSON).
import "encoding/json"
encoding/csv.NewReader Creează un cititor CSV peste un io.Reader.
import "encoding/csv"
encoding/csv.NewWriter Creează un scriitor CSV peste un io.Writer.
import "encoding/csv"
encoding/csv.Reader Cititor de fișiere CSV, cu separator și opțiuni configurabile.
import "encoding/csv"
encoding/csv.Reader.Read Citește următorul rând CSV ca []string.
import "encoding/csv"
encoding/csv.Reader.ReadAll Citește toate rândurile CSV rămase.
import "encoding/csv"
encoding/csv.Writer Scriitor de fișiere CSV, cu ghilimele automate.
import "encoding/csv"
encoding/csv.Writer.Write Scrie un rând CSV în buffer.
import "encoding/csv"
encoding/csv.Writer.WriteAll Scrie toate rândurile și apelează Flush.
import "encoding/csv"
encoding/csv.Writer.Flush Trimite datele din buffer la destinație.
import "encoding/csv"
encoding/base64.Encoding O codare Base64: StdEncoding, URLEncoding și variantele Raw.
import "encoding/base64"
encoding/base64.Encoding.EncodeToString Codează octeți ca text Base64.
import "encoding/base64"
encoding/base64.Encoding.DecodeString Decodează un text Base64 în octeți.
import "encoding/base64"
encoding/hex.EncodeToString Scrie octeții ca text hexazecimal.
import "encoding/hex"
encoding/hex.DecodeString Citește un text hexazecimal în octeți.
import "encoding/hex"
encoding/hex.Dump Tabel hex al octeților, ca hexdump -C.
import "encoding/hex"
crypto/sha256.Sum256 Amprenta SHA-256 a unor date (32 de octeți).
import "crypto/sha256"
crypto/sha256.New Calculator SHA-256 în care scrii datele pe bucăți.
import "crypto/sha256"
crypto/md5.Sum Suma MD5 (16 octeți); doar pentru sume de control.
import "crypto/md5"
crypto/rand.Int Număr aleatoriu sigur, uniform în [0, max).
import "crypto/rand"
crypto/rand.Prime Număr prim aleatoriu cu numărul de biți dat.
import "crypto/rand"
crypto/rand.Read Umple un slice cu octeți aleatorii siguri.
import "crypto/rand"
crypto/rand.Text Text aleatoriu sigur (base32), gata de folosit ca token.
import "crypto/rand"
text/template.New Creează un șablon text gol cu un nume.
import "text/template"
text/template.Must Returnează șablonul sau se oprește cu panică la eroare.
import "text/template"
text/template.ParseFiles Încarcă șabloane din fișiere.
import "text/template"
text/template.Template Un șablon text (sau un set de șabloane cu nume).
import "text/template"
text/template.Template.Parse Citește textul șablonului și verifică sintaxa.
import "text/template"
text/template.Template.Execute Completează șablonul cu date și scrie rezultatul.
import "text/template"
text/template.Template.Funcs Adaugă funcții proprii folosibile în șablon.
import "text/template"
text/template.Template.ExecuteTemplate Execută din set șablonul cu numele dat.
import "text/template"
html/template.HTMLEscapeString Codează caracterele speciale HTML dintr-un text.
import "html/template"
html/template.Template Șablon HTML care codează automat datele (protecție XSS).
import "html/template"
html/template.Template.Execute Completează șablonul HTML cu date codate după context.
import "html/template"