**JavaScript** (**JS**) é unha linguaxe de programación interpretada, é dicir, que non require compilación, utilizada principalmente en páxinas web, cunha sintaxe semellante á da Linguaxe Java e a linguaxe C.

Ao contrario que Java, JavaScript non é unha linguaxe orientada a obxectos propiamente, xa que non dispón de herdanza, é máis ben unha linguaxe baseado en prototipos, xa que as novas clases xéranse clonando as clases base (prototipos) e estendendo a súa funcionalidade.

Todos os navegadores interpretan o código JavaScript integrado dentro das páxinas web. Para interactuar cunha páxina web provese á linguaxe JavaScript dun desenvolvemento do DOM. O seu uso máis estendido atópase en páxinas web HTML para realizar tarefas e operacións no marco da aplicación unicamente cliente, sen acceso a funcións do servidor. JavaScript execútase no axente de usuario ao mesmo tempo que as sentenzas van descargándose xunto co código HTML.

Historia
--------

### Comezos

A linguaxe foi inicialmente definida por Brendan Eich na empresa Netscape Communications. Netscape buscaba unha linguaxe interpretada máis lixeira que complementase á linguaxe Java atraendo a programadores non profesionais dunha forma semellante ao Microsoft Visual Basic.

Inicialmente déuselle o nome de *Mocha*, e posteriormente *LiveScript* nas súas primeiras inclusións en versións beta do Netscape Navigator 2.0, en setembro de 1995. Foi renomeada coma JavaScript nun anuncio conxunto de Netscape e Sun cando se lanzou na versión 2.0B3 do navegador de Netscape.

O nome final de *JavaScript* causou confusión dando a impresión de que a linguaxe era derivada de Java, polo que a elección do nome foi caracterizada coma unha manobra de mercadotecnia de Netscape para darlle máis renome grazas á popularidade da outra linguaxe.

### Adopción por parte de Microsoft

As tecnoloxías de Microsoft Windows VBScript e JScript lanzáronse en 1996. JScript, adaptado dende o JavaScript de Netscape, formou parte do lanzamento o 16 de xullo de 1996 do Internet Explorer 3, ademais de incluírse do lado do servidor no Internet Information Server. IE3 tamén incluíu o primeiro soporte de Microsoft para CSS e varias extensións de HTML, pero os desenvolvementos eran notablemente diferentes ás do Netscape Navigator.

### Estandarización

En 1997 os autores propuxeron JavaScript para que fose adoptado como estándar da *European Computer Manufacturers Association (ECMA)*, que a pesar do seu nome non é europea senón internacional, con sede en Xenebra. En xuño de 1997 foi adoptado como un estándar ECMA, co nome de ECMAScript. En 1998 foi a linguaxe foi adaptada á ISO/IEC-16262. 
A última versión do estándar ECMAScript é a 5.1, que data do ano 2011.

Ademais, para evitar incompatibilidades, o World Wide Web Consortium deseñou o estándar Document Object Model (DOM, o Modelo de Documento Obxecto), que incorporan Konqueror, as versións 6 de Internet Explorer e Netscape Navigator, Opera versión 7, e Mozilla Application Suite e Mozilla Firefox desde a súa primeira versión.

Características
---------------

Algunhas das características compartidas polas distintas versións de JavaScript son:

* **Imperativa e estruturada**
* **Dinámica**
	+ Uso de tipos dinámicos
	+ Baseada en obxectos
	+ Capacidades de avaliación en tempo de execución
* **Funcional**
	+ Uso de funcións de primeira clase
* **Baseada en prototipos**
	+ Uso de prototipos
	+ Uso de funcións como construtoras de obxectos
	+ Uso de funcións coma métodos
* **Delegación explícita e implícita**
	+ Uso de funcións coma roles
	+ Composición de obxectos e herdos

Exemplos de sintaxe
-------------------

#### Definición de variables

As variables en JavaScript defínense empregando a palabra chave `var`

```
var x; // defines the variable x, although no value is assigned to it by default
var y = 2; // defines the variable y and assigns the value of 2 to it

```

Os comentarios do exemplo anterior van precedidos polos caractéres "//".

#### Función recursiva

Unha función recursiva sinxela sería da forma:

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

```

#### Exemplo avanzado

Cálculo do mínimo común múltiplo de dous números:

```
/\* Finds the lowest common multiple (LCM) of two numbers \*/
function LCMCalculator(x, y) { // constructor function
 var checkInt = function (x) { // inner function
 if (x % 1 !== 0) {
 throw new TypeError(x + "is not an integer"); // throw an exception
 }
 return x;
 };
 this.a = checkInt(x)
 // semicolons ^^^^ are optional, a newline is enough
 this.b = checkInt(y);
}
// The prototype of object instances created by a constructor is
// that constructor's "prototype" property.
LCMCalculator.prototype = { // object literal
 constructor: LCMCalculator, // when reassigning a prototype, set the constructor property appropriately
 gcd: function () { // method that calculates the greatest common divisor
 // Euclidean algorithm:
 var a = Math.abs(this.a), b = Math.abs(this.b), t;
 if (a < b) {
 // swap variables
 t = b;
 b = a;
 a = t;
 }
 while (b !== 0) {
 t = b;
 b = a % b;
 a = t;
 }
 // Only need to calculate GCD once, so "redefine" this method.
 // (Actually not redefinition—it's defined on the instance itself,
 // so that this.gcd refers to this "redefinition" instead of LCMCalculator.prototype.gcd.
 // Note that this leads to a wrong result if the LCMCalculator object members "a" and/or "b" are altered afterwards.)
 // Also, 'gcd' === "gcd", this['gcd'] === this.gcd
 this['gcd'] = function () {
 return a;
 };
 return a;
 },
 // Object property names can be specified by strings delimited by double (") or single (') quotes.
 lcm : function () {
 // Variable names don't collide with object properties, e.g. |lcm| is not |this.lcm|.
 // not using |this.a \* this.b| to avoid FP precision issues
 var lcm = this.a / this.gcd() \* this.b;
 // Only need to calculate lcm once, so "redefine" this method.
 this.lcm = function () {
 return lcm;
 };
 return lcm;
 },
 toString: function () {
 return "LCMCalculator: a = "+ this.a + ", b = "+ this.b;
 }
};

// Define generic output function; this implementation only works for Web browsers
function output(x) {
 document.body.appendChild(document.createTextNode(x));
 document.body.appendChild(document.createElement('br'));
}

// Note: Array's map() and forEach() are defined in JavaScript 1.6.
// They are used here to demonstrate JavaScript's inherent functional nature.
[[25, 55], [21, 56], [22, 58], [28, 56]].map(function (pair) { // array literal + mapping function
 return new LCMCalculator(pair[0], pair[1]);
}).sort(function (a, b) { // sort with this comparative function
 return a.lcm() - b.lcm();
}).forEach(function (obj) {
 output(obj + ", gcd = "+ obj.gcd() + ", lcm = "+ obj.lcm());
});

```

Esta función dará coma resultado nun navegador:

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

Uso en páxinas web
------------------

*Véxase tamén**:* HTML dinámico.
O uso máis común do JavaScript é engadir comportamentos do lado do cliente ás páxinas HTML, o que se coñece coma HTML dinámico (DHTML). Os guións inclúense dende as páxinas HTML e interactúan co DOM da páxina.

Debido a que o código do JavaScript pode executarse localmente no navegador do usuario no canto de facelo nun servidor, o navegador pode responder ás accións do usuario de forma rápida, facendo que as aplicacións teñan un tempo de resposta maior. Ademais, o código JavaScript pode detectar accións de usuario que o HTML non pode por si mesmo. Moitas aplicacións, coma por exemplo Gmail, aprovéitanse destas funcións, empregando JavaScript na súas lóxicas de interface de usuario.

Notas
-----

1. ↑  Developer.mozilla.org, ed. (18 de novembro de 2012). "New in JavaScript 1.8.5 | Mozilla Developer Network" (en inglés). Arquivado dende o orixinal o 25 de decembro de 2018. Consultado o 26 de maio de 2013.
2. ↑  "ECMAScript Language Specification" (PDF) (en inglés). Arquivado dende o orixinal (PDF) o 12 de abril de 2015. Consultado o 17 de marzo de 2015.
3. ↑  The Little JavaScripter *(en inglés)*
4. ↑  Severance, Charles (febreiro de 2012). "JavaScript: Designing a Language in 10 Days". *Computer* (en inglés) **45** (2) (IEEE Computer Society). pp. 7–8. doi:10.1109/MC.2012.57. Consultado o 23 de marzo de 2013.
5. ↑  Press release announcing JavaScript, "Netscape and Sun announce JavaScript", PR Newswire. 4 de decembro de 1995 *(en inglés)*
6. ↑  "TechVision: Innovators of the Net: Brendan Eich and JavaScript" (en inglés). Web.archive.org. Arquivado dende o orixinal o 08 de febreiro de 2008. Consultado o 17 de marzo de 2015.
7. ↑  "Programming languages used on the Internet and the World Wide Web (WWW)" (en inglés). Webdevelopersnotes.com. Consultado o 19 de maio de 2009.
8. ↑  "O'Reilly - Safari Books Online - 0596101996 - JavaScript: The Definitive Guide, 5th Edition" (en inglés). Safari.oreilly.com. Arquivado dende o orixinal o 08 de decembro de 2008. Consultado o 19 de maio de 2009.
9. ↑  Champeon, Steve (4 de xuño de 2001). "JavaScript: How Did We Get Here?". O'Reilly Media. Arquivado dende o orixinal o 19 de xullo de 2016. Consultado o 9 de marzo de 2015.
10. ↑  "Microsoft Internet Explorer 3.0 Beta Now Available". Microsoft. 29 de maio de 1996. Consultado o 9 de marzo de 2015.
11. ↑  "Standard ECMA-262" (PDF). Arquivado dende o orixinal (PDF) o 12 de abril de 2015. Consultado o 26 de maio de 2013.
12. ↑  "var - JavaScript - MDN". The Mozilla Developer Network. Consultado o 22 de decembro do 2012.

Véxase tamén
------------

|  |  |
| --- | --- |
|  | Wikimedia Commons ten máis contidos multimedia na categoría:  ***JavaScript Modificar a ligazón no Wikidata*** |

|  |  |
| --- | --- |
|  | O Galilibros ten un manual sobre:  ***JavaScript*** |

### Outros artigos

* AJAX

### Bibliografía

* Duffy, Scott (2003). *How to do Everything with JavaScript* (en inglés). Osborne. ISBN 0-07-222887-3.
* Flanagan, David; Ferguson, Paula (2002). *JavaScript: The Definitive Guide* (4.ª ed.). ISBN 0-596-00048-0.
* Goodman, Danny; Eich, Brendan (2001). *JavaScript Bible* (en inglés). John Wiley & Sons. ISBN 0-7645-3342-8.
* Goodman, Danny; Markel, Scott (2003). *JavaScript and DHTML Cookbook* (en inglés). O'Reilly & Associates. ISBN 0-596-00467-2.

### Ligazóns externas

* referencia de JavaScript, de Sun *(en inglés)*
* Javascript módulo Perl en CPAN para executar JavaScript embebido en programas Perl, usando o motor SpiderMonkey *(en inglés)*
* JE módulo Perl en CPAN. Un motor ECMAScript (JavaScript) escrito en Perl *(en inglés)*
* módulos Perl para JavaScript en CPAN *(en inglés)*

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q2005
* BNE: XX542465
* BNF: 12549978q
* EBID: ID
* FAST: 982071
* GEC: 0262788
* GND: 4420180-1
* LCCN: sh96004880
* MAG: 544833334
* NKC: ph117651
* PSH: 13865
* SUDOC: 034781870

 |