REPÚBLICA BOLIVARIANA DE VENEZUELA
INSTITUTO UNIVERSITARIO DE TECNOLOGÍA INDUSTRIAL
“RODOLFO LOERO ARISMENDI”
I.U.T.I.R.L.A
EXTENSIÓN MATURÍN
Fundamentos de Java Script
Docente: Estudiante:
María Aguilera Leonardo Guzmán
31.418.894
Maturín, Junio del año 2025
Índice
1.1. Introducción a JavaScript: Evolución histórica y propósito................................4
1.2. Entornos de ejecución: Navegador vs [Link]..................................................4
1.3. Fundamentos de la sintaxis...............................................................................5
1.3.1. Variables (var, let, const)................................................................................5
1.3.2. Estructuras de datos (objetos, matrices)........................................................6
1.3.3. Operadores y estructuras de control..............................................................6
1.4. Funciones..........................................................................................................7
1.4.1. Declaración y expresión.................................................................................7
1.4.2. Funciones de flecha y diferencias con funciones regulares...........................7
1.5. Diferencias clave con lenguajes previos...........................................................7
1.5.1. Tipado dinámico vs estático...........................................................................7
1.5.2. Ámbito léxico y closures.................................................................................7
1.5.3. Manejo de errores en JavaScript....................................................................8
Introducción
En el mundo actual, dominado por la tecnología y la digitalización, el desarrollo de
software se ha convertido en una de las habilidades más demandadas. Dentro de
este vasto campo, JavaScript emerge como uno de los lenguajes de programación
más relevantes y versátiles, siendo la piedra angular del desarrollo web moderno.
Este trabajo, titulado "Fundamentos de JavaScript", tiene como objetivo explorar
los conceptos esenciales que todo desarrollador debe dominar para aprovechar al
máximo este lenguaje, desde su historia y evolución hasta sus características
técnicas más avanzadas.
JavaScript nació en 1995 de la mano de Brendan Eich, un ingeniero de Netscape
Communications, con el propósito inicial de añadir interactividad a las páginas
web, que en ese entonces eran estáticas y limitadas. Lo que comenzó como un
simple lenguaje de scripting para navegadores ha evolucionado hasta convertirse
en una tecnología omnipresente, utilizada no solo en el frontend (la parte visual de
las aplicaciones web), sino también en el backend (gracias a [Link]), en el
desarrollo de aplicaciones móviles (con frameworks como React Native) e incluso
en el ámbito del Internet de las Cosas (IoT). Su estandarización bajo el nombre
ECMAScript (ES) ha permitido un crecimiento ordenado y constante, con
actualizaciones anuales que introducen mejoras y nuevas funcionalidades.
Este documento está estructurado en cinco secciones principales que abarcan
desde los conceptos más básicos hasta las diferencias clave que distinguen a
JavaScript de otros lenguajes de programación. En la Sección 1.1, se aborda la
evolución histórica de JavaScript, destacando su propósito original y su
transformación en un lenguaje multipropósito. La Sección 1.2 explora los entornos
de ejecución, comparando su uso en navegadores web (como Chrome y Firefox)
con su aplicación en [Link], un entorno que permite ejecutar JavaScript fuera del
navegador y en el lado del servidor.
1.1. Introducción a JavaScript: Evolución histórica y propósito
JavaScript surgió en 1995 como un lenguaje creado por Brendan Eich para
Netscape Navigator, con el objetivo de añadir interactividad a las páginas web
que, hasta entonces, eran estáticas. Originalmente se llamó Mocha y luego
LiveScript, pero finalmente adoptó el nombre JavaScript como estrategia
comercial, aprovechando la popularidad de Java en ese momento, aunque no
guarda relación directa con este último.
A lo largo de los años, JavaScript ha evolucionado de ser un simple lenguaje de
scripting para navegadores a convertirse en una tecnología fundamental tanto en
el desarrollo frontend como backend. Su estandarización bajo el
nombre ECMAScript (ES) permitió un crecimiento ordenado, con versiones clave
como ES5 (2009), que introdujo mejoras en el manejo de arrays y objetos,
y ES6/ES2015, que marcó un antes y después al incorporar clases, módulos,
arrow functions y otras características modernas.
Hoy en día, JavaScript no solo se limita al navegador, sino que también se utiliza
en el desarrollo de aplicaciones móviles (React Native), servidores ([Link]) e
incluso en el ámbito del Internet de las Cosas (IoT). Su flexibilidad y constante
evolución lo han convertido en uno de los lenguajes más importantes en el mundo
de la programación.
1.2. Entornos de ejecución: Navegador vs [Link]
JavaScript puede ejecutarse en dos entornos principales: navegadores
web y [Link]. Cada uno tiene sus propias características y casos de uso.
En el navegador, JavaScript se encarga de manipular el DOM (Document Object
Model), permitiendo modificar el contenido de una página web de manera
dinámica. También maneja eventos como clics, desplazamientos y teclas, y puede
realizar peticiones HTTP asíncronas (AJAX o Fetch API) para cargar datos sin
recargar la página. Cada navegador utiliza un motor de JavaScript diferente:
Chrome y Edge usan V8, Firefox utiliza SpiderMonkey y Safari
emplea JavaScriptCore (Nitro).
Por otro lado, [Link] es un entorno de ejecución que permite usar JavaScript
fuera del navegador, en el lado del servidor. Creado en 2009 y basado en el motor
V8 de Chrome, [Link] abrió las puertas al desarrollo backend con JavaScript,
permitiendo la creación de servidores web, acceso a bases de datos y
manipulación de archivos. A diferencia del navegador, [Link] no tiene acceso al
DOM, pero incluye módulos integrados para trabajar con el sistema de archivos
(fs), redes (http) y otros recursos del sistema.
La principal diferencia entre ambos entornos radica en su enfoque: mientras el
navegador se centra en la interacción con el usuario y la manipulación de la
interfaz, [Link] está diseñado para construir aplicaciones del lado del servidor y
herramientas de línea de comandos.
1.3. Fundamentos de la sintaxis
1.3.1. Variables (var, let, const)
En JavaScript, las variables se pueden declarar de tres
formas: var, let y const, cada una con comportamientos distintos.
Las variables declaradas con var tienen un ámbito de función, lo que significa que
son accesibles en cualquier parte de la función donde fueron declaradas, incluso
fuera de bloques como if o for. Además, sufren de hoisting, un comportamiento en
el que la declaración de la variable se "eleva" al inicio de su ámbito, aunque su
asignación ocurra más adelante.
Con la llegada de ES6, se introdujeron let y const, que tienen un ámbito de bloque.
Esto significa que solo existen dentro del bloque {} donde fueron definidas. La
diferencia principal entre ellas es que let permite reasignar valores, mientras
que const no, aunque en el caso de objetos y arrays declarados con const, sus
propiedades internas sí pueden modificarse.
1.3.2. Estructuras de datos (objetos, matrices)
Los objetos en JavaScript son colecciones de pares clave-valor, donde
cada clave es una cadena (o símbolo) y cada valor puede ser cualquier tipo de
dato, incluyendo otras funciones. Los objetos son fundamentales para representar
entidades complejas, como usuarios o productos, y permiten organizar y
estructurar datos de manera eficiente.
Las matrices (arrays), por otro lado, son listas ordenadas de valores que pueden
ser de cualquier tipo. A diferencia de los objetos, los arrays tienen métodos
integrados para manipular sus elementos, como push() para añadir elementos al
final, pop() para eliminarlos, o map() para transformarlos.
1.3.3. Operadores y estructuras de control
JavaScript incluye una variedad de operadores para realizar operaciones
aritméticas (+, -, *, /), comparaciones (==, ===, >, <) y lógicas (&&, ||, !). Es
importante destacar la diferencia entre == (igualdad débil, que convierte tipos
antes de comparar) y === (igualdad estricta, que compara tanto valor como tipo).
Las estructuras de control permiten manejar el flujo del programa. Las
condicionales como if, else y switch ejecutan bloques de código según se cumplan
ciertas condiciones, mientras que los bucles (for, while, do-while) repiten acciones
hasta que se cumple un criterio de salida.
1.4. Funciones
1.4.1. Declaración y expresión
Las funciones declaradas se definen usando la palabra clave function y
tienen la característica de ser hoisted, lo que significa que pueden ser llamadas
antes de su declaración en el código.
Por otro lado, las funciones expresadas son aquellas asignadas a una variable. A
diferencia de las declaradas, estas no sufren hoisting, por lo que solo pueden ser
invocadas después de su definición.
1.4.2. Funciones de flecha y diferencias con funciones regulares
Las funciones de flecha (arrow functions), introducidas en ES6, ofrecen una
sintaxis más concisa y no tienen su propio contexto this, heredándolo del ámbito
exterior. Esto las hace especialmente útiles en callbacks y métodos de arrays
como map() o filter. Sin embargo, no pueden ser utilizadas como constructores ni
tienen acceso al objeto arguments.
1.5. Diferencias clave con lenguajes previos
1.5.1. Tipado dinámico vs estático
A diferencia de lenguajes como Java o C++, que son de tipado estático (el
tipo de variable se define al declararla y no puede cambiar), JavaScript es
de tipado dinámico, permitiendo que una variable pueda contener diferentes tipos
de datos a lo largo de su vida útil.
1.5.2. Ámbito léxico y closures
El ámbito léxico en JavaScript significa que las funciones acceden a las
variables del ámbito en el que fueron creadas, no donde son ejecutadas.
Los closures son un concepto derivado de esto, permitiendo que una función
"recuerde" variables externas incluso después de que el ámbito padre haya
terminado.
1.5.3. Manejo de errores en JavaScript
JavaScript utiliza un sistema de try-catch-finally para manejar
excepciones. Los errores más comunes incluyen SyntaxError (código mal
escrito), TypeError (operaciones inválidas) y ReferenceError (variables no
definidas).
Conclusión
El estudio de los Fundamentos de JavaScript presentado en este trabajo ha
permitido explorar en profundidad uno de los lenguajes de programación más
influyentes y versátiles de la era digital. Desde sus humildes inicios en 1995 como
un simple lenguaje de scripting para Netscape Navigator, JavaScript ha
evolucionado hasta convertirse en una tecnología omnipresente, impulsando no
solo el desarrollo web, sino también aplicaciones móviles, servidores y sistemas
embebidos. Este documento ha abordado los pilares esenciales que todo
desarrollador debe dominar para aprovechar al máximo este lenguaje, destacando
su sintaxis, funcionalidades y diferencias clave con otros lenguajes de
programación.
A lo largo de las secciones analizadas, se ha demostrado que JavaScript es un
lenguaje dinámico y multiparadigma, capaz de adaptarse a distintos enfoques de
programación, ya sea orientado a objetos, funcional o basado en eventos. Su
tipado dinámico, aunque puede representar un desafío para desarrolladores
acostumbrados a lenguajes estáticos como Java o C++, ofrece una flexibilidad
invaluable en el desarrollo rápido de aplicaciones. Además, características como
el ámbito léxico y los closures permiten un manejo sofisticado de variables y
estados, facilitando patrones de diseño avanzados y una gestión eficiente de los
recursos.
En cuanto a su sintaxis, se ha destacado la importancia de comprender las
diferencias entre var, let y const, así como el manejo de estructuras de datos como
objetos y arrays, fundamentales para organizar y manipular información. Las
funciones, ya sean declaradas, expresadas o arrow functions, representan otro
pilar esencial, demostrando cómo JavaScript combina simplicidad y potencia para
permitir desde operaciones básicas hasta flujos asíncronos complejos.
