Exportado vs. No exportado

Parte de la sección Lógica y Flujo del Journey de GO de Coddy — lección 52 de 68.

En Go, la visibilidad de los identificadores (variables, funciones, tipos, etc.) se controla mediante una convención de nomenclatura sencilla. Esto determina si el código de otros paquetes puede acceder a sus identificadores.

Identificadores exportados comienzan con una letra mayúscula y son accesibles desde otros paquetes. Piense en ellos como "públicos": pueden ser utilizados por cualquiera que importe su paquete.

// Estos son exportados (públicos)
var Name string
func Calculate() int
type Person struct

Identificadores no exportados comienzan con una letra minúscula y solo son accesibles dentro del mismo paquete. Estos son "privados" para su paquete.

// Estos no están exportados (privados)
var age int
func helper() string
type config struct

Esta convención de nomenclatura es la forma en que Go controla el acceso sin necesidad de palabras clave como public o private. Cuando intentas usar un identificador no exportado de otro paquete, Go te dará un error de compilación porque ese identificador no es visible fuera de su paquete.

Ponte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Ponte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Ponte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Desafío

Fácil

Corrige los problemas de visibilidad en un paquete de Go corrigiendo la convención de nomenclatura para identificadores exportados y no exportados. Trabajarás con un escenario simulado de múltiples paquetes donde algunos identificadores están nombrados incorrectamente, lo que causa errores de compilación cuando se accede a ellos desde otros paquetes.

Recibirás dos entradas:

Una cadena que contiene definiciones de paquetes en el formato "package_name:identifier1:type1:visibility1,identifier2:type2:visibility2|package_name:identifier1:type1:visibility1" (por ejemplo, "utils:helper:function:private,Calculate:function:public|main:name:variable:private,Version:variable:public")
Una cadena que contiene intentos de acceso en el formato "accessing_package.identifier1,accessing_package.identifier2,accessing_package.identifier3" (por ejemplo, "main.helper,main.Calculate,utils.Version")

Tu tarea es:

Analizar la primera entrada dividiéndola por tuberías (pipes) para obtener las definiciones de paquetes individuales
Para cada definición de paquete, dividir por dos puntos para obtener el nombre del paquete y sus identificadores
Para cada definición de identificador, dividir por dos puntos para obtener el nombre del identificador, el tipo y la visibilidad prevista
Crear una función llamada fixIdentifierName que reciba un nombre de identificador y la visibilidad prevista, y devuelva el nombre corregido:
- Si la visibilidad es "public", asegúrate de que el identificador comience con una letra mayúscula
- Si la visibilidad es "private", asegúrate de que el identificador comience con una letra minúscula
Mostrar el encabezado del análisis de paquetes: "=== PACKAGE VISIBILITY ANALYSIS ==="
Para cada paquete, mostrar la información del paquete:
- "Package: [package_name]"
- Para cada identificador en el paquete:
  - Si el nombre del identificador necesita corrección: "- [original_name] ([type]) -> [corrected_name] (visibility: [visibility])"
  - Si el nombre del identificador es correcto: "- [identifier_name] ([type]) (visibility: [visibility]) ✓"
- Analizar la segunda entrada dividiéndola por comas para obtener los intentos de acceso individuales
- Para cada intento de acceso, dividir por puntos para obtener el paquete que accede y el identificador al que se accede
- Mostrar el encabezado de validación de acceso: "=== ACCESS VALIDATION ==="
- Para cada intento de acceso, determinar si el acceso es válido:
  - Buscar el paquete que contiene el identificador
  - Verificar si el nombre del identificador corregido comienza con una letra mayúscula (exportado)
  - Si el identificador es exportado: "[accessing_package] accessing [target_package].[corrected_identifier_name]: ✓ ALLOWED (exported)"
  - Si el identificador no es exportado: "[accessing_package] accessing [target_package].[corrected_identifier_name]: ✗ DENIED (unexported)"
  - Si el identificador no existe: "[accessing_package] accessing [target_package].[identifier_name]: ✗ NOT FOUND"
- Contar y mostrar las estadísticas de resumen:
  - "=== 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]"
- Mostrar las recomendaciones finales:
  - Si hubo identificadores que requirieron correcciones: "Recommendation: Fix identifier naming to follow Go conventions"
  - Si todos los identificadores eran correctos: "All identifiers follow proper Go naming conventions"

Utiliza el paquete strings para dividir las cadenas de entrada, el paquete fmt para la salida formateada y funciones de manipulación de cadenas para verificar y modificar los nombres de los identificadores. Este desafío demuestra cómo la convención de nomenclatura de Go controla la visibilidad de los paquetes y te ayuda a comprender la diferencia entre identificadores exportados y no exportados.

Hoja de referencia

Go controla la visibilidad a través de convenciones de nomenclatura sin palabras clave explícitas como public o private.

Los identificadores exportados comienzan con una letra mayúscula y son accesibles desde otros paquetes:

// Estos son exportados (públicos)
var Name string
func Calculate() int
type Person struct

Los identificadores no exportados comienzan con una letra minúscula y solo son accesibles dentro del mismo paquete:

// Estos no son exportados (privados)
var age int
func helper() string
type config struct

Intentar acceder a identificadores no exportados desde otros paquetes resulta en errores de compilación.

Pruébalo tú mismo

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Leer entrada
	var packageDefinitions string
	var accessAttempts string
	fmt.Scanln(&packageDefinitions)
	fmt.Scanln(&accessAttempts)

	// TODO: Escribe tu código a continuación
	
	// Crear la función fixIdentifierName
	
	// Analizar definiciones de paquetes
	
	// Mostrar análisis de paquetes
	
	// Analizar intentos de acceso
	
	// Mostrar validación de acceso
	
	// Calcular y mostrar estadísticas de resumen
	
	// Mostrar recomendaciones
}

Ponte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Lógica y Flujo

3Interfaces (Conceptos básicos)

¿Qué es una interfaz?Definir una interfaz Implementar una interfaz Uso de tipos de interfaz Interfaz vacía Aserciones de tipo Type Switch Resumen: Formas y comportamientos

6Go idiomático: Sets

El modismo de Set en Go Crear un Set Añadir a un Set Comprobar pertenencia Eliminar de un Set Iterar sobre un Set Resumen: Nombres de usuario únicos

9Paquetes y Ámbito

¿Qué es un paquete?Exportado vs. No exportadoCrear un paquete simple Alias de paquetes El identificador en blanco `_`La función `init`Repaso - Construir una utilidad