Convenio de denominación Camel Case, Kebab Case & Snake Case
¿Cuáles son las convenciones de nomenclatura de variables definidas durante la codificación? Reglas para nombres de variables formados por combinaciones de 2 o más palabras;
Convenio de denominación | Formato |
---|---|
Camel Case (Lower Camel Case, Dromedary Case) | camelCase |
Kebab Case (Dash Case, Lisp Case, Spinal Case) | kebab-case |
Snake Case (Pothole Case) | snake_case |
Pascal Case (Upper Camel Case, Studly Case) | PascalCase |
Flat Case | flatcase |
Upper Flat Case | UPPERFLATCASE |
Screaming Snake Case (Macro Case, Constant Case) | SCREAMING_SNAKE_CASE |
Camel Snake Case | camel_Snake_Case |
Pascal Snake Case | Pascal_Snake_Case |
Train Case (HTTP Header Case) | Train-Case |
Cobol Case (Screaming Kebab Case) | COBOL-CASE |
Convenio de denominación
Camel Case
También se le conoce como camel case, lower camel case y dromedary case», que es uno de los formatos de definición de variables más utilizados.
La primera letra de la primera palabra del nombre de la variable a formar por la combinación de 2 o más palabras se escribe de forma contigua, con la primera letra de la segunda palabra en mayúscula.
La variante creada se llama camel case porque se asemeja a la forma de la espalda de un camello.
let juniorToExpert
Kebab Case
También se conoce como kebab case, dash case, lisp case, spinal case, que es otra estructura de convención de nomenclatura común.
Se escribe separando las palabras del nombre de la variable a crear con un carácter «-«.
Esta estructura se llama kebab case porque se asemeja a un kebab con una botella. Esta estructura tiene varios nombres, pero se la conoce más comúnmente como el kebab case.
let junior-to-expert
Snake Case
Otra estructura de convención de código ampliamente utilizada, el snake case también se conoce como el pothole case.
Se escribe separando las palabras o caracteres que conformarán el nombre de la variable con un carácter «_».
let junior_to_expert
Flat Case
Flat case es una estructura de convención variable creada al combinar los caracteres o palabras que componen la variable con letras minúsculas tal como son.
let juniortoexpert
Pascal Case
Se forma combinando las palabras que componen la variable una al lado de la otra de modo que las primeras letras estén en mayúscula. Aunque más comúnmente conocido como pascal case, también se conoce como upper camel case y studly case.
let JuniorToExpert
Upper Flat Case
Se forma usando todas las letras de las palabras como letras mayúsculas y combinándolas al definir la variable.
let JUNIORTOEXPERT
Screaming Snake Case
Se forma utilizando todas las letras mayúsculas de las palabras que componen el nombre de la variable y combinándolas con un guión bajo (_). Aunque generalmente se conoce como el screaming snake case, también se le conoce como el macro case y el constant case.
let JUNIOR_TO_EXPERT
Camel Snake Case
El camel snake case, que es una combinación de las reglas snake case y camel case, se forma usando la primera letra de la primera palabra de las palabras que componen la variable, en minúsculas la primera letra del otras palabras, y separando estas palabras con un guión bajo (_).
let junior_To_Expert
Pascal Snake Case
El pascal snake case, que se forma mediante la combinación de las reglas snake case y pascal case, se forma poniendo en mayúscula las primeras letras de las palabras que componen la variable y separando estas palabras con un guión bajo (_).
let Junior_To_Expert
Train Case
El train case, que está formado por la combinación de las reglas kebab case y pascal case, también se conoce como HTTP header case. Se forma poniendo en mayúscula las primeras letras de las palabras que componen la variable y separando estas palabras con un guión (-).
let Junior-To-Expert
Cobol Case
El cobol case, que es una combinación de las reglas del upper flat case y el kebab case, también se conoce como el screaming kebab case. Las palabras que componen el nombre de la variable están todas en mayúsculas y separadas por un guión (-).
let JUNIOR-TO-EXPERT
Uso de convenciones de nomenclatura en lenguajes de software
Convención de nomenclatura Swift
Camel case, pascal case
Convención de nomenclatura Kotlin
Camel case
Fuente:
https://en.wikipedia.org/wiki/Naming_convention_(programming)