JS Recomendaciones

Estructura de Código

ES ALTAMENTE RECOMENDABLE delimitar cada instrucciones/declaracion con un punto y coma ;

<script>
alert('Hola'); alert('Mundo');
</script>

La mayoría de las guías de estilo de código coinciden en que debemos poner un punto y coma después de cada declaración.

Los puntos y comas no son necesarios después de los bloques de código {...} y los constructores de sintaxis como los bucles:

<script>
function f() 
{
  // no se necesita punto y coma después de la declaración de función
}

for(;;) 
{
  // no se necesita punto y coma después del bucle
}
</script>

…Pero incluso si colocásemos un punto y coma “extra” en alguna parte, eso no sería un error. Solo sería ignorado.

Variables

Se pueden declarar usando:

var : estilo antiguo
let : estilo moderno
const : constante que no se puede cambiar

Un nombre de variable puede incluir:

Letras y dígitos, pero el primer carácter no puede ser un dígito.
Los caracteres $ y _ son normales, al igual que las letras.
Los alfabetos y jeroglíficos no latinos también están permitidos, pero comúnmente no se usan.
Pueden almacenar cualquier valor.

Hay 8 tipos de datos

number : tanto para números de punto flotante como enteros.
bigint : para números enteros de largo arbitrario.
string : para textos.
boolean : para valores lógicos true/false.
null : un tipo con el valor único null, que significa “vacío” o “no existe”.
undefined : un tipo con el valor único undefined, que significa “no asignado”.
object y symbol : para estructuras de datos complejas e identificadores únicos.

El operador typeof devuelve el tipo de un valor, con dos excepciones:

<script>
typeof null == "object" // error del lenguaje
typeof function(){} == "function" // las funciones son tratadas especialmente
</script>

Interacción

Al utilizar un navegador web como entorno de trabajo, las funciones básicas de la interfaz de usuario serán:

prompt(question, [default])

Hace una pregunta question, y devuelve lo que ingresó el visitante o null si presiona “cancelar”.

confirm(question)

Hace una pregunta question, y sugiere elegir entre Aceptar y Cancelar. La elección se devuelve como booleano true/false.

alert(message)

Muestra un message.

Todas estas funciones son modales, pausan la ejecución del código y evitan que el visitante interactúe con la página hasta que responda.

Codigo

<script>
let userName = prompt("¿Su nombre?", "Alice");
let isTeaWanted = confirm("¿Quiere té?");

alert( "Visitante: " + userName ); // Alice
alert( "Quiere té: " + isTeaWanted ); // true
</script>

Operadores

Aritméticos

Los normales: * + - /, también % para los restos y ** para aplicar potencia de un número.

El binario más + concatena textos. Si uno de los operandos es un texto, el otro también se convierte en texto:

<script>
alert( '1' + 2 ); // '12', texto
alert( 1 + '2' ); // '12', texto
</script>

Condicional

El único operador con 3 parámetros: cond ? resultA : resultB. Sí cond es verdadera, devuelve resultA, de lo contrario resultB.

Logicos

Los operadores lógicos AND && y OR || realizan una evaluación de circuito corto y luego devuelven el valor donde se detuvo (no necesariamente true/false). El operador lógico NOT ! convierte el operando a tipo booleano y devuelve el valor inverso.

Comparaciones

Para verificar la igualdad == de valores de diferentes tipos, estos se convierten a número (excepto null y undefined que son iguales entre sí y nada más), por lo que son iguales:

<script>
alert( 0 == false ); // true
alert( 0 == '' ); // true
</script>

Igualdad estricta

El operador de igualdad estricta === no realiza la conversión: diferentes tipos siempre significan diferentes valores.

Los valores null y undefined son especiales: son iguales == el uno al otro y no cumplen con la igualdad estricta

<script>
  console.log( null == undefined ); // Especial vs Especial : true
  console.log( null === undefined ); // false
  console.log( '1' === 1 ); // String vs Number : false      
</script>

BUCLES

3 Tipos

Codigo

<script>
// 1
while (condicion) 
{
  ...
}

// 2
do 
{
  ...
} while (condicion);

// 3
for(let i = 0; i < 10; i++) 
{
  ...
}
</script>

La variable declarada en el bucle for(let...) sólo es visible dentro del bucle. Pero también podemos omitir el let y reutilizar una variable existente.

Directivas break/continue permiten salir de todo el ciclo/iteración actual. Use etiquetas para romper bucles anidados.

FUNCIONES

3 Formas de crear una funcion en JavaScript

Declaracion de funcion

<script>
function sum(a, b) 
{
  let result = a + b;

  return result;
}
</script>

Expresion de funcion

<script>
let sum = function(a, b) 
{
  let result = a + b;

  return result;
};
</script>

Funciones de flecha

<script>
// sin argumentos
let sayHi = () => alert("Hello");

// con un único argumento
let double = n => n * 2;

// con varios argumentos
let sum = (a, b) => a + b;

// o sintaxis multilínea { ... }, aquí necesita return:
let sum = (a, b) => 
{
  // ... mas codigo .....
  return a + b;
}
</script>

RECOMENDACIONES