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

JavaScript
Unofficial JavaScript logo 2.svg
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[1]
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[2], 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.[3]

Todos os navegadores interpretan o código JavaScript integrado dentro das páxinas web. Para interactuar cunha páxina web provese á linguaxe JavaScript dunha implementación 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.

Índice

HistoriaEditar

ComezosEditar

A linguaxe foi inicialmente definida por Brendan Eich na empresa Netscape Communications. Netscape buscaba un linguaxe interpretado máis lixeiro que complementase á Java atraendo a programadores non profesionais dunha forma semellante ao Microsoft Visual Basic.[4]

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

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 a popularidade da outra linguaxe.[7][8]

Adopción por parte de MicrosoftEditar

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 as implementacións eran notablemente diferentes ás do Netscape Navigator.[9][10]

EstandarizaciónEditar

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 é europeo 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 adaptado á ISO/IEC-16262. A última versión do estándar ECMAScript é a 5.1, que data do ano 2011.[11]

Ademais, para evitar incompatibilidades, o World Wide Web Consortium deseñou o estándar Document Object Model (DOM, ó Modelo de Obxectos do Documento en castelán), 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ísticasEditar

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

Exemplos de sintaxeEditar

Definición de variablesEditar

As variables en JavaScript defínense empregando a palabra chave var[12]

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 recursivaEditar

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

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

Exemplo avanzadoEditar

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 webEditar

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 respostar á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.

NotasEditar

  1. Developer.mozilla.org, ed. (18 de novembro de 2012). "New in JavaScript 1.8.5 | Mozilla Developer Network" (en inglés). Consultado o 26 de maio de 2013. 
  2. "ECMAScript Language Specification" (PDF) (en inglés). 
  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 8 de febreiro de 2008. 
  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. 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. 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). 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énEditar

Outros artigosEditar

BibliografíaEditar

  • 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 externasEditar