## Conservare e manipolare i dati

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.

### Dati in [!thelang]

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".

### Dichiarazioni di Variabili

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.

[!c|java]

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]:

- [!java|c]int[/!][!scala]Int[/!], per i numeri interi;
- [!java|c]double[/!][!scala]Double[/!], per i numeri con la virgola;
- [!c]int[/!][!java]boolean[/!][!scala]Boolean[/!], for booleans that are values being either [!c]1[/!][!java|scala]true[/!] or [!c]0[/!][!java|scala]false[/!];
- [!c]char*[/!][!java|scala]String[/!], for char strings.

[/!] [!python]

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"

### Assegnazione

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[/!]

### Traguardo dell'esercizio

È arrivato il momento di fare esercizi più competitivi, non trovate? L'obiettivo è ora di muoversi avanti fintanto che non si trova un baggle, prenderlo e tornare indietro alla posizione iniziale per poggiarlo.

### Come fare?

Per risolvere questo problema bisogna scomporlo in parti più semplici. Per esempio potresti eseguire questi punti:

1. Muoviti avanti fino a trovarsi su un baggle
2. Prendi il baggle
3. Muoviti indietro dello stesso ammontare di passi fatti nel primo punto
4. Posa a terra il baggle

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

[!python|scala]

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!