Convención de Nombres en los Lenguajes de Programación

4 minuto(s)

En la carrera de Ingeniería de Software, Sistemas, Programación o similares, existen diferentes términos que muchas veces ignoramos, porque solo nos enfocamos en el código o en la parte visual del proyecto, parte de las buenas prácticas en la Programación, es hacer uso de las Convenciones de nombres adecuadas, en este Post te contaré cuales son, como funcionan y otros detalles.

Antes de continuar con este Post te invito a escuchar el Podcast: Si No Tienes Experiencia Para Un Puesto De Trabajo, Créala !

Sound Cloud:

Spotify:

Bien ahora continuemos con el Post: Convención de Nombres en los Lenguajes de Programación.

Cada Lenguaje de Programación o entorno de un proyecto emplea una Convención de nombre especifica, sea para el nombre de un método, una clase y otros elementos del proyecto.

Las convenciones de nombres ayudan a mejorar la lectura del código, entre estas tenemos a la Notación Húngara, Kebab Case, Camel Case, Snake Case y Train Case, a continuación veremos como funciona cada una de ellos.

Notación Húngara

Esta convención de nombre es usada para colocar el nombre a las variables y para darle nombre a las instancias de objetos en el código, se caracteriza por colocar la primera letra en minúscula y el resto en letra capital, veamos el código JavaScript a continuación:


// Nombres de Variables usando 'Notación Húngara' 
pNombre = "Carlos Prado"; 
nPostre = "Torta de Chocolate"; 

console.log(nPostre);
Torta de Chocolate

// Nombres de Variables usando 'Notación Húngara'

pNombre = "Carlos Prado";

nPostre = "Torta de Chocolate";

console.log(nPostre);

Torta de Chocolate

En el código anterior puedes ver que he declarado 2 simples variables llamadas pNombre y nPostre con la Convención de Nombre o el formato Notación Húngara.

Kebab Case

Esta convención de nombre se caracteriza por llevar un guión medio, los elementos que llevan este tipo de formato son las dependencias y URLs amigables muy usadas en SEO o posicionamiento de buscadores, veamos a continuación el archivo package.json de un proyecto con React JS:


{
  "name": "proyectoreactjs",
  "version": "0.1.0",
  "private": true,
  "homepage": "/",
  "dependencies": {
    "bootstrap": "^4.4.1",
    "jquery": "^3.4.1",
    "popper.js": "^1.16.0",
    "react": "^16.12.0",
    "react-dom": "^16.12.0",
    "react-router": "^5.1.2", // Formato 'Kebab Case' 
    "react-router-dom": "^5.1.2", // Formato 'Kebab Case' 
    "react-scripts": "3.1.1"
  }, 
...
...
...

{

"name": "proyectoreactjs",

"version": "0.1.0",

"private": true,

"homepage": "/",

"dependencies": {

"bootstrap": "^4.4.1",

"jquery": "^3.4.1",

"popper.js": "^1.16.0",

"react": "^16.12.0",

"react-dom": "^16.12.0",

"react-router": "^5.1.2", // Formato 'Kebab Case'

"react-router-dom": "^5.1.2", // Formato 'Kebab Case'

"react-scripts": "3.1.1"

...

En el código anterior puedes ver por ejemplo que tenemos varias dependencias como react-router y react-router-dom que usan la convención de nombre o formato Kebab Case.

La URL de una página pueden contener un formato amigable en Kebab Case, por ejemplo la URL de este Post :


// URL con Formato 'Kebab Case' 
blog.nubecolectiva.com/convencion-de-nombres-en-los-lenguajes-de-programacion/

// URL con Formato 'Kebab Case'

blog.nubecolectiva.com/convencion-de-nombres-en-los-lenguajes-de-programacion/

Camel Case

Esta convención de nombre es usada para asignar nombre a las funciones, clases y métodos en el código de un proyecto, también es usado en muchas redes sociales para agrupar publicaciones por medio de nombres de hastags y otros entornos, se caracteriza por tener la forma de las jorobas de un camello, veamos a continuación el siguiente código PHP:


class JugosController extends Controller // El nombre de la clase usa el formato 'Camel Case' 
{
    public function ListarVariosRegistros() // El nombre de la función usa el formato 'Camel Case' 
    {
    	$jugos = Jugos::all();
        $someArray = json_decode($jugos, true);

        dd($someArray);



        return view('admin.jugos.index', compact('jugos', 'ijg', 'ip')); 
    }
 
    public function crearRegistro() // El nombre de la función usa el formato 'Camel Case' 
    {
        $jugos = Jugos::all();
        return view('admin.jugos.crear', compact('jugos'));
    }

...
...
...

class JugosController extends Controller // El nombre de la clase usa el formato 'Camel Case'

{

public function ListarVariosRegistros() // El nombre de la función usa el formato 'Camel Case'

{

$jugos = Jugos::all();

$someArray = json_decode($jugos, true);

dd($someArray);

return view('admin.jugos.index', compact('jugos', 'ijg', 'ip'));

}

public function crearRegistro() // El nombre de la función usa el formato 'Camel Case'

{

$jugos = Jugos::all();

return view('admin.jugos.crear', compact('jugos'));

}

...

En el código anterior puedes ver que estoy usando el formato o convención de nombre Camel Case en el nombre de la clase JugosController, en la función ListarVariosRegistros y en la función crearRegistro.

También se pueden encontrar en varios entornos como en los Hastags, por ejemplo: #soyProgramador, #soyDeveloper, #lenguajesDeProgramación, etc.

Snake Case

Esta convención de nombre se caracteriza por tener un guión en la parte inferior de las letras, este es usado en nombres de variables en algunos Lenguajes de Programación que soportan este formato, por ejemplo veamos a continuación el siguiente código en Java (Android):


public class MainActivity extends AppCompatActivity {

	// La variable UN_IMPORTANTE_MENSAJE usa el formato 'Snake Case' 
        public static final String UN_IMPORTANTE_MENSAJE = "com.example.myfirstapp.MESSAGE";
        
        @Override	
        protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	public void enviarMensaje(View view) {
		Intent intent = new Intent(this, DisplayMessageActivity.class);
		EditText editText = (EditText) findViewById(R.id.editText);
		String message = editText.getText().toString();
		intent.putExtra(UN_IMPORTANTE_MENSAJE, message);
		startActivity(intent);
	}
}

public class MainActivity extends AppCompatActivity {

// La variable UN_IMPORTANTE_MENSAJE usa el formato 'Snake Case'

public static final String UN_IMPORTANTE_MENSAJE = "com.example.myfirstapp.MESSAGE";

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

}

public void enviarMensaje(View view) {

Intent intent = new Intent(this, DisplayMessageActivity.class);

EditText editText = (EditText) findViewById(R.id.editText);

String message = editText.getText().toString();

intent.putExtra(UN_IMPORTANTE_MENSAJE, message);

startActivity(intent);

}

En el código anterior puedes ver que la variable UN_IMPORTANTE_MENSAJE esta usando el formato o convención de nombre Snake Case, es decir usa guiones en la parte inferior de cada palabra.

Train Case

Esta convención de nombre es algo similar a Snake Case, pero este se caracteriza por usar la primera letra en mayúscula de cada palabra, es usado para definir los nombres de las variables en los Lenguajes que soportan este formato, por ejemplo veamos el siguiente código Java (Android) similar al anterior solo que esta vez usamos Train Case:


public class MainActivity extends AppCompatActivity {

	// La variable Un_Importante_Mensaje usa el formato 'Train Case' 
        public static final String Un_Importante_Mensaje = "com.example.myfirstapp.MESSAGE";@Override
	
        protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	public void enviarMensaje(View view) {
		Intent intent = new Intent(this, DisplayMessageActivity.class);
		EditText editText = (EditText) findViewById(R.id.editText);
		String message = editText.getText().toString();
		intent.putExtra(Un_Importante_Mensaje, message);
		startActivity(intent);
	}
}

public class MainActivity extends AppCompatActivity {

// La variable Un_Importante_Mensaje usa el formato 'Train Case'

public static final String Un_Importante_Mensaje = "com.example.myfirstapp.MESSAGE";@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

}

public void enviarMensaje(View view) {

Intent intent = new Intent(this, DisplayMessageActivity.class);

EditText editText = (EditText) findViewById(R.id.editText);

String message = editText.getText().toString();

intent.putExtra(Un_Importante_Mensaje, message);

startActivity(intent);

}

En el código anterior puedes ver que la variable Un_Importante_Mensaje usa el formato o convención de nombre Train Case.

Conclusión

Si usas los formatos o convenciones de nombres correctamente en un Proyecto, vas a tener un código más profesional, que sigue las buenas prácticas y conforme los uses o pongas en práctica, los dominaras y entenderás mejor la importancia de su uso.

Cuéntanos en los comentarios que formato o convención de nombre conocías o usas en tus proyectos.

Nota(s)

No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenido.

Articulos
16-02-2020
11-03-2023
Crear un Post - Eventos Devs - Foro