Nombres à virgule flottante

Fait partie de la section Fondamentaux du Journey GO de Coddy — leçon 8 sur 109.

Apprenons-en plus sur les nombres à virgule flottante en Go, que nous utilisons pour stocker des valeurs décimales.

Tout d'abord, déclarons une variable à virgule flottante avec un type explicite :

var price float64 = 19.99
fmt.Println("Price:", price)

Après l'exécution de ce code, vous verrez ce qui suit à l'écran :

Price: 19.99

Nous avons créé une variable qui peut contenir des nombres décimaux.

En Go, il existe deux types à virgule flottante : float32 et float64. Voyons comment utiliser float32 :

var temperature float32 = 23.5
fmt.Println("Temperature:", temperature)

Après avoir exécuté ce code, vous verrez ce qui suit à l'écran :

Temperature: 23.5

La différence entre float32 et float64 réside dans la précision et la plage de valeurs. float64 utilise 64 bits et offre une précision plus élevée (environ 15 à 17 chiffres décimaux) alors que float32 utilise 32 bits avec une précision moindre (environ 6 à 9 chiffres décimaux).

Pour la plupart des applications, float64 est recommandé car il est plus précis.

Maintenant, utilisons l'inférence de type de Go pour créer un nombre à virgule flottante plus simplement :

temperature := 23.5 // Go utilise automatiquement float64
fmt.Println("Temperature:", temperature)

Après avoir exécuté ce code, vous verrez ce qui suit à l'écran :

Temperature: 23.5

Lorsque vous incluez un point décimal dans un nombre, Go le traite automatiquement comme un type float64.

Essayons quelques calculs mathématiques de base avec des nombres à virgule flottante :

radius := 5.0
pi := 3.14159
area := pi * radius * radius
fmt.Println("Circle area:", area)

Après avoir exécuté ce code, vous verrez ce qui suit à l'écran :

Circle area: 78.53975

Les nombres à virgule flottante nous permettent d'effectuer des calculs avec des valeurs décimales.

Défi

Débutant

Dans ce défi, vous allez vous entraîner à travailler avec des nombres à virgule flottante en Go.

Les nombres à virgule flottante sont utilisés pour représenter des valeurs décimales en Go. Il existe deux types principaux : float32 et float64, le type float64 étant le plus couramment utilisé car il offre une plus grande précision.

Votre tâche consiste à déclarer une variable à virgule flottante et à l'afficher dans la console.

Aide-mémoire

Go possède deux types à virgule flottante pour les nombres décimaux :

float32 - 32 bits, moins de précision (6 à 9 chiffres décimaux)
float64 - 64 bits, plus grande précision (15 à 17 chiffres décimaux), recommandé pour la plupart des applications

Déclarez des variables à virgule flottante avec un type explicite :

var price float64 = 19.99
var temperature float32 = 23.5

Utilisez l'inférence de type avec un point décimal (Go utilise automatiquement float64) :

temperature := 23.5

Effectuez des calculs avec des nombres à virgule flottante :

radius := 5.0
pi := 3.14159
area := pi * radius * radius

Essayez vous-même

package main

import "fmt"

func main() {
	// Quelques exemples de nombres à virgule flottante
	pi := 3.14159
	temperature := 72.5

	// TODO: Déclarer une nouvelle variable float64 nommée 'height' avec la valeur 5.9
	height := ?
		
	// Afficher les variables existantes
	fmt.Println("Pi approximately equals:", pi)
	fmt.Println("The temperature is:", temperature)
	
	// TODO: Afficher votre nouvelle variable 'height' avec un message descriptif
	fmt.Println("The height is:", ?)
}