Sintassi di base

La sintassi di base di Go è molto semplice e facile da capire, iniziamo con un esempio molto semplice.

package main

import "fmt"

func main() {
   fmt.Println("Hello Mondo!")
}

• La parola chiave package dichiara a quale pacchetto appartiene il file go corrente, il file di ingresso deve essere dichiarato come pacchetto main, la funzione di ingresso è la funzione main, quando si personalizzano pacchetti e funzioni si dovrebbe evitare di ripeterli.

• import è la parola chiave per l'importazione, seguita dal nome del pacchetto importato.

• func è la parola chiave per la dichiarazione di funzione, utilizzata per dichiarare una funzione.

• fmt.Println("Hello Mondo!") è un'istruzione che chiama la funzione Println del pacchetto fmt per l'output.

Questa è una semplice introduzione alla sintassi, ora esaminiamo più da vicino i concetti al suo interno.

Pacchetto

In Go, i programmi sono costruiti collegando pacchetti insieme. L'unità di base per l'importazione in Go è un pacchetto, non un file .go. Un pacchetto è essenzialmente una cartella, in inglese package, che condivide tutte le variabili, costanti e tutti i tipi definiti al suo interno. Si consiglia di utilizzare lettere minuscole per la denominazione dei pacchetti e di mantenerli il più brevi possibile.

Visibilità

Come menzionato in precedenza, all'interno di un pacchetto sono condivise tutte le variabili, costanti e tutti i tipi definiti, ma all'esterno del pacchetto non è così. A volte non si desidera che altri accedano a un certo tipo, quindi è necessario controllare la visibilità. Potresti aver visto parole chiave come Public, Private in altri linguaggi OOP, ma in Go non esistono, il modo in cui controlla la visibilità è molto semplice, le regole sono le seguenti

• I nomi che iniziano con lettere maiuscole sono tipi/variabili/costanti pubblici
• I nomi che iniziano con lettere minuscole o trattino basso sono tipi/variabili/costanti privati

Ad esempio, nel seguente esempio, la costante MyName è pubblica, mentre la costante mySalary è privata.

package example

// Pubblico
const MyName = "jack"

// Privato
const mySalary = 20_000

Questa regola di visibilità si applica ovunque in tutto il linguaggio Go.

Importazione

Importa un pacchetto per utilizzare i tipi/metodi/funzioni/variabili di quel pacchetto, la sintassi di importazione è import seguito dal nome del pacchetto

package main

import "example"

Quando si importano più pacchetti, puoi scrivere così

package main

import "example"
import "example1"

Oppure puoi racchiuderli tra parentesi, questo metodo è più comunemente usato nella pratica.

package main

import (
  "example"
  "example1"
)

Se ci sono nomi di pacchetto duplicati o nomi di pacchetto complessi, puoi anche assegnare loro degli alias

package main

import (
  e "example"
  e1 "example1"
)

Quando l'alias è un trattino basso _, si tratta di un'importazione anonima. I pacchetti importati in modo anonimo non possono essere utilizzati, questo viene fatto solitamente per caricare la funzione init del pacchetto, ma non è necessario utilizzare i tipi del pacchetto. Un esempio comune è la registrazione di driver di database, ma non è necessario utilizzarli manualmente.

package main

import (
  e "example"
  _ "mysql-driver-go"
)

Dopo aver importato, quando si desidera accedere a un tipo nel pacchetto, è possibile accedervi tramite nomePacchetto.identificatore, come nel seguente esempio, se si tenta di accedere a un tipo privato, il compilatore indicherà che non è possibile accedervi.

package main

import (
  "example"
   "fmt"
)

func main() {
    fmt.Println(example.MyName)
}

Esiste un modo speciale di importazione che consiste nell'importare tutti i tipi di quel pacchetto nell'ambito del pacchetto corrente. Con questo metodo di importazione, i tipi non richiedono più l'operatore . per essere accessibili, ma se ci sono tipi con lo stesso nome, non sarà possibile compilare.

package main

import (
  . "example"
)

WARNING

In Go non è possibile effettuare importazioni circolari, né dirette né indirette. Ad esempio, se il pacchetto A importa il pacchetto B e il pacchetto B importa anche il pacchetto A, si tratta di un'importazione circolare diretta. Se il pacchetto A importa il pacchetto C, il pacchetto C importa il pacchetto B e il pacchetto B importa il pacchetto A, si tratta di un'importazione circolare indiretta. Se esistono importazioni circolari, non sarà possibile compilare.

Pacchetto interno

In Go, per convenzione, un pacchetto chiamato internal all'interno di un pacchetto è un pacchetto interno. I pacchetti esterni non potranno accedere a nessun contenuto del pacchetto interno, altrimenti la compilazione non riuscirà. Vediamo un esempio.

/home/user/go/
    src/
        crash/
            bang/              (codice go nel pacchetto bang)
                b.go
        foo/                   (codice go nel pacchetto foo)
            f.go
            bar/               (codice go nel pacchetto bar)
                x.go
            internal/
                baz/           (codice go nel pacchetto baz)
                    z.go
            quux/              (codice go nel pacchetto main)
                y.go

Dalla struttura del file si può vedere che il pacchetto crash non può accedere ai tipi nel pacchetto baz.

Commenti

Go supporta commenti su singola riga e commenti su più righe. Si consiglia di lasciare uno spazio tra i commenti e il contenuto, ad esempio

// Questo è il pacchetto main
package main

// Importa il pacchetto fmt
import "fmt"

/*
*
Questa è la funzione di avvio main
*/
func main() {
  // Questa è un'istruzione
  fmt.Println("Hello Mondo!")
}

Identificatori

Un identificatore è un nome utilizzato per la denominazione di pacchetti, funzioni, variabili, ecc. Le regole di denominazione sono le seguenti

• Può essere composto solo da lettere, numeri e trattini bassi
• Può iniziare solo con lettere e trattini bassi
• Distingue rigorosamente tra maiuscole e minuscole
• Non può essere duplicato con nessun identificatore esistente, ovvero deve essere unico all'interno del pacchetto
• Non può essere in conflitto con nessuna parola chiave incorporata in Go

Di seguito sono elencate tutte le parole chiave incorporate, puoi anche visitare Manuale di riferimento - Identificatori per maggiori dettagli

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Operatori

Di seguito è riportata la priorità degli operatori supportati nel linguaggio Go, puoi anche visitare Manuale di riferimento - Operatori per maggiori dettagli.

Precedenza    Operatore
    5             *  /  %  <<  >>  &  &^
    4             +  -  |  ^
    3             ==  !=  <  <=  >  >=
    2             &&
    1             ||

C'è un punto a cui prestare attenzione, nel linguaggio Go non è stato scelto ~ come operatore di negazione, ma è stato riutilizzato il simbolo ^. Quando ^ viene utilizzato tra due numeri, ad esempio a^b, è l'operatore XOR. Quando viene utilizzato su un solo numero, ad esempio ^a, allora è l'operatore di negazione. Go supporta anche gli operatori di assegnazione avanzata, come segue.

a += 1
a /= 2
a &^= 2

TIP

Il linguaggio Go non ha operatori di incremento e decremento, sono stati declassati a istruzioni statement ed è stato specificato che possono trovarsi solo dopo l'operando, quindi non c'è bisogno di preoccuparsi di problemi come i++ e ++i.

a++ // Corretto
++a // Errato
a-- // Corretto

Un altro punto è che non hanno più un valore di ritorno, quindi istruzioni come a = b++ sono errate.

Letterali

Un letterale, secondo la terminologia dell'informatica, è un simbolo utilizzato per rappresentare un valore fisso nel codice sorgente, chiamato anche valore letterale. Entrambi i nomi hanno lo stesso significato, ciò che viene scritto è il valore, il valore è il valore "letterale".

Letterali interi

Per facilitare la lettura, è consentito utilizzare il trattino basso _ per suddividere i numeri, ma è consentito solo dopo il simbolo del prefisso e tra le cifre.

24 // 24
024 // 24
2_4 // 24
0_2_4 // 24
10_000 // 10k
100_000 // 100k
0O24 // 20
0b00 // 0
0x00 // 0
0x0_0 // 0

Letterali floating-point

È possibile esprimere numeri floating-point di diverse basi utilizzando diversi prefissi

0.
72.40
072.40       // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5
1_5.         // == 15.0
0.15e+0_2    // == 15.0

0x1p-2       // == 0.25
0x2.p10      // == 2048.0
0x1.Fp+0     // == 1.9375
0X.8p-0      // == 0.5
0X_1FFFP-16  // == 0.1249847412109375
0x15e-2      // == 0x15e - 2 (sottrazione intera)

Letterali complessi

0i
0123i         // == 123i
0o123i        // == 0o123 * 1i == 83i
0xabci        // == 0xabc * 1i == 2748i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i
0x1p-2i       // == 0x1p-2 * 1i == 0.25i

Letterali di carattere

I letterali di carattere devono essere racchiusi tra virgolette singole '', i caratteri in Go sono completamente compatibili con utf8.

'a'
'ä'
'你'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'

Caratteri di escape

Caratteri di escape disponibili in Go

\a   U+0007 Carattere di bell
\b   U+0008 Carattere di backspace
\f   U+000C Carattere di form feed
\n   U+000A Carattere di nuova riga
\r   U+000D Carattere di ritorno a capo
\t   U+0009 Carattere di tabulazione orizzontale
\v   U+000B Carattere di tabulazione verticale
\\   U+005C Escape per backslash
\'   U+0027 Escape per virgoletta singola (valido solo all'interno di caratteri)
\"   U+0022 Escape per virgoletta doppia (valido solo all'interno di stringhe)

Letterali di stringa

I letterali di stringa devono essere racchiusi tra virgolette doppie "" o accenti gravi `` (le stringhe con accento grave non consentono l'escape)

`abc`                // "abc"
`\n
\n`                  // "\\n\n\\n"
"\n"
"\""                 // `"`
"Hello, world!\n"
"今天天气不错"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"

Funzioni

La dichiarazione di funzioni in Go viene effettuata tramite la parola chiave func, simile alla maggior parte dei linguaggi

func main() {
  println(1)
}

Tuttavia, ci sono due differenze nelle funzioni di Go. La prima è che il tipo dei parametri viene dopo, come mostrato di seguito

func Hello(name string) {
  fmt.Println(name)
}

La seconda differenza è il valore di ritorno multiplo, che può anche avere nomi

func Pos() () (x, y float64) {
    ...
}

Stile

Per quanto riguarda lo stile di codifica, Go impone a tutti di adottare lo stesso stile. Go fornisce uno strumento di formattazione gofmt che può essere utilizzato tramite la riga di comando. Questo strumento di formattazione non ha parametri di formattazione da passare, gli unici due parametri sono solo per output del processo di formattazione, quindi non supporta affatto la personalizzazione. Ciò significa che tutto il codice formattato tramite questo strumento ha lo stesso stile di codifica, il che ridurrà notevolmente il carico cognitivo per i manutentori. Quindi cercare la personalità in questo ambito non è una scelta saggia.

Di seguito sono elencate alcune regole semplici, a cui si può prestare attenzione durante la scrittura del codice.

Parentesi graffe delle funzioni su nuova riga

Se le parentesi graffe dopo una funzione debbano andare su una nuova riga o meno, quasi ogni programmatore può dare le proprie ragioni. In Go, tutte le parentesi graffe non dovrebbero andare su una nuova riga

// Esempio corretto
func main() {
  fmt.Println("Hello Mondo!")
}

Se lo fai davvero, come mostrato di seguito

// Esempio errato
func main()
{
  fmt.Println("Hello Mondo!")
}

Questo tipo di codice non può nemmeno essere compilato, quindi Go impone a tutti i programmatori di non andare a capo dopo le parentesi delle funzioni.

Indentazione del codice

Go utilizza per impostazione predefinita il carattere di tabulazione Tab per l'indentazione, solo in alcune situazioni speciali verranno utilizzati gli spazi.

Spaziatura del codice

La maggior parte delle spaziature in Go ha un significato, in un certo senso, questo rappresenta anche come il compilatore vede il tuo codice. Ad esempio, per le operazioni matematiche seguenti

2*9 + 1/3*2

Come è noto, la priorità della moltiplicazione è superiore a quella dell'addizione. Dopo la formattazione, la spaziatura tra i simboli * sarà più compatta, il che significa che verranno calcolati per primi, mentre la spaziatura vicino al simbolo + sarà maggiore, il che rappresenta un calcolo successivo.

Omissione delle parentesi graffe

In altri linguaggi, le istruzioni if e for possono essere solitamente abbreviate, come mostrato di seguito

for (int i=0; i < 10; i++) printf("%d", i)

Ma in Go non è possibile, puoi scrivere solo una riga, ma devi aggiungere le parentesi graffe

for i := 0; i < 10; i++ {fmt.Println(i)}

Espressioni ternarie

Go non ha espressioni ternarie, quindi il seguente codice non può essere compilato

var c = a > b ? a : b

Attraverso questo articolo puoi avere una conoscenza preliminare della sintassi di Go, nei contenuti successivi verrà approfondita in modo più dettagliato.