Les packages(part II)
Les noms exportés
On va voir pourquoi les noms des fonctions Surface et Diagonal dans le package rectangle commencent par des majuscules. Toute fonction ou variable commençant par une majuscule est un nom exporté en go. Seules Les fonctions et les variables exportées sont accessibles à partir d'autres packages. Dans ce cas, on a besoin d'accéder aux fonctions Surface et Diagonal à partir du main package. Par conséquent, les noms de ces fonctions commencent par des majuscules.
Si les fonctions Surface et Diagonal ne commencent pas par des majuscules et qu'on essaie d'exécuter un programme, le compilateur va lancer une erreur geometrie.go:11: cannot refer to unexported name rectangle.area. Par conséquent, si on veut avoir l'accès à une fonction de l'extérieur d'un package, son nom doit nécessairement commencer par une majuscule.
La fonction init
Tout package peut contenir une fonction init. La fonction init ne doit rien retourner et ne doit pas avoir des paramètres, elle ne peut pas être appelée explicitement dans notre code source.
func init() {
}
La fonction init peut être utilisée pour performer des tâches d'initialisation et pour vérifier l'exactitude du programme avant son exécution.
L'ordre d'initialisation d'un package est comme suivant:
- Les variables sont initialisées en premier.
- La fonction init est appelée ensuite. Un package peut avoir plusieurs fonctions init qui vont être appelées dans l'ordre de leurs présentations pour le compilateur.
Si un package importe d'autres packages, le package importé est initialisé en premier.
Un package va être initialisé une seule fois même s'il est importé de plusieurs packages.
On va faire quelques modifications sur notre application, pour comprendre les fonctions init.
On va ajouter une fonction int au fichier rectprops.go.
//rectprops.go
package rectangle
import "math"
import "fmt"
/*
* la fonction init ajoutée
*/
func init() {
fmt.Println("le package rectangle est initialisé")
}
func Surface(len, wid float64) float64 {
surface := len * wid
return surface
}
func Diagonal(len, wid float64) float64 {
diagonal := math.Sqrt((len * len) + (wid * wid))
return diagonal
}
On a ajouté une simple fonction init qui affiche le package rectangle est initialisé
Maintenant, on va modifier le main package. On sait que length(longueur) et width(largeur) du rectangle doivent être supérieurs à zéro. On va définir cette vérification en utilisant la fonction init et le package niveau variables qui se trouve dans geometrie.go
On va modifier le fichier geometrie.go comme suivant:
//geometrie.go
package main
import (
"fmt"
"geometrie/rectangle" //importer le package personnalisé
"log"
)
/*
* 1. package variables
*/
var rectLen, rectWidth float64 = 6, 7
/*
*2. la fonction init pour vérifier si la longueur et la largeur sont supérieurs à zéro
*/
func init() {
println("main package initialisé")
if rectLen < 0 {
log.Fatal("longueur inférieur à zéro")
}
if rectWidth < 0 {
log.Fatal("largeur supérieur à zéro")
}
}
func main() {
fmt.Println("les poprpriétés d'une forme géométrique")
fmt.Printf("surface du rectangle %.2f\n", rectangle.Area(rectLen, rectWidth))
fmt.Printf("diagonale du rectangle %.2f ",rectangle.Diagonal(rectLen, rectWidth))
}
Les changements faites au niveau de geometrie.go sont comme suivant:
- Les variables rectLen et rectWidth sont déplacées du niveau de la fonction main vers le niveau package.
- Une fonction init est ajoutée. La fonction init affiche un log et met fin à l'exécution du programme si rectLen ou rectWith sont inférieurs à zéro en utilisant la fonction log.Fatal.
L'ordre de l'initialisation du main package est:
- Les packages importées sont initialisés d'abord. Par conséquent, le package rectangle est initialisé en premier.
- Ensuite, le package niveau variables rectLen et rectWidth sont initialisées .
- La fonction init est appelée.
- La fonction main est appelée en dernier.
Si vous exécutez ce programme, vous allez avoir la sortie suivante.
le package rectangle est initialisé
main package initialisé
les propriétés d'une forme géométrique
surface du rectangle 42.00
diagonal du the rectangle 9.22
On va modifier un peu ce programme pour apprendre à utiliser la fonction init.
On va changer la ligne var rectLen, rectWidth float64 = 6, 7dans geometrie.go par var rectLen, rectWidth float64 = -6, 7. On a initialisé rectLen à un nombre rectangle.
Si vous exécutez l'application maintenant, vous allez avoir:
le package rectangle est initialisé
main package initialisé
2017/12/26 12:34:56 longueur inférieur à zéro
Quand on arrive à la partie de l'exécution de la fonction init, le programme est interrompu après l'affichage de longueur inférieur à zéro.
Utiliser l'identificateur blank
Il est illégal en Go d'importer un package et ne pas l'utiliser dans une partie du code. Le compilateur va signaler cela, car cela va contribuer à prolonger la durée de la compilation du programme.
Exemple
//geometrie.go
package main
import (
"geometrie/rectangle" //importer le package personnalisé
)
func main() {
}
Le programme suivant va lancer l'erreur suivante geometrie.go:6: imported and not used: "geometrie/rectangle"
Toutefois, il est très courant d'importer des packages quand l'application est sous développement actif et qu'elle les utilise quelque part et plus tard dans le code. L'identificateur _ nous sauve dans des situations pareilles.
Exemple:
package main
import (
"geometrie/rectangle"
)
var _ = rectangle.Surface
func main() {
}
Parfois, on besoin d'importer des packages juste pour s'assurer que l'initialisaition a été faite même si qu'on n'utilise pas de variables ou de fonctions du package.
package main
import (
_ "geometrie/rectangle"
)
func main() {
}
L'exécution du programme va donner comme sortie le package rectangle est initialisé. On a initialisé le package avec succès même si qu''il n'est pas utilisé quelque part dans le code.
Posted on Utopian.io - Rewarding Open Source Contributors