La sintaxis de JavaScript se refiere a las reglas y la estructura que indican cómo se escribe el código en el lenguaje.
En JavaScript, el código está compuesto por instrucciones que se ejecutan de forma secuencial, esto es que las instrucciones se ejecutan una tras otra, de arriba hacia abajo, en el orden en que aparecen.
La sintaxis basica vendría siendo:
// Declaración de variables
Cómo c, d, e;
// Asigna un valor a la variable
c = 5;
// Valor informático de las variables
d = c;
e = c / d;
console.log("Método básico de impresión en JavaScript");
También hay valores los cuales son:
Valores fijos: Estos se conocen como literales.
Valores de variables: Estos se llaman variables.
Comenzando por los literales los cuales son fijos y tienen diferentes reglas en la sintaxis:
Los números se pueden escribir con o sin decimales.
Las cadenas son textos que se pueden escribir entre comillas simples o dobles
// Ejemplo
let num1 = 100
let num2 = 100.50
let cadena1 = "Pingüino"
let cadena2 = 'Pinguinos'
console.log(num1)
console.log(num2)
console.log(cadena1)
console.log(cadena2)
Salida:
100
100.50
Pingüino
Pingüinos
Hay variables, que una variable de JavaScript es simplemente el nombre de la ubicación de almacenamiento donde se guardan los datos, siendo globales con alcance fuera de la función y local limitado a cierto lugar como en una función.
Por ejemplo:
// Declara una variable e inicializarla
// Declaración de variable global
let ciudad = "Monterrey";
// Definición de la función
function mostrarUbicacion() {
// Declaración de variable local
let codigoPostal = 1000;
// Muestra el valor de la variable global
console.log(ciudad);
// Muestra el valor de la variable local
console.log(codigoPostal);
}
// Llamada a la función
mostrarUbicacion();
La salida será:
Monterrey
1000
Hay operadores que son símbolos que se utilizan para calcular valores.
Hay aritméticos para calcular valores, hay de asignación para asignar valores a variables y de comparación para comparar valores y determinar la igualdad o diferencia entre ellos
// Declaración de variables
let x, y, suma, esMayor;
// Asignar valor a las variables (Operador de asignación)
x = 3;
y = 23;
// Usar el operador aritmético para
// sumar dos números
suma = x + y;
// Usar el operador de comparación para
// evaluar si y es mayor que x
esMayor = y > x;
console.log(suma);
console.log(esMayor);
Salida será:
26
true
Hay expresiones, que una expresión es una combinación de valores, operadores y variables, se usan para calcular valores.
// Declaración de variables
let x, y, num, suma;
// Asignar valor a las variables
x = 20;
y = 30;
// Expresión para dividir un número
num = x / 2;
// Expresión para sumar dos números
suma = x + y;
console.log(num + "\n" + suma);
La salida es:
10
50
Hay palabras clave que son las palabras reservadas que tienen significados especiales en JavaScript.
// Let declara variables locales
let a, b;
// function declara una función
function miFuncion() {}
JavaScript también tiene diferentes tipos de datos para almacenar distintos valores en las variables, hay datos primitivos y de referencia.
// Almacena datos de tipo string
let texto = "Universidad";
// Almacena datos de tipo number
let a = 5;
let b = 5;
// Almacena datos de tipo booleano
let sonIguales = (a == b); // Devuelve true a la consola
// Comprobación estricta (compara valor y tipo de dato)
let sonEstrictamenteIguales = (a === b); // Devuelve true a la consola
// Almacena datos de tipo array
let elementos = ["Campus", "Laboratorio", "Espejo"];
// Almacena datos de tipo objeto
let estudiante = {
nombre: "Pedro",
apellido: "Mendoza",
edad: 21,
carrera: "Odontología"
};
// Salida en consola para verificar valores
console.log("Texto:", texto);
console.log("Números:", a, b);
console.log("¿Son iguales (==)?:", sonIguales);
console.log("¿Son estrictamente iguales (===)?:", sonEstrictamenteIguales);
console.log("Arreglo:", elementos);
console.log("Objeto:", estudiante);
Salida es:
Texto: Universidad
Números: 5 5
¿Son iguales (==)?: true
¿Son estrictamente iguales (===)?: true
Arreglo: [ 'Campus', 'Laboratorio', 'Espejo' ]
Objeto: { nombre: 'Pedro', apellido: 'Mendoza', edad: 21, carrera: 'Odontología' }
Hay funciones que son bloques de código que se utilizan para realizar operaciones específicas, y aparecen cuando las llamas.
// Definición de la función
function mostrarNumero() {
// Declarar una variable
let num = 45;
// Mostrar el resultado
console.log(num);
}
// Llamada a la función
mostrarNumero();
Salida: 45
Hay identificadores que son nombres que se utilizan para nombrar variables, palabras clave y funciones.
Un identificador debe comenzar con: Una letra (AZ o az), Un signo de dólar ($), Un guion bajo (_)
Siendo que los identificadores de JavaScript distinguen entre mayúsculas y minúsculas.
let primerNombre = "Hola";
let primernombre = 100;
console.log(primerNombre);
console.log(primernombre);
Salida:
Hola
100
Unicode abarca los caracteres, la puntuación y los símbolos.
let año = 2026;
let café = "Americano";
Para los comentarios es:
// Para una línea
/*
Para uno
de varias líneas
*/
Para las variables que te permiten almacenar algún tipo de valor hay 3 formas de declararla:
var: permite declarar una variable que tiene un alcance de nivel global o función.
let: solo va a estar dentro del bloque donde la declares.
const: declarar variable cuyo valor no podrá cambiar una vez que lo pongas dentro. Tambíen solo alcance nivel bloque.
var nombre = "Pedro"; // Variable con var
let edad = 60; // Variable con let
const ciudad = "CDMX"; // Variable con const
console.log(nombre); // Imprime Pedro
console.log(edad); // Imprime 60
console.log(ciudad); // Imprime CDMX
Básicamente son todos los tipos, excepto los objetos, definen valores inmutables.
String:es para cadenas de caracteres.
let cadena = "Hola"; // String
Number:es un valor en formato binario de 64 bits.
let numero = 50; // Number
Booleano:se utiliza para verdadero y falso.
let esVerdadero = true; // Boolean
Null:es la ausencia intencional de cualquier valor, se deja vacío a propósito.
let nulo = null; // null
Undefined:es una variable declarada, pero todavía no se le asigna nada, siendo que JavaScript dice que la variable existe, pero aún no tiene un valor definido.
let indefinido; // undefined
Symbol:es un tipo de dato que permite crear valores únicos, que pueden utilizarse como identificadores, como si fueran una huella que distingue un valor de otro.
let simbolo = Symbol('id'); // Symbol
BigInt:con BigInts, puedes almacenar y operar de forma segura con números enteros grandes.
let grande = 12345678901890n; // BigInt
Un objeto se usa para trabajar con personas, productos o usuarios, que pueden llegar a tener varias propiedades y comportamientos, siendo que los objetos permiten almacenar información de una manera estructurada y acceder a ellos por claves.
Se entiende por clave - valor, en donde clave es string y valor cualquier tipo de dato.
const persona = {
nombre: "Ledezma",
edad: 45,
profesion: "Programador",
hobbies: ["programar", "leer", "viajar"]
};
Se puede acceder a los valores de un objeto utilizando la sintaxis de punto o la sintaxis de corchetes.
console.log(persona.nombre); // Output:"Ledezma"
console.log(persona["edad"]); // Output:45
Un array es una colección ordenada de elementos, donde cada elemento se identifica por un índice numérico, son útiles para manejar colecciones de elementos homogéneos, como una lista de tareas, un conjunto de imágenes o una serie de valores numéricos.
const colores = ["rojo", "verde", "azul"];
Puedes acceder a los elementos de un array utilizando su índice, que va desde cero.
console.log(colores[0]); // Output: "rojo"
console.log(colores.length); // Output: 3
Los operadores son símbolos especiales que nos sirven para hacer operaciones, comparar valores o juntar condiciones en el código.
Los aritméticos son los de operaciones básicas, como la suma +, la resta -, la multiplicación *, la división /, el residuo o módulo % y la potencia **.
let precio = 10;
let cantidad = 3;
let total = precio * cantidad;
console.log(total); // 30
Los relacionales sirven para comparar dos valores, y al hacerlo siempre te van a regresar un booleano, o sea true o false según se cumpla, como la igualdad estricta ===, la desigualdad estricta !==, mayor que >, menor que <, mayor o igual >= y menor o igual <=.
let edad = 18;
let puedeVotar = edad >= 18;
console.log(puedeVotar); // true
Y ya por otro lado los lógicos se usan para juntar varias condiciones o invertirlas, devolviendo true o false, como el como el AND lógico && que da verdadero solo si todo se cumple, el OR lógico || que da verdadero si al menos uno se cumple, y el NOT lógico ! que le cambia el valor a lo contrario.
let tieneDinero = true;
let tieneTiempo = false;
let vaAlCine = tieneDinero && tieneTiempo;
console.log(vaAlCine); // va a dar false
Universidad Politécnica de Victoria Tarea N2 JS Abdiel Gerardo Alonso Herrera 2530150
