Editando JavaScript (sección)

== Sintaxis y semántica ==
La última versión del estándar que define Javascript es ECMAScript 2025. El estándar [[ECMAScript]] es publicado en junio de cada año por [[Ecma International|ECMA International]] bajo el código ECMA-262.<ref>http://www.ecma-international.org/publications/standards/Ecma-262.htm</ref>

=== Ejemplos sencillos ===
Las variables en JavaScript se definen usando la palabra clave [[Variable (programación)|var]]:<ref>{{Cita web |url=https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/var |título=var - JavaScript - MDN |editorial=The Mozilla Developer Network |fechaacceso=22 de diciembre de 2012}}</ref>
<syntaxhighlight lang="javascript">
var x; // define la variable x, aunque no tiene ningún valor asignado por defecto
var y = 2; // define la variable y y le asigna el valor 2 a ella
</syntaxhighlight>
A considerar los [[comentario (informática)|comentarios]] en el ejemplo de arriba, los cuales van precedidos con 2 barras diagonales.

No existen funcionalidades para [[Entrada/salida|I/O]] incluidas en el lenguaje; el entorno de ejecución ya lo proporciona. La especificación ECMAScript en su edición 5.1 hace mención:<ref>{{Cita web |url=http://www.ecma-international.org/ecma-262/5.1/#sec-4 |título=ECMAScript Language Specification - ECMA-262 Edition 5.1 |editorial=[[Ecma International]] |fechaacceso=22 de diciembre de 2012}}</ref>
<blockquote>... en efecto, no existen provisiones en esta especificación para entrada de datos externos o salida para resultados computados.</blockquote>

Sin embargo, la mayoría de los entornos de ejecución tiene un objeto<ref>{{Cita web |título=console |url=https://developer.mozilla.org/en-US/docs/DOM/console |obra=Mozilla Developer Network |editorial=[[Mozilla]] |fechaacceso=6 de abril de 2013}}</ref> llamado <code>console</code> que puede ser usado para imprimir por el flujo de salida de la consola de depuración. He aquí un simple programa que imprime «Hello world!»:
<syntaxhighlight lang="javascript">
console.log("Hello world!");
</syntaxhighlight>

Una función [[recursion|recursiva]]:
<syntaxhighlight lang="javascript">
function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1);
}
</syntaxhighlight>

Ejemplos de función anónima (o función [[lambda]]) y una clausura:
<syntaxhighlight lang="javascript">
var displayClosure = function() {
    var count = 0;
    return function () {
        return ++count;
    };
}
var inc = displayClosure();
inc(); // devuelve 1
inc(); // devuelve 2
inc(); // devuelve 3
</syntaxhighlight>

Las expresiones con invocación automática permiten a las funciones pasarle variables por parámetro dentro de sus propias clausuras.
<syntaxhighlight lang="javascript">
var v;
v = 1;
var getValue = (function(v) {
  return function() {return v;};
}(v));

v = 2;

getValue(); // 1
</syntaxhighlight>

=== Ejemplos más avanzados ===
El siguiente código muestra varias características de JavaScript.

<!-- No se intenta estandarizar el uso de ningún estilo estándar de codificación en este ejemplo—simplemente se intenta mostrar la sintaxis del lenguaje en este ejemplo -->
<div style="overflow:auto;">
<syntaxhighlight lang="javascript">/* Busca el mínimo común múltiplo (MCM) de dos números */
function LCMCalculator(x, y) { // función constructora
    var checkInt = function (x) { // función interior
        if (x % 1 !== 0) {
            throw new TypeError(x + " no es un entero"); // lanza una excepción
        }
        return x;
    };
    this.a = checkInt(x) // puntos y coma son opcionales
    this.b = checkInt(y);
}
// El prototipo de las instancias de objeto creados por el constructor es el de la propiedad "prototype" del constructor.
LCMCalculator.prototype = { // objeto definido como literal
    constructor: LCMCalculator, // cuando reasignamos un prototipo, establecemos correctamente su propiedad constructor
    gcd: function () { // método que calcula el máximo común divisor
        // Algoritmo de 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 necesitamos calcular el MCD una vez, por lo tanto 'redefinimos' este método.
        // (Realmente no es una redefinición—está definida en la propia instancia, por lo tanto
        // this.gcd se refiere a esta 'redefinición' en vez de a LCMCalculator.prototype.gcd).
        // Además, 'gcd' === "gcd", this['gcd'] === this.gcd
        this['gcd'] = function () {
            return a;
        };
        return a;
    },
    // Los nombres de las propiedades del objeto pueden ser especificados con cadenas delimitadas con comillas simples (') o dobles (").
    "lcm" : function () {
        // Los nombres de las variables no colisionan con las propiedades del objeto. Por ejemplo: |lcm| no es |this.lcm|.
        // No usar |this.a * this.b| para evitar problemas con cálculos en coma flotante.
        var lcm = this.a / this.gcd() * this.b;
        // Sólo necesitamos calcular MCM una vez, por lo tanto "redefinimos" este método.
        this.lcm = function () {
            return lcm;
        };
        return lcm;
    },
    toString: function () {
        return "LCMCalculator: a = " + this.a + ", b = " + this.b;
    }
};

// Definimos una función genérica para imprimir un resultado; esta implementación solo funciona en los 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 prototipo Array están definidos en JavaScript 1.6.
// Estos métodos son usados aquí para demostrar la naturaleza funcional inherente del lenguaje.
[[25, 55], [21, 56], [22, 58], [28, 56]].map(function (pair) { // construcción literal de un Array + función de mapeo.
    return new LCMCalculator(pair[0], pair[1]);
}).sort(function (a, b) { // ordenamos la colección por medio de esta función
    return a.lcm() - b.lcm();
}).forEach(function (obj) {
    output(obj + ", gcd = " + obj.gcd() + ", lcm = " + obj.lcm());
});</syntaxhighlight>
</div>

El siguiente ejemplo muestra la salida que debería ser mostrada en la ventana de un navegador.

<syntaxhighlight lang="text">
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
</syntaxhighlight>