Nu då vi vet att varje Scheme-sats omsluts av parenteser, och att funktionsnamnet/operatorn listas först, behöver vi veta hur vi skapar och använder variabler, och hur vi skapar och använder funktioner. Vi börjar med variablerna.
Även om det finns några olika metoder för att deklarera variabler så är den föredragna metoden att använda konstrukten let*. Om du är bekant med andra programspråk så är denna konstrukt ekvivalent med att definiera en lista med lokala variabler och en räckvidd i vilken de är aktiva. För att exempelvis deklarera två variabler, a och b, initierade till 1 respektive 2, skulle du skriva:
(let* ( (a 1) (b 2) ) (+ a b) )
eller som en rad:
(let* ( (a 1) (b 2) ) (+ a b) )
![]() |
Notera |
---|---|
Du kommer behöva stoppa allt detta på en rad om du använder konsolfönstret. Allmänt kommer du dock vilja adoptera en liknande indentering för att hjälpa till göra dina skript mer läsliga. Vi kommer prata lite mer om detta i avsnittet om blanktecken. |
Detta deklarerar två lokala variabler, a och b, initierar dem, och skriver sedan ut summan av de två variablerna.
Du kommer se att vi skrev summeringen (+ a b)
inuti parenteserna för let*
-uttrycket, inte efter det.
This is because the let*
statement defines an area in your script in which the declared
variables are usable; if you type the (+ a b)
statement after the (let* …)
statement,
you'll get an error, because the declared
variables are only valid within the context of the let*
statement; they are what programmers call local variables.
Den allmänna formen för en let*
-sats är:
(let* (variabler
)uttryck
)
where variables are declared within parens, e.g.,
(a 2)
, and
expressions are any valid Scheme expressions. Remember that the
variables declared here are only valid within the
let*
statement — they're local variables.
Previously, we mentioned the fact that you'll probably want to use indentation to help clarify and organize your scripts. This is a good policy to adopt, and is not a problem in Scheme — white space is ignored by the Scheme interpreter, and can thus be liberally applied to help clarify and organize the code within a script. However, if you're working in Script-Fu's Console window, you'll have to enter an entire expression on one line; that is, everything between the opening and closing parens of an expression must come on one line in the Script-Fu Console window.
När du har initierat en variabel kan du senare behöva ändra dess värde i skriptet. Använd satsen set!
för att ändra variabelns värde:
(let* ( (theNum 10) ) (set! theNum (+ theNum theNum)) )
Försök gissa vad satsen ovan kommer göra, och mata sedan in den i Script-Fu-konsolfönstret.
Nu då du har koll på variabler ska vi börja arbeta med några funktioner. Du deklarerar en funktion med följande syntax:
(define (namn
param-lista
)uttryck
)
där namn
är namnet som denna funktion tilldelas, param-lista
är en blankstegsseparerad lista över parameternamn, och uttryck
är en serie uttryck som funktionen exekverar när den anropas. Till exempel:
(define (AddXY inX inY) (+ inX inY) )
AddXY
är funktionens namn och inX
samt inY
är variablerna. Denna funktion tar sina två parametrar och adderar dem.
Om du programmerat i andra imperativa språk (som C/C++, Java, Pascal och så vidare), så kanske du lägger märke till att några saker saknas i denna funktionsdefinition i jämförelse med andra programspråk.
Notera först att parametrarna inte har några ”typer” (det vill säga, vi deklarerade dem inte som strängar, heltal och så vidare.). Scheme är ett typlöst språk. Detta är praktiskt och tillåter snabbare skriptskrivande.
Second, notice that we don't need to worry about how to ”return” the result of our function — the last statement is the value ”returned” when calling this function. Type the function into the console, then try something like:
(AddXY (AddXY 5 6) 4)