imports - ¿Qué forma de nombrar una función en Go, CamelCase o Semi-CamelCase?

golang tutorial

Question

Quiero escribir una función en Ir para insertar un documento en una colección en una base de datos MongoDB. ¿Cuál es la mejor manera de nombrar la función,

• writeToMongoDB o
• WriteToMongoD ?

El segundo es CamelCase, mientras vi a alguien usando el estilo del primero, así que no estoy seguro de cuál es el más apropiado. Gracias.

Answer 1

Sintaxis

En Go esto no es una cuestión de estilo, es una cuestión de sintaxis.

Los nombres exportados (es decir, los identificadores que se pueden usar de un paquete diferente al que se define) comienzan con una letra mayúscula. Por lo tanto, si su método es parte de su API pública, debe escribirse:

WriteToDB

pero si es un método interno de ayuda, debe escribirse:

writeToDB

La ventaja de hacerlo de esta manera sobre el uso de palabras clave para definir la exportación ( extern , public , etc.) es que al convertirlo en parte del nombre se garantiza que en cualquier lugar que se use un identificador se puede saber si se exporta o no sin tener que encontrarlo. donde se definió (para ver si la definición contiene una palabra clave).

Ver también: golang.org/ref/spec#Exported_identifiers de la especificación.

i18n

Debido a que Go está codificado en UTF-8 y admite cualquier carácter Unicode con la propiedad de letras o números en los nombres de identificadores, algunas personas en entornos locales que no tienen un concepto de caso pueden tener problemas para crear métodos exportados (el valor predeterminado es no exportado). En este caso (intencionalmente), es común prefijar los identificadores con una X para indicar la exportación. Por ejemplo: X日本語

Ver también: ¿Qué pasa con los identificadores Unicode? de las preguntas frecuentes

Estilo

En lo que se refiere al estilo general, es usar siempre una funda de camello (excepto la primera letra, como se mencionó anteriormente). Esto incluye constantes, funciones y otros identificadores. Entonces, por ejemplo, una lista de constantes (exportadas) podría verse como:

const (
    StateConnected = iota
    StateError
    StateDone

    internalStateMask = 0x2 
)

Además, las abreviaturas siempre se escriben con el mismo caso, por lo que escribiría uno de los siguientes:

dbWrite
writeDB

En lugar de writeDb o DbWrite .

Answer 2

En Go, es convencional usar un límite mixto. De los documentos: https://golang.org/doc/effective_go.html#mixed-caps

Finalmente, la convención en Go es usar MixedCaps o mixedCaps en lugar de guiones bajos para escribir nombres de varias palabras.

Tenga en cuenta que los nombres de nivel de archivo que comienzan con mayúscula se exportan a nivel de paquete: https://golang.org/doc/effective_go.html#Getters

Además, es una convención escribir acrónimos en mayúsculas. Así que abajo está bien:

writeToMongoDB // unexported, only visible within the package

o

WriteToMongoDB // exported

Y no:

writeToMongoDb

Answer 3

En Golang, cualquier variable (o una función) con un identificador que comience con una letra mayúscula (ejemplo, CamelCase) se hace pública (accesible) para todos los otros paquetes en su programa, mientras que las que comienzan con una letra minúscula (ejemplo) , camelCase) no es accesible a ningún paquete excepto al que se está declarando.

Debería usar CamelCase en caso de que pretenda usar la variable (o función) en otro paquete, o puede quedarse con camelCase.

Answer 4

Nombres

Los nombres son tan importantes en Go como en cualquier otro idioma. Incluso tienen un efecto semántico: la visibilidad de un nombre fuera de un paquete está determinada por si su primer carácter es mayúscula . Por lo tanto, vale la pena dedicar un poco de tiempo a hablar sobre la convención de nombres en los programas Go.

Nombres de paquete

Cuando se importa un paquete, el nombre del paquete se convierte en un elemento de acceso para los contenidos. Después

importar "bytes" el paquete de importación puede hablar de bytes.Buffer. Es útil si todos los que usan el paquete pueden usar el mismo nombre para referirse a su contenido, lo que implica que el nombre del paquete debe ser bueno: breve, conciso, evocador. Por convención, a los paquetes se les asignan minúsculas, nombres de una sola palabra; no debería haber necesidad de guiones bajos o Capas mixtas . Echa un vistazo a la brevedad, ya que todos los que usen tu paquete escribirán ese nombre. Y no te preocupes por las colisiones a priori. El nombre del paquete es solo el nombre predeterminado para las importaciones; no es necesario que sea único en todo el código fuente, y en el caso poco frecuente de una colisión, el paquete de importación puede elegir un nombre diferente para usar localmente. En cualquier caso, la confusión es rara porque el nombre del archivo en la importación determina qué paquete se está utilizando.

Otra convención es que el nombre del paquete es el nombre base de su directorio de origen; el paquete en src / encoding / base64 se importa como "encoding / base64" pero tiene el nombre base64, no encoding_base64 y no encodingBase64.

El importador de un paquete usará el nombre para referirse a su contenido, por lo que los nombres exportados en el paquete pueden usar ese hecho para evitar el tartamudeo. (No use la notación de importación, que puede simplificar las pruebas que deben ejecutarse fuera del paquete que están probando, pero se debe evitar). Por ejemplo, el tipo de lector en búfer en el paquete bufio se llama Reader, no BufReader, porque los usuarios lo ven como bufio.Reader, que es un nombre claro y conciso. Además, dado que las entidades importadas siempre se direccionan con su nombre de paquete, bufio.Reader no entra en conflicto con io.Reader. De manera similar, la función para crear nuevas instancias de ring.Ring, que es la definición de un constructor en Go, normalmente se llamará NewRing, pero como Ring es el único tipo exportado por el paquete, y dado que el paquete se llama ring, es Llamado simplemente Nuevo, que los clientes del paquete ven como anillo. Nuevo. Usa la estructura del paquete para ayudarte a elegir buenos nombres.

Otro ejemplo corto es una vez.Do; una vez. Do (configuración) lee bien y no se mejorará escribiendo una vez. DoOrWaitUntilDone (configuración). Los nombres largos no hacen que las cosas sean más legibles automáticamente. Un comentario de doc útil a menudo puede ser más valioso que un nombre extralargo .

Getters

Go no proporciona soporte automático para getters y setters. No hay nada de malo en proporcionar a los captadores y fijadores usted mismo, y a menudo es apropiado hacerlo, pero no es ni idiomático ni necesario poner a Get en el nombre del adquiridor. Si tiene un campo llamado owner (minúscula , no exportada), el método getter debe llamarse Owner (mayúscula, exportada), no GetOwner . El uso de nombres en mayúsculas para la exportación proporciona el gancho para discriminar el campo del método. Una función de establecimiento, si es necesaria, probablemente se llamará SetOwner . Ambos nombres leen bien en la práctica:

owner := obj.Owner()
if owner != user {
    obj.SetOwner(user)
}

Nombres de interfaz

Por convención, las interfaces de un método se nombran por el nombre del método más un sufijo -er o una modificación similar para construir un nombre de agente: Reader, Writer, Formatter, CloseNotifier, etc.

Hay varios de esos nombres y es productivo honrarlos y los nombres de funciones que capturan. Lectura, escritura, cierre, descarga, cadena, etc. tienen firmas y significados canónicos. Para evitar confusiones, no le dé a su método uno de esos nombres a menos que tenga la misma firma y significado. Por el contrario, si su tipo implementa un método con el mismo significado que un método de un tipo conocido, asígnele el mismo nombre y firma; llame a su método de conversión de cadenas String not ToString .

MixedCaps

Finalmente, la convención en Go es usar MixedCaps o mixedCaps en lugar de guiones bajos para escribir nombres de varias palabras .

ref: eficaz ir