Seguici su Telegram, ne vale la pena ❤️ ➡ @trovalost
Vai al contenuto

[Go] Guida veloce al linguaggio Golang

Tag:

Go, noto anche come Golang, è un linguaggio di programmazione open source sviluppato da Google. È stato creato da Robert Griesemer, Rob Pike e Ken Thompson nel 2007 e il suo sviluppo è stato reso pubblico nel 2009. Go è progettato per essere efficiente, conciso, veloce e altamente scalabile, con un’enfasi sulla semplicità e la produttività degli sviluppatori.

Go ha anche un altro nome, Golang (dove il nome significava Go Language, “linguaggio vai“), ma il suo nome proprio è Go, a causa del suo precedente nome di dominio, golang.org, ma il suo nome proprio è Go.

Dettagli sul funzionamento di Go

Go è un linguaggio di programmazione compilato e tipizzato in modo statico, progettato interamente dallo staff di programmatori di Google. Go è stato creato da Robert Griesemer, Rob Pike e Ken Thompson, che attualmente lavorano al progetto. Si tratta di un linguaggio sintatticamente molto simile a C, ma con una gestione migliorata della sicurezza sulla memoria, meccanismi di garbage collection, tipizzazione strutturata e programmazione concorrente in stile linguaggio CSP. Ci sono due implementazioni principali disponibili, una hosted by Google e l’altra da lanciare in autonomia: il motore software di Go è infatti disponibile come software open source.

Sintassi di Go

La sintassi di Go include aspetti tipici del linguaggio C, e non prevede l’uso di punti e virgola per delimitare le istruzioni (come in Python). àˆ stato introdotto un particolare operatore combinato di dichiarazione/inizializzazione che consente al programmatore di scrivere i := 2 o s := “Ciao Mondo!”, senza specificare i tipi, esattamente come avverrebbe in PHP.

Go aggiunge la possibilità  di utilizare letterali per l’inizializzazione dei parametri struct in base al nome e per l’inizializzazione di map e tipi complessi o composti. In alternativa al ciclo for a tre istruzioni di C, le espressioni di intervallo di Go consentono un’iterazione concisa su array, sezioni, stringhe, mappe e canali.

Go offre inoltre una serie di tipi incorporati, inclusi quelli numerici (ad esempio byte, int64, float32), Booleani e stringhe di caratteri (stringa). Le stringhe sono immutabili, la codifica e decodifica è nativamente UTF-8. I tipi di record personalizzati possono essere definiti con la parola chiave struct, come abbiamo appena accennato

Per ogni tipo T e per ogni costante intera non negativa n, esiste un tipo di array indicato con [n]T; array di lunghezze diverse sono quindi di tipi diversi. Gli array dinamici sono disponibili come “slice”, indicati con []T per alcuni tipi T. Questi hanno una lunghezza e una capacità  che specificano quando è necessario allocare nuova memoria per espandere l’array.

I puntatori sono disponibili per tutti i tipi e il tipo da puntatore a T è indicato con *T. L’assunzione di indirizzi e l’indirizzamento indiretto utilizzano gli operatori & e *, come in C, o avvengono implicitamente tramite la chiamata al metodo o la sintassi di accesso all’attributo. Non è consentito effettuare aritmetica del puntatore, se non tramite lo speciale tipo di variabile unsafe.Pointer nella libreria standard di Go.

Cosa si può fare in Go

Ecco alcuni punti chiave su Go:

  1. Sintassi chiara e concisa: Go è progettato con una sintassi semplice e leggibile che facilita la scrittura e la comprensione del codice. Ha un numero limitato di parole chiave e una struttura di controllo dei flussi di programma chiara e intuitiva.
  2. Concorrenza e gestione della concorrenza: Go offre un supporto integrato per la programmazione concorrente attraverso le goroutine e i canali. Le goroutine sono thread leggeri che consentono agli sviluppatori di scrivere codice altamente concorrente in modo semplice ed efficiente.
  3. Rapido e performante: Go è noto per le sue prestazioni elevate e la sua efficienza nell’utilizzo delle risorse. È particolarmente adatto per applicazioni che richiedono elevata concorrenza o elaborazione parallela.
  4. Tipizzazione statica e dinamica: Go è un linguaggio tipizzato staticamente, il che significa che le variabili devono essere dichiarate con un tipo specifico e il tipo delle variabili è verificato a tempo di compilazione. Tuttavia, Go offre anche la flessibilità della tipizzazione dinamica attraverso l’uso di interfacce.
  5. Ampia libreria standard: Go include una libreria standard ricca di funzionalità per gestire una vasta gamma di compiti, tra cui operazioni di I/O, gestione delle stringhe, networking, criptografia e altro ancora.
  6. Compilazione rapida: Il compilatore di Go è veloce e produce codice eseguibile altamente ottimizzato. Questo facilita lo sviluppo iterativo e la distribuzione rapida delle applicazioni.

Complessivamente, Go è diventato popolare tra gli sviluppatori per la sua semplicità, prestazioni elevate e capacità di gestire carichi di lavoro complessi, ed è utilizzato in una varietà di settori, tra cui lo sviluppo di applicazioni web, sistemi distribuiti, servizi cloud e molto altro ancora.

Con Go è possibile realizzare sia applicazioni a linea di comando che applicazioni web, eventualmente sfruttando GopherJS che permette di tradurre automaticamente Go in Javascript. All’interno del sito ufficiale è possibile testare il codice direttamente nel sito, realizzando un semplice Hello, World! con poche righe di codice:

package main
import "fmt"
func main() {
fmt.Println("Hello, amicone del cuore")
}

Il risultato è il seguente.

esempio hello world linguaggio GO

Se invece volessimo fare la stessa cosa lato web, si potrebbe fare in questi termini:

package main
import (
    "fmt"
    "log"
    "net/http"    
)
func helloFunc(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello world!")
}
func main() {
    http.HandleFunc("/", helloFunc)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Esempio di funzione in Go

Un esempio di funzione in Go è la seguente, che verifica se l’indirizzo IPv4 che gli passi sia di broadcast oppure no:

func (addr ipv4addr) ZeroAddress() bool {
    return addr == 0xFFFFFFFF
}

Calcolatrice scritta in Go

(esempio da testare per capire meglio)

package main

import (
"fmt"
)

func main() {
var operator string
var num1, num2 float64

fmt.Print("Inserisci il primo numero: ")
fmt.Scanln(&num1)

fmt.Print("Inserisci il secondo numero: ")
fmt.Scanln(&num2)

fmt.Print("Inserisci l'operatore (+, -, *, /): ")
fmt.Scanln(&operator)

result := 0.0
switch operator {
case "+":
result = num1 + num2
case "-":
result = num1 - num2
case "*":
result = num1 * num2
case "/":
if num2 != 0 {
result = num1 / num2
} else {
fmt.Println("Errore: divisione per zero!")
return
}
default:
fmt.Println("Operatore non valido!")
return
}

fmt.Printf("Il risultato di %.2f %s %.2f è: %.2f\n", num1, operator, num2, result)
}

Altri esempi di funzioni Go

Queste sono solo alcune delle molte funzioni utili che si possono scrivere in Go. Spero che queste ti diano una buona base per iniziare a esplorare il linguaggio e le sue potenzialità!

package main

import (
"fmt"
"math/rand"
"sort"
"time"
)

func main() {
// Inizializza il generatore di numeri casuali
rand.Seed(time.Now().UnixNano())

// 1. Funzione per calcolare la somma di due numeri
sum := add(5, 7)
fmt.Println("Somma di 5 e 7:", sum)

// 2. Funzione per trovare il massimo tra due numeri
max := maximum(10, 25)
fmt.Println("Massimo tra 10 e 25:", max)

// 3. Funzione per invertire un array
arr := []int{1, 2, 3, 4, 5}
reverseArray(arr)
fmt.Println("Array invertito:", arr)

// 4. Funzione per ordinare un array
arrToSort := []int{5, 2, 8, 1, 9}
sort.Ints(arrToSort)
fmt.Println("Array ordinato:", arrToSort)

// 5. Funzione per estrarre un numero casuale compreso tra un intervallo specificato
randomNum := generateRandomNumber(1, 100)
fmt.Println("Numero casuale tra 1 e 100:", randomNum)

// 6. Funzione per calcolare la media di un array di numeri
nums := []float64{5.5, 6.6, 7.7, 8.8, 9.9}
average := calculateAverage(nums)
fmt.Println("Media degli elementi:", average)

// 7. Funzione per verificare se un numero è presente in un array
exists := isNumberExists(arrToSort, 8)
fmt.Println("Il numero 8 esiste nell'array:", exists)

// 8. Funzione per calcolare la potenza di un numero
power := calculatePower(2, 3)
fmt.Println("2 elevato alla 3:", power)

// 9. Funzione per contare il numero di vocali in una stringa
vowelsCount := countVowels("Hello World")
fmt.Println("Numero di vocali nella stringa:", vowelsCount)

// 10. Funzione per invertire una stringa
reversedString := reverseString("Hello")
fmt.Println("Stringa invertita:", reversedString)
}

func add(a, b int) int {
return a + b
}

func maximum(a, b int) int {
if a > b {
return a
}
return b
}

func reverseArray(arr []int) {
for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 {
arr[i], arr[j] = arr[j], arr[i]
}
}

func generateRandomNumber(min, max int) int {
return rand.Intn(max-min+1) + min
}

func calculateAverage(nums []float64) float64 {
sum := 0.0
for _, num := range nums {
sum += num
}
return sum / float64(len(nums))
}

func isNumberExists(arr []int, target int) bool {
for _, num := range arr {
if num == target {
return true
}
}
return false
}

func calculatePower(base, exponent int) int {
result := 1
for i := 0; i < exponent; i++ {
result *= base
}
return result
}

func countVowels(str string) int {
count := 0
vowels := "aeiouAEIOU"
for _, char := range str {
if strings.ContainsRune(vowels, char) {
count++
}
}
return count
}

func reverseString(str string) string {
runes := []rune(str)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
runes[i], runes[j] = runes[j], runes[i]
}
return string(runes)
}

Dove e come scaricare Go

go.dev

Photo by Max Duzij on Unsplash

👇 Da non perdere 👇

Trovalost.it esiste da 4481 giorni (12 anni), e contiene ad oggi 6350 articoli (circa 5.080.000 parole in tutto) e 15 servizi online gratuiti. – Leggi un altro articolo a caso
Non ha ancora votato nessuno.

Ti sembra utile o interessante? Vota e fammelo sapere.

Leggi anche:
Questo sito contribuisce alla audience di sè stesso.
Il nostro network informativo: Lipercubo.it - Pagare.online - Trovalost.it.