El lenguaje de programación en español

Un lenguaje de programación moderno, expresivo y completamente en español.

Diseñado para eliminar las barreras del idioma en la educación tecnológica.

Inicio Rápido •
Instalación •
Documentación •
Ejemplos •
Contribuir

---

Tabla de Contenidos

- Acerca de HispanoLang
- Inicio Rápido
- Instalación
- Referencia del Lenguaje
- Variables y Constantes
- Tipos de Datos
- Operadores
- Estructuras de Control
- Funciones
- Programación Orientada a Objetos
- Colecciones
- Manejo de Errores
- Ejemplos
- API de Node.js
- Arquitectura
- Contribuir
- Licencia

---

Acerca de HispanoLang

HispanoLang es un lenguaje de programación interpretado con sintaxis completamente en español. Fue diseñado con un objetivo claro: democratizar el acceso a la programación para los más de 500 millones de hispanohablantes en el mundo.

$3

La mayoría de los lenguajes de programación utilizan palabras clave en inglés, creando una barrera adicional para quienes están aprendiendo a programar. HispanoLang elimina esta barrera, permitiendo que los estudiantes se concentren en los conceptos fundamentales de la programación sin tener que lidiar simultáneamente con un idioma extranjero.

$3

| Característica | Descripción |
| ------------------------------ | ---------------------------------------------------------------------- |
| Sintaxis en Español | Palabras clave intuitivas como variable, funcion, si, mientras |
| Tipado Dinámico | Sistema de tipos flexible con conversiones automáticas |
| POO Completa | Clases, herencia, constructores y métodos |
| Funciones de Primera Clase | Funciones como valores, closures y callbacks |
| Colecciones Ricas | Arrays y objetos con métodos funcionales integrados |
| REPL Interactivo | Experimenta con código en tiempo real |
| Integración Node.js | Usa HispanoLang como módulo en proyectos JavaScript |
| TypeScript Ready | Definiciones de tipos incluidas |

---

Inicio Rápido

``bash


Instalar globalmente

npm install -g hispano-lang

Iniciar el REPL interactivo

hispano

O ejecutar un archivo

hispano mi_programa.hl
`

Tu primer programa en HispanoLang:

`
variable mensaje = "¡Hola, mundo!"
mostrar mensaje
`

---

Instalación

$3

- Node.js 20.0.0 o superior
- npm o yarn

$3

`bash
npm install -g hispano-lang
`

$3

`bash
npm install hispano-lang
`

$3

`bash
git clone https://github.com/nicvazquezdev/hispano-lang.git
cd hispano-lang
npm install
npm run build
npm link
`

$3

`bash
hispano --version
`

---

Referencia del Lenguaje

$3

#### Variables

Las variables se declaran con la palabra clave variable y pueden ser reasignadas:

`
variable nombre = "Ana"
variable edad = 25
variable activo = verdadero

edad = 26 // Reasignación permitida
`

#### Constantes

Las constantes se declaran con constante y no pueden ser reasignadas:

`
constante PI = 3.14159
constante MAX_INTENTOS = 3
constante VERSION = "2.0.0"

PI = 3.14 // Error: No se puede reasignar la constante
`

---

$3

| Tipo | Ejemplo | Descripción |
| ---------- | -------------------- | ------------------------------ |
| Número | 42, 3.14, -10 | Enteros y decimales |
| Texto | "Hola", 'Mundo' | Cadenas de caracteres |
| Booleano | verdadero, falso | Valores lógicos |
| Arreglo | [1, 2, 3] | Colección ordenada |
| Objeto | { clave: valor } | Colección de pares clave-valor |
| Nulo | nulo | Ausencia intencional de valor |
| Indefinido | indefinido | Variable sin valor asignado |
| Función | funcion() {} | Bloque de código reutilizable |
| Clase | clase {} | Plantilla para crear objetos |

#### Conversión de Tipos

`
entero("42") // 42
entero(3.7) // 3

decimal("3.14") // 3.14

texto(123) // "123"
texto(verdadero) // "verdadero"

booleano(1) // verdadero
booleano("") // falso

tipo(42) // "numero"
tipo("hola") // "texto"
tipo([1, 2]) // "arreglo"
`

---

$3

#### Aritméticos

| Operador | Descripción | Ejemplo |
| -------- | -------------- | -------------- |
| + | Suma | 5 + 3 → 8 |
| - | Resta | 5 - 3 → 2 |
| | Multiplicación | 5 3 → 15 |
| / | División | 6 / 2 → 3 |
| % | Módulo | 7 % 3 → 1 |

#### Comparación

| Operador | Descripción | Ejemplo |
| -------- | ------------- | ---------------------- |
| == | Igual a | 5 == 5 → verdadero |
| != | Diferente de | 5 != 3 → verdadero |
| < | Menor que | 3 < 5 → verdadero |
| > | Mayor que | 5 > 3 → verdadero |
| <= | Menor o igual | 3 <= 3 → verdadero |
| >= | Mayor o igual | 5 >= 5 → verdadero |

#### Lógicos

| Operador | Descripción | Ejemplo |
| -------- | ----------- | --------------------------------- |
| y | AND lógico | verdadero y falso → falso |
| o | OR lógico | verdadero o falso → verdadero |
| ! | NOT lógico | !verdadero → falso |

#### Asignación Compuesta

`
variable x = 10
x += 5 // x = 15
x -= 3 // x = 12
x *= 2 // x = 24
x /= 4 // x = 6
x %= 4 // x = 2
`

#### Incremento y Decremento

| Operador | Tipo | Descripción | Ejemplo |
| -------- | -------- | ----------------------------------- | ----------------------------- |
| x++ | Postfijo | Retorna valor original, luego suma | x = 5; mostrar x++ → 5 |
| x-- | Postfijo | Retorna valor original, luego resta | x = 5; mostrar x-- → 5 |
| ++x | Prefijo | Suma primero, luego retorna | x = 5; mostrar ++x → 6 |
| --x | Prefijo | Resta primero, luego retorna | x = 5; mostrar --x → 4 |

`
variable contador = 5

// Postfijo: retorna el valor ANTES del cambio
mostrar contador++ // Imprime 5, contador ahora es 6
mostrar contador // Imprime 6

// Prefijo: retorna el valor DESPUÉS del cambio
mostrar ++contador // Imprime 7, contador ahora es 7
mostrar contador // Imprime 7
`

Funcionan también con arrays y objetos:

`
variable nums = [1, 2, 3]
mostrar ++nums[0] // Imprime 2, nums[0] ahora es 2

variable obj = { valor: 10 }
mostrar obj.valor++ // Imprime 10, obj.valor ahora es 11
`

---

$3

#### Condicional Si/Sino

`
si edad >= 18 {
mostrar "Mayor de edad"
} sino {
mostrar "Menor de edad"
}
`

#### Condicional Si/Sino Si (Else If)

`
variable nota = 85

si nota >= 90 {
mostrar "Excelente"
} sino si nota >= 80 {
mostrar "Muy bien"
} sino si nota >= 70 {
mostrar "Aprobado"
} sino {
mostrar "Reprobado"
}
`

Se pueden anidar condiciones:

`
variable edad = 25
variable estudiante = verdadero

si edad < 18 {
mostrar "Menor de edad"
} sino si edad < 30 {
si estudiante {
mostrar "Joven estudiante"
} sino {
mostrar "Joven trabajador"
}
} sino {
mostrar "Adulto"
}
`

#### Elegir/Caso (Switch)

`
elegir opcion {
caso 1: mostrar "Opción uno"
caso 2: mostrar "Opción dos"
caso 3: {
mostrar "Opción tres"
mostrar "Con múltiples líneas"
}
pordefecto: mostrar "Opción no válida"
}
`

#### Bucle Mientras

`
variable i = 0
mientras i < 5 {
mostrar i
i = i + 1
}
`

#### Bucle Para

`
para (variable i = 0; i < 5; i = i + 1) {
mostrar i
}
`

#### Bucle Hacer/Mientras

`
variable x = 0
hacer {
mostrar x
x = x + 1
} mientras x < 3
`

#### Bucle Para Cada

`
variable frutas = ["manzana", "banana", "naranja"]
para cada fruta en frutas {
mostrar fruta
}
`

#### Control de Flujo

`
mientras verdadero {
si condicion {
romper // Sale del bucle
}
si otraCondicion {
continuar // Salta a la siguiente iteración
}
}
`

---

$3

#### Declaración y Llamada

`
funcion saludar(nombre) {
retornar "Hola, " + nombre
}

mostrar saludar("María") // "Hola, María"
`

#### Funciones Anónimas

`
variable duplicar = funcion(x) {
retornar x * 2
}

mostrar duplicar(5) // 10
`

#### Funciones Flecha

Sintaxis concisa para funciones anónimas:

`
// Un parámetro (sin paréntesis)
variable doble = x => x * 2

// Múltiples parámetros
variable suma = (a, b) => a + b

// Sin parámetros
variable saludar = () => "Hola mundo"

// Con bloque de código
variable factorial = n => {
si (n <= 1) { retornar 1 }
retornar n * factorial(n - 1)
}

mostrar doble(5) // 10
mostrar suma(3, 4) // 7
mostrar factorial(5) // 120
`

Funciones flecha son ideales para callbacks:

`
variable numeros = [1, 2, 3, 4, 5]

numeros.mapear(x => x * 2) // [2, 4, 6, 8, 10]
numeros.filtrar(x => x > 2) // [3, 4, 5]
numeros.reducir((a, b) => a + b, 0) // 15
`

#### Funciones como Parámetros

`
funcion aplicar(valor, operacion) {
retornar operacion(valor)
}

variable resultado = aplicar(5, funcion(x) { retornar x * x })
mostrar resultado // 25
`

#### Funciones Matemáticas Integradas

`
raiz(16) // 4
potencia(2, 8) // 256
absoluto(-5) // 5
redondear(3.7) // 4
piso(3.7) // 3
techo(3.2) // 4
seno(0) // 0
coseno(0) // 1
tangente(0) // 0
aleatorio() // Número entre 0 y 1
`

---

$3

#### Definición de Clases

`
clase Persona {
constructor(nombre, edad) {
este.nombre = nombre
este.edad = edad
}

saludar() {
retornar "Hola, soy " + este.nombre
}

cumplirAnios() {
este.edad = este.edad + 1
}
}
`

#### Instanciación

`
variable persona = nuevo Persona("Carlos", 30)
mostrar persona.nombre // "Carlos"
mostrar persona.saludar() // "Hola, soy Carlos"

persona.cumplirAnios()
mostrar persona.edad // 31
`

#### Herencia

`
clase Empleado extiende Persona {
constructor(nombre, edad, cargo) {
super(nombre, edad)
este.cargo = cargo
}

presentarse() {
retornar este.saludar() + " y trabajo como " + este.cargo
}
}

variable emp = nuevo Empleado("Ana", 28, "Ingeniera")
mostrar emp.presentarse() // "Hola, soy Ana y trabajo como Ingeniera"
`

#### Verificación de Tipo

`
variable p = nuevo Persona("Luis", 25)
mostrar tipo(p) // "Persona"
`

---

$3

#### Arreglos

`
variable numeros = [1, 2, 3, 4, 5]

// Acceso y modificación
mostrar numeros[0] // 1
numeros[0] = 10

// Propiedades y métodos básicos
numeros.longitud() // 5
numeros.primero() // 10
numeros.ultimo() // 5
numeros.agregar(6) // Añade al final
numeros.remover() // Remueve del final
numeros.contiene(3) // verdadero
`

#### Métodos Funcionales

`
variable nums = [1, 2, 3, 4, 5]

// Transformación
nums.mapear(funcion(x) { retornar x * 2 })
// [2, 4, 6, 8, 10]

// Filtrado
nums.filtrar(funcion(x) { retornar x > 2 })
// [3, 4, 5]

// Reducción
nums.reducir(funcion(acc, x) { retornar acc + x }, 0)
// 15

// Búsqueda
nums.buscar(funcion(x) { retornar x > 3 })
// 4

// Verificación
nums.algunos(funcion(x) { retornar x > 4 }) // verdadero
nums.todos(funcion(x) { retornar x > 0 }) // verdadero

// Ordenamiento
nums.ordenar() // [1, 2, 3, 4, 5]
nums.invertir() // [5, 4, 3, 2, 1]

// Manipulación
nums.cortar(1, 3) // [2, 3]
nums.insertar(2, 99) // Inserta 99 en posición 2
nums.unir(", ") // "1, 2, 3, 4, 5"
`

#### Iteración

`
variable colores = ["rojo", "verde", "azul"]
colores.recorrer(funcion() {
mostrar "Color: " + elemento + " en índice " + indice
})
`

#### Objetos

`
variable persona = {
nombre: "Elena",
edad: 32,
ciudad: "Madrid"
}

mostrar persona.nombre // "Elena"
persona.edad = 33 // Modificar
persona.profesion = "Dev" // Añadir propiedad
`

#### Cadenas de Texto

`
variable texto = "Hola Mundo"

// Propiedades
texto.longitud() // 10

// Transformación
texto.mayusculas() // "HOLA MUNDO"
texto.minusculas() // "hola mundo"
texto.recortar() // Elimina espacios extremos
texto.invertir() // "odnuM aloH"

// Búsqueda
texto.incluye("Mundo") // verdadero
texto.empiezaCon("Hola") // verdadero
texto.terminaCon("Mundo") // verdadero

// Extracción
texto.caracter(0) // "H"
texto.subcadena(0, 4) // "Hola"

// Manipulación
texto.dividir(" ") // ["Hola", "Mundo"]
texto.reemplazar("Mundo", "Amigo") // "Hola Amigo"
`

#### Interpolación de Cadenas

`
variable nombre = "María"
variable edad = 25

mostrar Hola ${nombre}, tienes ${edad} años
// "Hola María, tienes 25 años"

mostrar El doble de tu edad es ${edad * 2}
// "El doble de tu edad es 50"
`

#### Métodos Numéricos

`
variable n = 42

n.esPar() // verdadero
n.esImpar() // falso
n.esPositivo() // verdadero
n.esNegativo() // falso
n.aTexto() // "42"
`

---

$3

`
intentar {
variable resultado = operacionRiesgosa()
mostrar resultado
} capturar (error) {
mostrar "Ocurrió un error: " + error
}
`

---

Ejemplos

$3

`
funcion calculadora(a, b, operacion) {
elegir operacion {
caso "+": retornar a + b
caso "-": retornar a - b
caso "": retornar a b
caso "/": {
si b == 0 {
retornar "Error: División por cero"
}
retornar a / b
}
pordefecto: retornar "Operación no válida"
}
}

mostrar calculadora(10, 5, "+") // 15
mostrar calculadora(10, 5, "*") // 50
`

$3

`
funcion fibonacci(n) {
si n <= 1 {
retornar n
}
retornar fibonacci(n - 1) + fibonacci(n - 2)
}

para (variable i = 0; i < 10; i = i + 1) {
mostrar fibonacci(i)
}
`

$3

`
clase Producto {
constructor(nombre, precio) {
este.nombre = nombre
este.precio = precio
}
}

clase Carrito {
constructor() {
este.productos = []
}

agregar(producto) {
este.productos.agregar(producto)
}

total() {
retornar este.productos.reducir(
funcion(acc, p) { retornar acc + p.precio },
0
)
}

mostrarResumen() {
mostrar "=== Carrito de Compras ==="
para cada producto en este.productos {
mostrar ${producto.nombre}: $${producto.precio}
}
mostrar Total: $${este.total()}
}
}

variable carrito = nuevo Carrito()
carrito.agregar(nuevo Producto("Laptop", 999))
carrito.agregar(nuevo Producto("Mouse", 29))
carrito.agregar(nuevo Producto("Teclado", 79))
carrito.mostrarResumen()
`

---

API de Node.js

$3

`javascript
const { interpret, run } = require("hispano-lang");

// Interpretar código y obtener resultado completo
const result = interpret(
variable x = 10
mostrar x * 2
);

console.log(result.success); // true
console.log(result.output); // ['20']
console.log(result.error); // null

// Ejecutar y obtener solo la salida
const output = run(mostrar "Hola desde Node.js");
console.log(output); // ['Hola desde Node.js']
`

$3

`typescript
import { interpret, InterpretationResult } from "hispano-lang";

const result: InterpretationResult = interpret(
variable mensaje = "TypeScript + HispanoLang"
mostrar mensaje
);
`

---

Arquitectura

HispanoLang utiliza una arquitectura de intérprete clásica con tres fases:

`
┌─────────────┐ ┌────────────┐ ┌─────────────┐
│ Tokenizer │ ──▶ │ Parser │ ──▶ │ Evaluator │
│ (Léxico) │ │ (Sintaxis) │ │ (Ejecución) │
└─────────────┘ └────────────┘ └─────────────┘
│ │ │
▼ ▼ ▼
Tokens AST Resultado
`

$3

`
hispano-lang/
├── src/
│ ├── tokenizer.js # Análisis léxico
│ ├── parser.js # Análisis sintáctico → AST
│ ├── evaluator.js # Evaluación del AST
│ └── interpreter.js # Orquestador principal
├── bin/
│ └── hispano.js # CLI
├── test/
│ └── test.js # Suite de tests (334+)
└── dist/ # Build de producción
`

---

Contribuir

Las contribuciones son bienvenidas. Por favor, lee las siguientes guías antes de contribuir.

$3

`bash
git clone https://github.com/nicvazquezdev/hispano-lang.git
cd hispano-lang
npm install
npm test
`

$3

1. Fork del repositorio
2. Crear rama feature: git checkout -b feature/nueva-funcionalidad
3. Commit de cambios: git commit -m 'Añadir nueva funcionalidad'
4. Push a la rama: git push origin feature/nueva-funcionalidad
5. Crear Pull Request

$3

- Ejecutar npm run lint antes de commit
- Ejecutar npm run format` para formatear código
- Añadir tests para nuevas funcionalidades
- Mantener cobertura de tests existente

$3

Abre un issue incluyendo:

- Descripción del problema
- Código para reproducir
- Comportamiento esperado vs actual
- Versión de Node.js y sistema operativo

---

Licencia

Distribuido bajo la Licencia MIT. Ver LICENSE para más información.

---

Autor

Nicolas Vazquez

- GitHub: @nicvazquezdev
- Email: nicorvazquezs@gmail.com

---

_{Hecho con dedicación para la comunidad hispanohablante}