Funzione del linguaggio Go

La funzione è generalmente un blocco di codice o una statement nel programma, che permette di utilizzare lo stesso codice più volte, raggiungendo così di risparmiare memoria, tempo e, soprattutto, migliorare la leggibilità del codice. Pertanto,基本上函数是语句的集合，这些语句执行某些特定的任务并将结果返回给调用方。函数也可以执行某些特定任务而无需返回任何内容。

Dichiarazione della funzione

La dichiarazione della funzione è un metodo di costruzione di costruttori.

Sintassi：

func function_name(Parameter_list)(Return_type){
　　　　//　function　body.....
}

La dichiarazione della funzione contiene:

• func：È una parola chiave del linguaggio Go, utilizzata per creare funzioni.

• function_name：ÈLa funzioneIl nome.

• Parameter_list：Contiene il nome e il tipo dei parametri della funzione.

• Return_type：Questa è opzionale, contiene il tipo di valore restituito dalla funzione. Se viene utilizzato return_type nella funzione, deve essere utilizzato anche la statement return.

Chiamata di funzione

La chiamata di funzione viene completata quando l'utente desidera eseguire la funzione. È necessario chiamare la funzione per utilizzare le sue funzionalità. Come nell'esempio seguente, abbiamo una funzione chiamata add() con due parametri. Ora chiamiamo questa funzione nel main utilizzando il nome, ossia area(12, 10) con due parametri.

package main
import "fmt"
// area() viene utilizzata per trovare l'area del rettangolo
// Due parametri della funzione, ossia la lunghezza e la larghezza
func area(length, width int) int {
　　　　Ar := length * width
　　　　return Ar
}
func main() {
　　　　// Visualizzazione dell'area del rettangolo
　　　　// Chiamata tramite metodo
　　　　fmt.Printf("L'area del rettangolo: %d", area(12, 10))
}

Output:

L'area del rettangolo: 120

Parametri della funzione

In Go, i parametri passati a una funzione sono chiamati parametri effettivi (parametri reali), mentre i parametri ricevuti dalla funzione sono chiamati parametri formali (parametri formali).

Attenzione:Per default, Go utilizza il metodo di chiamata per valore per passare parametri a una funzione.

Go supporta due metodi per passare parametri a una funzione:

1. Call by value// In questo metodo di passaggio dei parametri, il valore del parametro effettivo viene copiato nel parametro formale della funzione e i due tipi di parametri vengono memorizzati in posizioni di archiviazione diverse. Pertanto, qualsiasi modifica effettuata all'interno della funzione non si riflette nei parametri effettivi del richiamante.

   Esempio

   package main　
   　　　
   import "fmt"
   　　　
   // Funzione per scambiare valori
   func swap(a, b int) int {　
   　　
   　　　　var o int
   　　　　o = a　
   　　　　a = b　
   　　　　b = o　
   　　　　　
   　　　return o　　
   }　
   　　　
   func main() {　
   　var p int = 10　
   　var q int = 20　
   　　fmt.Printf("p = %d e q = %d", p, q)　
   　　　
   　// call by values　
   　swap(p, q)　
   　　　fmt.Printf("\np = %d e q = %d", p, q)　
   }

   Output:

   p = 10 e q = 20
   p = 10 e q = 20

2. Richiamo per riferimento:I parametri effettivi e i parametri formali puntano alla stessa posizione, quindi qualsiasi modifica effettuata all'interno della funzione si riflette effettivamente sui parametri effettivi del richiamante.

   Esempio

   package main
   import "fmt"
   // Funzione per scambiare valori
   func swap(a, b *int) int {
   　　　　var o int
   　　　　o = *a
   　　　　*a = *b
   　　　　*b = o
   　　　　return o
   }
   func main() {
   　　　　var p int = 10
   　　　　var q int = 20
   　　　　fmt.Printf("p = %d e q = %d", p, q)
   　　　　// Richiamo per riferimento
   　　　　swap(&p, &q)
   　　　　fmt.Printf("\np = %d e q = %d", p, q)
   }

   Output:

   p = 10 e q = 20
   p = 20 e q = 10