Clojure para programadores Java(2)

Siguiendo la serie de post sobre Clojure veremos los tipos de datos en este lenguaje de programación. Como cualquier otro lenguaje dependiente de la JVM posee tipos de datos.

Ejemplos de tipos de datos en Clojure

"Esto es una cadena de texto. "	String
'W'	Character
34500	Long
7.54	Double
nil	null
bar	símbolo en Clojure
:bar	llave en Clojure
(1 2 3)	lista en Clojure
[1 2 3]	vector en Clojure
{"Alef" 1 "Bet" 2 }	mapa en Clojure

REPL de Clojure

Abrimos una terminal y tecleamos clj. Esto abrirá un REPL:

Clojure 1.10.2
user=>  1 +2 +3 +4
1
2
3
4
user=> + 3 4 5 6
#object[clojure.core$_PLUS_ 0x1d572e62 "clojure.core$_PLUS_@1d572e62"]
3
4
5
6
user=> (+ 3 4 5 6)
18
user=> ( * 4 5 6 7)
840
user=> "Esto es una cadena en Clojure."
"Esto es una cadena en Clojure."
user=> (def texto "Esto es un texto en una variable.")
#'user/texto
user=> (texto)
Execution error (ClassCastException) at user/eval5 (REPL:1).
class java.lang.String cannot be cast to class clojure.lang.IFn (java.lang.String is in module java.base of loader 'bootstrap'; clojure.lang.IFn is in unnamed module of loader 'app')
user=> (println texto)
Esto es un texto en una variable.
nil
user=> (def numero 32)
#'user/numero
user=> (println "Numero = "numero)
Numero =  32
nil
user=> (defn hola-mundo [] (println "Hola, mundo en Clojure"))
#'user/hola-mundo
user=> (hola-mundo)
Hola, mundo en Clojure
nil
user=> (defn sumar [x y] (+ x y))
#'user/sumar
user=> (println "Suma : "(sumar 45 33))
Suma :  78
nil
user=>

Es importante notar algunas cosas:

Hacer uso de los paréntesis, tanto para definir variables y asignar un valor, como para imprimir en pantalla o realizar alguna operación. Abajo podemos ver la sintaxis para definir una variable y asignar un valor. El valor puede ser de tipo String, Long, Double, Character, etc. o hasta uno definido por nosotros (clase/tipo).

(comment
   sintaxis:
   (def ref valor)
)
;; Definimos una variable y asignamos un valor 
(def variable "Valor de la variable")

Ejemplos de declaración de variables

; Definimos variable(s) y su valor(es)
(def ID 123455)
(def nombre "Fernando")
(def edad (- 2022 1981))
(def puede-votar (> edad 18))

Al definir una variable también podemos agregar un comentario.

(def valor "comentario" "Fernando")
(println valor);; Fernando

(def numero "Esto es un  numero Long" 324555)
(println numero);; 324555

(def caracter "Esto es un Character" "@")
(println caracter);; @

Operadores

Operador	Significado
+	suma
-	resta
*	multiplicación
/	división
=	igualdad
<	menor que
>	mayor que
inc	incremento
dec	decremento

Abrimos una terminal para hacer algunas pruebas:

$ clj
Clojure 1.10.2
user=> (/ 45 3)
15
user=> (inc 4)
5
user=> (dec 10)
9
user=> (mod 220 200)
20
user=> (< 3 2)
false
user=> (> 220 200)
true
user=> (= 11 11)
true
user=> (+ 1 2 3 4 5)
15
user=> (- 99 88 11)
0
user=> (* 5 4 3 2 1)
120
user=>

Condicionales y operadores booleanos o lógicos

El usor de operadores lógicos no puede faltar en cualquier lenguaje de programación.

Operador	Significado
and	operador AND
or	operador OR
not	operador NOT

Abrimos una terminal y probamos:

clj
Clojure 1.10.2
user=> (not (< 200 220))
false
user=> (and true true)
true
user=> (or true false)
true
user=> (or false false)
false
user=> (and true false)
false
user=> (and false false)
false
(println "3 >= 3  and 7 != 8 :"
    (and (>= 3 3) (not= 7 8) )
)
3 >= 3  and 7 != 8 : true
nil

El clásico if y su sintaxis en Clojure:

(if (condicion)
   cuerpo
)

Abrimos una terminal y probamos:

$ clj
Clojure 1.10.2
user=> (if (< 200 220) (println "Es verdadero"))
Es verdadero
nil
user=> (if (= 20 20) (println "Correcto"))
Correcto
nil
user=> (if (> 100 99) (println "Es verdadero"))
Es verdadero
nil
user=> (if (not (< 100 99)) (println "True"))
True
nil

Ejemplo. Crear una función que valide si un número es mayor a 100.

;; Función 
(defn mayor-a-100? "Si es mayor a 100 devolvera un true" [num]
    (if (> num 100)
       true
    )    
)

;; Prueba de la función
(println (str "¿100 es mayor a 100?: " (if (mayor-a-100? 100) "Si, es mayor." "No, no lo es.")))
(println (str "¿110 es mayor a 100?: " (if (mayor-a-100? 110) "Si, es mayor." "No, no lo es.")))
(println (str "¿1000 es mayor a 100?: " (if (mayor-a-100? 1000) "Si, es mayor." "No, no lo es.")))

Funciones

Básicamente, una función es un bloque de código que hace alguna operación y devuelve un valor. Es similar a un procedimiento, pero el procedimiento no devuelve nada.

Sintaxis

;; Definimos la función
(defn nombreFunc [arg1 arg2 argN]
   cuerpo-de-la-función
)

Ejemplo. Función para comprobar si un número es mayor a 10.

;; Definimos la función
(defn esmayor10? [num]
   (if (> num 10) "Si" "No")
)

;; Pruebas de la función
(println "300 es mayor a 10? "(esmayor10? 300))
(println "30 es mayor a 10? "(esmayor10? 30))
(println "0 es mayor a 10? "(esmayor10? 0))
(println "-1 es mayor a 10? "(esmayor10? -1))

Es importante notar que al definir una fucnión se le puede agregar un comentario sobre qué es lo que hace.

; Función cuadrado
(defn cuadrado "Multiplica un numero ṕor si mismo"[n]
 (* n n)
)
; Función sumar
(def sumar "Suma dos numeros" [x y]
   (+ x y)
)
;; Función para resolver una ecuación
(defn calcular "Devuelve una operacion" [ a b c d e f denominador]
	(def x (/ (- (* c e) (* b f) ) denominador));;x
	(def y (/ (- (* a f) (* c d) ) denominador));;y
	(println "Solucion:\nx="x" , y="y)
  )

; Procedimiento (no devuelve valor)
(defn my-func-hola "Este solo es un clásico Hola, Mundo!!" []
    (println "Este solo es un clásico Hola, Mundo!!")    
)

;; Esta función tiene parametros
(defn my-func-hola-two "Devuelve un saludo. Verifica si el nombre esta en blanco o es null" [nombre]
    (if (clojure.string/blank? nombre)
        (println "Hola, Extraño")
        (println "Hola,"nombre)
    )    
)

;; Para verificar si una cadena termina en xml
(defn es-xml? "Verifica si una cadena termina en xml" [documento]
    (if (clojure.string/ends-with? documento "xml")
        (println "Se consume el archivo "documento".")
        (println "El archivo ["documento"] no puede ser procesado.")
    )    
)

;; Verifica si una cadena inicia con la letra a
(defn inicia-con-a? "Verifica si una cadena empieza con la letra a" [documento]
    (if (clojure.string/starts-with? documento "a")
        (println "Inicia con a: "documento".")
        (println " ["documento"] no puede ser procesado.")
    )    
)

;; Convertir, por ejemplo, -1 a 1
(defn my-abs "Esta funcion devuelve un valor absoluto de otro numero" [x]
    (if (> x 0)
       x 
       (- x)
    )
)

;; Si un numero es mayor a 100
(defn mayor-a-100? "Si es mayor a 100 devolvera un true" [num]
    (if (> num 100)
       true
    )    
)

Para terminar dejamps un vídeo sobre un tutoria sobre Clojure.

Clojure language tutorial

Enlaces:

https://learnxinyminutes.com/docs/es-es/clojure-es/

Java en ejemplos: creando nuestras propias excepciones

De errores y excepciones Una excepción en programación es una anomalía en el flujo de un programa. El programador puede anticiparse a ésta haciendo que su código pueda librarla y que el programa no termine abruptamente. Ejemplo. Una excepción podría ocurrir en un programa que lee archivos de texto, el programa es incapaz de leer líneas con acentos, apóstrofes, letras Ñ o símbolos raros. El programador tendría que saber manejar esas excepciones y mitigarlas. Un error es un problema en el programa que hará que éste termine abruptamente; el programador queda indefenso, no puede hacer nada al respecto para remediarlo. Este error puede ser falta de memoria o recursos del sistema, entre otros más. Ejemplo. Un programa pude cerrarse abruptamente al quedarse sin memoria el sistema operativo. En Java cada clase (propia o definida por el programador) es hija de la clase padre ``Object``. La clase ``Throwable`` es padre de la clase ``Exception`` y así sucesivamente. Como

Comunidad City Java

Buscar este blog