Edición de «JavaScript»

{{otros usos|Java|otro=Jabba el Hutt}}
{{Ficha de lenguaje de programación
|paradigma = [[Lenguaje de programación#Clasificación por paradigmas|Multiparadigma]], [[programación funcional]],<ref name="jsfunc">[https://web.archive.org/web/20090923001111/http://www.blinkx.com/video/douglas-crockford-on-functional-javascript/xscZz8XhfuNQ_aaVuyUB2A Douglas Crockford on Functional JavaScript] (2:49): "[JavaScript] es el lenguaje funcional más popular del mundo. JavaScript es y siempre ha sido, al menos desde [la versión] 1.2, un lenguaje de programación funcional."</ref> [[programación basada en prototipos]], [[Programación imperativa|imperativo]], [[Lenguaje de programación interpretado|interpretado (''scripting'')]]
|año = 4 de diciembre de 1995
|diseñador = [[Brendan Eich]], [[Netscape Communications]], [[Fundación Mozilla]]
|última_versión        = ECMAScript 2025
|fecha_última_versión  = {{fecha de lanzamiento|01|06|2025}}
|tipo_dato = dinámico, [[Duck typing|''duck'']]
|implementaciones = [[SpiderMonkey]], [[Rhino (intérprete de JavaScript)|Rhino]], [[KJS]], [[JavaScriptCore]], [[V8 (motor JavaScript)|V8]], [[Chakra (intérprete de JScript)|Chakra]].
|influido_por = [[Java (lenguaje de programación)|Java]], [[Perl]], [[Self]], [[Python]], [[C (lenguaje de programación)|C]], [[Scheme]]
|ha_influido = [[Objective-C]], [[JScript]], [[TypeScript]]
| operating_system       = [[Multiplataforma]]
|extensiones_comunes=<code>.js</code>
|captura=Ejemplo de código JavaScript.jpg}}
'''JavaScript''' (abreviado comúnmente '''JS''') es un [[lenguaje de programación]] [[Intérprete (informática)|interpretado]], dialecto del estándar [[ECMAScript]]. Se define como [[Programación orientada a objetos|orientado a objetos]],<ref>{{Cita web |url=http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf |título=Copia archivada |fechaacceso=23 de noviembre de 2010 |urlarchivo=https://web.archive.org/web/20150412040502/http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf |fechaarchivo=12 de abril de 2015 }}</ref> [[Programación basada en prototipos|basado en prototipos]], imperativo, [[Tipado fuerte#Lenguajes no tipados|débilmente tipado]] y [[Tipado dinámico|dinámico]].

Se utiliza principalmente del [[cliente (informática)|lado del cliente]], implementado como parte de un [[navegador web]] permitiendo mejoras en la [[interfaz de usuario]] y [[Página web|páginas web]] dinámicas<ref>{{Cita publicación
 |título=Bases de datos en el cliente con JavaScript DB
 |autor=M. Domínguez-Dorado,. Todo Programación. Nº 12. Págs. 48-51. Editorial Iberprensa (Madrid). DL M-13679-2004. Septiembre de 2005
}}</ref> y JavaScript del lado del servidor (''Server-side JavaScript'' o ''SSJS''). Su uso en [[Aplicación informática|aplicaciones]] externas a la [[World Wide Web|web]], por ejemplo en documentos [[PDF]], aplicaciones de escritorio (mayoritariamente [[widget]]s) es también significativo.

Desde 2012, todos los navegadores modernos soportan completamente ECMAScript 5.1, una versión de JavaScript. Los navegadores más antiguos soportan por lo menos ECMAScript 3. La sexta edición se liberó en julio de 2015.<ref>{{Cita web |url=https://developer.mozilla.org/es/docs/Web/JavaScript |título=JavaScript |fechaacceso=16 de septiembre de 2016 |sitioweb=Mozilla Developer Network}}</ref>

JavaScript se diseñó con una sintaxis similar a [[C++]] y [[Java (lenguaje de programación)|Java]],<ref>{{Cita web|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/About_JavaScript|título=About JavaScript - JavaScript {{!}} MDN|fechaacceso=2022-07-04|sitioweb=developer.mozilla.org|idioma=en-US}}</ref><ref>{{Cita web|url=https://web.stanford.edu/class/cs98si/slides/overview.html|título=Introduction|fechaacceso=2022-07-04|sitioweb=web.stanford.edu}}</ref> aunque adopta nombres y convenciones del lenguaje de programación Java. Sin embargo, Java y JavaScript tienen semánticas y propósitos diferentes. Su relación es puramente comercial, tras la compra del creador de Java (Sun Microsystems) de Netscape Navigator (creador de LiveScript) y el cambio de nombre del lenguaje de programación.

Todos los navegadores modernos interpretan el código JavaScript integrado en las páginas web. Para interactuar con una página web se provee al lenguaje JavaScript de una implementación del [[Document Object Model]] (DOM). Javascript es el único lenguaje de programación que entienden de forma nativa los navegadores.

Tradicionalmente se venía utilizando en páginas web [[HTML]] para realizar operaciones y únicamente en el marco de la [[Cliente (informática)|aplicación cliente]], sin acceso a funciones del [[servidor]]. Actualmente es ampliamente utilizado para enviar y recibir información del servidor junto con ayuda de otras tecnologías como [[AJAX]]. JavaScript se interpreta en el [[agente de usuario]] al mismo tiempo que las sentencias van descargándose junto con el código HTML.

Desde el lanzamiento en junio de 1997 del estándar [[ECMAScript]] 1, han existido las versiones 2, 3 y 5, que es la más usada actualmente (la 4 se abandonó<ref>{{Cita web |apellidos1=Eich |nombre1=Brendan |título=ECMAScript Harmony |url=https://mail.mozilla.org/pipermail/es-discuss/2008-August/003400.html |fecha=13 de agosto de 2008 |fechaacceso=22 de julio de 2015 |fechaarchivo=26 de agosto de 2013 |urlarchivo=https://web.archive.org/web/20130826220148/https://mail.mozilla.org/pipermail/es-discuss/2008-August/003400.html |deadurl=yes }}</ref>). En junio de 2015 se cerró y publicó la versión ECMAScript 6.<ref>{{Cita web |autor1=campusMVP |título=ECMAScript 6 es ya un estándar abierto |url=http://www.campusmvp.es/recursos/post/ECMAScript-6-es-ya-un-estandar-cerrado.aspx |fecha=19 de junio de 2015 |fechaacceso=22 de julio de 2015}}</ref>

== Historia ==

=== Nacimiento de JavaScript ===
JavaScript fue desarrollado originalmente por [[Brendan Eich]] de [[Netscape Communications Corporation|Netscape]] con el nombre de ''Mocha'', el cual fue renombrado posteriormente a ''LiveScript'', para finalmente quedar como JavaScript. El cambio de nombre coincidió aproximadamente con el momento en que Netscape agregó compatibilidad con la tecnología Java en su [[Netscape Navigator|navegador web Netscape Navigator]] en la versión 2002 en diciembre de 1995. La denominación produjo confusión, dando la impresión de que el lenguaje es una prolongación de Java, y fue considerada por muchos como una estrategia de mercadotecnia de Netscape para obtener prestigio e innovar en el ámbito de los nuevos lenguajes de programación web.<ref>[http://www.webdevelopersnotes.com/basics/languages_on_the_internet.php3 Lenguajes de programación usados en Internet y la World Wide Web (WWW) (castellano)]</ref><ref>[http://shop.oreilly.com/product/9780596805531.do JavaScript: The Definitive Guide, 6th Edition]</ref>

«JAVASCRIPT» es una [[marca registrada]] de [[Oracle Corporation]].<ref>{{Cita web|url=https://tsdr.uspto.gov/|título=Trademark Status & Document Retrieval|fechaacceso=2024-03-25|sitioweb=tsdr.uspto.gov}}</ref> Es usada con licencia por los productos creados por [[Netscape Communications]] y entidades actuales como la [[Fundación Mozilla]].<ref name="MarcasOracle">[http://www.oracle.com/us/legal/third-party-trademarks/index.html Marcas registradas de Oracle].</ref><ref name = "mdm">{{Cita web |url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/About_JavaScript?redirectlocale=en-US&redirectslug=JavaScript%2FAbout_JavaScript |título=About JavaScript |fechaacceso=29 de agosto de 2013 |idioma=inglés |cita=JavaScript is a trademark or registered trademark of Oracle in the U.S. and other countries}}</ref>

[[Microsoft]] dio como nombre a su dialecto de JavaScript «[[JScript]]», para evitar problemas relacionadas con la marca. JScript fue adoptado en la versión 3.0 de Internet Explorer, liberado en agosto de 1996, e incluyó compatibilidad con el [[Efecto 2000]] con las funciones de fecha, una diferencia de los que se basaban en ese momento. Los dialectos pueden parecer tan similares que los términos «JavaScript» y «JScript» a menudo se utilizan indistintamente, pero la especificación de JScript es incompatible con la de ECMA en muchos aspectos.

Para evitar estas incompatibilidades, el [[World Wide Web Consortium]] diseñó el estándar Document Object Model (DOM, o Modelo de Objetos del Documento en español), que incorporan [[Konqueror]], las versiones 6 de [[Internet Explorer]] y [[Netscape Navigator]], [[Opera (navegador)|Opera]] la versión 7, [[Mozilla Application Suite]] y [[Mozilla Firefox]] desde su primera versión.{{Cita requerida}}

En 1996 los autores propusieron<ref>{{Cita web |url=http://cgi.netscape.com/newsref/pr/newsrelease289.html |título=Netscape Comunicado de prensa (castellano) |fechaacceso=13 de septiembre de 2008 |fechaarchivo=3 de diciembre de 1998 |urlarchivo=https://web.archive.org/web/19981203070212/http://cgi.netscape.com/newsref/pr/newsrelease289.html |deadurl=yes }}</ref> JavaScript para que fuera adoptado como estándar de la European Computer Manufacturers 'Association [[ECMA]], que a pesar de su nombre no es europeo sino internacional, con sede en Ginebra. En junio de 1997 fue adoptado como un estándar ECMA, con el nombre de [[ECMAScript]]. Poco después también como un estándar [[Organización Internacional para la Estandarización|ISO]].

=== JavaScript en el lado servidor ===
Netscape introdujo una implementación de la [[programación del lado del servidor]] con [[Netscape Enterprise Server]], lanzada en diciembre de 1994 (poco después del lanzamiento de JavaScript para navegadores web).<ref name = "Newscape JavaScript Guide-1998">{{Cita web |título=Server-Side JavaScript Guide |editorial=Netscape Communications Corporation |año=1998 |capítulo=Chapter 2: Getting Started |url=http://docs.oracle.com/cd/E19957-01/816-6411-10/getstart.htm |fechaacceso=25 de abril de 2012}}</ref><ref name = "Morgan-Netcape LiveWire">{{Cita web |título=Using Netscape™ LiveWire™, Special Edition |autor=Mike Morgan |capítulo=Chapter 6: Netscape Internet Application Framework |url=http://vampire.rulez.org/onlinedoc/book/NetscapeLiveWire/ch6.htm |año=1996 |editorial=Que |urlarchivo=https://web.archive.org/web/20121221071020/http://vampire.rulez.org/onlinedoc/book/NetscapeLiveWire/ch6.htm |fechaarchivo=21 de diciembre de 2012 |fechaacceso=19 de mayo de 2013 }}</ref>
A partir de mediados de la década de los 2000, ha habido una proliferación de implementaciones de JavaScript para el lado servidor. [[Node.js]] es uno de los notables ejemplos de JavaScript en el lado del servidor, siendo usado en proyectos importantes.<ref name="RWW-Server-Side-2009-12-17">{{Cita web |título= Server-Side Javascript: Back With a Vengeance |obra= Read Write Web |fecha= 17 de diciembre de 2009 |fechaacceso= 28 de mayo de 2012 |url= http://www.readwriteweb.com/archives/server-side_javascript_back_with_a_vengeance.php |urlarchivo= https://web.archive.org/web/20120602170854/http://www.readwriteweb.com/archives/server-side_javascript_back_with_a_vengeance.php |fechaarchivo= 2 de junio de 2012 }}</ref><ref name="node.js-about">{{Cita web |url=http://nodejs.org/about/ |título= Node's goal is to provide an easy way to build scalable network programs |obra= About Node.js |editorial= Joyent}}</ref> Nuevas implementaciones para ejecutar JavaScript son [[Deno (software)|Deno]] (escrito principalmente en [[Rust (lenguaje de programación)|Rust]]), y [[Bun (software)|Bun]] (escrito principalmente en [[Zig (lenguaje de programación)|Zig]]). Ambos entornos de ejecución JavaScript pueden interpretar [[TypeScript]], y [[WebAssembly|WebAssembly (WASM)]]. <ref>{{Cita web|url=https://docs.deno.com/|título=Deno: the easiest, most secure JavaScript runtime {{!}} Deno Docs|fechaacceso=2024-08-12|sitioweb=docs.deno.com}}</ref>

=== Desarrollos posteriores ===

JavaScript se ha convertido en uno de los lenguajes de programación más populares en internet y más usados. Al principio, sin embargo, muchos desarrolladores renegaban del lenguaje porque el público al que va dirigido lo formaban publicadores de artículos y demás aficionados, entre otras razones.<ref>{{Cita web |url=http://www.crockford.com/javascript/javascript.html |título=JavaScript: The World's Most Misunderstood Programming Language |editorial=Crockford.com |fechaacceso=19 de mayo de 2009}}</ref> La llegada de AJAX devolvió JavaScript a la fama y atrajo la atención de muchos otros programadores. Como resultado de esto hubo una proliferación de un conjunto de [[Framework para aplicaciones web|frameworks]] y [[Biblioteca (informática)|bibliotecas]] de ámbito general, mejorando las prácticas de programación con JavaScript, y aumentado el uso de JavaScript fuera de los [[Navegador web|navegadores web]], como se ha visto con la proliferación de entornos JavaScript del lado del servidor.
En enero de 2009, el proyecto [[CommonJS]] fue inaugurado con el objetivo de especificar una biblioteca para uso de tareas comunes principalmente para el desarrollo fuera del navegador web.<ref>{{Cita web |url=http://arstechnica.com/web/news/2009/12/commonjs-effort-sets-javascript-on-path-for-world-domination.ars |título=CommonJS effort sets JavaScript on path for world domination |autor=Kris Kowal |fecha=1 de diciembre de 2009 |obra=[[Ars Technica]] |editorial=[[Condé Nast Publications]] |fechaacceso=18 de abril de 2010}}</ref>

En junio de 2015 se cerró y publicó el estándar [[ECMAScript]] 6<ref>{{Cita web |autor=ECMA International |url=http://www.ecma-international.org/publications/standards/Ecma-262.htm |título=Standard ECMA-262 6th Edition |fecha=Junio de 2015}}</ref><ref>{{Cita web |autor=campusMVP |url=http://www.campusmvp.es/recursos/post/ECMAScript-6-es-ya-un-estandar-cerrado.aspx |título=ECMAScript 6 ya es un estándar cerrado|fecha=19 de junio de 2015 |fechaacceso=22 de julio de 2015}}</ref> con un soporte irregular entre navegadores<ref>{{Cita web |url=http://kangax.github.io/compat-table/es6/ |título=Tabla de compatibilidad de navegadores con ECMAScript 6 (Inglés) |fechaacceso=22 de julio de 2015 |fechaarchivo=22 de octubre de 2020 |urlarchivo=https://web.archive.org/web/20201022231752/http://kangax.github.io/compat-table/es6/ |deadurl=yes }}</ref> y que dota a JavaScript de características avanzadas que se echaban de menos y que son de uso habitual en otros lenguajes como, por ejemplo, módulos para organización del código, verdaderas [[clase (informática)|clases]] para [[programación orientada a objetos]], expresiones de flecha, iteradores, generadores o promesas para programación asíncrona.

La versión 7 de ECMAScript se conoce como ECMAScript 2016,<ref>{{Cita web |autor=ECMA International |url=http://www.ecma-international.org/publications/standards/Ecma-262.htm |título=Standard ECMA-262 7th Edition |fecha=Junio de 2016}}</ref> y es la última versión disponible, publicada en junio de 2016. Se trata de la primera versión para la que se usa un nuevo procedimiento de publicación anual y un proceso de desarrollo abierto.<ref>{{Cita web |autor=ECMA International |url=http://www.ecma-international.org/ecma-262/7.0/index.html |título=ECMAScript 2016 Language Specification |fecha=Junio de 2016}}</ref>

== Características ==

Las siguientes características son comunes a todas las implementaciones que se ajustan al estándar ECMAScript, a menos que especifique explícitamente en caso contrario.

=== Imperativo y estructurado ===
JavaScript es compatible con gran parte de la [[programación estructurada|estructura de programación]] de [[C (lenguaje de programación)|C]] (por ejemplo, sentencias <code>if</code>, bucles <code>for</code>, sentencias <code>switch</code>, etc.). Con una salvedad, en parte: en C, el [[Ámbito (programación)|ámbito]] de las [[Variable (programación)|variables]] alcanza al bloque en el cual fueron definidas; sin embargo JavaScript no es compatible con esto, puesto que el ámbito de las variables es el de la función en la cual fueron declaradas. Esto cambia con la versión de ECMAScript 2015, ya que añade compatibilidad con block scoping por medio de la palabra clave <code>let</code>. Como en C, JavaScript hace distinción entre [[Expresión (informática)|expresiones]] y sentencias. Una diferencia sintáctica con respecto a C es la inserción automática de punto y coma, es decir, en JavaScript los puntos y coma que finalizan una sentencia pueden ser omitidos.{{Harvnp|Flanagan|2006| p=16}}

=== Dinámicos ===
; Tipado dinámico: Como en la mayoría de [[script|lenguajes de scripting]], el [[sistema de tipos|tipo]] está asociado al valor, no a la variable. Por ejemplo, una variable <code>x</code> en un momento dado puede estar ligada a un número y más adelante, religada a una [[string|cadena]]. JavaScript es compatible con varias formas de comprobar el tipo de un objeto, incluyendo [[duck typing]].{{Harvnp|Flanagan|2006| pp=176–178}} Una forma de saberlo es por medio de la palabra clave <code>typeof</code>.

; Objetual: JavaScript está formado casi en su totalidad por [[programación orientada a objetos|objetos]]. Los objetos en JavaScript son arrays asociativos, mejorados con la inclusión de prototipos (ver más adelante). Los nombres de las propiedades de los objetos son claves de tipo cadena: <code>obj.x&nbsp;=&nbsp;10</code> y <code>obj['x']&nbsp;=&nbsp;10</code> son equivalentes, siendo [[azúcar sintáctico]] la notación con punto. Las propiedades y sus valores pueden ser creados, cambiados o eliminados en tiempo de ejecución. La mayoría de propiedades de un objeto (y aquellas que son incluidas por la cadena de la herencia prototípica) pueden ser enumeradas por medio de la instrucción de bucle <code>for... in</code>. JavaScript tiene un pequeño número de objetos predefinidos como son <code>Function</code> y <code>Date</code>.

; Evaluación en tiempo de ejecución: JavaScript incluye la función <code>eval</code> que permite evaluar expresiones expresadas como cadenas en tiempo de ejecución. Por ello se recomienda que <code>eval</code> sea utilizado con precaución y que se opte por utilizar la función <code>JSON.parse()</code> en la medida de lo posible, pues puede resultar mucho más segura.

=== Funcional ===
; Funciones de primera clase: A las [[Subrutinas|funciones]] se les suele llamar ciudadanos de primera clase; son objetos en sí mismos. Como tal, poseen propiedades y métodos, como <code>.call()</code> y <code>.bind()</code>.<ref>{{Cita web |url=http://es5.github.com/#x15.3.4-toc |título=Properties of the Function Object |fechaacceso=19 de mayo de 2013 |fechaarchivo=28 de enero de 2013 |urlarchivo=https://web.archive.org/web/20130128185825/http://es5.github.com/#x15.3.4-toc |deadurl=yes }}</ref> Una función anidada es una función definida dentro de otra. Esta es creada cada vez que la función externa es invocada. Además, cada función creada forma una [[Clausura (informática)|clausura]]; es el resultado de evaluar un ámbito conteniendo en una o más variables dependientes de otro ámbito externo, incluyendo constantes, variables locales y argumentos de la función externa llamante. El resultado de la evaluación de dicha clausura forma parte del estado interno de cada objeto función, incluso después de que la función exterior concluya su evaluación.{{Harvnp|Flanagan|2006| p=141}}

=== Prototípico ===
; Prototipos: JavaScript usa [[Programación basada en prototipos|prototipos]] en vez de [[Clase (informática)|clases]] para el uso de [[Herencia (informática)|herencia]].<ref>{{Cita web |título=Inheritance and the prototype chain |url=https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Inheritance_and_the_prototype_chain |obra=Mozilla Developer Network |editorial=[[Mozilla]] |fechaacceso=6 de abril de 2013}}</ref> Es posible llegar a emular muchas de las características que proporcionan las clases en lenguajes orientados a objetos tradicionales por medio de prototipos en JavaScript.<ref>{{Cita libro|apellidos=Herman |nombre=David |título=Effective Javascript |url=https://archive.org/details/effectivejavascr0000herm |año=2013 |editorial=Addison-Wesley |isbn=9780321812186 |página=[https://archive.org/details/effectivejavascr0000herm/page/83 83]}}</ref>

; Funciones como constructores de objetos: Las funciones también se comportan como constructores. Prefijar una llamada a la función con la palabra clave <code>new</code> crear una nueva instancia de un prototipo, que heredan propiedades y métodos del constructor (incluidas las propiedades del prototipo de <code>Object</code>).<ref>{{Cita libro|apellidos=Haverbeke |nombre=Marjin |título=Eloquent Javascript |url=https://archive.org/details/eloquentjavascri00have_492 |año=2011 |editorial=No Starch Press |isbn=9781593272821 |páginas=[https://archive.org/details/eloquentjavascri00have_492/page/n102 95]-97}}</ref> ECMAScript 5 ofrece el método <code>Object.create</code>, permitiendo la creación explícita de una instancia sin tener que heredar automáticamente del prototipo de Object (en entornos antiguos puede aparecer el prototipo del objeto creado como <code>null</code>).<ref>{{Cita web |apellido=Katz |nombre=Yehuda |título=Understanding "Prototypes" in JavaScript |url=http://yehudakatz.com/2011/08/12/understanding-prototypes-in-javascript/ |fechaacceso=6 de abril de 2013}}</ref> La propiedad <code>prototype</code> del constructor determina el objeto usado para el prototipo interno de los nuevos objetos creados. Se pueden añadir nuevos métodos modificando el prototipo del objeto usado como constructor. Constructores predefinidos en JavaScript, como <code>Array</code> u <code>Object</code>, también tienen prototipos que pueden ser modificados. Aunque esto sea posible se considera una mala práctica modificar el prototipo de <code>Object</code> ya que la mayoría de los objetos en Javascript heredan los métodos y propiedades del objeto <code>prototype</code>, objetos los cuales pueden esperar que estos no hayan sido modificados.<ref>{{Cita libro|apellidos=Herman |nombre=David |título=Effective Javascript |url=https://archive.org/details/effectivejavascr0000herm |año=2013 |editorial=Addison-Wesley |isbn=9780321812186 |páginas=[https://archive.org/details/effectivejavascr0000herm/page/125 125]-127}}</ref>

=== Otras características ===
; Entorno de ejecución: JavaScript normalmente depende del entorno en el que se ejecute (por ejemplo, en un [[navegador web]]) para ofrecer objetos y métodos por los que los scripts pueden interactuar con el «mundo exterior». De hecho, depende del entorno para ser capaz de proporcionar la capacidad de incluir o importar scripts (por ejemplo, en HTML por medio del tag <code><nowiki><script></nowiki></code>). (Esto no es una característica del lenguaje, pero es común en la mayoría de las implementaciones de JavaScript.)

; Funciones variádicas: Un número indefinido de parámetros pueden ser pasados a la función. La función puede acceder a ellos a través de los parámetros o también a través del objeto local <code>arguments</code>. Las funciones variádicas también pueden ser creadas usando el método <code>.apply()</code>.

; Funciones como métodos: A diferencia de muchos lenguajes orientados a objetos, no hay distinción entre la definición de función y la definición de [[Método (informática)|método]]. Más bien, la distinción se produce durante la llamada a la función; una función puede ser llamada como un método. Cuando una función es llamada como un método de un objeto, la palabra clave <code>this</code>, que es una variable local a la función, representa al objeto que invocó dicha función.

; Arrays y la definición literal de objetos: Al igual que muchos lenguajes de script, arrays y objetos (arrays asociativos en otros idiomas) pueden ser creados con una sintaxis abreviada. De hecho, estos literales forman la base del formato de datos [[JSON]].

; Expresiones regulares: JavaScript también es compatible con [[expresiones regulares]] de una manera similar a [[Perl]], que proporcionan una sintaxis concisa y poderosa para la manipulación de texto que es más sofisticado que las funciones incorporadas a los objetos de tipo string.<ref>{{Cita libro|apellidos=Haverbeke |nombre=Marijn |título=Eloquent JavaScript |url=https://archive.org/details/eloquentjavascri00have_492 |año=2011 |editorial=No Starch Press |isbn=978-1593272821 |páginas=[https://archive.org/details/eloquentjavascri00have_492/page/n146 139]-149}}</ref>

=== Extensiones específicas del fabricante ===
JavaScript se encuentra oficialmente bajo la organización de [[Mozilla Foundation]], y periódicamente se añaden nuevas características del lenguaje. Sin embargo, solo algunos [[Intérprete de JavaScript|motores JavaScript]] son compatibles con estas características:

* Las propiedades <code>get</code> y <code>set</code> (también compatibles con WebKit, Opera,<ref>Robert Nyman, [http://robertnyman.com/2009/05/28/getters-and-setters-with-javascript-code-samples-and-demos/ Getters And Setters With JavaScript – Code Samples And Demos], published 29 May 2009, accessed 2 January 2010.</ref> ActionScript y Rhino).<ref>John Resig, [http://ejohn.org/blog/javascript-getters-and-setters/ JavaScript Getters and Setters], 18 July 2007, accessed 2 January 2010</ref>
* Cláusulas <code>catch</code> condicionales.
* Protocolo iterador adoptado de [[Python]].
* Corrutinas también adoptadas de Python.
* Generación de listas y expresiones por comprensión también adoptado de Python.
* Establecer el ámbito a bloque a través de la palabra clave <code>let</code>.
* Desestructuración de arrays y objetos (forma limita de emparejamiento de patrones).
* Expresiones concretas en funciones (function(args) expr).
* ECMAScript para XML (E4X), una extensión que añade compatibilidad nativa XML a ECMAScript.

== Sintaxis y semántica ==
La última versión del estándar que define Javascript es ECMAScript 2025. El estándar [[ECMAScript]] es publicado en junio de cada año por [[Ecma International|ECMA International]] bajo el código ECMA-262.<ref>http://www.ecma-international.org/publications/standards/Ecma-262.htm</ref>

=== Ejemplos sencillos ===
Las variables en JavaScript se definen usando la palabra clave [[Variable (programación)|var]]:<ref>{{Cita web |url=https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/var |título=var - JavaScript - MDN |editorial=The Mozilla Developer Network |fechaacceso=22 de diciembre de 2012}}</ref>
<syntaxhighlight lang="javascript">
var x; // define la variable x, aunque no tiene ningún valor asignado por defecto
var y = 2; // define la variable y y le asigna el valor 2 a ella
</syntaxhighlight>
A considerar los [[comentario (informática)|comentarios]] en el ejemplo de arriba, los cuales van precedidos con 2 barras diagonales.

No existen funcionalidades para [[Entrada/salida|I/O]] incluidas en el lenguaje; el entorno de ejecución ya lo proporciona. La especificación ECMAScript en su edición 5.1 hace mención:<ref>{{Cita web |url=http://www.ecma-international.org/ecma-262/5.1/#sec-4 |título=ECMAScript Language Specification - ECMA-262 Edition 5.1 |editorial=[[Ecma International]] |fechaacceso=22 de diciembre de 2012}}</ref>
<blockquote>... en efecto, no existen provisiones en esta especificación para entrada de datos externos o salida para resultados computados.</blockquote>

Sin embargo, la mayoría de los entornos de ejecución tiene un objeto<ref>{{Cita web |título=console |url=https://developer.mozilla.org/en-US/docs/DOM/console |obra=Mozilla Developer Network |editorial=[[Mozilla]] |fechaacceso=6 de abril de 2013}}</ref> llamado <code>console</code> que puede ser usado para imprimir por el flujo de salida de la consola de depuración. He aquí un simple programa que imprime «Hello world!»:
<syntaxhighlight lang="javascript">
console.log("Hello world!");
</syntaxhighlight>

Una función [[recursion|recursiva]]:
<syntaxhighlight lang="javascript">
function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1);
}
</syntaxhighlight>

Ejemplos de función anónima (o función [[lambda]]) y una clausura:
<syntaxhighlight lang="javascript">
var displayClosure = function() {
    var count = 0;
    return function () {
        return ++count;
    };
}
var inc = displayClosure();
inc(); // devuelve 1
inc(); // devuelve 2
inc(); // devuelve 3
</syntaxhighlight>

Las expresiones con invocación automática permiten a las funciones pasarle variables por parámetro dentro de sus propias clausuras.
<syntaxhighlight lang="javascript">
var v;
v = 1;
var getValue = (function(v) {
  return function() {return v;};
}(v));

v = 2;

getValue(); // 1
</syntaxhighlight>

=== Ejemplos más avanzados ===
El siguiente código muestra varias características de JavaScript.

<!-- No se intenta estandarizar el uso de ningún estilo estándar de codificación en este ejemplo—simplemente se intenta mostrar la sintaxis del lenguaje en este ejemplo -->
<div style="overflow:auto;">
<syntaxhighlight lang="javascript">/* Busca el mínimo común múltiplo (MCM) de dos números */
function LCMCalculator(x, y) { // función constructora
    var checkInt = function (x) { // función interior
        if (x % 1 !== 0) {
            throw new TypeError(x + " no es un entero"); // lanza una excepción
        }
        return x;
    };
    this.a = checkInt(x) // puntos y coma son opcionales
    this.b = checkInt(y);
}
// El prototipo de las instancias de objeto creados por el constructor es el de la propiedad "prototype" del constructor.
LCMCalculator.prototype = { // objeto definido como literal
    constructor: LCMCalculator, // cuando reasignamos un prototipo, establecemos correctamente su propiedad constructor
    gcd: function () { // método que calcula el máximo común divisor
        // Algoritmo de Euclides:
        var a = Math.abs(this.a), b = Math.abs(this.b), t;
        if (a < b) {
            // intercambiamos variables
            t = b;
            b = a;
            a = t;
        }
        while (b !== 0) {
            t = b;
            b = a % b;
            a = t;
        }
        // Solo necesitamos calcular el MCD una vez, por lo tanto 'redefinimos' este método.
        // (Realmente no es una redefinición—está definida en la propia instancia, por lo tanto
        // this.gcd se refiere a esta 'redefinición' en vez de a LCMCalculator.prototype.gcd).
        // Además, 'gcd' === "gcd", this['gcd'] === this.gcd
        this['gcd'] = function () {
            return a;
        };
        return a;
    },
    // Los nombres de las propiedades del objeto pueden ser especificados con cadenas delimitadas con comillas simples (') o dobles (").
    "lcm" : function () {
        // Los nombres de las variables no colisionan con las propiedades del objeto. Por ejemplo: |lcm| no es |this.lcm|.
        // No usar |this.a * this.b| para evitar problemas con cálculos en coma flotante.
        var lcm = this.a / this.gcd() * this.b;
        // Sólo necesitamos calcular MCM una vez, por lo tanto "redefinimos" este método.
        this.lcm = function () {
            return lcm;
        };
        return lcm;
    },
    toString: function () {
        return "LCMCalculator: a = " + this.a + ", b = " + this.b;
    }
};

// Definimos una función genérica para imprimir un resultado; esta implementación solo funciona en los navegadores web
function output(x) {
    document.body.appendChild(document.createTextNode(x));
    document.body.appendChild(document.createElement('br'));
}

// Nota: Los métodos.map() y.forEach() del prototipo Array están definidos en JavaScript 1.6.
// Estos métodos son usados aquí para demostrar la naturaleza funcional inherente del lenguaje.
[[25, 55], [21, 56], [22, 58], [28, 56]].map(function (pair) { // construcción literal de un Array + función de mapeo.
    return new LCMCalculator(pair[0], pair[1]);
}).sort(function (a, b) { // ordenamos la colección por medio de esta función
    return a.lcm() - b.lcm();
}).forEach(function (obj) {
    output(obj + ", gcd = " + obj.gcd() + ", lcm = " + obj.lcm());
});</syntaxhighlight>
</div>

El siguiente ejemplo muestra la salida que debería ser mostrada en la ventana de un navegador.

<syntaxhighlight lang="text">
LCMCalculator: a = 28, b = 56, gcd = 28, lcm = 56
LCMCalculator: a = 21, b = 56, gcd = 7, lcm = 168
LCMCalculator: a = 25, b = 55, gcd = 5, lcm = 275
LCMCalculator: a = 22, b = 58, gcd = 2, lcm = 638
</syntaxhighlight>

== Uso en páginas web ==
{{AP|Intérprete de JavaScript|AJAX}}
El uso más común de JavaScript es escribir funciones embebidas o incluidas en páginas HTML y que interactúan con el Document Object Model (DOM o Modelo de Objetos del Documento) de la página. Algunos ejemplos sencillos de este uso son:
* Cargar nuevo contenido para la página o enviar datos al servidor a través de AJAX sin necesidad de recargar la página (por ejemplo, una red social puede permitir al usuario enviar actualizaciones de estado sin salir de la página).
* Animación de los elementos de página, hacerlos desaparecer, cambiar su tamaño, moverlos, etc.
* Contenido interactivo, por ejemplo, juegos y reproducción de audio y vídeo.
* Validación de los valores de entrada de un formulario web para asegurarse de que son aceptables antes de ser enviado al servidor.
* Transmisión de información sobre los hábitos de lectura de los usuarios y las actividades de navegación a varios sitios web. Las páginas Web con frecuencia lo hacen para hacer análisis web, seguimiento de anuncios, la personalización o para otros fines.<ref>{{Cita web |url=http://piwik.org/docs/javascript-tracking/ |título=JavaScript tracking - Piwik |editorial=[[Piwik]] |fechaacceso=31 de marzo de 2012<!-- 17:56 (UTC)--> |urlarchivo=https://web.archive.org/web/20131031182703/http://piwik.org/docs/javascript-tracking/ |fechaarchivo=31 de octubre de 2013 }}</ref>

Dado que el código JavaScript puede ejecutarse localmente en el navegador del usuario (en lugar de en un servidor remoto), el navegador puede responder a las acciones del usuario con rapidez, haciendo una aplicación más sensible. Por otra parte, el código JavaScript puede detectar acciones de los usuarios que HTML por sí sola no puede, como pulsaciones de teclado. Las aplicaciones como [[Gmail]] se aprovechan de esto: la mayor parte de la lógica de la interfaz de usuario está escrita en JavaScript, enviando peticiones al servidor (por ejemplo, el contenido de un mensaje de correo electrónico). La tendencia cada vez mayor por el uso de la programación Ajax explota de manera similar esta técnica.

Un motor de JavaScript (también conocido como intérprete de JavaScript o implementación JavaScript) es un intérprete que interpreta el código fuente de JavaScript y ejecuta la secuencia de comandos en consecuencia. El primer motor de JavaScript fue creado por Brendan Eich en Netscape Communications Corporation, para el navegador web Netscape Navigator. El motor, denominado [[SpiderMonkey]], está implementado en C. Desde entonces, ha sido actualizado (en JavaScript 1.5) para cumplir con el ECMA-262 edición 3. El motor [[Rhino (intérprete de JavaScript)|Rhino]], creado principalmente por Norris Boyd (antes de Netscape, ahora en Google) es una implementación de JavaScript en [[Java (lenguaje de programación)|Java]]. [[Rhino (intérprete de JavaScript)|Rhino]], como [[SpiderMonkey]], es compatible con el ECMA-262 edición 3.

Un navegador web es, con mucho, el entorno de acogida más común para JavaScript. Los navegadores web suelen crear objetos no nativos, dependientes del entorno de ejecución, para representar el Document Object Model (DOM) en JavaScript. El servidor web es otro entorno común de servicios. Un servidor web JavaScript suele exponer sus propios objetos para representar objetos de petición y respuesta HTTP, que un programa JavaScript podría entonces interrogar y manipular para generar dinámicamente páginas web.

Debido a que JavaScript es el único lenguaje por el que los más populares navegadores comparten su apoyo, se ha convertido en un lenguaje al que muchos frameworks en otros lenguajes compilan, a pesar de que JavaScript no fue diseñado para tales propósitos.<ref name="computerworld">{{Cita web |apellido=Hamilton |nombre=Naomi |url=http://www.computerworld.com.au/article/255293/-z_programming_languages_javascript |título=The A-Z of Programming Languages: JavaScript |editorial=computerworld.com.au |fecha=31 de junio de 2008}}</ref> A pesar de las limitaciones de rendimiento inherentes a su naturaleza dinámica, el aumento de la velocidad de los motores de JavaScript ha hecho de este lenguaje un entorno para la compilación sorprendentemente factible.

=== Ejemplo de script ===
A continuación se muestra un breve ejemplo de una página web (ajustándose a las normas del estándar para [[HTML5]]) que utiliza JavaScript para el manejo del Document Object Model (DOM):
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Ejemplo sencillo</title>
</head>
<body>
    <h1 id="header">Esto es JavaScript</h1>

    <script>
        document.body.appendChild(document.createTextNode('Hola Mundo!'));
    
        var h1 = document.getElementById('header'); // contiene la referencia al tag <h1>
        h1 = document.getElementsByTagName('h1')[0]; // accediendo al mismo elemento <h1>
    </script>

    <noscript>Tu navegador no admite JavaScript, o JavaScript está deshabilitado.</noscript>
</body>
</html>
</syntaxhighlight>

=== Consideraciones acerca de la compatibilidad ===
{{AP|Interoperabilidad web}}
Debido a que JavaScript se ejecuta en entornos muy variados, una parte importante de las pruebas y la depuración es probar y verificar que el código JavaScript funciona correctamente en múltiples navegadores.
La interfaz DOM para acceder y manipular páginas web no es parte del estándar ECMAScript, o de la propia JavaScript. El DOM es definido por los esfuerzos de estandarización del [[W3C]], una organización independiente. En la práctica, las implementaciones que hacen de JavaScript los distintos navegadores difieren tanto entre ellos mismos como de las normas del estándar.

Para hacer frente a estas diferencias, los autores de JavaScript pudieron ser capaces de escribir código compatible con los estándares que también fuera capaz de ejecutarse correctamente en la mayoría de los navegadores, o en su defecto, que al menos se pudiera escribir código capaz de comprobar la presencia de ciertas funcionalidades del navegador y que se comportase de manera diferente si no se dispusiese de dicha funcionalidad.<ref>Peter-Paul Koch, [http://www.quirksmode.org/js/support.html Object detection]</ref> Existen casos en los que dos navegadores pueden llegar a implementar la misma característica, pero con un comportamiento diferente, hecho que a los programadores les puede resultar de ayuda para detectar qué navegador se está ejecutando en ese instante y así cambiar el comportamiento de su escritura para que coincida.<ref>Peter-Paul Koch, [http://www.evolt.org/node/23335 Mission Impossible - mouse position] {{Wayback|url=http://www.evolt.org/node/23335 |date=20181017042943 }}</ref><ref>Peter-Paul Koch, [http://www.quirksmode.org/js/detect.html Browser detect]</ref> Los programadores también suelen utilizar bibliotecas o herramientas que tengan en cuenta las diferencias entre navegadores.

Además, los scripts pueden no funcionar para algunos usuarios. Por ejemplo, un usuario puede:
* Utilizar un navegador antiguo sin compatibilidad completa con la API DOM,
* Utilizar un navegador PDA o teléfono móvil que no puede ejecutar JavaScript
* Tener la ejecución de JavaScript deshabilitada, como precaución de seguridad,
* Utilizar un navegador de voz debido a, por ejemplo, una discapacidad visual.

Para apoyar a estos usuarios, los programadores web suelen crear páginas que sean [[Tolerancia a fallos|tolerante de fallos]] según el agente de usuario (tipo de navegador) que no admita JavaScript. En particular, la página debe seguir siendo útil aunque sin las características adicionales que JavaScript habría añadido. Un enfoque alternativo que muchos encuentran preferible es primero crear contenido utilizando las tecnologías que funcionan en todos los navegadores, y mejorar el contenido para los usuarios que han permitido JavaScript.

=== Accesibilidad ===
{{AP|Accesibilidad web}}
Suponiendo que el usuario no haya desactivado la ejecución de código JavaScript, en el lado del cliente JavaScript debe ser escrito tanto con el propósito de mejorar las experiencias de los visitantes con discapacidad visual o física, como el de evitar ocultar información a estos visitantes.{{Harvnp|Flanagan|2006| pp=262–263}}

Los [[lector de pantalla|lectores de pantalla]], utilizados por los ciegos y deficientes visuales, pueden ser tenidos en cuenta por JavaScript y así poder acceder y leer los elementos DOM de la página. El código HTML escrito debe ser lo más conciso, navegable y semánticamente rico posible, tanto si JavaScript se ejecuta como si no.

JavaScript no debería de ser totalmente dependiente de los eventos de ratón del navegador y debería ser accesible para aquellos usuarios que no quieran hacer uso del [[ratón (informática)]] para navegar o que opten por utilizar solamente el teclado.
Hay eventos independientes del dispositivo, tales como <code>onfocus</code> y <code>onchange</code> que son preferibles en la mayoría de los casos.{{Harvnp|Flanagan|2006| pp=262–263}}

JavaScript no debe ser utilizado para crear confusión o desorientación al usuario web. Por ejemplo, modificar o desactivar la funcionalidad normal del navegador, como cambiar la forma en que el botón de navegar hacia atrás o el evento de actualización se comportan, son prácticas que generalmente son mejores evitar. Igualmente, desencadenar eventos que el usuario puede no tener en cuenta reduce la sensación de control del usuario y provoca cambios inesperados al contenido de la página.<ref>{{Cita web |título=Creating Accessible JavaScript |url=http://www.webaim.org/techniques/javascript/ |editorial=WebAIM |fechaacceso=8 de junio de 2010}}</ref>

A menudo, el proceso de dotar a una página web compleja el mayor grado [[accesibilidad web|accesibilidad]] posible, se convierte en un problema no trivial donde muchos temas se acaban llevando al debate y a la opinión, siendo necesario el compromiso de todos hasta el final. Sin embargo, los agentes de usuario y las tecnologías de apoyo a personas con discapacidad están en constante evolución y nuevas directrices e información al respecto siguen publicándose en la web.{{Harvnp|Flanagan|2006| pp=262–263}}

== Seguridad ==
{{AP|Seguridad del navegador}}

JavaScript y el DOM permite que existan programadores que hagan un uso inapropiado para introducir scripts que ejecuten código con contenido malicioso sin el consentimiento del usuario y que pueda así comprometer su seguridad.

Los desarrolladores de los navegadores tienen en cuenta este riesgo utilizando dos restricciones.
En primer lugar, los [[script]]s se ejecutan en un [[Sandbox (seguridad informática)|sandbox]] en el que solo se pueden llevar a cabo acciones relacionadas con la web, no con tareas de programación de propósito general, como la creación de archivos.
En segundo lugar, está limitada por la política del mismo origen: los scripts de un sitio web no tienen acceso a la información enviada a otro sitio web (de otro dominio) como pudiera ser nombres de usuario, contraseñas o cookies. La mayoría de los fallos de seguridad de JavaScript están relacionados con violaciones de cualquiera de estas dos restricciones.

Existen proyectos como AdSafe o Secure ECMA script (SES) que proporcionan mayores niveles de seguridad, en especial en el código creado por terceros (tales como los anuncios).<ref>[http://www.adsafe.org/ ADsafe - Making JavaScript Safe for Advertising]</ref><ref>[http://code.google.com/p/es-lab/wiki/SecureEcmaScript Secure ECMA Script (SES)]</ref>

La Política de Contenido Seguro (CSP) es el método principal previsto para garantizar que solo código de confianza pueda ser ejecutado en una página web.

=== Vulnerabilidades cross-site ===
{{AP|Cross-site scripting|Cross Site Request Forgery}}
Un problema común de seguridad en JavaScript es el [[cross-site scripting]] o XSS, una violación de la política de mismo origen. Las vulnerabilidades XSS permiten a un atacante inyectar código JavaScript en páginas web visitadas por el usuario. Una de esas webs podría ser la de un banco, pudiendo el atacante acceder a la aplicación de banca con los privilegios de la víctima, lo que podría revelar información secreta o transferir dinero sin la autorización de la víctima.
Una solución para las vulnerabilidades XSS es utilizar ''HTML escaping'' cuando se muestre información de fuentes no confiables.

Algunos navegadores incluyen una protección parcial contra los ataques XSS reflejados (el atacante está en la misma petición web). El atacante proporciona una URL incluyendo código malicioso. Sin embargo, incluso los usuarios de los navegadores son vulnerables a otros ataques XSS, tales como aquellos en los que el código malicioso se almacena en una base de datos. Solo el correcto diseño de las aplicaciones Web en la parte servidora puede prevenir totalmente XSS.
Las vulnerabilidades XSS también pueden ocurrir debido a errores de ejecución por los desarrolladores del navegador.<ref>MozillaZine, [http://www.mozillazine.org/talkback.html?article=4392 Mozilla Cross-Site Scripting Vulnerability Reported and Fixed]</ref>

Otra vulnerabilidad es la falsificación de petición de sitio cruzado o CSRF. En CSRF, el código del sitio web atacante engaña al navegador de la víctima, permitiendo al atacante realizar peticiones en nombre de la víctima, haciendo imposible saber a la aplicación de destino (por ejemplo, la de un banco haciendo una transferencia de dinero) saber si la petición ha sido realizada voluntariamente por el usuario o por un ataque CSRF.

El ataque funciona porque, si el sitio de destino hace uso únicamente de las cookies para autenticar las solicitudes de la víctima, las peticiones iniciadas por el código del atacante tendrán las mismas credenciales de acceso legítimo que las solicitudes iniciadas por el propio usuario.

En general, la solución a CSRF consiste en introducir un campo de formulario oculto cuyo valor se utilice para realizar la autenticación, y no solo por medio de las cookies, en solicitudes que puedan tener efectos duraderos. La comprobación de la cabecera HTTP referer también puede servir de ayuda.

«''Hijacking JavaScript''» es un tipo de ataque CSRF en el que una etiqueta <script> en el sitio web del atacante explota una vulnerabilidad en la página del sitio de la víctima que le hace devolver información privada, en forma de JSON o código JavaScript. Las posibles soluciones son:
* que se requiera un token de autenticación en los parámetros de las peticiones POST y GET para aquellas peticiones que requieran devolver información privada del usuario.
* usar POST y nunca GET para solicitudes que devuelven información privada

== Herramientas de desarrollo ==
En JavaScript, disponer de un depurador se convierte en necesario cuando se desarrollan grandes aplicaciones, no triviales. Dado que puede haber diferencias de implementación entre los diferentes navegadores (especialmente en cuanto al DOM), es útil tener acceso a un depurador para cada uno de los navegadores a los cuales nuestra [[aplicación web]] irá dirigido.<ref>{{Cita web |url=http://www.alistapart.com/articles/advanced-debugging-with-javascript/ |título=Advanced Debugging With JavaScript |editorial=alistapart.com |fecha=3 de febrero de 2009 |fechaacceso=28 de mayo de 2010}}</ref>

Los depuradores web están disponibles para Internet Explorer, Firefox, Safari, Google Chrome y Opera.<ref>{{Cita web |url=http://javascript.about.com/od/problemsolving/ig/JavaScript-Debugging/ |título=The JavaScript Debugging Console |editorial=javascript.about.com |fecha=28 de mayo de 2010 |fechaacceso=28 de mayo de 2010 |fechaarchivo=8 de abril de 2016 |urlarchivo=https://web.archive.org/web/20160408185418/http://javascript.about.com/od/problemsolving/ig/JavaScript-Debugging/ |deadurl=yes }}</ref>

Existen tres depuradores disponibles para [[Internet Explorer]]: [[Microsoft Visual Studio]] es el más avanzado de los tres, seguido de cerca por Microsoft Script Editor (un componente de [[Microsoft Office]])<ref>[http://msdn2.microsoft.com/en-us/library/aa202668(office.11).aspx JScript development in Microsoft Office 11] (MS InfoPath 2003)</ref> y, finalmente, Microsoft Script Debugger, que es mucho más básico que el otro dos, aunque es gratuito. El [[Entorno de desarrollo integrado|IDE]] gratuito Microsoft Visual Web Developer Express ofrece una versión limitada de la funcionalidad de depuración de JavaScript en el Microsoft Visual Studio. Internet Explorer ha incluido herramientas de desarrollo desde la versión 8 (se muestra pulsando la tecla F12).
Las aplicaciones web dentro de [[Firefox]] se pueden depurar usando el [[Firebug]] add-on o el antiguo depurador Venkman. Firefox también tiene integrada una consola de errores básica, que registra y evalúa JavaScript. También registra errores de [[Hojas de estilo en cascada|CSS]] y advertencias.
Opera incluye un conjunto de herramientas llamado Dragonfly.<ref>{{Cita web |url=http://www.opera.com/dragonfly/ |título=Opera DragonFly |editorial=Opera Software |fechaacceso=19 de mayo de 2013 |urlarchivo=https://www.webcitation.org/618EWbOQ4?url=http://www.opera.com/dragonfly/ |fechaarchivo=22 de agosto de 2011 }}</ref>
El Inspector Web de [[WebKit]] incluye un depurador de JavaScript<ref>{{Cita web |url=http://webkit.org/blog/61/introducing-drosera/ |título=Introducing Drosera - Surfin' Safari |editorial=Webkit.org |fecha=28 de junio de 2006 |fechaacceso=19 de mayo de 2009}}</ref> utilizado en [[Safari]], junto con una versión modificada de [[Google Chrome]].

Existen algunas herramientas de ayuda a la depuración, también escritas en JavaScript y construidas para ejecutarse en la Web. Un ejemplo es el programa [[JSLint]], desarrollado por [[Douglas Crockford]], quien ha escrito extensamente sobre el lenguaje. JSLint analiza el código JavaScript para que este quede conforme con un conjunto de normas y directrices y que aseguran su correcto funcionamiento y [[mantenibilidad]].

Hay frameworks de programación como '''PaulaJS''' que ofrece funciones para realizar sistemas de frontend con más utilidades que no hay que programar directamente, mejoras en estética y experiencia de usuario.

== Véase también ==
{{VT|VBScript|jQuery}}

== Referencias ==
{{listaref|2}}

== Enlaces externos ==
* [https://developer.mozilla.org/es/docs/Web/JavaScript Mozilla Developer Center].
* {{en}} [http://www.w3schools.com/js/ Javascript tutorial].
* [https://web.archive.org/web/20220327060138/https://reanimandowebs.com/articulos-sobre-programacion-web/javascript/ JavaScript - Mirando tras las bambalinas].
* [https://www.buscaminegocio.com/cursos-de-javascript/index.html Curso de JavaScript gratis].

{{Control de autoridades}}
[[Categoría:Lenguajes de programación]]
[[Categoría:Lenguajes interpretados]]
[[Categoría:JavaScript|JavaScript]]
[[Categoría:Lenguajes de programación orientada a objetos]]
[[Categoría:Lenguajes de programación basados en prototipos]]
[[Categoría:Software de 1995]]
[[Categoría:Netscape]]