Sintaxis Básica y Variables

Estructura básica de un programa JavaScript

Un programa JavaScript puede estar compuesto por:

• Declaraciones
• Expresiones
• Comentarios
• Variables y constantes
• Operadores
• Funciones
• Objetos

Cada instrucción en JavaScript suele terminar con un punto y coma (;), aunque en muchos casos es opcional debido a la inserción automática de punto y coma (ASI).

// Esto es un programa JavaScript simple
let mensaje = "Hola mundo";  // Declaración de variable
console.log(mensaje);        // Llamada a función

Comentarios en JavaScript

Los comentarios son notas que el programador añade al código para explicar su funcionamiento. No se ejecutan y son ignorados por el intérprete de JavaScript.

Comentarios de una línea

Se utilizan para comentarios breves y se crean con dos barras diagonales:

// Este es un comentario de una línea
let x = 5; // También puede ir después de una instrucción

Comentarios multilínea

Se utilizan para comentarios más extensos y se crean con una barra diagonal seguida de un asterisco para abrir y un asterisco seguido de una barra diagonal para cerrar:

/* Este es un comentario
   que ocupa múltiples líneas
   y puede ser tan largo como necesites */
let y = 10;

Comentarios de documentación

Aunque JavaScript no tiene un formato oficial para comentarios de documentación como JavaDoc, muchas herramientas como JSDoc utilizan un formato similar:

/**
 * Calcula la suma de dos números
 * @param {number} a - El primer número
 * @param {number} b - El segundo número
 * @returns {number} La suma de a y b
 */
function suma(a, b) {
    return a + b;
}

Variables y constantes

Las variables son "contenedores" para almacenar datos en la memoria que pueden ser utilizados y modificados durante la ejecución del programa.

Declaración de variables

JavaScript ofrece tres formas de declarar variables:

1. var (tradicional, menos recomendada actualmente)

var edad = 25;
var nombre = "Juan";
var esMayorDeEdad = true;

Características de var:

• Tiene ámbito de función o global
• Permite redeclaración
• Puede ser utilizada antes de su declaración (hoisting)

2. let (introducida en ES6, recomendada para variables)

let edad = 25;
let nombre = "Juan";
let esMayorDeEdad = true;

Características de let:

• Tiene ámbito de bloque
• No permite redeclaración en el mismo ámbito
• No puede ser utilizada antes de su declaración (temporal dead zone)

3. const (introducida en ES6, para valores constantes)

const PI = 3.14159;
const NOMBRE_USUARIO = "admin";
const COLORES = ["rojo", "verde", "azul"];

Características de const:

• Tiene ámbito de bloque
• No permite reasignación
• Para objetos y arrays, no permite reasignar la referencia, pero sí modificar su contenido
• No puede ser utilizada antes de su declaración

Declaración vs. Inicialización

Puedes declarar una variable sin asignarle un valor inicial (excepto con const):

let contador;        // Declaración (valor es undefined)
contador = 1;        // Inicialización

// También puedes hacer ambas cosas a la vez:
let total = 0;       // Declaración e inicialización

Tipos de datos primitivos

JavaScript tiene 7 tipos de datos primitivos:

1. Number

Representa tanto números enteros como decimales:

let entero = 42;
let decimal = 3.14;
let negativo = -10;
let exponencial = 2.5e6;    // 2.5 millones
let binario = 0b1010;       // 10 en decimal
let octal = 0o744;          // 484 en decimal
let hexadecimal = 0xFF;     // 255 en decimal

También incluye valores especiales:

• Infinity: representa el infinito matemático
• -Infinity: representa el infinito negativo
• NaN: "Not a Number", resultado de operaciones inválidas

2. String

Representa texto y se define con comillas simples, dobles o backticks:

let nombre = "María";
let apellido = 'López';
let direccion = `Calle Principal 123`;  // Template literal (ES6)

// Strings multilínea con template literals
let mensaje = `Hola ${nombre},
Bienvenido a nuestro sitio.
Gracias por registrarte.`;

3. Boolean

Representa un valor lógico: verdadero o falso:

let esMayorDeEdad = true;
let tieneDescuento = false;

4. Undefined

Representa una variable que ha sido declarada pero no inicializada:

let variableSinValor;
console.log(variableSinValor);  // undefined

5. Null

Representa la ausencia intencional de cualquier valor:

let datoVacio = null;

6. Symbol (introducido en ES6)

Representa un identificador único e inmutable:

let id = Symbol("id");
let otroId = Symbol("id");
console.log(id === otroId);  // false, son símbolos diferentes

7. BigInt (introducido en ES2020)

Representa números enteros de precisión arbitraria:

let numeroGrande = 9007199254740991n;  // El sufijo 'n' crea un BigInt
let otroGrande = BigInt("9007199254740991");

Conversión y coerción de tipos

JavaScript permite convertir valores de un tipo a otro de dos maneras:

Conversión explícita (type casting)

El programador convierte intencionalmente un tipo a otro:

// Conversión a String
let num = 42;
let str1 = String(num);       // "42"
let str2 = num.toString();    // "42"

// Conversión a Number
let str = "42";
let num1 = Number(str);       // 42
let num2 = parseInt(str);     // 42 (entero)
let num3 = parseFloat("3.14"); // 3.14 (decimal)

// Conversión a Boolean
let bool1 = Boolean(1);       // true
let bool2 = Boolean("");      // false

Coerción implícita (type coercion)

JavaScript convierte automáticamente los tipos en ciertas operaciones:

// Coerción a String
console.log("El número es: " + 42);  // "El número es: 42"

// Coerción a Number
console.log("5" - 2);  // 3 (string "5" se convierte a number)
console.log("5" + 2);  // "52" (aquí el 2 se convierte a string)

// Coerción a Boolean
if ("texto") {
    // "texto" se convierte a true
    console.log("Este texto se imprimirá");
}

Nombrado de variables y mejores prácticas

Reglas para nombrar variables

1. Pueden contener letras, dígitos, guiones bajos y el signo de dólar
2. Deben comenzar con una letra, $ o _
3. Son sensibles a mayúsculas y minúsculas (case-sensitive)
4. No pueden ser palabras reservadas (como if, function, return, etc.)

Convenciones de nomenclatura

camelCase (recomendada para variables y funciones)

let nombreCompleto = "Juan Pérez";
let esUsuarioActivo = true;
function calcularTotal() { /* ... */ }

PascalCase (para clases y constructores)

class Usuario { /* ... */ }
function Producto() { /* ... */ }

SNAKE_CASE_MAYÚSCULAS (para constantes importantes)

const PI = 3.14159;
const URL_API = "https://api.ejemplo.com";

Mejores prácticas

1. Usa nombres descriptivos:

   // Mal
   let x = 5;
   
   // Bien
   let edadUsuario = 5;
   

2. Evita nombres demasiado cortos o largos:

   // Demasiado corto
   let n = "Juan Pérez";
   
   // Demasiado largo
   let nombreCompletoDelUsuarioRegistradoEnElSistema = "Juan Pérez";
   
   // Adecuado
   let nombreUsuario = "Juan Pérez";
   

3. Usa constantes para valores que no cambian:

   const SEGUNDOS_POR_DIA = 86400;
   

4. Prefiere let y const sobre var:

   // Evitar
   var contador = 1;
   
   // Preferir
   let contador = 1;
   const PI = 3.14;
   

5. Declara variables al principio de su ámbito:

   function calcularArea() {
       // Variables declaradas al principio
       let ancho = 10;
       let alto = 5;
       
       // Resto de la función
       return ancho * alto;
   }
   

6. Evita variables globales innecesarias:

   // Evitar
   totalGlobal = 100;  // Sin let, se convierte en global
   
   // Preferir
   let total = 100;  // Variable local
   

Resumen

• JavaScript tiene una sintaxis sencilla con declaraciones que terminan en punto y coma (opcional)
• Los comentarios ayudan a documentar el código (// para una línea, /* */ para múltiples)
• Hay tres formas de declarar variables: var, let y const, con diferentes comportamientos
• JavaScript tiene 7 tipos de datos primitivos: Number, String, Boolean, Undefined, Null, Symbol y BigInt
• Los tipos pueden convertirse explícitamente o implícitamente (coerción)
• Es importante seguir buenas prácticas de nomenclatura para mantener el código legible y mantenible