JavaScript

Na Galipedia, a Wikipedia en galego.
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
Implementacións: 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

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.

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.

Historia[editar | editar a fonte]

Comezos[editar | editar a fonte]

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 Microsoft[editar | editar a fonte]

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, ademáis 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ón[editar | editar a fonte]

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]

Ademáis, 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ísticas[editar | editar a fonte]

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

Exemplos de sintaxe[editar | editar a fonte]

Definición de variables[editar | editar a fonte]

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 recursiva[editar | editar a fonte]

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

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

Exemplo avanzado[editar | editar a fonte]

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[editar | editar a fonte]

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. Ademáis, o código JavaScript pode detectar accións de usuario que o HTML non pode por sí 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[editar | editar a fonte]

  1. "New in JavaScript 1.8.5 | Mozilla Developer Network" (en inglés). Developer.mozilla.org. 18 de novembro de 2012. https://developer.mozilla.org/en/JavaScript/New_in_JavaScript/1.8.5. Consultado o 26 de maio de 2013.
  2. "ECMAScript Language Specification" (en inglés). http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf.
  3. The Little JavaScripter (en inglés)
  4. Severance, Charles (febreiro de 2012). "JavaScript: Designing a Language in 10 Days" (en inglés). Computer (IEEE Computer Society) 45 (2): pp. 7–8. DOI:10.1109/MC.2012.57. http://www.computer.org/csdl/mags/co/2012/02/mco2012020007-abs.html. 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 do orixinal o 8 de febreiro de 2008. https://web.archive.org/web/20080208124612/http://wp.netscape.com/comprod/columns/techvision/innovators_be.html.
  7. "Programming languages used on the Internet and the World Wide Web (WWW)" (en inglés). Webdevelopersnotes.com. http://www.webdevelopersnotes.com/basics/languages_on_the_internet.php3. 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. http://safari.oreilly.com/0596101996/jscript5-CHP-1. 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. http://archive.oreilly.com/pub/a/javascript/2001/04/06/js_history.html. Consultado o 9 de marzo de 2015.
  10. "Microsoft Internet Explorer 3.0 Beta Now Available". Microsoft. 29 de maio de 1996. http://news.microsoft.com/1996/05/29/microsoft-internet-explorer-3-0-beta-now-available/. Consultado o 9 de marzo de 2015.
  11. "Standard ECMA-262" (PDF). http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf. Consultado o 26 de maio de 2013.
  12. "var - JavaScript - MDN". The Mozilla Developer Network. https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/var. Consultado o 22 de decembro do 2012.

Véxase tamén[editar | editar a fonte]

Commons
Commons ten máis contidos multimedia na categoría: JavaScript Modificar a ligazón no Wikidata
Galilibros
O Galilibros ten un manual sobre: JavaScript

Outros artigos[editar | editar a fonte]

Bibliografía[editar | editar a fonte]

  • Duffy, Scott (2003) (en inglés). How to do Everything with JavaScript. 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) (en inglés). JavaScript Bible. John Wiley & Sons. ISBN 0-7645-3342-8.
  • Goodman, Danny; Markel, Scott (2003) (en inglés). JavaScript and DHTML Cookbook. O'Reilly & Associates. ISBN 0-596-00467-2.

Ligazóns externas[editar | editar a fonte]