Convenciones de nomenclatura: Camel, Pascal, Kebab y Snake case

Introducción

Si estudias programación, es probable que te encuentres en todo momento nombrando cosas, como variables, clases, métodos, funciones y mucho más. ¿Pero será que existe alguna convención para ayudar en este proceso de nombramiento?

Hay diversas maneras de aplicar las buenas prácticas en tu código, una de ellas es la convención de nomenclatura, que son recomendaciones para nombrar identificadores ayudando a que su código sea más limpio y sencillo de comprender, manteniendo un patrón para el lector e incluso proporcionando información sobre la función del identificador.

Además, podemos encontrar otros lenguajes, como Go, que dependen mucho de que conozcas la diferencia entre los casos de uso, ya que la convención utilizada en el nombre también tiene un efecto semántico.

Ahora, vamos a conocer los cuatro tipos más comunes de convenciones de nomenclatura para combinar palabras en una única cadena (string). ¡Hagámoslo!

Camel case

En Camel case debes empezar con la primera letra minúscula y la primera letra de cada nueva palabra subsecuente en mayúscula:

cosasParaHacer

edadDelAmigo

valorFinal

Pascal case

También conocido como "upper camel case" o "capital case", Pascal case combina palabras poniéndolas todas con la primera letra en mayúscula:

CosasParaHacer

EdadDelAmigo

ValorFinal

Snake case

En Snake case, conocido también como "underscore case", se utiliza guión bajo (underscore) en lugar de espacio para separar las palabras. Cuando snake case está en mayúsculas, se le conoce como "screaming snake case":

cosas_para_hacer

edad_del_amigo

valor_final

PRIMER_NOMBRE

LISTA_INICIAL

Kebab case

En Kebab case se utiliza el guión para combinar las palabras. Cuando el Kebab case está en mayúsculas, se llama "screaming kebab case":

cosas-para-hacer

edad-del-amigo

valor-final

PRIMER-NOMBRE

LISTA-INICIAL

Convenciones Java

Java tiene el Java Secure Coding Guidelines, una documentación disponible por Oracle, basada en los patrones de codificación presentados en el Java Language Specification. Es importante destacar que estas convenciones de código Java se escribieron en 1999 y no se han actualizado desde entonces, por lo que alguna información contenida en el documento puede no estar actualizada. Las convenciones más comunes son:

• camelCase para variables, atributos y métodos;
• PascalCase para clases, enum e interfaces;
• SCREAMING_SNAKE_CASE para constantes.

public class Persona{
    public static void main(String[] args) {

        String primerNombre = "Maria";
        int edad = 22;
        double alturaActual = 1.65;
        final String MENSAGE_PATRON = "Hola";
    }
}

Convenciones JavaScript

Se recomienda usar:

• camelCase para variables, constantes, funciones y métodos;
• PascalCase para clases.

class ClienteBanco {
    constructor(primerNombre, documentoIdentidad) {
      this.primerNombre = primerNombre;
      this.documentoIdentidad = documentoIdentidad;
    }

  exibirPrimerNome(){
     console.log(this.primerNombre);
    }
}

var clienteUno = new ClienteBanco('Maria', 150);
var clienteDos = new ClienteBanco('João', 70);

Convenciones Python

Python tiene una guía de estilo y estructuración, el PEP8, que proporciona convenciones de codificación para el código. Esto no significa que tu código no funcionará si no sigue las directrices, sin embargo, según el PEP 20 -- The Zen of Python, la legibilidad cuenta.

Se recomienda usar:

• snake_case para variables, funciones y métodos;
• PascalCase para clases;
• SCREAMING_SNAKE_CASE para constantes.

class Persona:
    def __init__(self, nombre, documento_identidad):
        self.nombre = nombre
        self.documento_identidad = documento_identidad

        def exibir_primer_nombre(self):
        print(self.nombre)

        persona_uno = Persona('Alice', '123456789')

Convenciones Go

Los nombres en el lenguaje Go tienen un efecto semántico, la visibilidad de un identificador fuera de un paquete se determina si el nombre comienza con una letra mayúscula o minúscula, por lo que debemos estar atentos con las convenciones utilizadas. Go también tiene una documentación con excelentes consejos para escribir un código claro, el Effective Go.

Se recomienda usar:

• PascalCase para exportar (accesible fuera del paquete);
• camelCase para internos (no es exportado).

package nombre

type ExportedStruct {
    unexportedField string
}

Convenciones Ruby

El lenguaje Ruby usa el Ruby Style Guide, una guía de estilo que te da buenos consejos para la escritura del código.

Se recomienda usar:

• PascalCase para clases y módulos;
• snake_case para métodos, variables, nombrar archivos y directorios;
• SCREAMING_SNAKE_CASE para constantes.

class Persona

    def initialize(primer_nombre, documento_identidad)
        @primer_nombre = primer_nombre
        @documento_identidad = documento_identidad
    end

    def exibe_primer_nombre
        @primer_nombre
    end
end

persona_uno = Persona.new('Alice', 123456789)

Tabla

Para ayudarte, consulta esta tabla que muestra las principales convenciones de nomenclatura que abordamos en esta lectura.

Conclusión

En este artículo, vimos que cada lenguaje tiene sus propias convenciones de nomenclatura. Inclusive, algunas empresas y proyectos adoptan un patrón a seguir, como por ejemplo Google, que utiliza el Google Style Guides, una guía de estilos para ayudar a los desarrolladores que trabajan en sus proyectos de código abierto.

Las particularidades de cada lenguaje de programación pueden hacer que una convención sea más útil que en otro lenguaje, por lo que es importante estar atento a las convenciones utilizadas en tu proyecto y mantener la consistencia con la elegida.

¿Y tú, qué tal si aplicas esas buenas prácticas en tu código? ¡Buen estudio y hasta la próxima!

Akemi Alice

Monitora en Alura actuando en la Escuela de Programación con enfoque en Java y estudiante de Informática en el Instituto Federal de São Paulo (IFSP).

Este artículo fue adecuado para Alura Latam por: Bruno Souza