proses penggunaan golang

Golang ialah bahasa pengaturcaraan popular yang terkenal dengan kesederhanaan, kecekapan dan kebolehpercayaannya. Artikel ini akan memperkenalkan cara menggunakan bahasa Go, termasuk pemasangan, menetapkan pembolehubah persekitaran, membina program pertama, sintaks, fungsi, penunjuk, struktur dan antara muka, dsb.

1. Pasang bahasa Go

Mula-mula, anda perlu memuat turun pakej pemasangan Go yang sesuai untuk sistem pengendalian anda daripada tapak web rasmi https://golang.org/dl/. Selepas memuat turun, klik dua kali pada pakej pemasangan dan ikut arahan untuk melengkapkan pemasangan. Selepas pemasangan selesai, anda perlu menetapkan pembolehubah persekitaran.

2. Tetapkan pembolehubah persekitaran

Dalam sistem Windows, anda perlu mencari tetapan sifat "Komputer" atau "PC ini". Klik "Tetapan Sistem Terperinci", pilih "Pembolehubah Persekitaran", cari "Laluan" dalam "Pembolehubah Sistem", klik "Edit", dan tambah laluan direktori bin laluan pemasangan Go pada penghujung, contohnya: "C:go dalam".

Dalam persekitaran seperti Unix seperti Linux atau Mac OS, anda perlu mengedit fail bashrc atau bash_profile dan menambah baris berikut:

eksport PATH=$PATH:/usr/local/ go/bin

Nota: /usr/local/go/bin ialah direktori pemasangan Go dan perlu ditetapkan mengikut situasi sebenar.

3 Bina program pertama

Selepas melengkapkan persediaan persekitaran, anda boleh cuba membina program Go pertama anda.

Buka editor teks kegemaran anda (seperti Sublime Text, Atom, VS Code, dll.), buat fail bernama "hello.go", masukkan kod berikut:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Teruskan Datang ke bawah, buka terminal baris arahan, masukkan direktori di mana fail terletak, dan jalankan arahan berikut:

go run hello.go

Selepas operasi berjaya, anda seharusnya melihat output "Hello, World!" terminal.

4. Tatabahasa

Tatabahasa bahasa Go sangat mudah dan mudah dipelajari serta diingati. Berikut ialah beberapa ciri bahasa asas:

1. Jenis: Bahasa Go menyokong berbilang jenis data, seperti: Boolean (bool), integer (int, int8, int16, int32, int64), unsigned integer ( uint, uint8, uint16, uint32, uint64), nombor titik terapung (float32, float64), aksara (rune), rentetan (rentetan), nombor kompleks (complex64, complex128) dan penunjuk (penunjuk), dsb.
2. Pengisytiharan pembolehubah: Anda boleh menggunakan var untuk mengisytiharkan pembolehubah, dan jenisnya akan disimpulkan secara automatik jika nilai dimulakan.

var a int
a = 100

var b string = "hello"

Anda juga boleh menggunakan := untuk memudahkan perisytiharan pembolehubah dan permulaan.

c := true
d := 1.23

3. Pernyataan bersyarat: pernyataan jika dan suis digunakan untuk pertimbangan bersyarat dan pemilihan berbilang masing-masing.

if x < 0 {
    fmt.Println("x is negative")
} else if x == 0 {
    fmt.Println("x is zero")
} else {
    fmt.Println("x is positive")
}

switch day {
    case "Monday":
        fmt.Println("Today is Monday")
    case "Tuesday":
        fmt.Println("Today is Tuesday")
    default:
        fmt.Println("Today is a different day")
}

4. Struktur gelung: Bahasa Go menyediakan gelung, yang mempunyai banyak kegunaan.

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

for index, value := range array {
    fmt.Println(index, value)
}

for condition {
    // loop body
}

5. Fungsi

Fungsi dalam bahasa Go bermula dengan fungsi kata kunci, diikuti dengan nama fungsi dan senarai parameter. Jika fungsi mengembalikan nilai, anda perlu menambah jenis nilai pulangan selepas senarai parameter.

func functionName(parameter1 type, parameter2 type) returnType {
    // function body
}

Sebagai contoh, berikut ialah fungsi mudah yang mengira jumlah dua integer:

func add(x int, y int) int {
    return x + y
}

result := add(2, 3) // 5

Bahasa Go juga menyokong fungsi tertib lebih tinggi, yang boleh dihantar sebagai argumen kepada fungsi lain , Anda juga boleh menggunakan fungsi sebagai nilai pulangan.

6. Penunjuk

Penunjuk ialah pembolehubah yang menyimpan alamat memori pembolehubah lain. Dalam bahasa Go, alamat memori pembolehubah diperoleh melalui operator & dan nilai yang disimpan pada alamat tersebut diakses melalui operator *.

x := 10
ptr := &x       // &x 表示取 x 的地址，ptr 保存了 x 的地址
fmt.Println(*ptr) // *ptr 表示获取指针指向的值，即 x 的值，输出 10

*ptr = 100      // 修改指针指向的值，即将 x 的值改为 100
fmt.Println(x) // 输出 100

7 Struktur dan antara muka

Bahasa Go menyokong pengaturcaraan berorientasikan objek, di mana struktur dan antara muka adalah konsep utama. Struktur ialah jenis tersuai yang boleh mengandungi berbilang medan dan membenarkan struktur lain digabungkan. Antara muka mentakrifkan satu set kaedah, tetapi tidak mengandungi butiran pelaksanaan, dan digunakan untuk mencapai polimorfisme.

Berikut ialah contoh mudah yang menunjukkan cara mentakrif dan menggunakan struktur dan antara muka:

type person struct {
    name string
    age  int
}

type animal interface {
    voice() string
}

func (p person) speak() {
    fmt.Println("My name is", p.name, "and I am", p.age, "years old")
}

type cat struct{}

func (c cat) voice() string {
    return "meow"
}

func main() {
    p := person{name: "Alice", age: 25}
    p.speak()

    var a animal
    a = cat{}
    fmt.Println(a.voice()) // 输出 "meow"
}

8 Ringkasan

Artikel ini memperkenalkan pengetahuan asas bahasa Go, termasuk Pemasangan , menetapkan pembolehubah persekitaran, membina program pertama anda, sintaks, fungsi, penunjuk, struktur, antara muka dan banyak lagi. Walaupun ini hanyalah gambaran ringkas, ia sepatutnya cukup untuk membantu pemula memulakan bahasa Go dan memahami alatan dan ciri yang tersedia. Jika anda ingin mengetahui lebih lanjut, lihat dokumentasi dan buku rasmi, dan berlatih membina projek sebenar.

Atas ialah kandungan terperinci proses penggunaan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!