Listas en Scratch 3: colecciones, recorrido y gestión de datos

¿Qué es una lista en Scratch?

Una lista es una colección ordenada de datos. A diferencia de una variable (que guarda un solo valor), una lista guarda muchos elementos en un orden específico: el elemento 1, el elemento 2, el elemento 3, etc. En Scratch 3, las listas pueden pertenecer a un objeto (solo ese sprite las usa) o al escenario (compartidas).

Piensa en una lista como una fila numerada: cada casilla tiene un número (índice) y un contenido (elemento). Ese orden importa: “espada, poción, llave” no es lo mismo que “llave, espada, poción”.

Bloques esenciales de listas (gestión de datos)

Los bloques de listas están en la categoría Datos cuando creas una lista. Los más usados para gestionar elementos son:

• añadir (cosa) a [Lista]: agrega al final.
• insertar (cosa) en (i) de [Lista]: coloca en una posición y desplaza el resto.
• borrar (i) de [Lista] y borrar todos de [Lista]: elimina elementos.
• reemplazar elemento (i) de [Lista] por (cosa): cambia el contenido sin alterar el tamaño.
• elemento (i) de [Lista]: lee el valor en una posición.
• longitud de [Lista]: cuántos elementos hay.
• [Lista] contiene (cosa)?: comprueba si existe un valor en la lista.

Índices: cómo se numeran los elementos

En Scratch, los índices de una lista empiezan en 1, no en 0. Si la lista tiene 5 elementos, los índices válidos son 1, 2, 3, 4 y 5.

Leer elemento (2) de [Inventario] devuelve “Poción”.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

Errores comunes con índices (y cómo evitarlos)

• Índice fuera de rango: ocurre cuando intentas leer, borrar o reemplazar un índice menor que 1 o mayor que la longitud. Ejemplo: si la lista tiene longitud 3, pedir el elemento 4 es un error lógico.
• Lista vacía: si la longitud es 0, no existe ningún índice válido. Cualquier intento de leer elemento (1) fallará.

Patrón de seguridad recomendado antes de leer o borrar:

si <(longitud de [Lista]) > (0)> entonces  leer o borrar  si no  manejar caso vacío

Y antes de usar un índice variable (por ejemplo i):

si <(i) >= (1) y (i) <= (longitud de [Lista])> entonces  usar elemento (i)

Operaciones típicas: agregar, insertar, borrar, reemplazar y leer

Agregar (al final)

Útil cuando el orden es “por llegada”: historial, cola de mensajes, registro de puntos.

añadir (puntos) a [HistorialPuntos]

Insertar (en una posición)

Útil cuando quieres priorizar algo o mantener un orden específico. Por ejemplo, insertar un objeto “urgente” al inicio:

insertar ("Llave maestra") en (1) de [Inventario]

Borrar (uno o todos)

Para eliminar un elemento consumido o reiniciar el estado:

borrar (1) de [Inventario]  // elimina el primer objeto

borrar todos de [Inventario]  // reinicia inventario

Reemplazar (editar sin cambiar tamaño)

Útil para actualizar un registro: cambiar el nombre de un nivel, corregir una palabra, actualizar un valor.

reemplazar elemento (3) de [Palabras] por ("dragón")

Leer (consultar un elemento)

Para mostrar un mensaje, comparar, o construir resultados:

decir (elemento (i) de [Dialogos])

Usos conceptuales de listas (ideas de diseño)

Inventario

Lista de objetos recogidos. Acciones típicas: añadir al recoger, borrar al usar, comprobar si contiene un objeto.

si <[Inventario] contiene ("Llave")?> entonces  abrir puerta

Historial de puntuaciones

Al finalizar una partida, añade la puntuación a una lista. Luego puedes buscar el máximo o contar cuántas partidas superaron cierto valor.

Palabras para un juego (adivinar, ordenar, completar)

Lista de palabras posibles. Puedes elegir una al azar usando un índice aleatorio entre 1 y la longitud.

fijar [i v] a (número aleatorio entre (1) y (longitud de [Palabras]))  fijar [palabraActual v] a (elemento (i) de [Palabras])

Secuencias de pasos

Una lista puede guardar instrucciones: “arriba, arriba, izquierda, espacio”. Esto permite que el juego compare lo que hace el jugador con una secuencia esperada o que un personaje ejecute una coreografía.

Patrones de recorrido: procesar elementos con bucles

Recorrer una lista significa visitar sus elementos en orden (del 1 al último) para procesarlos. En Scratch, el patrón típico usa un índice i que va aumentando.

Recorrido básico (leer todos los elementos)

fijar [i v] a (1)  repetir (longitud de [Lista])  decir (elemento (i) de [Lista])  cambiar [i v] por (1)

Este patrón es la base para buscar, contar y filtrar.

Buscar: encontrar la posición de un valor

Objetivo: localizar el índice de un elemento (por ejemplo, “Poción”). Si no está, devolver 0 o un mensaje.

fijar [objetivo v] a ("Poción")  fijar [posicion v] a (0)  fijar [i v] a (1)  repetir (longitud de [Inventario])  si <(elemento (i) de [Inventario]) = (objetivo)> entonces  fijar [posicion v] a (i)  fijar [i v] a ((longitud de [Inventario]) + (1))  // salida rápida  si no  cambiar [i v] por (1)

La “salida rápida” se logra forzando el índice a pasar del final. Es un truco útil cuando quieres detener el recorrido al encontrar lo buscado.

Contar: cuántas veces aparece algo

Ejemplo: contar cuántas veces aparece “moneda” en una lista de recompensas.

fijar [contador v] a (0)  fijar [i v] a (1)  repetir (longitud de [Recompensas])  si <(elemento (i) de [Recompensas]) = ("moneda")> entonces  cambiar [contador v] por (1)  cambiar [i v] por (1)

Filtrar: construir una nueva lista con elementos que cumplen una regla

Filtrar significa crear una lista “resultado” con solo los elementos que te interesan. Ejemplo: quedarte con puntuaciones mayores o iguales a 100.

borrar todos de [PuntosAltos]  fijar [i v] a (1)  repetir (longitud de [HistorialPuntos])  si <(elemento (i) de [HistorialPuntos]) >= (100)> entonces  añadir (elemento (i) de [HistorialPuntos]) a [PuntosAltos]  cambiar [i v] por (1)

Este patrón (recorrer + condición + añadir a otra lista) es una herramienta general para “limpiar” datos o preparar información para mostrar.

Ejercicio guiado: lista para controlar diálogos (y niveles)

Vas a crear un sistema donde un personaje muestra un diálogo paso a paso usando una lista. Luego lo extenderás para controlar niveles con otra lista. Este ejercicio entrena: lectura por índice, control de límites, lista vacía y recorrido secuencial.

Parte A: Diálogos con una lista

Objetivo: al presionar una tecla, el personaje dice la siguiente frase de la lista. Cuando llega al final, reinicia.

Paso 1: Crear la lista y llenarla

• Crea una lista llamada Dialogos (para todos los objetos o solo para el sprite, según tu diseño).
• Añade manualmente 5 frases, por ejemplo: “Hola”, “Necesito tu ayuda”, “Busca la llave”, “Evita al guardia”, “¡Buen trabajo!”.

Paso 2: Crear el índice del diálogo

Crea una variable indiceDialogo. Este índice apunta a qué elemento se mostrará.

Paso 3: Inicialización segura

Al iniciar, asegúrate de que el índice sea válido incluso si la lista está vacía.

al presionar bandera verde  fijar [indiceDialogo v] a (1)

Opcional (recomendado si la lista puede estar vacía):

al presionar bandera verde  fijar [indiceDialogo v] a (1)  si <(longitud de [Dialogos]) = (0)> entonces  añadir ("(sin diálogos)") a [Dialogos]

Paso 4: Mostrar el siguiente diálogo con una tecla

Usa una tecla (por ejemplo, espacio) para avanzar. Incluye control de rango para no pasarte del final.

al presionar tecla [espacio v]  si <(longitud de [Dialogos]) = (0)> entonces  decir ("No hay diálogos")  si no  decir (elemento (indiceDialogo) de [Dialogos])  cambiar [indiceDialogo v] por (1)  si <(indiceDialogo) > (longitud de [Dialogos])> entonces  fijar [indiceDialogo v] a (1)

Qué estás practicando aquí: leer por índice, evitar lista vacía, y reiniciar cuando el índice supera la longitud.

Paso 5 (mejora): Insertar y reemplazar diálogos en tiempo real

Prueba estas acciones durante el juego para ver cómo cambia el comportamiento:

• Insertar una frase urgente al inicio: insertar ("¡Cuidado!") en (1) de [Dialogos]
• Reemplazar la frase 2 por otra: reemplazar elemento (2) de [Dialogos] por ("He cambiado de plan")
• Borrar una frase específica por índice (si sabes cuál es): borrar (3) de [Dialogos]

Parte B: Usar una lista para controlar niveles

Objetivo: tener una lista con nombres de niveles y avanzar al siguiente nivel con una tecla. Cada nivel puede cambiar el fondo, la velocidad o el objetivo.

Paso 1: Crear la lista de niveles

• Crea una lista llamada Niveles.
• Agrega elementos como: “Bosque”, “Cueva”, “Castillo”.

Paso 2: Variable de nivel actual

Crea una variable nivelActual (será un índice dentro de la lista).

al presionar bandera verde  fijar [nivelActual v] a (1)

Paso 3: Bloque de “cargar nivel” usando el elemento de la lista

Scratch no tiene funciones como tal, pero puedes simularlo con un mensaje (broadcast) o con un bloque de “Mis bloques” si lo estás usando. Aquí lo haremos con una estructura simple: al cambiar el nivel, lees el nombre del nivel desde la lista y actúas según ese nombre.

definir cargarNivel  fijar [nombreNivel v] a (elemento (nivelActual) de [Niveles])  si <(nombreNivel) = ("Bosque")> entonces  cambiar fondo a [Bosque v]  si <(nombreNivel) = ("Cueva")> entonces  cambiar fondo a [Cueva v]  si <(nombreNivel) = ("Castillo")> entonces  cambiar fondo a [Castillo v]

Si no quieres depender de nombres, también puedes usar el índice directamente (nivel 1, 2, 3) y decidir por número.

Paso 4: Avanzar de nivel con control de límites

al presionar tecla [n v]  si <(longitud de [Niveles]) = (0)> entonces  decir ("No hay niveles")  si no  cambiar [nivelActual v] por (1)  si <(nivelActual) > (longitud de [Niveles])> entonces  fijar [nivelActual v] a (1)  cargarNivel

Paso 5 (reto opcional): Filtrar niveles desbloqueados

Crea una lista NivelesDesbloqueados y filtra desde Niveles según una regla (por ejemplo, solo los primeros k niveles). Luego usa NivelesDesbloqueados para avanzar. Este reto refuerza el patrón de filtrar construyendo una lista resultado.