Go è un linguaggio generico progettato pensando alla programmazione dei sistemi ed è stato inizialmente sviluppato presso 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.

Di seguito sono riportati i vantaggi dell'utilizzo della programmazione Go:

• 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 della concorrenza InBuilt: processi leggeri (tramite goroutine), canali, istruzione select.

• Concisione, semplicità e sicurezza.

• Supporto per interfacce e tipo embdding.

• Produzione di file binari nativi collegati staticamente senza dipendenze esterne.

Nessun supporto per l'ereditarietà del tipo.

Nessun supporto per il sovraccarico dell'operatore.

Nessun supporto per il sovraccarico del metodo.

Nessun supporto per l'aritmetica del puntatore.

Nessun supporto per la programmazione generica.

Sì! Go è un linguaggio di programmazione case sensitive.

La dichiarazione della variabile di tipo statico fornisce la garanzia al compilatore che esiste una variabile esistente con il tipo e il nome dati in modo che il compilatore proceda per un'ulteriore compilazione senza bisogno di dettagli completi sulla variabile. Una dichiarazione di variabile ha il suo significato solo al momento della compilazione, il compilatore necessita di una dichiarazione di variabile effettiva al momento del collegamento del programma.

Una dichiarazione di variabile di tipo dinamico richiede che il compilatore interpreti il ​​tipo di variabile in base al valore passato ad essa. Il compilatore non ha bisogno di una variabile per avere il tipo staticamente come requisito necessario.

Sì È possibile dichiarare variabili di diversi tipi in una volta sola utilizzando l'inferenza del tipo.

var a, b, c = 3, 4, "foo"

Il codice seguente stampa il tipo di una variabile -

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

È una variabile puntatore che può contenere l'indirizzo di una variabile.

Ad esempio:

var x = 5
var p *int
p = &x
fmt.Printf("x = %d", *p)

Qui si può accedere a x da * p.

break termina il ciclo for o l'istruzione switch e trasferisce l'esecuzione all'istruzione immediatamente successiva al ciclo for o all'opzione.

continue fa sì che il ciclo salti il ​​resto del suo corpo e ritorni immediatamente le sue condizioni prima di ripetere.

goto trasferisce il controllo all'istruzione etichettata.

La sintassi di un ciclo for nel linguaggio di programmazione Go è:

for [condition |  ( init; condition; increment ) | Range] {
   statement(s);
}

Ecco il flusso di controllo in un ciclo for -

• se la condizione è disponibile, il ciclo for viene eseguito fintanto che la condizione è vera.

• se la clausola for che è (init; condizione; incremento) è presente allora

  Il passaggio di inizializzazione viene eseguito per primo e solo una volta. Questo passaggio consente di dichiarare e inizializzare qualsiasi variabile di controllo del ciclo. Non è necessario inserire una dichiarazione qui, a condizione che venga visualizzato un punto e virgola.

  Successivamente, viene valutata la condizione. Se è vero, viene eseguito il corpo del ciclo. Se è falso, il corpo del ciclo non viene eseguito e il flusso di controllo salta all'istruzione successiva subito dopo il ciclo for.

  Dopo che il corpo del ciclo for è stato eseguito, il flusso di controllo torna all'istruzione increment. Questa istruzione consente di aggiornare qualsiasi variabile di controllo del ciclo. Questa istruzione può essere lasciata vuota, purché dopo la condizione venga visualizzato un punto e virgola.

  La condizione viene ora valutata di nuovo. Se è vero, il ciclo viene eseguito e il processo si ripete (corpo del ciclo, quindi incremento del passo e quindi di nuovo condizione). Dopo che la condizione diventa falsa, il ciclo for termina.

• se l'intervallo è disponibile, il ciclo for viene eseguito per ogni elemento nell'intervallo.

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 func avvia la dichiarazione di una funzione.

• Function Name- Questo è 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. Ilreturn_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 - Il corpo della funzione contiene una raccolta di istruzioni che definiscono cosa fa la 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)
}

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

• Call by value- 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.

• Call by reference −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, questo significa che il codice all'interno di una funzione non può alterare gli argomenti usati per chiamare la funzione e l'esempio sopra menzionato mentre si chiama la funzione max () ha usato lo stesso metodo.

Il linguaggio di programmazione Go offre flessibilità per creare funzioni al volo e utilizzarle come valori. Possiamo impostare una variabile con una definizione di funzione e usarla come parametro di una funzione.

La chiusura delle funzioni sono funzioni anonime e possono essere utilizzate nella programmazione dinamica.

Il linguaggio di programmazione Go supporta tipi speciali di funzioni chiamate metodi. Nella sintassi della dichiarazione del metodo, è presente un "ricevitore" per rappresentare il contenitore della funzione. Questo ricevitore può essere utilizzato per chiamare la funzione utilizzando "." operatore.

Una variabile locale ha un valore predefinito poiché corrisponde al valore 0.

Una variabile globale ha un valore predefinito poiché corrisponde al valore 0.

Il puntatore viene inizializzato a zero.

Stampa l'output formattato.

L'espressione che appare sul lato destro dell'operatore di assegnazione viene chiamata rvalue. Rvalue è assegnato a lvalue, che appare sul lato sinistro dell'operatore di assegnazione. Il valore dovrebbe indicare una variabile, non una costante.

I parametri inviati alla funzione alla fine della chiamata sono chiamati come parametri effettivi mentre alla ricezione della definizione della funzione chiamati come parametri formali.

La dichiarazione associa il tipo alla variabile mentre la definizione fornisce il valore alla variabile.

Dividere il programma in sottoprogrammi (moduli / funzione) per ottenere il compito dato è un approccio modulare. La definizione di funzioni più generiche offre la possibilità di riutilizzare le funzioni, come le funzioni di libreria incorporate.

Un programma Go è costituito da vari token e un token può essere una parola chiave, un identificatore, una costante, una stringa letterale o un simbolo.

vai a

Array è la raccolta di elementi di dati simili con un nome comune.

Il compilatore Go assegna un valore Nil a una variabile puntatore nel caso in cui non si abbia un indirizzo esatto da assegnare. Questo viene fatto al momento della dichiarazione della variabile. Un puntatore a cui è assegnato nil è chiamato puntatore nil. Il puntatore nil è una costante con un valore zero definito in diverse librerie standard.

È una variabile puntatore che può contenere l'indirizzo di un'altra variabile puntatore. Rimanda due volte per indicare i dati contenuti nella variabile puntatore designata.

var a int
var ptr *int
var pptr **int
a = 3000
ptr = &a
pptr = &ptr
fmt.Printf("Value available at **pptr = %d\n", **pptr)

Pertanto 'a' è accessibile da ** pptr.

La struttura è un altro tipo di dati definito dall'utente disponibile nella programmazione Go, che consente di combinare elementi di dati di diversi tipi.

Per definire una struttura, è necessario utilizzare le istruzioni type e struct. L'istruzione struct definisce un nuovo tipo di dati, con più di un membro per il programma. L'istruzione type lega un nome con il tipo che è struct nel nostro caso.

Il formato dell'istruzione struct è questo:

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

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

Per definire una fetta, puoi dichiararla come un array senza specificare la dimensione o usare la funzione make per crearla.

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*/

La funzione len () restituisce gli elementi presenti nello slice.

La funzione len () restituisce gli elementi presenti nella slice dove la funzione cap () restituisce la capacità della slice quanti sono gli elementi che può ospitare.

Slice consente di specificare il limite inferiore e il limite superiore per ottenere la sottosezione utilizzando [limite inferiore: limite superiore].

La parola chiave range viene utilizzata nel ciclo for per iterare su 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.

Go fornisce un'altra importante mappa dei tipi di dati 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.

È necessario utilizzare la funzione make 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)

La funzione delete () viene utilizzata per eliminare una voce dalla mappa. Richiede mappa e chiave corrispondente che deve essere cancellata.

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. Puoi convertire i valori da un tipo a un altro usando l'operatore cast come segue:

type_name(expression)

La programmazione Go fornisce un altro tipo di dati chiamato interfacce che 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.