Elementos bsicos de

programacin en Scratch

Tabla de contenido
Introduccin ......................................................................................................................................... 2
Procesamiento de bloques en Scratch ............................................................................................... 2
Estructuras de Control ......................................................................................................................... 5
Repeticiones ................................................................................................................................... 5
Decisiones ....................................................................................................................................... 8
Definicin y uso de variables............................................................................................................... 9
Operadores ................................................................................................................................... 10
Definicin de nuevos bloques. .......................................................................................................... 11

Elaborado por Pedro Hepp para el Ministerio de Educacin de Chile.

Costadigital. Pontificia Universidad Catlica de Valparaso.
Julio 2017
Scratch is developed by the Lifelong Kindergarten Group at the MIT Media Lab. See http://scratch.mit.edu
Scratch es desarrollado por Lifelong Kindergarten Group del Media Lab en el MIT. Ver http://scratch.mit.edu

1
Introduccin
En este documento se presentan las ideas bsicas de programacin con estructuras de
control para repetir y tomar decisiones en Scratch. Adicionalmente, se describe como tra-
bajar con variables y como definir nuevos bloques.
Un programa en Scratch se compone de diversos algoritmos, que son secuencias de ins-
trucciones o bloques que actan sobre datos. En este documento usaremos principalmente
el concepto de algoritmo para referirnos a la programacin en Scratch.
El documento propone algunos desafos o ejercicios para profundizar los conceptos.

Procesamiento de bloques en Scratch

El lenguaje de programacin Scratch es un lenguaje con el que se programa en bloques.
Los bloques son instrucciones que ejecutan una accin.
En un algoritmo, los bloques se ejecutan secuencialmente, de arriba hacia abajo, a menos
que se incorporen estructuras de control para repetir bloques o bien bloques de decisin
para cambiar el curso secuencial de las acciones.

En el siguiente algoritmo hay 3 bloques, lo que se ejecutan secuencialmente en el siguiente

orden:
1. el bloque al presionar es un bloque de eventos, lo que significa que ese bloque
se ejecuta cuando ocurre un evento, en este caso, el usuario hace clic sobre la
banderita verde o sobre el el bloque.
2. A continuacin, est el bloque mover 100 pasos: en este caso, el objeto (el gato,
por defecto) avanza 100 pasos en la direccin en que se encuentra.
3. Finalmente, se ejecuta el bloque girar 90 grados, que indica que el objeto (el gato
en este caso) gire 90 grados en direccin de las mancillas del reloj.

Algoritmo con 3 bloques que se ejecutan secuencialmente

2
El primer bloque de evento al presionar tiene un rol importante al encabezar un algoritmo,
pues como se ver ms adelante, se pueden tener varios objetos (no solo el gato), cada
uno de ellos con su propio algoritmo. De esta forma se pueden tener objetos interactuando
simultneamente en el programa, cada uno ejecutando su propio algoritmo.
En este caso, es ms propio usar el trmino programa como un conjunto de algoritmos
que se procesan coordinadamente.

Para activar todos los algoritmos al mismo tiempo en un programa, se usa la bandera verde

en el borde en el borde superior derecho del escenario:

Ejercicio: pruebe armando diversos algoritmos con los bloques del men Mo-
vimiento y Lpiz de Scratch y observe su efecto en el escenario.

Ejemplo: definimos un escenario con dos objetos, en este ejemplo 2 pelotas, cada uno con
un algoritmo similar:

Escenario con 2 objetos independientes cada uno con su propio algoritmo

Los algoritmos asociados a los Objetos 1 (pelota 1) y Objeto 2 (pelota 2) son idnticos en
este ejemplo:

3
 Algoritmo asociado a cada objeto pelota.

Al hacer clic sobre el bloque de evento al presionar en el algoritmo de alguno de estos

objetos, solo ese objeto (esa pelota) comenzar a avanzar y rebotar. Sin embargo, al apre-
tar la bandera verde del borde superior derecho del escenario, ambas pelotas comenzarn
a avanzar y rebotar al mismo tiempo.

De esta manera se pueden definir programas muy sofisticados que implementen juegos
interactivos e interaccin entre personajes. Por ejemplo, definir objetos con forma de per-
sona y asociarle algoritmos de movimiento y de mensajes a cada uno. Scratch facilita esta
programacin, permitiendo que los objetos se puedan comunicar entre si y cambiar de
forma a travs de disfraces. As, por ejemplo, se puede programar a una persona cami-
nando, si el objeto tiene varios disfraces con distintas posiciones de las manos y los pies,
que se van alternando sucesivamente.

Ejercicio: repita el ejemplo de las dos pelotas, agregando una 3 pelota y mo-
difique los bloques de cada una para observar un comportamiento diferente
de cada una. Pruebe activar el algoritmo de cada una independientemente (ha-
ciendo clic sobre el bloque al presionar de su algoritmo) y todos juntos (ha-
ciendo clic en la bandera verde sobre el escenario).

4
Estructuras de Control
Hemos visto que un algoritmo se procesa secuencialmente de arriba hacia abajo, un bloque
tras otro. Podemos alterar este procesamiento introduciendo estructuras de control, que
adems de enriquecer la programacin, ayudan a simplificar los programas.

Veremos algunas estructuras de control simples y tiles.

Repeticiones
La repeticin es una estructura de control que permite repetir un conjunto de bloques las
veces que deseemos. Hay dos estructuras de repeticin bsicas:

Repite las instrucciones que contiene Repite las instrucciones que contiene
Un nmero determinado de veces Hasta que el programa sea detenido
(10 veces en este caso)

Por ejemplo, si deseamos dibujar un cuadrado, podemos hacerlo con un conjunto de

bloques como los siguientes. En ambos casos, el efecto es el mismo.

5
Dibujo de un cuadrado con secuencia Dibujo con estructura de repeticin.
De bloques

Ejercicio: pruebe dibujar un tringulo y un hexgono usando la estructura de

repeticin 3 y 6 veces respetivamente.

En el diseo de algoritmos siempre es conveniente identificar oportunidades de usar es-

tructuras de control, ya que adems de simplificar un algoritmo, tambin lo hace ms fcil
de comprender por otras personas, y por lo tanto de modificar y corregir si fuese necesario.

En el caso de la estructura de repeticin por siempre: resulta til si

queremos que el algoritmo repita el conjunto de bloques un nmero indefinido de veces o

6
hasta que el programa sea detenido externamente, con el botn en el borde superior

derecho del escenario, o bien con el bloque de control detener

Ejemplos de uso de la estructura por siempre son juegos interactivos, programas en que
queremos que se verifique una condicin cada cierto tiempo (por ejemplo, verificar el valor
de un sensor) y luego tomar acciones al respecto.

Por cierto, es posible anidar estructuras de repeticin, es decir, incorporar una repeticin
dentro de otra.
El siguiente ejemplo realiza esta anidacin, generando hexgonos dentro de un hexgono.

7
 Ejercicio: pruebe dibujar anidando varias estructuras de repeticin y observe
su efecto en el escenario. Note que conviene comenzar el algoritmo borrando
el escenario. Para observar ms lentamente como dibuja un algoritmo, puede

introducir el bloque de control al interior de las re-

peticiones.

Decisiones
Normalmente se deben tomar decisiones al interior de un algoritmo, por ejemplo, ejecutar
una cierta accin solo si se ha cumplido una determinada condicin o alterar el curso de
accin ante un evento. Para estas ocasiones estn las estructuras de control de decisiones.

Ejecuta las acciones al interior de la estructura solo si se cumple la

condicin sealada.

Ejemplo: nuestro escenario es el espacio, con un planeta y una nave espacial que deambula
por el espacio. Al tocar la nave espacial al planeta, el programa se detiene (esta es la deci-
sin que se toma):

8
 Ejercicio: replique este ejemplo, modificando las condiciones para que la nave
espacial se detenga.

Una variante muy til de la toma de decisiones es tener opciones ante un evento. Es decir,
si se cumple una condicin, entonces se ejecuta un conjunto de bloques y en caso contrario,
si no se cumple, se ejecuta otro conjunto de bloques. Para eso est la siguiente estructura
de control:

Definicin y uso de variables

Las variables son objetos que guardan un valor y este valor puede ser modificado en el
transcurso de un programa. Las variables son muy utilizadas en programacin para alma-
cenar valores sobre los que queremos tomar decisiones.

Para definir una variable, utilizamos el men Datos de Scratch y usamos el bloque Crear
una variable:

Al crear una variable, se le debe colocar un nombre, que, en este ejemplo, llamaremos
Alfa:

9
 :

Scratch reconoce esta variable y permite asignarle valores y modificarlos. Por ejemplo:

A continuacin, veremos el uso de variables en combinacin con operadores, para tomar

decisiones.

Operadores
Normalmente las decisiones se combinan con operadores y variables. En el men Opera-
dores de Scratch se encuentran los operadores disponibles.

Supongamos que tenemos una variable denominada Alfa que almacena un valor que se
va modificando con el tiempo (por ejemplo: la posicin de un objeto en el escenario). Que-
remos tomar una decisin si el valor de Alfa es mayor que 100 (ejemplo: queremos mover
el objeto). Para ello, utilizamos el siguiente operador:

Y le incorporamos el nombre de la variable y el valor 100:

10
As, la estructura de decisin queda de la siguiente manera:

Definicin de nuevos bloques

Otra caracterstica interesante de Scratch es la posibilidad de asignarle un nombre a un

conjunto de bloques y usar ese nombre cada vez que se desee usar ese conjunto de blo-
ques.

Por ejemplo: muchas veces queremos que un programa comience con un objeto en cierta
posicin inicial, con el escenario limpio y apuntando en cierta direccin. Podemos definir el
bloque Inicio asocindole los bloques iniciales y luego usar Inicio cada vez que se re-
quiera. De este modo, el programa queda ms corto y ms claro de entender.

Para definir nuevos bloques se utiliza el bloque Crear un bloque del men Ms Bloques:
Por ejemplo, definimos el bloque Inicio y le asociamos una serie bloques:

11
Luego, podemos usar el nuevo bloque inicio:

Al igual que otros bloques de Scratch, los nuevos bloques pueden tener parmetros de
entrada, es decir, su ejecucin depende del valor del parmetro. Por ejemplo, si queremos
crear un bloque para crear cuadrados de diferentes tamaos, podemos definir un bloque
Cuadrado y darle como parmetro el largo del lado:

Y definimos el nuevo bloque Cuadrado con los siguientes bloques:

12
Ahora podemos dibujar cuadrados de distintos tamaos con este nuevo bloque:

Ejercicio: pruebe crear nuevos bloques (por ejemplo, que hagan un dibujo de-
terminado) y luego use ess nuevo bloque para repetir los dibujos.

13