Nei programmi che abbiamo scritto fin ora manca una parte fondamentale della computazione. Al momento è stata tutta una questione di elaborazione di dati attraverso delle istruzioni. Nel mondo dei buggle i dati principali sono nascosti dietro una rappresentazione grafica ma non ci sono ragioni per evitare di manipolare i dati esplicitamente.
In un programma potete usare diversi tipi di dati, come numeri interi o stringhe di caratteri. Se volete utilizzare un dato più volte avete bisogno di memorizzarlo all'interno di una variabile che è una cella di memoria contenente un valore: mettete il vostro dato (diciamo il valore '5') nella variabile (diciamo 'lunghezza') e potrete recuperarlo più tardi, quando vi occorrerà. Questo è molto simile ad una scatola con l'etichetta 'regalo' in cui volete mettere alcune cose, come una bottiglia di profumo "Channel N°5".
Dichiarare (o anche creare) una variabile in [!thelang] è molto
semplice. Dovete semplicemente scrivere [!java]il suo tipo, uno spazio ed il
nome della variabile.[/!] [!scala]la parola chiave var
, il nome
della variabile, i duepunti (:) ed il tipo della variabile seguito da un
uguale (=) e un valore iniziale.[/!] [!python]il nome della variabile, il
simbolo uguale (=) e un valore iniziale.[/!] Il nome della variabile è
l'etichetta che serve a recuperare successivalemente il
dato[!python].[/!][!java|scala], mentre il suo tipo è la categoria di dati
che la variabile accetta.[/!] È proibito utilizzare spazi nei nomi delle
variabili. Potete chiamare una variabile passiTotali
se volete
ma passi totali
non è un nome valido.
Quindi, per creare una variabile chiamata x destinata a contenere numeri interi, bisognerebbe scrivere:
int x;
Se volete potete specificare il valore iniziale della variabile aggiungendo dopo la dichiarazione un segno uguale (=) seguito dal valore.
int x=5;[/!] [!python]
So, if you want that the variable contains 5 as initial value, you should type:
x = 5[/!] [!scala]
Quindi, per creare una variabile chiamata x destinata a contenere interi con 42 come valore iniziale, dovreste scrivere:
var x:Int = 42
In molti casi il computer è capace di intuire il tipo di variabile dal suo valore iniziale e voi potete evitare di specificarlo:
var x = 42
You still have to specify if you use some generic values as an
initialization, such as the very particular value null
, which
type happens to be ambiguous. Even when the type is clear, you can still
specify it if you prefer. So you want that the variable contains 5 as
initial value, you should type:
var x: Int = 5 // Posso specificare il tipo se voglio var y = 10 // oppure ometterlo a mia scelta[/!] [!java|scala|c]
Come potete vedere, in [!thelang] le variabili sono tipizzate, che significa che sono in qualche modo specializzate: Una data variabile può immagazzinare esclusivamente dati di un solo tipo; Non pensateci minimamente di memorizzare numeri in una variabile destinata alle lettere! Si dice quindi che il linguaggio [!thelang] è staticamente tipizzato.
Altri linguaggi (come il Python) sono meno esigenti e permettono di immagazzinare qualsiasi tipo di dato nelle variabili senza constrizioni (questi linguaggi vengono definiti dinamicamente tipizzati). Ad una prima occhiata questa sembra una banalità ma permette al compilatore di generarvi più errori logici, che potrebbe anche essere un bene. In un certo senso Python è più facile da scrivere ma gli errori possono occultarsi più facilmente che in [!thelang].
Ci sono diversi tipi esistenti in [!thelang]:
Come potete vedere le variabili in Python non sono tipizzate, che significa che non sono specializzate in nessun tipo di dato. Una data variabile può immagazzinare indistintamente qualsiasi tipo di dato: potete memorizzare un numero in una variabile ed in un secondo momento metterci una lettera. Il valore è ancora tipizzato ma non la variabile. Python viene quindi definito dinamicamente tipizzato.
Altri linguaggi (come Java, Scala o C) sono molto più esigenti e precludono la possibilità di mischiare i tipi di dato in una variabile (vengono chiamati staticamente tipizzati). Questo potrebbe sembrare noioso ad una prima occhiata ma codeste restrizioni permettono al compilatore di generarvi più errori logici, il che potrebbe anche essere un bene. In un certo senso è più facile scrivere in Python ma gli errori possono occultarsi più facilmente.
[/!]Se sapete che il valore della vostra "variabile" non cambierà mai (ad
esempio perché contiene la dimensione dello schermo o altri valori costanti)
allora potete utilizzare direttamente un valore piuttosto che una
variabile. Semplicemente cambiate la parolachiave var
con
val
. Il compilatore potrà fare più verifiche ed avvertirvi
quando modificherete il valore per sbaglio. Ancora più interessante è sapere
che il complatorepotrebbe produrre codice più veloce in alcuni casi.
Le variabili funzionano in modo molto simile per stringhe, numeri in virgola mobile e valori boleani.
char* name = "Martin Quinson"; double height=1.77; // in meters int married=1;// 1 means "true"; "false" would be written 0
String nome = "Martin Quinson"; double altezza=1.77; // In metri boolean sposato=true;// il contrario si scriverebbe "false"
val nome:String = "Martin Quinson"; // questo non può essere modificato (è un valore) var altezza: Double = 1.77; // in metri var sposato = true; // il contrario si scriverebbe "false" // Scala sa che 'true' è un valore Boolean e quindi non c'è bisogno di specificarlo
nome = "Martin" cognome = 'Quinson' # sia gli apici che i doppi apici (virgolette) funzionano ugualmente motto = "Non finisco mai nie' (ma ci provo)" # è ok avere apici singoli all'interno delle virgolette altezza=1.77 # in metri sposato=True # il contrario si scriverebbe "false"
Dopo aver dichiarato una variabile è possibile assegnare un nuovo valore ad essa. Questo è veramente semplice:
x = 3[!java|c];[/!]
A destra del simbolo di uguaglianza potete mettere un espressione aritmetica contenente costanti, variabili e operazioni.
x = 3 + 2[!java|c];[/!]
x = 3 * x[!java|c];[/!]
[!java|scala|python]greeting = "Hello "+name[!java];[/!] [!python]#[/!][!scala|java]//[/!] + is (also) the operation to concatenate (ie, to join) strings[/!]
Per risolvere questo problema bisogna scomporlo in parti più semplici. Per esempio potresti eseguire questi punti:
Naturalmene è impossibile fare il giusto numero di passi indietro al punto 3
se non avete contato quelli fatti nel punto 1. Per fare questo potete usare
una variabile chiamata passiTotali
.
Create una variabile di tipo intero prima della fase 1, inizializzatela a 0
ed ogni volta che vi muovete di un passo in avanti incrementate il suo
valore di uno (passiTotali = passiTotali + 1;
[!java|c] oppure
passiTotali++;
, entrambe le sintassi sono equivalenti[/!]).
Variabili di questo tipo che assumono ogni valore di un dato intervallo sono
spesso chiamate stepper (Ndt "contapassi", un contatore a passo
fisso, non credo abbia traduzione in italiano). in
Se conoscete il Java o un altro linguaggio probabilmente proverete ad usare
l'operatore ++
per incrementare la variabile ma questo non è
possibile in [!thelang]. Il motivo è che sarebbe difficile definire questo
operatore per ogni tipo di dato esistente. Per esempio cosa dovrebbe fare ++
se applicato su un valore Complesso oppure una Stringa? Questo problema non
accade in Java perché int
non è un oggetto ma un tipo
primitivo. (se non conoscete l'operatore ++
ignorate questo
paragrafo: esso non esiste in [!thelang])
La fase 3 consiste nella semplice creazione di una nuova variabile intera
passiCompiuti
, inizializzarla a 0 e fare un passo indietro
fintanto che passiCompiuti
non eguaglia
passiTotali
, incrementando di volta in volta
passiCompiuti
. L'operatore !=
dovrebbe essere
utilizzato per testare la disuguaglianza (se alcuni valori NON sono uguali):
Ed adesso è il vostro turno!