GOBSTONES
Poner()
Sacar()
Mover()
program{ }
procedure NombreMayusculas(){ }
procedure Poner3Rojas() {
Poner(Rojo)
Poner(Rojo)
Poner(Rojo)
}
program {
Poner3Rojas()
}
Llegó el momento de programar desde cero. ¡No te
preocupes! Como recién estamos empezando, repasemos lo
que aprendimos.
A esta altura ya sabemos que para programar siempre
tenemos que tener en cuenta la sintaxis y que para definir
nuevos procedimientos también tenemos reglas:
empezamos con la palabra reservada procedure;
elegimos un nombre que lo describa y lo escribimos con
mayúscula seguido de paréntesis ();
encerramos las acciones que queremos que haga entre
llaves {}.
Entonces, un procedimiento que se mueve cuatro celdas al
Norte se va a definir así:
procedure Mover4AlNorte() {
Mover(Norte)
Mover(Norte)
Mover(Norte)
Mover(Norte)
}
Y si lo queremos utilizar, tenemos que invocarlo dentro
del program escribiendo su nombre tal cual y sin olvidar los
paréntesis() ¡Prestá atención a la sintaxis!
program {
Mover4AlNorte()
}
Resumiendo, en lo que a un procedimiento respecta, se
pueden distinguir dos momentos:
la definición, que es cuando ponemos procedure
Poner3Verdes() y el bloque de código que especifica qué
hace.
el uso o invocación, que es cuando
escribimos Poner3Verdes() en alguna parte
de program (o de otro procedimiento).
Algo MUY importante es que un procedimiento se
define una sola vez y luego se puede usar todas las
veces que necesitemos, como cualquier otro
comando.
Por eso, su nombre debe ser único dentro de todo el
programa. Recordá que la computadora no hace más
que seguir órdenes y si existiera más de un
procedimiento con el mismo nombre, no sabría cuál
elegir.
Repasemos:
Para definir un procedimiento nuevo usamos procedure y
le ponemos un nombre que describa lo que hace seguido
por paréntesis (). A continuación y entre llaves {} lo que
querramos que haga.
Los procedimientos se definen una sola vez. Si ya están
definidos en la Biblioteca o en alguna parte del código no
hay que volver a hacerlo (no se pueden repetir los
nombres, si se define un procedimiento más de una vez
nuestro programa va a fallar).
Para invocar un procedimiento escribimos su nombre (sin
olvidar los paréntesis() al final). ¡Y podemos hacerlo
todas las veces que sean necesarias!
Aunque también se escribe entre llaves {},
el program nunca lleva nombre ni paréntesis.
Cuando creamos procedimientos agrupamos varias acciones
en una tarea que podemos reconocer y nombrar. Eso hace
nuestros programas más claros, legibles y nos ahorra
repeticiones innecesarias.
Ya vimos que un procedimiento puede ser invocado tantas
veces como queramos dentro de un programa , pero como su
objetivo es agrupar los pasos de una tarea para usarla cuando
haga falta, también lo podemos invocar dentro de otros
procedimientos. ¡Vamos a probarlo!
Definí el procedimiento Poner9Rojas que,
utilizando Poner3Rojas, ponga nueve bolitas rojas en una
celda. Una vez definido, invocá el nuevo procedimiento en
un program.
1
procedure Poner9Rojas(){
2
Poner3Rojas()
3
Poner3Rojas()
4
Poner3Rojas()
5
}
6
program{
7
Poner9Rojas()
8
}
Bueno, ya sabemos cómo crear procedimientos, pero ¿por qué
querríamos hacerlos?
Algunas posibles respuestas:
para simplificar código, escribiendo una sola vez y en
un solo lugar cosas que vamos a hacer muchas veces;
para escribir menos, por qué querríamos hacer cosas
de más;
para que el propósito de nuestro programa sea más
entendible para los humanos, como vimos en el
ejemplo de DibujarCuadradoNegroDeLado3. Para esto es
fundamental pensar buenos nombres, que no sean
muy largos
(DibujarCuadradoNegroDeLado3FormadoPor9BolistasDeA
rribaAAbajo), ni demasiado cortos (DibCuaNeg), y sobre
todo que dejen en claro qué hace nuestro
procedimiento;
para comunicar la estrategia que pensamos para
resolver nuestro problema;
y como consecuencia de todo esto: para poder escribir
programas más poderosos.
procedure DibujarDosPuntas(){
DibujarPuntaNegra()
Mover(Este)
Mover(Norte)
Mover(Norte)
DibujarPuntaNegra()
}
program{
DibujarDosPuntas()
}
Para resolver este problema lo que hicimos fue separarlo en
partes, identificando las tareas más pequeñas que ya
teníamos resueltas.
Los procedimientos son muy útiles para esto, se ocupan de
resolver una subtarea y nos permiten repetirla o combinarla
para solucionar un problema mayor que la incluya.
Ya vimos que los comandos que vienen definidos por el
lenguaje se llaman primitivas. Hay una primitiva que no
usaste hasta ahora que queremos presentarte.
Imaginate que no sabés ni dónde está el cabezal ni qué
tamaño tiene el tablero pero querés llegar a una esquina: La
primitiva Mover no te va a ser de mucha ayuda.
Por suerte existe una primitiva llamada IrAlBorde, que toma
una dirección, y se mueve todo lo que pueda en esa
dirección, hasta llegar al borde.
¿Cómo? Mirá el resultado del siguiente programa:
program {
IrAlBorde(Este)
}
Para resolver un problema nos conviene comprender bien de
qué se trata para elegir una estrategia. Es el momento de
empezar a hacerlo aprovechando los procedimientos.
Uno de los objetivos al usar procedimientos es identificar y
nombrar las subtareas que conforman un problema y
combinar sus soluciones para poder resolverlo. Veamos un
ejemplo:
Queremos decorar con guirnaldas las dos esquinas superiores
de cualquier tablero como muestra la imagen.
Pensemos una estrategia distinguiendo subtareas:
Cada guirnalda se compone de 3 bolitas rojas y 3 bolitas
verdes. Ya resolvimos cómo hacerlo en otros ejercicios , hacer
una guirnalda solo requerirá combinar esas soluciones. Y
ponerla donde corresponda, claro.
¿Y que más? el procedimiento que decore el tablero debería
poder aprovechar la creación de una guirnalda para usarla
varias veces en las posiciones que querramos decorar. Nos
vendría muy bien alguna primitiva que nos ayude a llegar a
los bordes.
¡Manos a la obra!
Definí dos procedimientos: el
procedimiento PonerGuirnalda que coloque 3 bolitas rojas y 3
bolitas verdes en una celda y el
procedimiento DecorarTablero que lo utilice y ponga una
guirnalda en cada esquina superior. Invocá DecorarTablero en
el program. Tené en cuenta que no sabemos la posición inicial
donde se encontrará el cabezal.
¡Dame una pista!
procedure PonerGuirnalda(){
2
Poner3Verdes()
3
Poner3Rojas()
4
5
}
6
procedure DecorarTablero(){
7
IrAlBorde(Este)
8
IrAlBorde(Norte)
9
PonerGuirnalda()
10
IrAlBorde(Oeste)
11
PonerGuirnalda()
12
}
13
program{
14
DecorarTablero()
15
}
procedure DibujarLineaColorida() {
PonerCeldaColorida()
Mover(Este)
PonerCeldaColorida()
Mover(Este)
PonerCeldaColorida()
Mover(Este)
PonerCeldaColorida()
IrAlBorde(Oeste)
}
procedure PonerCeldaColorida() {
Poner(Verde)
Poner(Rojo)
Poner(Negro)
Poner(Azul)
}
procedure DibujarCuadradoColorido() {
DibujarLineaColorida()
Mover(Norte)
DibujarLineaColorida()
Mover(Norte)
DibujarLineaColorida()
Mover(Norte)
DibujarLineaColorida()
IrAlBorde(Sur)
}
program{
DibujarCuadradoColorido()
}
podemos escribir expresiones aritméticas (o sea, cuentas
matemáticas) en los mismos lugares donde hasta ahora
veníamos escribiendo números.
procedure PonerSuma(x,y){
PonerN(x+y,Rojo)
}
nroBolitas(color). Lo que hace es simple: nos retorna la
cantidad de bolitas de un color determinado en la posición
actual.
Si partimos de este tablero inicial:
Y luego ejecutamos Mover(siguiente(Norte)) el tablero
obtenido será así:
Porque siguiente(Norte) es Este. Si luego
ejecutamos Mover(previo(Oeste)) lograremos el siguiente
tablero:
Porque previo(Oeste) es Sur
hayBolitas(color), que recibe un color y retorna True o False.
Otra que trae True o False (y que vas a tener que usar ahora)
es puedeMover(direccion)
son un caso particular de las expresiones, y por lo tanto
siguen las mismas reglas que ellas: se escriben con
la primera letra minúscula y siempre denotan algún valor
(en este caso, un número);
en la última línea de su definición siempre va un return,
seguido de una expresión entre paréntesis: el valor que la
función va a retornar.
JAVASCRIPT
unciones matemáticas es apenitas diferente de lo que veníamos
haciendo hasta ahora: hay que prefijarlas con Math.. Por ejemplo, la
función que nos sirve para redondear un número es [Link]:
function cuantoSaleAproximadamente(precio, impuestos) {
return [Link](precio * impuestos);
}
Ahora miremos a los booleanos con un poco más de detalle:
Se pueden negar, mediante el operador !: !hayComida
Se puede hacer la conjunción lógica entre dos booleanos
(and, también conocido en español como y lógico), mediante
el operador &&: hayComida && hayBebida
Se puede hacer la disyunción lógica entre dos booleanos (or,
también conocido en español como o lógico), mediante el
operador ||: unaExpresion || otraExpresion
function gritar(texto){
return convertirEnMayuscula("¡"+texto+"!");
function cuidadoSegun(dia) {
if (dia === "lunes") {
return "fertilizar";
} else if (dia === "viernes") {
return "fumigar";
} else {
return "regar";
}
}
