domingo, 30 de noviembre de 2014

como Integrar Node.js y NetBeans

Integración Node.js y NetBeans


Salim A. Castellanos R.
salimsalim4@gmail.com
@SCastellanosR

Aunque para escribir aplicaciones con Node.js no es necesario ningún IDE, basta con abrir un archivo bloc de notas y guardarlo como (.js), también es indiscutible que los IDE nos facilita la vida, sobre todo cuando el proyecto crece y ya no es solamente un archivo si no muchas carpetas con muchos archivos, además que nos organizan el código por bloques y colores, lo que facilita la lectura y búsqueda de errores.

NetBeans tiene un plugin para ejecutar archivos (.js) como archivos de Node.js. Para que funcione ya deberían tener instalado Node.js, si no lo han hecho diríjanse a la siguiente entrada.

También podrán descargar NetBeans desde el siguiente link: https://netbeans.org/downloads/

Ejecutamos NetBeans y nos vamos a Tools -> Plugins, nos aparece una interfaz en la que hacemos click en la pestaña de Available Plugins o Extensiones Disponibles, en el cuadro de búsqueda ingresamos Node, y en las opciones que nos salen seleccionamos NodeJS, le damos Install y seguimos los pasos. Cuando terminemos de Instalar Node.js, buscamos ahora con la palaba html e instalamos los plugin, HTML Custom, y HTML5 Kit.





HTML Custom: Nos servirá para que le podamos indicar a NetBeans que un archivo con extensión desconocida para él, como por ejemplo, (.ejs), le indiquemos que lo queremos abrir con el editor de texto HTML.  

HTML5 Kit: Nos permitirá cargar una carpeta que contenga archivos de Node.js como un proyecto HTML5, y de esta forma poder explorar todo el aplicativo desde un solo paquete, y no tener que abrir archivo por archivo.

Ahora todo lo que tenemos es que crear un nuevo proyecto HTML5 con NetBeans en,

File->New Project, en la ventana que aparece seleccionamos HTML5, y en Projects: HTML5 Application, o, HTML5 Application with Existing Sources, si lo que queremos es cargar un proyecto a partir de una carpeta existente.



En el proyecto le damos click derecho, new->JavaScript File, le damos un nombre, en mi caso utilizaré el ejemplo de hola mundo, le llamare server, quedara como server.js.
Ingresare el siguiente Codigo:

// Server.js

// Definimos la variable http importando el modulo 'HTTP'.

var http = require("http");

/*

 *
 Ejecutamos la funcion createServer(), que es la que crea  nuestro servidor web y le pasamos como parametro nuestro  CallBack, que es la  funcion que se ejecuta cada  vez que  se lance el evento create, osea cada vez que  apuntemos a  nuestra pagina web que estara en, http://localhost:9999/
 *
 */
http.createServer(function (request, response) {

 /* con la variable response, que es la que nos da 

  *  la     oportunidad de responder a la peticion de           nuestro request que en este caso seria                     http://localhost:9999, 

    la funcion writeHead iene dos parametros, el primero       indica el codigo

    de la respuesta, y el segungo el tipo de documento
    el codigo 200 en http significa -> OK
    el tipo de documento es texto plano en formato html
 *
 */

    response.writeHead(200, {"Content-Type": "text/html"});

//  Con write escribimos directamente en el body de la 
//  pagina web

    response.write("Hola Mundo...");

    console.log("Escribiendo en la consola de Node...");



    // terminamos la respuesta al explorador


    response.end();

}).listen(9999);


Le doy click derecho sobre el archivo server.js, escojo Run with Node.js. y vemos como en la barra Output de NetBeans aparece el log de evento de nuestro server.js ejecutado sobre Node.js.

Para que la función createServer se ejecute, debemos hacer el respectivo request, http://localhost:9999/


Otros Articulos:
  • http://nodejs-español.blogspot.com/2014/11/que-es-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/integracion-de-nodejs-y-netbeans.html
  • http://nodejs-español.blogspot.com/2014/11/instalacion-de-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/manejo-de-funciones-y-callback-en-nodejs.html
  • http://xn--nodejs-espaol-skb.blogspot.com/2014/11/funciones-y-programacion-asincrona-en.html




Funciones y programacion asincrona en Node.js, ejemplos y buenas practicas, codigo no bloqueante

Funciones y programación asíncrona en Node.js
Buenas Prácticas
Salim A. Castellanos R.
salimsalim4@gmail.com
@SCastellanosR


Una de las ventajas de programar en Node.js es la posibilidad de ejecutar funciones asíncronas, veremos primero la forma correcta de ejecutar un callback, y después veremos algún método de hacer esto asíncronamente.

El ejemplo consiste en programar una función que calcule el factorial de un número y después lo escriba por pantalla, primero lo haremos con código bloqueante o sincrono y después con código no bloqueante o asíncrono. En ambos ejemplos mostraremos como se debe utilizar el callback correctamente. Y al final mostraremos como podemos exportar la función para que nuestro archivo se convierta en un modulo reutilizable.


Supongo que ya saben crear y ejecutar un archivo con Node.js, si no es así remítanse al siguiente artículo.
http://xn--nodejs-espaol-skb.blogspot.com/2014/11/instalacion-de-nodejs.html

Empecemos programando la función factorial síncrono:

function factorialSincrono(numero, callback) {

    // Variable donde almacenaremos el resultado.
    var resultado = 1;

    // Variable donde almacenaremos el numero
    // por donde vamos multiplicando.
    var donde = 1;

    // Función que llamaremos recursivamente
    // Para evaluar el progreso y aumentar el contador.
    (function actuar() {

        if (donde <= numero) {
            resultado = resultado * donde;
            donde = donde + 1;
            actuar(); // Llamado recursivo.
        } else {
            //ejecución del callback
            callback(resultado);
        }

    })();

}

// Llamada de la función factorialSincrono
// Observar como en el callback se programa lo que queremos //hacer con el resultado cuando este esté listo.
factorialSincrono(10, function (resultado) {

    console.log("El resultado del factorial síncrono es: " + resultado);

});

console.log("Empezando");


Guardamos el archivo, en mi caso lo guarde como ‘factorialSincrono.js’, me para en la línea de comandos en la carpeta donde guarde el archivo, lo ejecuto con ‘node factorialSincrono.js’. Y en la consola me debería de salir en la primera línea, ‘El resultado del factorial síncrono es: 3628800’, y en la siguiente línea, ‘Empezando’, esto es porque hasta que no se termino de ejecutar la operación que calculaba el factorial no continuo con la siguiente línea que era escribir, ‘Empezando’, en este caso es una operación que se hace relativamente fácil, pero supongamos que era una consulta a una base que durara 5 segundos, durante todo ese tiempo el servidor estaría bloqueado, y nuestra siguiente línea se hubiera demorado en ejecutarse.
Por ultimo agreguemos al final la línea:
exports.factorialSincrono = factorialSincrono;
Y ahora desde otros archivos la podremos importar de la siguiente forma.



// El archivo factorialSincrono.js deberá estar ubicado
// en la misma carpeta.
Var factorial = require(“./factorialSincrono”);
factorial(10, function (resultado) {

    console.log("El resultado del factorial síncrono es: " + resultado);

});


Ahora veamos cómo podemos hacer esta función que se ejecute Asíncronamente para que no bloguee nuestra ejecución.

Creemos otro archivo que se llame ‘factorialAsincrono.js’, y reescribamos nuestra función.

function factorialAsincrono(numero, callback) {
    // Variable donde almacenaremos el resultado.
    var resultado = 1;

    // Variable donde almacenaremos el numero
    // por donde vamos multiplicando.
    var donde = 1;

    // Función que llamaremos recursivamente
    // Para evaluar el progreso y aumentar el contador.
    (function actuar() {
        // Es aqui donde se hace la magia
        // La funcion nextTick del modulo global process
        // hace que lo que mandemos como argumento de su callback
        // se ejejute en una iteracion futura del bucle de eventos de Node
        process.nextTick(function () {

            if (donde <= numero) {
                resultado = resultado * donde;
                donde = donde + 1;
                actuar();
            } else {
                callback(resultado);
            }
        });
    })()

}

// Llamada de la función factorialAsincrono
// Observar como en el callback se programa lo que queremos //hacer con el resultado cuando este esté listo.

factorialAsincrono(10, function (resultado) {

    console.log("El resultado del factorial asíncrono es: " + resultado);

});
// Escritura por consola que nos permitirá mostrar
// que nuestra función es no bloqueante.
console.log("Empezando1");

Ejecutamos nuestro archivo con, ‘node factorialAsincrono.js’, veremos que lo primero que se escribe en nuestra consola es, ‘Empezando1’, y después:

 ‘El resultado del factorial asíncrono es: 3628800’.

 Lo que demuestra que nuestro programa no bloqueo nuestra ejecución al pasar por la ejecución de nuestra función asíncrona, escribió ‘Empezando1’ primero, y después cuando estuvo lista nuestra operación de factorización ejecuto su respectivo callback.

Con esto terminamos nuestro artículo de hoy, espero les haya gustado, dejen sus comentarios, díganme sobre que les gustaría la próxima entrada, ya casi se acercan los artículos sobre Sails.js, en estos momentos empezare a terminar de escribir el artículo sobre el modulo global ‘process’, que empezó escribiéndolo primero que este y este lo termino antes, jajajaja, al parecer también escribo 
asíncronamente.


  • http://nodejs-español.blogspot.com/2014/11/que-es-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/integracion-de-nodejs-y-netbeans.html
  • http://nodejs-español.blogspot.com/2014/11/instalacion-de-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/manejo-de-funciones-y-callback-en-nodejs.html
  • http://xn--nodejs-espaol-skb.blogspot.com/2014/11/funciones-y-programacion-asincrona-en.html
  • http://xn--nodejs-espaol-skb.blogspot.com/2014/11/modulos-globales-ennode.html




¿Que es Node.js?

¿Que es Node.js?

Salim A. Castellanos R.
salimsalim4@gmail.com
@SCastellanosR




Node.js, ("Node Yei es"), es una plataforma para desarrollar aplicaciones de propósito general que corre en la capa de servidor, está basada en javascript y fue creada por Ryan Dahl en el 2009. Corre actualmente sobre el flamante motor V8 de Google, que es el mismo utilizado en Google Chrome para correr javascript, está basado en javascript como ya se dijo, pero con módulos especiales para poder trabajar en el ámbito del servidor, por ejemplo el HTTP, que es el que se utiliza para desarrollar aplicativos web. Esto es importante tenerlo en cuenta pues no es como Dart que todos los paquetes se pueden utilizar tanto en el servidor como en el cliente.

Node.js es totalmente asíncrono y orientado a eventos, lo que lo hace muy veloz y especialmente apropiado para crear aplicaciones en tiempo real. Aunque es asíncrono no es multihilos, tiene un bucle de eventos que es el que se encarga de revisar cuando el evento que se lanzó de forma asíncrona (también se pueden lanzar eventos bloqueantes), es emitido y entonces lanza el CallBack, que es la función donde está tu código.

Es importante saber que aunque Node.js es comúnmente usado como lenguaje de backend, también se ha utilizado en el desarrollo de drivers y librerías para hardware, por lo que no es un entorno con el que solo se puedan desarrollar aplicativos web. 

Node.js es muy diferente a otros lenguajes de servidor como PHP que utilizan un servidor externo para generar codigo html, como por ejemplo Apache, en Node.js tu creas tu propio servidor HTTP desde cero, aunque hay que decir que hacer esto con Node.js es muy sencillo. Es esta y otras características las que te permiten ver que estas desarrollando una aplicación web desde cero, sin nada de código inútil, y así crear aplicaciones extremadamente rápidas y eficientes.

Uno de los casos más significativos y muestra que con Node.js se pueden hacer aplicaciones en verdad grandes es la red social linkedin, linkedin migro a Node.js y antes de esta migración  utilizaba 30 servidores para correr su infraestructura web, al pasarse a Node.js solo necesitaron 5 Servidores, eso equivale a un ahorro en hardware del 83.33%, esto es debido a la forma muy eficiente en que Node.js utiliza la memoria, sobre todo a que no tiene que generar un hilo por cada proceso si no que lo administra con la pila de eventos.

Y bueno, para terminar esta primera entrada que aun aunque la quería hacer muy corta salió grandísima por tantas cosas que hay que decir sobre Node, mostrare el típico ejemplo de ‘hola mundo’, en la próxima entrada explicare como instalar Node.js, arrancarlo y empezaremos con un framework MVC para Node.js muy interesante llamado Sails.js. < 

// Server.js


// Definimos la variable http importando el modulo 'HTTP'.

//var http = require("http");

/*

 * 
 *Ejecutamos la funcion createServer(), que es la que crea        *nuestro servidor web
 *y le pasamos como parametro nuestro CallBack, que es la funcion  *que se ejecuta cada 
 *vez que se lance el evento create, osea cada vez que apuntemos  *a nuestra pagina web  *que estara en
 * http://localhost:9999/
 *
 */

http.createServer(function (request, response) {


    response.writeHead(200, {"Content-Type": "text/html"});

    response.write("Hola Mundo...");
    response.end();

}).listen(9999);



Otros Articulos:
  • http://nodejs-español.blogspot.com/2014/11/que-es-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/integracion-de-nodejs-y-netbeans.html
  • http://nodejs-español.blogspot.com/2014/11/instalacion-de-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/manejo-de-funciones-y-callback-en-nodejs.html
  • http://xn--nodejs-espaol-skb.blogspot.com/2014/11/funciones-y-programacion-asincrona-en.html

sábado, 29 de noviembre de 2014

Utilizar Modulos globales en Node.js – ‘process’ Parte II

Modulos globales en Node.js – ‘process’
 Parte II


Salim A. Castellanos R.
salimsalim4@gmail.com
@SCastellanosR

Modulo ‘process’: Es uno de los módulos más interesantes de la plataforma, presente en el espacio global de ejecución del proceso principal de Node, ósea que puede ser accedido desde cualquier parte y representa a este mismo proceso. Es a su vez una instancia de EventEmitter. En general ‘process’ da información sobre la ejecución de Node, variables de entorno, versión, módulos cargados, procesos cargados, el bucle de eventos, etc.
La mayor funcionalidad de ‘process’ está contenida en la función ‘.on()’, dicha función esta escuchando durante todo el proceso que se ejecuta, es por eso que solo se puede actuar sobre su callback.

process.on(“evento”,callback);

A continuación enunciaremos los tipos de eventos y algún ejemplo práctico.
Evento ‘exit’: Es emitido cuando el proceso está a punto de terminar, el bucle del proceso principal no seguirá ejecutándose despues de finalizar el callback del evento ‘exit’, por lo tanto un timer podría no funcionar. Es una forma aunque peligrosa y no recomendada de ejecutar algún código asíncronamente, es más conveniente para pruebas unitarias si lo que queremos es medir el tiempo de ejecución.
Ejemplo:

process.on('exit', function () {
    var sumatoria = 0;
    for (i = 0; i <= 100; i++) {
        sumatoria += i;
    }

console.log('La sumatoria de los primero 100 números es: %d', sumatoria);

    console.log('Esto no se escribirá porque está a punto de terminar el callback');

});

console.log('termino.');

Si se dan cuenta genera código no bloqueante, por lo cual se escribe primero por consola, ‘termino.’ Y después el resultado de la sumatoria, y efectivamente el ultimo log no se muestra por consola.

Evento: 'uncaughtException'

function (err) { }
Emitido cuando una excepción es devuelta hacia el bucle de evento. Si se ha añadido un listener a esta excepción, no se producirá la acción por defecto (imprimir una traza del stack y salir).
Ejemplo escuchando a uncaughtException:

process.on('uncaughtException', function (err) {
  console.log('Excepción recogida: ' + err);
});
 
setTimeout(function () {
  console.log('Esto seguirá ejecutándose.');
}, 500);
 
// Se fuerza una excepción, pero no se recoge.
nonexistentFunc();
console.log('Esto no se ejecutará.');

Nótese que uncaughtException es un mecanismo muy básico para manejar excepciones. Usando try / catch en tu programa te dará más control sobre el flujo de tu programa. Especialmente para aplicaciones de servidor que están diseñados para ejecutarse eternamente, uncaughtException puede ser un mecanismo muy útil de seguridad.

Eventos de señal#

function () {}
Emitido cuando los procesos reciben una señal. Mirar sigaction(2) para una lista de nombres de señal estándard POSIX como SIGINT, SIGUSR1, etc.
Ejemplo escuchando a SIGINT:
// Empieza leyendo de stdin para evitar salir.
process.stdin.resume();
 
process.on('SIGINT', function () {
  console.log('Recibido SIGINT.  Haz Control-D para salir.');
});
Una manera sencilla de enviar la señal SIGINT es con Control-C en la mayoria de aplicaciones de terminal.

process.stdout#

Un Stream de Escritura para stdout.
Ejemplo: la definición de console.log
console.log = function (d) {
  process.stdout.write(d + '\n');
};

process.stderr#

Un stream de escritura para stderr. Las escrituras en este stream son bloqueantes.

process.stdin#

Un Stream de Lectura para stdin. El stream stdin se detiene por defecto, así que se tiene que llamar aprocess.stdin.resume() para leer de él.
Ejemplo de como abir la entrada estándard (stdin) y escuchar a ambos eventos:
process.stdin.resume();
process.stdin.setEncoding('utf8');
 
process.stdin.on('data', function (chunk) {
  process.stdout.write('data: ' + chunk);
});
 
process.stdin.on('end', function () {
  process.stdout.write('end');
});

process.argv#

Un array que contiene los argumentos de la línea de comandos. El primer elemento será 'node', el segundo elemento será el nombre del fichero JavaScript. Los siguientes elementos serán argumentos adicionales de la línea de comandos.
// imprimir process.argv
process.argv.forEach(function (val, index, array) {
  console.log(index + ': ' + val);
});
Generará:
$ node process-2.js one two=three four
0: node
1: /Users/mjr/work/node/process-2.js
2: one
3: two=three
4: four

process.execPath#

Es la ruta absoluta del ejecutable que inició el proceso.
Ejemplo:
/usr/local/bin/node

process.chdir(directory)#

Cambia el directorio actual de trabajo del proceso o lanza una excepción si falla.
console.log('Directorio inicial: ' + process.cwd());
try {
  process.chdir('/tmp');
  console.log('Directorio nuevo: ' + process.cwd());
}
catch (err) {
  console.log('chdir: ' + err);
}

process.cwd()#

Devuelve el directorio actual de trabajo del proceso.
console.log('Directorio actual: ' + process.cwd());

process.env#

Un objeto que contiene el entorno del usuario. Mirar environ(7).

process.exit(code=0)#

Termina el proceso con el code especificado. Si se omite, exit usa el código de 'éxito' 0.
Para salir con un código de 'fallo':
process.exit(1);
El shell que ha ejecutado node debería ver 1 como código de salida.

process.getgid()#

Obtiene la identidad de grupo del proceso. (Mirar getgid(2).) Es el id de grupo numérico, no el nombre del grupo.
console.log('Actual gid: ' + process.getgid());

process.setgid(id)#

Establece la identidad de grupo del proceso. (Mirar setgid(2).) Acepta tanto un ID numérico como una cadena de texto con el nombre del grupo. Si se especifica el nombre del grupo, el método se bloquea mientras lo resuelve a un ID numérico.
console.log('Actual gid: ' + process.getgid());
try {
  process.setgid(501);
  console.log('Nuevo gid: ' + process.getgid());
}
catch (err) {
  console.log('Fallo al cambiar el gid: ' + err);
}

process.getuid()#

Obtiene la identidad de usuario del proceso. (Mirar getuid(2).) Es la id de usuario númerica, no el nombre de usuario.
console.log('Actual uid: ' + process.getuid());

process.setuid(id)#

Establece la identidad de usuario del proceso. (Mirar setuid(2).) Acepta tanto un ID numérico como una cadena de texto con el nombre de usuario. Si se especifica el nombre de usuario, el método se bloquea mientras lo resuelve a un ID numérico.
console.log('Actual uid: ' + process.getuid());
try {
  process.setuid(501);
  console.log('Nuevo uid: ' + process.getuid());
}
catch (err) {
  console.log('Fallo al establecer uid: ' + err);
}

process.version#

Una propiedad dentro del compilado que expone NODE_VERSION.
console.log('Versión: ' + process.version);

process.installPrefix#

Una propiedad dentro del compilado que expone NODE_PREFIX.
console.log('Pr: ' process.installPrefix);

process.kill(pid, signal='SIGTERM')#

Envia una señal a un proceso. pid es la id de proceso y signal es la cadena de texto que describe la señal a enviar. Los nombres de señales son cadenas de texto como 'SIGINT' o 'SIGUSR1'. Si se omite, la señal será 'SIGTERM'. Mirar kill(2) para más información.
Notar que ya que el nombre de la función es process.kill, se trata solo de un emisor de señales, como la llamada a sistema kill. La señal enviada puede hacer algo más que matar el proceso escogido.
Ejemplo de como enviarse una señal a uno mismo:
process.on('SIGHUP', function () {
  console.log('Recibida señal SIGHUP.');
});
 
setTimeout(function () {
  console.log('Saliendo.');
  process.exit(0);
}, 100);
 
process.kill(process.pid, 'SIGHUP');

process.pid#

El PID del proceso.
console.log('El pid de este proceso es  ' + process.pid);

process.title#

Getter/setter para establecer lo que mostrará 'ps'.

process.platform#

En que plataforma se está ejecutando. 'linux2', 'darwin', etc.
console.log('La plataforma es ' + process.platform);

process.memoryUsage()#

Devuelve un objeto describiendo el uso de la memoria del proceso Node.
var util = require('util');
 
console.log(util.inspect(process.memoryUsage()));
Generará:
{ rss: 4935680,
  vsize: 41893888,
  heapTotal: 1826816,
  heapUsed: 650472 }

heapTotal y heapUsed se refieren al uso de la memoria de V8.

process.nextTick(callback)#

En la siguiente iteración del bucle del evento se llama a callback. No es simplemente un alias parasetTimeout(fn, 0) , es mucho más eficiente.
process.nextTick(function () {
  console.log('nextTick callback');
});

process.umask([mask])#

Establece o lee la máscara del modo de creación del fichero del proceso. Los procesos hijos heredan la máscara del proceso padre. Devuelve la antigua máscara si se pasa el argumento mask, si no devuelve la máscara actual.
var oldmask, newmask = 0644;
 
oldmask = process.umask(newmask);
console.log('Cambiada umask de: ' + oldmask.toString(8) +
            ' a ' + newmask.toString(8));

Con esto terminamos nuestro artículo de hoy, espero les haya gustado, dejen sus comentarios, díganme sobre que les gustaría que escriba la próxima entrada, ya casi se acercan los artículos sobre Sails.js.
  • http://nodejs-español.blogspot.com/2014/11/que-es-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/integracion-de-nodejs-y-netbeans.html
  • http://nodejs-español.blogspot.com/2014/11/instalacion-de-nodejs.html
  • http://nodejs-español.blogspot.com/2014/11/manejo-de-funciones-y-callback-en-nodejs.html
  • http://xn--nodejs-espaol-skb.blogspot.com/2014/11/funciones-y-programacion-asincrona-en.html
  • http://xn--nodejs-espaol-skb.blogspot.com/2014/11/modulos-globales-ennode.html