# &kturtle;'s &logo; programmeringsreference

Dette er en reference til &kturtle;s &logo;. I dette kapitel næver vi kort alle forskellige instruktionstyper. Derefter forklares alle kommandoer i en af gangen. Herefter følger forklaringer af beholdare, math, spørgsmål og kommandoer til at styre kørslen. Tilsidst vises hvordan du kan oprette dine egne kommandoer med learn.

## Forskellige instruktionstyper

Som i alle sprog har Logo forskellige typer af ord og symboler. Her forklares kortfattet forskellen mellem typerne.

### Kommandoer

Ved brug af kommandoerne beder du &kturtle; om at gøre noget. Nogle kommandoer har brug for inddata, nogle giver uddata.

    # forward er en kommando som behøver inddata, i dette tilfælde tallet 100:
    forward 100

For en detaljeret oversigt over alle kommandoer som &kturtle; understøtter, se her.

### Tal

Formodentlig ved du allerede en hel del om tal. Måden som tal bruges i &kturtle; er ikke særlig anderledes end i sprog eller matematik.

Vi har de såkaldte naturlige tal: `0`, `1`, `2`, `3`, `4`, `5`, osv. De negative tal: `-1`, `-2`, `-3`, osv. Og tal med decimaler eller decimaltal, for eksempel: `0,1`, `3,14`, `33,3333`, `-5,05`, `-1,0`.

Tal kan bruges i matematiske beregninger og spørgsmål. De kan også placeres i containere.

Tal er fremhævede med blåt i kodeditoren.

### Strenge

Først et eksempel:

    skriv "Goddag, jeg er en streng."

I dette eksemplet er `print` en kommando, mens `"Goddag, jeg er en streng."` er en streng. Strenge begynder og slutter med tegnet `"`. Det er disse tegn som gør at &kturtle; véd at det er en streng.

Strenge kan placeres i containere, men de kan ikke bruges i matematiske beregninger eller i spørgsmål.

Strenge fremhæves med mørkerødt i kodeditoren.

### Navne

Når du bruger programsproget &logo; laver du nye ting. Hvis du skriver et program har du ofte brug for containere og sommetider har du brug for learn for at oprette nye kommandoer. Når du laver en container eller en ny kommando med learn skal du angive et navn.

Du kan vælge et hvilket som helst navn, under forudsætning af at det ikke allerede har en betydning. Du kan for eksempel ikke navngive en container forward, eftersom dette navn allerede bruges til en kommando, og allerede har en betydning.

    # Her bruges forward som en container, men det har allerede en betydning,
    # altså forårsager dette et fejl:
    forward = 20

    # Dette virker:
    forward 20

Navne kan kun indeholde bogstaver, tal og understregninger (_), og de skal begynde med et bogstav.

Læs gerne dokumentationen om containere og kommandoen learn for en bedre forklaring og flere eksempler.

### Tilknytninger

Tilknytninger udføres med tegnet `=`. I programmeringssprog er det bedre ikke at udtale et enkelt `=` som 'er lig med' men som 'bliver'. Udtrykket 'er lig med' er m ere passende for `==`, som er et spørgsmål.

Tilknytninger bruges i almindelighed af to grunde: (1) for at tilføje indhold til containere, og (2) for at ændre indholdet i en beholder. For eksempel:

    x = 10
    # Containeren x indeholder nu tallet 10.
    W = "Min alder er: "
    # Containeren W indeholder nu "Min alder er: ".
    # Dette udskriver ud containerne 'W' og 'x' på kanvassen
    print W + x

For flere eksempler, se afsnittet om containere.

### Matematiske symboler

&kturtle; understøtter alle grundlæggende matematiske symboler: addere (`+`), subtrahere (`-`), multiplicere (`*`), dividere (`/`) og parenteser `(` og `)`.

For en fuldstændig forklaring og flere eksempler, se afsnittet om matematiske beregninger.

### Spørgsmål

Vi kan stille enkle spørgsmål hvor svaret er 'sand' eller 'falsk'.

At bruge spørgsmål beskrives udførligt i afsnittet om spørgsmål.

### Spørgsmål klister-ord

Spørgsmål kan klistres sammen med såkaldte 'klisterord'. Klisterordene er `og`, `eller`, og det specielle klisterord `ikke`.

Brug af klisterord i spørgsmål forklares i afsnittet om klisterord i spørgsmål.

### Kommentarer

Kommentarer er linjer som begynder med tegnet `#`. For eksempel:

    # Dette er en kommentar!
    print "Dette er ikke en kommentar"
    # Foregående linje er ikke en kommentar, men den næste linje er det:
    # print "Dette er ikke en kommentar"

Vi kan tilføje kommentarer til koden, som vi selv og andre kan læse. Kommentarer bruges for at: (1) tilføje en kort beskrivelse af programmet, (2) forklare hvordan et kodeafsnit virker hvis det er svært at forstå, og (3) til at 'kommentere væk' kodelinjer som (midlertidigt) skal ignoreres (se sidste linje i eksemplet).

Kommentarlinjer er fremhævede med mørkegult i kodeditoren.

## Kommandoer

Ved brug af kommandoerne beder du &kturtle; om at gøre noget. Nogle kommandoer har brug for inddata, nogle giver uddata. I dette afsnit forklarer vi alle kommandoerne der kan bruges i &kturtle;. Bemærk venligst at alle indbyggede kommandoer som vi diskuterer her er fremhævede med mørkegrønt i kodeeditoren. Dette kan hjælpe dig med at se dem.

### Flyt skildpadden

Der er adskillige kommandoer til at flytte skildpadden rundt på skærmen.

#### forward (fw)

forward

-     forward X

  `forward` flytter skildpadden X pixels fremad. Når pennen er nede vil skildpadden efterlade et spor. `forward` kan forkortes til `fw`

#### backward (bw)

backward

-     backward X

  `backward` flytter skildpadden X pixels tilbage. Når pennen er nede vil skildpadden efterlade et spor. `backward` kan forkortes til `bw`

#### turnleft (tl)

turnleft

-     turnleft X

  `turnleft` beder skildpadden om at dreje X grader til venstre. `turnleft` kan forkortes til `tl`.

#### turnright (tr)

turnright

-     turnright X

  `turnright` beder skildpadden om at dreje X grader til højre. `turnleft` kan forkortes til `tr`.

#### direction (dir)

direction

-     direction X

  `direction` sætter skildpaddens retning til X grader talt ud fra nul, og således ikke relativ til skildpaddens tidligere retning. `direction` kan forkortes til `dir`.

#### center

center

-     center

  `center` flytter skildpadden til centrum for kanvassen.

#### go

go

-     go X,Y

  `go` beder skildpadden om at gå til et betsemt sted på kanvassen. Dette sted er X pixels fra venstre side af kanvassen, og Y pixels fra toppen af kanvassen. Bemærk at ved brug af `go` kommandoen vil skildpadden ikke tenge en linje.

#### gox

gox

-     gox X

  `gox` brug af denne kommando vil få skildpadden til at flytte til X pixels fra venstre side af kanvassen mens den forbliver på samme højde.

#### goy

goy

-     goy Y

  `goy` brug af denne kommando vil få skildpadden til at flytte til X pixels fra toppen af kanvassen mens afstanden til venstre side er uforandret.

### Skildpadden har en pen

Skildpadden har en pen, der tegner en linje når skildpadden flyttes. Der er nogle få kommandoer til at kontrollere pennen. I dette afsnit forklarer vi disse kommandoer.

#### penup (pu)

penup

-     penup

  `pendown` trykker pennen ned på kanvassen. Når pennen er down på kanvassen vil en linje blive tegnet når skildpadden bevæger sig. Se også `penup`.

#### pendown (pd)

pendown

-     pendown

  `pendown` trykker pennen ned på kanvassen. Når pennen er down på kanvassen vil en linje blive tegnet når skildpadden bevæger sig. Se også `penup`. `pendown` kan forkortes til `pd`.

#### penwidth (pw)

penwidth

-     penwidth X

  `penwidth` sætter pennens bredde (linjebredden) til mængden X pixels. `penwidth` kan forkortes til `pw`.

#### pencolor (pc)

pencolor

-     pencolor R,G,B

  `pencolor` sætter pennens farve. `pencolor` tager en RGB kombination som inddata. `pencolor` kan forkortes til `pc`.

### Kommandoer til at kontrollere kanvassen

Der er adskillige kommandoer til at kontrollere kanvassen.

#### canvassize (cs)

canvassize

-     canvassize X,Y

  Med kommandoen `canvassize` kan du sætte størrelsen af kanvassen. Den tager X og Y som inddata, hvor X er den nye kanvas' bredde i pixels, og Y den nye højde for kanvassen i pixels. `canvassize` kan forkortes til `cs`.

#### canvascolor (cc)

canvascolor

-     canvascolor R,G,B

  `canvascolor` sætter farven for kanvassen. `canvascolor` tager en RGB combination som inddata. `canvascolor` kan forkortes til `cc`.

#### wrapon

wrapon

-     wrapon

  Med kommandoen `wrapon` kan du slå ombrydning til for kanvassen. Se venligst ordforklaringen hvis du ønsker at vide hvad ombrydning er.

#### wrapoff

wrapoff

-     wrapoff

  Med kommandoen `wrapoff` kan du slå ombrydning fra for kanvassen. Dette betyder at skildpadden kan flytte væk fra kanvassen og fare vild. Se venligst ordforklaringen hvis du ønsker at vide hvad ombrydning er.

### Kommandoer til at rydde op

Der er to kommandoer til at rydde op på kanvassen efter du har rodet.

#### clear (cr)

clear

-     clear

  Med `clear` kan du rydde alle tegninger væk fra kanvassen. Alt andet forbliver: positionen og vinklen for skildpadden, kanvasfarven, skildpaddens synlighed og kanvassens størrelse. `clear` kan forkortes til `cr`.

#### reset

reset

-     reset

  `reset` rydder meget mere gennemgribende op end kommandoen `clear`. Efter en `reset` kommando er alt som lige efter du netop startede &kturtle;. Skildpadden er lige i midten af skærmen, kanvasfarven er hvis og skildpadden tegner en sort linje på kanvassen.

### Skildpadden er en sprite

Først en kort forklaring af hvad en sprite er: en sprite er et lille billede der kan flyttes rundt på skærmen, ligesom vi man ofte ser i computer-spil. For mere info se ordforklaringen om sprite).

Herefter vil du finde et fuldt overblik over alle kommandoer til at arbejde med sprite.

[Denne udgave af &kturtle; understøtter endnu ikke brugen af sprite bortset fra skildpadden. I fremtidige udgaver vil du kunne ændre skildpadden til noget du selv har designet.]

#### show

show (ss)

-     show

  `show` gør skildpadden synlig igen efter den har været skjult. `show` kan forkortes til `ss`.

#### hide (sh)

hide

-     hide

  `hide` skjuler skildpadden. Dette kan bruges hvis skildpadden ikke passer ind i din tegning. `hide` kan forkortes til `sh`.

### Kan skildpadderne skrive?

Svaret er: ja. Skildpaddenkan skrive, han skiver næsten alt det du beder den om at skrive.

#### print

print

-     print X

  `print`-kommandoen bruges til atbede skildpadden om at skrive noget på kanvassen. `print` tager tal og strenge som inddata. Du kan `print` forskellige tal og strenge ved at bruge +-symbolet. Se et lille eksempel her:

      year = 2003
      author = "Cies"
      print author + " startede KTurtle-projektet i " + year + " og nyder stadig at arbejde med det!"

#### fontsize

fontsize

-     fontsize X

  `fontsize` sætter skriftens størrelse der bruges af `print`. `fontsize` tager inddata der skal være et tal. Størrelsen sættes i pixels.

### En kommando der ruller en terning for dig

Der er en kommando som ruller terninger for dig. Den kaldes `random`, og er meget nyttig til at få uforudsete resultater.

tilfældig

-     random X,Y

  `random` er en kommando der bruger inddata og giver uddata. Som inddata kræves to tal, det første (X) sætter minimum for uddata, det andet (Y) sætter maksimum. Uddata er et tilfældigt valgt tal der er større end eller lig med minimum og mindre end eller lig med maksimum. Her er el lille eksempel:

            repeat 500 [
              x = random 1,20
              forward x
              turnleft 10 - x
            ]

  Brug af random-kommandoen kan tilføje lidt kaos til dit program.

### Input og tilbagemelding gennem dialoger

En dialog er et lille vindue der giver noget tilbagemelding eller beder om noget input. &kturtle; har to kommandoer for dialoger, nemlig: `message` og `inputwindow`

#### message

message

-     message X

  `message`-kommandoen tager en streng som input. Den viser en dialog der indeholder teksten fra strengen.

      year = 2003
      author = "Cies"
      print author + " startede KTurtle-projektet i " + year + " og nyder stadig at arbejde med det!"

#### inputwindow

inputwindow

-     inputwindow X

  `inputwindow` tager en streng som input. Det viser en dialog der indeholder teksten fra strengen, ligesom message. Men derudover er der også et inddatafelt i dialogen. Gennem dette inddatafelt kan brugeren indtaste et tal eller en streng som kan opbevares i en container. For eksempel

      in = inputwindow "Hvor gammel er du?"
      out = 2003 - in
      print "I 2003 var du " + out + " år gammel på et tidspunkt."

  Når en bruger annullere dialogen, eller ikke indtaster noget over hovedet, bliver containeren tømt.

## Containere

Containere er bogstaver eller ord der kan bruges af programmører til at opbevare et tal eller en tekst. Containere der indeholder et tal kaldes variabler, containere der indeholder tekst kaldes streng.

Containere der ikke bruges indeholder ingenting. Et eksempel:

    print N

Dette vil ingenting udskrive. Hvis vi prøver at udføre math med tomme containere vil vi få fejl.

### Variabler: antal containere

Lad os starte med et eksempel:

    x = 3
    print x

I den første linje gøres bogstavet `x` til en variable (tal-container). Som du ser bliver værdien af den variable `x` sat til 3. På den anden linje bliver værdien udskrevet.

Bemærk at hvis vi ønskede at udskrive et x så skulle vi have skrevet

    print "x"

Det var nemt, nu til et lidt sværere eksempel:

    A = 2004
    B = 25
    C = A + B

    # den næste kommando udskriver "2029"
    print C
    backward 30
    # den næste kommando udskriver "2004 plus 25"
    print A + " plus " + B
    backward 30
    # den næste kommando udskriver "1979"
    print A - B

I de første to linjer bliver variablerne `A` og `B` sat til 2004 og 25. På den tredje linje bliver variablen `C` sat til `A + B`, som er 2029. Resten af eksemplet består af 3 `print` kommandoer med `backward 30` imellem. `backward 30` er der for at sørge for at hvert uddata er på en ny linje. I dette eksempel ser du også at variabler kan bruges i matematiske beregninger.

### Containere som indeholder tekst (strenge)

I programkode indledes og afsluttes almindelig tekst med citationstegn. Som vi allerede har set:

    skriv "Hej, programmør!"

Den almindelige tekst afgrænses af citationstegn. Denne almindelige tekst kalder vi en streng.

Strenge kan også opbevares i containere ligesom talStrenge er meget ligesom variabler. Den største forskel er at de indeholder tekst i stedet for tal. Derfor kan strenge ikke bruges i matematiske beregninger og spørgsmål. Et eksempel på brugen af strenge:

    x = "Goddag "
    name = inputwindow "indtast venligst dit navn..."
    print x + name + ", hvordan går det?"

I den første linje sættes strengen `x` til Goddag. I den anden linje sættes strengen `name` til uddata fra `inputwindow` kommandoen. På den tredje linje udskriver programmet en komposition af tre strenge på kanvassen.

Dette program beder dig om at indtaste dit navn. Når du for eksempel indtaster navnet Jesper, udskriver programmet Goddag Jesper, hvordan går det?. Bemærk venligst at plusset (+) er det eneste matematiske symbol du kan bruge med strenge.

## Kan skildpadden lave matematik?

Ja, &kturtle; kanlave matematik for dig. Du kan lægge sammen (+), trække fra (-), gange (*) og dividere (/). Her er et eksempel hvori vi bruger dem allesammen:

    a = 20 - 5
    b = 15 * 2
    c = 30 / 30
    d = 1 + 1
    print "a: "+a+", b: "+b+", c: "+c+", d: "+d

Ved du hvilken værdi a, b, c og d har? Bemærk venligst brugen af tilknytningssymbolet `=`.

Hvis du blot ønsker at en simpel beregning skal udføres kan du gøre noget i retning af dette:

    print 2004-12

Nu et eksempel med parenteser:

    print ( ( 20 - 5 ) * 2 / 30 ) + 1

Det der er imellem parenteserne vil blive beregnet først. I dette eksepel, bliver 20-5 beregnet, så ganget med 2, divideret med 30, og derpå adderes 1 (hvilket giver 2).

## Stille spørgsmål, få svar...

`if` og `while` er udførselskontroller som vi vil diskutere i næste afsnit. I dette afsnit bruger vi `if`-kommandoen til at forklare spørgsmål.

### Spørgsmål

Et simpelt eksempel på et spørgsmål:

    x = 6
    if x > 5 [
      print hello
    ]

I dette eksempel er spørgsmålet `x > 5`, hvis svaret på dette spørgsmål er 'sand' så vil koden mellem parenteserne blive udført. Spørgsmål er en vigtig del af programmering og bruges ofte sammen med udførselskontroller, såsom `if`. Alle tal og variabler (tal-containere) kan sammenlignes med hianden med spørgsmål.

Her er alle mulige spørgsmål:

### Typer af spørgsmål

`a == b` | er lig med | svaret er sand hvis `a` er lig med `b`
`a != b` | ikke lig med | svaret er sand hvis `a` ikke er lig med `b`
`a > b` | større end | svaret er sand hvis `a` er større end `b`
`a < b` | mindre end | svaret er sand hvis `a` er mindre end `b`
`a >= b` | større end eller lig med | svaret er sand hvis `a` er større end eller lig med `b`
`a <= b` | mindre end eller lig med | svaret er sand hvis `a` er mindre end eller lig med `b`

Spørgsmål er fremhævede med lyseblåt i kodeditoren.

### Spørgsmålsklister

Spørgsmålenes klisterord kan få nogle spørgsmål til at blive til et stort spørgsmål.

    a = 1
    b = 5
    if a < 5 and b == 5 [
      print goddag
    ]

I dette eksempel bliver klister-ordet `and` brugt til at klistre 2 spørgsmål (`a < 5`, `b == 5`) sammen. Hvis en side af `and` vil svare 'falsk' så vil hele spørgsmålet svare 'falsk', fordimed klister-ordet `and` skal begge sider være 'sand' for at svare 'sand'. Glem endelig ikke parenteser rundt om spørgsmålene!

Her er en skematisk oversigt, en mere detaljeret forklaring følger nedenfor:

### Spørgsmål klister-ord

`and` | Begge sider skal være 'sande' for at svaret er 'sand'
`or` | Hvis en af siderne er 'sand' så er svaret 'sand'
`not` | Specialtilfælde: virker kun for et spørgsmål. Ændrer 'sand' til 'falsk' og 'falsk' til 'sand'.

Klisterord i spørgsmål er fremhævede med violet i kodeditoren.

#### and

Når to spørgsmål klistres sammen med `og` skal begge sider af `og` være 'sande' for at resultatet skal være 'sandt'. Et eksempel:

    a = 1
    b = 5
    if ((a < 10) and (b == 5)) and (a < b) [
      print "Hej"
    ]

I dette eksempel ser du et spørgsmål klistret sammen med et andet spørgsmål.

#### or

Hvis et af de to spørgsmål som klistres sammen med `eller` er 'sandt' er resultatet 'sandt'. Et eksempel:

    a = 1
    b = 5
    if ((a < 10) or (b == 10)) or (a == 0) [
      print "Hej"
    ]

I dette eksempel ser du et spørgsmål klistret sammen med et andet spørgsmål.

#### not

`not` er et specielt klisterord i spørgsmål eftersom det kun virker med et spørgsmål af gangen. `not` ændrer 'sand' til 'falsk' og 'falsk' til 'sand'. Et eksempel:

    a = 1
    b = 5
    if not ((a < 10) and (b == 5)) [
      print "Goddag"
    ]
    else
    [
      print "Farvel"
    ]

I dette eksempel er det sammenklistrede spørgsmål 'sandt', men `not` ændrer det til 'falsk'. Altså skrives `"Farvel"` ud på kanvassen.

## Udførselskontrol

Udførselskontrol gør dig i stand til — som navnet antyder — at kontrollere udførslen.

Kommandoer til at styre kørslen fremhæves med mørkegrønt og fed type. Kantede parenteser bruges som oftest sammen med kommandoer til at styre kørslen, og de er fremhævet med lysegrønt.

### Lad skildpadden vente

Hvis du har prøvet at programmere noget i &kturtle; har du måske bemærket at skildpadden kan være meget hurtig til at tegne. Denne kommando får skildpadden til at vente et givet stykke tid.

wait

-     wait X

  `wait` lader skildpadden vente i X sekunder.

            repeat 36 [
              forward 5
              turnright 10
              wait 0.5
            ]

  Denne kode tegne en cirkel, men skildpadden vil vente et halvt sekund ved hvert skridt. Dette giver indtrykket af en skildpadde der bevæger sig langsomt.

### Udfør "if"

if

-     if spørgsmål [ ... ]

  Koden der er placeret på ... vil kun blive udført hvis altså `if` svaret på spørgsmålet er sand. Læs venligst mere om spørgsmål i spørgsmålsafsnittet.

            x = 6
            if x > 5 [
              print "x er større end fem!"
            ]

  På første linje sættes `x` til 6. På den anden linje stilles spørgsmålet `x > 5`. Da svaret på dette spørgsmål er sand vil udførselskontrollen `if` tillade koden mellem parenteserne at blive udført

### "while"-løkken

while

-     while spørgsmål [ ... ]

  Udførselskontrollen `while` er meget lige som `if`. Forskellen er at `while` bliver ved med at gentage (gå i løkke) koden mellem parenteserne indtil svaret på spørgsmålet er falsk.

            x = 1
            while x < 5 [
              forward 10
              wait 1
              x = x + 1
            ]

  På den første linje sættes `x` til 1. På den anden linje stilles spørgsmålet `x < 5`. Da svaret på dette spørgsmål er sand starter udførselskontrollen `while` udførslen af koden mellem parenteserne indtil svaret på spørgsmålet er falsk. I dette tilfælde vil koden mellem parenteserne blive udført 4 gange, fordi hver gang den femte linje udføres bliver `x` en større.

### Hvis ikke, så med andre ord ellers: "else"

else

-     if spørgsmål [ ... ] else [ ... ]

  `else` kan yderligere bruges i udførselskontrollen `if`. Koden mllem parenteserne efter `else` udføres kun hvis svaret på spørgsmålet der stilles er falsk.

      reset
      x = 4
      if x > 5 [
        print "x er større end fem!"
      ]
      else
      [
        print "x er mindre end seks!"
      ]

  Der spørges om `x` er større end 5. Idet `x` er sat til 4 på den første linje er svaret på spørgsmålet falsk. Dette betyder at koden mellem parenteserne efter `else` bliver udført.

### "for" løkken, en tælleløkke

for

-     for startpunkt til slutpunkt [ ... ]

  `for` løkken er en tælleløkke, den tæller for dig.

            for x = 1 to 10 [
              print x * 7
              forward 15
            ]

  Hver gang koden mellem parenteserne udføres bliver `x` et tal større, indtil x når tallet 10. Koden mellem parenteserne udskriver `x` ganget med 7. Efter dette program er færdigt vil du se syv-tabellen på kanvassen.

## Lav dine egne kommandoer med learn

`learn` er en meget speciel kommando, fordi den bruges til at lave dine egne kommandoer. Kommandoen du laver kan tage inddata og give uddata tilbage. Lad os kigge på hvordan en ny kommando laves.

    learn circle x [
      repeat 36 [
        forward x
        turnleft 10
      ]
    ]

Den nye kommando hedder `circle`. `circle` tager en inddata, et tal, til at sætte cirklens størrelse. `circle` giver ingen uddata. `circle` kommandoen kan nu bruges ligesom en normal kommando i resten af koden. Se dette eksempel:

    learn circle X [
      repeat 36 [
        forward X
        turnleft 10
      ]
    ]

    go 30,30
    circle 20

    go 40,40
    circle 50

I det næste eksempel vil en kommando med en returværdi blive lavet.

    reset

    learn multiplyBySelf n [
      r = n * 1
      r = n * n
      return r
    ]
    i = inputwindow "Indtast venligst et tal og tryk på o.k."
    print i + " ganget med sig selv er: " + multiplyBySelf i

I dette eksempel laves en ny kommando der hedder `multiplyBySelf`. Inddata for denne kommando bliver ganget med sig selv og derefter returneret, ved brug af `return` kommandoen. `return` kommandoen er måden at få uddata fra en hjemmelavet funktion.