JavaScript 

es un robusto lenguaje de programación que se puede aplicar a un

documento HTML y usarse para crear interactividad dinámica en los sitios web.
Fue inventado por Brendan Eich, cofundador del proyecto Mozilla, Mozilla
Foundation y la Corporación Mozilla.

Puedes hacer casi cualquier cosa con JavaScript. Puedes empezar con pequeñas
cosas como carruseles, galerías de imágenes, diseños fluctuantes, y respuestas a
las pulsaciones de botones. Con más experiencia, serás capaz de crear juegos,
animaciones 2D y gráficos 3D, aplicaciones integradas basadas en bases de datos
¡y mucho más!

JavaScript por sí solo es bastante compacto aunque muy flexible, y los

desarrolladores han escrito gran cantidad de herramientas encima del núcleo del
lenguaje JavaScript, desbloqueando una gran cantidad de funcionalidad adicional
con un mínimo esfuerzo. Esto incluye:

 Interfaces de Programación de Aplicaciones del Navegador (APIs) — APIs

construidas dentro de los navegadores que ofrecen funcionalidades como
crear dinámicamente contenido HTML y establecer estilos CSS, hasta
capturar y manipular un vídeo desde la cámara web del usuario, o generar
gráficos 3D y muestras de sonido.
 APIs de terceros, que permiten a los desarrolladores incorporar
funcionalidades en sus sitios de otros proveedores de contenidos como
Twitter o Facebook.
 Marcos de trabajo y librerías de terceros que puedes aplicar a tu HTML para
que puedas construir y publicar rápidamente sitios y aplicaciones.
Ya que se supone que este artículo es solo una introducción ligera a JavaScript, la
intención no es confundirte en esta etapa hablando en detalle sobre cuál es la
diferencia entre el núcleo del lenguaje JavaScript y las diferentes herramientas
listadas arriba. Puedes aprender todo eso en detalle más tarde, en el Área de
Aprendizaje en MDN, y en el resto de MDN.

Debajo se presentan algunos aspectos del núcleo del lenguaje y también jugarás
con unas pocas características de la API del navegador. ¡Diviértete!

Las variables Java son un espacio de memoria en el que guardamos un determinado valor (o
dato). Para definir una variable seguiremos la estructura:

[privacidad] tipo_variable identificador;

Java es un lenguaje de tipado estático. Por lo cual todas las variables tendrán un tipo de dato
(ya sea un tipo de dato primitivo o una clase) y un nombre de identificador.
El tipo de dato se asignará a la hora de definir la variable. Además, en el caso de que las
variables sean propiedades de objetos tendrán una privacidad.
Ejemplos de variables serían…

int numero = 2;
String cadena = "Hola";
long decimal = 2.4;
boolean flag = true;

Las variables son utilizadas como propiedades dentro de los objetos.

class Triangulo {
private long base;
private long altura;
}

No te preocupes por el concepto de objeto, ya que lo revisaremos más

adelante cuando hablemos de la Programación Orientada a Objetos

Tipos de variables en Java

Dentro de Java podemos encontrar los siguientes tipos de variables:

 Variables de instancia (campos no estáticos), son las variables que están definidas
dentro de un objeto pero que no tienen un modificador de estáticas (static). Suelen
llevar un modificador de visibilidad (public, private, protected) definiéndose.

class Triangulo {
private long base;
private long altura;
}

 Variables de clase (campos estáticos), son aquellas variables que están precedidas
del modificador static. Esto indica que solo hay una instancia de dicha variable. Es
decir, aunque tengamos N objetos de la clase, la variable estática solo se instancia
una vez.

class Triangulo {
static long lados = 3;
}

Si además queremos que el valor no pueda cambiar nunca la definiremos como final.
class Matematicas {
final static long PI = 3.14159;
}

 Variables locales, son variables temporales cuyo ámbito de visibilidad es el método

sobre el que están definidas. No pueden ser accedidas desde otra parte del código. Se
las distingue de las variables de instancia ya que estas no llevan modificadores de
visibilidad delante.

int variable = 2;

 Parámetros, son las variables recibidas como parámetros de los métodos. Su

visibilidad será el código que contenga dicho método.

public Triangulo(long base, long altura){...}

Tipado dinámico
JavaScript es un lenguaje débilmente tipado y dinámico. Las variables en
JavaScript no están asociadas directamente con ningún tipo de valor en particular,
y a cualquier variable se le puede asignar (y reasignar) valores de todos los tipos:

let foo = 42; // foo ahora es un número

foo = 'bar'; // foo ahora es un string

foo = true; // foo ahora es un booleano

Copy to Clipboard

Estructuras y tipos de datos

El último estándar ECMAScript define nueve tipos:

 Seis tipos de datos primitivos, controlados por el operador typeof

o Undefined: typeof instance === "undefined"
o Boolean: typeof instance === "boolean"
o Number: typeof instance === "number"
o String: typeof instance === "string"
o BigInt: typeof instance === "bigint"
 o Symbol: typeof instance === "symbol"
 Null: typeof instance === "object". Tipo primitivo especial que tiene un uso
adicional para su valor: si el objeto no se hereda, se muestra null;
 Object: typeof instance === "object". Tipo estructural especial que no es de
datos pero para cualquier instancia de objeto construido que también se utiliza
como estructuras de datos: new Object, new Array, new Map, new Set,
new WeakMap, new WeakSet, new Date y casi todo lo hecho con la palabra clave new;
 Function: una estructura sin datos, aunque también responde al
operador typeof: typeof instance === "function". Esta simplemente es una
forma abreviada para funciones, aunque cada constructor de funciones se deriva
del constructor Object.
Ten en cuenta que el único propósito valioso del uso del operador typeof es
verificar el tipo de dato. Si deseamos verificar cualquier Tipo Estructural derivado
de Object, no tiene sentido usar typeof para eso, ya que siempre recibiremos
"object". La forma correcta de comprobar qué tipo de Objeto estamos usando es la
palabra clave instanceof. Pero incluso en ese caso, puede haber conceptos
erróneos.

Valores primitivos
Todos los tipos, excepto los objetos, definen valores inmutables (es decir, valores
que no se pueden cambiar). Por ejemplo (y a diferencia de C), las cadenas son
inmutables. Nos referimos a los valores de estos tipos como "valores primitivos".

Tipo Boolean

Boolean representauna entidad lógica y puede tener dos valores: true y false.

Consulta Boolean y Boolean para obtener más detalles.

Tipo Null

El tipo Null tiene exactamente un valor: null. Consulta null y Null para obtener más

detalles.

Tipo Undefined

Una variable a la que no se le ha asignado un valor tiene el valor undefined.

Consulta undefined y Undefined para obtener más detalles.

Tipo Number

ECMAScript tiene dos tipos numéricos integrados: Number y BigInt (ve más abajo).

El tipo Number es un valor en formato binario de 64 bits de doble precisión IEEE
754 (números entre -(253 - 1) y 253 - 1). Además de representar números de punto
flotante, el tipo Number tiene tres valores simbólicos: +Infinity, -Infinity y NaN ("Not
a Number" o No es un número).

Para verificar el valor disponible más grande o el valor más pequeño disponible
dentro de ±Infinity, puedes usar las
constantes Number.MAX_VALUE o Number.MIN_VALUE.

A partir de ECMAScript 2015, también puedes comprobar si un número está en el

rango de números de punto flotante de doble precisión
mediante Number.isSafeInteger() así
como Number.MAX_SAFE_INTEGER y Number.MIN_SAFE_INTEGER (en-US).

Más allá de este rango, los enteros en JavaScript ya no son seguros y serán una
aproximación de punto flotante de doble precisión del valor.
El tipo number solo tiene un entero con dos representaciones: 0 se representa
como -0 y +0. (0 es un alias de +0).

En la praxis, esto casi no tiene impacto. Por ejemplo, +0 === -0 es true. Sin
embargo, puedes notar esto cuando divides entre cero:

> 42 / +0

Infinity

> 42 / -0

-Infinity

Copy to Clipboard

Aunque un number a menudo representa solo su valor, JavaScript

proporciona operadores binarios (bitwise) (en-US).

Precaución: Aunque los operadores bit a bit se pueden usar para representar

múltiples valores Booleanos dentro de un solo número usando el enmascaramiento
de bits, esto generalmente se considera una mala práctica. JavaScript ofrece otros
medios para representar un conjunto de valores booleanos (como un arreglo de
valores booleanos o un objeto con valores booleanos asignados a propiedades con
nombre). El enmascaramiento de bits también tiende a hacer que el código sea
más difícil de leer, comprender y mantener.
Posiblemente sea necesario utilizar estas técnicas en entornos muy restringidos,
como cuando se intenta hacer frente a las limitaciones del almacenamiento local, o
en casos extremos (como cuando cada bit de la red cuenta). Esta técnica solo se
debe considerar cuando sea la última medida que se pueda tomar para optimizar el
tamaño.

Tipo BigInt

El tipo BigInt es un primitivo numérico en JavaScript que puede representar

números enteros con precisión arbitraria. Con BigInts, puedes almacenar y operar
de forma segura en números enteros grandes incluso más allá del límite seguro de
enteros para Numbers.

Un BigInt se crea agregando n al final de un número entero o llamando al

constructor.

Puedes obtener el valor más seguro que se puede incrementar con Numbers

utilizando la constante Number.MAX_SAFE_INTEGER. Con la introducción de BigInts,
puedes operar con números más allá de Number.MAX_SAFE_INTEGER.

Este ejemplo demuestra, dónde, incrementando

el Number.MAX_SAFE_INTEGER devuelve el resultado esperado:

> const x = 2n ** 53n;

9007199254740992n

> const y = x + 1n;

9007199254740993n

Copy to Clipboard

Puedes utilizar los operadores +, *, -, ** y % con BigInts, igual que con Numbers.

Un BigInt no es estrictamente igual a un Number, pero lo es en términos generales.

Un BigInt se comporta como un Number en los casos en que se convierte

a Boolean: if, ||, &&, Boolean, !.

Los BigInt no se pueden utilizar indistintamente con los Number. En su lugar, se

lanzará un TypeError.

Tipo String

El tipo String de JavaScript se utiliza para representar datos textuales. Es un

conjunto de "elementos" de valores enteros sin signo de 16 bits. Cada elemento
del String ocupa una posición en la cadena. El primer elemento está en el índice 0,
el siguiente en el índice 1, y así sucesivamente. La longitud de una cadena es el
número de elementos que contiene.

A diferencia de algunos lenguajes de programación (tal como C), las cadenas de

JavaScript son inmutables. Esto significa que una vez que se crea una cadena, no
es posible modificarla.

Sin embargo, todavía es posible crear otra cadena basada en una operación en la
cadena original. Por ejemplo:

 Una subcadena de la original seleccionando letras individuales o

usando String.substr().
 Una concatenación de dos cadenas usando el operador de concatenación (+)
o String.concat().
¡Ten cuidado de no "convertir a cadenas" tu código!
Puede resultar tentador utilizar cadenas para representar datos complejos. Hacer
esto viene con beneficios a corto plazo:

 Es fácil construir cadenas complejas con concatenación.

 Las cadenas son fáciles de depurar (lo que ves impreso siempre es lo que está en
la cadena).
 Las cadenas son el denominador común de muchas APIs (campos de entrada —
inputs—, valores de almacenamiento local, respuestas XMLHttpRequest cuando se
usa responseText, etc.) y puede resultar tentador trabajar solo con cadenas.
Con las convenciones, es posible representar cualquier estructura de datos en una
cadena. Esto no la convierte en una buena idea. Por ejemplo, con un separador, se
podría emular una lista (mientras que un arreglo de JavaScript sería más
adecuado). Desafortunadamente, cuando el separador se usa en uno de los
elementos de la "lista", la lista se rompe. Se puede elegir un caracter de escape,
etc. Todo esto requiere convenciones y crea una innecesaria carga de
mantenimiento.

Utiliza cadenas para datos textuales. Cuando quieras representar datos

complejos, procesa las cadenas y usa la abstracción adecuada.

Tipo Symbol

Un símbolo es un valor primitivo único e inmutable y se puede utilizar como clave

de una propiedad de objeto (ve más abajo). En algunos lenguajes de
programación, los símbolos se denominan "átomos".

Para obtener más detalles, consulta Symbol y el contenedor de objetos Symbol en

JavaScript.
Objetos
En ciencias de la computación, un objeto es un valor en la memoria al que
posiblemente hace referencia un identificador.

Propiedades

En JavaScript, los objetos se pueden ver como una colección de propiedades. Con
la sintaxis de objeto literal (en-US), se inicia un conjunto limitado de propiedades;
luego se pueden agregar y eliminar propiedades. Los valores de propiedad pueden
ser valores de cualquier tipo, incluidos otros objetos, lo que permite construir
estructuras de datos complejas. Las propiedades se identifican mediante
valores clave. Un valor clave es un valor de cadena o un símbolo.

Hay dos tipos de propiedades de objeto que tienen ciertos atributos: la

propiedad data y la propiedad accessor.

Nota: Cada propiedad tiene atributos correspondientes. Los atributos, internamente

los utiliza el motor JavaScript, por lo que no puedes acceder a ellos directamente.
Es por eso que los atributos se enumeran entre corchetes dobles, en lugar de
simples.

Consulta Object.defineProperty() para obtener más información.

Propiedad  Data
Asocia una clave con un valor y tiene los siguientes atributos:

Atributos de una propiedad data

Valor
Atributo Tipo Descripción
predeterminado

Cualquier
El valor recuperado por un captador de
[[Value]] tipo de undefined
acceso get a la propiedad.
JavaScript

Si es false, el [[Value]] de la propiedad

[[Writable]] Boolean false
no se puede cambiar.

[[Enumerable]] Boolean Si es true, la propiedad se enumerará false

 Atributos de una propiedad data

Valor
Atributo Tipo Descripción
predeterminado

en bucles for...in.
Consulta también Enumerabilidad y
posesión de propiedades.

Si es false, la propiedad no se puede

eliminar, no se puede cambiar a una
[[Configurable]] Boolean propiedad de acceso descriptor y los false
atributos que no sean [[Value]] y
[[Writable]] no se pueden cambiar.

Atributos obsoletos (a partir de ECMAScript 3, renombrado en ECMAScript 5)

Atributo Tipo Descripción

Read-only Boolean Estado inverso del atributo ES5 [[Writable]].

DontEnum Boolean Estado inverso del atributo ES5 [[Enumerable]].

DontDelete Boolean Estado inverso del atributo ES5 [[Configurable]].

Propiedad  Accessor
Asocia una clave con una de las dos funciones de acceso (get y set) para
recuperar o almacenar un valor y tiene los siguientes atributos:
 Atributos de una propiedad accessor

Valor
Atributo Tipo Descripción
predeterminado

La función se llama con

una lista de
argumentos vacía y
recupera el valor de la
Objeto Function o undefine
[[Get]] propiedad cada vez undefined
d
que se realiza un
acceso al valor.
Consulta también get
(en-US).

La función se llama con

un argumento que
contiene el valor
asignado y se ejecuta
Objeto Function o undefine
[[Set]] siempre que se intenta undefined
d
cambiar una propiedad
específica.
Consulta también set
(en-US).

Si es true, la
propiedad se
[[Enumerable]] Boolean false
enumerará en
bucles for...in.

Si es false, la
propiedad no se puede
[[Configurable]] Boolean eliminar y no se puede false
cambiar a una
propiedad de datos.
Objetos y funciones "normales"

Un objeto JavaScript es una asociación entre claves y valores. Las claves son

cadenas (o Symbols), y los valores pueden ser cualquier cosa. Esto hace que los
objetos se ajusten naturalmente a hashmaps.

Las funciones son objetos regulares con la capacidad adicional de ser invocables.

Fechas

Al representar fechas, la mejor opción es utilizar la utilidad Date incorporada en

JavaScript.

Colecciones indexadas: arreglos y arreglos tipados

Los arreglos (en-US) son objetos regulares para los que existe una relación
particular entre las propiedades de clave entera y la Propiedad length.

Además, los arreglos heredan de Array.prototype, que les proporciona un puñado

de convenientes métodos para manipular arreglos. Por ejemplo, indexOf (buscando
un valor en el arreglo) o push (agrega un elemento al arreglo), y así sucesivamente.
Esto hace que el Array sea un candidato perfecto para representar listas o
conjuntos.

Los Arreglos tipados son nuevos en JavaScript con ECMAScript 2015 y presentan

una vista similar a un arreglo de un búfer de datos binarios subyacente. La
siguiente tabla ayuda a determinar los tipos de datos equivalentes en C:

Tamaño
Tipo Intervalo de valores Descripción T
en bytes

Dos enteros complementarios de 8 bits

Int8Array -128 a 127 1 b
con signo

Uint8Array 0 a 255 1 Entero de 8-bit sin signo o

 Tamaño
Tipo Intervalo de valores Descripción T
en bytes

Uint8ClampedArra
0 a 255 1 Entero de 8 bits sin signo (sujeto) o
y

Dos enteros complementarios de 16

Int16Array -32768 a 32767 2 s
bits con signo

Uint16Array 0 a 65535 2 Entero de 16 bits sin signo S

-2147483648 a 214748364 dos enteros complementarios de 32

Int32Array 4 l
7 bits con signo

Uint32Array 0 a 4294967295 4 Enteros de 32 bits sin signo l

Número de coma flotante IEEE de 32

f
Float32Array 1.2×10  a 3.4×10
-38 38
4 bits (7 dígitos significativos, p.
r
ej., 1.1234567)
 Tamaño
Tipo Intervalo de valores Descripción T
en bytes

Número de coma flotante IEEE de 64

d
Float64Array 5.0×10-324 a 1.8×10308 8 bits (16 dígitos significativos, p.
r
ej., 1.123...15)

Dos enteros complementarios de 64

BigInt64Array -263 a 263-1 8 b
bits con signo

BigUint64Array 0 a 264-1 8 Entero de 64 bits sin signo b

Un lenguaje de programación En primer lugar, un lenguaje de programación es un lenguaje que

permite a los desarrolladores escribir código fuente que será analizado por un ordenador. Un
desarrollador o programador es una persona que desarrolla programas. Puede ser un profesional
(un ingeniero, programador informático o analista) o un aficionado. El código fuente está escrito
por el desarrollador. Este es un conjunto de acciones, llamadas instrucciones, lo que permitirá dar
órdenes al ordenador para operar el programa. El código fuente es algo oculto, como un motor en
un automóvil está oculto, pero está ahí, y es quien asegura que el coche puede ser conducido. En
el caso de un programa, es lo mismo, el código fuente rige el funcionamiento del programa.
Dependiendo del código fuente, el ordenador realiza varias acciones, como abrir un menú, iniciar
una aplicación, efectuar búsquedas, en fin, todo lo que el equipo es capaz de hacer. Hay una gran
cantidad de lenguajes de programación, la mayoría se encuentran en esta página de la Wikipedia

Estructuras condicionales compuestas en JavaScript.

Cuando se presenta la elección tenemos la opción de realizar una actividad u otra. Es
decir tenemos actividades por el verdadero y por el falso de la condición.

Lo más importante que hay que tener en cuenta es que se realizan las actividades
de la rama del verdadero o las del falso, NUNCA se realizan las actividades de las
dos ramas.

En una estructura condicional compuesta tenemos entradas, salidas, operaciones,

tanto por la rama del verdadero como por la rama del falso.
Ejemplo: Realizar un programa que lea dos números distintos y muestre el mayor
de ellos:

<html>
<head>
</head>
<body>
<script language="javascript">
var num1,num2;
num1=prompt('Ingrese el
primer número:','');
num2=prompt('Ingrese el
segundo número:','');
num1=parseInt(num1);
num2=parseInt(num2);
if (num1>num2)
{
document.write('el mayor es '+num1);
}
else
{
document.write('el mayor es '+num2);
}
</script>
</body>
</html>

Ver ejemplo anterior

La función prompt retorna un string por lo que debemos convertirlo a entero

cuando queremos saber cual de los dos valores es mayor numéricamente. En el
lenguaje JavaScript una variable puede ir cambiando el tipo de dato que almacena
a lo largo de la ejecución del programa.

Más adelante veremos qué sucede cuando preguntamos cual de dos string es
mayor.
Estamos en presencia de una ESTRUCTURA CONDICIONAL COMPUESTA ya
que tenemos actividades por la rama del verdadero y del falso.

Una sintaxis básica if...else luce así. pseudocode:

if (condición) {
código a ejecutar si la condición es verdadera
} else {
ejecuta este otro código si la condición es falsa
}
Aquí tenemos:

1. La palabra clave if seguida de unos paréntesis.

2. Una condición a probar, puesta dentro de los paréntesis (típicamente "¿es este
valor mayor que este otro valor?", o "¿existe este valor?"). Esta condición usará
los operadores de comparación que hemos hablado en el módulo anterior y
retorna un valor true o false (verdadero o falso).
3. Un conjunto de llaves, en las cuales tenemos algún código — puede ser cualquier
código que deseemos, código que se ejecutará sólamente si la condición retorna
true.
4. La palabra clave else.
5. Otro conjunto de llaves, dentro de las cuales tendremos otro código — puede ser
cualquier código que deseemos, y sólo se ejecutará si la condición no es true.

Este código es fácil de leer — está diciendo "si (if) la condición retorna verdadero
(true), entonces ejecute el código A, sino (else) ejecute el código B"

Habrás notado que no tienes que incluir else y el segundo bloque de llaves — La
siguiente declaración también es perfectmente legal.