JavaScript

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.

JavaScript
Paradigma	Baseado en prototipos, Programación orientada a obxectos
Data	4 de decembro de 1995
Deseñador	Brendan Eich
Desenvolvedor	Netscape Communications, Mozilla Foundation
Última versión	1.8.5
Tipo de dato	Débil, dinámico
Postas en funcionamento	KJS, Rhino, SpiderMonkey, V8, Carakan, Chakra
Dialectos	JavaScript estándar e JScript (Javascript para IE)
Influído por	Java
Influíu	ActionScript, AtScript, CoffeeScript, Dart, JScript .NET, Objective-J, QML, TypeScript, LiveScript

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.

Véxase tamén

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)