Memahami Stack dan Heap in Go: Panduan Mudah

Apabila anda mula belajar Go, atau mana-mana bahasa pengaturcaraan dalam hal ini, anda akan sering mendengar tentang ingatan tindanan dan timbunan. Kedua-dua kawasan ingatan ini sangat penting untuk memahami cara program anda berjalan dan mengurus data di sebalik tabir. Tetapi jangan risau—hari ini, kami akan menerangkannya dengan cara yang mudah difahami dengan sentuhan yang menyeronokkan.

Apakah Stack?

Bayangkan timbunan itu sebagai longgokan dulang yang kemas di kafeteria. Setiap kali seseorang memerlukan dulang, mereka mengambil satu dari atas. Dan apabila mereka memulangkan dulang, mereka meletakkannya semula di atas longgokan. Tindanan dalam Go berfungsi sama!

• Timbunan ialah kawasan memori yang kecil dan sangat laju.
• Ia menyimpan perkara seperti panggilan fungsi dan pembolehubah setempat (seperti integer atau struct kecil).
• Setiap kali fungsi dipanggil, Go menambah "dulang" (bingkai) ke bahagian atas tindanan. Apabila fungsi selesai, ia mengeluarkan dulang itu dari atas.

Jadi, tindanan mengikuti sistem LIFO (Masuk Terakhir, Keluar Dahulu), sama seperti cara anda mengambil dan memulangkan dulang.

Contoh: Timbunan dalam Tindakan
Katakan kita mempunyai kod Go yang ringkas ini:

func main() {
    greet("John")
}

func greet(name string) {
    message := "Hello, " + name
    fmt.Println(message)
}

Berikut ialah perkara yang berlaku langkah demi langkah:

1. Go meletakkan dulang pada tindanan untuk fungsi utama.
2. panggilan utama greet(), jadi dulang lain (bingkai tindanan) ditambah untuk greet().
3. Fungsi salam mencipta mesej pembolehubah setempat, dan Go letakkan dalam dulang.
4. Setelah salam() selesai, dulang itu dikeluarkan (tertimbul) daripada timbunan.
5. Akhir sekali, apabila utama selesai, dulang terakhir dikeluarkan.

Kemas dan tersusun kan? Tindanan ini sesuai untuk mengendalikan perkara yang bersifat sementara dan hilang dengan cepat—seperti pembolehubah setempat dalam fungsi.

Apakah Heap itu?

Sekarang, mari bayangkan timbunan itu sebagai taman permainan yang besar. Tidak seperti timbunan, di mana anda hanya boleh menambah atau mengalih keluar sesuatu dari bahagian atas, timbunan itu lebih seperti kawasan terbuka yang besar di mana anda boleh meletakkan sesuatu di mana-mana sahaja.

• Timbunan ialah ruang ingatan yang lebih besar.
• Ia digunakan untuk menyimpan data yang perlu disimpan seketika, walaupun selepas sesuatu fungsi selesai.
• Perkara yang disimpan pada timbunan tidak mempunyai susunan tertentu dan Go perlu menjejakinya menggunakan sesuatu yang dipanggil penunjuk.

Walaupun timbunan itu besar dan boleh menyimpan lebih banyak data, ia lebih perlahan untuk diakses daripada timbunan kerana Go perlu memikirkan di mana keadaannya dan membersihkannya sendiri. Go mempunyai pengumpul sampah yang secara automatik mengemas ingatan timbunan yang tidak digunakan, sama seperti seseorang menyapu taman permainan.

Contoh: Timbunan dalam Tindakan
Lihat kod Go ini:

func main() {
    user := newUser("Alice")
    fmt.Println(user.name)
}

func newUser(name string) *User {
    user := &User{name: name}
    return user
}

type User struct {
    name string
}

Begini cara timbunan itu dimainkan:

1. panggilan utama newUser().
2. Di dalam newUser, kami mencipta struct Pengguna baharu dengan medan nama.
3. Go memutuskan untuk menyimpan struct ini pada timbunan, bukan pada timbunan, kerana ia perlu melekat selepas Pengguna baru kembali.
4. Go memberi kita penunjuk (seperti peta tempat struct tinggal dalam ingatan) dan mengembalikannya ke utama.
5. Kini, walaupun selepas Pengguna baru selesai, struct Pengguna kekal dalam ingatan (pada timbunan), dan utama masih boleh mengaksesnya menggunakan penuding.

Timbunan berguna apabila anda perlu menyimpan data yang melebihi fungsi ia dicipta, tetapi ia lebih perlahan dan memerlukan pengurusan yang teliti oleh pemungut sampah Go.

Stack vs. Heap: Apakah Perbezaannya?

• Timbunan adalah seperti timbunan dulang: kecil, pantas dan sementara. Sesuai untuk pembolehubah tempatan dalam fungsi.

• Timbunan adalah seperti taman permainan: besar, lebih fleksibel, tetapi lebih perlahan. Digunakan untuk perkara yang perlu hidup lebih lama (seperti objek yang perlu dikongsi merentas fungsi).

Kesimpulan

Memahami perbezaan antara tindanan dan timbunan adalah kunci untuk menulis program Go yang cekap. Tindanan adalah pantas dan mudah diurus, bagus untuk data sementara. Timbunan lebih besar tetapi lebih perlahan, digunakan apabila anda memerlukan sesuatu untuk melekat.

Go mengendalikan banyak kerumitan untuk anda dengan pengurusan memori automatik, tetapi mengetahui konsep ini akan membantu anda menulis kod yang lebih optimum dan cekap.

Selamat pengekodan!

Atas ialah kandungan terperinci Memahami Stack dan Heap in Go: Panduan Mudah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!