JavaScript

**JavaScript** (embrivíu comúnmente **JS**) ye un llinguaxe de programación interpretáu, dialeutu del estándar ECMAScript. Defínese como Programación empobinada a oxetos empobináu a oxetos, Programación basada en prototipos basáu en prototipos, imperativu, sele tipado y dinámicu.

Utilízase principalmente na so forma del llau del veceru (''client-side''), implementáu como parte d'un navegador web dexando meyores na interfaz d'usuariu y páxina web dinámiques anque esiste una forma de JavaScript del llau del servidor(Server-side JavaScript o SSJS). El so usu n'aplicaciones esternes a la web, por casu en documentos PDF, aplicaciones d'escritoriu (mayoritariamente widgets) ye tamién significativu.

Dende'l 2012, tolos navegadores modernos soporten dafechu ECMAScript 5.1, una versión de javascript. Los navegadores más antiguos soporten a lo menos ECMAScript 3. La sesta edición lliberar en xunetu del 2015.

JavaScript diseñar con una sintaxis similar a C, anque adopta nomes y convenciones del llinguaxe de programación Java. Sicasí, Java y JavaScript tienen semántiques y propósitos distintos.

Toos el navegadores modernos interpreten el códigu JavaScript integráu nes páxines web. Pa interactuar con una páxina web aprovir al llinguaxe JavaScript d'una implementación del Document Object Model (DOM).

Tradicionalmente venía utilizándose en páxina web HTML pa realizar operaciones y namái nel marcu de l'aplicación vecera, ensin accesu a funciones del servidor. Anguaño ye llargamente utilizáu pa unviar y recibir información del servidor xunto con ayuda d'otres teunoloxíes como AJAX. JavaScript interpretar nel axente d'usuariu coles mesmes que les sentencies van descargándose xunto col códigu HTML.

Dende'l llanzamientu en xunu de 1997 del estándar ECMAScript 1, esistieron les versiones 2, 3 y 5, que ye la más usada anguaño (la 4 abandonóse). En xunu de 2015 cerróse y publicó la versión ECMAScript 6.

## Historia

### Nacencia de JavaScript
JavaScript foi desenvueltu orixinalmente por Brendan Eich de Netscape col nome de *Mocha*, que foi renomáu darréu a *LiveScript*, pa finalmente quedar como JavaScript. El cambéu de nome coincidió aproximao col momentu en que Netscape amestó compatibilidá cola teunoloxía Java na so navegador web Netscape Navigator na versión 2.002 n'avientu de 1995. La denominación produció tracamundiu, dando la impresión de que'l llinguaxe ye un allongamientu de Java, y caracterizóse por munchos como una estratexa de mercadotecnia de Netscape pa llograr prestíu y anovar nel ámbitu de los nuevos llinguaxes de programación web.

«JAVASCRIPT» ye una marca rexistrada d'Oracle Corporation. Ye usada con llicencia polos productos creaos por Netscape Communications y entidaes actuales como la Fundación Mozilla.

Microsoft dio como nome al so dialeutu de JavaScript «JScript», pa evitar problemes rellacionaes cola marca. JScript foi adoptáu na versión 3.0 d'Internet Explorer, lliberáu n'agostu de 1996, ya incluyó compatibilidá col Efeutu 2000 coles funciones de fecha, una diferencia de los que se basaben nesi momentu. Los dialeutos pueden paecer tan similares que los términos «JavaScript» y «JScript» de cutiu utilícense indistintamente, pero la especificación de JScript ye incompatible cola de ECMA en munchos aspeutos.

Pa evitar estes incompatibilidaes, el World Wide Web Consortium diseñó l'estándar Document Object Model (DOM, o Modelu d'Oxetos del Documentu n'español), qu'incorporen Konqueror, les versiones 6 d'Internet Explorer y Netscape Navigator, Opera la versión 7, Mozilla Application Suite y Mozilla Firefox dende la so primer versión.

En 1997 los autores propunxeron JavaScript por que fuera adoptáu como estándar de la European Computer Manufacturers 'Association ECMA, qu'a pesar del so nome nun ye européu sinón internacional, con sede en Xinebra. En xunu de 1997 foi adoptáu como un estándar ECMA, col nome d'ECMAScript. Poco dempués tamién como un estándar ISO.

### JavaScript nel llau servidor
Netscape introdució una implementación de script del llau del servidor con Netscape Enterprise Server, llanzada n'avientu de 1994 (pocu dempués del llanzamientu de JavaScript pa navegador web).
A partir de mediaos de la década de los 2000, hubo una proliferación de implementaciones de JavaScript pal llau servidor. Node.js ye unu de los notables exemplos de JavaScript nel llau del servidor, siendo usáu en proyeutos importantes.

### Desenvolvimientos posteriores

JavaScript convirtióse n'unu de los llinguaxes de programación más populares n'internet. De primeres, sicasí, munchos desarrolladores renegaben del llinguaxe porque'l públicu al que va empobináu formar publicadores d'artículos y demás aficionaos, ente otres razones. La llegada d'Ajax devolvió JavaScript a la fama y atraxo l'atención de munchos otros programadores. Como resultáu d'esto hubo una proliferación d'un conxuntu de frameworks y llibreríes d'ámbitu xeneral, ameyorando les práutiques de programación con JavaScript, y aumentáu l'usu de JavaScript fora de los navegador web, como se vio cola proliferación de redolaes JavaScript del llau del servidor.
En xineru de 2009, el proyeutu CommonJS foi inauguráu coles mires d'especificar una llibrería pa usu de xeres comunes principalmente pal desenvolvimientu fuera del navegador web.

En xunu de 2015 cerróse y publicó l'estándar ECMAScript 6 con un soporte irregular ente navegadores y que dota a JavaScript de carauterístiques avanzaes que s'echaben de menos y que son d'usu habitual n'otros llinguaxes como, por casu, módulos pa organización del códigu, verdaderes clases para programación empobinada a oxetos, espresiones de flecha, iteradores, xeneradores o promeses pa programación asíncrona.

La versión 7 de ECMAScript conozse como ECMAScript 2016, y ye la última versión disponible, publicada en xunu de 2016. Trátase de la primer versión pa la que s'usa un nuevu procedimientu de publicación añal y un procesu de desenvolvimientu abiertu.

## Carauterístiques

Les siguientes carauterístiques son comunes a toles implementaciones que s'afaen al estándar ECMAScript, nun siendo qu'especifique explícitamente en casu contrariu.

### Imperativu y estructurado
JavaScript ye compatible con gran parte de la estructura de programación de C (por casu, sentencies `if`, bucles `for`, sentencies `switch`, etc.). Con una salvedá, en parte: en C, l'ámbitu de les variables algama al bloque nel cual fueron definíes; sicasí JavaScript nun ye compatible con esto, yá que l'ámbitu de les variables ye'l de la función na cual fueron declaraes. Esto camuda cola versión de ECMAScript 2015, yá que añade compatibilidá con block scoping per mediu de la pallabra clave `let`. Como en C, JavaScript fai distinción ente espresiones y sentencies. Una diferencia sintáctica con al respective de C ye l'insertamientu automáticu de puntu y coma, esto ye, en JavaScript los puntos y coma que rematen una sentencia pueden ser omitíos.

### Dinámicu
; Tipado dinámicu: Como na mayoría de llinguaxes de scripting, el tipo ta acomuñáu al valor, non a la variable. Por casu, una variable `x` nun momentu dau pue tar amestada a un númberu y más palantre, religada a una cadena. JavaScript ye compatible con delles formes de comprobar el tipu d'un oxetu, incluyendo duck typing. Una forma de sabelo ye per mediu de la pallabra clave typeof.

; Objetual: JavaScript ta formáu casi na so totalidá por oxetos. Los oxetos en JavaScript son arrays asociativos, ameyoraos cola inclusión de prototipos (ver más palantre). Los nomes de les propiedaes de los oxetos son claves de tipo cadena: `obj.x&nbsp;=&nbsp;10` y `obj['x']&nbsp;=&nbsp;10` son equivalentes, siendo azucre sintáctico la notación con puntu. Les propiedaes y los sos valores pueden ser creaos, camudaos o esaniciaos en tiempu d'execución. La mayoría de propiedaes d'un oxetu (y aquelles que son incluyíes pola cadena del heriedu prototípicu) pueden ser numberaes a per mediu de la instrucción de bucle `for... in`. JavaScript tien un pequeñu númberu d'oxetos predefinidos como son `Function` y `Date`.

; Evaluación en tiempu d'execución: JavaScript inclúi la función `eval` que dexa evaluar espresiones espresaes como cadenes en tiempu d'execución. Por ello encamiéntase que eval sía utilizáu con procuru y que s'opte por utilizar la función `JSON.parse()` na midida de lo posible, pos resulta muncho más segura.

### Funcional
; Funciones de primer clase: A les funciones suélse-yos llamar ciudadanos de primer clase; son oxetos en sí mesmos. Como tal, tienen propiedaes y métodos, como `.call()` y `.bind()`. Una función añerada ye una función definida dientro d'otra. Esta ye creada cada vez que la función esterna ye invocada. Amás, cada función creada forma una clausura; ye la resultancia d'evaluar un ámbitu conteniendo nuna o más variables dependientes d'otru ámbitu esternu, incluyendo constantes, variables locales y argumentos de la función esterna llamante. La resultancia de la evaluación de felicidá clausura forma parte del estáu internu de cada oxetu función, inclusive dempués de que la función esterior concluya la so evaluación.

### Prototípicu
; Prototipos: JavaScript usa prototipos en cuenta de clases pal usu d'heriedu. Ye posible llegar a emular munches de les carauterístiques qu'apurren les clases en llinguaxes empobinaos a oxetos tradicionales per mediu de prototipos en JavaScript.

; Funciones como constructores d'oxetos: Les funciones tamién se porten como constructores. Prefijar una llamada a la función cola pallabra clave `new` crear una nueva instancia d'un prototipu, qu'herieden propiedaes y métodos del constructor (incluyíes les propiedaes del prototipu de `Object`). ECMAScript 5 ufierta'l métodu `Object.create`, dexando la creación esplícita d'una instancia ensin tener qu'heredar automáticamente del prototipu de Object (en redolaes antigües puede apaecer el prototipu del oxetu creáu como `null`). La propiedá `prototype` del constructor determina l'oxetu usáu pal prototipu internu de los nuevos oxetos creaos. Pueden añader nuevos métodos modificando'l prototipu del oxetu usáu como constructor. Constructores predefinidos en JavaScript, como `Array` o `Object`, tamién tienen prototipos que pueden ser modificaos. Anque esto sía posible considérase una mala práutica modificar el prototipu de Object yá que la mayoría de los oxetos en Javascript herieden los métodos y propiedaes del oxetu prototype, oxetos los cualos pueden esperar qu'estos nun fueren modificaos.

### Otres carauterístiques
; Redolada d'execución: JavaScript de normal depende de la redolada nel que s'execute (por casu, nun navegador web) pa ufiertar oxetos y métodos polos que los scripts pueden interactuar col "mundu esterior". Ello ye que depende de la redolada pa ser capaz d'apurrir la capacidá d'incluyir o importar scripts (por casu, en HTML per mediu del tag ``). (Esto nun ye una carauterística del llinguaxe, pero ye común na mayoría de les implementaciones de JavaScript.)

; Funciones variádicas: Un númberu indefiníu de parámetros pueden ser pasaos a la función. La función puede aportar a ellos al traviés de los parámetros o tamién al traviés del oxetu local `arguments`. Les funciones variádicas tamién pueden ser creaes usando'l métodu `.apply()`.

; Funciones como métodos: A diferencia de munchos llinguaxes empobinaos a oxetos, nun hai distinción ente la definición de función y la definición de métodu. Más bien, la distinción producir mientres la llamada a la función; una función puede ser llamada como un métodu. Cuando una función ye llamada como un métodu d'un oxetu, la pallabra clave `this`, que ye una variable local a la función, representa al oxetu qu'invocó dicha función.

; Arrays y la definición lliteral d'oxetos: Al igual que munchos llinguaxes de script, arrays y oxetos (arrays asociativos n'otros idiomes) pueden ser creaos con una sintaxis embrivida. Ello ye que estos lliterales formen la base del formatu de datos JSON.

; Espresiones regulares: JavaScript tamién ye compatible con espresiones regulares d'una manera similar a Perl, qu'apurren una sintaxis concisa y poderosa pa la manipulación de testu que ye más sofisticáu que les funciones incorporaes a los oxetos de tipu string.

### Estensiones específiques del fabricante
JavaScript atópase oficialmente so la organización de Mozilla Foundation, y dacuando añader nueves carauterístiques del llinguaxe. Sicasí, namái dalgunos motores JavaScript son compatibles con estes carauterístiques:

* Les propiedaes get y set (tamién compatibles con WebKit, Opera, ActionScript y Rhino).
* Cláusules `catch` condicionales.
* Protocolu iterador adoptáu de Python.
* Corrutinas tamién adoptaes de Python.
* Xeneración de llistes y espresiones per comprensión tamién adoptáu de Python.
* Establecer l'ámbitu a bloque al traviés de la pallabra clave `let`.
* Desestructuración de arrays y oxetos (forma llinda d'axugamientu de patrones).
* Espresiones concretes en funciones (function(args) expr).
* ECMAScript para XML (Y4X), una estensión qu'añade compatibilidá nativa XML a ECMAScript.

## Sintaxis y semántica

la última versión del llinguaxe ye ECMAScript 2016 publicada'l 17 de xunu del 2016

### Exemplos senciellos
Les variables en JavaScript defínense usando la pallabra clave var:

```javascript
var x; // define la variable x, anque nun tien nengún valor asignáu por defectu var
y = 2; // define la variable y y asígna-y el valor 2 a ella
```


A considerar los comentarios nel exemplu de riba, que van precedíos con 2 barres diagonales.

Nun esisten funcionalidades para I/O incluyíes nel llinguaxe; la redolada d'execución yá la apurre. La especificación ECMAScript na so edición 5.1 fai mención:
... n'efeutu, nun esisten provisiones nesta especificación pa entrada de datos esternos o salida pa resultaos computaes.

Sicasí, la mayoría de les redolaes d'execución tien un oxetu llamáu `console` que puede ser usáu pa imprimir pol fluxu de salida de la consola de depuración. He equí un simple programa qu'imprime “Hello world!”:

```javascript
console.log("Hello world!");
```


Una función recursiva:

```javascript
function factorial(n) {
 if (n === 0) {
 return 1;
 }
 return n * factorial(n - 1);
}
```


Exemplos de función anónima (o función lambda) y una clausura:

```javascript
var displayClosure = function() {
 var count = 0;
 return function () {
 return ++count;
 };
}
var inc = displayClosure();
inc(); // devuelve 1
inc(); // devuelve 2
inc(); // devuelve 3
```


Les espresiones con invocación automática dexen a les funciones pasa-y variables per parámetru dientro de les sos propies clausures.

```javascript
var v;
v = 1;
var getValue = (function(v) {
 return function() {return v;};
}(v));

v = 2;

getValue(); // 1
```


### Exemplos más avanzaos
El siguiente códigu amuesa delles carauterístiques de JavaScript.



```javascript
/* Busca'l mínimu común múltiplu (MCM) de dos númberos */
function LCMCalculator(x, y) { // función constructora var
 checkInt = function (x) { // función interior
 if (x % 1 !== 0) {
 throw new TypeError(x + " nun ye un enteru"); // llanza una esceición
 }
 return x;
 };
 this.a = checkInt(x) // puntos y coma son opcionales
 this.b = checkInt(y);
}
// El prototipu de les instancies d'oxetu creaos pol constructor ye'l de la propiedá “prototype” del constructor.
LCMCalculator.prototype = { // oxetu definíu como lliteral
 constructor: LCMCalculator, // cuando reasignamos un prototipu, establecemos correutamente la so propiedá constructor
 gcd: function () { // métodu que calcula'l máximu común divisor
 // Algoritmu d'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 precisamos calcular el MCD una vegada, polo tanto 'redefinimos' esti métodu.
 // (Realmente nun ye una redefinición—ta definida na mesma instancia, polo tanto //
 this.gcd referir a esta 'redefinición' en cuenta de a LCMCalculator.prototype.gcd).
 // Amás, 'gcd' === "gcd", this['gcd'] === this.gcd
 this['gcd'] = function () {
 return a;
 };
 return a;
 }, //
 Los nomes de les propiedaes del oxetu pueden ser especificaos con cadenes delimitadas con comines simples (') o dobles (").
 "lcm" : function () {
 // Los nomes de les variables nun topeten coles propiedaes del oxetu. Por casu: |lcm| nun ye |this.lcm|.
 // Nun usar |this.a * this.b| pa evitar problemes con cálculos en coma flotante.
 var lcm = this.a / this.gcd() * this.b;
 // Namái precisamos calcular MCM una vegada, polo tanto "redefinimos" esti métodu.
 this.lcm = function () {
 return lcm;
 };
 return lcm;
 }, toString:
 function () {
 return "LCMCalculator: a = " + this.a + ", b = " + this.b;
 }
};

// Definimos una función xenérica pa imprimir una resultancia; esta implementación solo funciona n'el 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 prototipu Array tán definíos en JavaScript 1.6.
// Estos métodos son usaos equí pa demostrar la naturaleza funcional inherente del llinguaxe.
[[25, 55], [21, 56], [22, 58], [28, 56]].map(function (pair) { // construcción lliteral d'un Array + función de mapeo.
 return new LCMCalculator(pair[0], pair[1]);
}).sort(function (a, b) { // ordenamos la coleición per mediu d'esta función
 return a.lcm() - b.lcm();
}).forEach(function (obj) {
 output(obj + ", gcd = " + obj.gcd() + ", lcm = " + obj.lcm());
});
```



El siguiente exemplu amuesa la salida que tendría de ser amosada na ventana d'un navegador.


```html4strict
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
```



## Usu en páxina web

L'usu más común de JavaScript ye escribir funciones enfiñíes o incluyíes en páxina HTML y que interactúan col Document Object Model (DOM o Modelu d'Oxetos del Documentu) de la páxina. Dellos exemplos senciellos d'esti usu son:
* Cargar nuevu conteníu pa la páxina o unviar datos al servidor al traviés de AJAX ensin necesidá de recargar la páxina (por casu, una rede social puede dexar al usuariu unviar actualizaciones d'estáu ensin salir de la páxina).
* Animación de los elementos de páxina, faelos sumir, camudar el so tamañu, movelos, etc.
* Conteníu interactivo, por casu, xuegos y reproducción d'audiu y videu.
* Validación de los valores d'entrada d'un formulariu web p'asegurase de que son aceptables antes de ser unviáu al servidor.
* Tresmisión d'información sobre los vezos de llectura de los usuarios y les actividaes de navegación a dellos sitios web. Les páxines Web con frecuencia facer pa faer analís web, siguimientu d'anuncios, la personalización o pa otros fines.

Yá que el códigu JavaScript puede executase llocalmente nel navegador del usuariu (en llugar d'en un servidor remotu), el navegador puede responder a les aiciones del usuariu con rapidez, faciendo una aplicación más sensible. Per otra parte, el códigu JavaScript puede detectar aiciones de los usuarios qu'HTML por sigo sola nun puede, como pulsaciones de tecláu. Les aplicaciones como Gmail aprovechar d'esto: la mayor parte de la lóxica de la interfaz d'usuariu ta escrita en JavaScript, unviando pidimientos al servidor (por casu, el conteníu d'un mensaxe de corréu electrónicu). L'enclín cada vez mayor pol usu de la programación Ajax esplota de manera similar esta téunica.

Un motor de JavaScript (tamién conocíu como intérprete de JavaScript o implementación JavaScript) ye un intérprete qu'interpreta'l códigu fonte de JavaScript y executa la secuencia de comandos en consecuencia. El primer motor de JavaScript foi creáu por Brendan Eich en Netscape Communications Corporation, pal navegador web Netscape Navigator. El motor, denomináu SpiderMonkey, ta implementáu en C. De magar, foi actualizáu (en JavaScript 1.5) pa cumplir col ECMA-262 edición 3. El motor Rhino, creáu principalmente por Norris Boyd (antes de Netscape, agora en Google) ye una implementación de JavaScript en Java. Rhino, como SpiderMonkey, ye compatible col ECMA-262 edición 3.

Un navegador web ye, con muncho, la redolada d'acoyida más común pa JavaScript. El navegadores web suelen crear oxetos non nativos, dependientes de la redolada d'execución, pa representar el Document Object Model (DOM) en JavaScript. El servidor web ye otra redolada común de servicios. Un servidor web JavaScript suel esponer los sos propios oxetos pa representar oxetos de pidimientu y respuesta HTTP, qu'un programa JavaScript podría entós entrugar y manipoliar pa xenerar dinámicamente páxina web.

Por cuenta de que JavaScript ye l'únicu llinguaxe pol que los más populares navegadores comparten el so sofitu, convirtióse nun llinguaxe al que munchos frameworks n'otros llinguaxes compilan, a pesar de que JavaScript nun foi diseñáu pa tales propósitos. A pesar de les llimitaciones de rendimientu inherentes a la so naturaleza dinámica, l'aumentu de la velocidá de los motores de JavaScript fixo d'esti llinguaxe una redolada pa la compilación sorprendentemente facedera.

### Exemplu de script
De siguío amuésase un curtiu exemplu d'una páxina web (ajustadose a les normes del estándar pa HTML5) qu'utiliza JavaScript pal manexu del DOM:

```html5
<!DOCTYPE html>
<html>
<head>
 <meta charset="utf-8">
 <title>Exemplu senciellu</title>
</head>
<body>
 <h1 id="header">Esto ye JavaScript</h1>

 <script>
 document.body.appendChild(document.createTextNode('Hola Mundu!'));
 
 var h1 = document.getElementById('header'); // contién la referencia al tag <h1>
 h1 = document.getElementsByTagName('h1')[0]; // aportando al mesmu elementu <h1>
 </script>

 <noscript>El to navegador nun almite JavaScript, o JavaScript ta evacuáu.</noscript>
</body>
</html>
```


### Considerancies alrodiu de la compatibilidá

Por cuenta de que JavaScript executar en redolaes bien variaes, una parte importante de les pruebes y la depuración ye probar y verificar que'l códigu JavaScript funciona correutamente en múltiples navegadores.
La interfaz DOM p'aportar y manipoliar páxina web nun ye parte del estándar ECMAScript, o de la mesma JavaScript. El DOM ye definíu polos esfuerciu d'estandarización del W3C, una organización independiente. Na práutica, les implementaciones que faen de JavaScript los distintos navegadores difieren tantu ente ellos mesmos como de les normes del estándar.

Pa faer frente a estes diferencies, los autores de JavaScript pudieron ser capaces d'escribir códigu compatible colos estándares que tamién fuera capaz d'executase correutamente na mayoría de los navegadores, o nel so defectu, que siquier se pudiera escribir códigu capaz de comprobar la presencia de ciertes funcionalidades del navegador y que se portara de manera distinta si nun se dispunxera de felicidá funcionalidad. Esisten casos nos que dos navegadores pueden llegar a implementar la mesma carauterística, pero con un comportamientu distintu, fechu qu'a los programadores puede resulta-yos d'ayuda pa detectar qué navegador se ta executando nesi intre y asina camudar el comportamientu de la so escritura por que coincida. El programadores tamién suelen utilizar biblioteques o ferramientes que tengan en cuenta les diferencies ente navegadores.

Amás, los scripts pueden nun funcionar pa dellos usuarios. Por casu, un usuariu puede:
* utilizar un navegador antiguu ensin compatibilidá completa cola API DOM, *
utilizar un navegador PDA o teléfonu móvil que nun puede executar JavaScript
* tener la execución de JavaScript evacuada, como procuru de seguridá, *
utilizar un navegador de voz por cuenta de, por casu, una discapacidá visual.

Pa sofitar a estos usuarios, el programadores web suelen crear páxines que sían Tolerancia a fallos tolerante a fallos según l'axente d'usuariu (tipu de navegador) que nun almita JavaScript. En particular, la páxina tien de siguir siendo útil anque ensin les carauterístiques adicionales que JavaScript añadiría. Un enfoque alternativu que munchos atopen preferible ye primero crear conteníu utilizando les teunoloxíes que funcionen en tolos navegadores, y ameyorar el conteníu pa los usuarios que dexaron JavaScript.

### Accesibilidá

Suponiendo que l'usuariu nun desactivara la execución de códigu JavaScript, nel llau del veceru JavaScript ten de ser escritu tantu col propósitu d'ameyorar les esperiencies de los visitantes con discapacidá visual o física, como'l d'evitar despintar información a estos visitantes.

Los llector de pantalla llectores de pantalla, utilizaos polos ciegos y deficientes visuales, pueden ser teníos en cuenta por JavaScript y asina poder aportar y lleer los elementos DOM de la páxina. El códigu HTML escritu ten de ser lo más conciso, navegable y semánticamente ricu posible, tanto si JavaScript execútase como si non.

JavaScript nun debería de ser totalmente dependiente de los eventos de ratón del navegador y tendría de ser accesible p'aquellos usuarios que nun quieran faer usu del ratón pa navegar o qu'opten por utilizar solamente'l tecláu.
Hai eventos independientes del dispositivu, tales como `onfocus` y `onchange` que son preferibles na mayoría de los casos.

JavaScript nun tien de ser utilizáu pa crear tracamundiu o desorientación al usuariu web. Por casu, modificar o desactivar la funcionalidad normal del navegador, como camudar la forma en que'l botón de navegar escontra tras o l'eventu d'actualización pórtense, son práutiques que xeneralmente son meyores evitar. Igualmente, desencadenar eventos que l'usuariu puede nun tener en cuenta amenorga la sensación de control del usuariu y provoca cambeos inesperaos al conteníu de la páxina.

De cutiu, el procesu de dotar a una páxina web complexa'l mayor grau accesibilidá posible, convertir nun problema non trivial onde munches temes acaben llevándose al alderique y a la opinión, siendo necesariu'l compromisu de toos hasta'l final. Sicasí, los axentes d'usuariu y les teunoloxíes de sofitu a persones con discapacidá tán en constante evolución y nueves directrices ya información al respeutu siguen publicar na web.

## Seguridá

JavaScript y el DOM dexa qu'esistan programadores que faigan un usu desaveniente pa introducir scripts qu'executen códigu con conteníu malicioso ensin el consentimientu del usuariu y que pueda asina comprometer la so seguridá.

Los desarrolladores de los navegadores tienen en cuenta esti riesgu utilizando dos restricciones.
De primeres, los scripts executar nun sandbox nel que namái se pueden llevar a cabu remanes rellacionaes cola web, non con xeres de programación de propósitu xeneral, como la creación d'archivos.
De segundes, ta llindada pola política del mesmu orixe: los scripts d'un sitiu web nun tienen accesu a la información unviada a otru sitio web (d'otru dominiu) como pudiera ser nomes d'usuariu, contraseñes o cookies. La mayoría de los fallos de seguridá de JavaScript tán rellacionaos con violaciones de cualesquier d'estos dos restricciones.

Esisten proyeutos como AdSafe o Secure ECMA script (SES) qu'apurren mayores niveles de seguridá, cuantimás nel códigu creáu por terceros (tales como los anuncios).

La Política de Conteníu Seguro (CSP) ye'l métodu principal previstu pa garantizar que namái códigu d'enfotu pueda ser executáu nuna páxina web.

### Vulnerabilidad cross-site

Un problema común de seguridá en JavaScript ye'l cross-site scripting o XSS, una violación de la política de mesmu orixe. Les vulnerabilidaes XSS dexen a un atacante inyectar códigu JavaScript en páxina web visitaes pol usuariu. Una d'eses webs podría ser la d'un bancu, pudiendo l'atacante aportar a l'aplicación de banca colos privilexos de la víctima, lo que podría revelar información secreta o tresferir dineru ensin l'autorización de la víctima.
Una solución pa les vulnerabilidaes XSS ye utilizar *HTML escaping* cuando s'amuese información de fontes non confiables

Dellos navegadores inclúin una proteición parcial contra los ataques XSS reflexaos (l'atacante ta nel mesmu pidimientu web). L'atacante apurre una URL incluyendo códigu maliciosu. Sicasí, inclusive los usuarios de los navegadores son vulnerables a otros ataques XSS, tales como aquellos nos que'l códigu maliciosu almacenar nuna base de datos. Namái'l correutu diseñu de les aplicaciones Web na parte servidora puede prevenir totalmente XSS.
Les vulnerabilidaes XSS tamién pueden asoceder por cuenta d'errores d'execución polos desarrolladores del navegador.

Otra vulnerabilidá ye la falsificación de pidimientu de sitiu cruzáu o CSRF. En CSRF, el códigu del sitio web atacante engaña al navegador de la víctima, dexando al atacante realizar pidimientos en nome de la víctima, faciendo imposible saber a l'aplicación de destín (por casu, la d'un bancu faciendo una tresferencia de dineru) saber si'l pidimientu foi realizada voluntariamente pol usuariu o por un ataque CSRF.

L'ataque funciona porque, si'l sitiu de destín fai usu namái de les cookies pa autenticar les solicitúes de la víctima, los pidimientos empecipiaos pol códigu del atacante van tener les mesmes credenciales d'accesu llexítimu que les solicitúes empecipiaes pol mesmu usuariu.

Polo xeneral, la solución a CSRF consiste n'introducir un campu de formulariu ocultu que'l so valor utilizar pa realizar la autenticación, y non yá per mediu de les cookies, en solicitúes que puedan tener efeutos duraderos. La comprobación de la cabecera HTTP referer tamién puede sirvir d'ayuda.

"Hijacking JavaScript" ye un tipu d'ataque CSRF nel qu'una etiqueta  nel sitiu web del atacante esplota una vulnerabilidá na páxina del sitiu de la víctima que-y fai devolver información privada, en forma de JSON o códigu JavaScript. Les posibles soluciones son:
* que se riquir un token de autenticación nos parámetros de los pidimientos POST y GET p'aquellos pidimientos que rican devolver información privada del usuariu.
* usar POST y nunca GET pa solicitúes que devuelven información privada

## Ferramientes de desenvolvimientu
En JavaScript, disponer d'un depurador convertir en necesariu cuando se desenvuelven grandes aplicaciones, non triviales. Yá que puede haber diferencies de implementación ente los distintos navegadores (especialmente en cuanto al DOM), ye útil tener accesu a un depurador pa cada unu de los navegadores a los cualos nuesa aplicación web va dir empobináu.

Los depuradores web tán disponibles pa Internet Explorer, Firefox, Safari, Google Chrome y Opera.

Esisten trés depuradores disponibles para Internet Explorer: Microsoft Visual Studio ye'l más avanzáu de los trés, siguíu de cerca por Microsoft Script Editor (un componente de Microsoft Office) y, finalmente, Microsoft Script Debugger, que ye muncho más básicu que l'otru dos, anque ye gratuitu. L'IDE gratuitu Microsoft Visual Web Developer Express ufierta una versión llindada de la funcionalidad de depuración de JavaScript nel Microsoft Visual Studio. Internet Explorer incluyó ferramientes de desenvolvimientu dende la versión 8 (amuésase pulsiando la tecla F12).
Les aplicaciones web dientro de Firefox pueden depurase usando'l Firebug add-on o l'antiguu depurador Venkman. Firefox tamién tien integrada una consola d'errores básica, que rexistra y evalúa JavaScript. Tamién rexistra errores de CSS y alvertencies.
Opera inclúi un conxuntu de ferramientes llamáu Dragonfly.
L'Inspector Web de WebKit inclúi un depurador de JavaScript utilizáu en Safari, xunto con una versión modificada de Google Chrome.

Esisten delles ferramientes d'ayuda a la depuración, tamién escrites en JavaScript y construyíes pa executase na Web. Un exemplu ye'l programa JSLint, desenvueltu por Douglas Crockford, quien escribió estensamente sobre'l llinguaxe. JSLint analiza'l códigu JavaScript por que esti quede conforme con un conxuntu de normes y directrices y qu'aseguren el so correutu funcionamientu y mantenibilidad.

## Ver tamién
* VBScript
* AJAX
* Aplicación web
* Document Object Model
* JSON
* HTML

## Referencies

## Bibliografía
* 

## Enllaces esternos
* Mozilla Developer Center
* slice( ) - O'Reilly Answers (n'inglés)
* Distinción ente variables locales y globales
* Javascript tutorial