Types

introduction

This article is about Types that are available in go, their characteristics and some tools to manipulate them.

Les types suivants sont les types disponibles dans go:

• bool
• Types numériques:
  • int8, int16, int32, int64, int
  • uint8, uint16, uint32, uint64, uint
  • float32, float64
  • complex64, complex128
  • byte
  • rune
• string

Note:

Toutes les exécutions se feront en playground.

Bool

Un type bool représente un booléen qui est ou bien true(vrai) ou bien false(faux).

package main

import "fmt"

func main() {  
    a := true
    b := false
    fmt.Println("a:", a, "b:", b)
    c := a && b
    fmt.Println("c:", c)
    d := a || b
    fmt.Println("d:", d)
}

Dans le programme ci-dessus, on a attribué true à a et false à b.

On a attribué à c a && b. L'opérateur && retourne true si seulement et si a et b sont tous les deux true. Dans ce cas alors c est false.

L'opérateur || retourne true quand l'une des valeurs a ou b est true. Dans ce cas true est attribué à d car a est true. l'exécution du programme donnerait ceci:

a: true b: false  
c: false  
d: true

Les entiers signés

nt8: représente des entiers signés 8 bit
size: 8 bits
range: -128 à 127

int16: représente des entiers signés 16 bit
size: 16 bits
range: -32768 à 32767 entiers signés

int32: représente des entiers signés 32 bit
size: 32 bits
range: -2147483648 à 2147483647

int64: représente des entiers signés 64 bit
size: 64 bits
range: -9223372036854775808 à 9223372036854775807

int: représente des entiers 32 ou 64 bit selon la plateforme sous-jacente. Vous devez généralement utiliser int pour représenter des entiers à moins que vous avez besoin d'utiliser un entier de taille spécifique.

size: 32 bits dans un système de 32 bit et 64 bits dans un système de 64 bit.

range: -2147483648 à 2147483647 dans un système de 32 bit et -9223372036854775808 à 9223372036854775807 dans un système de 64 bit.

package main

import "fmt"

func main() {  
    var a int = 50
    b := 70
    fmt.Println("valeur de a est", a, "et b est", b)
}

le résulat de l'exécution est valeur de a est 50 et b est 70

On va essayer de vérifier la définition ci-dessus relative au type en utilisant %T . Go a un package unsafe qui une fonction Sizeof qui retourne en bit la taille de la variable passée à la fonction. Ce package doit être utilisé avec prudence car le code peut avoir des problèmes de portabilité.

Le programme suivant donne le type et la taille des variables a et b. %T est le déterminant de format pour écrire le type et %d est utilisé pour déterminer la taille.

package main

import (  
    "fmt"
    "unsafe"
)

func main() {  
    var a int = 50
    b := 70
    fmt.Println("valeur de a est", a, "et b est", b)
    fmt.Printf("type de a est %T, taille de a est %d", a, unsafe.Sizeof(a)) //type et taille de a
    fmt.Printf("\ntype de b est %T, taille de b est %d", b, unsafe.Sizeof(b)) //taille et type de b
}

l'exécution du programme donnerait ceci:

valeur de a est 50 et b est 70  
type de a est int, taille de a est 4  
type de b est int, taille de b est 4  

On peut déduire que le système utilisé est de 32 bit(4bits pour un entier).

Les entiers non-signés

uint8: représente des entiers non-signés 8 bit
size: 8 bits
range: 0 à 255

uint16: représente des entiers non-signés 16 bit
size: 16 bits
range: 0 à 65535

uint32: représente des entiers non-signés 32 bit
size: 32 bits
range: 0 à 4294967295

uint64: représente des entiers non-signés 64 bit
size: 64 bits
range: 0 à 18446744073709551615

uint : représente des entiers non-signés 32 ou 64 bits selon la plateforme sous-jacente.

size : 32 bits dans les systèmes de 32 bit et 64 bits dans les systèmes de 64 bit .

range : 0 à 4294967295 dans les systèmes de 32 bit et 0 à 18446744073709551615 dans les systèmes de 64 bit.

Les nombres réels

float 32: nombres réels 32 bit

float 64: nombre réels 64 bit

Voici un exemple qui illustre le type entier et le type float:

package main

import (  
    "fmt"
)

func main() {  
    a, b := 5.67, 8.97
    fmt.Printf("type de a %T b %T\n", a, b)
    som := a + b
    diff := a - b
    fmt.Println("som", som, "diff", diff)

    no1, no2 := 96, 79
    fmt.Println("som", no1+no2, "diff", no1-no2)
}

Le type des variables a et b est déduit des valeurs attribuées aux variables. Dans ce cas, a et b sont des float64.

le résultat de l'exécution du programme ci-dessus est:

type de a float64 b float64  
sum 14.64 diff -3.300000000000000  
som 175 diff 17 

Le type complex

complex64: les nombres complexes dont la partie réelle et imaginaire est un réel float32

complex128: les nombres complexes dont la partie réelle et imaginaire est un réel float64

La fonction intrinsèque complex est utilisée pour construire un nombre complexe avec une partie imaginaire et une partie réelle.

func complex(r, i FloatType) ComplexType

Cette fonction prend la partie réelle et la partie imaginaire comme paramètres et retourne le type complex, les deux parties doivent être du même type. Si les deux parties sont des float32, la fonction retourne une valeur complexe de type complex64, s'ils sont des float64, la fonction retourne une valeur complexe de type complex128.

Les nombres complexes peuvent aussi être créés en utilisant le syntaxe concis suivant:

c : 7 + 8i

Voici un exemple pour bien comprendre les nombres complexes:

package main

import (  
    "fmt"
)

func main() {  
    c1 := complex(4, 7)
    c2 := 9 + 6i
    cadd := c1 + c2
    fmt.Println("som:", cadd)
    cmul := c1 * c2
    fmt.Println("produit:", cmul)
}

le résultat de l'exécution du programme est comme suivant:

som: (13+13i)
produit: (-6 + 87i)

Autres types numériques

byte est un allias de uint8

rune est un allias de int32

Le type string

String est une collection de bits dans golang. On suppose pour l'instant que c'est une collection de caractères.

Exemple:

package main

import (  
    "fmt"
)

func main() {  
    first := "Émilie"
    last := "Poirot"
    name := first +" "+ last
    fmt.Println("Mon nom est",name)
}

On peut cancaténer les strings en utilisant l'opérateur +.

Le programme ci-dessus affichera comme sortie Mon nom est Émilie Poirot.

La conversion

Go est très strict en ce qui concerne le tapage explicite. Il n'y a pas de conversion automatique.

Examinez cet exemple pour bien comprendre ce qu'on vient de dire:

package main

import (  
    "fmt"
)

func main() {  
    i := 74      //int
    j := 77.8    //float64
    sum := i + j //int + float64 n'est pas permise
    fmt.Println(sum)
}

Dans le code ci-dessus, on était entrain d'essayer d'ajouter deux types différents ce qui n'est pas permis en go. Quand vous allez exécuter ce programme, vous aurez comme sortie:main.go:10: invalid operation: i + j (mismatched types int and float64)

Pour résoudre ce problème, les deux variables doivent être du même type. On doit alors recourir à la conversion . W(a) est le syntaxe pour convertir une valeur a de type W.

exemple:

package main

import (  
    "fmt"
)

func main() {  
    i := 74      //int
    j := 77.8    //float64
    sum := i + int(j) //int + float64 n'est pas permise
    fmt.Println(sum)
}

Quand vous allez exécuter le programme, vous allez avoir 151 comme sortie.

Il est de même pour l'affectation (la variable et la valeur affectée doivent être du même type)

Exemple:

package main

import (  
    "fmt"
)

func main() {  
    i := 12
    var j float64 = float64(i) //cette déclaration ne va pas marcher sans une conversion explicite  
    fmt.Println("j", j)
}

La variable i est converti à float64 , puis affectée à la variable j, si vous négligez la conversion, le compilateur signalera une erreur.

---

Posted on Utopian.io - Rewarding Open Source Contributors

---