Editando JavaScript (sección)

== 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.