Cómo nombrar según el tipo de dato

• Arrays: Plural.
• Booleanos: Con prefijos “is”, “has” y “can”. (“es verdadero”, “tiene/contiene x”, “puede hacer x”).
• Números: Con prefijos “min”, “max” y “total”.
• Funciones: Verbo + sustantivo/s (ya que son acciones).
  • …de Acceso: get + sustantivo
  • …de Modificación: set + sustantivo;
  • …de Predicado: is + sustantivo;
• Clases: Sustantivos (no genéricos).

// Arrays: 
const users = ["Alex", "Mariana", Jessica"];

//Booleanos:
const isValid = true;
const hasColor = true;
const canRead = false;

//Números:
const maxUsers = 50;
const minUsers = 10;
const totalUsers = 15;

//Funciones:
createUser();
updateUser();
sendEmail();
//Acceso:
getUser();
//Modificación:
setUser()
//Predicado:
isValidUser();

//Clases:
class User {}
class UserProfile {}
class Account {}

Cómo nombrar variables, funciones y clases según su tipo de dato.

Recordemos que es importante, según las reglas de nomenclatura, no incluir información técnica dentro de los nombres, pero aún así, nuestro código debe ser autodescriptivo; por lo tanto, como buena práctica, desde el nombre, debemos denotar el tipo de dato.

// Arrays: lista de elementos, generalmento del mismo tipo.
// Se recomienda usar el nombre de la variable en plural.

// No recomendado
const user = ["Alex", "Mariana", "Jessica"];

// Regular
const userList = ["Alex", "Mariana", "Jessica"];

// Bueno
const users = ["Alex", "Mariana", "Jessica"];

// Excelente
const userNames = ["Alex", "Mariana", "Jessica"];

// Booleans: solo tiene 2 valores, true o false.
// Se recomienda utilizar ciertos prefijos para identificar las variables: is(¿es?), has(¿tiene?), can(¿puede?).

// No recomendado
const valid = true;
const read = false;
const color = true;

// Recomendado
const isValid = true;
const canRead = false;
const hasColor = true;

// Numbers
// Se recomienda prefijos que hagan referencia a que la variable contiene números como: max, min y total; son autodescriptivas y también hablan de lo que hace el código.

// No recomendado
const users = 15;

// Recomendado
const maxUsers = 50;
const minUsers = 10;
const totalUsers = 15;

// Funciones: representan una acción.
// Se recomienda que inicien con un verbo, seguido de un sustantivo, por ejemplo: get como verbo y name como sustantivo.
// Deben ser concisos y estar en camelCase.

// No recomendado
createUserIfNotExist();
updateUserIfNotEmpty();
sendEmailIfIsValid();

// Recomendado
createUser();
updateUser();
sendEmail();

// Funciones de acceso, modificación o predicado.
// Se recomienda añadir el prefijo de get, set o is.

// Ejemplo
getUser();
setUser();
isValidUser();

// Clases
// Para nombrar clases se recomienda utilizar sustantivos, por ejemplo: user o userProfile, pero se debe evitar utilizar nombres genéricos como: data o manager, porque esto puede llevar a que estas clases tengan más de una sola responsabilidad.
// Según el principio de responsabilidad único tanto una clase como una función deben ser responsables de una sola acción.

// No recomendado
class Data {}
class Manager {}
class Info {}

// Recomendado
class User {}
class UserProfile {}
class Account {}

Éstas cosas uno las infiere en los cursos, pero está bueno aprender las reglas estandarizadas según el Clean Code para buenas prácticas.

NOMENCLATURA SEGÚN TIPO DE DATO

ARRAYS:
plural,
ejemplo: const userNames = [“Ale”, “Ana”, “Aldo”] es decir, tipoPropiedad

BOOLEANOS:
prefijos “is”, “can”, “has”.
ejemplo: const isValid = true; //es valido: si o no
const canRead = false; //puede leerse: si o no
const hasColor = false; //tiene color: si o no

NÚMEROS:
prefijos “min”, “max”, "total"
ejemplo: const maxUsers = 50;
const minUsers = 10;
const totalUsers = 100;

FUNCIONES:
verbo+sustantico, acciones
ejemplo: createUser();
updateUser();
sendEmail();

Otras tipos de funciones:
…de Acceso: getUser();
…de Modificación: setUser();
…de Predicado: isValidUser();

CLASES:
Sustantivos, no generales, dirigidos a fx
ejemplo: User();
UserProfile();
Account();

Cómo nombrar según el tipo de dato

Arrays

Son una lista de elementos por lo general de un mismo tipo, se recomienda usar el nombre de la variable en plural.

// 😡 No recomendado 😡
const user = ['Galeed', 'Evelin', 'Aarón'];

// 😐 Regular 😐
const userList = ['Galeed', 'Evelin', 'Aarón'];

// 🙂 Bueno 🙂
const users = ['Galeed', 'Evelin', 'Aarón'];

// 😊 Recomendado 😊
const userNames = ['Galeed', 'Evelin', 'Aarón'];

Booleanos

Estos solo pueden tener dos estados o dos valores, true o false.

Es recomendable usar ciertos prefijos para identificar a las variables como is, has, can.

// 😡 No recomendado 😡
const valid = true;
const read = false;
const color = true;

// 😊 Recomendado 😊
const isValid = true;
const canRead = false;
const hasColor = true;

Números

Contiene números de cualquier tipo, es comendable agregarlo un prefijo como min, max, total.

// 😡 No recomendado 😡
const users = 15;

// 😊 Recomendado 😊
const maxUsers = 50;
const minUsers = 10;
const totalUsers = 15;

Funciones

Por la naturaleza de estas representan una acción y al representar una acción es por eso que se recomienda que su nombre empiece por un verbo y continúe con un sustantivo. El nombre tiene que ser conciso, es decir, que se espera (en pocas palabras) que haga esa función.

// 😡 No recomendado 😡
createUserIfNotExist();
updateUserIfNotEmpty();
sendEmailIfIsValid();

// 😊 Recomendado 😊
createUser();
updateUser();
sendEmail();

Funciones de acceso

Recomendable utilizar el prefijo get.

Funciones de modificación

Recomendable emplear el prefijo set.

Funciones de predicado

Recomendable utilizar el prefijo is.

// 😊 Recomendado 😊
getUser();
setUser();
isValidUser();

Clases

Para estos es recomendable usar sustantivos. No utilizar nombres genéricos, esto puede llevar a que la clase tenga más de una responsabilidad.

// 😡 No recomendado 😡
class Data {};
class Manager {};
class Infor {};

// 😊 Recomendado 😊
class User {};
class UserProfile {};
class Account {};

Ay por Dioooos, está clase me encanto !! Me volo la cabeza
Libere endorfinaaaas !!! xD la ame. siento que evoluciono jaja

WOW sufrìa como nombrar mis variables, ahora lo sé. 😄