Packages et Imports
Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 3 sur 107.
Chaque fichier Go commence par une déclaration package. Le mot-clé import importe des paquets de la bibliothèque standard de Go afin que vous puissiez utiliser leurs fonctions.
Importer un seul package
import "fmt"Importez plusieurs packages en utilisant un bloc d'importation
import (
"fmt"
"math"
"strings"
)Utilisez les fonctions des packages importés avec le nom du package comme préfixe
package main
import (
"fmt"
"strings"
"math"
)
func main() {
upper := strings.ToUpper("hello")
fmt.Println(upper) // Résultat : HELLO
root := math.Sqrt(16)
fmt.Println(root) // Résultat : 4
}Paquetages courants de la bibliothèque standard
"fmt" // E/S formatées (Print, Scan, Sprintf)
"strings" // Manipulation de chaînes (ToUpper, Contains, Replace)
"math" // Fonctions mathématiques (Sqrt, Pow, Pi)
"strconv" // Conversions de chaînes (Itoa, Atoi)Vous accédez aux fonctions d'un package en utilisant packagename.FunctionName. Go vous permet uniquement d'importer les packages que vous utilisez réellement — les imports inutilisés provoquent une erreur de compilation.
Défi
MoyenCorrigez l'instruction d'importation dans utils.go pour que les fonctions fonctionnent correctement. Vous devez importer les packages strings et math :
FormatTextutilisestrings.ToUpperContainsWordutilisestrings.ContainsSquareRootutilisemath.Sqrt
Aide-mémoire
Chaque fichier Go commence par une déclaration package. Utilisez le mot-clé import pour importer des packages de la bibliothèque standard de Go.
Importer un seul package :
import "fmt"Importer plusieurs packages en utilisant un bloc d'importation :
import (
"fmt"
"math"
"strings"
)Accédez aux fonctions des packages importés en utilisant packagename.FunctionName :
package main
import (
"fmt"
"strings"
"math"
)
func main() {
upper := strings.ToUpper("hello")
fmt.Println(upper) // Résultat : HELLO
root := math.Sqrt(16)
fmt.Println(root) // Résultat : 4
}Packages courants de la bibliothèque standard :
"fmt" // E/S formatées (Print, Scan, Sprintf)
"strings" // Manipulation de chaînes (ToUpper, Contains, Replace)
"math" // Fonctions mathématiques (Sqrt, Pow, Pi)
"strconv" // Conversions de chaînes (Itoa, Atoi)Remarque : Go vous permet uniquement d'importer les packages que vous utilisez réellement — les importations inutilisées provoquent une erreur de compilation.
Essayez vous-même
package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func main() {
scanner := bufio.NewScanner(os.Stdin)
scanner.Scan()
line := scanner.Text()
parts := strings.Fields(line)
numStr := parts[len(parts)-1]
text := strings.Join(parts[:len(parts)-1], " ")
num, _ := strconv.ParseFloat(numStr, 64)
fmt.Printf("Upper: %s\n", FormatText(text))
fmt.Printf("Contains 'world': %t\n", ContainsWord(text, "world"))
fmt.Printf("Sqrt: %.2f\n", SquareRoot(num))
}Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.
Toutes les leçons de Programmation Orientée Objet
1Fondamentaux de la POO en Go
Fichiers externesEspace de travail et Modules GoPackages et ImportsNoms exportés vs non exportésIntroduction à la POO en GoLes Structs comme ClassesDéfinir des méthodes sur les StructsReceveurs par pointeur vs par valeurInitialisation de StructsFonctions constructeursRécapitulatif - Calculatrice simple4Interfaces
Introduction aux interfacesImplémentation impliciteL'interface comme contratInterface vide (any)Assertion de typeType SwitchComposition d'interfacesInterfaces Stringer & ErrorRécapitulatif - Calculateur de formes7Encapsulation
Champs exportés vs non exportésEncapsulation au niveau du packageMéthodes Getter & SetterMasquage d'informations en GoRécapitulatif - Dossiers étudiants10Génériques (Go 1.18+)
Introduction aux génériquesParamètres de typeContraintes de typeStructures génériquesContournement pour les méthodes génériquesRécapitulatif - Collections génériques13Patrons de conception, Partie 1
Introduction aux Design PatternsPatron SingletonPatron FactoryPatron Abstract FactoryPatron ObserverPatron Strategy2Exploration approfondie des Types et Structs
Types de base et compositesDéfinitions de types personnalisésTags de StructStructs anonymesStructs imbriquéesValeurs par défaut et Zero ValuesRécapitulatif - Carnet de contacts5Composition plutôt qu'héritage
Pourquoi Go n'a pas d'héritageLes bases de l'imbrication de structsPromotion de méthodesImbriquer plusieurs structsImbrication vs AgrégationMasquage de méthodes imbriquéesRécapitulatif - Hiérarchie des employés8Gestion des erreurs & POO
L'interface errorTypes d'erreurs personnalisésError Wrapping (fmt.Errorf)Erreurs sentinelleserrors.Is() et errors.As()Panic, Defer et RecoverRécapitulatif - File Parser11Bibliothèque standard et POO
io.Reader & io.WriterL'interface sort.InterfaceL'interface fmt.Stringerencoding/json avec les StructsL'interface http.HandlerRécapitulatif - Modèles d'API REST14Patrons de conception, Partie 2
Patron CommandePatron AdaptateurPatron DécorateurPatron Template MethodPatron ÉtatPatron CompositeMiddleware en tant que Décorateur3Pointeurs et Mémoire
Bases des pointeurs en GoPointeurs vers des structsPassage par valeur vs référenceLa fonction new()Garbage Collection en GoRécapitulatif - Constructeur de liste chaînée6Le polymorphisme en Go
Le polymorphisme via les interfacesLe Duck Typing en GoRègles de satisfaction des interfacesCollections polymorphesInjection de dépendancesRécapitulatif - Processeur de paiement9Concurrence et POO
Bases des GoroutinesChannels et CommunicationChannels avec buffer vs sans bufferL'instruction Selectsync.Mutex et sync.RWMutexsync.WaitGroupConception de structures Thread-SafeRécapitulatif - Worker Pool