Vai - Guida rapida

Go è un linguaggio generico progettato pensando alla programmazione dei sistemi. Inizialmente è stato sviluppato da Google nel 2007 da Robert Griesemer, Rob Pike e Ken Thompson. È fortemente e staticamente tipizzato, fornisce il supporto integrato per la garbage collection e supporta la programmazione concorrente.

I programmi sono costruiti utilizzando pacchetti, per una gestione efficiente delle dipendenze. Le implementazioni di programmazione Go utilizzano un modello di compilazione e collegamento tradizionale per generare file binari eseguibili. Il linguaggio di programmazione Go è stato annunciato nel novembre 2009 ed è utilizzato in alcuni dei sistemi di produzione di Google.

Caratteristiche di Go Programming

Le caratteristiche più importanti della programmazione Go sono elencate di seguito:

Supporto per l'ambiente che adotta modelli simili ai linguaggi dinamici. Ad esempio, inferenza di tipo (x: = 0 è una dichiarazione valida di una variabile x di tipo int)
Il tempo di compilazione è veloce.
Supporto integrato della concorrenza: processi leggeri (tramite routine go), canali, istruzione select.
I programmi Go sono semplici, concisi e sicuri.
Supporto per interfacce e incorporamento di tipi.
Produzione di file binari nativi collegati staticamente senza dipendenze esterne.

Caratteristiche escluse intenzionalmente

Per mantenere il linguaggio semplice e conciso, le seguenti funzionalità comunemente disponibili in altre lingue simili vengono omesse in Go:

Supporto per l'ereditarietà del tipo
Supporto per il sovraccarico di metodi o operatori
Supporto per dipendenze circolari tra pacchetti
Supporto per l'aritmetica del puntatore
Supporto per affermazioni
Supporto per la programmazione generica

Vai ai programmi

Un programma Go può variare in lunghezza da 3 righe a milioni di righe e dovrebbe essere scritto in uno o più file di testo con estensione ".go". Ad esempio, hello.go.

Puoi usare "vi", "vim" o qualsiasi altro editor di testo per scrivere il tuo programma Go in un file.

Configurazione dell'ambiente locale

Se sei ancora disposto a configurare il tuo ambiente per il linguaggio di programmazione Go, hai bisogno dei seguenti due software disponibili sul tuo computer:

Un editor di testo
Vai al compilatore

Editor di testo

Avrai bisogno di un editor di testo per digitare i tuoi programmi. Esempi di editor di testo includono Blocco note di Windows, comando Modifica OS, Brief, Epsilon, EMACS e vim o vi.

Il nome e la versione degli editor di testo possono variare a seconda dei sistemi operativi. Ad esempio, Blocco note viene utilizzato su Windows e vim o vi è utilizzato su Windows, Linux o UNIX.

Vengono chiamati i file che crei con l'editor di testo source files. Contengono il codice sorgente del programma. I file sorgente per i programmi Go sono in genere denominati con l'estensione".go".

Prima di iniziare la programmazione, assicurati di avere un editor di testo e di avere abbastanza esperienza per scrivere un programma per computer, salvarlo in un file, compilarlo e infine eseguirlo.

Il compilatore Go

Il codice sorgente scritto nel file sorgente è la sorgente leggibile dall'uomo per il tuo programma. Deve essere compilato e trasformato in linguaggio macchina in modo che la tua CPU possa effettivamente eseguire il programma secondo le istruzioni fornite. Il compilatore del linguaggio di programmazione Go compila il codice sorgente nel suo programma eseguibile finale.

La distribuzione Go viene fornita come binario installabile per FreeBSD (versione 8 e successive), Linux, Mac OS X (Snow Leopard e successive) e sistemi operativi Windows con architetture di processori x86 a 32 bit (386) e 64 bit (amd64).

La sezione seguente spiega come installare la distribuzione binaria Go su vari sistemi operativi.

Scarica Go Archive

Scarica l'ultima versione del file di archivio installabile Go da Go Downloads . La seguente versione viene utilizzata in questo tutorial: go1.4.windows-amd64.msi .

Viene copiato nella cartella C: \> go.

OS	Nome dell'archivio
finestre	go1.4.windows-amd64.msi
Linux	go1.4.linux-amd64.tar.gz
Mac	go1.4.darwin-amd64-osx10.8.pkg
FreeBSD	go1.4.freebsd-amd64.tar.gz

Installazione su UNIX / Linux / Mac OS X e FreeBSD

Estrai l'archivio di download nella cartella / usr / local, creando un albero Go in / usr / local / go. Ad esempio:

tar -C / usr / local -xzf go1.4.linux-amd64.tar.gz

Aggiungi / usr / local / go / bin alla variabile d'ambiente PATH.

OS	Produzione
Linux	export PATH = $ PATH: / usr / local / go / bin
Mac	export PATH = $ PATH: / usr / local / go / bin
FreeBSD	export PATH = $ PATH: / usr / local / go / bin

Installazione su Windows

Usa il file MSI e segui le istruzioni per installare gli strumenti Go. Per impostazione predefinita, il programma di installazione utilizza la distribuzione Go in c: \ Go. Il programma di installazione dovrebbe impostare la directory c: \ Go \ bin nella variabile di ambiente PATH di Windows. Riavvia tutti i prompt dei comandi aperti per rendere effettive le modifiche.

Verifica dell'installazione

Crea un file go denominato test.go in C:\>Go_WorkSpace.

File: test.go

package main

import "fmt"

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

Ora esegui test.go per vedere il risultato -

C:\Go_WorkSpace>go run test.go

Produzione

Hello, World!

Prima di studiare gli elementi costitutivi di base del linguaggio di programmazione Go, discutiamo prima la struttura minima dei programmi Go in modo da poterla prendere come riferimento nei capitoli successivi.

Hello World Example

Un programma Go è costituito fondamentalmente dalle seguenti parti:

Dichiarazione del pacchetto
Importa pacchetti
Functions
Variables
Dichiarazioni ed espressioni
Comments

Esaminiamo un semplice codice che stamperebbe le parole "Hello World" -

package main

import "fmt"

func main() {
   /* This is my first sample program. */
   fmt.Println("Hello, World!")
}

Diamo uno sguardo alle varie parti del programma di cui sopra:

La prima riga del pacchetto principale del programma definisce il nome del pacchetto in cui dovrebbe trovarsi questo programma. È un'istruzione obbligatoria, poiché i programmi Go vengono eseguiti in pacchetti. Il pacchetto principale è il punto di partenza per eseguire il programma. Ogni pacchetto ha un percorso e un nome associati.
La riga successiva import "fmt" è un comando del preprocessore che dice al compilatore Go di includere i file che si trovano nel pacchetto fmt.
La riga successiva func main () è la funzione principale da cui inizia l'esecuzione del programma.
La riga successiva /*...*/ viene ignorata dal compilatore ed è lì per aggiungere commenti nel programma. I commenti sono anche rappresentati usando // simili ai commenti Java o C ++.
La riga successiva fmt.Println (...) è un'altra funzione disponibile in Go che genera il messaggio "Hello, World!" da visualizzare sullo schermo. Qui il pacchetto fmt ha esportato il metodo Println che viene utilizzato per visualizzare il messaggio sullo schermo.
Notare la P maiuscola del metodo Println. Nella lingua Go, un nome viene esportato se inizia con una lettera maiuscola. Esportato significa che la funzione o la variabile / costante è accessibile all'importatore del rispettivo pacchetto.

Esecuzione di un programma Go

Parliamo di come salvare il codice sorgente in un file, compilarlo e infine eseguire il programma. Si prega di seguire i passaggi indicati di seguito -

Apri un editor di testo e aggiungi il codice sopra menzionato.
Salva il file come hello.go
Apri il prompt dei comandi.
Vai alla directory in cui hai salvato il file.
Digita go run hello.go e premi Invio per eseguire il codice.
Se non ci sono errori nel codice, vedrai "Hello World!" stampato sullo schermo.

$ go run hello.go
Hello, World!

Assicurati che il compilatore Go sia nel tuo percorso e che lo stai eseguendo nella directory che contiene il file sorgente hello.go.

Abbiamo discusso la struttura di base di un programma Go nel capitolo precedente. Ora sarà facile capire gli altri elementi costitutivi di base del linguaggio di programmazione Go.

Gettoni in Go

Un programma Go è costituito da vari token. Un token è una parola chiave, un identificatore, una costante, una stringa letterale o un simbolo. Ad esempio, la seguente istruzione Go è composta da sei token:

fmt.Println("Hello, World!")

I gettoni individuali sono:

fmt
.
Println
(
   "Hello, World!"
)

Separatore di linea

In un programma Go, il separatore di riga è un terminatore di istruzione. Cioè, le singole dichiarazioni non necessitano di un separatore speciale come ";" in C. Il compilatore Go inserisce internamente ";" come terminatore dell'istruzione per indicare la fine di un'entità logica.

Ad esempio, dai un'occhiata alle seguenti affermazioni:

fmt.Println("Hello, World!")
fmt.Println("I am in Go Programming World!")

Commenti

I commenti sono come testi di aiuto nel programma Go e vengono ignorati dal compilatore. Iniziano con / * e terminano con i caratteri * / come mostrato di seguito -

/* my first program in Go */

Non è possibile avere commenti all'interno di commenti e non si trovano all'interno di una stringa o di caratteri letterali.

Identificatori

Un identificatore Go è un nome utilizzato per identificare una variabile, una funzione o qualsiasi altro elemento definito dall'utente. Un identificatore inizia con una lettera dalla A alla Z o dalla aaz o un trattino basso _ seguito da zero o più lettere, trattini bassi e cifre (da 0 a 9).

identificatore = lettera {lettera | unicode_digit}.

Go non consente caratteri di punteggiatura come @, $ e% all'interno degli identificatori. Go è uncase-sensitivelinguaggio di programmazione. Pertanto, Manpower e manpower sono due identificatori diversi in Go. Di seguito sono riportati alcuni esempi di identificatori accettabili:

mahesh      kumar   abc   move_name   a_123
myname50   _temp    j      a23b9      retVal

Parole chiave

Il seguente elenco mostra le parole riservate in Go. Queste parole riservate non possono essere utilizzate come costanti, variabili o altri nomi di identificatori.

rompere	predefinito	funz	interfaccia	Selezionare
Astuccio	differire	Partire	carta geografica	Struct
chan	altro	Vai a	pacchetto	Interruttore
const	sfumare	Se	gamma	genere
Continua	per	importare	ritorno	Var

Spazio bianco in Go

Lo spazio bianco è il termine utilizzato in Vai per descrivere spazi vuoti, tabulazioni, caratteri di nuova riga e commenti. Una riga contenente solo spazi, possibilmente con un commento, è nota come riga vuota e un compilatore Go la ignora completamente.

Gli spazi bianchi separano una parte di un'istruzione da un'altra e consentono al compilatore di identificare dove un elemento in un'istruzione, come int, finisce e inizia l'elemento successivo. Pertanto, nella seguente dichiarazione:

var age int;

Ci deve essere almeno un carattere di spazio (di solito uno spazio) tra int ed age affinché il compilatore sia in grado di distinguerli. D'altra parte, nella seguente dichiarazione:

fruit = apples + oranges;   // get the total fruit

Non sono necessari caratteri di spazi bianchi tra frutta e =, o tra = e mele, sebbene tu sia libero di includerne alcuni se lo desideri per motivi di leggibilità.

Nel linguaggio di programmazione Go, i tipi di dati si riferiscono a un ampio sistema utilizzato per dichiarare variabili o funzioni di diversi tipi. Il tipo di variabile determina quanto spazio occupa nella memoria e come viene interpretata la sequenza di bit memorizzata.

I tipi in Go possono essere classificati come segue:

Sr.No.	Tipi e descrizione
1	Boolean types Sono di tipo booleano e sono costituiti dalle due costanti predefinite: (a) true (b) false
2	Numeric types Sono ancora tipi aritmetici e rappresentano a) tipi interi o b) valori in virgola mobile in tutto il programma.
3	String types Un tipo stringa rappresenta l'insieme di valori stringa. Il suo valore è una sequenza di byte. Le stringhe sono tipi immutabili che una volta create, non è possibile modificare il contenuto di una stringa. Il tipo di stringa predichiarato è stringa.
4	Derived types Includono (a) tipi di puntatore, (b) tipi di array, (c) tipi di struttura, (d) tipi di unione e (e) tipi di funzione f) tipi di sezioni g) tipi di interfaccia h) tipi di mappa i) tipi di canale

I tipi di array e i tipi di struttura vengono indicati collettivamente come aggregate types. Il tipo di una funzione specifica l'insieme di tutte le funzioni con gli stessi parametri e tipi di risultati. Discuteremo i tipi di base nella sezione seguente, mentre altri tipi saranno trattati nei prossimi capitoli.

Tipi interi

I tipi interi indipendenti dall'architettura predefiniti sono:

Sr.No.	Tipi e descrizione
1	uint8 Intero a 8 bit senza segno (da 0 a 255)
2	uint16 Intero a 16 bit senza segno (da 0 a 65535)
3	uint32 Intero a 32 bit senza segno (da 0 a 4294967295)
4	uint64 Intero a 64 bit senza segno (da 0 a 18446744073709551615)
5	int8 Intero a 8 bit con segno (da -128 a 127)
6	int16 Intero a 16 bit con segno (da -32768 a 32767)
7	int32 Intero a 32 bit con segno (da -2147483648 a 2147483647)
8	int64 Intero a 64 bit con segno (da -9223372036854775808 a 9223372036854775807)

Tipi galleggianti

I tipi di virgola mobile predefiniti indipendenti dall'architettura sono:

Sr.No.	Tipi e descrizione
1	float32 Numeri in virgola mobile a 32 bit IEEE-754
2	float64 Numeri in virgola mobile a 64 bit IEEE-754
3	complex64 Numeri complessi con float32 parti reali e immaginarie
4	complex128 Numeri complessi con parti reali e immaginarie float64

Il valore di un intero a n bit è n bit ed è rappresentato utilizzando operazioni aritmetiche in complemento a due.

Altri tipi numerici

C'è anche una serie di tipi numerici con dimensioni specifiche dell'implementazione:

Sr.No.	Tipi e descrizione
1	byte uguale a uint8
2	rune uguale a int32
3	uint 32 o 64 bit
4	int stesse dimensioni di uint
5	uintptr un numero intero senza segno per memorizzare i bit non interpretati di un valore del puntatore

Una variabile non è altro che un nome dato a un'area di memoria che i programmi possono manipolare. Ogni variabile in Go ha un tipo specifico, che determina la dimensione e il layout della memoria della variabile, l'intervallo di valori che possono essere memorizzati all'interno di quella memoria e l'insieme di operazioni che possono essere applicate alla variabile.

Il nome di una variabile può essere composto da lettere, cifre e il carattere di sottolineatura. Deve iniziare con una lettera o un trattino basso. Le lettere maiuscole e minuscole sono distinte perché Go distingue tra maiuscole e minuscole. In base ai tipi di base spiegati nel capitolo precedente, ci saranno i seguenti tipi di variabili di base:

Suor n	Tipo e descrizione
1	byte Tipicamente un singolo ottetto (un byte). Questo è un tipo di byte.
2	int La dimensione più naturale del numero intero per la macchina.
3	float32 Un valore in virgola mobile a precisione singola.

Il linguaggio di programmazione Go consente anche di definire vari altri tipi di variabili come Enumeration, Pointer, Array, Structure e Union, di cui parleremo nei capitoli successivi. In questo capitolo ci concentreremo solo sui tipi di variabili di base.

Definizione variabile in Go

Una definizione di variabile indica al compilatore dove e quanto spazio di archiviazione creare per la variabile. Una definizione di variabile specifica un tipo di dati e contiene un elenco di una o più variabili di quel tipo come segue:

var variable_list optional_data_type;

Qui, optional_data_type è un tipo di dati Go valido che include byte, int, float32, complex64, boolean o qualsiasi oggetto definito dall'utente, ecc. e variable_listpuò essere costituito da uno o più nomi di identificatori separati da virgole. Alcune dichiarazioni valide sono mostrate qui -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

La dichiarazione “var i, j, k;”dichiara e definisce le variabili i, j e k; che indica al compilatore di creare variabili denominate i, j e k di tipo int.

Le variabili possono essere inizializzate (assegnato un valore iniziale) nella loro dichiarazione. Il tipo di variabile viene giudicato automaticamente dal compilatore in base al valore passato ad essa. L'inizializzatore è costituito da un segno di uguale seguito da un'espressione costante come segue:

variable_name = value;

Per esempio,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Per la definizione senza un inizializzatore: le variabili con durata di memorizzazione statica sono inizializzate implicitamente con nil (tutti i byte hanno il valore 0); il valore iniziale di tutte le altre variabili è il valore zero del loro tipo di dati.

Dichiarazione di tipo statico in Go

Una dichiarazione di variabile di tipo statico fornisce la garanzia al compilatore che è disponibile una variabile con il tipo e il nome dati in modo che il compilatore possa procedere per un'ulteriore compilazione senza richiedere i dettagli completi della variabile. Una dichiarazione di variabile ha il suo significato solo al momento della compilazione, il compilatore necessita dell'effettiva dichiarazione di variabile al momento del collegamento del programma.

Esempio

Prova il seguente esempio, dove la variabile è stata dichiarata con un tipo e inizializzata all'interno della funzione principale -

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

20
x is of type float64

Dichiarazione di tipo dinamico / inferenza di tipo in Go

Una dichiarazione di variabile di tipo dinamico richiede che il compilatore interpreti il tipo della variabile in base al valore passato ad essa. Il compilatore non richiede che una variabile abbia il tipo staticamente come requisito necessario.

Esempio

Prova il seguente esempio, in cui le variabili sono state dichiarate senza alcun tipo. Nota, in caso di inferenza di tipo, abbiamo inizializzato la variabiley con: = operatore, mentre x viene inizializzato utilizzando l'operatore =.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

20
42
x is of type float64
y is of type int

Dichiarazione di variabili miste in Go

Le variabili di diversi tipi possono essere dichiarate in una volta sola utilizzando l'inferenza del tipo.

Esempio

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

3
4
foo
a is of type int
b is of type int
c is of type string

I lvalues e i rvalues in Go

Ci sono due tipi di espressioni in Go:

lvalue- Le espressioni che fanno riferimento a una posizione di memoria sono chiamate espressione "lvalue". Un lvalue può essere visualizzato sia come lato sinistro che come lato destro di un compito.
rvalue- Il termine rvalue si riferisce a un valore di dati archiviato in un indirizzo in memoria. Un rvalue è un'espressione a cui non può essere assegnato un valore, il che significa che un rvalue può apparire a destra ma non a sinistra di un compito.

Le variabili sono i valori e quindi possono apparire sul lato sinistro di un compito. I letterali numerici sono rvalues e quindi potrebbero non essere assegnati e non possono essere visualizzati sul lato sinistro.

La seguente dichiarazione è valida:

x = 20.0

La seguente dichiarazione non è valida. Genererebbe un errore in fase di compilazione -

10 = 20

Le costanti si riferiscono a valori fissi che il programma non può alterare durante la sua esecuzione. Questi valori fissi vengono anche chiamatiliterals.

Le costanti possono essere di uno qualsiasi dei tipi di dati di base come una costante intera, una costante mobile, una costante di carattere o una stringa letterale . Ci sono anche costanti di enumerazione.

Le costanti vengono trattate come variabili regolari tranne per il fatto che i loro valori non possono essere modificati dopo la loro definizione.

Letterali interi

Un valore letterale intero può essere una costante decimale, ottale o esadecimale. Un prefisso specifica la base o la radice: 0x o 0X per esadecimale, 0 per ottale e niente per decimale.

Un valore letterale intero può anche avere un suffisso che è una combinazione di U e L, rispettivamente per unsigned e long. Il suffisso può essere maiuscolo o minuscolo e può essere in qualsiasi ordine.

Ecco alcuni esempi di valori letterali interi:

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

Di seguito sono riportati altri esempi di vari tipi di valori letterali interi:

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

Valori letterali a virgola mobile

Un valore letterale a virgola mobile ha una parte intera, una virgola decimale, una parte frazionaria e una parte esponente. È possibile rappresentare valori letterali a virgola mobile in forma decimale o esponenziale.

Mentre si rappresenta utilizzando la forma decimale, è necessario includere il punto decimale, l'esponente o entrambi e mentre si rappresenta utilizzando la forma esponenziale, è necessario includere la parte intera, la parte frazionaria o entrambe. L'esponente con segno è introdotto da e o E.

Ecco alcuni esempi di valori letterali in virgola mobile:

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Sequenza di fuga

Quando alcuni caratteri sono preceduti da una barra rovesciata, avranno un significato speciale in Vai. Questi sono noti come codici di sequenza di escape che vengono utilizzati per rappresentare la nuova riga (\ n), la tabulazione (\ t), il backspace, ecc.

Sequenza di escape	Senso
\\	\ personaggio
\ '	' personaggio
\ "	" personaggio
\?	? personaggio
\un	Allerta o campanello
\ b	Backspace
\ f	Avanzamento modulo
\ n	Nuova linea
\ r	Ritorno in carrozza
\ t	Tab orizzontale
\ v	Scheda verticale
\ ooo	Numero ottale da uno a tre cifre
\ xhh. . .	Numero esadecimale di una o più cifre

L'esempio seguente mostra come utilizzare \t in un programma -

package main

import "fmt"

func main() {
   fmt.Printf("Hello\tWorld!")
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Hello World!

Valori letterali stringa in Go

I valori letterali o le costanti stringa sono racchiusi tra virgolette doppie "". Una stringa contiene caratteri simili ai caratteri letterali: caratteri normali, sequenze di escape e caratteri universali.

È possibile suddividere una lunga riga in più righe utilizzando stringhe letterali e separandole utilizzando spazi bianchi.

Di seguito sono riportati alcuni esempi di stringhe letterali. Tutte e tre le forme sono stringhe identiche.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

La parola chiave const

Puoi usare const prefisso per dichiarare le costanti con un tipo specifico come segue:

const variable type = value;

L'esempio seguente mostra come utilizzare il const parola chiave -

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int

   area = LENGTH * WIDTH
   fmt.Printf("value of area : %d", area)   
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

value of area : 50

Notare che è una buona pratica di programmazione definire le costanti in MAIUSCOLO.

Un operatore è un simbolo che dice al compilatore di eseguire specifiche manipolazioni matematiche o logiche. La lingua Go è ricca di operatori incorporati e fornisce i seguenti tipi di operatori:

Operatori aritmetici
Operatori relazionali
Operatori logici
Operatori bit per bit
Operatori di assegnazione
Operatori vari

Questo tutorial spiega aritmetica, relazionale, logica, bit per bit, assegnazione e altri operatori uno per uno.

Operatori aritmetici

La tabella seguente mostra tutti gli operatori aritmetici supportati dal linguaggio Go. Assumi variabileA detiene 10 e variabile B tiene 20 quindi -

Mostra esempi

Operatore	Descrizione	Esempio
+	Aggiunge due operandi	A + B dà 30
-	Sottrae il secondo operando dal primo	A - B dà -10
*	Moltiplica entrambi gli operandi	A * B dà 200
/	Divide il numeratore per il denominatore.	B / A dà 2
%	Operatore modulo; dà il resto dopo una divisione intera.	B% A dà 0
++	Operatore di incremento. Aumenta il valore intero di uno.	A ++ dà 11
-	Operatore di decremento. Diminuisce il valore intero di uno.	A-- dà 9

Operatori relazionali

La tabella seguente elenca tutti gli operatori relazionali supportati dal linguaggio Go. Assumi variabileA detiene 10 e variabile B detiene 20, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
==	Controlla se i valori di due operandi sono uguali o meno; se sì, la condizione diventa vera.	(A == B) non è vero.
! =	Controlla se i valori di due operandi sono uguali o meno; se i valori non sono uguali, la condizione diventa vera.	(A! = B) è vero.
>	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro; se sì, la condizione diventa vera.	(A> B) non è vero.
<	Controlla se il valore dell'operando di sinistra è inferiore al valore dell'operando di destra; se sì, la condizione diventa vera.	(A <B) è vero.
> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro; se sì, la condizione diventa vera.	(A> = B) non è vero.
<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro; se sì, la condizione diventa vera.	(A <= B) è vero.

Operatori logici

La tabella seguente elenca tutti gli operatori logici supportati dalla lingua Go. Assumi variabileA detiene 1 e variabile B contiene 0, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
&&	Chiamato operatore AND logico. Se entrambi gli operandi sono diversi da zero, la condizione diventa vera.	(A && B) è falso.
\|\|	Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera.	(A \|\| B) è vero.
!	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	! (A && B) è vero.

La tabella seguente mostra tutti gli operatori logici supportati dalla lingua Go. Assumi variabileA è vero e variabile B è falso, quindi -

Operatore	Descrizione	Esempio
&&	Chiamato operatore AND logico. Se entrambi gli operandi sono falsi, la condizione diventa falsa.	(A && B) è falso.
\|\|	Chiamato Operatore OR logico. Se uno dei due operandi è vero, la condizione diventa vera.	(A \|\| B) è vero.
!	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	! (A && B) è vero.

Operatori bit per bit

Gli operatori bit per bit lavorano sui bit ed eseguono operazioni bit per bit. Le tabelle di verità per &, | e ^ sono le seguenti:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assumiamo A = 60; e B = 13. In formato binario, saranno i seguenti:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

Gli operatori bit per bit supportati dal linguaggio C sono elencati nella tabella seguente. Supponiamo che la variabile A contenga 60 e la variabile B ne contenga 13, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
&	L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi.	(A e B) darà 12, che è 0000 1100
\|	L'operatore OR binario copia un bit se esiste in uno degli operandi.	(A \| B) darà 61, che è 0011 1101
^	L'operatore XOR binario copia il bit se è impostato in un operando ma non in entrambi.	(A ^ B) darà 49, che è 0011 0001
<<	Operatore binario di spostamento sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra.	Un << 2 darà 240 che è 1111 0000
>>	Operatore binario di spostamento a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra.	Un >> 2 darà 15 che è 0000 1111

Operatori di assegnazione

La tabella seguente elenca tutti gli operatori di assegnazione supportati dalla lingua Go:

Mostra esempi

Operatore	Descrizione	Esempio
=	Operatore di assegnazione semplice, Assegna i valori dagli operandi del lato destro all'operando del lato sinistro	C = A + B assegnerà il valore di A + B a C
+ =	Aggiungi operatore di assegnazione AND, aggiunge l'operando destro all'operando sinistro e assegna il risultato all'operando sinistro	C + = A è equivalente a C = C + A
- =	Sottrai AND operatore di assegnazione, sottrae l'operando destro dall'operando sinistro e assegna il risultato all'operando sinistro	C - = A è equivalente a C = C - A
* =	Moltiplica AND operatore di assegnazione, moltiplica l'operando destro con l'operando sinistro e assegna il risultato all'operando sinistro	C * = A è equivalente a C = C * A
/ =	Divide AND operatore di assegnazione, divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro	C / = A è equivalente a C = C / A
% =	Modulo AND operatore di assegnazione, richiede il modulo utilizzando due operandi e assegna il risultato all'operando sinistro	C% = A è equivalente a C = C% A
<< =	Shift sinistro AND operatore di assegnazione	C << = 2 è uguale a C = C << 2
>> =	Spostamento a destra e operatore di assegnazione	C >> = 2 è uguale a C = C >> 2
& =	Operatore di assegnazione AND bit per bit	C & = 2 è uguale a C = C & 2
^ =	OR bit per bit esclusivo e operatore di assegnazione	C ^ = 2 è uguale a C = C ^ 2
\| =	OR bit per bit inclusivo e operatore di assegnazione	C \| = 2 è uguale a C = C \| 2

Operatori vari

Ci sono alcuni altri importanti operatori supportati da Go Language, incluso sizeof e ?:.

Mostra esempi

Operatore	Descrizione	Esempio
&	Restituisce l'indirizzo di una variabile.	&un; fornisce l'indirizzo effettivo della variabile.
*	Puntatore a una variabile.	*un; fornisce un puntatore a una variabile.

Precedenza degli operatori in Go

La precedenza degli operatori determina il raggruppamento dei termini in un'espressione. Ciò influisce sul modo in cui viene valutata un'espressione. Alcuni operatori hanno la precedenza maggiore di altri; ad esempio, l'operatore di moltiplicazione ha una precedenza maggiore dell'operatore di addizione.

Ad esempio x = 7 + 3 * 2; qui, x è assegnato 13, non 20 perché l'operatore * ha una precedenza maggiore di +, quindi viene prima moltiplicato per 3 * 2 e poi somma in 7.

Qui, gli operatori con la precedenza più alta vengono visualizzati nella parte superiore della tabella, quelli con la priorità più bassa in fondo. All'interno di un'espressione, verranno valutati per primi gli operatori con precedenza più alta.

Mostra esempi

Categoria	Operatore	Associatività
Postfix	() [] ->. ++ - -	Da sinistra a destra
Unario	+ -! ~ ++ - - (tipo) * & sizeof	Da destra a sinistra
Moltiplicativo	* /%	Da sinistra a destra
Additivo	+ -	Da sinistra a destra
Cambio	<< >>	Da sinistra a destra
Relazionale	<<=>> =	Da sinistra a destra
Uguaglianza	==! =	Da sinistra a destra
Bitwise AND	&	Da sinistra a destra
Bitwise XOR	^	Da sinistra a destra
OR bit per bit	\|	Da sinistra a destra
AND logico	&&	Da sinistra a destra
OR logico	\|\|	Da sinistra a destra
Incarico	= + = - = * = / =% = >> = << = & = ^ = \| =	Da destra a sinistra
Virgola	,	Da sinistra a destra

Le strutture decisionali richiedono che il programmatore specifichi una o più condizioni che devono essere valutate o testate dal programma, insieme a una o più istruzioni da eseguire se la condizione è determinata essere vera e, facoltativamente, altre istruzioni da eseguire se la condizione è determinato a essere falso.

Di seguito è riportata la forma generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione Go fornisce i seguenti tipi di dichiarazioni decisionali. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Suor n	Dichiarazione e descrizione
1	istruzione if Un if statement consiste in un'espressione booleana seguita da una o più istruzioni.
2	if ... else dichiarazione Un if statement può essere seguito da un optional else statement, che viene eseguito quando l'espressione booleana è falsa.
3	istruzioni if annidate Puoi usarne uno if o else if dichiarazione dentro un'altra if o else if dichiarazione (i).
4	istruzione switch UN switch consente di verificare l'uguaglianza di una variabile rispetto a un elenco di valori.
5	seleziona dichiarazione UN select dichiarazione è simile a switch dichiarazione con differenza che le dichiarazioni case si riferiscono alle comunicazioni di canale.

Potrebbe esserci una situazione in cui è necessario eseguire un blocco di codice più volte. In generale, le istruzioni vengono eseguite in sequenza: la prima istruzione in una funzione viene eseguita per prima, seguita dalla seconda e così via.

I linguaggi di programmazione forniscono varie strutture di controllo che consentono percorsi di esecuzione più complicati.

Un'istruzione loop ci consente di eseguire un'istruzione o un gruppo di istruzioni più volte e la seguente è la forma generale di un'istruzione loop nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione Go fornisce i seguenti tipi di loop per gestire i requisiti di loop.

Suor n	Tipo e descrizione del loop
1	per loop Esegue una sequenza di istruzioni più volte e abbrevia il codice che gestisce la variabile del ciclo.
2	loop annidati Questi sono uno o più cicli all'interno di qualsiasi ciclo for.

Dichiarazioni di controllo del loop

Le istruzioni di controllo del ciclo cambiano un'esecuzione dalla sua sequenza normale. Quando un'esecuzione lascia il suo ambito, tutti gli oggetti automatici che sono stati creati in tale ambito vengono distrutti.

Go supporta le seguenti istruzioni di controllo:

Suor n	Dichiarazione di controllo e descrizione
1	dichiarazione di interruzione Termina a for loop o switch istruzione e trasferisce l'esecuzione all'istruzione immediatamente successiva al ciclo for o all'opzione.
2	continua dichiarazione Fa sì che il ciclo salti il resto del suo corpo e ritorni immediatamente le sue condizioni prima di ripetere.
3	istruzione goto Trasferisce il controllo all'istruzione etichettata.

Il ciclo infinito

Un ciclo diventa un ciclo infinito se la sua condizione non diventa mai falsa. Il ciclo for è tradizionalmente utilizzato per questo scopo. Poiché nessuna delle tre espressioni che formano il ciclo for è richiesta, è possibile creare un ciclo infinito lasciando vuota l'espressione condizionale o passandola fedele.

package main

import "fmt"

func main() {
   for true  {
       fmt.Printf("This loop will run forever.\n");
   }
}

Quando l'espressione condizionale è assente, si presume che sia vera. Potresti avere un'inizializzazione e un'espressione di incremento, ma i programmatori C usano più comunemente il costrutto for (;;) per indicare un ciclo infinito.

Note - Puoi terminare un ciclo infinito premendo i tasti Ctrl + C.

Una funzione è un gruppo di istruzioni che insieme eseguono un'attività. Ogni programma Go ha almeno una funzione, ovveromain(). Puoi dividere il tuo codice in funzioni separate. Il modo in cui dividi il tuo codice tra le diverse funzioni dipende da te, ma logicamente, la divisione dovrebbe essere tale che ogni funzione svolga un compito specifico.

Una funzione declarationindica al compilatore il nome di una funzione, il tipo restituito e i parametri. Una funzionedefinition fornisce il corpo effettivo della funzione.

La libreria standard Go fornisce numerose funzioni incorporate che il programma può chiamare. Ad esempio, la funzionelen()accetta argomenti di vario tipo e restituisce la lunghezza del tipo. Se gli viene passata una stringa, la funzione restituisce la lunghezza della stringa in byte. Se gli viene passato un array, la funzione restituisce la lunghezza dell'array.

Le funzioni sono anche conosciute come method, sub-routine, o procedure.

Definizione di una funzione

La forma generale di una definizione di funzione nel linguaggio di programmazione Go è la seguente:

func function_name( [parameter list] ) [return_types]
{
   body of the function
}

Una definizione di funzione nel linguaggio di programmazione Go è costituita da un'intestazione di funzione e un corpo di funzione . Ecco tutte le parti di una funzione:

Func - Avvia la dichiarazione di una funzione.
Function Name- È il nome effettivo della funzione. Il nome della funzione e l'elenco dei parametri insieme costituiscono la firma della funzione.
Parameters- Un parametro è come un segnaposto. Quando viene richiamata una funzione, si passa un valore al parametro. Questo valore viene indicato come parametro o argomento effettivo. L'elenco dei parametri si riferisce al tipo, all'ordine e al numero dei parametri di una funzione. I parametri sono opzionali; ovvero, una funzione non può contenere parametri.
Return Type- Una funzione può restituire un elenco di valori. Return_types è l'elenco dei tipi di dati dei valori restituiti dalla funzione. Alcune funzioni eseguono le operazioni desiderate senza restituire un valore. In questo caso, return_type non è richiesto.
Function Body - Contiene una raccolta di istruzioni che definiscono cosa fa la funzione.

Esempio

Il codice sorgente seguente mostra una funzione chiamata max(). Questa funzione accetta due parametri num1 e num2 e restituisce il massimo tra i due -

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Chiamare una funzione

Durante la creazione di una funzione Go, dai una definizione di ciò che la funzione deve fare. Per utilizzare una funzione, dovrai chiamare quella funzione per eseguire l'attività definita.

Quando un programma chiama una funzione, il controllo del programma viene trasferito alla funzione chiamata. Una funzione chiamata esegue un'attività definita e quando viene eseguita la sua istruzione return o quando viene raggiunta la parentesi graffa di chiusura di fine funzione, restituisce il controllo del programma al programma principale.

Per chiamare una funzione, è sufficiente passare i parametri richiesti insieme al nome della funzione. Se la funzione restituisce un valore, è possibile memorizzare il valore restituito. Ad esempio:

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

Abbiamo mantenuto la funzione max () insieme alla funzione main () e compilato il codice sorgente. Durante l'esecuzione dell'eseguibile finale, produrrebbe il seguente risultato:

Max value is : 200

Restituzione di più valori dalla funzione

Una funzione Go può restituire più valori. Ad esempio:

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Kumar Mahesh

Argomenti della funzione

Se una funzione deve utilizzare argomenti, deve dichiarare variabili che accettano i valori degli argomenti. Queste variabili sono chiamateformal parameters della funzione.

I parametri formali si comportano come le altre variabili locali all'interno della funzione e vengono creati all'ingresso nella funzione e distrutti all'uscita.

Durante la chiamata a una funzione, ci sono due modi in cui gli argomenti possono essere passati a una funzione:

Suor n	Tipo di chiamata e descrizione
1	Chiama per valore Questo metodo copia il valore effettivo di un argomento nel parametro formale della funzione. In questo caso, le modifiche apportate al parametro all'interno della funzione non hanno effetto sull'argomento.
2	Chiama per riferimento Questo metodo copia l'indirizzo di un argomento nel parametro formale. All'interno della funzione, l'indirizzo viene utilizzato per accedere all'argomento effettivo utilizzato nella chiamata. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.

Per impostazione predefinita, Go utilizza la chiamata per valore per passare gli argomenti. In generale, significa che il codice all'interno di una funzione non può alterare gli argomenti utilizzati per chiamare la funzione. Il programma precedente, mentre chiamava la funzione max (), utilizzava lo stesso metodo.

Function Usage

A function can be used in the following ways:

Sr.No	Function Usage & Description
1	Function as Value Functions can be created on the fly and can be used as values.
2	Function Closures Functions closures are anonymous functions and can be used in dynamic programming.
3	Method Methods are special functions with a receiver.

A scope in any programming is a region of the program where a defined variable can exist and beyond that the variable cannot be accessed. There are three places where variables can be declared in Go programming language −

Inside a function or a block (local variables)
Outside of all functions (global variables)
In the definition of function parameters (formal parameters)

Let us find out what are local and global variables and what are formal parameters.

Local Variables

Variables that are declared inside a function or a block are called local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. The following example uses local variables. Here all the variables a, b, and c are local to the main() function.

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

When the above code is compiled and executed, it produces the following result −

value of a = 10, b = 20 and c = 30

Variabili globali

Le variabili globali sono definite al di fuori di una funzione, generalmente nella parte superiore del programma. Le variabili globali mantengono il loro valore per tutta la durata del programma ed è possibile accedervi all'interno di una qualsiasi delle funzioni definite per il programma.

È possibile accedere a una variabile globale da qualsiasi funzione. Cioè, una variabile globale è disponibile per l'uso in tutto il programma dopo la sua dichiarazione. L'esempio seguente utilizza variabili globali e locali:

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

value of a = 10, b = 20 and g = 30

Un programma può avere lo stesso nome per variabili locali e globali ma il valore della variabile locale all'interno di una funzione ha la preferenza. Ad esempio:

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

value of g = 10

Parametri formali

I parametri formali sono trattati come variabili locali con in quella funzione e hanno la preferenza sulle variabili globali. Ad esempio:

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

Inizializzazione delle variabili locali e globali

Le variabili locali e globali vengono inizializzate al loro valore predefinito, che è 0; mentre i puntatori vengono inizializzati a zero.

Tipo di dati	Valore predefinito iniziale
int	0
float32	0
puntatore	zero

Le stringhe, che sono ampiamente utilizzate nella programmazione Go, sono una fetta di byte di sola lettura. Nel linguaggio di programmazione Go, le stringhe sonoslices. La piattaforma Go fornisce varie librerie per manipolare le stringhe.

unicode
regexp
strings

Creazione di stringhe

Il modo più diretto per creare una stringa è scrivere -

var greeting = "Hello world!"

Ogni volta che incontra una stringa letterale nel codice, il compilatore crea un oggetto stringa con il suo valore in questo caso, "Hello world!".

Una stringa letterale contiene sequenze UTF-8 valide chiamate rune. Una stringa contiene byte arbitrari.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("normal string: ")
   fmt.Printf("%s", greeting)
   fmt.Printf("\n")
   fmt.Printf("hex bytes: ")
   
   for i := 0; i < len(greeting); i++ {
       fmt.Printf("%x ", greeting[i])
   }
   fmt.Printf("\n")
   
   const sampleText = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98" 
   /*q flag escapes unprintable characters, with + flag it escapses non-ascii 
   characters as well to make output unambigous  
   */
   fmt.Printf("quoted string: ")
   fmt.Printf("%+q", sampleText)
   fmt.Printf("\n")  
}

Ciò produrrebbe il seguente risultato:

normal string: Hello world!
hex bytes: 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 
quoted string: "\xbd\xb2=\xbc \u2318"

Note - La stringa letterale è immutabile, quindi una volta creata una stringa letterale non può essere modificata.

Lunghezza della stringa

Il metodo len (str) restituisce il numero di byte contenuti nella stringa letterale.

package main

import "fmt"

func main() {
   var greeting =  "Hello world!"
   
   fmt.Printf("String Length is: ")
   fmt.Println(len(greeting))  
}

Ciò produrrebbe il seguente risultato:

String Length is : 12

Concatenazione di stringhe

Il pacchetto di stringhe include un metodo join per concatenare più stringhe -

strings.Join(sample, " ")

Join concatena gli elementi di un array per creare una singola stringa. Il secondo parametro è il separatore che si trova tra gli elementi dell'array.

Guardiamo il seguente esempio:

package main

import ("fmt" "math" )"fmt" "strings")

func main() {
   greetings :=  []string{"Hello","world!"}   
   fmt.Println(strings.Join(greetings, " "))
}

Ciò produrrebbe il seguente risultato:

Hello world!

Il linguaggio di programmazione Go fornisce una struttura dati chiamata the array, che può memorizzare una raccolta sequenziale di dimensioni fisse di elementi dello stesso tipo. Un array viene utilizzato per memorizzare una raccolta di dati, ma spesso è più utile pensare a un array come una raccolta di variabili dello stesso tipo.

Invece di dichiarare variabili individuali, come numero0, numero1, ... e numero99, dichiari una variabile di matrice come numeri e utilizzi numeri [0], numeri [1] e ..., numeri [99] per rappresentare variabili individuali. Un elemento specifico in un array è accessibile da un indice.

Tutti gli array sono costituiti da posizioni di memoria contigue. L'indirizzo più basso corrisponde al primo elemento e l'indirizzo più alto all'ultimo elemento.

Dichiarazione di array

Per dichiarare un array in Go, un programmatore specifica il tipo di elementi e il numero di elementi richiesti da un array come segue:

var variable_name [SIZE] variable_type

Questo è chiamato array unidimensionale . IlarraySize deve essere una costante intera maggiore di zero e typepuò essere qualsiasi tipo di dati Go valido. Ad esempio, per dichiarare un array di 10 elementi chiamatobalance di tipo float32, usa questa istruzione -

var balance [10] float32

Qui, balance è un array di variabili che può contenere fino a 10 numeri float.

Inizializzazione degli array

È possibile inizializzare l'array in Go uno per uno o utilizzando una singola istruzione come segue:

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Il numero di valori tra parentesi graffe {} non può essere maggiore del numero di elementi dichiarati per l'array tra parentesi quadre [].

Se ometti la dimensione dell'array, viene creato un array abbastanza grande da contenere l'inizializzazione. Pertanto, se scrivi -

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

Creerai esattamente lo stesso array che hai fatto nell'esempio precedente. Di seguito è riportato un esempio per assegnare un singolo elemento dell'array:

balance[4] = 50.0

L'istruzione precedente assegna all'elemento numero 5 ^° nell'array un valore di 50.0. Tutti gli array hanno 0 come indice del loro primo elemento che è anche chiamato indice di base e l'ultimo indice di un array sarà la dimensione totale dell'array meno 1. Di seguito è la rappresentazione pittorica dello stesso array che abbiamo discusso sopra -

Accesso agli elementi dell'array

Si accede a un elemento indicizzando il nome dell'array. Questo viene fatto inserendo l'indice dell'elemento tra parentesi quadre dopo il nome dell'array. Ad esempio:

float32 salary = balance[9]

L'istruzione precedente avrà 10 ^esimo elemento dall'array e assegnare il valore alla variabile stipendio. Di seguito è riportato un esempio che utilizzerà tutti i tre concetti sopra menzionati vale a dire. dichiarazione, assegnazione e accesso agli array -

package main

import "fmt"

func main() {
   var n [10]int /* n is an array of 10 integers */
   var i,j int

   /* initialize elements of array n to 0 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* set element at location i to i + 100 */
   }
   /* output each array element's value */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Vai agli array in dettaglio

Ci sono concetti importanti relativi all'array che dovrebbero essere chiari a un programmatore Go -

Suor n	Concetto e descrizione
1	Array multidimensionali Go supporta array multidimensionali. La forma più semplice di un array multidimensionale è l'array bidimensionale.
2	Passaggio di array a funzioni È possibile passare alla funzione un puntatore a un array specificando il nome dell'array senza un indice.

I puntatori in Go sono facili e divertenti da imparare. Alcune attività di programmazione Go vengono eseguite più facilmente con i puntatori e altre attività, come la chiamata per riferimento, non possono essere eseguite senza utilizzare i puntatori. Quindi diventa necessario imparare i puntatori per diventare un perfetto programmatore Go.

Come sapete, ogni variabile è una posizione di memoria e ogni posizione di memoria ha il proprio indirizzo definito a cui è possibile accedere utilizzando l'operatore e commerciale (&), che denota un indirizzo in memoria. Considera il seguente esempio, che stamperà l'indirizzo delle variabili definite:

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Address of a variable: 10328000

Quindi hai capito cos'è l'indirizzo di memoria e come accedervi. Vediamo ora cosa sono i puntatori.

Cosa sono i puntatori?

UN pointerè una variabile il cui valore è l'indirizzo di un'altra variabile, cioè l'indirizzo diretto della posizione di memoria. Come qualsiasi variabile o costante, è necessario dichiarare un puntatore prima di poterlo utilizzare per memorizzare qualsiasi indirizzo di variabile. La forma generale di una dichiarazione di variabile puntatore è:

var var_name *var-type

Qui, typeè il tipo di base del puntatore; deve essere un tipo di dati C valido evar-nameè il nome della variabile del puntatore. L'asterisco * che hai usato per dichiarare un puntatore è lo stesso asterisco che usi per la moltiplicazione. Tuttavia, in questa istruzione l'asterisco viene utilizzato per designare una variabile come puntatore. Di seguito sono riportate le dichiarazioni di puntatore valide:

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

Il tipo di dati effettivo del valore di tutti i puntatori, intero, float o altro, è lo stesso, un numero esadecimale lungo che rappresenta un indirizzo di memoria. L'unica differenza tra i puntatori di diversi tipi di dati è il tipo di dati della variabile o della costante a cui punta il puntatore.

Come usare i puntatori?

Ci sono alcune operazioni importanti, che eseguiamo frequentemente con i puntatori: (a) definiamo variabili puntatore, (b) assegniamo l'indirizzo di una variabile a un puntatore e (c) accediamo al valore all'indirizzo memorizzato nella variabile puntatore .

Tutte queste operazioni vengono eseguite utilizzando l'operatore unario * che restituisce il valore della variabile situata all'indirizzo specificato dal suo operando. L'esempio seguente mostra come eseguire queste operazioni:

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Nessun puntatore in Go

Il compilatore Go assegna un valore Nil a una variabile puntatore nel caso in cui non si disponga di un indirizzo esatto da assegnare. Questo viene fatto al momento della dichiarazione della variabile. Un puntatore assegnato a zero è chiamato anil puntatore.

Il puntatore nil è una costante con un valore zero definito in diverse librerie standard. Considera il seguente programma:

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

The value of ptr is 0

Sulla maggior parte dei sistemi operativi, ai programmi non è consentito accedere alla memoria all'indirizzo 0 perché tale memoria è riservata dal sistema operativo. Tuttavia, l'indirizzo di memoria 0 ha un significato speciale; segnala che il puntatore non è destinato a puntare a una posizione di memoria accessibile. Ma per convenzione, se un puntatore contiene il valore nil (zero), si presume che punti a nulla.

Per verificare la presenza di un puntatore nullo puoi usare un'istruzione if come segue:

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

Vai a puntatori in dettaglio

I puntatori hanno molti ma semplici concetti e sono molto importanti per la programmazione. I seguenti concetti di puntatori dovrebbero essere chiari a un programmatore Go:

Suor n	Concetto e descrizione
1	Vai: matrice di puntatori È possibile definire array per contenere un numero di puntatori.
2	Vai: puntatore al puntatore Go ti consente di avere un puntatore su un puntatore e così via.
3	Passaggio di puntatori a funzioni in Go Il passaggio di un argomento per riferimento o per indirizzo consente entrambi di modificare l'argomento passato nella funzione chiamante dalla funzione chiamata.

Gli array Go consentono di definire variabili che possono contenere diversi elementi di dati dello stesso tipo. Structure è un altro tipo di dati definito dall'utente disponibile nella programmazione Go, che consente di combinare elementi di dati di diversi tipi.

Le strutture vengono utilizzate per rappresentare un record. Supponi di voler tenere traccia dei libri in una biblioteca. Potresti voler monitorare i seguenti attributi di ogni libro:

Title
Author
Subject
ID libro

In un tale scenario, le strutture sono molto utili.

Definizione di una struttura

Per definire una struttura, è necessario utilizzare type e structdichiarazioni. L'istruzione struct definisce un nuovo tipo di dati, con più membri per il programma. L'istruzione type lega un nome al tipo che è struct nel nostro caso. Il formato dell'istruzione struct è il seguente:

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

Una volta definito un tipo di struttura, può essere utilizzato per dichiarare le variabili di quel tipo utilizzando la seguente sintassi.

variable_name := structure_variable_type {value1, value2...valuen}

Accesso ai membri della struttura

Per accedere a qualsiasi membro di una struttura, utilizziamo il member access operator (.).L'operatore di accesso al membro è codificato come un periodo tra il nome della variabile di struttura e il membro della struttura a cui si desidera accedere. Userestistructparola chiave per definire variabili di tipo struttura. L'esempio seguente spiega come utilizzare una struttura:

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   /* print Book2 info */
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Book 1 title      : Go Programming
Book 1 author     : Mahesh Kumar
Book 1 subject    : Go Programming Tutorial
Book 1 book_id    : 6495407
Book 2 title      : Telecom Billing
Book 2 author     : Zara Ali
Book 2 subject    : Telecom Billing Tutorial
Book 2 book_id    : 6495700

Strutture come argomenti di funzione

Puoi passare una struttura come argomento di una funzione in modo molto simile quando passi qualsiasi altra variabile o puntatore. Accederesti alle variabili di struttura nello stesso modo in cui hai fatto nell'esempio precedente:

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books    /* Declare Book1 of type Book */
   var Book2 Books    /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(Book1)

   /* print Book2 info */
   printBook(Book2)
}
func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Puntatori alle strutture

Puoi definire i puntatori a strutture nello stesso modo in cui definisci il puntatore a qualsiasi altra variabile come segue:

var struct_pointer *Books

Ora è possibile memorizzare l'indirizzo di una variabile di struttura nella variabile puntatore definita sopra. Per trovare l'indirizzo di una variabile di struttura, inserire l'operatore & prima del nome della struttura come segue:

struct_pointer = &Book1;

Per accedere ai membri di una struttura utilizzando un puntatore a tale struttura, è necessario utilizzare il "." operatore come segue -

struct_pointer.title;

Riscriviamo l'esempio precedente usando il puntatore alla struttura -

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}
func main() {
   var Book1 Books   /* Declare Book1 of type Book */
   var Book2 Books   /* Declare Book2 of type Book */
 
   /* book 1 specification */
   Book1.title = "Go Programming"
   Book1.author = "Mahesh Kumar"
   Book1.subject = "Go Programming Tutorial"
   Book1.book_id = 6495407

   /* book 2 specification */
   Book2.title = "Telecom Billing"
   Book2.author = "Zara Ali"
   Book2.subject = "Telecom Billing Tutorial"
   Book2.book_id = 6495700
 
   /* print Book1 info */
   printBook(&Book1)

   /* print Book2 info */
   printBook(&Book2)
}
func printBook( book *Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Book title     : Go Programming
Book author    : Mahesh Kumar
Book subject   : Go Programming Tutorial
Book book_id   : 6495407
Book title     : Telecom Billing
Book author    : Zara Ali
Book subject   : Telecom Billing Tutorial
Book book_id   : 6495700

Go Slice è un'astrazione su Go Array. Go Array consente di definire variabili che possono contenere diversi elementi di dati dello stesso tipo ma non fornisce alcun metodo integrato per aumentare le sue dimensioni dinamicamente o ottenere un proprio sotto-array. Le fette superano questa limitazione. Fornisce molte funzioni di utilità richieste su Array ed è ampiamente utilizzato nella programmazione Go.

Definizione di una fetta

Per definire una fetta, puoi dichiararla come un array senza specificarne la dimensione. In alternativa, puoi usaremake funzione per creare una fetta.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

funzioni len () e cap ()

Una fetta è un'astrazione su un array. In realtà utilizza gli array come struttura sottostante. Illen() funzione restituisce gli elementi presenti nello slice dove cap()restituisce la capacità dello slice (cioè quanti elementi può contenere). L'esempio seguente spiega l'utilizzo di slice:

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

len = 3 cap = 5 slice = [0 0 0]

Nessuna fetta

Se una slice viene dichiarata senza input, per impostazione predefinita viene inizializzata come nil. La sua lunghezza e capacità sono pari a zero. Ad esempio:

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

len = 0 cap = 0 slice = []
slice is nil

Subslicing

Slice consente di specificare il limite inferiore e il limite superiore per ottenerne la sottosezione utilizzando[lower-bound:upper-bound]. Ad esempio:

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

Funzioni append () e copy ()

Si può aumentare la capacità di una fetta usando il append()funzione. Utilizzandocopy()funzione, il contenuto di una slice di origine viene copiato in una slice di destinazione. Ad esempio:

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]

Il range la parola chiave è utilizzata in forloop per scorrere gli elementi di un array, slice, canale o mappa. Con array e slice, restituisce l'indice dell'elemento come numero intero. Con le mappe, restituisce la chiave della successiva coppia chiave-valore. L'intervallo restituisce uno o due valori. Se viene utilizzato un solo valore a sinistra di un'espressione di intervallo, è il primo valore nella tabella seguente.

Espressione di intervallo	1 ° valore	2 ° valore (opzionale)
Array o slice a [n] E	indice i int	a [i] E
String tipo di stringa	indice i int	rune int
mappa m mappa [K] V	chiave k K	valore m [k] V
canale c chan E	elemento e E	nessuna

Esempio

Il paragrafo seguente mostra come utilizzare l'intervallo:

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8} 
   
   /* print the numbers */
   for i:= range numbers {
      fmt.Println("Slice item",i,"is",numbers[i])
   }
   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"}
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* print map using key-value*/
   for country,capital := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",capital)
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Slice item 0 is 0
Slice item 1 is 1
Slice item 2 is 2
Slice item 3 is 3
Slice item 4 is 4
Slice item 5 is 5
Slice item 6 is 6
Slice item 7 is 7
Slice item 8 is 8
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo

Go fornisce un altro tipo di dati importante denominato map che mappa chiavi univoche ai valori. Una chiave è un oggetto che utilizzi per recuperare un valore in un secondo momento. Data una chiave e un valore, è possibile memorizzare il valore in un oggetto Map. Dopo che il valore è stato memorizzato, è possibile recuperarlo utilizzando la sua chiave.

Definizione di una mappa

Devi usare make funzione per creare una mappa.

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type

/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

Esempio

L'esempio seguente illustra come creare e utilizzare una mappa:

package main

import "fmt"

func main() {
   var countryCapitalMap map[string]string
   /* create a map*/
   countryCapitalMap = make(map[string]string)
   
   /* insert key-value pairs in the map*/
   countryCapitalMap["France"] = "Paris"
   countryCapitalMap["Italy"] = "Rome"
   countryCapitalMap["Japan"] = "Tokyo"
   countryCapitalMap["India"] = "New Delhi"
   
   /* print map using keys*/
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* test if entry is present in the map or not*/
   capital, ok := countryCapitalMap["United States"]
   
   /* if ok is true, entry is present otherwise entry is absent*/
   if(ok){
      fmt.Println("Capital of United States is", capital)  
   } else {
      fmt.Println("Capital of United States is not present") 
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Capital of India is New Delhi
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of United States is not present

Funzione delete ()

La funzione delete () viene utilizzata per eliminare una voce da una mappa. Richiede la mappa e la chiave corrispondente che deve essere cancellata. Ad esempio:

package main

import "fmt"

func main() {   
   /* create a map*/
   countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo","India":"New Delhi"}
   
   fmt.Println("Original map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
   
   /* delete an entry */
   delete(countryCapitalMap,"France");
   fmt.Println("Entry for France is deleted")  
   
   fmt.Println("Updated map")   
   
   /* print map */
   for country := range countryCapitalMap {
      fmt.Println("Capital of",country,"is",countryCapitalMap[country])
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Original Map
Capital of France is Paris
Capital of Italy is Rome
Capital of Japan is Tokyo
Capital of India is New Delhi
Entry for France is deleted
Updated Map
Capital of India is New Delhi
Capital of Italy is Rome
Capital of Japan is Tokyo

La ricorsione è il processo di ripetizione di elementi in modo auto-simile. Lo stesso concetto si applica anche ai linguaggi di programmazione. Se un programma consente di chiamare una funzione all'interno della stessa funzione, viene chiamata chiamata di funzione ricorsiva. Dai un'occhiata al seguente esempio:

func recursion() {
   recursion() /* function calls itself */
}
func main() {
   recursion()
}

Il linguaggio di programmazione Go supporta la ricorsione. Cioè, consente a una funzione di chiamare se stessa. Ma mentre si utilizza la ricorsione, i programmatori devono fare attenzione a definire una condizione di uscita dalla funzione, altrimenti diventerà un ciclo infinito.

Esempi di ricorsione in Go

Le funzioni ricorsive sono molto utili per risolvere molti problemi matematici come il calcolo fattoriale di un numero, la generazione di una serie di Fibonacci, ecc.

Esempio 1: calcolo fattoriale utilizzando la ricorsione in Go

L'esempio seguente calcola il fattoriale di un dato numero utilizzando una funzione ricorsiva -

package main

import "fmt"

func factorial(i int)int {
   if(i <= 1) {
      return 1
   }
   return i * factorial(i - 1)
}
func main() { 
   var i int = 15
   fmt.Printf("Factorial of %d is %d", i, factorial(i))
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Factorial of 15 is 1307674368000

Esempio 2: serie di Fibonacci che utilizza la ricorsione in Go

L'esempio seguente mostra come generare una serie di Fibonacci di un dato numero utilizzando una funzione ricorsiva:

package main

import "fmt"

func fibonaci(i int) (ret int) {
   if i == 0 {
      return 0
   }
   if i == 1 {
      return 1
   }
   return fibonaci(i-1) + fibonaci(i-2)
}
func main() {
   var i int
   for i = 0; i < 10; i++ {
      fmt.Printf("%d ", fibonaci(i))
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

0 1 1 2 3 5 8 13 21 34

Il casting del tipo è un modo per convertire una variabile da un tipo di dati a un altro tipo di dati. Ad esempio, se desideri memorizzare un valore long in un numero intero semplice, puoi digitare cast long in int. È possibile convertire i valori da un tipo a un altro utilizzando ilcast operator. La sua sintassi è la seguente:

type_name(expression)

Esempio

Si consideri il seguente esempio in cui l'operatore cast fa sì che la divisione di una variabile intera per un'altra venga eseguita come operazione con numero mobile.

package main

import "fmt"

func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("Value of mean : %f\n",mean)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Value of mean : 3.400000

La programmazione Go fornisce un altro tipo di dati chiamato interfacesche rappresenta un insieme di firme di metodo. Il tipo di dati struct implementa queste interfacce per avere definizioni di metodo per la firma del metodo delle interfacce.

Sintassi

/* define an interface */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* define a struct */
type struct_name struct {
   /* variables */
}

/* implement interface methods*/
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* method implementation */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* method implementation */
}

Esempio

package main

import (
   "fmt" 
   "math" 
)

/* define an interface */
type Shape interface {
   area() float64
}

/* define a circle */
type Circle struct {
   x,y,radius float64
}

/* define a rectangle */
type Rectangle struct {
   width, height float64
}

/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
   return rect.width * rect.height
}

/* define a method for shape */
func getArea(shape Shape) float64 {
   return shape.area()
}

func main() {
   circle := Circle{x:0,y:0,radius:5}
   rectangle := Rectangle {width:10, height:5}
   
   fmt.Printf("Circle area: %f\n",getArea(circle))
   fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Circle area: 78.539816
Rectangle area: 50.000000

La programmazione Go fornisce un framework di gestione degli errori piuttosto semplice con il tipo di interfaccia di errore integrato della seguente dichiarazione:

type error interface {
   Error() string
}

Le funzioni normalmente restituiscono l'errore come ultimo valore restituito. Usoerrors.New per costruire un messaggio di errore di base come segue:

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}

Usa valore di ritorno e messaggio di errore.

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

Esempio

package main

import "errors"
import "fmt"
import "math"

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}
func main() {
   result, err:= Sqrt(-1)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
   
   result, err = Sqrt(9)

   if err != nil {
      fmt.Println(err)
   } else {
      fmt.Println(result)
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Math: negative number passed to Sqrt
3

Vai - Guida rapida

Caratteristiche di Go Programming

Caratteristiche escluse intenzionalmente

Vai ai programmi

Configurazione dell'ambiente locale

Editor di testo

Il compilatore Go

Scarica Go Archive

Installazione su UNIX / Linux / Mac OS X e FreeBSD

Installazione su Windows

Verifica dell'installazione

File: test.go

Produzione

Hello World Example

Esecuzione di un programma Go

Gettoni in Go

Separatore di linea

Commenti

Identificatori

Parole chiave

Spazio bianco in Go

Tipi interi

Tipi galleggianti

Altri tipi numerici

Definizione variabile in Go

Dichiarazione di tipo statico in Go

Esempio

Dichiarazione di tipo dinamico / inferenza di tipo in Go

Esempio

Dichiarazione di variabili miste in Go

Esempio

I lvalues ​​e i rvalues ​​in Go

Letterali interi

Valori letterali a virgola mobile

Sequenza di fuga

Valori letterali stringa in Go

La parola chiave const

Operatori aritmetici

Operatori relazionali

Operatori logici

Operatori bit per bit

Operatori di assegnazione

Operatori vari

Precedenza degli operatori in Go

Dichiarazioni di controllo del loop

Il ciclo infinito

Definizione di una funzione

Esempio

Chiamare una funzione

Restituzione di più valori dalla funzione

Argomenti della funzione

Function Usage

Local Variables

Variabili globali

Parametri formali

Inizializzazione delle variabili locali e globali

Creazione di stringhe

Lunghezza della stringa

Concatenazione di stringhe

Dichiarazione di array

Inizializzazione degli array

Accesso agli elementi dell'array

Vai agli array in dettaglio

Cosa sono i puntatori?

Come usare i puntatori?

Nessun puntatore in Go

Vai a puntatori in dettaglio

Definizione di una struttura

Accesso ai membri della struttura

Strutture come argomenti di funzione

Puntatori alle strutture

Definizione di una fetta

funzioni len () e cap ()

Nessuna fetta

Subslicing

Funzioni append () e copy ()

Esempio

Definizione di una mappa

Esempio

Funzione delete ()

I lvalues e i rvalues in Go