WEBVTT

00:00:01.383 --> 00:00:03.649
Nu til noget du har brugt

00:00:03.649 --> 00:00:05.685
hele tiden: Funktioner.

00:00:05.685 --> 00:00:09.140
Hver gang du har brugt kommandoer
som rect(), fill() eller text(),

00:00:09.140 --> 00:00:12.376
har du kaldt funktioner,
og de funktioner har tegnet

00:00:12.376 --> 00:00:15.132
hvad du har bedt dem om.

00:00:15.132 --> 00:00:16.806
Hvad er funktioner?

00:00:16.806 --> 00:00:19.483
Det er en samling kode 
som vi har grupperet

00:00:19.483 --> 00:00:21.240
og givet et navn
fordi vi vil være i stand til,

00:00:21.240 --> 00:00:23.168
at bruge dens
funktionalitet flere gange.

00:00:23.368 --> 00:00:25.981
Tænk på rect().
Hvad gør rect()?

00:00:25.981 --> 00:00:28.551
Det tegner bare fire linjer, ikke?

00:00:28.551 --> 00:00:31.141
Det kunne vi da bare gøre
med vores line() funktion, ikke?

00:00:31.141 --> 00:00:33.847
og her har vi
hvad der ligner et rektangel.

00:00:33.847 --> 00:00:36.751
Men vi indser at vi
gerne vil kunne

00:00:36.751 --> 00:00:39.322
tegne et rektangel mange gange,

00:00:39.322 --> 00:00:40.773
og det ville være irriterende

00:00:40.773 --> 00:00:42.784
at lave matematikken hver gang
for at finde ud af

00:00:42.784 --> 00:00:44.282
hvordan man tegner en linje
fra et hjørne til det næste

00:00:44.282 --> 00:00:45.818
og det næste og næste

00:00:45.818 --> 00:00:48.538
Så i stedet har vi bare lavet
en rect() funktion,

00:00:48.538 --> 00:00:50.858
og den funktion gør
præcis den samme ting,

00:00:50.858 --> 00:00:55.148
som de fire linjers kode gjorde,
men fylder meget mindre.

00:00:55.148 --> 00:00:58.399
Det er pænt sejt,
og rect() er en af de funktioner

00:00:58.399 --> 00:01:00.519
som er tilgængelig
for ALLE programmer

00:01:00.519 --> 00:01:02.729
og kan bruges her på Khan Academy.

00:01:02.729 --> 00:01:05.339
Men - du kan også lave
dine egne funktioner

00:01:05.339 --> 00:01:08.409
til brug i dine programmer.

00:01:08.409 --> 00:01:11.430
For eksempel - lad os sige
at vi laver et program,

00:01:11.430 --> 00:01:14.434
og gerne vil tegne Winston
flere gange -

00:01:14.434 --> 00:01:17.017
måske fordi vi vil fortælle
Winstons livshistorie

00:01:17.017 --> 00:01:20.190
og vise de forskellige aldre
gennem hans liv. 

00:01:20.190 --> 00:01:24.243
Her er hvad vores Winston
tegne-kode kunne starte med:

00:01:24.243 --> 00:01:27.106
Vi har variablene
'faceX' og 'faceY

00:01:27.106 --> 00:01:29.029
til at gemme centrum
af ansigtet

00:01:29.029 --> 00:01:31.243
og så tegner vi øjnene
og munden

00:01:31.243 --> 00:01:33.039
relativt til de variable.

00:01:33.039 --> 00:01:34.732
Lige nu ser
programmet koden,

00:01:34.732 --> 00:01:37.325
og det er ikke inde i en funktion,
så det bliver bare kørt,

00:01:37.325 --> 00:01:39.739
og det bliver kun kørt en gang.

00:01:39.739 --> 00:01:43.717
OK, lad os gøre det til en funktion.

00:01:43.717 --> 00:01:46.439
Dette gøres lidt på samme måde

00:01:46.439 --> 00:01:48.487
som vi erklærer en variabel,
fordi det er faktisk

00:01:48.487 --> 00:01:50.245
hvad vi gør.

00:01:50.245 --> 00:01:52.077
Så vi siger 'var drawWinston'.

00:01:52.077 --> 00:01:54.551
Vi giver det et godt navn,
meget beskrivende,

00:01:54.551 --> 00:01:59.037
og så '=', men her
i stedet for at skrive et tal eller en tekststreng,

00:01:59.037 --> 00:02:02.721
skal vi skrive 'function'
(vær sikker på at stave det korrekt)

00:02:02.721 --> 00:02:08.357
og så tomme parenteser '()'
og så en krøllet startparantes '{'

00:02:08.357 --> 00:02:11.563
og så en krøllet slutparantes '}'
og vores semikolon ';'

00:02:11.563 --> 00:02:14.490
OK så det vi skal gøre
er at putte alt

00:02:14.490 --> 00:02:19.454
som vi vil have i vores funktion
mellem den krøllede start og slut parentes 

00:02:19.454 --> 00:02:22.130
Så vi skal tage alt
koden her,

00:02:22.130 --> 00:02:26.816
og putte det i vores funktion
(indenter det pænt) og Ta Da!

00:02:26.816 --> 00:02:28.970
Så det vi har nu
er denne variabel

00:02:28.970 --> 00:02:32.379
der gemmer en funktion -
så vi har principielt

00:02:32.379 --> 00:02:35.759
en mærkat til denne kodeblok,
sådan at vi når som helst

00:02:35.759 --> 00:02:37.859
kan sige til vores program,

00:02:37.859 --> 00:02:40.765
"Hey, find den kodeblok med
denne mærkat og kør det!"

00:02:40.765 --> 00:02:43.551
Vi gør at dette stykke kode
kan genbruges.

00:02:43.551 --> 00:02:46.535
Men nu kan vi se,
at der ikke er nogen Winston længere!

00:02:46.535 --> 00:02:49.357
Vi har mistet Winston!
Hvor mon han blev af?

00:02:49.357 --> 00:02:53.025
OK - så det der skete er
da vi puttede det ind i en funktion,

00:02:53.025 --> 00:02:55.907
fortalte vi vores program
"hey her er en bunke kode

00:02:55.907 --> 00:02:57.842
som jeg vil kunne
køre senere,

00:02:57.842 --> 00:03:00.807
men kun når jeg SIGER at du skal køre det"

00:03:00.807 --> 00:03:04.288
Så vi skal bede det køre koden,
hvilket betyder at vi skal

00:03:04.288 --> 00:03:09.110
'call' funktionen - lige som vi gjorde
med ellipse() og rect() og line().

00:03:09.400 --> 00:03:13.753
Så vi skriver bare
funktions navnet ('drawWinston')

00:03:13.753 --> 00:03:16.376
efterfulgt af vores start
og slut paranteser '()'

00:03:16.376 --> 00:03:18.959
og, selvfølgelig, vores semikolon,
og Ta Da -

00:03:18.959 --> 00:03:20.942
Vi har en Winston!

00:03:20.942 --> 00:03:24.237
OK! Jeg syntes det er sejt,
men det kan være at du ikke syntes det er så sejt

00:03:24.237 --> 00:03:27.373
fordi at alt hvad vi gjort,
er at få vores program til at gøre

00:03:27.373 --> 00:03:30.239
præcis hvad det gjorde før.
Lidt fjollet, hva'?

00:03:30.239 --> 00:03:32.920
Hele pointen med funktioner
er at vi kan genbruge dem

00:03:32.920 --> 00:03:34.957
Så lad os gøre det nu.

00:03:34.957 --> 00:03:41.162
Vi kan bare klippe-klistre funktionen
kaldet "ta da!" "ta da!" igen og igen

00:03:41.162 --> 00:03:46.572
Hmmm, men det ser ens ud -
- jamen - det virkede -

00:03:46.572 --> 00:03:48.998
det tegner flere Winstons,
men problemet

00:03:48.998 --> 00:03:51.474
er at de alle er det samme sted.

00:03:51.474 --> 00:03:54.428
Hvis vi havde røntgen syn,
kunne vi røntgen syne tegneområdet

00:03:54.428 --> 00:03:57.631
og se tre Winstons,
men jeg har ikke røntgen syn,

00:03:57.631 --> 00:04:00.334
(jeg ved ikke med dig).

00:04:00.334 --> 00:04:03.440
Men, vi kan lave en lille ændring
af vores funktion

00:04:03.440 --> 00:04:05.486
der VIL gøre det tydeligt.

00:04:05.486 --> 00:04:08.825
Ser du, faceX og faceY -
de er altid 202 og 208?

00:04:08.825 --> 00:04:11.587
Vi kan ændre det
ved at bruge random() funktionen -

00:04:11.587 --> 00:04:14.849
- lad os sige random() fra 50 til 350
og det vil generere

00:04:14.849 --> 00:04:19.183
et tilfældigt tal mellem disse to -
og vi kan gøre det samme her -

00:04:19.183 --> 00:04:23.023
så hver gang funktionen bliver kaldt,
genererer den et nyt tilfældigt tal,

00:04:23.023 --> 00:04:26.566
og hvis vi trykker genstart,
kan vi fortæt få tilfældige Winstons.

00:04:26.566 --> 00:04:29.359
SÅ sejt!
Wohoo!!

00:04:29.359 --> 00:04:32.095
Okay - altså jeg syntes det er sejt
fordi det kunne have

00:04:32.095 --> 00:04:34.916
taget en masse kode at skrive dette
hvis vi ikke havde det i en funktion,

00:04:34.916 --> 00:04:38.317
Det ville have været
tre gange så meget kode.

00:04:38.317 --> 00:04:40.960
Men det ville ikke have været
SÅ brugbart som det kunne have været

00:04:40.960 --> 00:04:43.796
fordi vi sikkert
ikke vil have tilfældige Winstoner.

00:04:43.796 --> 00:04:45.736
Vi vil nok gerne kunne
give Winston

00:04:45.736 --> 00:04:47.846
en specifik position på skærmen.

00:04:47.846 --> 00:04:49.943
Så bliv hængende, for' vi vil snakke
om at give paramtere

00:04:49.943 --> 00:04:52.483
til vores funktioner,
så du kan

00:04:52.000 --> 00:04:56.000
gøre præcis det.