Scarica Programmazione in Go e similarità con Java e più Sintesi del corso in PDF di Programmazione Java solo su Docsity!
GO
Viene utilizzato ATOM come editor di testo. Il primo programma che andiamo a scrivere sarà hello.go il quale è il file sorgente. Da compilatore (linea di comando) per farlo partire (per compilarlo) posso usare due comandi: go build hello.go oppure per compilarlo e farlo partire allo stesso tempo posso scrivere: go run hello.go (in questo modo me lo compila e poi esegue con un unico comando). Esecuzione invece: con Linux scrivo: ./hello se lo faccio con Windows scriverò: hello.exe. Primo programma go: package main import “fmt” #funzione per scrivere a video e leggere da tastiera func main () { } Secondo programma go: package main Import “fmt” Func main () { fmt.Println (“ Hello word”) # non vengono messi i punti e virgola. Questa i struzione è utilizzata per stampare a video }
si può utilizzare “go fmt” per dargli un indentazione corretta automatica
Terzo progetto: package main import “fmt” func main () { var i , n int # devo sempre mettere prima var poi il nome Delle variabili e alla fine il tipo di variabile fmt.Println(“quante volte?”) fmt.Scan(&n) # con questa istruzione posso immettere da tastiera il valore di n utilizzato come variabile
scriviamo ora un ciclo for
for i=0 ; i Come simbolo di assegnamento utilizziamo = Nel terzo progetto potevo anche scrivere nell'ultimo fmt: fmt.Println(“Ciao”, i ) Se non metto ln dopo Print avrò che la stringa dopo stampata a video sarà affiancata a questa e non andrà a capo. Quarto progetto: package main import “fmt” func main () { var n,m int fmt.Println(“Imserisci primo numero”) fmt.Scan(&n) fmt.Println(“Inserisci secondo nuemro”) fmt.Scan(&m) fmt.Println(n*m) } Lezione seconda Token quattro tipi:
- Parole chiave
- Identificatori (es sequenze di carattere) (es se scrivo var i int il mio identificatore sarà i) non posso utilizzare parole chiave come identificatori.
- Segni d’imputazione: ++ < = ecc
- Le costanti: (ricordiamo che nel linguaggio go 3.1415E9 è come scrivere 3.1415 per dieci alla nove, mentre 3.1415_9 come se fosse 3.1415 per dieci alla meno nove (non sono sicuro)) Le rune sono: 'a' è quello che noi in genere chiamiamo carattere e viene scritto tra due apici, il doppio apice serve per scrivere una stringa ossia un insieme di caratteri “”. Con \n vado a capo (Come faccio a scrivere “ all’interno di una stringa senza che lui me lo consideri come fine stringa? Scrivendo \”. Esempio: “ciao \” “ mi stampa ciao “ mentre se scrivo “ciao “ “ mi darà un errore). Se voglio mettere più istruzioni sulla stessa linea devo dividerli con ; altrimenti scrivendoli in colonna go mi mette automaticamente (anche se non si vede) un ; alla fine della mia istruzione. Spaziatura:
- Spazio normale
- A capo
- Ritorno a carrello
la stessa cosa vale per import: import ( “fmt” “math” ) Che equivale a scrivere: import “fmt” import “math” Effetto sharling (credo si chiami così) ossia quando dichiaro due variabili una dentro un blocco (che può essere per esempio il ciclo for) e una all’esterno del blocco. Questo è un effetto ombra ossia il ciclo (in questo caso) prende in considerazione l’ultima variabile dichiarata oscurando quella che si trova fuori da quest’ultimo. Esempio: package main import “fmt” func main () { var i,x int x= for i=0; i<5; i++ { var x int x= x++ } fmt.Println(x) } Se il programma viene eseguito stamperà 5 per il motivo spiegato prima. Comando da scrivere sul prompt dei comandi per correggere gli errori di sintassi: go vet – shadowstrict – shadow=true nome.go Analizziamo un altro esempio: package main import “fmt” func main () {
var x, y, z int x= y= z= x+y fmt.Println(z) y= fmt.Println(z) } Questo programma ci stamperà a video: 12 12 Un modo per non utilizzare var: se scrivo x:=3 cosa succede: il compilatore “indovina” il tipo di variabile che in questo caso sarà int. La scrittura x:=3 equivale a scrivere: var x int x= questo linguaggio mi permette di scrivere in un altro modo il ciclo for anche: for i :=0; i // se vogliamo controllare che sia davvero intero il valore di x scriviamo: fmt.Printf(“%T\n”, x) fmt.Println(x) se aggiungiamo la libreria math possiamo anche scrivere: x:= int (math.round(f)) // questa prima arrotonda il valore di f e poi lo mette in x trasformandolo in intero. Lezione quarta Input output Es: package main Import (
. “fmt” _”math” ) func main () { // Differenza tra Print e Pronti: con Println mi inserisce spazi e alla fine va a capo, mentre con Print non mi // mette spazi e non mi va a capo Println(3,4) // stampa 3 4 con lo spazio tra i due Println(3, “è minore di”, 4) // stampa 3 è minore di 4 sempre con lo spazio Var x=3 int Print (x*x) // stampa il valore dato dalla moltiplicazione tra x e x Print (3,4) // stampa 34 senza spazio tra i due Print (3, “è minore di”,4) // stampa 3èminoredi4 tutto attaccato e senza il “a capo” alla fine // Se non utilizzo Println ma uso Print per andare a capo aggiungo \n: Print(“3 è minore di 4\n”) mi stamperà un “a capo” dopo la frase. Se scrivo \t funziona come una tabulazione. } Come fare inserire i valori dall’utente: fmt.Scan Quindi: Var x int Fmt.Scan(&x) // con questo comando facciamo inserire i valori
Esempio anno di nascita: … Var anno int Fmt.Println(“inserisci il tuo anno di nascita”) // sto chiedendo di inserire l'anno fmt.Scan(&anno) fmt.Println(“Hai”, 2018-anno, “anni”) … Esempio, quanti minuti mancano a mezzanotte? ….. Var h,m int fmt.Print(“Inserisci ore e minuti:”) fmt.Scan(&h) fmt.Scan(&m) fmt.Println(“Mancano”, (23-h) * 60 + 60 – m, “minuti a mezzanotte”) #variante fmt.Println(“inserisci ore”) fmt.Scan(&h) fmt.Println(“inserisci minuti”) fmt.Scan(&m) esempio iva: package main import ( “fmt” “math” ) func main () { fmt.Println(“Inserisci imponibile”) var impo float fmt.Scan(&impo) fmt.Pritln(“Inserisci aliquota”) var aliquota int fmt.Scan(&aliquota) fmt.Println(“Il prezzocomplessivo è:”, impo + impo * float64(aliquota)/ 100)
Con math posso mettere in import: _”math” Sintassi: x++ incrementa di 1 la mia x, corrisponde a scrivere: x = x+ x-- decrementa di 1 la mia x, corrisponde a: x = x- 1 scrivere x++, x=x+1 o x +=1 è la stessa cosa e vale per ogni operazione sempio: +=, - =, /=, %= esempio (corpo): var x,y,z float Scan(&x, &y, &z) somma := x+y+z Println(“Media:”, somma) esempio2: for i,x := 0, 1; i<10; i++ { Println(x) x *= }
