Bloques como “reglas” que la computadora puede ejecutar
En Scratch, un programa (guion) es una lista de bloques conectados. Cada bloque representa una pieza de lógica que la computadora puede ejecutar sin ambigüedad. Para pensar de forma lógica, conviene clasificar lo que ves en tres niveles: instrucciones (hacer), condiciones (decidir) y estructuras (organizar el orden y la repetición).
| Tipo | Qué significa | Cómo se reconoce en Scratch | Ejemplo de bloque |
|---|---|---|---|
| Instrucción (acción) | Orden directa: “haz esto” | Bloques que cambian algo (movimiento, apariencia, sonido, variables) | mover (10) pasos, decir [Hola] por (2) segundos |
| Condición (decisión) | Pregunta con respuesta Sí/No | Bloques con forma hexagonal (booleanos) o comparaciones | <tocando [borde]?>, <(x) > (100)> |
| Estructura (organización) | Define el flujo: cuándo, cuántas veces, bajo qué regla | Bloques de Control que “envuelven” otros bloques | si <...> entonces, por siempre, repetir (10) |
Marco conceptual: acción, decisión y repetición
Acción: un bloque que cambia el estado del proyecto. Por ejemplo, mover un sprite, cambiar un disfraz, sumar a una variable o reproducir un sonido. Si lo ejecutas dos veces, normalmente verás dos cambios.
Decisión: una condición no “hace” algo por sí sola; evalúa si una regla se cumple. En Scratch, las condiciones suelen aparecer dentro de estructuras como si o repetir hasta. La condición es la pregunta; la estructura decide qué hacer con la respuesta.
Repetición: no es una acción aislada, sino una forma de ejecutar acciones muchas veces. La repetición vive en estructuras como por siempre o repetir (n). La lógica aquí es: “mientras se cumpla esta regla, vuelve a ejecutar”.
Diferencia práctica: instrucciones, condiciones y estructuras
Una forma útil de no confundirse es pensar en “qué puede ir dentro de qué”:
- Escuche el audio con la pantalla apagada.
- Obtenga un certificado al finalizar.
- ¡Más de 5000 cursos para que explores!
Descargar la aplicación
- Una instrucción suele poder colocarse sola en un guion (por ejemplo, debajo de
al presionar bandera verde). - Una condición casi siempre necesita una estructura que la use (por ejemplo, dentro de
si). - Una estructura es un contenedor: define el orden y contiene instrucciones (y a veces otras estructuras).
Ejemplo mínimo para ver los roles:
al presionar bandera verde (estructura de inicio/evento) si <tocando [mouse-pointer]?> entonces (estructura de decisión) decir [¡Hola!] por (1) segundos (instrucción/acción)Leer un guion como una frase: sujeto implícito, verbo y conectores
Un guion de Scratch se puede “leer” como una oración. Esto mejora la legibilidad y te ayuda a detectar errores lógicos.
- Sujeto implícito: el sprite o el escenario donde está el guion. No se escribe, pero siempre existe: “El gato…” o “El escenario…”.
- Verbo: el bloque de acción principal: mover, decir, cambiar, reproducir, sumar, etc.
- Conectores: bloques de Control y condiciones que unen ideas: “si… entonces…”, “repetir…”, “por siempre…”, “esperar…”.
Ejemplo de lectura:
[Sprite: Gato] al presionar bandera verde por siempre si <tecla [derecha] presionada?> entonces cambiar x por (5)Lectura como frase: “El Gato, al iniciar, por siempre, si se presiona la tecla derecha, cambia su x en 5.”
Guía práctica paso a paso: convertir una idea en guion legible
Objetivo: “Cuando toque el borde, rebotar y avisar una vez”.
Define el sujeto: elige el sprite que se moverá (por ejemplo, una pelota). Todo el guion pertenece a ese sujeto.
Elige el evento de inicio: por ejemplo
al presionar bandera verde.Escribe el verbo principal (acción repetida): si la pelota se mueve todo el tiempo, esa acción va dentro de una repetición:
por siempre+mover ( ) pasos.Agrega el conector de decisión: usa
si <tocando [borde]?> entoncespara detectar el borde.Dentro del “si”, coloca acciones claras:
rebotar si toca un bordey luego el aviso.Evita avisos infinitos: si el sprite se queda tocando el borde, el “si” se cumple muchas veces. Para avisar una sola vez, añade una regla extra (por ejemplo, una variable de control).
Versión legible con variable yaAvisé (0/1):
al presionar bandera verde fijar [yaAvisé v] a (0) por siempre mover (6) pasos si <tocando [borde]?> entonces rebotar si toca un borde si <(yaAvisé) = (0)> entonces decir [¡Rebote!] por (1) segundos fijar [yaAvisé v] a (1)Lectura como frase: “La Pelota inicia, pone yaAvisé en 0, por siempre se mueve; si toca el borde, rebota; y si todavía no avisó, dice ‘Rebote’ y marca que ya avisó.”
Mismo objetivo, distinta claridad: buenas prácticas de legibilidad
La computadora ejecuta ambas soluciones si están bien construidas, pero una persona entiende mejor la que expresa la intención. La legibilidad es parte del pensamiento lógico: hace visibles las reglas.
Ejemplo 1: “Moverse con flechas” (misma función, distinta claridad)
Menos claro (repite lógica y mezcla ideas):
al presionar bandera verde por siempre si <tecla [derecha] presionada?> entonces cambiar x por (5) si <tecla [izquierda] presionada?> entonces cambiar x por (-5) si <tecla [arriba] presionada?> entonces cambiar y por (5) si <tecla [abajo] presionada?> entonces cambiar y por (-5)Más claro (misma idea, agrupada por intención):
al presionar bandera verde por siempre si <tecla [derecha] presionada?> entonces cambiar x por (5) si <tecla [izquierda] presionada?> entonces cambiar x por (-5) si <tecla [arriba] presionada?> entonces cambiar y por (5) si <tecla [abajo] presionada?> entonces cambiar y por (-5)La diferencia parece pequeña, pero la indentación (bloques “dentro” de otros) hace visible la estructura: por siempre contiene cuatro decisiones, y cada decisión contiene una acción.
Ejemplo 2: “Contar hasta 10” (estructura primero, acciones después)
Menos claro (no se ve la regla de repetición):
al presionar bandera verde fijar [i v] a (1) decir (i) por (0.2) segundos cambiar [i v] por (1) decir (i) por (0.2) segundos cambiar [i v] por (1) decir (i) por (0.2) segundos cambiar [i v] por (1)Más claro (la repetición expresa la regla):
al presionar bandera verde fijar [i v] a (1) repetir (10) decir (i) por (0.2) segundos cambiar [i v] por (1)Aquí se lee como frase: “Inicia i en 1; repite 10 veces: di i y luego suma 1”. La estructura repetir (10) hace explícita la regla.
Ejemplo 3: “Si pasa algo, entonces…” (condición separada de la acción)
Menos claro (condición difícil de leer):
al presionar bandera verde por siempre si <<(x posición) > (100)> y <tocando [mouse-pointer]?>> entonces cambiar tamaño por (10)Más claro (misma lógica, intención más visible con pasos intermedios):
al presionar bandera verde por siempre fijar [enZona v] a <(x posición) > (100)> fijar [tocandoMouse v] a <tocando [mouse-pointer]?> si <<enZona> y <tocandoMouse>> entonces cambiar tamaño por (10)Separar condiciones en variables (o al menos en bloques más simples) ayuda a “leer” la decisión. La computadora no lo necesita, pero tú sí cuando depuras o amplías el proyecto.
Checklist rápido de legibilidad lógica (para revisar tus guiones)
- ¿Se ve el sujeto? (¿está el guion en el sprite correcto?)
- ¿Se ve el verbo? (¿la acción principal está clara y no enterrada entre detalles?)
- ¿Se ven los conectores? (¿las estructuras de control muestran el orden: si, repetir, por siempre?)
- ¿Cada “si” responde una pregunta simple? (si no, divide la condición)
- ¿La repetición tiene sentido? (¿lo que está dentro de
por siemprerealmente debe repetirse?) - ¿Evitas duplicar bloques? (si copias y pegas mucho, probablemente falta una estructura)
