Funcții în Go

În Go, funcțiile sunt blocuri de cod care îndeplinesc sarcini specifice, care pot fi reutilizate în întregul program pentru a economisi memorie, a îmbunătăți lizibilitatea și a economisi timp. Funcțiile Golang pot returna sau nu o valoare apelantului.

Lucruri de știut despre funcțiile din Golang

• Sintaxa funcției în Golang
• Declarație de funcție
• Funcția de apelare
• Argumente ale funcției
  • Apel după valoare
  • Sunați prin referință

De exemplu:

package main
import "fmt"

// multiply() nhân 2 số nguyên và trả về kết quả
func multiply(a, b int) int {
    return a * b
}

func main() {
    result := multiply(5, 10)
    fmt.Printf("multiplication: %d", result)
}

Rezultat:

multiplication: 50

Sintaxa funcției în Golang

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Declarație de funcție

În Go, o funcție este declarată cu cuvântul cheie func, urmat de un nume, parametri și tip de returnare opțional.

Sintaxă

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Exemplu de funcție de multiplicare

func multiply(a, b int) int {
    return a * b
}

func: Cuvânt cheie pentru a declara o funcție.
function_name: numele functiei, de ex. multiplica.
Lista parametrilor: a, b int—parametrii împreună cu tipurile lor.
Return_type: int specifică tipul returnării.

Funcția de apelare

Pentru a utiliza o funcție, pur și simplu apelați funcția după numele ei cu orice argumente necesare. Aici, multiplicarea(5, 10) apelează funcția cu 5 și 10 ca argumente.

De exemplu

result := multiply(5, 10)
fmt.Printf("Result of multiplication: %d", result)

Argumente ale funcției

Go acceptă două moduri de a transmite parametrii funcțiilor: Apel după valoare și Apel prin referință. În mod implicit, Go utilizează apel după valoare, ceea ce înseamnă că valorile sunt copiate și modificările din interiorul funcției nu afectează variabilele apelantului.

Apel după valoare

În apelul după valoare, valorile argumentelor sunt copiate în parametrii funcției, astfel încât modificările funcției nu afectează variabilele originale.

De exemplu:

package main
import "fmt"

func multiply(a, b int) int {
    a = a * 2 // chỉnh sửa bên trong hàm này
    return a * b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(x, y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Rezultat:

Before: x = 5, y = 10
multiplication: 100
After: x = 5, y = 10

Sunați prin referință

În apelul prin referință, pointerii sunt folosiți astfel încât modificările din interiorul funcției să se reflecte în variabilele apelantului.

De exemplu:

package main
import "fmt"

func multiply(a, b *int) int {
    *a = *a * 2 // chỉnh sửa giá trị của a ở địa chỉ bộ nhớ của nó
    return *a * *b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(&x, &y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Rezultat

Before: x = 5, y = 10
multiplication: 100
After: x = 10, y = 10