Code monkey: enero 2019

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.

Creamos una carpeta llamada testNodeJS
Tecleamos npm init
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:

https://linuxize.com/post/how-to-install-node-js-on-ubuntu-18.04/

https://codemonkeyjunior.blogspot.com/2016/11/un-vistazo-nodejs.html

https://nodejs.org/es/

sábado, 19 de enero de 2019

Creando un sencillo servicio REST con Kotlin y Spark Framework

REST (Representational State Transfer o Transferencia de Estado Representacional) es considerada como cualquier interfaz entre sistemas que usen HTTP para obtener datos o generar operaciones sobre esos datos; el formato de salida puede ser JSON y/o XML.

Existen tres niveles de implementación:

A nivel recursos (el más básico)
Usando verbos HTTP (get, post, put, options, etc.)
HATEOAS (el nivel más avanzado)

Para este ejemplo necesitamos importar las dependencias necesarias en nuestro archivo build.gradle

buildscript {
    ext.kotlin_version = '1.3.10'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
    mavenCentral()
}

dependencies {
    compile "com.sparkjava:spark-kotlin:1.0.0-alpha"
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

main.kt

package com.codemonkey

import spark.Spark.*;

object Main {
   @JvmStatic
   fun main(args:Array<String>){
    get("/holaKotlin") { req, res -> "Spark Framework desde Kotlin" }
   }

}

Construimos el proyecto

$ gradle build

Ejecutamos

$ gradle run

Abrimos un navegador web en http://localhost:4567/holaKotlin

Links:
http://sparkjava.com/

HashMap en Kotlin

En el post anterior vimos como de definir arreglos y listas (entre otras cosas). En está ocasión aprenderemos a usar HashMap en Kotlin.

Definir mapa:

val mapa:Map<String,Int> = hashMapOf<String,Int>("a" to 12, "b" to 15, "c" to 25)

Recorrer con for each:

mapa.forEach { (key, value) -> println("$key = $value") }

Recorrer con for:

for((key,value) in mapa){

    println("$key : $value")

}

sábado, 5 de enero de 2019

Herencia en Kotlin

Herencia en Kotlin
En este ejemplo veremos herencia, un concepto base en el paradigma orientado a objetos. En Herencia una clase Base (clase padre o superclase) puede heredar atributos (variables de instancia) y su comportamiento (métodos).

¿Cómo creamos herencia en Kotlin?

open class Electronico{}

data class Computadora: Electronico(){}

Esto parece sencillo, pero ¿qué pasa cuando las clases tienen atributos? Enseguida veremos un ejemplo.

Crearemos dos clases:

Una clase Padre (Padre.kt) y
Una clase hija (Estudiante.kt)

Persona.kt

package com.codemonkey.clases;

open class Persona(open val nombre:String, open val apellidos:String, open val edad:Byte){
    init{
        println("objeto Persona creado e inicializado");
    }

    var Color:String = "Blanco";

    constructor(nombre:String, apellidos:String, edad:Byte, color:String): this(nombre,apellidos,edad){
        Color = color;
    }
}

Persona (Superclase) posee tres atributos en el constructor principal: nombre,apellidos y edad. Enel segundo constructor añadimos un nuevo atributo: color.

Estudiante.kt

package com.codemonkey.clases;

data class Estudiante(override val nombre:String,override val apellidos:String,override val edad:Byte, val id:Long):Persona(nombre,apellidos,edad){
    init{
        println("objeto Estudiante creado e inicializado");
    }

    init{
        println("Estudiante ${nombre} ${apellidos}");
    }
}

Como se puede observar no solo hereda sus atributos sino que podemos añadir uno propio. En esta caso es el id del Estudiante. También es importante notar el bloque de código que empieza con init. Este se ejecutará al inicio (parecido al constructor).

main.kt

package com.codemonkey;

import com.codemonkey.clases.*

object Main {
   @JvmStatic
   fun main(args:Array<String>){
var id=10000L
     var nombre = "Carolina"
     var apellidos = "Contreras Lopez"
     var edad:Byte = 10
     var estudiante:Estudiante = Estudiante(nombre,apellidos,edad,id);
     println(estudiante)

     nombre = "Juan"
     apellidos = "Estevez"
     var tuEdad:Byte=33;
     var color = "Castaño"
     var persona = Persona(nombre,apellidos,tuEdad,color);
     println("Nombre compledo ${persona.nombre} ${persona.apellidos}");
     println("Edad ${persona.edad} años, color de cabello: ${persona.Color}");
}
}

Post anteriores:
http://codemonkeyjunior.blogspot.com/2019/01/arreglos-listas-funciones-y-clases-en.html
http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html

Arreglos, listas, funciones y clases en Kotlin

En casi cualquier lenguaje de programación debemos trabajar con estructuras de datos como listas, arreglos, mapas, etc. Kotlin no se queda atrás y nos permite definir estas estructuras con algunas peculiaridades.
Si queremos definir un array (no olvidar que debemos poner de qué tipo) :

var arreglo: Array<Double> = arrayOf<Double>(10.7,20.55,31.90,49.99,53.33,66.666,70.70);

Si queremos definir una lista, por ejemplo de un tipo específico (un tipo Clase) podríamos definir primero la clase:

data class Circulo(val radio:Double)

¿Sólo eso? Sí, sólo eso. Kotlin nos ahorra mucho trabajo.

Ahora definamos una lista de tipo Circulo:

val listaCirculo: List<Circulo> =listOf(Circulo(34.55), Circulo(7.8),Circulo(12.00));

¿Cómo los recorremos?

//for en arreglo
     for(arr:Double in arreglo){
       println("Hola ${arr}");
     }
println();
     //for en lista Circulo
     for(circulo:Circulo in listaCirculo){
       println(circulo);
       println("Radio = ${circulo.radio}")
     }

¿Y qué pasa con las funciones?
Aquí unos ejemplos:

//Una función sin parámetros de entrada y salida
fun nombreFuncion(){
  println("Hola, desde Kotlin!!!");

}

nombreFuncion();

//Una función con parámetros de entrada:
fun getValor(numero:Int): Int{
  return numero*2;
}

var valor = getValor(2);
println("Valor: ${valor}");

//Una función de tipo Boolean
fun String.esMayorACinco():Boolean{
    return this.length > 5;
}
 println("CINCO".esMayorACinco());//false

Post anterior: http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html

Links:
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a

Conociendo Kotlin

Kotlin es un lenguaje dependiente de la Máquina Virtual Java (JVM); empresas como Google han adoptado este lenguaje porque promete ofrecer compatibilidad e interoperabilidad con proyectos hechos con le lenguaje Java. Kotlin es muy similar a otros lenguajes de programación como Scala y Go (e incluso Typescript). Al igual que Java posee tipos clase (Byte, Short, Int, Float, Double, Boolean, Char). Además podemos importar librerías de Java sin ningún problema. Para declarar una variable modificable usamos var, para declarar una variable no modificable usamos val (similar a Scala).

¿Tipado estático?
El tipado estático puede parecer engorroso a algunos programadores, pero tener que definir el tipo de variables a usar tiene la ventaja de que a la hora de la compilación verificará si existe algún problema. (Supongamos que en un lenguaje dinámico donde no es necesario declarar el tipo de variable a usar necesitamos listar, en una llamada a un método especial, cadenas de texto ("strings") y le pasamos una lista con datos tipo Boolean, etc. y nos provoca un error).

Un programa escrito en Kotlin debe llevar la extensión *.kt

main.kt

package com.codemonkey

fun main() {
    println("Programando en Kotlin!!!")
}

Tipos de variables main.kt

//Enteros:
var byte:Byte = 0;
var short:Short = 120;
var int:Int = 40;
var long:Long = 12000000;

//Reales
var float:Float = 2.30f;
var double:Double = 12.654;

//Booleano
var verdadero:Boolean = true;

//Caracter
var character:Char = '\u0000';

//Cadenas
var cadenaStr:String = "Codemonkey Junior";


//Array
var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);

//Lista
var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala");

Imprimimos los datos a pantalla:

//Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

Compilamos y creamos el jar:
$ kotlinc main.kt -include-runtime -d main.jar
Ejecutamos:
$ java -jar main.jar

También existe la manera de crear y compilar proyectos Kotlin usando Gradle. Para eso debemos definir nuestro archivo gradle.build

gradle.build

buildscript {
    ext.kotlin_version = '1.3.10'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

Modificamos nuestro código:

package com.codemonkey

object Main {
   @JvmStatic
   fun main(args:Array<String>){
       //Enteros:
     var byte:Byte = 0;
     var short:Short = 120;
     var int:Int = 40;
     var long:Long = 12000000;
     
     //Reales
     var float:Float = 2.30f;
     var double:Double = 12.654;
     
     //Booleano
     var verdadero:Boolean = true;
     
     //Caracter
     var character:Char = '\u0000';
     
     //Cadenas
     var cadenaStr:String = "Codemonkey Junior";
     
     //Arrays
     var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);
     //Lista
     var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 

     //Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

   }
}

Listar Arrays

  println();
     for(numero in numeros){
       println(" "+numero);
     }
     println();
     for(elemento in miLista){
       println("${elemento}")
     }

Para compilar, construir nuestro proyecto tecleamos:
$ gradle build

Para listar las tareas disponibles usamos:
$ gradle -q task

Usaremos run para correr el proyecto:

$ gradle run

Links de interés
https://codemonkeyjunior.wordpress.com/2018/11/18/gradle-kotlin/
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a
https://rubentejera.com/por-que-usar-kotlin/
https://emanuelpeg.blogspot.com/2019/01/propiedades-y-campos-en-kotlin.html

Poner código en blogger
http://hilite.me/