Esempi di casting Golang

Esempi Di Casting Golang



Il processo di alterazione del tipo di dati di un valore da un tipo a un altro è noto come casting di tipo, talvolta noto come conversione di tipo. Il cast di tipi viene eseguito in Go utilizzando le conversioni di tipo esplicite. Go supporta la digitazione forte. Pertanto, durante la conversione tra i tipi, dobbiamo indicare esplicitamente il nostro obiettivo. Ciò promuove l'indipendenza dai tipi e riduce la probabilità di errori di battitura. In questo articolo, esploreremo il casting con diversi tipi in Go.

Esempio 1: lancio di tipo base Golang

Cominciamo con l'esempio del casting diretto e di base in Go perché richiediamo il typecasting per modificare il tipo della variabile, ovunque.

pacchetto principale
importare (
'fmt'
)
funz principale () {
era X int = 31
E := galleggiante64 ( X )
fmt . Stampaln ( E )
}

Qui, iniziamo con la funzione principale dichiarando una variabile denominata 'x' di tipo 'int' e assegnandole un valore di 31. Quindi, la variabile 'y' viene dichiarata utilizzando l'operatore di assegnazione abbreviato ':='. Il tipo di 'y' è determinato automaticamente dall'espressione sul lato destro che è il risultato della conversione di 'x' in un 'float64'. Quindi, in questo programma, il valore di 'x' viene convertito in un 'float64' e viene assegnato a 'y'.







I risultati recuperati dal casting di base in Go vengono visualizzati come segue:





Esempio 2: casting di tipo implicito Golang

Il casting di tipo implicito non è consentito tra tipi diversi. Go applica una tipizzazione forte, il che significa che non possiamo assegnare o utilizzare direttamente un valore di un tipo come un altro tipo senza una conversione esplicita. Di seguito, proviamo ad eseguire il casting implicito che genera l'eccezione tramite Go:





pacchetto principale
importare 'fmt'
funz principale () {
era numero intero int = 9 . 08
fmt . Stampaf ( 'Il numero intero è %g' , numero intero )
}

Ecco il codice che inizia con la funzione main() dove viene dichiarata una variabile “intera” con il tipo “int”. Il valore che viene assegnato alla variabile “integer” è 9.08 che è un numero in virgola mobile. Poiché stiamo tentando di assegnare un valore a virgola mobile direttamente a una variabile intera, si verifica un errore di mancata corrispondenza del tipo. Quindi, usiamo la funzione 'printf' dal pacchetto 'fmt' per stampare il valore della variabile 'integer' usando l'identificatore di formato '%g'.

Come previsto, il casting di tipo implicito non è accettabile in Golang. Il casting di tipo implicito precedente genera il seguente errore:



Esempio 3: Casting esplicito di tipo Golang

La conversione esplicita del tipo ci consente di convertire in modo sicuro i valori tra tipi compatibili dichiarando esplicitamente un'intenzione. Assicura che siamo a conoscenza della conversione del tipo e aiuta a prevenire errori di tipo accidentali. Considera il seguente casting esplicito:

pacchetto principale
importare 'fmt'

funz principale () {
era floatVal galleggiante32 = 6 . 75
era intVal int = int ( floatVal )
fmt . Stampaf ( 'Il valore float è %g \N ' , floatVal )
fmt . Stampaf ( 'Il valore intero è %d' , intVal )
}

Qui viene creata una variabile 'floatVal' con il tipo 'float32' e le viene assegnato il valore '6.75'. Quindi, viene dichiarata una variabile 'intVal' con il tipo 'int'. Per assegnare il valore di floatVal a intVal, viene utilizzata la conversione del tipo. Per trasformare floatVal in un valore intero, viene utilizzata la funzione 'int' con floatVal come input. Successivamente, 'fmt.Printf('Float Value is %g\n', floatVal)' stampa il valore di floatVal usando l'identificatore di formato %g che è adatto per stampare i valori in virgola mobile. Mentre la riga di codice 'fmt.Printf('Integer Value is %d', intVal)' stampa il valore di intVal usando l'identificatore di formato %d che è adatto per stampare i valori interi.

Il seguente output genera i valori sia per floatVal che per intVal dopo averlo lanciato:

Esempio 4: casting di tipo Golang per ottenere la media

Successivamente, eseguiamo il casting per ottenere il numero medio dai valori dati. Esaminiamo il codice sorgente fornito di seguito:

pacchetto principale
importare 'fmt'
funz principale () {
era totale int = 900
era Il mio numero int = venti
era media galleggiante32
media = galleggiante32 ( totale ) / galleggiante32 ( Il mio numero )
fmt . Stampaf ( 'La media è = %f \N ' , media )
}

Qui, inizialmente dichiariamo tre variabili. Il 'totale' è una variabile intera che viene inizializzata con il valore di 900. Il 'MyNumber' è una variabile intera che viene inizializzata con il valore di 20. La media calcolata viene quindi memorizzata nella variabile 'average' float32. Viene quindi fornita la formula media per eseguire il calcolo. Per garantire che la divisione venga eseguita come divisione in virgola mobile, i valori di 'total' e 'MyNumber' vengono convertiti in float32 utilizzando la conversione del tipo. La media calcolata è assegnata alla variabile “media”. Infine, la stringa di formato '%f\n' utilizzata nella funzione 'printf' specifica che deve essere stampato un valore float, seguito da un carattere di nuova riga.

Il valore risultante come media viene recuperato dopo aver implicato il casting del tipo nel codice precedente:

Esempio 5: Casting del tipo Golang Int e String

Inoltre, Go offre anche il casting tra i tipi Int e String. Possiamo farlo usando la funzione del pacchetto strconv.

pacchetto principale
importare (
'fmt'
'strconv'
)
funz principale () {
era str corda = '1999'
In , _ := strconv . trailer ( S )
fmt . Stampaln ( In )
era numero intero int = 1999
toStr := strconv . affogato ( numero intero )

fmt . Stampaln ( toStr )
}

Ecco il codice che inizia con la dichiarazione di due variabili. 'str' ​​è una variabile stringa inizializzata con il valore '1999' e 'integer' è una variabile intera inizializzata con il valore '1999'. Successivamente, la funzione 'strconv.Atoi()' viene utilizzata per convertire la stringa 'str' ​​in un valore intero. Il valore restituito di 'v' rappresenta il numero intero convertito e l'identificatore '_' vuoto viene utilizzato per ignorare qualsiasi potenziale errore restituito da Atoi().

Successivamente, viene utilizzata la funzione strconv.Itoa() per trasformare l'intero in un valore stringa. Il valore restituito che è 'toStr' rappresenta la stringa convertita.

L'output visualizza la conversione dalla stringa '1999' a un numero intero e di nuovo a una stringa che produce il valore originale di '1999':

Esempio 6: casting di tipo Golang tra stringa e byte

Inoltre, il casting in Go può essere eseguito anche nei tipi stringa e byte. I seguenti codici dimostrano la conversione tra stringhe e fette di byte:

pacchetto principale
importare (
'fmt'
)
funz principale () {
era mystr corda = 'Ehilà'
era b1 [] byte = [] byte ( myStr )
fmt . Stampaln ( b1 )
accordare := corda ( b1 )
fmt . Stampaln ( accordare )
}

Qui, le variabili vengono prima dichiarate come 'myStr' e 'b1' che vengono inizializzate con determinati valori. Quindi, l'espressione []byte(myStr) converte la stringa 'myStr' in una porzione di byte utilizzando la conversione del tipo. Assegna il byte slice risultante alla variabile 'b1'. Successivamente, l'espressione 'string(b1)' riconverte la porzione di byte b1 in una stringa utilizzando la conversione del tipo. Assegna la stringa risultante alla variabile 'toString'.

L'output mostra la conversione tra la stringa 'Hey There' e la corrispondente rappresentazione della sezione di byte nel modo seguente:

Esempio 7: Casting di tipo Golang per ottenere la radice quadrata

Ora eseguiamo il casting in Go per trovare i risultati della radice quadrata. Il codice è posizionato come segue:

pacchetto principale
importare (
'fmt'
'matematica'
)
funz principale () {
era N int = 177
era SqrtN galleggiante64
SqrtN = matematica . Quadrato ( galleggiante64 ( N ))
fmt . Stampaf ( 'La radice quadrata di %d è %.2f \N ' , N , SqrtN )
}

Qui, la variabile 'n' è dichiarata come int e assegna il valore di '144'. La variabile 'SqrtN' è dichiarata come float64 e memorizza la radice quadrata calcolata di 'n'. Quindi, viene distribuita la funzione math.Sqrt() per calcolare la radice quadrata di 'n'. Poiché math.Sqrt() prevede un argomento float64 e il valore di 'n' viene convertito in float64 utilizzando float64(n). Successivamente, la stringa di formato 'Radice quadrata di %d è %.2f\n' chiama la funzione 'printf' che specifica un valore intero (%d) e un valore a virgola mobile (%.2f). L'identificatore di precisione '.2' in '%.2f' assicura che la radice quadrata venga stampata con due cifre decimali.

Viene recuperato il seguente output che indica la radice quadrata del valore dato:

Conclusione

Il casting in Go è discusso con esempi distinti che sono tutti eseguibili. Tieni presente che in Go, il typecasting è esplicito, il che impone una tipizzazione forte e promuove la chiarezza e l'affidabilità del codice.