Fonctions constructeurs

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 10 sur 107.

Go n'a pas de constructeurs comme d'autres langages. Au lieu de cela, la convention est de créer une fonction nommée NewTypeName qui retourne une structure initialisée, souvent sous forme de pointeur.

Fonction constructeur de base

type Person struct {
    Name string
    Age  int
}

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

Constructeur avec des valeurs par défaut

type Config struct {
    Host    string
    Port    int
    Timeout int
}

func NewConfig(host string) *Config {
    return &Config{
        Host:    host,
        Port:    8080,    // Valeur par défaut
        Timeout: 30,      // Valeur par défaut
    }
}

Constructeur avec validation

func NewPerson(name string, age int) *Person {
    if name == "" {
        name = "Unknown"
    }
    if age < 0 {
        age = 0
    }
    return &Person{
        Name: name,
        Age:  age,
    }
}

Utilisation des fonctions constructeurs

func main() {
    p1 := NewPerson("Alice", 25)
    fmt.Println(p1.Name) // Alice

    p2 := NewPerson("", -5)
    fmt.Println(p2.Name) // Unknown
    fmt.Println(p2.Age)  // 0
}

Les fonctions constructeurs retournent un pointeur (*StructName) en utilisant &. Cela évite de copier la structure et permet aux méthodes avec des récepteurs de pointeur de fonctionner directement. La validation et les valeurs par défaut se placent à l'intérieur du constructeur.

Défi

Moyen

Créez une fonction constructeur NewBankAccount pour la structure BankAccount avec validation :

Prend name (string) et balance (float64) comme paramètres
Si name est vide, utilisez par défaut "Unnamed"
Si balance est négatif, utilisez par défaut 0
Définissez Owner sur "Default Owner" toujours
Retournez un pointeur vers la nouvelle structure

Aide-mémoire

Go utilise des fonctions constructeurs au lieu de constructeurs. La convention est de les nommer NewTypeName et de retourner un pointeur vers la structure initialisée.

Fonction constructeur de base :

type Person struct {
    Name string
    Age  int
}

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

Constructeur avec des valeurs par défaut :

func NewConfig(host string) *Config {
    return &Config{
        Host:    host,
        Port:    8080,    // Valeur par défaut
        Timeout: 30,      // Valeur par défaut
    }
}

Constructeur avec validation :

func NewPerson(name string, age int) *Person {
    if name == "" {
        name = "Unknown"
    }
    if age < 0 {
        age = 0
    }
    return &Person{
        Name: name,
        Age:  age,
    }
}

Les fonctions constructeurs retournent un pointeur (*StructName) en utilisant & pour éviter de copier la structure et permettre aux méthodes avec un récepteur de pointeur de fonctionner directement.

Essayez vous-même

package main

import "fmt"

func main() {
    var name string
    var balance float64
    fmt.Scan(&name, &balance)

    account := NewBankAccount(name, balance)

    fmt.Printf("Account: %s\n", account.Name)
    fmt.Printf("Balance: %.2f\n", account.Balance)
    fmt.Printf("Owner: %s\n", account.Owner)
}