go - usar - Público, privado-Mayúsculas, minúsculas:

uso de mayusculas y minusculas pdf (3)

Nuevo en GoLang, procedente de Delphi, C ++:

La primera vez que intenté crear mi propio paquete en Go, seguí todas las instrucciones sobre cómo diseñar el espacio de trabajo, etc., pero seguí obteniendo un error de compilación:

./myPackage.go:52: undefined: myFunc

Después de hurgar un poco, descubrí que el modificador de acceso público en Go se logra simplemente declarando una función en mayúsculas. Estupendo.

Pero cuando comencé a experimentar con las clases de contenedor - List para principiantes, descubrí que tenía que declarar un valor de retorno de referencia de lista como este:

func GetFactors(value *int64) *list.List {...

*list está en minúsculas.

Lo mismo cuando declaré una referencia local a una lista, tuve que usar:

l := list.New()

De nuevo, minúsculas para la list .

Entonces, estoy confundido. ¿Cuál es la regla? Las llamadas a la lista y las referencias son obviamente públicas, o no podría llamarlas / usarlas, entonces ¿por qué están en minúsculas?

En este caso, list es el nombre del paquete, que está importando a través de la import "container/list" , y sus miembros públicos son mayúsculas, como List .

La regla es que las funciones públicas, tipos, etc., deben ser mayúsculas.

Puede alias los paquetes importados como quiera, pero de manera predeterminada es solo el nombre de la última parte de la ruta del paquete, en este caso, list .

Actualización: no es la última parte de la ruta del paquete. Es el nombre real del paquete (que a menudo es lo mismo).

Nota: a partir de Go 1.5 (Q2 / Q3 2015), también obtendrá importación "protegida" (denominada "interna").

Consulte Go 1.4 doc :

El sistema de paquetes de Go facilita la estructuración de programas en componentes con límites claros, pero solo hay dos formas de acceso: local (no exportado) y global (exportado).
A veces uno desea tener componentes que no se exportan, por ejemplo, para evitar adquirir clientes de interfaces para el código que es parte de un repositorio público pero que no está destinado a ser utilizado fuera del programa al que pertenece.
El idioma Go no tiene el poder para imponer esta distinción, pero a partir de Go 1.4, el comando go introduce un mecanismo para definir paquetes "internos" que pueden no ser importados por paquetes fuera del subárbol de origen en el que residen.
Para crear dicho paquete, colóquelo en un directorio llamado internal o en un subdirectorio de un directorio llamado internal .
Cuando el comando go ve una importación de un paquete con internal en su ruta, verifica que el paquete que realiza la importación está dentro del árbol rooteado en el padre del directorio interno.
Por ejemplo, un paquete .../a/b/c/internal/d/e/f puede importarse solo por código en el árbol de directorios rooteado en .../a/b/c .
No puede ser importado por código en .../a/b/g ni en ningún otro repositorio.
Para Go 1.4, el mecanismo del paquete interno se aplica para el repositorio principal de Go ;
desde 1.5 en adelante se aplicará para cualquier repositorio .

Nota: la especificación Ir para el nombre del paquete no menciona que el nombre del paquete esté siempre en minúscula.
Solo indica que su nombre está representado por un identifier , que se compone de una colección de " letter ".

Este hilo aclara:

Los nombres de los paquetes pueden ser cualquier cosa, puede iniciarlos con una letra mayúscula si lo desea.
Pero la convención es todo en minúscula, lo que supongo que le ahorra la molestia de escribir una letra mayúscula.
La exportabilidad en mayúsculas / minúsculas no es realmente relevante para los paquetes, ya que no puede tener un paquete privado.

Una vez que lo sabes, es más fácil de reconocer:

list.New() para un constructor (siempre en el nivel del paquete, para construir una instancia inicializada de un tipo), como os.NewFile() ,
list.List para un tipo de estructura de la lista de paquetes (el otro tipo de estructura de ese mismo paquete es list.Element ).