Notación cafesito

Con estas instrucciones te aseguro que vas a razonar cualquier código de programación 3 veces más rápido.

Diferenciar variables

Es necesario reconocer cuáles son variables de otras cosas; aunque un lenguaje ya tenga creada ciertas variables, nuestras variables, las que creamos, deben reconocerse rápidamente. Propongo utilizar prefijo _ (subguión, guión bajo, barra baja; como quieras llamarle).

```javascript
let _suNombre = "Enrico Palazzo" ;
printf( "Bienvenido %s", _suNombre );
```

La idea surgió de PHP, lenguaje en que para todas las variables es obligatorio tener $. En JavaScript es válido generar una variable con $ de prefijo, pero en los otros lenguajes de programación no son caracteres válidos. Es por eso que propongo utilizar el subguión.

Nombramiento de funciones y sus parámetros

Lo primero es reconocer las funciones. De hecho, toda función al ejecutarse debe aplicarse un par de paréntesis (excepto en Pascal y en Basic). Por ejemplo sqrt(225), reconocemos que la función se llama sqrt por sus paréntesis. Sin embargo, muchos lenguajes permiten que nosotros programadores podamos crear nuestras propias funciones, y que eventualmente utilicemos las funciones mediante su referencia (como en funciones de callback), y en ellas si no vemos los paréntesis no nos daremos cuenta que son funciones.

Propongo crear las funciones con prefijo fn:

```javascript
function fnMiFuncion( _dadoValor1, _dadoValor2 ) {
  let _auxiliar = _dadoValor1*23 + _dadoValor2 ;
  alert( _auxiliar );
  return _auxiliar ;
}

let _timer = setTimeout( 
  fnMiFuncion
  , 3000
  , 3, 2 
) ;

```

Acá hemos creado una función, fnMiFuncion, que reconocemos que es una función porque... Se creó con la palabra clave function, y tiene como prefijo las letras fn. Sin estas letras al ejecutar la función setTimeout() tardamos más en reconocer que el primer parámetro debe ser una función.

Notemos también sobre los parámetros. Cuando ejecutamos una función hay que "darle" valores a la función. Es por eso que los parámetros son un tipo de variables que además les agrego como prefijo la palabra "dar" conjugada.

Podría haberse llamado el _dadoValor2 como _dadaSuma.

Por último, respecto de funciones, al ejecutar si anotamos los parámetros dados en distintos renglones, con las comas al principio de cada renglón, es mejor. Esto lo digo desde la experiencia de dar clases en un pizarrón finito. Muchas veces no vemos la coma del final, y si no sabemos del tema quizás se piense que no hace falta colocar una coma.

Identificación de elementos de la página web

Según el motor de JavaScript de navegador, si un objeto de la página web está identificado siguiendo las reglas de identificación (nombramiento) de variables de JavaScript, automáticamente genera una variable que apunta al objeto y que lo podamos controlar.

La idea es evitar ejecutar la función de búsqueda document.getElementById() lo más que podamos. Es por eso que propongo que cada elemento HTML identificado que querramos controlar tenga de prefijo en su ID las letras "id".

```html
<input id="idNombreUsuario" name="nmNombreUsuario" placeholder="Escribí acá tu nombre" />
```

Que si queremos controlarlo podemos encontrar algo como...

```javascript
let _elInput = document.getElementById( "idNombreUsuario" );
alert( "Bienvenido " + _elInput.value );
```

Podríamos evitar un proceso extra con...

```javascript
alert( "Bienvenido " + idNombreUsuario.value );
```

Y en formuarios al enviar los datos al aplicar Submit, se enviará el NAME de cada input. Ponerle prefijo nm para el NAME de estos elementos me hubiera servido al aprender todo esto, y como digo lo hubiera aprendido 3 veces más rápido.

Por ejemplo:

```html
<input id="idOpcion1" name="nmOpcionEdad" value="1" /> Entre 12 y 19 años <br />
<input id="idOpcion2" name="nmOpcionEdad" value="2" /> Entre 20 y 40 años <br />
<input id="idOpcion3" name="nmOpcionEdad" value="3" /> Más de 40 años <br />

```

En SQL

Como SQLite permite varias cosas, recomiendo éstas.

• Al nombrar una tabla, prefijo T mayúscula.

  CREATE TABLE TPersonal (...)

• Al nombrar un campo, prefijo _ (subguión).

   ( _id INTEGER PRIMARY KEY AUTOINCREMENT, _nombre TEXT ...)

Facilitar reconocer el tipo entregado en una instrucción

La idea es la siguiente. Tengo una operación entre funciones y operadores de datos. Al finalizar el renglón, explicar con comentarios qué es lo que termina devolviendo ese renglón

```javascript
let _sueldo = parseFloat(  prompt( "Cuánto ganás por mes" )  )
  ; // Número decimal
let _bono = 
  _sueldo > 4000
  ? 10/100*_sueldo
  : 2/100*_sueldo
; // Número con decimales
printf( 
  "Para tu sueldo de $%1.2f tenés un bono de $%1.2f"
  , _sueldo
  , _bono 
); // Acción
```

También notar que al ejecutar una función, lo que vaya dentro de los paréntesis debe estar separado de estos por tantos espacios como sub-funciones se apliquen. La función prompt() como no tiene otra función ejecutándose dentro tiene 0 ó 1 espacio entre su parámetro y sus paréntesis. Y la función parseFloat(), como sí lo tiene, tiene entre su parámetro y los paréntesis, 2 espacios de cada lado.

For

Para los bucles y extracción de elementos de una lista, generamos las variables con prefijos _cada y _este.

```javascript
let _misNumeros = [ 3, 4, -3, 44, 0x2, 034 ] ;
for( 
  let _cadaUno = 0 
  ; _cadaUno < _misNumeros.length 
  ; _cadaUno++ 
) {
  _esteNumero = _misNumeros[_cadaUno] ;
  alert( "Mi número es " + _esteNumero ) ;
}
// También podríamos
for( _cadaNumero of _misNumeros ) {
  alert( "Mi número es " + _cadaNumero ) ;
}
// También podríamos
_misNumeros.forEach(
  function( _cadaNumero, _suOrden, _todos ) {
    alert( "Mi numero es " + _cadaNumero ) ;
  }
);
```