ejemplos de javascript

basic.js

/*
  
  * Los elementos primitivos de javascript son

  * números
  * strings
  * booleans
  * nulidades: `undefined`(implícita) y  `null` (explícita)

  *Los medios de combinación: arreglos y objetos.
  Los arreglos son de tamaño variable y pueden guardar cualquier tipo de variables

  Los objetos se escriben en JSON (javascript object notation):
    
  a = {
    prop1 : "a",
    prop2 : 3.0,
    prop3 : function(){console.log("soy una f");}
  }

  Y se leen con el operador corchetes:
  a['prop1']
  o con el operador punto (`.`)
  a.prop1

  * Los medios de abstracción son las funciones: uno puede usar una función para representar un tipo, 
    además del hecho que las funciones tienen su propio ámbito y pueden usarse como cualquier otro tipo:
    pasarse como parámetro y valores de retorno

  * En javascript, las funciones son "ciudadanos de primer orden": lo mismo que cualquier otro tipo (números, strings, arreglos). cf. http://en.wikipedia.org/wiki/First-class_function#JavaScript

 */

//un ejemplo de abstracción: usaremos una función para representar el concepto de círculo:

var Circulo = function(nuevoRadio){
  this.radio = nuevoRadio;
  //el objeto Math tiene constantes y funciones predefinidas
  /*Nótese que podemos asignar una función a una variable porque son "first-class citizens" */
  this.area =  function(){
    return Math.pow(this.radio, 2) * Math.PI;
  }
};

//creamos dos círculos:
a = new Circulo(5.0);
b = new Circulo(2);

//vemos las áreas:

console.log("Área de a: "+ a.area());
console.log("Área de b: "+ b.area());

//oops, se nos olvidó definir la circunferencia, no hay problema, la inyectamos:

Circulo.prototype.circunferencia = function(){
    return 2 * Math.PI * this.radio;
}

console.log("Circunferencia de a:"+ a.circunferencia());
console.log("Circunferencia de b:"+ b.circunferencia());


//también existe el concepto de SINGLETON: una instancia que es a la vez un tipo (http://www.phpied.com/3-ways-to-define-a-javascript-class/)

var messenger = new function(){

    //`this` accede al ámbito público de esta función
    this.messages = [];

    //esta función, así como está ahora es "privada", no es parte del ámbito público
    function getMessage(query){
        for(i = 0, l= this.messages.length;i< l; i++)
            if(this.messages[i].indexOf(query) != -1)
                return this.messages[i];
        //retornamos la nulidad explícita, si no devolvieramos nada, sería undefined
        return null;
    }
    
    //si no copiamos la función getMessage al ámbito público, no podremos acceder a ella desde afuera
    this.getMessage = getMessage;

    function addMessage(m){
        this.messages.push(m);
    }

    this.addMessage = addMessage;
}

console.log("[SINGLETON MESSENGER] acaba de empezar, hay " + messenger.messages.length + " mensajes");
messenger.addMessage("Tenés un mensaje nuevo");
messenger.addMessage("Tenés otro mensaje nuevo");
console.log("buscando "+ messenger.getMessage('otro')); //como en ruby, las comillas sencillas también delimitan un string

//pero también podemos usar JSON para representar un singleton (esta es la manera preferida por librerías como jQuery):

var json_messenger= {
    messages : [], 
    getMessage: function(query){
        for(i = 0, l= this.messages.length;i< l; i++)
            if(this.messages[i].indexOf(query) != -1)
                return this.messages[i];
        //retornamos la nulidad explícita, si no devolvieramos nada, sería undefined
        return null;
    }, //separamos los elementos con comas, porque un JSON es un mapa

    addMessage: function(m){
        this.messages.push(m);
    }
}

console.log("[JSON MESSENGER] acaba de empezar, hay " + json_messenger.messages.length + " mensajes");
json_messenger.addMessage("Tenés un mensaje nuevo");
json_messenger.addMessage("Tenés otro mensaje nuevo");
console.log("buscando 'otro' "+ json_messenger.getMessage('otro'));

functions.js

/*Ejemplos de funciones como ciudadanos de primer orden*/
/*más ejemplos interesantes: http://spheredev.org/wiki/Higher-order_programming_in_JavaScript#map*/
var LISP = function(){
    /*Recordemos que `arguments` contiene los parámetros que la función recibió, y en javascript los parámetros son
     opcionales y variables siempre*/

    /*si sólo viene un argumento, y éste es una cadena, escribieron las cosas en literal*/
    if(typeof arguments[0] == "string"){
        //usamos una expresión regular para partir por espacios: puede ser uno o muchos:
        
        tokens   = arguments[0].split(/\s+/);
        operator = tokens.shift(); //la función shift es como un `pop` al revés
        //como aplicamos el shift, ahora los operandos son lo que quedó en el arreglo:
        operands = tokens;

        //el operador TIENE que ser una función, así que usamos la instrucción `eval`
        //para ejecutar código, ¿qué código? obtener la referencia a la función que el operador
        //define:
        try{
            operator = eval(operator);
        }catch(error){
            //el nombre puede apuntar a una función que no está definida:
            console.log("¡El operador "+ operator + "  no existe!");
        }
    }else if(arguments.length > 1){
        operator = arguments[0]; 
        //usamos la función slice para sacar todos los elementos, desde el segundo al último
        //arguments no es un arreglo normal, así que no tiene slice, pero podemos convertirlo en un Array:
        arguments = Array.prototype.slice.call(arguments)
        operands = arguments.slice(1, arguments.length);
    }
    //aplicamos el operador a los operandos:
    //podemos iterar en las propiedades de un objeto, arguments es un object, no un Array:
    accum = operands[0];
    for(i = 1; i < operands.length; i++)
        accum = operator(accum, operands[i]);
       

    return accum;
}

//probando la función:
var BasicMath = {
    //la concatenación es ambigua, así que casteamos a números:
    sum : function(a,b){return new Number(a)+new Number(b)},
    product: function(a,b){return a*b;}
}

//podemos enviar referencias a funciones como parámetros a otras:
console.log("probando suma: "+ LISP("BasicMath.sum 1 2"));
console.log("probando suma otra vez: "+ LISP(BasicMath['sum'], 3, 4));
console.log("probando producto: "+ LISP(BasicMath.product, 21, 2));

//también podemos retornar funciones:

/*Transposer agarra resultados de operaciones y los transpone en la recta numérica*/
var transposer = function(transpose, f){
    return function(){ //f es una función que recibe un número
        //convertimos los argumentos en un arreglo
        var args = Array.prototype.slice.call(arguments);
        //como args es un arreglo, usamos `apply` para llamar la función original
        return transpose + f.apply(null, args);
    }
}

console.log("la suma normal: "+ BasicMath.sum(1,2)) ;
console.log("la suma transpuesta: " + transposer(42, BasicMath.sum)(1,2)) ;
//también podemos hacerlo paso a paso:
var sumaTranspuesta = transposer(42, BasicMath.sum); //esto es una función;
console.log("suma transpuesta en más pasos: "+ sumaTranspuesta(1,2)); //llamamos a la función que transposer crea