Oggi vediamo i costrutti di controllo offerti da GO. I costrutti consentono di configurare il flusso delle operazione sequenziali in base all’algoritmo stabilito dall’autore. Si dividono in iterativi e di selezione.<\/p>\n\n\n\n
il costrutto for \u00e8 un costrutto iterativo e consente di iterare un comando n volte fino a che \u00e8 valida la condizione di controllo<\/p>\n\n\n\n
package main\nimport \"fmt\"\nconst limite = 5\n\/\/ Stampa - commento\nfunc main() {\n\tfor i := 0; i < limite; i++ {\n\t\tfmt.Println(i)\n\t}\n}<\/code><\/pre>\n\n\n\nnel ciclo for ho inizializzato la variabile i con 0 (Non ho esplicitato il tipo perch\u00e8 Go lo desume da solo), ho definivo la condizione per continuare l’iterazione (i deve essere minore della costante limite) e ho definito la regola di incremento ( in questo caso i cresce di una unit\u00e0 per ogni iterazione). Rispetto ad altri linguaggi come java non sono richieste parentesi per chiudere i comandi di inizializzazione del for, mentre sono obbligatorie le parentesi {} per racchiudere il blocco di operazioni da effettuare.<\/p>\n\n\n\n
La condizione di inizializzazione e la condizione di incremento sono opzionali, pertanto posso scrivere il codice in questo, rendendo il codice equivalente ad un costrutto while.<\/p>\n\n\n\n
j := 0\nfor j < limite {\n\tfmt.Println(j)\n\tj = j + 1\n}<\/code><\/pre>\n\n\n\nAnche la condizione di uscita pu\u00f2 essere omessa, ottenendo cos\u00ec un ciclo virtualmente infinito che pu\u00f2 essere pilotato tramite il comando break che interrompe l’esecuzione.<\/p>\n\n\n\n
z := 0\nfor {\n\tz = z + 1\n\tfmt.Println(z)\n\tif z == 5 {\n\t\tbreak\n\t}\n}<\/code><\/pre>\n\n\n\nInsieme al comando break pu\u00f2 essere usato il comando continue che permette di saltare l’iterazione corrente e andare alla prossima.<\/p>\n\n\n\n
- IF<\/li><\/ul>\n\n\n\n
Il costrutto IF \u00e8 un costrutto di seleziona e consente di eseguire il codice contenuto nelle sue parentesi {} al verificare di una condizione booleana. Se guardate il codice precedente quando il contatore vale 5 il sistema interrompe il ciclo con il comando break. <\/p>\n\n\n\n
Tramite il comando else \u00e8 possibile definire un blocco di operazioni alternativo ed inoltre \u00e8 possibile all’interno del blocco if definire una assegnazione ad una variabile che sar\u00e0 visibile solo nel blocco if. <\/p>\n\n\n\n
z := 0\nfor {\n\tz = z + 1\n\tif d := z; d == 5 {\n\t\tfmt.Println(\"fine\")\n\t\tbreak\n\t} else {\n\t\tfmt.Println(d)\n\t}\n}<\/code><\/pre>\n\n\n\nNel blocco ho introdotto una variabile d inizializzata con il valore di z e ho definito una condizione alternativa a quella di uscita, grazie alla quale stampo il valore corrente dell’indice.<\/p>\n\n\n\n
- SWITCH<\/li><\/ul>\n\n\n\n
Il costrutto switch \u00e8 un costrutto di selezione e ci viene in aiuto quando dobbiamo gestire la verifica di n possibili valori. Invece di usare tanti if\/else annidati lo switch case ci consente di gestire in modo elegante la casistisca descritta.<\/p>\n\n\n\n
switch z {\ncase 1:\n\tfmt.Println(1)\ncase 2:\n\tfmt.Println(2)\ncase 3, 4:\n\tfmt.Println(\"3 o 4\")\ncase 1 * 5:\n\tfmt.Println(\"5\")\ndefault:\n\tfmt.Println(\"default\")\n}<\/code><\/pre>\n\n\n\nNel blocco sopra sto verificando il valore di z, gestendo le casistiche 1 e 2 con apposito output, per gli altri valori viene stampato il valore default. Quando la condizione viene riscontrata il sistema esegue il codice relativo, a differenza di altri linquaggi come JAVA non \u00e8 necessario specificare la chiave break. Nella clausola case possono essere presenti pi\u00f9 condizioni separate da virgola ed \u00e8 possibile inserire l’output di una funzione, l’importante che il tipo sia dello stesso tipo delle altre clausole.<\/p>\n\n\n\n
E’ possibile anche omettere la condizione da verificare ottenendo un modo pi\u00f9 elegante per scrivere degli if\/else in cascata specificando la regola di ingresso a livello del blocco case. Lo stesso codice di sopra pu\u00f2 essere riscritto come segue<\/p>\n\n\n\n
switch {\ncase z == 1:\n\tfmt.Println(1)\ncase z == 2:\n\tfmt.Println(2)\ncase z == 3 || z == 4:\n\tfmt.Println(\"3 o 4\")\ncase z == 1*5:\n\tfmt.Println(\"5\")\ndefault:\n\tfmt.Println(\"default\")\n}<\/code><\/pre>\n\n\n\n- DEFER<\/li><\/ul>\n\n\n\n
Il costrutto DEFER \u00e8 un comando interessante. Consente di eseguire un codice alla fine del programma. Agisce come una pila con una logica di tipo First In Last Out, pertanto il primo comando inserito sar\u00e0 l’ultimo ad essere eseguito.<\/p>\n\n\n\n
package main\n\nimport \"fmt\"\n\nconst limite = 5\n\nfunc main() {\n\n\tdefer fmt.Println(\"Fatto quello che c'era da fare\")\n\tdefer fmt.Println(\"Sto per scrivere il penultimo messaggio\")\n\n\tfor i := 0; i < limite; i++ {\n\t\tfmt.Println(i)\n\t}\n\n\tj := 0\n\tfor j < limite {\n\t\tfmt.Println(j)\n\t\tj = j + 1\n\t}\n\n\tvar z int = 0\n\tfor {\n\t\tz = z + 1\n\t\tif d := z; d == 5 {\n\t\t\tfmt.Println(\"fine\")\n\t\t\tbreak\n\t\t} else {\n\t\t\tfmt.Println(d)\n\t\t}\n\t}\n\n\tswitch z {\n\tcase 1:\n\t\tfmt.Println(1)\n\tcase 2:\n\t\tfmt.Println(2)\n\tcase 3, 4:\n\t\tfmt.Println(\"3 o 4\")\n\tcase 1 * 5:\n\t\tfmt.Println(\"5\")\n\tdefault:\n\t\tfmt.Println(\"default\")\n\t}\n\n\tswitch {\n\tcase z == 1:\n\t\tfmt.Println(1)\n\tcase z == 2:\n\t\tfmt.Println(2)\n\tcase z == 3 || z == 4:\n\t\tfmt.Println(\"3 o 4\")\n\tcase z == 1*5:\n\t\tfmt.Println(\"5\")\n\tdefault:\n\t\tfmt.Println(\"default\")\n\t}\n}\n<\/code><\/pre>\n\n\n\nOttenendo cos\u00ec l’output atteso<\/p>\n\n\n\n
0\n1\n2\n3\n4\n0\n1\n2\n3\n4\n1\n2\n3\n4\nfine\n5\n5\nSto per scrivere il penultimo messaggio\nFatto quello che c'era da fare<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"Oggi vediamo i costrutti di controllo offerti da GO. I costrutti consentono di configurare il flusso delle operazione sequenziali in base all’algoritmo stabilito dall’autore. Si dividono in iterativi e di selezione. FOR il costrutto for \u00e8 un costrutto iterativo e consente di iterare un comando n volte fino a che \u00e8 valida la condizione di … Continua la lettura di TUTORIAL GO – COSTRUTTI DI CONTROLLO<\/span>