Saltar al contenido

ESLE2

El lenguaje SLE2 en el navegador

Documentación de ESLE2

Todo el lenguaje SL (SLE2) explicado, tal como lo implementa este sitio. Escribí en el buscador del índice para filtrar: se ocultan los apartados que no tengan que ver con lo que buscás. Atajo: pulsá / para ir al buscador.

Acá está el lenguaje. La interfaz —qué hace cada botón y cada panel— se explica con capturas en el botón Tutorial de ESLE2.

Qué es ESLE2

Un entorno completo de SLE2 que corre dentro del navegador.

El lenguaje

SL (y su entorno SLE2) es un lenguaje creado en el Centro Nacional de Computación de la Universidad Nacional de Asunción para enseñar algoritmos. Su sintaxis se parece a la de Pascal y C, pero está simplificada: hay un único tipo numérico, las cadenas crecen solas y no hace falta el punto y coma al final de cada sentencia.

ESLE2 reimplementa ese lenguaje en JavaScript, así que podés escribir, compilar y ejecutar programas SLE2 sin instalar nada.

Cómo se usa el IDE

EL CAMINO DE UN PROGRAMA Editor programa.sl lo que escribís vos Revisar sintaxis y recomendaciones Ejecutar el intérprete corre tu programa Pantalla la salida Entrada de datos lo que consume leer() si algo está mal, el error te devuelve al editor con una recomendación
Todo pasa dentro del navegador. El programa que escribís se revisa, se ejecuta y muestra su salida en la pantalla de abajo; los datos que necesite leer() salen del panel Entrada de datos. Si hay un error, ESLE2 te lleva de vuelta a la línea exacta del editor.
  • Explorador de archivos (en el menú Ver, viene apagado): si lo encendés, aparece a la izquierda una lista con todos tus programas, como en un editor de escritorio. El que tenías en el editor pasa a ser el primero, así que no se pierde nada. Podés crear, renombrar, duplicar y borrar archivos; al tocar uno se guarda solo el que estabas escribiendo y se abre el otro. Las carpetas son parte del nombre: si a un archivo lo llamás parcial/ej1.sl queda dentro de la carpeta «parcial», y moverlo de carpeta es renombrarlo. Apagándolo, ESLE2 vuelve a trabajar con un solo programa y tus archivos quedan guardados por si lo prendés de nuevo.
  • ESLE2 Visual: una página aparte para hacer ventanas con botones, cajas de texto y listas, y dibujar en un lienzo, con el mismo lenguaje de siempre y sin ninguna palabra reservada nueva. Está en ESLE2 Visual y tiene su propia documentación.
  • La barra de herramientas está agrupada en tres menús —Archivo, Ver y Traducir— para que a la vista queden solo los botones que se usan todo el tiempo: Ejecutar, Revisar y Depurar. Cada botón tiene su icono, y los menús se abren con el teclado y se cierran con Esc.
  • Editor: escribís el programa. Se guarda solo en tu navegador.
  • Entrada de datos: las líneas que va a consumir leer(). Si se agotan, ESLE2 te las pide por consola mientras el programa corre.
  • Ejecutar (Ctrl + Enter): compila y corre.
  • Revisar: verifica la sintaxis, muestra recomendaciones (variables sin usar, ciclos que podrían no terminar, palabras mal escritas…) y sugerencias de estilo para escribir el mismo programa mejor.
  • Detener (o la tecla Esc): corta el programa en el acto, esté dando vueltas en un ciclo o esperando datos, una tecla o una pausa de beep().
  • Guardar .sl / Abrir…: bajás o subís el archivo fuente.
  • Proyectar (Ctrl + Shift + P): agranda el código y la pantalla y saca de en medio lo que no se ve desde el fondo del aula. La barra de abajo ajusta el tamaño y sale.
  • El panel Para repasar hoy propone rehacer, de memoria, ejercicios que ya resolviste hace unos días: cuanto más te costó uno, antes vuelve.
  • Para el examen hay plantillas listas (lo básico, vectores y matrices, cadenas, práctica rápida), y con Ver entregas… se pueden abrir varias a la vez: sale una planilla del curso con la nota de cada uno, que se baja en .csv.
  • Modo examen… (en el Curso): el profesor elige ejercicios y minutos y baja un archivo de examen; el alumno lo carga, lo rinde con cronómetro y sin pistas, y al entregar el navegador corrige solo y baja la entrega con los resultados, el código y los tiempos.
  • El panel Cómo venís, debajo de la lista del curso, cuenta cuántos ejercicios resolviste por nivel, cuántas veces verificaste y en cuál te trabaste más.
  • Mis ejercicios… (en el Curso): creá tus propios ejercicios con sus casos de prueba —se corrigen solos igual que los del curso— y compartilos como archivo.
  • Modo aula… (en el Curso): armá una guía con los ejercicios que quieras —del curso, o tuyos con tus propios casos de prueba—, ponele un título y un mensaje para la clase, y copiá un enlace. Quien lo abre ve esa guía y nada más, y cada ejercicio se corrige solo, como siempre. La guía entera viaja adentro del enlace, después del #: no hay servidor, no hay cuentas, no hay nada que se caiga el día del parcial, y lo que va después del # no se manda a ningún lado. Para volver al curso completo está Salir de la guía.
  • Grabar ejecución (al lado de Depurar): corre el programa entero de una vez y deja abajo una barra de tiempo. Arrastrándola se vuelve a cualquier instante: la línea que se estaba ejecutando se marca en el editor, las variables vuelven al valor que tenían —y la que cambió en ese paso queda resaltada—, y lo que el programa había imprimido y dibujado se borra o se vuelve a pintar según hacia dónde muevas. Sirve para la pregunta que uno se hace de verdad: ¿en qué momento esta variable se llenó de basura? Si el programa no termina, se corta a los 4000 pasos y te lo dice; lo grabado hasta ahí es justo lo que hay que mirar. Mientras graba, los datos salen del panel Entrada de datos: no te los va a pedir por consola.
  • Modo enfoque (menú Ver, o Alt + E): deja el editor y nada más —sin pestañas, sin menús, sin la columna de la derecha— con una barra chica abajo. Al ejecutar, la pantalla vuelve sola para que veas el resultado, y se va de nuevo en cuanto seguís escribiendo; también se puede dejar fija. Trae música de fondo tranquila, apagada de entrada: se puede encender y bajarle el volumen desde esa barra. La música no es un archivo descargado, se calcula en el momento, así que no pesa nada y funciona sin internet.
  • Programar en grupo… (menú Archivo): dos alumnos, o la clase entera, escriben el mismo programa desde computadoras distintas, como en un documento compartido. Uno crea la sala y reparte el enlace. El texto viaja cifrado de punta a punta con una llave que sale del mismo enlace: el servidor que lo reparte no la recibe nunca y no puede leer nada. Se comparte solo el texto del programa —la entrada, la salida y tu progreso siguen siendo tuyos—, y cada uno ejecuta en su máquina. Es lo único de ESLE2 que necesita internet, y lo que hace falta para que ande se descarga recién al abrirlo.
  • Transmitir mi lógica… (menú Archivo): un enlace corto y fácil de dictar —esle2.vercel.app/live/juan— para que otros vean, en el momento, cómo vas escribiendo tu programa. Los que miran solo miran: no pueden tocar tu código. Sirve para mostrarle algo a un profesor sin mandarle un archivo, o para que la clase siga desde su pantalla lo que se hace adelante. Ese enlace es público: el nombre es corto para poder dictarlo, así que también es fácil de adivinar, y cualquiera que escriba esa dirección puede mirar mientras estés transmitiendo. No pongas ahí tu nombre completo, y cortá la transmisión al terminar. Cuando cerrás la pestaña no queda nada que mirar: no se guarda en ningún lado.
  • Batallas de código… (en el Curso): dos personas, el mismo problema, cinco minutos. Alguien crea la batalla, dicta el código —RIO-482— y el resto entra con él; el sistema empareja de a dos y le da a cada pareja el mismo ejercicio. Gana quien pasa todos los casos de prueba primero. El código que escribe cada uno es suyo: entre las dos máquinas solo viaja «terminé, en tantos segundos». Los puntos se guardan en tu navegador y no hay tabla mundial: la idea es que dos se sienten a resolver lo mismo, no un ranking.
  • Si te trabás, te lo decimos. Cuando el mismo error de sintaxis aparece cinco veces seguidas en menos de dos minutos, sale un mensaje en la salida ofreciendo mirar juntos la línea, y si sigue pasando, propone parar treinta segundos —que destraba más que otros diez intentos—. No interrumpe, no roba el foco, no repite, y se apaga para siempre con un botón.
  • ESLE2 funciona sin internet: la primera visita deja todo guardado en el navegador. También se puede instalar como aplicación con el botón Instalar.
  • A JavaScript y A Python: muestran el mismo programa traducido, listo para correr con node programa.js o python programa.py. Sirve para ver cómo se escribe en otro lenguaje lo que ya sabés hacer en SLE2.
  • En el celular: ESLE2 se adapta a la pantalla —la barra de arriba, las pestañas y las herramientas se deslizan de costado en vez de apilarse, y los paneles van uno debajo del otro— y se puede instalar como aplicación con el botón . Queda con su icono en la pantalla de inicio, se abre sin la barra del navegador y anda sin internet. En Android e iPhone los pasos son distintos: el mismo botón te muestra los de tu teléfono.
  • Sonidos: el botón de la barra de arriba enciende y apaga tres avisos cortos y suaves —uno cuando el programa compila o termina bien, otro cuando se resuelve un ejercicio, y uno más grave y bajito cuando algo falla—. Duran menos de un segundo y no son archivos de audio: las notas se generan en el momento, así que no pesan nada y andan sin internet. La preferencia se guarda en este navegador.
  • ⟲ Historial: control de versiones en chiquito. ESLE2 guarda solo una copia de tu programa cada vez que lo ejecutás, cuando resolvés un ejercicio y antes de cualquier cosa que pise el editor —abrir un archivo, cargar un ejemplo, empezar un ejercicio, «Nuevo»—; también podés guardar una a mano con un nombre. En el diálogo se ve la lista de versiones y, al elegir una, qué cambió entre esa versión y lo que tenés ahora: en rojo lo que ya no está, en verde lo que se agregó. Restaurar la trae de vuelta al editor, y como antes de restaurar también se guarda lo que había, volver atrás nunca te hace perder nada.
  • Autocompletado: mientras escribís aparece una lista con lo que puede ir ahí —palabras reservadas, subrutinas del lenguaje con su firma y su explicación, y las variables, constantes, tipos y subrutinas de tu propio programa—. Se elige con las flechas y Enter, se cierra con Esc y se abre a mano con Ctrl + Espacio. Está pensado sobre todo para no escribir mal un nombre: si ponés imrimir te ofrece imprimir, y si escribís una palabra reservada con mayúsculas —Si, MIENTRAS— lo primero que aparece es la forma en minúsculas, que es la única válida. Las estructuras se completan enteras, con el sino adentro de las llaves.
  • ▤ Memoria: el simulador de memoria. Corre el programa guardando una foto por sentencia y después se recorre con una línea de tiempo: se ve nacer cada caja de variable —con su dirección, su tipo y cuántos bytes ocupa—, ponerse en amarillo cuando cambia su contenido y desaparecer cuando termina la subrutina. Cada llamada abre su marco en la pila, más abajo que el anterior, y al costado va escrito en palabras qué pasó en ese paso. Las direcciones y los tamaños son los de manual (un número 8 bytes, un lógico 1, una cadena una letra por byte), no los que usa el navegador por dentro.
  • ◇ Diagrama: dibuja el programa como diagrama de flujo —óvalo para el inicio y el fin, rectángulo para un proceso, romboide para la entrada y la salida, rombo para cada decisión— y al costado lo cuenta en palabras, paso por paso. El dibujo se baja como .svg y la explicación se copia al portapapeles, que es lo que suelen pedir los trabajos prácticos. Cada subrutina tiene su propio diagrama. El desde se dibuja abierto (inicializar, preguntar, cuerpo, sumar el paso) porque es la forma en que se explica en clase.
  • Los paneles se acomodan: las barras que los separan cambian el tamaño arrastrándolas —o con las flechas del teclado, que se pueden enfocar con Tab—, y cada panel se mueve de lugar arrastrándolo del título o con el botón de su encabezado. La disposición queda guardada en el navegador; ⤢ Paneles vuelve a la original.
  • Ajustar texto (Alt + Z, en el menú Ver): corta las líneas largas al ancho del panel en vez de dejarlas salir por la derecha. Lo que sigue abajo arranca a la altura de la línea original, así que un imprimir sangrado se sigue leyendo sangrado. Sirve sobre todo en un teléfono y proyectando en clase. Queda guardado, y cada ESLE2 tiene el suyo.
  • Buscar (Ctrl + K): un solo campo para llegar a cualquier parte: secciones de las dos documentaciones, ejercicios de los dos cursos y subrutinas predefinidas.
  • Exportar / Importar progreso (en el Curso): baja tu avance como archivo y lo vuelve a cargar en otra computadora o después de limpiar el navegador.
  • Depurar (F9): ejecuta el programa paso a paso. Se detiene antes de cada sentencia, te marca la línea que está por ejecutarse y muestra el panel Variables, que dibuja lo que vale cada una: los vectores como casillas numeradas desde 1, las matrices como filas de casillas y los registros con sus campos. F10 da un paso, F8 sigue sin pausas y Detener corta.
  • Compartir: copia un enlace con el programa y los datos de entrada adentro. El que lo abre lo recibe cargado en su IDE. El programa viaja en la propia dirección, así que no se sube a ningún servidor.
  • Archivos…: los archivos de texto que usan set_stdin() y set_stdout(). Viven en la memoria del navegador; podés crearlos, editarlos y ver lo que escribió tu programa.
  • Argumentos: los parámetros que devuelven paramval() y pcount(). Si un argumento tiene espacios, ponelo entre comillas.

Las dos versiones del lenguaje

ESLE2 acepta tanto la sintaxis del libro Introducción al lenguaje SL (1999) como las novedades del manual de subrutinas predefinidas (2004). En concreto, además de lo clásico podés usar:

  • sub como sinónimo de subrutina.
  • &&, ||, ! y != como sinónimos de and, or, not y <>.
  • Declarar variables con valor inicial y dejar que el tipo se deduzca: n = 0.
  • leer() e imprimir() con arreglos y registros enteros.
  • Archivos, colores, cursor, ifval(), intercambiar(), max(), min(), terminar(), beep() y readkey().

El curso

La pestaña Curso tiene ejercicios de nivel fácil, medio y avanzado. Cada uno trae enunciado, pista, plantilla y casos de prueba. Al pulsar Verificar solución el programa se ejecuta con todos los casos y se compara la salida. El progreso queda guardado en una cookie de tu navegador.

Con el teclado y con lector de pantalla

  • El primer Tab de cada página ofrece Saltar al contenido, para no recorrer la barra entera.
  • Todo lo que se puede tocar con el mouse se puede usar con el teclado, y lo que tiene el foco se ve con un contorno.
  • La pantalla del programa se anuncia sola: un lector de pantalla lee lo que va imprimiendo.
  • Los colores del sitio cumplen el contraste mínimo de la norma (WCAG AA, 4.5:1), en los dos temas y en los ocho fondos de la página Diseño.

Tu primer programa

Leer un dato, calcular y mostrar el resultado.

Ejemplo completo

/*
   Calcular e imprimir la suma de los numeros pares entre 1 y un n dado.
*/
programa suma_pares
var
   n, suma, k : numerico
inicio
   imprimir ("Ingrese un valor para n: ")
   leer (n)
   suma = 0
   desde k=2 hasta n paso 2
   {
      suma = suma + k
   }
   imprimir ("\nLa suma es ", suma)
fin

Con 20 en la entrada de datos, el programa imprime La suma es 110.

Qué mirar de ese programa

  • La cláusula programa nombre es opcional: solo documenta.
  • Todas las variables se declaran antes de usarlas, en la sección var.
  • El cuerpo va entre inicio y fin.
  • \n dentro de una cadena hace que lo siguiente se imprima en otra línea.
  • No hace falta ; al final de cada sentencia.

Estructura de un programa

Secciones de declaración, cuerpo principal y subrutinas.

Esqueleto general

programa suma_pares nombre del programa (opcional) const MAX = 100 valores que no cambian tipos FECHA : registro { … } tipos propios var n, suma : numerico las variables inicio … sentencias … fin el cuerpo: lo único obligatorio es este bloque subrutina promedio (…) … fin van siempre DESPUÉS del fin
Un programa mínimo es solo inicio … fin. Todo lo demás —nombre, constantes, tipos y variables— es opcional, puede repetirse y venir en cualquier orden; las subrutinas, en cambio, van siempre después del fin del programa principal.
programa nombre_del_programa     // opcional

const
   declaración de una o más constantes
tipos
   declaración de uno o más tipos de datos
var
   declaración de una o más variables

inicio
   sentencias...
fin

subrutina sub1 (parametros) retorna tipo_dato
   const / tipos / var propios
inicio
   sentencias...
   retorna ( algun_valor )
fin

Las cláusulas const, tipos y var pueden aparecer ninguna o varias veces y en cualquier orden. Las subrutinas van siempre después del fin del programa principal, y pueden tener sus propias constantes, tipos y variables.

Separadores de sentencias

El lenguaje es de formato libre: una sentencia puede ocupar varias líneas y no necesita ; al final. Si querés poner dos sentencias en la misma línea, ahí sí las separás con punto y coma:

a = (b + c) * (b / y) +
    (y / c)              // una sola sentencia en dos líneas

a = b + c; n = a / y     // dos sentencias en una línea

Comentarios

Texto que el compilador ignora.

Las dos formas

// Comentario de una línea: vale hasta el fin de la línea.

/*
   Comentario de varias líneas.
   Puede contener // adentro, pero no otro comentario /* ... */

Los comentarios multilínea no se pueden anidar: el primer */ cierra el comentario.

Identificadores y palabras reservadas

Cómo se nombran variables, constantes, tipos y subrutinas.

Reglas de los identificadores

  • Empiezan con una letra o con guión bajo _.
  • Pueden tener hasta 32 caracteres.
  • No llevan espacios ni guiones medios.
  • Admiten letras, dígitos, _ y también ñ / Ñ.
  • No admiten vocales acentuadas.
  • Distinguen mayúsculas de minúsculas: CANTIDAD, cantidad y Cantidad son tres identificadores distintos.

Válidos: peso, total_puntos, MAXCOLUMNAS, mat2, sgte_año.
No válidos: 2da_var, $prueba, cant alumnos, tot-puntos.

Palabras reservadas

Se escriben siempre en minúsculas. No pueden usarse como nombres:

and        archivo    caso       const      constantes
desde      eval       fin        hasta      inicio
lib        libext     matriz     mientras   not
or         paso       sub        subrutina  programa
ref        registro   repetir    retorna    si
sino       tipos      var        variables  vector

sub es el nombre corto de subrutina que usa el manual de 2004; las dos formas son equivalentes.

Si escribís Si o MIENTRAS, el compilador las toma como nombres de variables y el error aparece más adelante, en un lugar raro. El botón Revisar del IDE detecta este caso y te avisa.

Tipos de datos y constantes literales

numerico, cadena y logico, más los valores que se escriben directamente.

Tipos básicos

numerico 42 -7.5 1.7E308 Un solo tipo para enteros y decimales. arranca en 0 cadena "hola" "12/2026" Crece sola: no hay que declarar su largo. arranca en "" logico TRUE / FALSE SI y NO son sinónimos de esos dos valores. arranca en FALSE
Tres tipos y nada más. No hay entero separado de real, ni un largo máximo para las cadenas. Toda variable arranca con un valor razonable, así que nunca vas a leer basura.
TipoValores que admiteValor inicial
numericoEnteros y reales, con o sin signo (de −1.7E308 a 1.7E308). SL no distingue entre entero y real.0
cadenaCualquier secuencia de caracteres. La longitud se ajusta sola; la cadena vacía es "".""
logicoTRUE y FALSE, o sus sinónimos SI y NO.FALSE

Números

Enteros, reales con punto decimal y notación científica:

314      -100     +217
3.14     2e+10    5e-3     8E+131

Cadenas y secuencias de escape

Una cadena va entre comillas dobles o entre apóstrofes. Sirve cualquiera de los dos, lo que permite incluir el otro adentro:

"Aprendiendo a programar..."
"Conteste con 'si' o 'no', por favor"
'Maria dijo: "Buenos dias!"'
SecuenciaSignificado
\nPasa al inicio de la línea siguiente
\rVuelve al inicio de la línea actual
\tTabulador
\\ \" \'El carácter que sigue a la barra, tal cual

Una constante de cadena tiene que entrar en una sola línea. Para repartirla, se concatena:

texto = "Aprender a programar " +
        "es divertido"

Variables y constantes

Declaración, valores por defecto y constantes manifiestas.

Declarar variables

var
   edad : numerico
   nombre : cadena
   tot_mensual, tot_general : numerico   // varias del mismo tipo

Todas las variables se declaran antes de usarlas. SL les da un valor inicial automático (0, cadena vacía o FALSE según el tipo).

Valor inicial e inferencia de tipo

Una declaración puede traer su valor inicial. Si lo trae, el tipo puede omitirse: SL lo deduce del valor. Las tres formas son válidas y se pueden mezclar:

var
   n = 0                                  // numerico, vale 0
   nombre = ""                            // cadena vacía
   ok = TRUE                              // logico
   pos_A = ord ("A")                      // el valor inicial puede ser una expresión
   nom_dias : vector [*] cadena = {"dom", "lun", "mar", "mie",
                                   "jue", "vie", "sab"}
   tope : vector [12] numerico = {31, 28, 31, 30, 31, 30,
                                  31, 31, 30, 31, 30, 31}

El valor inicial se evalúa una sola vez, al empezar el programa (o al entrar en la subrutina, si la variable es local). Un literal { … } sin tipo declarado produce un vector abierto del tipo de su primer elemento.

Escribir n = 0 en la sección var declara una variable; escribirlo en la sección const declara una constante que no puede cambiar.

Constantes manifiestas

const
   RAIZ_3  = 1.732050808
   DIGITOS = "0123456789"
   MAX     = 20

El tipo de la constante lo determina el valor que se le asigna. El compilador impide que se le asigne otro valor durante la ejecución. Sirven para no repetir “números mágicos” y para cambiar un valor en un solo lugar.

Están predefinidas cuatro constantes lógicas: TRUE, FALSE, SI (sinónimo de TRUE) y NO (sinónimo de FALSE).

Ámbito: global y local

Lo declarado al inicio del programa principal es global y se ve desde cualquier parte. Lo declarado dentro de una subrutina (o sus parámetros) es local y solo se ve ahí. Si un nombre local coincide con uno global, el global queda tapado mientras dura la subrutina.

Vectores y matrices

Arreglos de tamaño fijo, arreglos abiertos, dim(), alen() y literales.

Declaración

VECTOR A : vector [6] numerico 14 7 31 0 92 5 1 2 3 4 5 6 A [3] → 31 alen (A) → 6 Los índices empiezan en 1. No existe A [0]. MATRIZ M : matriz [3, 4] numerico fila 1 fila 2 fila 3 col 1 col 2 col 3 col 4 8 M [2, 3] → 8 alen (M) → 3 (filas) alen (M [1]) → 4 (columnas)
Un vector es una fila de casillas numeradas desde 1; una matriz es una cuadrícula. En la matriz, el primer índice es la fila y el segundo la columna, y alen() aplicado a una fila da la cantidad de columnas.
var
   A  : vector [100] numerico       // 100 elementos, índices de 1 a 100
   M  : matriz [5, 10] cadena       // 5 filas por 10 columnas
   M3 : matriz [3, 5, 2] numerico   // tres dimensiones
   v  : vector [*] numerico         // arreglo abierto (tamaño desconocido)
   Q  : matriz [*, 8] numerico      // filas abiertas, 8 columnas fijas
Los índices empiezan en 1, no en 0. A[1] es el primer elemento.

Una vez que se pone un tamaño concreto, las dimensiones siguientes ya no pueden ser *: matriz [5, *] es un error.

Arreglos abiertos: dim() y alen()

var
   v : vector [*] numerico
   n, k : numerico
inicio
   leer (n)
   dim (v, n)                 // recién ahora v tiene n elementos
   desde k=1 hasta alen (v)   // alen() devuelve la cantidad de elementos
   {
      v [k] = 0
   }
fin

alen() devuelve 0 si el arreglo abierto todavía no fue inicializado. Usar un arreglo abierto sin dimensionar es un error de ejecución.

Literales estructurados

tope_meses = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
dias_sem   = {"lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"}
mat        = { {1, 2, 3},
               {4, 5, 6},
               {7, 8, 9} }

v = {0, ...}          // completa con ceros todo el vector (solo tamaño fijo)
v = {}                // vuelve a dejar "sin inicializar" un arreglo abierto

Los tres puntos repiten el último valor hasta el final; solo se pueden usar en arreglos de tamaño fijo. Asignar un literal a un arreglo abierto lo dimensiona automáticamente.

Contornos irregulares

En SL una matriz es un vector de vectores, así que las filas pueden tener distinto largo:

M = { {1, 3, 13, 31},
      {7, 21, 5, 17, 19, 2},
      {},
      {71, 23} }

alen (M)      // 4 filas
alen (M[2])   // 6 elementos en la segunda fila

Asignación entre arreglos

M2 = M1        // copia completa, elemento por elemento
V1 = M1 [2]    // una fila de la matriz es un vector
V2 = V1

Para que dos arreglos sean asignables, los tipos de sus elementos tienen que ser compatibles y el destino debe tener la misma cantidad de elementos o ser abierto. La asignación copia los valores: después son independientes.

Registros

Agrupar varios datos en una sola variable.

Declaración y acceso

r : registro nombre : cadena edad, peso : numerico fecha_nac : registro dia, mes, año : numerico un registro adentro de otro r.nombre r.fecha_nac.dia Cada campo se toca con un punto, encadenando tantos como haga falta. A [2].nombre si es un vector de registros
Un registro es una ficha: varios datos con nombre en una sola variable. Se llega a cada campo con un punto, y un campo puede a su vez ser otro registro o un arreglo.
var
   r : registro
   {
      nombre : cadena
      edad, peso : numerico
      fecha_nac : registro
      {
         dia, mes, año : numerico
      }
      notas : vector [100] numerico
   }
inicio
   r.nombre = "Maria Gonzalez"
   r.edad = 15
   r.fecha_nac.dia = 23
   r.notas [2] = 98
fin

A las variables que contiene un registro se las llama campos y se acceden con un punto. Un registro necesita al menos un campo y no puede tener dos campos con el mismo nombre.

Literales y asignación entre registros

r = { "Carolina Gomez",     // campo nombre
      {12, 07, 1969},       // campo fecha_nac
      {87, 91, 99, 93} }    // campo notas

a = b   // copia todos los campos

Dos registros son asignables si tienen la misma cantidad de campos y cada campo coincide en características con el de la misma posición del otro. Los nombres de los campos no importan para esa comparación.

Arreglos de registros

var
   A : vector [*] registro
   {
      nombre : cadena
      cedula : numerico
      notas  : vector [*] numerico
   }
inicio
   dim (A, 25)
   A [3].cedula = 1234567
   A = { {"Mirta", 12781891, {78, 96, 100}},
         {"Jose",  14271843, {91, 68, 83}} }
fin

Para leer o imprimir un registro hay que hacerlo campo por campo: no se puede imprimir (r) directamente.

Tipos definidos por el programador

La sección tipos: nombres propios y alias.

Definir un tipo

tipos
   PRODUCTO : registro
   {
      codigo  : numerico
      descrip : cadena
      precio  : numerico
   }
   LISTA : vector [*] PRODUCTO
   TLineaTexto : cadena          // alias de un tipo existente

var
   monitor, teclado : PRODUCTO
   catalogo : LISTA
   primera_linea : TLineaTexto

Una vez definido, el nombre del tipo se puede usar en cualquier lugar donde SL espere un tipo de dato, incluidos los parámetros y el valor de retorno de las subrutinas. Un alias es intercambiable con el tipo original.

Operadores y expresiones

Aritméticos, relacionales, lógicos, concatenación y precedencia.

Operadores aritméticos

OperadorSignificadoEjemplo
+Sumaa = b + 10
-Restaa = b - 10
*Multiplicacióna = b * 10
/División (da decimales)1234 / 10 → 123.4; con int() se queda la parte entera
%Módulo: resto de la división. Ignora las partes decimales10 % 3 → 1
^Potenciación; el exponente puede ser fraccionario2 ^ 4 → 16; 2 ^ 0.5 → 1.41421
- +Cambio de signo / identidad (un solo operando)b = -a
Dividir por cero (con / o con %) corta la ejecución del programa.

Operadores relacionales

OperadorSignificado
<Menor que
>Mayor que
<=Menor o igual que (no vale =<)
>=Mayor o igual que (no vale =>)
==Igual que
<>Distinto de (no vale ><)

Se aplican a dos valores del mismo tipo simple y dan un resultado lógico. Con cadenas se comparan carácter por carácter según la tabla ASCII, de izquierda a derecha:

ComparaciónResultadoPor qué
"ABC" < "ACC"verdaderoLa B viene antes que la C
"a" <= "A"falsoLas minúsculas están después de las mayúsculas
"ABA" > "AB"verdaderoCoinciden, pero la primera tiene un carácter más
"Z" > ""verdaderoCualquier cadena es mayor que la vacía

Operadores lógicos

and (conjunción) y or (disyunción) son binarios; not (negación) es unario.

si ( a >= 1 and a <= 100 ) { ... }
ok = not (n == 0)

SLE2 admite además los símbolos al estilo C, que aparecen en los ejemplos del manual de 2004. Son exactamente equivalentes:

Forma con palabrasForma con símbolos
a and ba && b
a or ba || b
not a!a
a <> ba != b

Concatenación de cadenas

El mismo + concatena cuando los dos operandos son cadenas:

cad3 = cad1 + " " + cad2
apellido + ", " + nombre     // "Gonzalez, Marta"

No es conmutativa, y no se puede mezclar una cadena con un número: para eso están str() y val().

Precedencia de los operadores

De mayor a menor. Los de la misma línea se evalúan de izquierda a derecha:

  1. ^ (potenciación; se asocia a la derecha: 2^3^2 es 2^(3^2))
  2. - + unarios
  3. * / %
  4. + -
  5. == <> < <= > >=
  6. not
  7. and
  8. or

Por eso -2^2 vale −4 y (-2)^2 vale 4. Ante la duda, usá paréntesis: sobran sin costo y hacen el programa más legible.

Sentencias

Asignación, si, eval, mientras, repetir, desde, llamadas y retorna.

Asignación

a = 10.231
b = a + 1
hipotenusa = sqrt (a^2 + b^2)
v [3] = 0
r.nombre = "Ana"

Sentencia si

si cond sentencias no sí sigue mientras cond cuerpo sí sigue no puede no entrar nunca repetir … hasta cuerpo cond no sí sigue el cuerpo corre al menos una vez desde k = 1 hasta n paso p k = 1 k <= n cuerpo k = k + p el paso por omisión es 1; con paso negativo cuenta hacia atrás
Las cuatro formas de repetir y decidir. mientras pregunta antes (puede no entrar nunca) y repetir…hasta pregunta después (el cuerpo corre al menos una vez); desde es un mientras con el contador ya resuelto.
si ( condicion )
{
   sentencias...
sino
   sentencias...
}

Y la forma encadenada, que evita anidar:

si ( pnt >= 95 )
{
   n5 = n5 + 1
sino si ( pnt >= 85 )
   n4 = n4 + 1
sino si ( pnt < 60 )
   n1 = n1 + 1
sino
   otros = otros + 1
}
Lo más distinto de otros lenguajes: en SL el sino va dentro de las llaves, y las ramas sino si (...) no llevan llaves propias. La llave de cierre es una sola, al final de toda la cadena.

Sentencia eval

Equivale a un si encadenado largo, pero se lee mejor:

eval
{
   caso ( let >= 'A' and let <= 'Z' )
      msg = "letra mayuscula"
   caso ( let >= 'a' and let <= 'z' )
      msg = "letra minuscula"
   caso ( let >= '0' and let <= '9' )
      msg = "digito"
   sino
      msg = "algun otro"
}

Se evalúan los casos en orden y se ejecuta el primero que dé verdadero; después se sigue con la sentencia que está tras la llave de cierre. La cláusula sino es opcional y, si está, tiene que ir última.

Ciclo mientras

mientras ( condicion )
{
   sentencias...
}

Comprueba la condición antes de cada vuelta, así que el cuerpo puede no ejecutarse nunca. La condición va siempre entre paréntesis.

Ciclo repetir … hasta

repetir
   dig = num % 10
   imprimir ("\n", dig)
   num = int (num / 10)
hasta ( num == 0 )

Comprueba la condición al final, de modo que el cuerpo se ejecuta al menos una vez. Ojo: la condición es de fin, no de continuación.

Ciclo desde

desde variable = valor_inicial hasta valor_final [paso incremento]
{
   sentencias...
}

desde k=1 hasta 10          { imprimir ("\n", k, " : ", k^2) }
desde k=strlen (z) hasta 1 paso -1 { imprimir (z [k]) }
  • El valor inicial y el incremento se truncan a enteros; el incremento puede ser negativo.
  • El ciclo puede ejecutarse de 0 a n veces.
  • La variable de control tiene que ser numérica (puede ser un elemento de un arreglo).
  • Cambiar el valor final o el incremento adentro no altera la cantidad de vueltas: se calculan al entrar. Para salir antes, asignale a la variable de control el valor final.

Llamada a subrutinas y retorna

cls()
imprimir_explicacion()
calcular_suma (n)

retorna ( expresion )     // última sentencia de una función

Subrutinas y funciones

Procedimientos, funciones, parámetros por valor y por referencia, recursión.

Los dos tipos

POR VALOR — (n : numerico) el que llama a = 5 copia la subrutina n = 5 → 99 al volver, a sigue valiendo 5 la subrutina trabajó sobre una copia POR REFERENCIA — (ref n : numerico) el que llama a = 5 → 99 la misma casilla la subrutina n = 99 al volver, a vale 99 las dos ven la misma variable Los arreglos y registros grandes conviene pasarlos con ref: se evita copiarlos enteros.
Sin ref, la subrutina recibe una copia. Con ref, recibe la variable misma, así que lo que le haga adentro se ve afuera. Es la única forma de que un procedimiento devuelva más de un resultado.
  • Funciones: llevan retorna tipo en el encabezado, devuelven un valor y pueden usarse dentro de una expresión.
  • Procedimientos: no devuelven nada; se invocan como una sentencia.
subrutina entero (n : numerico) retorna numerico
var
   ent : numerico
inicio
   ent = 0
   mientras ( n >= 1 )
   {
      ent = ent + 1
      n = n - 1
   }
   retorna ( ent )
fin

Una función puede devolver cualquier tipo, incluidos arreglos y registros. No hace falta declarar prototipos: las subrutinas pueden aparecer en cualquier orden después del programa principal.

La palabra sub es un sinónimo de subrutina; el manual de 2004 la usa en todas sus definiciones:

sub entero (n : numerico) retorna numerico

Parámetros por valor y por referencia

subrutina mi_sub (a : numerico; ref b : numerico)
subrutina prt (v1, v2 : numerico; r : cadena)
subrutina intercambiar (ref primera, segunda : numerico)   // "ref" alcanza al grupo
  • Por valor (lo normal): la subrutina recibe una copia; los cambios no salen de la subrutina.
  • Por referencia (ref): recibe la variable en sí, así que los cambios se ven en quien la llamó. Es obligatorio pasar una variable, no una cuenta.
Si una subrutina tiene que llenar un arreglo o un registro, el parámetro debe ir con ref; si no, lo cargado se pierde al salir.

Arreglos abiertos como parámetros

subrutina impr_vect (v : vector [*] numerico)
var
   k : numerico
inicio
   desde k=1 hasta alen (v)
   {
      imprimir (v [k], " ")
   }
fin

impr_vect (A)                    // vector de tamaño fijo
impr_vect ({100, 200, 300})      // literal

Así se escriben subrutinas generales, que sirven para arreglos de cualquier tamaño.

Recursión

subrutina fact (n : numerico) retorna numerico
inicio
   si ( n <= 1 ) { retorna (1) }
   retorna ( n * fact (n - 1) )
fin

Como cada llamada tiene sus propias variables locales, la recursión funciona sin más. Acordate siempre del caso base.

Operaciones con cadenas

Longitud, acceso a caracteres, subcadenas y conversiones.

Acceso y modificación de caracteres

Una cadena se puede usar como si fuera un vector de caracteres, con índices desde 1:

dig = "0123456789"
desde k=strlen (dig) hasta 1 paso -1
{
   imprimir ("\n", dig [k])
}

z [k] = 'b'        // también se puede asignar
A diferencia de los vectores, pedir un carácter que no existe devuelve la cadena vacía y asignar a una posición inexistente se ignora: no hay error.

Funciones de cadena más usadas

strlen ("prueba")            // 6
substr ("ABCD", 2)           // "BCD"  (hasta el final)
substr ("ABC", 1, 1)         // "A"
substr ("ABCD", 5, 1)        // ""     (posición pasada del final)
pos ("hola mundo", "mundo")  // 6, o 0 si no aparece
strdup ("-", 5)              // "-----"
upper ("ñandu")              // "ÑANDU"
val ("123.4")                // 123.4   (0 si no es un número)
str (123.40451, 10, 3)       // "   123.405"
ord ("A")                    // 65
ascii (65)                   // "A"

Entrada y salida de datos

imprimir(), leer() y el separador de campos.

imprimir()

imprimir ("\nLa suma es ", suma)
imprimir (a, b*10, s + "algo")

Recibe cualquier cantidad de valores numéricos, de cadena o lógicos (estos últimos salen como TRUE o FALSE) y los muestra uno tras otro, sin separación automática. Los saltos de línea los ponés vos con \n.

leer()

ENTRADA DE DATOS Ana,17 3,5 hola leer (nombre, edad) una línea entera, partida por comas leer (a, b) a = 3 b = 5 leer (t) t = "hola" Cada leer() consume una línea completa, tenga los datos que tenga. Si la entrada se agota, ESLE2 te pide el dato por consola mientras el programa corre.
Una llamada a leer(), una línea. Los valores de esa línea se separan por comas (o por lo que digas con set_ifs()) y se reparten entre las variables en orden.
leer (n)
leer (a, b, c)
leer (v [k])
leer (c[k].nombre, c[k].nota)

Toma los datos del panel Entrada de datos. Cada llamada consume tantos campos como variables reciba; los campos de una misma línea se separan con el separador de campos, que por defecto es la coma. Con la entrada:

100,ejemplo de cadena

la llamada leer (n, s) deja n = 100 y s = "ejemplo de cadena". Si se agotan los datos, ESLE2 te los pide por consola; en la corrección automática de los ejercicios, en cambio, se produce un error.

Se pueden leer variables numéricas o de cadena, pero no lógicas.

Cambiar el separador de entrada

set_ifs ("#")
leer (n, s)      // ahora la entrada sería:  100#Perez, Juan
get_ifs ()       // devuelve el separador actual

El salto de línea siempre separa campos, además del carácter elegido. Dos casos útiles: set_ifs ("\n") hace que cada campo sea una línea entera, y set_ifs ("") hace que se lea carácter por carácter.

set_stdin() restaura el separador a la coma, así que si necesitás otro, llamá a set_ifs() después de set_stdin().

Leer e imprimir datos estructurados

Tanto leer() como imprimir() aceptan arreglos y registros enteros, no solo valores simples. Los recorren de principio a fin, campo por campo:

var
   A : vector [10] numerico
   r : registro { cedula : cadena  p1, p2 : numerico }
inicio
   leer (A)        // toma 10 valores de la entrada, uno por elemento
   leer (r)        // toma 3 valores: cedula, p1 y p2
   imprimir (A)    // 1,4,9,16,25,36,49,64,81,100
fin

Al imprimir, los valores se separan con el OFS (output field separator), que por defecto es la coma. Un arreglo abierto sin dimensionar se muestra como <nodim>.

Para leer un arreglo abierto primero hay que dimensionarlo con dim(): leer() necesita saber cuántos valores tomar.

Cambiar el separador de salida: set_ofs()

El parámetro de set_ofs() tiene dos partes: el primer carácter es el separador y todo lo que sigue es lo que se muestra cuando aparece un arreglo sin dimensionar. Por defecto es como haber escrito set_ofs (",<nodim>").

tipos
   Alumno : registro { cedula : cadena  notas : vector [*] numerico }
var
   lista : vector [3] Alumno
   k = 0
inicio
   lista = { {"1283912", {5, 4, 5}},
             {"1278217", {} },        // este alumno no tiene notas
             {"1938281", {4, 3, 2}} }
   set_ofs (" *Sin notas")            // separador = espacio
   desde k=1 hasta alen (lista)
   {
      imprimir (lista [k], "\n")
   }
fin

Imprime:

1283912 5 4 5
1278217 *Sin notas
1938281 4 3 2

Archivos de texto

Redirigir la entrada y la salida con set_stdin(), set_stdout() y eof().

Cómo funcionan en ESLE2

En el navegador no hay disco, así que ESLE2 mantiene los archivos en memoria. Se los ve y edita con el botón Archivos… de la barra de herramientas: ahí podés crear un archivo de datos a mano antes de ejecutar, y también leer lo que el programa escribió. Se pierden al recargar la página.

set_stdout(): escribir en un archivo

set_stdout (nombre_archivo)             // modo "wt": borra lo anterior
set_stdout (nombre_archivo, "at")       // modo "at": agrega al final
set_stdout ("")                         // vuelve a la pantalla

Mientras hay un archivo abierto, todo lo que imprima imprimir() va al archivo y no a la pantalla. Devuelve un valor lógico: falso si el archivo no se pudo abrir.

set_stdin() y eof(): leer un archivo

si ( not set_stdin ("datos.txt") )
{
   terminar ("No se pudo abrir datos.txt")
}
set_ifs ("\n")            // cada campo será una línea entera
leer (linea)
mientras ( not eof() )
{
   inc (num_linea)
   imprimir ("\n", num_linea, ": ", linea)
   leer (linea)
}

Leyendo de un archivo, leer() no produce error cuando se acaban los datos: simplemente eof() pasa a valer verdadero. Ese es el motivo del orden del ejemplo: se lee una vez antes del ciclo y otra al final de cada vuelta.

set_stdin ("") vuelve a tomar los datos del teclado (el panel Entrada de datos) y cierra el archivo.

Traer y llevar archivos de verdad

En el panel Archivos… del IDE, Subir… trae uno o varios .txt de tu computadora —quedan con el mismo nombre, así que set_stdin ("notas.txt") los encuentra— y Bajar guarda en tu disco el archivo elegido, incluso si lo escribió tu programa con set_stdout().

Los archivos viven en la memoria del navegador: lo que no bajes se pierde al recargar la página.

Pantalla, sonido y lienzo

set_color(), set_curpos(), get_scrsize(), beep(), readkey() y dibujar_pixel().

Colores

columna 1 columna 80 fila 1 fila 25 Menu principal 1. Cargar datos cursor: set_curpos (4, 3) get_scrsize (ref f, ref c) → f = 25 filas, c = 80 columnas set_color (14, 1) pinta el texto que sigue: amarillo sobre azul
La pantalla es una cuadrícula de 25 filas por 80 columnas. El cursor se mueve con set_curpos (fila, columna) —fila primero— y todo lo que se imprima después sale desde ahí, con los colores vigentes.
set_color (primer_plano, fondo)     // cambia los colores del texto que sigue
get_color (ref texto, ref fondo)    // deja los colores vigentes en dos variables

Los colores se identifican por un número. El 0 significa «no cambiar», así que se usan del 1 al 15:

1234567
azulverdecianrojomagentamarróngris claro
891011121314
gris oscuroazul claroverde clarocian clarorojo claromagenta claroamarillo

El 15 es blanco. get_color() recibe sus dos parámetros por referencia, así que hay que pasarle nombres de variables.

Como el 0 significa «no cambiar», los colores elegidos siguen vigentes hasta que se los cambie. Para volver a los colores normales de la pantalla, llamá a cls(): además de limpiarla, reinicia el color de texto y de fondo.

Cursor y tamaño de pantalla

set_curpos (linea, columna)          // 0 en un parámetro = dejar como está
get_curpos (ref linea, ref columna)  // dónde está el cursor
get_scrsize (ref lineas, ref columnas)   // tamaño de la pantalla (25 x 80)
cls()                                // limpia la pantalla

La esquina superior izquierda es la posición (1, 1). Volver a una posición guardada sirve, por ejemplo, para redibujar una barra de progreso siempre en el mismo lugar:

imprimir ("\nProgreso: ")
get_curpos (lin, col)
desde k=1 hasta 20
{
   set_curpos (lin, col)
   imprimir (strdup ("#", k), strdup (".", 20-k), " ", str (k*5, 3, 0), "%")
}
Cuando la salida está redirigida a un archivo, cls(), set_color() y set_curpos() no tienen ningún efecto, y get_curpos() devuelve ceros.

Sonido y teclado

beep (frecuencia, duracion_en_milisegundos)   // por defecto (500, 100)
readkey (milisegundos)                        // espera una tecla y devuelve su código

beep() además pausa el programa el tiempo indicado, así que beep (0, 500) es una pausa de medio segundo sin sonido. readkey() sin parámetro espera indefinidamente; con parámetro espera ese tiempo y devuelve 0 si no se pulsó nada. Para que reciba las teclas, hacé clic en la pantalla de salida.

Dibujar en el lienzo

El SLE original tenía unas pocas órdenes para dibujar en pantalla; con las mismas ideas —un punto, una línea, un rectángulo, un círculo, todos de un color— alcanza para armar un Snake o un Pong en pseudocódigo. El panel Lienzo aparece solo, debajo de la Pantalla, la primera vez que el programa dibuja algo.

dibujar_pixel (x, y, color)                    // un punto; color es opcional
dibujar_linea (x1, y1, x2, y2, color)          // una línea recta
dibujar_rectangulo (x, y, ancho, alto, color)  // relleno
dibujar_circulo (x, y, radio, color)           // relleno
limpiar_lienzo (color)                         // borra todo; color opcional
lienzo_ancho ()  /  lienzo_alto ()             // 320 y 200

Los colores son los mismos 1 a 15 de set_color(). Como en dibujar_pixel() el color casi siempre es el mismo dentro de un dibujo, es opcional (por defecto 15, blanco); en limpiar_lienzo() es 0 (negro).

Una pelotita que rebota, como para empezar:

var
   x, y, dx, dy : numerico
inicio
   x = 160  y = 100  dx = 2  dy = 1
   mientras (TRUE)
   {
      limpiar_lienzo ()
      dibujar_circulo (x, y, 6, 12)
      x = x + dx
      y = y + dy
      si (x < 6 or x > 314) { dx = -dx }
      si (y < 6 or y > 194) { dy = -dy }
      beep (0, 30)                    // el "beep" de pausa marca el ritmo de cada cuadro
   }
fin
No hay una orden para "leer una tecla sin esperar": usá readkey (ms) con un tiempo corto —por ejemplo readkey (30)— adentro del mientras, en vez de beep(), para que el juego siga moviéndose mientras espera que jueguen.

Subrutinas y funciones predefinidas

Referencia completa de lo que trae el lenguaje.

Entrada y salida

SubrutinaQué hace
imprimir (v1, v2, …)Muestra los valores en la salida (pantalla o archivo). Acepta valores simples, arreglos y registros.
leer (v1, v2, …)Lee valores y los asigna a las variables. También acepta arreglos y registros enteros.
cls ()Limpia la pantalla de salida.
set_ifs (c) / get_ifs ()Separador de campos de leer(). "" = carácter por carácter.
set_ofs (c) / get_ofs ()Separador con que imprimir() muestra los datos estructurados, más la marca de arreglo sin dimensionar.
eof ()Verdadero cuando ya no quedan datos por leer.

Archivos

SubrutinaQué hace
set_stdin (nombre)De dónde lee leer(). "" vuelve al teclado. Devuelve falso si no se pudo abrir. Restaura el separador a la coma.
set_stdout (nombre, modo)A dónde escribe imprimir(). Modo "wt" (por defecto) borra el contenido previo; "at" agrega al final. "" vuelve a la pantalla.

Pantalla y teclado

SubrutinaQué hace
set_color (texto, fondo)Cambia los colores (1 a 15; 0 = no cambiar).
get_color (ref texto, ref fondo)Deja los colores vigentes en dos variables.
set_curpos (linea, col)Mueve el cursor; 0 conserva la coordenada.
get_curpos (ref linea, ref col)Posición actual del cursor.
get_scrsize (ref lineas, ref cols)Tamaño de la pantalla.
beep (frecuencia, ms)Pitido y pausa. Por defecto (500, 100).
readkey (ms)Espera una tecla y devuelve su código; 0 si se agotó el tiempo.

Lienzo

SubrutinaQué hace
dibujar_pixel (x, y, color)Pinta un punto. color es opcional (15, blanco, por defecto).
dibujar_linea (x1, y1, x2, y2, color)Una línea recta entre dos puntos.
dibujar_rectangulo (x, y, ancho, alto, color)Un rectángulo relleno.
dibujar_circulo (x, y, radio, color)Un círculo relleno.
limpiar_lienzo (color)Borra el lienzo entero. color es opcional (0, negro, por defecto).
lienzo_ancho () / lienzo_alto ()El tamaño del lienzo: 320 × 200 píxeles.

Los colores son los mismos 1 a 15 de set_color(). El panel Lienzo aparece solo la primera vez que el programa dibuja algo.

Arreglos y control

SubrutinaQué hace
dim (a, t1, t2, …)Dimensiona un arreglo abierto. Solo se dan los tamaños de las dimensiones abiertas.
alen (a)Cantidad de elementos (0 si es abierto y no fue inicializado).
intercambiar (a, b) / swap (a, b)Intercambia dos variables del mismo tipo: simples, arreglos o registros.
terminar (mensaje)Imprime el mensaje (opcional) y termina el programa. El control nunca vuelve.

Funciones matemáticas

FunciónQué devuelve
abs (n)Valor absoluto.
int (n)Parte entera: int (3.45) → 3.
sqrt (n)Raíz cuadrada.
exp (n)e elevado a n.
log (n)Logaritmo en base 10.
sin (g), cos (g), tan (g), arctan (g)Trigonometría; el ángulo va en radianes.
random (tope, semilla)Entero al azar entre 0 y tope − 1. La semilla es opcional y conviene omitirla: SL inicializa el generador solo al arrancar el programa (ESLE2 la acepta por compatibilidad pero no la usa).
inc (n, a) / dec (n, a)Suma o resta a (por defecto 1) a la variable n —la recibe por referencia— y devuelve el nuevo valor.

Funciones de cadena y conversión

FunciónQué devuelve
strlen (s)Cantidad de caracteres.
substr (s, inicio, cant)Subcadena; si se omite cant, va hasta el final.
pos (s1, s2, ini)Posición de s2 dentro de s1, o 0.
strdup (s, cant)La cadena repetida cant veces.
upper (s) / lower (s)En mayúsculas / minúsculas.
ascii (n)El carácter cuyo código ASCII es n.
ord (c)El código ASCII del primer carácter de c.
val (s)El valor numérico de la cadena; 0 si no se puede convertir.
str (n, ancho, dec, relleno)El número como cadena con dec decimales (2 por defecto), completado a la izquierda hasta ancho con relleno (un espacio por defecto).
n = 123.40451
str (n)              // "123.40"
str (n, 10)          // "    123.40"
str (n, 10, 3)       // "   123.405"   (redondeado)
str (n, 0, 0)        // "123"
str (n, 10, 0, '*')  // "*******123"

Otras

FunciónQué devuelve
ifval (cond, e1, e2)e1 si la condición es verdadera y e2 si es falsa. Es una expresión condicional: solo evalúa la rama que corresponde. Las dos expresiones tienen que ser del mismo tipo simple.
max (a, b) / min (a, b)El mayor / el menor de dos valores simples del mismo tipo. La cadena vacía es menor que cualquier otra.
paramval (k) / pcount ()El k-ésimo argumento del programa (siempre una cadena) y cuántos hay. En ESLE2 se cargan en el campo Argumentos.
sec ()Segundos transcurridos desde el 1 de enero de 1970. Sirve para medir cuánto tarda una parte del programa.
runcmd (cmd)Ejecutaría un programa externo. En el navegador no existe: siempre devuelve 127.
mem ()Memoria disponible (valor simbólico en la versión web).
// ifval() protege de un índice fuera de rango sin escribir un si:
retorna ifval (num_dia > 0 and num_dia < 8, nom_dias [num_dia], "MAL")

Errores frecuentes y cómo evitarlos

Qué significa cada mensaje de ESLE2 y qué hacer con él.

Cómo lee el IDE los errores

Cuando algo falla, ESLE2 muestra un recuadro con tres partes: el tipo de error y la línea, la línea de código señalada, y una recomendación concreta. Además marca la línea en el editor. Los errores de compilación aparecen antes de ejecutar (sintaxis); los de ejecución, mientras el programa corre.

El botón Revisar agrega un tercer nivel: avisos, que no impiden ejecutar pero suelen anticipar el problema (variables sin usar, un ciclo cuya condición nunca cambia, una palabra reservada escrita con mayúsculas…).

Errores de compilación

MensajeCausa habitualSolución
la palabra "sino" está fuera de lugarSe cerró la llave del si antes del sino, como en C o Pascal.El sino va dentro de las llaves; la llave de cierre es una sola, al final.
apareció "=" dentro de una condiciónSe escribió si ( a = b ).Para comparar se usa ==; el = solo asigna.
el programa termina antes de tiempo: falta …Falta un fin o una llave de cierre.Verificá que cada inicio tenga su fin y cada { su }.
"Si" no se reconoce como palabra reservadaPalabra reservada escrita con mayúsculas.Todas las palabras reservadas van en minúsculas.
no se puede usar la letra acentuada "…"Un identificador con tilde, o un texto sin comillas.Sacá la tilde del nombre, o poné el texto entre comillas.
el operador "&" solo, no existe en SLSe escribió un solo & o un solo |.Los operadores lógicos son and / && y or / ||: van dobles.
constante de cadena sin cerrarFalta una comilla, o el texto ocupa dos líneas.Cerrá la comilla; para partir el texto, concatená con +.
sentencia no válida / sentencia incompletaFalta el = de la asignación o los paréntesis de la llamada.Revisá la línea señalada: toda sentencia es una asignación, una llamada o una estructura de control.

Errores de ejecución

MensajeCausa habitualSolución
identificador no declarado: "x"Falta declarar la variable, o está escrita distinto (SL distingue mayúsculas).Declarala en var. ESLE2 te sugiere el nombre parecido más cercano.
no hay concordancia de tiposSe mezcló una cadena con un número.Convertí con val (s) o con str (n).
índice fuera de rangoSe usó el índice 0, o se pasó del último elemento.Los índices van de 1 a alen (v). Revisá los límites del ciclo.
el arreglo abierto todavía no fue inicializadoSe usó un vector [*] sin darle tamaño.Llamá antes a dim (v, n) o asignale un literal.
división por ceroEl divisor terminó valiendo 0.Verificá el divisor antes de dividir.
no hay más datos en la entrada para leer()El programa lee más veces de las que hay datos.Agregá líneas en Entrada de datos o controlá con eof().
el programa ejecutó demasiadas instruccionesUn ciclo que no termina.Dentro del ciclo tiene que cambiar alguna variable de la condición.
la función "f" terminó sin ejecutar "retorna"Hay un camino que no retorna nada.Asegurate de que todos los caminos ejecuten retorna ( … ).
demasiadas llamadas anidadasRecursión sin caso base.Agregá la condición que corta las llamadas.
no se puede leer un arreglo abierto sin dimensionarSe pasó un vector [*] entero a leer() sin darle tamaño.Llamá antes a dim (v, n): leer() necesita saber cuántos valores tomar.
leer() no admite variables lógicasSe intentó leer (ok) con ok : logico.Leé un número o una cadena y convertilo: ok = (resp == "s").
«…» recibe sus parámetros por referenciaA get_color(), get_curpos(), get_scrsize() o intercambiar() se les pasó una cuenta o un valor fijo.Pasales nombres de variables, no expresiones.
no se pueden intercambiar … y …Las dos variables de intercambiar() son de tipos distintos.Tienen que coincidir en tipo (dos números, dos vectores del mismo tipo, etc.).
max() / min() compara dos valores simples del mismo tipoSe les pasó un arreglo, un registro, o dos tipos distintos.Compará valores simples: dos números, dos cadenas o dos lógicos.
imprimir() no puede mostrar este valorSe quiso imprimir algo que no es número, cadena, lógico, arreglo ni registro.Revisá qué le estás pasando a imprimir().

Recomendaciones para escribir sin errores

  • Declará todo lo que vayas a usar y respetá mayúsculas y minúsculas.
  • Escribí el esqueleto completo (inicio … fin, llaves) antes de llenarlo: así no te faltan cierres.
  • Indentá tres espacios por nivel; con las llaves alineadas los errores saltan a la vista.
  • Antes de dividir o de indexar, preguntate si el valor puede ser 0 o pasarse del rango.
  • En cada ciclo, mirá qué variable cambia para que la condición llegue a ser falsa.
  • Probá con casos límite: 0, un solo elemento, la cadena vacía, un número negativo.
  • Usá el botón Revisar antes de ejecutar; casi todos los avisos son bugs en potencia.

Sugerencias de estilo

Revisar también avisa de cosas que andan igual pero se pueden escribir mejor. Aparecen aparte de los errores, en azul, y nunca impiden ejecutar:

SugerenciaEn vez deConviene
Comparar con TRUE o FALSEsi ( listo == TRUE )si ( listo )
Un si que solo guarda un lógicosi (n % 2 == 0) { par = TRUE sino par = FALSE }par = ( n % 2 == 0 )
Variable que se escribe y no se leeresto = a % b y nunca se usausarla, o sacar la línea
Condición que no depende de nadasi ( 2 > 1 )una condición con variables
Bloque vacíosi ( n > 0 ) { }completarlo o sacarlo
Línea inalcanzablealgo después de retornamoverlo antes
Cambiar la variable del desde adentrodesde k=1 hasta 10 { k = k + 1 }mientras, que sí la maneja el programa
El mismo número grande repetido365 tres vecesconst DIAS = 365
Una letra sola para un texto o una fichat = "Ana"nombre = "Ana"

Están pensadas para no molestar: las 50 soluciones del curso pasan sin una sola sugerencia.

Diferencias con el SLE2 de escritorio

Qué cambia respecto del programa original para Windows y Linux.

Lo que cambia

  • Archivos: set_stdin() y set_stdout() funcionan, pero sobre archivos guardados en la memoria del navegador (botón Archivos…). No se tocan archivos de tu computadora.
  • Argumentos: paramval() y pcount() leen el campo Argumentos de la barra de herramientas, no una línea de comandos.
  • Pantalla: get_scrsize() informa siempre 25 × 80, como el SLE original, aunque el panel del navegador se adapte a tu ventana.
  • runcmd() no puede ejecutar programas externos: devuelve 127.
  • mem() devuelve un valor simbólico.

Lo que no está

  • El depurador paso a paso con puntos de parada y visor de expresiones.
  • Las cláusulas lib, libext y archivo, reservadas en el compilador original pero no documentadas.

Lo que se agregó

  • Recomendaciones y detección de errores frecuentes (botón Revisar).
  • Corte automático de programas que no terminan, y botón Detener.
  • Curso con corrección automática y progreso guardado.

Nota fina: el ejemplo de precedencias de la página 41 del manual imprime valores que no se corresponden con su propio código fuente. ESLE2 respeta la tabla de precedencias, que sí es coherente.

Enlaces y fuentes

De dónde sale todo esto.