Exporté vs Non-exporté

Fait partie de la section Logique & Flux du Journey GO de Coddy. Leçon 52 sur 68.

En Go, la visibilité des identifiants (variables, fonctions, types, etc.) est contrôlée par une simple convention de nommage. Celle-ci détermine si le code d’autres packages peut accéder à vos identifiants.

Les identifiants exportés commencent par une majuscule et sont accessibles depuis d’autres packages. Considérez-les comme « publics » : toute personne qui importe votre package peut les utiliser.

// Ces éléments sont exportés (publics)
var Name string
func Calculate() int
type Person struct

Les identifiants non exportés commencent par une lettre minuscule et sont accessibles uniquement au sein du même package. Ils sont « privés » à votre package.

// Ces éléments ne sont pas exportés (privés)
var age int
func helper() string
type config struct

Cette convention de nommage est la manière dont Go contrôle l’accès sans avoir besoin de mots-clés comme public ou private. Lorsque tu essaies d’utiliser un identifiant non exporté depuis un autre package, Go te renvoie une erreur de compilation, car cet identifiant n’est pas visible en dehors de son package.

Défi

Facile

Corrigez les problèmes de visibilité dans un package Go en rectifiant la convention de nommage des identifiants exportés et non exportés. Vous travaillerez sur un scénario simulé avec plusieurs packages, où certains identifiants sont mal nommés, ce qui provoque des erreurs de compilation lorsqu’ils sont utilisés depuis d’autres packages.

Vous recevrez deux entrées :

Une chaîne contenant des définitions de packages au format "package_name:identifier1:type1:visibility1,identifier2:type2:visibility2|package_name:identifier1:type1:visibility1" (par exemple, "utils:helper:function:private,Calculate:function:public|main:name:variable:private,Version:variable:public")
Une chaîne contenant des tentatives d’accès au format "accessing_package.identifier1,accessing_package.identifier2,accessing_package.identifier3" (par exemple, "main.helper,main.Calculate,utils.Version")

Votre tâche consiste à :

Analyser la première entrée en la divisant sur les barres verticales afin d’obtenir les définitions individuelles des packages
Pour chaque définition de package, la diviser sur les deux-points afin d’obtenir le nom du package et ses identifiants
Pour chaque définition d’identifiant, la diviser sur les deux-points afin d’obtenir le nom de l’identifiant, son type et sa visibilité prévue
Créer une fonction appelée fixIdentifierName qui prend un nom d’identifiant et la visibilité prévue, puis renvoie le nom corrigé :
- Si la visibilité est "public", veiller à ce que l’identifiant commence par une majuscule
- Si la visibilité est "private", veiller à ce que l’identifiant commence par une minuscule
Afficher l’en-tête de l’analyse des packages : "=== PACKAGE VISIBILITY ANALYSIS ==="
Pour chaque package, afficher ses informations :
- "Package: [package_name]"
- Pour chaque identifiant du package :
  - Si le nom de l’identifiant doit être corrigé : "- [original_name] ([type]) -> [corrected_name] (visibility: [visibility])"
  - Si le nom de l’identifiant est correct : "- [identifier_name] ([type]) (visibility: [visibility]) ✓"
- Analyser la deuxième entrée en la divisant sur les virgules afin d’obtenir les tentatives d’accès individuelles
- Pour chaque tentative d’accès, la diviser sur les points afin d’obtenir le package à l’origine de l’accès et l’identifiant visé
- Afficher l’en-tête de validation des accès : "=== ACCESS VALIDATION ==="
- Pour chaque tentative d’accès, déterminer si l’accès est valide :
  - Trouver le package qui contient l’identifiant
  - Vérifier si le nom corrigé de l’identifiant commence par une majuscule (exporté)
  - Si l’identifiant est exporté : "[accessing_package] accessing [target_package].[corrected_identifier_name]: ✓ ALLOWED (exported)"
  - Si l’identifiant n’est pas exporté : "[accessing_package] accessing [target_package].[corrected_identifier_name]: ✗ DENIED (unexported)"
  - Si l’identifiant n’existe pas : "[accessing_package] accessing unknown.[identifier_name]: ✗ NOT FOUND" (afficher le mot unknown comme nom de package ; cette tentative compte comme un accès refusé)
- Compter et afficher les statistiques récapitulatives :
  - "=== SUMMARY ==="
  - "Total packages analyzed: [number_of_packages]"
  - "Total identifiers processed: [total_number_of_identifiers]"
  - "Identifiers requiring fixes: [number_of_identifiers_that_needed_fixing]"
  - "Access attempts: [number_of_access_attempts]"
  - "Allowed accesses: [number_of_allowed_accesses]"
  - "Denied accesses: [number_of_denied_accesses]"
- Afficher les recommandations finales :
  - S’il y avait des identifiants à corriger : "Recommendation: Fix identifier naming to follow Go conventions"
  - Si tous les identifiants étaient corrects : "All identifiers follow proper Go naming conventions"

Utilisez le package strings pour diviser les chaînes d’entrée, le package fmt pour produire une sortie formatée, ainsi que des fonctions de manipulation de chaînes pour vérifier et modifier les noms d’identifiants. Ce défi montre comment la convention de nommage de Go contrôle la visibilité des packages et vous aide à comprendre la différence entre les identifiants exportés et non exportés.

Essayez vous-même

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Lire les données d’entrée
	var packageDefinitions string
	var accessAttempts string
	fmt.Scanln(&packageDefinitions)
	fmt.Scanln(&accessAttempts)

	// TODO: Écrivez votre code ci-dessous
	
	// Créer la fonction fixIdentifierName
	
	// Analyser les définitions des packages
	
	// Afficher l’analyse des packages
	
	// Analyser les tentatives d’accès
	
	// Afficher la validation des accès
	
	// Calculer et afficher les statistiques récapitulatives
	
	// Afficher les recommandations
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur Go en ligne