Expresiones, Literales y Listas

En esta sección, exploraremos los bloques básicos de construcción de valores en pixelWallE: los literales, cómo se combinan para formar expresiones y cómo organizar colecciones de datos usando listas.

Literales

Los literales son valores fijos que aparecen directamente en tu código. Son la forma más simple de expresión, ya que se evalúan a sí mismos.

  • Números: Representan valores numéricos enteros.

    10
-5
3
0

  • Cadenas de Texto: Representan secuencias de caracteres, usualmente usadas para nombres de colores, códigos Hex, o mensajes.

    "red"
"#FF0000"
"MiEtiqueta"
"Hello PixelWallE"

  • Booleanos: Representan valores de verdad: verdadero o falso.

    true
false

  • Listas: Representan una colección ordenada de elementos del mismo tipo base.

    List< int > [1, 2, 3] 
    
List < string > ["red", "blue", "green"] 
    
List< bool > [] // Lista vacía

  • Llamadas a Funciones: Aunque son operaciones, el *resultado* de una función es un valor que puede ser tratado como un literal dentro de una expresión.

    GetActualX() // Esto devuelve un número

    IsBrushColor("blue") // Esto devuelve un booleano

    Consulta la sección de Funciones para más detalles.

Expresiones

Las expresiones son combinaciones de literales, variables, operadores y llamadas a funciones que se evalúan para producir un valor. Este valor puede ser un número, una cadena de texto, un booleano o una lista.

Expresiones Unarias

Operan sobre un único operando.

  • Negación Numérica (`-`): Cambia el signo de un número.

    -10
-(5 + 3) // Evalúa la expresión entre paréntesis primero

  • Negación Lógica (`!`): Invierte un valor booleano.

    !true // Se evalúa a false 
    
!IsBrushColor("black") // Si IsBrushColor("black") devuelve true, esto evalúa a false

Expresiones Binarias

Operan sobre dos operandos y un operador.

Operadores Aritméticos:

  • `+` (Suma)
  • `-` (Resta)
  • `*` (Multiplicación)
  • `**` (Potencia)
  • `%` (Módulo - resto de la división)
  • `/` (División)
10 + 5          # Se evalúa a 15
GetActualY() * 2 # Multiplica la posición Y actual por 2
(GetActualX() + 1) / 2 # Suma 1 al resultado de GetActualX, luego divide por 2
4 ** 2          # Se evalúa a 16
10 % 3          # Se evalúa a 1

La suma (`+`) también puede ser utilizada para concatenar cadenas de texto.

"Pixel" + "WallE" # Se evalúa a "PixelWallE"
"Tamaño: " + GetCanvasSize() #Concatena texto y número (conversión automática)

Operadores Lógicos y de Comparación:

  • `<` (Menor que)
  • `<=` (Menor o igual que)
  • `>` (Mayor que)
  • `>=` (Mayor o igual que)
  • `==` (Igual a)
  • `!=` (Distinto de)
  • `&&` (AND lógico)
  • `||` (OR lógico)
GetActualX() > 100             # ¿Es la posición X mayor que 100? (Booleano)
IsColor("#00FF00", 5, 5) == true # ¿El píxel en (5,5) es verde? (Booleano)
true && (GetCanvasSize() > 50) # ¿Verdadero Y el lienzo es mayor de 50? (Booleano)
"red" != "blue"                # ¿"red" es distinto de "blue"? (true)

Agrupación con Paréntesis

Los paréntesis `()` se usan para controlar el orden de evaluación de las expresiones, asegurando que ciertas partes se calculen antes que otras. Esto es fundamental para la claridad y la lógica de tus cálculos.

(5 + 3) * 2 # La suma (8) se hace antes que la multiplicación (8 * 2 = 16)
5 + (3 * 2) # La multiplicación (6) se hace antes que la suma (5 + 6 = 11)

Listas

Las listas son colecciones ordenadas y mutables de elementos del mismo tipo base (números, cadenas de texto o booleanos). Son útiles para almacenar y manipular conjuntos de datos, como una secuencia de colores o coordenadas.

Declaración e Inicialización

Se declaran usando la palabra clave List, seguida del tipo base de los elementos entre <> y un nombre identificador (el nombre de tu lista). Se pueden inicializar al mismo tiempo con un literal de lista.

 myNumbers <- List< int >[1, 5, 10, 20]; # Declara e inicializa una lista de enteros
colors <- List< string > ["red", "green", "blue", "#FF0000"]; # Declara e inicializa una lista de cadenas
 emptyList <- List< bool > []; # Declara e inicializa una lista de booleanos vacía

Una vez declarada, puedes asignar una nueva lista del mismo tipo.

myNumbers <- [100, 200]; # Reemplaza el contenido de myNumbers

Acceso a Elementos

Se accede a los elementos individuales por su índice (posición) dentro de la lista, usando corchetes [] después del nombre de la lista. Los índices en pixelWallE, como en muchos lenguajes, comienzan desde 0 para el primer elemento.

firstNumber = myNumbers[0]; # firstNumber ahora vale 1 (o 100 si se reasignó antes)
secondColor = colors[1]; # secondColor ahora vale "green"
lastColor = colors[colors.Length - 1]; # Accede al último elemento usando Length

Nota: Intentar acceder a un índice que no existe en la lista (un índice negativo o un índice mayor o igual que la longitud de la lista) generará un error de ejecución.

Métodos de Lista

Las listas tienen métodos integrados (funciones asociadas a la lista) para manipular sus elementos. Se llaman usando un punto . después del nombre de la lista, seguido del nombre del método y paréntesis () si el método requiere argumentos.

  • Add(item): Añade el item especificado al final de la lista. El tipo del item debe coincidir con el tipo base de la lista.

    myNumbers.Add(25); # myNumbers se convierte en [..., 25]
colors.Add("yellow"); # colors se convierte en [..., "yellow"]

  • RemoveAt(index): Elimina el elemento en el index especificado. El índice debe ser un número válido dentro del rango de la lista.

    myNumbers.RemoveAt(1); # Elimina el segundo elemento

    Nota: Eliminar un índice fuera de rango generará un error de ejecución.

  • Clear(): Elimina todos los elementos de la lista, dejándola vacía.

    colors.Clear(); # colors ahora es una lista vacía []

  • Length: (Es una propiedad, no un método, por lo que no lleva `()`) Devuelve el número de elementos en la lista como un número entero.

    numColors = colors.Length; # numColors contendrá el número actual de elementos en colors

    Se usa comúnmente para iterar sobre la lista o para verificar si está vacía.