We're back with our program
that uses a function
to draw Winston four times.
And I've changed it
to actually show what age he is
at each point of life,
and you'll see why soon.
But first I need to tell you
something about Winston:
Winston has an addiction to donuts.
He eats three of them a day.
It's probably why his face
is so big and yellow.
So to warn Winston about
how bad donuts are for him,
I wanna modify this program
to show how many donuts
he's eaten total
at each point in his life.
For example, when he's two years old,
that means he's
eaten 3 times 365 times 2,
so three in a day,
times 365 days, times 2 years.
And we'll just display that
underneath that header, so wow!
Two thousand donuts, that
is a lot of donuts for a two-year-old.
Now when he's 14 years old, let's see,
he's had 3 times 365 times 14
And that is 15,000 donuts. All right.
So I could keep doing this math,
but I'm beginning to notice a pattern.
I'm repeating my calculation here,
and I'm just changing one thing about it:
the number of years.
Whenever I see repeated code like this,
I think to myself, "Hmm,
can I make that into a function?"
Yeah, definitely, we can.
So let's do that now.
I'll define my function up here
and call it calcTotalDonuts = function
And it's going to take one parameter,
the number of years,
because that's the only thing
that we're changing
each time we do this calculation.
And then inside, we'll do the calculation,
and save it into a variable,
so it'll be 3 times 365 times numYears.
All right, so now that we
have that function,
I'm going to replace this expression here
with calcTotalDonuts,
the call to the function,
and passing in "2".
Okay, um, well now we
don't see any total at all.
Hmm, okay, what happened?
Well, our function
did calculate the total, here,
but it didn't tell anybody
about that total.
It's like if a teacher calls on you
in class to answer a question
and you answer it in your head
but you're too shy to say the answer.
You've done the work, but your teacher's
never gonna know about it.
If we want the function
to communicate a value
to whoever called it, the function
has to explicitly return the value.
So for a function to return a value,
we need to type return,
and then whatever it wants to return.
Maybe it's a variable
or a value or an expression,
so here we'll say
return totalDonuts, okay?
So whoever's calling that function's
going to get this response.
And now our value displays, yay!
And actually we
can shorten our function,
we don't even have to
store it into a variable,
we can just take
this whole expression here
put it in the return,
and then it's just a one-liner. Nice.
All right, so now we can go through
and calculate the total donuts
at each point in life
by just calling this function
and passing in the number of years.
Um, let's see, it's calcTotalDonuts(25),
position is correctly, calcTotalDonuts(65)
Okay! Wow, so if he makes it to 65,
he will eat 70,000 donuts.
That is a lot of donuts.
I don't think Winston's
gonna make it. (laugh)
But now that we've
made it into a function,
it's really easy for us
to change parts of it.
Like if Winston sees this and says,
"Whoa, whoa, that's a lot.
What if I just ate one a day?"
Okay, well we can just go here,
change this one number,
and see everything change.
So that's 23,000. Still a lot.
So maybe Winston's like,
"All right, all right, what if
I just had one a week?"
Yeah, that's reasonable, okay.
So then we could just change 365 to 50,
because there's like
50 weeks in a year, right?
Okay, that's a lot better, right?
3,000 donuts, that seems reasonable.
All right, so if you see,
with functions and return values,
we can save code and save lives.
Tak jsme zpátky s naším programem.
Ten používá funkci k
malování čtyř Winstonů.
Změnila jsem ho trošku.
Nyní ukazuje skutečný věk
v určitém bodě života.
Brzy uvidíte proč.
Nejdříve Vám musím něco
říct o Winstonovi.
Winston má závislost na koblihách.
Jí je 3x denně.
Pravděpodobně díky tomu je jeho
obličej tak velký a žlutý.
Jak varovat Winstona,
že jsou pro něj koblihy špatné?
Musíme tento program trochu upravit.
A to tak, aby ukázal kolik
koblih snědl v každém bodě jeho života.
Například, když mu byly dva roky,
což znamená, že jich snědl 3x365x2.
Zobrazíme si to pod tímto nadpisem.
Dva tisíce koblih, to je hodně koblih
za dva roky.
Nyní mu je 14 let, podívejme,
3 krát 365 krát 14.
Správně, to je 15 000 koblih.
Mohli bychom nadále takto počítat,
ale všimněte si určitého vzoru.
Opakuji stále můj výpočet a jedinou věc,
kterou měním je počet let.
Kdykoliv vidím opakující se kód,
jako je tento.
Pomyslím si,
"Hm, mohu z toho udělat funkci?"
Ano určitě můžeme.
Tak pojďme na to.
Definuji zde moji funkci.
Nazvu ji calcTotalDonuts = function.
Dáme jí jeden parametr a to
počet let.
Je to totiž jediná věc, jenž
měníme.
A to pokaždé, když děláme tento výpočet.
Uvnitř provedeme výpočet.
Tento výpočet uložíme do proměnné,
takže to bude 3x 365x numYears.
Správně, nyní máme funkci.
Nahradím zde tento výraz
výrazem calcTotalDonuts s parametrem 2.
Dobře, nyní nevidíme žádný celkový počet.
Co se stalo?
Naše funkce zde spočítala celkový počet.
Problém je, že o tom nikomu neřekla.
Je to jako, když se Vás učitelka
na něco zeptá.
A odpověď je u Vás v hlavě.
Prostě se stydíte odpovědět.
Odpověděli jste, ale Vaše učitelka
se o tom nikdy nedozví.
Pokud má funkce něco vracet, tak
musí mít definovanou návratovou hodnotu.
K definování této hodnoty
stačí napsat return a to co chceme ukázat.
Může to být proměnná nebo
hodnota nějakého výrazu.
Pro náš příklad budeme vracet
totalDonuts.
Tedy kdokoliv zavolá tuto funkci,
dostane tuto odpověď.
Nyní se již naše hodnota zobrazuje.
Můžeme naší funkci zkrátit.
Nemusíme ji ukládat
do proměnné.
Celý výraz vložíme do return.
Nyní je to na jednom řádku.
Dále spočítáme celkový počet
koblih.
Uděláme to pomocí zavolání této
funkce s počtem let.
Podívejte, je to calcTotalDonuts(25),
poté calcTotalDonuts(65).
Tedy pokud by mu bylo 65 let,
tak by snědl 70 000 koblih a to je dost.
Nemyslím si, že by toho byl
Winston schopen.
Nyní je to funkce a
je snadné měnit její části.
Například kdyby to viděl
Winston a řekl:
"Páni, to je až moc.
Co kdybych jedl jednu denně?"
Dobře, stačí změnit pouze jedno číslo.
Tím se vše změní.
Výsledek je 23 000. Stále dost.
Možná by Winston řekl:
"Dobře, dobře, tak co kdybych jedl
jen jednu týdně?"
Ano, to je již rozumné.
Stačí jen změnit 365 na 50,
protože rok má 50 týdnů.
Je to lepší? 3000 koblih se zdá již jako
rozumné množství.
Takže jak vidíte s funkcemi a návratovými
hodnotami můžeme zachránit kód a životy.
Aquí estamos, con un programa que usa una
función para dibujar a Winston 4 veces.
Y lo he modificado para mostrar su edad
en cada momento, pronto verás por qué.
Pero antes, necesito decirte algo sobre
Winston: tiene una adicción a los dónuts.
Toma tres cada día. Por eso probablemente
su cara es tan grande y amarilla.
Así, para decirle a Winston lo malos que son
para él, quiero modificar este programa para
mostrar el total de dónuts en cada momento.
Por ejemplo, si tiene dos años, esto supone que
ha comido tres veces 365 por dos, es decir,
tres cada día, 365 veces, durante dos años.
Lo mostraremos bajo la cabecera. Vaya! Dos
mil dónuts, que es un montón para 2 años.
Así, cuando tenga 14 años, veamos, habrá
tomado 3 veces 365 por 14.
Eso hace 15 mil dónuts. Bien. Puedo seguir
calculando, pero intuyo una estructura.
Estoy repitiendo mis cálculos y sólo
cambio una cosa: el número de años.
Siempre que veo repetirse código así,
pienso si podré convertirlo en una función.
Sí. por supuesto, es posible. Así que,
hagámoslo ahora.
Definiré aquí mi función y la llamaré
calcTotalDonuts igual a function.
Va a tener un parámetro, el número de años,
que es lo único que cambiaremos cada vez.
Y ahora dentro, hacemos el cálculo y lo
guardamos en una variable. que será tres veces
365 por el número de años.
Bien, ahora que tenemos la función, voy a
reemplazar esta expresión por calcTotalDonuts (la
llamada a la función) con el parámetro "2".
Bien, pero ahora no vemos ningún resultado.
¿Qué ha ocurrido? Vale, nuestra función calculó
el total, pero no le pasó el dato a nadie.
Es como si un profesor te pregunta y sabes
la respuesta, pero eres tan tímido que no la dices.
Has hecho el trabajo, pero tu profesor
nunca lo sabrá.
Si queremos que la función informe a quien la
llama, debe devolver el valor de forma explícita.
Para que una función devuelva el resultado,
escribiremos "return" y lo que debe devolver:
una variable, un valor o una expresión.
así que pondremos "return totalDonuts". Con
lo que al llamar a esta función dará este valor.
¡Ahora se muestra nuestro resultado!
Realmente podemos abreviar la función, sin
siquiera usar una variable, poniendo la expresión
con "return" y ya sólo es una línea. Vale.
Bien, ahora podemos seguir y calcular el
total de dónuts en cada momento llamando a
la función y pasándole el número de años.
Veamos, calcTotalDonuts(25), en la posición
correcta, calcTotalDonuts(65).
¡Bien! Esto hace que a los 65 haya comido
70 000 dónuts. ¡Es un montón de dónuts!
No creo que Winston lo consiga. [risas]
Pero ahora que hemos creado una función,
es muy fácil cambiarla.
Si Winston lo ve y dice "¡Vaya! Es mucho.
¿Qué tal si sólo como uno al día?"
Bien, sólo tenemos que ir aquí, cambiar
este número, y ver cómo todo cambia.
Ahora son 23 000. Todavía muchos. Así que
Winston puede decir "¡Vale! ¿Y si sólo tomo
uno por semana?". Sí, eso es razonable.
Sólo tenemos que cambiar 365 por 50, ya
que hay unas 50 semanas en un año, ¿vale?
Bien, esto es mucho mejor. 3 000 dónuts
parece razonable.
Como veis, con funciones y resultados
podemos ahorrar código y salvar vidas.
Estamos de regreso con nuestro programa que usa una función
para dibujar a "Winston" cuatro veces.
Y la he cambiado para mostrar en realidad de qué edad es
en cada etapa de su vida, y pronto verás por qué.
Pero primero necesito decirles algunas cosas sobre "Winston":
"Winston" tiene una adicción a las donas.
Se come tres al día.
Probablemente por eso es que tiene esa cara tan grande y amarilla.
Así que para advertir a "Winston" sobre lo malo que son las donas para él,
quiero modificar este programa para mostrar cuantas donas
en total se ha comido en cada etapa de su vida.
Por ejemplo, cuando él tenía dos años de edad,
eso significa que se había comido 3 por 365 por 2,
tres por día, por 365 días por 2 años.
Y sólo tendremos que mostrarlo debajo de ese encabezado, ¡wow!
Dos mil donas, esas son muchas donas para un niño de dos años.
Ahora, cuando tenía 14 años, déjenme ver, se había comido 3 por 365 por 14,
y esas son 15,000 donas. Muy bien.
Entonces podría continuar haciendo estos cálculos, pero empiezo a darme cuenta de que hay un patrón.
Estoy repitiendo mis cálculos aquí,
y sólo estoy cambiando una cosa: el número de años.
Cuando veo que un código se repite como éste,
Pienso: "Mmm, ¿podré hacer una función con esto?".
Sí, definitivamente, podemos. Así que hagámoslo.
Voy a definir mi función aquí arriba
y llamarla "calcTotalDonuts = function"
Y va a necesitar un parámetro, el número de años,
porque ésta es la única cosa que estamos cambiando
cada vez que hacemos este cálculo.
Y luego, dentro, haremos el cálculo,
y lo salvaremos en una variable, así que será 3 por 365 por "numYears" (número de años).
Muy bien, entonces ahora que tenemos esa función,
voy a reemplazar esta expresión aquí con "calcTotalDonuts",
la llamada a la función, y voy a pasar el parámetro "2".
Ok, bueno ahora no vemos ningún total.
Mmm, ok, ¿qué pasó?
Bueno, nuestra función hizo el cálculo del total, aquí,
pero no le dijo a nadie sobre ese total.
Es como si un maestro te hiciera una pregunta en clase,
y tú la contestas en tu mente
pero eres muy tímido para decir la respuesta.
Has hecho el trabajo, pero tu maestra nunca lo va a saber.
Si queremos que una función comunique un valor
cada que es llamada, la función tiene que regresar el valor explícitamente.
Así que para que una función regrese el valor necesitamos teclear "Return",
y lo que debe regresar.
Puede ser una variable, un valor o una expresión,
así que aquí diremos: "return totalDonuts", ¿está bien?
Entonces quien llamó la función tendrá esta respuesta.
¡Y ahora podemos ver nuestro resultado!
Y en realidad podemos acortar nuestra función,
no tenemos que almacenar todo esto en una variable,
podemos tomar esta expresión que tenemos aquí
y ponerla en el "return", y entonces la tenemos en una sola línea. Genial.
Muy bien, ahora podemos avanzar
y calcular el total de donas en cada etapa de la vida
sólo llamando esta función y pasándole el número de años.
Déjenme ver, es "calcTotalDonuts(25)",
la posición es correcta, "calcTotalDonuts(65)",
¡Muy bien! Wow, si lo sigue haciendo hasta los 65,
se habrá comido 70,000 donas. Son muchas donas.
No creo que "Winston" lo haga.
Pero ahora que lo hemos hecho con una función,
realmente es fácil cambiar alguna de las partes.
Si "Winston" ve esto y dice:
"Vaya, es mucho, ¿qué tal si sólo como una dona al día?"
Ok, bueno podemos ir justo aquí y cambiar este número,
y vemos que todo cambia.
Ahora son 23,000. Todavía es mucho. Así que tal vez "Winston" diga:
"Está bien, ¿qué tal si sólo como una a la semana?"
Sí, eso es razonable, ok.
Entonces sólo cambiamos 365 por 50,
porque un año tiene como 50 semanas, ¿cierto?
Ok, eso está mucho mejor, ¿cierto?
3,000 donas, eso parece razonable.
Muy bien, así que como ves, con funciones y regresando valores,
podemos ahorrar código y salvar vidas.
Voici le code qui utilise une fonction
pour dessiner Winston 4 fois.
J'ai juste ajouté l'age qu'il avait
à chaque période de sa vie.
Et vous allez voir pourquoi bientôt.
J'ai une histoire à raconter :
Winston adore les donuts !
Il en mange 3 par jour !
C'est probablement pour ça
que son visage est gros et jaune !
Pour lui faire comprendre que
ce n'est pas bon pour lui,
je veux afficher le nombre de donuts
qu'il aura mangé au total à chaque age.
Par exemple, à 2 ans, il en aura mangé ...
3 chaque jour, pendant 365 jours, sur 2 ans.
C'est à dire : 3 fois 365 fois 2 !
On affiche ça sous le titre...
Wouah ! ça fait plus de 2.000 donuts
alors qu'il n'a que 2 ans !
Maintenant, lorsqu'il aura 14 ans,
voyons un peu...
il en aura mangé 3 fois 365 fois 14.
Et ça fait... plus de 15.000 donuts !
OK. Je peux continuer comme ça
mais je reconnais une formule.
Je répète mon calcul ici.
Je change juste un truc :
le nombre d'années.
Dès que je vois que je répète du code,
comme ça...
je dois penser à faire une fonction.
Et oui, c'est ce qu'il faut faire.
Faisons-le, alors !
Je défini ma fonction ici,
et je l'appelle...
"calcTotalDonuts" (pour "calcule le nombre
total de donuts").
Elle va utiliser un paramètre
(le nombre d'années)
car c'est la seule chose
qui change dans ma formule.
A l'intérieur, on va faire le calcul.
Le résultat sera dans une variable.
C'est 3 fois 365 fois "numYears".
(le nombre d'années, le paramètre)
OK. Maintenant qu'on a cette fonction,
je remplace les calculs...
par l'appel de la fonction... ici...
en lui passant le nombre d'années, ici 2.
OK. Hum...
on ne voit plus aucun calcul maintenant !
Pourquoi ça ?
Notre fonction a fait le calcul, ici.
Mais on n'a pas indiquer
ce qu'il fallait en faire.
C'est un peu comme si
votre professeur vous pose une question...
vous pensez à la réponse...
mais vous oubliez de la dire.
Vous avez fait le travail, mais votre
professeur ne pourra pas le savoir.
Si on veut que la fonction communique
une valeur au programme qui l'a appelée,
on doit indiquer à la fonction de le faire.
Pour que la fonction retourne une valeur,
on doit écrire "return",
puis la valeur à retourner.
Ça peut être la valeur
d'une variable, ou une expression.
Donc, ici, on va retourner la valeur
de notre variable. OK ?
Celui qui va appeler cette fonction
va obtenir cette réponse.
Et maintenant, notre valeur est affichée !
Yahou !
On peut même optimiser
le code de la fonction,
car on n'a pas besoin de la variable intermédiaire, ici.
On peut directement retourner l'expression ! Impec.
Donc maintenant, on peut utiliser notre fonction
aux différents endroits en passant le nombre d'années.
Voyons... calcTotalDonuts(25)...
et calcTotalDonuts(65)
OK ! ... si il fait ça pendant 65 ans,
il aura mangé 70.000 donuts !
Ça fait beaucoup, non ?
Je ne pense pas qu'il fera ça !
Maintenant qu'on en a fait une fonction,
c'est simple de la faire évoluer.
Par exemple, si Winston voit ça et se dit :
"ça fait trop ! et si j'en mangeais qu'un par jour ?"
OK. On a juste à aller ici...
pour changer ce nombre.
et du coup, tous les calculs changent d'un coup.
Bon, ça fait encore 23.000 !
C'est encore beaucoup.
Et si il en mangeais seulement
un par semaine ?
On a juste a changer le 365 par 52,
car il y a 52 semaines dans une année...
OK. C'est mieux...
3.000 donuts, c'est plus raisonnable.
OK. Vous avez vu qu'avec les fonctions
qui retournent une valeur,
on peut gagner en ligne de code...
et on se simplifie la vie !
חזרנו לתוכנית שלנו שמשתמשת בפונקציה בכדי לצייר את וינסטון ארבע פעמים.
ושיניתי אותה קצת על מנת להראות באיזה גיל הוא נמצא בכל נקודה של בחיים, ותראו למה בקרוב.
אבל קודם אני צריכה לספר לכם משהו על ווינסטון: לוינסטון יש התמכרות לסופגניות.
הוא אוכל שלוש מהן ביום. זו הסיבה כנראה לכך שהפנים שלו כל-כך גדולות וצהובות.
אז כדי להזהיר וינסטון שסופגניות הן רעות בשבילו, אני רוצה לשנות את התוכנית כך שתראה כמה סופגניות הוא אכל בכל נקודה בחיים שלו.
לדוגמה, כשהוא בן שנתיים, זה אומר שהוא אכל 2 פעמים (שנתיים) כפול 365 פעמים (מספר הימים בשנה) כפול 3 פעמים (שלוש פעמים ביום), אז פי שלוש ביום, כפול 365 ימים, לשנתיים.
אנחנו רק נציג את זה מתחת לכותרת הזו, אז וואו! אלפיים סופגניות, זה הרבה סופגניות למישהו בן שנתיים.
עכשיו כאשר הוא בן 14, בוא נראה, יש לו 3 פעמים ביום כפול 365 ימים כפול 14 שנים.
זה חמש עשרה אלף סופגניות. בסדר. אז אני יכולה להמשיך את המתמטיקה הזאת, אבל אני מתחילה לשים לב דפוס.
אני חוזרת על החישובים שלי כאן, ואני משנה רק דבר אחד: מספר השנים.
בכל פעם שאני רואה קוד שחוזר על עצמו ככה, אני חושבת לעצמי, "הממ, אולי אני יכולה להפוך את זה לפונקציה?"
כן, בהחלט, אנחנו יכולים. אז בואו נעשה את זה עכשיו.
אני אגדיר את הפונקציה כאן למעלה ואקרא לפונקציה בשם calcTotalDonuts (נכתוב: calcTotalDonuts = function)
היא הולכת לקבל פרמטר אחד, את מספר שנים, כי זה הדבר היחיד שאנו משנים כל הזמן בחישוב הזה
ואז בפנים, נוכל לעשות את החישוב, לשמור אותו לתוך משתנה, כך שיהיה שהמשתנה יהיה מספר השנים (numYears) כפול 3 פעמים כפול 365.
בסדר, אז עכשיו שיש לנו את הפונקציה הזו, אני הולכת להחליף את הביטוי הזה כאן עם calcTotalDonuts - הקריאה לפונקציה - ואני אעביר לה את הערך "2".
טוב, עכשיו אנחנו לא רואים את הסך הכל בכלל.
המממ, אוקיי, מה קרה? ובכן, הפונקציה שלנו חישבה את הסך הכל כאן, אבל היא לא סיפרה לאף אחד על הסכום.
זה כמו שאם מורה קורא לך בכיתה בכדי להשיב על שאלה, ואתה תענה לו בראש שלך אבל אתה מתבייש לומר את התשובה.
עשית את העבודה, אבל המורה שלך לעולם לא יידע על כך.
אם אנחנו רוצים שהפונקציה תתקשר את הערך למי שקרא לה, הפונקציה צריכה להחזיר את הערכים באופן ספציפי.
אז בשביל שפונקציה תחזיר ערך, אנחנו צריכים להגיד מהו סוג הערך שהיא תחזיר, ואז מה הערך עצמו. אולי זה משתנה, או ערך או ביטוי.
אז כאן נגיד שאנחנו רוצים להחזיר את זה totalDonuts חזרה, בסדר? אז מי שקורא לאותה הפונקציה הולך לקבל את התשובה הזו.
כעת הערך שלנו מוצג, איזה כיף!
בעצם אנחנו יכולים לקצר את הפונקציה שלנו, אנחנו אפילו לא צריכים לאחסן אותו לתוך משתנה, נוכל לקחת את הביטוי הזה כאן
לשים אותו בערך שהפונקציה מחזירה (ה-return), ואז זו רק שורה אחד של קוד. מגניב.
בסדר, אז עכשיו אנו יכולים לעבור ולחשב את מספר הסופגניות הכולל בכל נקודה בחיים על-ידי פשוט לקרוא לפונקציה זו, ולהעביר לה את מספר השנים.
בוא נראה, זה (calcTotalDonuts(25, נמקם את זה כראוי, (calcTotalDonuts(65
בסדר! וואו, אז אם הוא יגיע עד גיל 65, הוא יאכל 70,000 סופגניות. זה הרבה סופגניות...
אני לא חושבת שוינסטון הולך להגיע לזה...
אבל עכשיו כשהפכנו את זה לפונקציה, זה מאוד קל לנו לשנות חלקים ממנה.
אם וינסטון יראה את זה ויאמר "רגע, רגע, זה המון. מה אם אני פשוט אוכל אחת ביום? "
טוב אנחנו יכולים פשוט ללכת לכאן, לשנות את המספר לאחד, והכל ישתנה.
אז זה סך הכל 23,000. עדיין הרבה. אז אולי וינסטון יגיד: "בסדר, בסדר, מה אם אני פשוט אוכל אחת בשבוע?" כן, זה הגיוני, בסדר.
אז אנחנו פשוט יכולים לשנות את 365 ל-50, כי יש 50 שבועות בשנה, נכון?
טוב, זה הרבה יותר טוב, 3,000 דונאטס, נשמע הגיוני.
מעולה, אז כפי שראיתם, עם פונקציות וערכים חוזרים, אנחנו יכולים לחסוך בקוד ולהציל חיים!
დავუბრუნდით ჩვენს პროგრამას
რომელიც იყენებს ფუნქციას,
რათა ვინსტონი ოთხჯერ დახატოს
მე შეცვალე ეს ფუნქცია
ახლა ის აჩვენებს, რა ასაკისაა ვინსტონი
ცხოვრების ამა თუ იმ მომენტში
მალე ნახავთ რატომაც
მაგრამ მანამდე
რაღაც უნდა გითხრათ ვინსტონზე
ვინსტონი ზედმეტად უყვარს დონატები
ის ყოველდღე სამ ცალს ჭამს.
ამიტომაც ამხელა ყვითელი სახე აქვს
იმისთვის, რომ გავაფრთხილო,
რამდენად მავნეა მისი ეს ჩვევა
მე მინდა შევცალო პროგრამა ისე,
რომ მან აჩვენოს
რამდენი დონატი ექნება მას ნაჭამი
ცხოვრების რაღაც მომენტისთვის.
მაგალითად, როცა ის ორი წლისაა
მას ნაჭამი ექნება
3-ჯერ 365 გამრავლებული 2-ზე
სამი დონატი დღეში, წელიწადში 365 დღეა,
და ასე ორი წლის განმავლობაში
ამ რიცხვს
გამოვაჩენთ სათაურის ქვეშ
ორი ათასი დონატი!
ძალიან ბევრია ორწლიანისთვის.
ახლა ვნახოთ, რამდენს შეჭამს ის
14 წლის ასაკში, ანუ 3-ჯერ 365 14-ზე
გამოვიდა 15000 დონატი
შემეძლო გამეგრძელებინა გამოთვლები,
მაგრამ კანონზომიერებას ვამჩნევ
გამოთვლები მეორდება
და ყოველ ჯერზე
მხოლოდ წლების რაოდენობა იცვლება
როდესაც კოდის ასეთ გამეორებას ვხედავ,
ვფიქრობ "შემიძლია აქ ფუნქცია დავწერო?"
კი, ნაღდად შემიძლია.
დავწეროთ ეს ფუნქცია
ფუნქციას აი აქ განვსაზღვრავ
დავარქვათ მას calcTotalDonuts
(დათვალე დონატების საერთო რაოდენობა)
მას გადაეცემა ერთადერთი პარამეტრი -
წლების რაოდენობა
იმიტომ რომ ეს ერთადერთი ცვლადი რამეა
ჩვენს გამოთვლებში
აქ, შიგნით, გამოვითვლით მნიშვნელობას
და შევინახავთ მას ცვლადში
ეს იქნება 3-ჯერ 365 გამრავლებული
წლების რაოდენობაზე
კარგი. ფუნქცია მზადაა
ამ გამოსახულებას აქ
calcTotalDonuts-ით შევცვლი
გამოვიძახებ ამ ფუნქციას და გადავცემ ორიანს
ახლა საერთო რაოდენობა აღარ ჩანს
რა მოხდა?
ჩვენმა ფუნქციამ
გამოთვალა მნიშვნელობა აი აქ
მაგრამ საერთო
რაოდენობა არავის ამცნო
ეს იგივეა, რაც მასწავლებელმა რომ
გამოგიძახოთ გაკვეთილზე, დაგისვათ კითხვა
და თქვენ მიხვდეთ პასუხს
მაგრამ მოგერიდოთ მისი ხმამაღლა თქმა.
თქვენ შეასრულეთ დავალება,
მაგრამ მასწავლებელი ამას არასდროს გაიგებს
თუ გვინდა, რომ ფუნქციამ
გადასცეს მნიშვნელობა იმას, ვინც გამოიძახა
ფუნქციამ უნდა დააბრუნოს მნიშვნელობა
ამისთვის უნდა დავწეროთ: return
(დააბრუნე)
და ის, რაც გვინდა დავაბრუნებინოთ
ეს შეიძლება იყოს ცვლადი,
მნიშვნელობა ან გამოსახულება
აქ დავწერთ:
return totalDonuts
ახლა ის, ვინც
გამოიძახებს ამ ფუნქციას, მიიღევს პასუხს
და ჩვენი მნიშვნელობაც გამოჩნდა!
შეგვიძლია ჩვენი ფუნქცია შევამოკლოთ
არ გვჭირდება ცვლადში
მნიშვნელობის დამახსოვრება
შეგვიძლია მთელი გამოსახულება
return-ის მერე დავსვათ
და გამოგვივა ერთხაზიანი ფუნქცია.
კარგი, ახლა შეგვიძლია დავთვალოთ
რამდენი დონატი შეჭამა ვინსტონმა
ცხოვრების ამა თუ იმ მომენტში
უბრალოდ გამოვიძახოთ ეს ფუნქცია
და გადავცეთ წლების რაოდენობა
კარგი, აქ გვაქვს calcTotalDonuts(25)
სწორ ადგილას დავწეროთ
calcTotalDonuts(65)
გამოდის, რომ 65 წლის ვინსტონს
70000 დონატი ექნება ნაჭამი!
ეს მართლაც ძალიან ბევრია
არა მგონია ვინსტონმა ამდენს გაუმკლავდეს.
ახლა, რაც გამოთვლები ფუნქციაში გვაქვს
გაგვიმარტივდება მისი ნაწილები შევცვალოთ
მაგალითად, ვინსტონმა
ეს რომ ნახოს და თქვას
"ო, ეს ზედმეტია. იქნებ დღეში ერთი ვჭამო?"
ჩვენ აქ გადავალთ და შევცვლით რიცხვს
და ყველაფერი შეიცვლება
გამოვიდა 23000. ისევ ძალიან ბევრია.
ახლა ვინსტონმა შეიძლება თქვას:
"კარგი, იქნებ კვირაში ერთი ვჭამო?"
ეს ნორმალურია
365-ს შევცვლით 50-ით
იმიტომ რომ წელიწადში დაახლოებით 50 კვირაა
გაცილებით უკეთესია.
3000 დონატი, საკმაოდ ნორმალურია
როგორც ხედავთ, ფუნქციებისა და
დასაბრუნებელი მნიშვნელობების გამოყენებით
საწერი კოდის რაოდენობაც
და ვინსტონის წონაც შევამცირეთ
Winston을 4번 그리는 함수가 있는
프로그램으로 돌아왔습니다
Winston이 인생의 각 시점에 몇살인지
보여주도록 프로그램을 수정하였습니다
왜 그런지 곧 알게 될겁니다
하지만 우선 Winston에 대해서 몇가지 말 해줄 필요가 있습니다
Winston는 도넛 중독자입니다
하루에 3개씩 먹습니다
그렇기 때문에 얼굴이 이렇게 크고 노랑색입니다
그래서 도넛이 얼마나 그에게 나쁜지 경고하기 위해서,
인생의 각 시점에 얼마나 많은 도넛을 먹었는지 보여주도록
전 프래그램을 변경하고 싶습니다
예을 들면 Winston이 두살때
그것은 곧 , 3 X 365 X 2 만큼 먹었다는 겁니다
즉 하루에3개씩, 곱하기 365일, 곱하기 2 살이지요
그리고 헤더밑에 표시 하게습니다. 와!!!!
2천개의 도넛이네요. 2살짜리 에게는 너무나 많은 도넛이에요
14살이 되었을때는 3 X 365 X 14 를 먹겠네요
즉 1만5천개 입니다
계속 계산 할수 있겠지만, 페턴이 보이기 시작하네요
계산을 반복하고 있네요
하나만 변경하겠습니다: 햇수 (즉, 몇 년동안)를 변경하겠습니다
이것처럼 반복되는 코드를 볼때마다
스스로 생각해 봅니다
"흠 이것을 함수로 말들수 있을까?"
그럼요 당연히 만들수 있지요 그럼 지금 해 봅시다
함수를 이쪽에서 선언 해 보겠습니다
calcTotalDonunts = function 이라고 부르겠습니다
햇수 (the number of years)입니다
왜냐하면 계산 할때 마다 변하는 것은
단지 햇수 하나 이기 때문입니다
그리고 안 에서, 계산을 하겠습니다
그리고 변수(variable)에 저장을 합니다
즉 3 X 365 X numYears
좋습니다 이제 함수를 만들었구요
이 식(expression)을 calTotalDounts로 대치하겠습니다
함수을 부르고, 2를 값으로 보내겠습니다
근데 지금 전체 도넛양이 안 보이네요
흠, 무슨일이 일어 났지요?
우리의 함수가 전체 값을 계산 했네요
근데 값을 말 해 주지 않고 있어요
이건 꼭 수업시간에 선생님이 질문에 답하라고 불렀는데
답이 머리에서만 있고
너무 부끄러워 답을 말하지 못하고 있는 것 같네요
과제는 했는데, 선생님이 전혀 몰라주는것과 같아요
함수가 어디서든 불려져서 부른 곳에다가 값을 전달하려면
그 값을 명시적으로 반환하여야 합니다
그래서 값을 반환하려는 함수에서는
return 이라고 쓰고 반환하려는 값을 씁니다
모든 원하는 값을
아마도 그것은 변수 또는 값 또는 식이 될 수도 있는데
여기서 우린 return totalDonuts이라고 하겠습니다.
그럼, 누가 이 함수를 부르던지, 이렇게 닶을 얻을 것입니다
이제 값이 표시 되네요!
그리고 사실 이 함수를 좀더 간단하게 만들 수 있습니다
변수에다 값을 저장 할 필요가 없어요
그냥 여기 식(expression) 전체를
return 에 넣어줘도 됩니다 그러면 한 줄이 간단히 한 줄이 되지요
좋아요, 이제 살펴보지요
각 시점의 전체 도넛의 수를 계산하는 것은
함수를 불러, 햇수(number of year)를 넘겨줍니다
자 봅시다. calcTotalDounuts(25),
위치를 정확하게 해주고, calcTotalDounuts(65)
오케이, 와, 65까지 살게 되면
Winston은 7만개의 도넛을 먹게 되겠네요
엄청 많은 도넛이네요
제 생각에는 Winston이 그때 까지 못 살것 같아요 (웃음)
하지만 우리가 함수를 만든 한
일부분을 수정하는 것도 아주 쉬운 일이지요
만약 Winston이 이걸 보고
와, 이건 너무 많네요. 만약 하루에 하나만 먹으면요?
오케이, 그럼 여기로 가서 숫자 하나만 변경하면 되요
그럼 모든것이 변경되지요
그래서 2만3천개가 됩니다 여전히 많은 양이네요
아마도 Winston이
좋아요, 만약 한주에 하나면 먹으면요? 라고 하면
네, 합리적이네요, 좋아요
그럼 365를 50로 변경하고
왜냐하면 일년에 50주가 있으니깐요
좋아요, 이제 훨씬 낫네요
3천개 도넛, 적당한것 같아요
함수와 반환값으로
코드도 만들수 있고, 한 생명을 살리수도 있네요
Wracamy do programu,
który wykorzystuje funkcję
i rysuje Winstona cztery razy.
Zmieniłam to tak, żeby pokazać
jego wiek w każdym etapie życia.
Niedługo zobaczycie, dlaczego.
Najpierw powiem wam coś o Winstonie.
Jest uzależniony od pączków.
Je trzy pączki dziennie.
Pewnie dlatego ma tak dużą
i żółtą twarz.
Żeby mu powiedzieć,
jak szkodliwe są pączki,
zmienię program
i pokażę, ile zjadł pączków
w różnych etapach życia.
Np. gdy miał 2 lata...
to zjadł już...
3 razy 365 razy 2.
3 pączki dziennie razy 365 dni
razy 2 lata.
Wyświetlimy to pod nagłówkiem.
Dwa tysiące pączków!
Dużo jak na dwulatka!
Tu ma 14 lat.
Zjadł 3 razy 365 razy 14.
To 15 tysięcy pączków.
Mogłabym liczyć dalej,
ale dostrzegam schemat.
Powtarzam obliczenia
i zmieniam tylko jedno: liczbę lat.
Gdy widzę taki powtarzalny kod,
myślę: „Czy mogłabym
zrobić z tego funkcję?”.
Tak, to możliwe.
Zróbmy więc to teraz.
Zdefiniuję funkcję. Nazwę ją
„calcTotalDonuts = function”.
Będzie przyjmować
jeden parametr, liczbę lat.
Bo tylko to zmieniamy
w tych obliczeniach.
Obliczymy to wewnątrz
i zachowamy w zmiennej.
Mamy: 3 razy 365 razy „numYears”
(liczba lat).
Gdy już mamy tę funkcję,
zastąpię to wyrażenie
przywołaniem funkcji
„calcTotalDonuts”,
i wprowadzę „2”.
No i nie widzimy żadnej sumy.
Co się stało?
Nasza funkcja obliczyła sumę, tutaj,
ale nikomu o niej nie powiedziała.
Jakby nauczyciel wywołał was
do odpowiedzi,
a wy udzielacie jej w głowie,
bo głośno się wstydzicie.
Uczyliście się,
a nauczyciel się o tym nie dowie.
Jeśli chcemy, by funkcja
pokazywała wartość,
musi ona tę wartość zwrócić.
Żeby funkcja zwróciła wartość,
musimy wpisać „return”,
i określić, co.
Zmienną, wartość, wyrażenie...
Tu napiszemy:
„return totalDonuts”.
Kto przywołał tę funkcję,
uzyska odpowiedź.
I wartość już widać!
Możemy skrócić funkcję,
nie trzymać jej w zmiennej.
Bierzemy to wyrażenie,
umieszczamy je w „zwróć”
i mamy jedną linijkę. Ładnie!
Możemy teraz obliczyć, ile pączków
zjadł w każdym etapie życia,
przywołując tę funkcję
i wprowadzając liczbę lat.
Mamy więc „calcTotalDonuts(25)”,
umieśćmy to...
„calcTotalDonuts(65)”...
Jeśli dożyje 65 lat,
to łącznie zje
70 tysięcy pączków. Dużo!
Chyba nie da rady.
Gdy już zrobiliśmy z tego funkcję,
będziemy mogli łatwo
zmieniać jej części.
Winston to widzi i mówi:
„Dużo! A gdybym jadł
jednego pączka dziennie?”.
Wejdźmy tu, zmieńmy jedną liczbę
i zmieni się wszystko.
Jest 23 tysiące. Nadal dużo.
Winston mówi „Dobrze,
może więc jeden tygodniowo?”.
To już rozsądne.
Zmieniamy 365 na 50,
bo rok ma ok. 50 tygodni.
Tak już lepiej, prawda?
3 tysiące pączków. To rozsądne.
Znając funkcje
i zwracane wartości
uratujemy program
i życie innych osób!
Estamos de volta com nosso programa que
usa uma função que desenha Winston 4 vezes
E eu alterei ela para que seja exibido sua
idade em cada ponto da vida, logo veremos
Mas antes eu tenho que dizer algo:
Winston é viciado em donuts
Ele come 3 deles por dia. Deve ser por
isso que sua cara é grande e amarela.
Então, para alertar como os donuts são ruins para ele.
E vou modificar este programa para mostrar quantos donuts ele comeu em cada ponto de sua vida
Por exemplo, quando ele tinha 2 anos, significa que ele comeu 3 vezes 365 vezes 2.
3 por dia, vezes 365 dias, vezes 2 anos.
E nós vamos mostrar bem abaixo do cabeçalho, entao wow!
2 mil donuts, é muito donuts para 2 anos de idade
Agora que ele tem 14 anos, vamos ver,
3 vezes 135 vezes 14
E isto é 15 mil donuts. Tudo bem, eu poderia
continuar esta matemática, mas estou começando a perceber um padrão.
Estou repetindo meus cálculos aqui, só
estou mudando uma coisa: os anos
Sempre que eu ver códigos repetidos como este,
eu penso, "Hmm, posso transformar numa função?"
Yeah, definitivamente, podemos.
Então vamos fazer agora.
Definirei minha função aqui e chamarei
de calcTotalDonuts igual function
E ela receberá um parâmetro, o número de anos,
porque esta é a única coisa que muda sempre
E então dentro, nós calcularemos, e guardamos
numa variável, então será 3 vezes 365 vez numYears
Ok, agora que temos a função, vamos substituir a expressão
aqui com calcTotalDonuts - para chamar a função - passando 2.
Ok, nós não vemos o total.
Hmm, ok, o que aconteceu? Bem, nossa função
calculou o total, aqui, mas não disse pra ninguém qual foi o total
É como se um professor perguntasse algo para você
e a resposta estivesse em sua cabeça, mas você é muito tímido pra dizer a resposta.
Você fez o trabalho, mas seu professor
nunca saberá
Se quisermos que a função comunique-se com quem a chamou,
a função deve explicitamente retornar o valor
Para a função retornar um valor, precisamos escrever return, e então o que quisermos retornar.
Talvez seja uma variável ou o resultado de uma expressão.
então aqui vamos colocar return totalDonuts, ok? Então quem chamar esta função
irá pegar esta resposta
E agora nosso valor é exibido, yay!
Agora podemos encurtar nossa função, nós nem precisamos guardar o valor numa variável, podemos simplesmente pegar esta expressão inteira.
colocar no return, e então ela só
terá uma linha, Linda.
Ok, agora podemos prosseguir e calcular o total de donuts em cada ponto da vida chamando esta função e passando o numéro de anos.
Um, vamos ver ,é calcTotalDonuts(25), posição correta, calcTotalDonuts(65)
Ok! Wow, então se ele fizer 65, terá comido 70.000 donuts.
É muito donuts.
Eu acho que Winston não conseguirá[risos]
Mas agora que fizemos numa função,
é realmente fácil alterar partes dela
Como se Winston olhasse e dissesse
"Woah, woah, é muito! E se eu comesse uma por dia?"
Ok, nós podemos vir aqui, alterar este número
e ver tudo mudar.
Então será 23.000.Ainda é muito. Então talvez Winston diga "Ok, ok, e se eu tivesse uma por dia?
Yeah, isto é razoável, ok.
Então, nós poderíamos alterar 365 para 50,
porque temos 50 semanas no ano, certo?
Ok, é muito melhor certo? 3.000 donuts,
parece razoável.
Ok, então se você ver, com funções e valores de retorno,
nós podemos salvar códigos e vidas
Ta trở lại với chương trình của mình sử dụng một hàm
để vẽ Winston tới 4 lần.
Và tôi đã thay đổi để nó thực sự thể hiện anh ta bao nhiêu tuổi
tại mỗi thời điểm trong đời, và bạn sẽ sớm biết tại sao.
Nhưng trước tiên tôi cần nói với bạn vài điều về Winston:
Winston nghiện bánh rán.
Anh ấy ăn 3 cái một ngày.
Có lẽ đó là lý do tại sao khuôn mặt của anh ta to tròn và vàng như thế.
Vì vậy, để cảnh báo Winston về việc bánh rán có hại như thế nào,
Tôi muốn sửa đổi chương trình này để hiển thị
Anh ấy đã ăn tổng cộng bao nhiêu bánh rán tại mỗi thời điểm trong đời mình.
Ví dụ, khi anh ấy hai tuổi,
nghĩa là anh ta đã ăn 3 * 365 * 2,
cứ như vậy ba cái một ngày, * 365 ngày, * 2 năm.
Và ta sẽ chỉ hiển thị bên dưới phần tiêu đề, thật tuyệt vời!
2000 chiếc bánh rán, quả là rất nhiều đối với một đứa trẻ 2 tuổi.
Bây giờ khi anh ấy 14 tuổi, hãy xem, anh ấy đã 3 * 365 * 14
Và đó là 15.000 chiếc bánh rán. Được rồi.
Như vậy, tôi có thể tiếp tục làm toán, nhưng đã bắt đầu nhận thấy một mô hình.
Tôi đang lặp lại tính toán ở đây,
và chỉ thay đổi một điều về nó: số năm.
Bất cứ khi nào thấy mã lặp đi lặp lại như thế này,
Tôi luôn tự nghĩ, "Hmm, ta có thể biến nó thành một hàm hay không?"
Đúng vậy, chắc chắn rồi, ta có thể. Vì vậy, hãy làm ngay bây giờ.
Tôi sẽ định nghĩa hàm của mình ở đây
và gọi nó là calcTotalDonuts = function
Và nó sẽ lấy một tham số, số năm,
bởi vì đó là thứ duy nhất thay đổi
mỗi lần thực hiện tính toán.
Và sau đó bên trong, ta sẽ thực hiện tính toán,
và lưu nó vào một biến, như vậy nó sẽ là 3 * 365 * số năm.
Được rồi, vậy giờ ta có hàm đó,
Tôi sẽ thay thế biểu thức này ở đây bằng calcTotalDonuts,
gọi đến hàm và truyền vào "2".
Được rồi, ừm, giờ ta không thấy tổng số nào cả.
Hmm, được rồi, chuyện quái gì xảy ra thế?
Vâng, hàm của ta đã tính tổng, ở đây,
nhưng nó không nói cho ai biết về tổng số đó.
Giống như nếu một giáo viên gọi bạn trong lớp để trả lời một câu hỏi
và bạn trả lời nó trong đầu
bạn ngại nói ra câu trả lời.
Bạn đã hoàn thành công việc, nhưng giáo viên sẽ không bao giờ biết về nó.
Nếu ta muốn hàm này truyền một giá trị
cho thứ gì gọi nó, hàm phải trả về giá trị một cách rõ ràng.
Vì vậy, để một hàm trả về một giá trị, ta cần gõ return,
và sau đó là giá tị hàm muốn trả về.
Có thể đó là một biến hoặc một giá trị hoặc một biểu thức,
Vì vậy, ở đây ta sẽ gõ return TotalDonuts, được chưa nhỉ?
Vì vậy, bất cứ thứ gì hàm đó cũng sẽ nhận được phản hồi này.
Và bây giờ giá trị của ta đã hiển thị, yay!
Và thực sự ta có thể rút gọn hàm,
thậm chí không phải lưu trữ nó trong một biến,
ta chỉ cần lấy toàn bộ biểu thức này ở đây
đặt sau return, và sau đó nó chỉ là 1 dòng. Tốt rồi.
Như vậy bây giờ ta có thể tiếp tục
và tính tổng số bánh rán tại mỗi điểm trong đời
bằng cách chỉ gọi hàm này và truyền vào số năm.
Ừm, hãy xem, calcTotalDonuts(25),
vị trí là chính xác, calcTotalDonuts(65)
OK! Wow, như vậy nếu anh ta 65 tuổi,
anh ta sẽ ăn 70.000 chiếc bánh rán. Con số đó là rất nhiều.
Tôi không nghĩ Winston sẽ làm được đâu. (cười)
Nhưng bây giờ ta đã biến nó thành một hàm,
thật dễ dàng để thay đổi các phần của nó.
Giống như nếu Winston nhìn thấy điều này và nói,
"Whoa, whoa, nhiều quá. Nếu tôi chỉ ăn 1 cái mỗi ngày thì sao?"
Được rồi, ta có thể vào đây, thay đổi một số này,
và mọi thứ thay đổi.
Vậy là 23.000. Vẫn còn rất nhiều. Vì vậy, có thể Winston thích,
"Được rồi, được rồi, nếu tôi chỉ ăn 1 cái 1 tuần thì sao?"
Ừ, hợp lý đấy, được thôi.
Như vậy, sau đó ta có thể đổi 365 thành 50,
bởi vì có 50 tuần trong một năm, phải không?
Được rồi, tốt hơn nhiều, phải không? 3.000 bánh rán, có vẻ hợp lý.
Được rồi, bạn thấy đấy, với các hàm và giá trị trả về,
ta có thể lưu code và cứu mạng (Winston) nữa.
让我们回到我们的程序,
此程序利用函数功能
描画了四个Winston(大黄娃娃头)。
我已经改变了他
在每一年龄阶段实际年龄的显示。
你很快会明白为什么。
但首先我需要让你们知道关于
Winston 的某些事情。
Winston 特别喜欢炸甜面圈,
他一天吃三个。
那就是他的脸又大又黄的原因。
所以为了警告Winston有关
炸甜面圈对他有多么不好,
我想修改一下这个程序
显示他在每个年龄段吃了
多少个炸甜面圈。
比如,当他两岁的时候,
那意味着他吃了3x365x2,
所以是一天三个,乘以365天,
再乘以2年,
我们会在那个头下面显示那个结果。
哇,这么多!
两千个炸甜面圈,对一个两岁的
孩子来说真的很多。
现在他是十四岁,让我们看看,
应该是3乘以365 再乘以14,
那就是15,000个。好了。
我可以一直用这个算式,
但我开始注意到一个模式。
我在重复我的计算。
虽然我只是改变一个数字:
年数。
无论何时当我看到这样的重复编码,
我会想,“嗯,我能把这变成一项函数吗?“
是的,绝对可以。
那么现在让我们来试试看。
我会在这儿定义我的函数
或者把它叫做calTotalDonuts=function
它需要一个参数,年龄的数目,
因为那是我们每次
做计算时唯一有变化的数字。
我们将在这里面做计算,
并将其存作一个变量,
所以是3乘以365 乘以numYears.
可以啦,现在我们就有了这个函数功能。
我会用calcTotalDonuts来替代这个表达式
使用函数功能,并且输入“2”
好了,我们并没有看见总数
那么,怎么回事儿?
哦,我们的函数功能在这儿计算了总数
但没有告诉任何人那个总数。
就像老师在课堂上叫你起来回答问题
你的答案在你的脑子里,
但你羞于把它说出来。
你已经完成了工作,但你的老师
却不知道,
如果我们想让函数把值告诉给
调用它的人,
那这个函数必须明确地回返一个值。
所以,为了函数能回返一个值,
我们必须写下“return”
然后就有了它所要的回值。
也许它是一个变量或者
是一个值或一个表达式,
那么在这儿我们就敲上
return totalDonuts,行吗?
这样调用这个函数就能得到回应了
现在我们的值显示在此,好棒!
事实上我们能够缩短我们的函数,
我们甚至不用把它存进变量,
我们仅仅把这儿的整个表达式
放进回车,然后它就仅有一行。很好。
好吧,现在我们可以履行
在一生的各个年龄段
计算炸甜面圈的总量
只需点击这个函数功能
并且输入年数。
让我们来看看,这是 calcTotalDonuts(25),
没有打错地方,it's calcTotalDonuts(65)
好了!很棒,如果他到了65岁,
它就吃了70,000个炸甜面圈。
这太多了。
我觉得Winston不会活那么长。(笑声)
但现在我们已经把它做成了函数功能,
要改变一下它的某些部分也很容易。
比如Winston明白这个并且说,
“哇,哇,这太多了。如果我每天
只吃一个怎么样?”
行, 我们可以从这儿开始,
改变这一个数字,
然后看看所有的变化。
这是23,000.还是很多。
那么Winston又说,
“好吧,好吧,如果我每周吃一个怎么样?”
好的,这样比较合理。
那么我们只需要把365 变为50,
因为好像是一年50个星期,是吗?
好,这就好多了,是吗?
3000个炸甜面圈,这看起来还比较合理。
所以,你看利用函数和回返值,
我们能够缩短编码而且挽救生命。
我們又回到用函數
來畫4個溫斯頓的程式了
我修改了一下
以便顯示溫斯頓不同人生階段的年紀
你等一下就會明白
我要告訴你一件關於溫斯頓的事:
溫斯頓愛死甜甜圈了
他每天吃3個
難怪一張臉又大又黃
為了提醒他
甜甜圈對身體不好
我想修改一下程式
以便顯示於每個年紀
他累計吃下多少甜甜圈
例如,他2歲時
他共吃了3﹡365﹡2
1天3個,1年365天,2年
讓數量顯示在標頭下
哇!2千個甜甜圈
對2歲娃來說太多了
現在他14歲
他吃了 3﹡365﹡14
共吃了1萬5千個甜甜圈
我一直這樣算也行
但我開始發現一個規律
我正在重複我的運算
而我只改變其中的一樣東西:年數
每當我看到像這樣重複的程式碼
我便想:「嗯,這能否寫成函數?」
對,我們絕對可以的
我們動手吧
我在這裡定義函數
叫它做 calcTotalDonuts = function
裡面只有一個參數,年數
因為那是我們每次做這計算時
唯一變動的東西
程式裡面,我們做計算
將它存為變數
也就是 3﹡365﹡numYears
我們現在有了這函數
我將利用 calcTotalDonuts
去取代在這裏的表示式
以便召喚程式,及傳遞數值 2
好,現在我們看不到任何總數
嗯,怎麼了呢?
我們的函式確實計算了總數
在這
但它沒有告知任何人那總數
好比學校老師點你回答問題
而你只在腦中回答
因爲你太害羞去講出答案
你有答案,但老師永遠不會知道
如果我們想函數
傳某值給召喚它的人
函數就要寫明去回傳 (return) 那值
要函數回傳一個值
我們須輸入 return
不管它想回傳什麼
可以是變數、數值或表示式
這裡我們指明
return totalDonuts
所以誰召喚此函數
誰就會得到這回答
總計顯示出來了, 耶!
這裡我們可簡化函數
不必儲存成變數
只需把整個表示式
寫在 return 裡
函數就變成一行
好
現在我們可以來回顧和計算
每個年紀吃下的甜甜圈總量
就是召喚這函數
傳遞年數
嗯,這裡是 calcTotalDonuts(25)
位置沒錯 calcTotalDonuts(65)
好!哇!如果他吃到65歲
他將吃下7萬個甜甜圈
那真是超多甜甜圈
我不覺得溫斯頓能辦到(笑)
不過現在我們寫了這函數
做些小調整並不難
好比溫斯頓看到這結果
說: 「噢!這太多了
如果我1天只吃1個?」
那我們可以來到這
修改這一個數字
所有都改好了
2萬3千個,還是很多
也許溫斯頓說:
「好吧好吧!如果我1週吃1個呢?」
嗯,這比較合理
那我們改 365 為 50
因為一年有50週,對吧?
好,看來好多了,是吧?
3千個,那蠻合理的
所以你看,運用函數和數值回傳
我們能保存程式碼,亦能保護生命