Mostrando entradas con la etiqueta node. Mostrar todas las entradas
Mostrando entradas con la etiqueta node. Mostrar todas las entradas

viernes, 6 de marzo de 2026

WebSockets: un canal permanente para enviar y recibir datos

Los WebSockets son un protocolo que permite comunicación bidireccional en tiempo real entre cliente y servidor, a diferencia de HTTP que funciona en modo solicitud-respuesta.

Es como un canal permanente, donde ambos lados (cliente y servidor) pueden enviar datos en cualquier momento.

Son útiles en cualquier escenario donde se requiera interacción instantánea:

  • Chats y mensajería: WhatsApp Web, Slack, Discord. 
  • Juegos online: sincronización de movimientos en tiempo real. 
  • Colaboración en documentos: Google Docs, Notion, donde ves cambios de otros usuarios al instante.
  • Notificaciones en vivo: alertas de bolsa, actualizaciones deportivas, sistemas de monitoreo. 
  • Aplicaciones financieras: transmisión de precios de criptomonedas o acciones en tiempo real. 
  • IoT y dashboards: dispositivos que envían datos continuamente a una interfaz web .

Entre las ventajas principales encontramos:

  • Baja latencia: no hay que abrir y cerrar conexiones constantemente. 
  • Menor consumo de recursos: menos overhead que múltiples peticiones HTTP. 
  • Escalabilidad: ideal para aplicaciones con miles de usuarios conectados simultáneamente.  
  • Flexibilidad: permite enviar datos en ambos sentidos (cliente ↔ servidor).

Entre los riesgos y consideraciones a tomar tenemos:

  • Seguridad: al ser persistentes, requieren cifrado (wss://) para evitar ataques de interceptación. 
  • Escalabilidad: manejar miles de conexiones simultáneas exige servidores optimizados. 
  • Compatibilidad: aunque ampliamente soportados, algunos entornos antiguos pueden no tener soporte completo.

WebSockets

Iniciemos pues con los WebSockets. Haremos un sencillo ejemplo. Para ello necesitamos:

  • Tener Node instalado en nuestras máquinas. 
  • Tener conocimiento de Javascript y Node. 
  • Instalar Express y Socket.IO

¿Qué haremos? Una aplicación que nos muestre un ejemplo del uso de WebSockets, con ayuda de JS y Node.

1. Crearemos un directorio y nos ubicaremos en el:

$ mkdir websocket-demo
$ cd websocket-demo

2. Una vez dentro del directorio, crearemos un proyecto Node:

$ npm init -y

Esto nos generará el proyecto Node.

3. Instalar las dependencias (Express y Socket.IO) con ayuda de la herramienta ``npm``:

$ npm install express socket.io

Podemos validar la descarga con este comando:

$ npm list

Salida:

+-- express@5.2.1
`-- socket.io@4.8.3

4. Creando un servidor que escuche ``server.js``:

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server);

app.use(express.static('public'));

io.on('connection', (socket) => {
  console.log('Un usuario se conectó');

  socket.on('chat message', (msg) => {
    console.log('Mensaje recibido: ' + msg);
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('Un usuario se desconectó');
  });
});

server.listen(3000, () => {
  console.log('Servidor escuchando en http://localhost:3000');
});

5. Crearemos un cliente para hacer petciones al servidor:

public\index.html

<!DOCTYPE html>
<html>
<head>
  <title>Chat con Socket.IO</title>
</head>
<body>
  <h1>Chat sencillo</h1>
  <ul id="mensajes"></ul>
  <form id="form">
    <input id="input" autocomplete="off" /><button>Enviar</button>
  </form>
  <script src="/socket.io/socket.io.js"></script>
  <script>
    const socket = io();

    const form = document.getElementById('form');
    const input = document.getElementById('input');
    const messages = document.getElementById('mensajes');
form.addEventListener('submit', (e) => { e.preventDefault(); if (input.value) { socket.emit('chat message', input.value); input.value = ''; } }); socket.on('chat message', (msg) => { const item = document.createElement('li'); item.textContent = msg; messages.appendChild(item); }); </script> </body> </html>

6. Ejecutamos la aplicación:

$ node server.js

Si todo va bien veremos este mensaje:

Servidor escuchando en http://localhost:3000

Abrimos un navegador en la ruta: http://localhost:3000/

Veremos lo siguiente:

Mandamos un mensaje y obtendremos una respuesta:

¡Hemos creado nuestra primera aplicación con WebSockets!

Continuaremos con estos temas en próximas entregas.

Enlaces:

https://en.wikipedia.org/wiki/WebSocket
https://socket.io/
https://expressjs.com/

jueves, 25 de diciembre de 2025

Websharper

Websharper, según la documentación oficial es: un framework y un conjunto de herramientas para desarrollar aplicaciones web/móviles y servicios web íntegramente en C# o F# (o una combinación de ambos lenguajes) con comunicación cliente-servidor y navegación web fuertemente tipadas.

Características principales:

Veremos las sus características principales.

  • Sitelets: funcionalidad del lado del servidor. 
  • Compilador de JavaScript y abstracciones del lado del cliente. 
  • Facilidades de interacción cliente-servidor. 
  • Funciones adicionales.

Empezando con Websharper

Por default se usa C#, veamos un ejemplo paso a paso.

1. Creamos un directorio y nos ubicamos en el:

$ mkdir proyecto-websharper
$ cd proyecto-websharper

2. Instalamos los templates de WebSharper:

$ dotnet new -i WebSharper.Templates

3. Creamos un proyecto WebSharper:

$ dotnet new websharper-web

4. Ejecutamos la aplicación:

$ dotnet run

Abrimos el navegador en la ruta: http://localhost:5000

Con esto hemos creado nuestra primera aplicación con WebSharper.

Ahora miremos el contenido del proyecto:

Como se puede observar hay directorios que llaman la atención, describiremos las carpetas:

  • bin: Carpeta estándar de .NET donde se colocan los archivos compilados finales (DLLs, ejecutables, etc.) después de construir el proyecto. En proyectos WebSharper, también puede contener subcarpetas con archivos generados para despliegue (como HTML/JS en versiones antiguas). 
  • Generated: Carpeta generada automáticamente por WebSharper. Contiene código JavaScript (y posiblemente otros artefactos) traducido desde el código C# marcado con atributos como [JavaScript]. Este código es el resultado de la compilación client-side de WebSharper. 
  • node_modules: Carpeta creada por npm (Node.js package manager). Contiene todas las dependencias JavaScript externas instaladas vía package.json. En proyectos WebSharper modernos, se usa para herramientas de bundling como Vite o esbuild, y para librerías frontend. 
  • obj: Carpeta estándar de compilación .NET. Almacena archivos intermedios temporales durante el proceso de build (como objetos compilados, recursos embebidos, etc.). No se debe modificar manualmente ni incluir en control de versiones. 
  • wwwroot: Carpeta raíz para archivos estáticos en proyectos web .NET (como ASP.NET Core). Aquí se colocan los archivos que se sirven directamente al navegador: HTML, CSS, JS bundlado, imágenes, etc. En WebSharper, el output final del cliente (JS generados, bundles) suele configurarse para ir aquí (a menudo vía wsconfig.json con "outputDir": "wwwroot").

Estas carpetas combinan elementos estándar de proyectos .NET/ASP.NET Core con específicas de WebSharper (como Generated) y modernas herramientas frontend (como node_modules y configuración para bundlers como Vite/esbuild, visibles en archivos como vite.config.js y esbuild.config.mjs).

Ahora miremos los achivos:

  • proyecto-websharper.csproj: Archivo de proyecto principal de .NET (formato SDK-style). Define la configuración del proyecto: tipo de salida (generalmente una aplicación web ASP.NET Core), referencias a paquetes NuGet (como WebSharper, WebSharper.CSharp, etc.), propiedades de compilación y opciones específicas de WebSharper (por ejemplo, vía propiedades como o referencias a targets). Es esencial para que dotnet build o Visual Studio compile el proyecto correctamente. 
  • appsettings.json: Archivo de configuración estándar de ASP.NET Core. Contiene settings de la aplicación, como cadenas de conexión a bases de datos, opciones de logging, URLs de APIs externas o configuraciones específicas de WebSharper (por ejemplo, sección "websharper" para redirección de scripts en modo debug). Se carga en tiempo de ejecución y puede tener versiones por entorno (como appsettings.Development.json). 
  • Client.cs: Archivo de código C# que contiene la lógica client-side (lado del navegador). Aquí se escribe código marcado con atributos como [JavaScript] o [SPAEntryPoint], que WebSharper traduce automáticamente a JavaScript. Es el punto principal para definir la interfaz de usuario interactiva (UI con WebSharper.UI, eventos, etc.). 
  • esbuild.config.mjs: Archivo de configuración para esbuild (un bundler/minificador rápido de JavaScript). En proyectos WebSharper modernos, se usa para procesar el output prebundled generado por WebSharper (cuando "prebundle": true en wsconfig.json), creando un bundle final optimizado para producción (minificación, tree-shaking, etc.). 
  • Main.html: Archivo HTML principal (plantilla o index). Sirve como página base para la aplicación (SPA o sitelet). Contiene placeholders especiales de WebSharper (como
    o atributos ws-replace) donde se inyecta el contenido dinámico generado desde el lado server o client. En modo desarrollo, Vite lo sirve con hot-reload. 
  • package.json: Archivo estándar de Node.js/npm. Define las dependencias JavaScript externas (como librerías UI, polyfills o herramientas) y scripts de build (por ejemplo, "dev" para Vite, "build" para producción). WebSharper lo usa para integrar con bundlers modernos como Vite o esbuild. 
  • Remoting.cs: Archivo C# que define funciones RPC (Remote Procedure Calls). Contiene métodos marcados con [Rpc] que permiten llamar código server-side desde el client de forma segura y tipada (sin escribir AJAX manual). Es clave para la comunicación client-server en aplicaciones WebSharper
  • Site.cs: Archivo C# que define el sitelet (estructura de rutas y páginas de la aplicación). Usa WebSharper.Sitelets para declarar endpoints (acciones, páginas, etc.) y cómo renderizar el contenido (integrando templates como Main.html y código client). Es el núcleo de la lógica de enrutamiento server-side. 
  • Startup.cs: Archivo estándar de ASP.NET Core para configurar la aplicación. Aquí se registra el pipeline (middleware), se integra WebSharper (por ejemplo, services.AddWebSharper() o configuración de sitelets/RPC), se carga appsettings.json y se define el hosting (Kestrel, IIS, etc.). 
  • vite.config.js: Archivo de configuración para Vite (servidor de desarrollo y bundler moderno). Se usa en modo debug para hot-module-replacement (HMR), proxy de APIs y servir el proyecto rápidamente. En producción, puede delegar a esbuild. Los templates WebSharper recientes lo incluyen para un desarrollo fluido. 
  • wsconfig.json: Archivo de configuración específico de WebSharper. Define opciones del compilador como tipo de proyecto ("site", "spa", etc.), output directory (ej. "wwwroot"), prebundling, source maps, descarga de recursos remotos y más. Es crucial para personalizar cómo WebSharper genera el JavaScript.

Continuaremos con esta serie de entregas sobre .NET.

Enlaces:

https://websharper.com/

sábado, 19 de junio de 2021

Node en ejemplos: importando paquetes

 

Node JS es una plataforma que nos permite correr aplicaciones Javascript del lado del servidor.  En post pasados hemos visto su instalación y algunos ejemplos. 

Instalación en distribuciones Ubuntu.


$ curl -fsSL https://deb.nodesource.com/setup_14.x | sudo -E bash -
$ sudo apt-get install -y nodejs

Comprobamos su instalación:
$ npm -v
$ node -v
Paquetes en Node JS.

Un paquete son archivos JS empaquetados. Es una parte fundamental en la reutlización de código.

Node JS nos permite importar paquetes para realizar ciertas funciones especiales, así como importar nuestros propios paquetes.


Ejemplo. Importar el paquete 'path' de Node Js. Para ello necesitamos tener un archivo texto.txt.
const path = require('path');
const print = console.log;

print("Archivo:");
print(path.parse("/home/codemonkey/Documentos/pruebasNodeJS/texto.txt"));
La salida:
Archivo:
{
  root: '/',
  dir: '/home/codemonkey/Documentos/pruebasNodeJS',
  base: 'texto.txt',
  ext: '.txt',
  name: 'texto'
}
Ejemplo. Crear un paquete llamado suma e importarlo en otro archivo denominado test_suma.js.
suma.js
exports.sumar = (x,y) => x+y;
test_suma.js
// Importamos suma.js
const operacion = require('./suma');
var x = 4, y = 3;
console.log(`Suma de ${x} + ${y} es: ${operacion.sumar(x,y)}`);

// Creamos una clase
class Operacion{
   getOperacion(x,y){
      const operacion = require('./suma.js');
      return operacion.sumar(x,y);
   }
}

x = 7;
y = 8;
let my_operacion = new Operacion().getOperacion(x,y);
console.log(`Suma de ${x} + ${y} es: ${my_operacion}`);
Ejecutamos:
$ node test_suma.js
Resultado:
Suma de 4 + 3 es: 7
Suma de 7 + 8 es: 15

Nota:
  Cuando es un paquete de Node JS no es necesario poner el punto y diagonal. Solo cuando es un paquete hecho por nosotros. También se puede omitir la extensión *.js en paquetes propios como se puede ver:
// Importo paquete de Node JS
const path = require("path");

// Importo mi paquete 
const path = require("./saludo");
Y un ejemplo más...
const path = require('path');
const print = console.log;

print("Archivo:");
print(path.parse("/home/codemonkey/Documentos/pruebasNodeJS/texto.txt"));


const saludo = require('./saludo');
saludo.saludo();
saludo.despedida();

const opera = require('./suma');
let x = 87.5;
let y = 45.8;
console.log(`Numeros >> x = ${x}, y = ${y} `);
console.log("Suma: ",opera.sumar(x,y));

const os = require('os');
console.log("Info del sistema:");
console.log("Arquitectura:",os.arch());
console.log("Hostname:",os.hostname());


Enlaces:
https://codemonkeyjunior.blogspot.com/search?q=node
https://nodejs.org

sábado, 13 de julio de 2019

Ionic framework

Ionic es un framework que permite crear aplicaciones móviles híbridas. Éstas aplicaciones son las que emplean tecnologías como HTML, CSS y Javascript. Una aplicación móvil híbrida se despliega dentro de un contenedor como Cordova. Contrario a las aplicaciones nativas no emplea ninún lenguaje propio del dispositivo.

Instalando Ionic Framework

$ npm i -g ionic

Comprobamos su instalación:

$ ionic --version


Creando una aplicación.

Creamos una aplicación en blanco.
$ ionic start miApp blank --type=angular

Nos ubicamos en la carpeta creada.

$ cd miApp 

 Arrancamos el servidor:
$ ionic serve

Se abrirá el navegador en la dirección http://localhost:8100

Creamos una página.

$ ionic generate page pagina-uno

Ahora editamos home.page.html y agregamos un botón.

<div class="ion-padding">
    <p>Está la página de inicio.</p>
    <ion-button class="primary"  (click)="launchPaginaUnoPage()" >Ir a la página uno</ion-button>
  </div>

Editamos home.page.ts añadiendo un método para lanzar la página pagina-uno.

import { Component } from '@angular/core';
import { NavController } from '@ionic/angular';
import { PaginaUnoPage } from '../pagina-uno/pagina-uno.page';
import { Router } from '@angular/router';

@Component({
  selector: 'app-home',
  templateUrl: 'home.page.html',
  styleUrls: ['home.page.scss'],
})
export class HomePage {

  constructor(public navCtrl: NavController,
   private router: Router) {}

  launchPaginaUnoPage(){
   console.log('Voy a la página uno')
   this.router.navigate(['/pagina-uno'])
  }

}

Agregamos un bóton de regreso a home en pagina-uno.page.html

<div class="ion-padding">
    <p>Está es nuestra primera página.</p>
    <ion-button class="primary" (click)="launchHomePage()" >Ir a home</ion-button >
  </div>

Creamos el método para regresar a home en pagina-uno.page.ts


import { Component, OnInit } from '@angular/core';
import { Router } from '@angular/router';

@Component({
  selector: 'app-pagina-uno',
  templateUrl: './pagina-uno.page.html',
  styleUrls: ['./pagina-uno.page.scss'],
})
export class PaginaUnoPage implements OnInit {

  constructor(private router:Router) { }

  ngOnInit() {
  }

  public launchHomePage():void{
    console.log('De regreso a home');
   this.router.navigate([''])
  }


}

Arrancamos el servidor.

$ ionic serve

Observamos el resultado:

Damos click en Ir a la página uno.

 Tenemos hecha nuestra primera aplicación con Ionic.





martes, 30 de abril de 2019

AngularJS: Directivas y expresiones

En este post hablaremos de directivas en AngularJS. Pero antes que nada debemos instalar un sencillo y muy útil servidor:


$ npm install -g http-server 

Para ponerlo activo tecleamos desde una terminal:
$ http-server carpetaProyecto/

Abrimos nuestro navegador en http://localhost:8080/ para cerrar tecleamos en la terminal Ctrl + C.

Como vimos en el anterior post AngularJS posee etiquetas especiales llamadas directivas.Éstas directivas son atributos que se agregan a los elementos HTML, por lo regular comienzan con ng-.

Directivas comunes:

  • ng-app: para especificar una aplicación.
  • ng-controller: para especificar un controlador.
  • ng-model: asocia el valor de una variable con el elemento HTML.
  • ng-click: para soltar o ejecutar un evento.
  • ng-bind: para enlazar un valor del scope con un elemento HTML sin necesidad de {{ }}

Ejemplo. Creamos un módulo y un controlador.

app.js
/*Módulo 'miApp'*/
var app = angular.module('miApp', []);

/*Controlador 'miControlador'*/
app.controller('miControlador', function($scope) {});

En HTML:

view.html

<!-- Definimos la app -->
<html ng-app='miApp'>

<!-- Definimos el controlador -->
<body ng-controller='miControlador'>
   <!-- contenido -->
</body>

¿Cómo defino las expresiones?
Existen dos formas para definir una expresión.

 Primera forma:
{{ expresion }}
Segunda forma:
ng-bind="expresion".

Ejemplo. Algunas expresiones:
{{ 34 + 32 }}

{{ cadena }}

{{ edad>18? "Eres mayor de edad" : "Eres menor de edad" }}

Ejemplo. Una página simple usando AngularJS.
<html ng-app="miApp">

<script src="js/angular.min.js"></script>


<body ng-controller="miControlador">
<h1>{{ titulo }}</h1>

<script>
/*Módulo 'miApp'*/
var app = angular.module('miApp', []);

/*Controlador 'miControlador'*/
app.controller('miControlador', function($scope) {
 
 //$scope es la variable principal
 $scope.titulo ="Codemonkey Junior";

});

</script>

</body>
</html>

Es todo por hoy.

miércoles, 30 de enero de 2019

Node JS



Node es considerado un entorno de ejecución de JavaScript orientado a eventos asíncronos (más información en https://nodejs.org/es/about/). 

Creamos un archivo *.js

test.js

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/html');
  res.end('<h1>Hola Node JS</h1>');
});

server.listen(port, hostname, () => {
  console.log(`El servidor se está ejecutando en http://${hostname}:${port}/`);
});

Ejecutamos:
$ node test.js
Abrimos el navegador en http://localhost:3000

Ahora crearemos un módulo.

  1. Creamos una carpeta llamada testNodeJS
  2. Tecleamos npm init
  3. Tecleamos npm install

Si todo va bien, debe haber un archivo llamado package.json


{
  "name": "app-node",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}
Por defecto tendremos un index.js Ahora sustituimos su contenido por esto:
const http = require('http');
const hostname = '127.0.0.1';
const port = 8088;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/html');
  res.write('<h1>Node JS</h1><br/>');
  res.end();
});

server.listen(port, hostname, () => {
  console.log(`Servidor corriendo en http://${hostname}:${port}/`);
});


Ejecutamos:

$ node index.js

Abrimos el navegador en http://localhost:8088/

Veremos el mensaje Node JS

Ahora crearemos un módulo

listaString.js


exports.listaString=["Java","Kotlin","Scala","Groovy","Ceylon"];

Ahora modificaremos el archivo index.js, importamos el módulo de la siguiente manera:


var identificador = require('nombre_modulo')

index.js


//importamos nuestro módulo listaString.js
var listaStr = require('./app/listaString.js');


const http = require('http');
const hostname = '127.0.0.1';
const port = 8088;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/html');
  res.write('<h1>Node JS</h1><br/>');
  res.write("<ul>");
  for(elemento in listaStr.listaString){
   res.write("<li>"+listaStr.listaString[elemento]+"</li>");
  }
  res.write("</ul>");
  res.end();
});

server.listen(port, hostname, () => {
  console.log(`Servidor corriendo en http://${hostname}:${port}/`);
});

Es preciso notar esto:

res.write("<ul>");
  for(elemento in listaStr.listaString){
   res.write("<li>"+listaStr.listaString[elemento]+"</li>");
  }
  res.write("</ul>");

Así la lista se verá en nuestro index.js

Links:

martes, 1 de noviembre de 2016

Un vistazo a Node.js

Node.js es un entorno de ejecución para aplicaciones hechas con Javascript. Posee un ecosistema de paquetes (npm) que nos provee una manera más fácil para el desarrollo de nuestras aplicaciones.

Existen diversas maneras de instalar Node.js. Una de ellas es mediante nvm.

Para ello podemos teclear la siguiente orden en la terminal de comandos (si usas Linux, debo aclarar):

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash


Para que surja efecto hay que teclear:
source ~/.bashrc

Listo, tenemos instalado nvm:
nvm --version

Para instalar node tecleamos: 
nvm install node

Para instalar el gestor de paquetes npm:
nvm install npm

Comprobamos su instalación:
node -v
npm -v 

Ahora a crear el primer ejemplo.
1. Creamos un archivo llamado hola.js
2. Ejecutamos el script mediante node


hola.js
console.log("Hola, Codemonkeys");


En terminal tecleamos:
node hola.js
 

Ya tenemos nuestro primer ejemplo en Node.js

Links
https://github.com/creationix/nvm
https://nodejs.org/es/

Jai un lenguaje de programación inspirado en C++

Hoy hablaremos de un nuevo lenguaje de programación llamado Jai . Se trata de un lenguaje de programación que está desarrolland...

Etiquetas

Archivo del blog