Polimorfisme Menggunakan Golang

Kadang-kadang saya telah menemukan lebih mudah untuk menjelaskan polimorfisme dengan ilustrasi. Sebuah ilustrasi mencoba untuk menyederhanakan dan pasti memiliki kekurangan, tetapi bisa membantu memperjelas ide. Asumsikan Mars datang ke  bumi dan dia tahu tentang manusia, tetapi dia tidak tahu tentang perbedaan antara seorang pria dan seorang wanita. Dia sekarang mendekati manusia acak di jalan dan meminta pertanyaan yang sama, "Manusia, katakan apa yang Anda ingin lakukan". Asumsikan sekarang bahwa manusia pertama Mars mendekati dengan pertanyaan ini adalah Man. Untuk pergi dengan stereotip Barat, jawabannya bisa "Aku suka memancing". Sekarang menganggap itu mendekati Wanita dengan pertanyaan yang sama. Melanjutkan dengan stereotip, tanggapannya bisa "Aku suka belanja". Sejauh Mars yang melihatnya, tampak bahwa ia telah meminta hanya Manusia, tapi dia mendapat jawaban yang berbeda setiap kali. Jawabannya tergantung pada jenis sebenarnya dari orang yang ia tanya. Contoh konyol mungkin, tapi ini mirip dengan polimorfisme - di mana respon yang berbeda diperoleh dari jenis yang sama, dalam hal ini manusia, tergantung pada apa jenis tertentu itu.

Di Go, kita menggunakan antarmuka untuk mencapai polimorfisme ini. Untuk tutorial pemula pada antarmuka di Go, silahkan baca tutorial ini: Antarmuka di Go. Jika kita membuat sebuah antarmuka dan memiliki jenis lain mengimplementasikan antarmuka itu, maka kita dapat mencapai ke masing-masing jenis melalui metode yang didefinisikan antarmuka tanpa harus tahu apa jenis tertentu itu. Mari kita menerapkan itu dan melihat apa yang kita dapatkan.

kode lengkap

package main

import "fmt"

type Human interface {
    myStereotype() string
}

type Man struct {
}

func (m Man) myStereotype() string {
    return "I'm going fishing."
}

type Woman struct {
}

func (m Woman) myStereotype() string {
    return "I'm going shopping."
}
func main() {
    m := new (Man)
    w := new (Woman)

    // array Manusia - kita tidak tahu apakah Man atau Perempuan
    hArr := [...]Human{m, w} // array 2 Manusia. Salah satunya adalah tipe manusia, satu adalah tipe Perempuan.
    for n, _ := range (hArr) {

        fmt.Println("I'm a human, and my stereotype is: ", hArr[n].myStereotype())   // muncul sebagai jenis manusia, tetapi perilaku berubah tergantung pada contoh aktual
        
    }

}

I'm a human, and my stereotype is: I'm going fishing.
I'm a human, and my stereotype is: I'm going shopping.

Dalam kode di atas dalam untuk loop, kita dapat meminta stereotip manusia, tetapi mendapatkan tanggapan yang berbeda setiap kali berdasarkan apa jenis intrinsik, baik pria atau wanita. Pada titik memanggil, kita hanya tahu bahwa itu adalah manusia - sehingga tampak bahwa manusia adalah morphing setiap kali. Di sana Anda pergi, polimorfisme!

Saya berharap bahwa contoh mudah untuk memahami dan menggambarkan konsep. Polimorfisme, setidaknya bagi saya, telah menjadi konsep yang sulit untuk menjelaskan, itulah sebabnya saya resor untuk contoh lebih mudah. Tapi jika Anda berpikir tentang hal ini, contoh di atas bisa dalam kenyataannya dilaksanakan seolah-olah pria dan wanita yang mewarisi dari Human. Jadi mari kita memperpanjang contoh sedikit lebih jauh.

Kami akan kali ini mengubah antarmuka ke Hobby. Kali ini kita akan memiliki Man and Woman berasal dari Manusia. Selain itu kami juga akan menambahkan Anjing yang tidak berasal dari jenis lainnya. Tapi kita akan memiliki masing-masing menerapkan Hobby antarmuka. Karena mereka melakukan itu, kita harus bisa memanggil myStereotype () metode pada semua dari mereka dan menerima hasil yang berbeda berdasarkan jenis intrinsik.

kode lengkap

package main

import "fmt"

type Hobby interface {
    myStereotype() string
}

type Human struct {

}

func (h Human) myStereotype() string {
    return "I'm a Human, only an abstract concept, and I can have no hobby."
}

type Man struct {
    Human // kelas anonim untuk mewarisi perilaku manusia
}

func (m Man) myStereotype() string {
    return "I'm a Man and I'm going fishing."
}

type Woman struct {
    Human // kelas anonim untuk mewarisi perilaku manusia
}

func (m Woman) myStereotype() string {
    return "I'm a Woman and I'm going shopping."
}

type Dog struct {
    // tidak mewarisi jenis lain
}

func (m Dog) myStereotype() string {
    return "bow bow bow, I'm chasing sticks."
}

func main() {
    h := new (Human)
    m := new (Man)
    w := new (Woman)
    d := new (Dog)

   // array contoh hobi - kita tidak perlu tahu apakah manusia atau anjing
    hobbyArr := [...]Hobby{h, m, w, d} //array of 3 Humans and 1 dog.
    for n, _ := range (hobbyArr ) {

        fmt.Println("My hobby?  Well,", hobbyArr [n].myStereotype())  // muncul sebagai jenis Hobby, tetapi perubahan perilaku tergantung pada contoh aktual

    }
}

My hobby? Well, I'm a Human, only an abstract concept, and I can have no hobby.
My hobby? Well, I'm a Man and I'm going fishing.
My hobby? Well, I'm a Woman and I'm going shopping.
My hobby? Well, bow bow bow, I'm chasing sticks.

Cara Penggunaan Struct pada Golang

Langsung aja gan disini ane akan menjelaskan apakah Go itu adalah sebuah bahasa pemrograman dengan OOP... ^_^

Indikasi awal yang digunakan untuk mendeteksi bahwa itu adalah OOPS, Langkah pertama yang harus diingat adalah Go tidak memiliki kata kunci 'class'. Sebuah struct adalah apa yang akan digunakan untuk konsep paralel di Go. Bahasa seperti Java, C #, C ++ dan lain-lain juga memiliki struct. Seperti banyak dari bahasa pemrograman yang lain mendukung penggunan metode struct, Go juga begitu. Sehingga seharusnya tidak sulit untuk dipahami. Tapi ada perbedaan. o__o)

Dalam beberapa bahasa berorientasi objek, metode terdiri dalam class atau struct. Di Go, mereka 'associated' dengan struct.

Potongan script: Untuk Jawa

class House {
    public String getHouseName() {  //metode untuk mendefinisikan class
    }
}

Potongan script: Untuk Go

type House struct { }

func (h House) GetHouseName() string { } //metode untuk mendefinisikan struck yang beradadalam House struct

Sekarang mari kita belajar cara membuat struct dan spesialisasi mereka dalam Go, yang memungkinkan kita untuk mendapatkan semua kebaikan pemrograman berorientasi objek tanpa benar-benar membutuhkannya. .___.)/ Sebuah struct didefinisikan dengan type dan struct sebagai kata kunci.

type my_struct_name struct { }

type Rectangle struct { }

type Vehicle struct { }

type Vehicle1_Car struct { }

Semua pernyataan di atas adalah definisi yang valid karena mereka mengikuti penamaan konvensi variable Go . Yang di bawah ini adalah tidak sah.

type Hash# struct {} //tidak mempunyai karakter spesial
type 0struct struct {} //tidak dapat memulai dengan angka

Berikutnya, struct dapat berisi data lainnya. Jadi struct, seperti class yang memungkinkan untuk menentukan isi dari item dunia nyata yang sedang mencoba untuk mewakili dan menata letak memori yang sesuai. Berikut adalah beberapa contoh yang valid.

type my_struct_name struct {
    i int 
    j int 
    s string
}

type Rectangle struct {
    length, width int //dapat mendefinisikan item multiple pada beberapa tipe yang sama d    dengan garis yang dibatasi dengan koma
    area float64
}

Sekarang untuk menggunakan struct dalam kode. Ane mencoba mempertahankan bagian dari kelas Rectangle dan mencetaknya.

package main

import "fmt"

type Rectangle struct {
    length, width int 
}

func main() {
    r := Rectangle{}  
    fmt.Println("Default rectangle is: ", r) //mencetak nilai default
}

Default rectangle is: {0 0}

Ada satu hal penting untuk melihat output: nilai-nilai variabel dalam struct adalah nol-ed, yaitu int akan 0, string akan kosong, dll Jadi pada dasarnya, struct juga memiliki nilai nol ed yang diinisialisasi tergantung pada jenis konstituennya.

Pada contoh berikut, terlihat cara yang berbeda untuk menginisialisasi struct, menetapkan nilai untuk variabel di dalamnya, dan juga bawaan pencetakan.

package main

import "fmt"

type Rectangle struct {
    length, width int 
    name string
}

func main() {
    r1 := Rectangle{2, 1, "my_r1"} // menginialisasi nilai dalam urutan mereka yang didefinisikan dalam struct
    fmt.Println("Rectangle r1 is: ", r1) 

    r2 := Rectangle{width:3, name:"my_r2", length:4}  menginialisasi nilai dengan nama variable di beberapa urutan
    fmt.Println("Rectangle r2 is: ", r2) 
    pr := new (Rectangle) // mendapatkan pointer ke jarak dengan kata kunci new
    (*pr).width = 6 //memasang nilai menggunakan notasi yang arahkan dengan pointer
    pr.length = 8 // Go automatically converts memasang nilai menggunakan nilai yang sama. disana adalah no-> operator atau seperti di c++
    pr.name = "ptr_to_rectangle"
    fmt.Println("Rectangle pr as address is: ", pr) //Go menampilkan default atau struct
    fmt.Println("Rectangle pr as value is: ", *pr) // alamat dan nilai dibedakan dengan simbol &
}

Rectangle r1 is: {2 1 my_r1}
Rectangle r2 is: {4 3 my_r2}
Rectangle pr as address is: &{8 6 ptr_to_rectangle}
Rectangle pr as value is: {8 6 ptr_to_rectangle}

Beberapa hal yang perlu diperhatikan di sini :

* Agan dapat menginisialisasi nilai-nilai dalam struct dengan menyebutkan hal itu dalam kurung kurawal sesuai urutan di mana mereka muncul, masing-masing dipisahkan dengan koma. r1: = Rectangle {2, 1, "my_r1"}

* Agan dapat menginisialisasi nilai dengan memberikan nama variabel dan nilainya dipisahkan oleh titik dua. r2: = Rectangle {width: 3, Nama: "my_r2", panjang: 4}

* Agan bisa mendapatkan pointer ke contoh struct yang baru dibuat dengan menggunakan kata kunci new.

* Pointer yang diperoleh, dapat digunakan dengan atau tanpa menggunakan operator * untuk mendapatkan variabel di dalamnya

* Go menyediakan mekanisme cetak default untuk struct berdasarkan nilai-nilainya.

• Enkapsulasi dan visibilitas struct dan variabel

Bahasa pemrograman lain menggunakan beberapa kata kunci seperti public, private, package, protected, dan lain-lain yang memungkinkan pengembang untuk menentukan visibilitas dan aksesibilitas variabel dalam konteks yang berbeda. Ane pikir semua itu benar-benar diperlukan sampai melihat pendekatan Go untuk itu. Pendekatan Go untuk visibilitas variabel dan aksesibilitas sangat sederhana bahwa Ane berpikir itu sangat konyol. Jadi, tanpa basa-basi bahwa jika huruf pertama adalah kapital, itu terlihat di luar paket. 

sebagian kode:

type notExported struct { //struct ini terlihat hanya dalam paket seperti itu untuk memulai dengan huruf kecil.
}

type Exported struct { // variable memulai dengan huruf kapital, jadi kelihatan diluar paket variable ini
    notExportedVariable int // variable memulai dengan huruf kecil, jadi tidak kelihatan di luar paket variable ini    ExportedVariable int //variable memulai dengan huruf kapital, jadi kelihatan diluar paket variable ini
    s string //tidak tersaring 
    S string //tersaring
}   

Memanipulasi String dalam Bahasa Go

• Membandingkan String

str1 := "A string"

str2 := "A " + "string"

if (str1 == str2) {

   fmt.Printf("’%s’ and ’%s’ are equal\n", str1,str2)

}

if (&str1 == &str2) {

   fmt.Printf("’%s’ and ’%s’ are identical\n",str1, str2)

}

str2 += " with a suffix"

if (str1 < str2) {

   fmt.Printf("’%s’ comes before ’%s’\n", str1,str2)

}

       Go string adalah jenis High-Level, dan memiliki konsep kesetaraan built in. Sebagian besar bug dalam kode C berhubungan dengan penanganan string, dan penyempurnaan ini adalah salah satu tugas penting ketika merancang Go. Hal ini jelas ketika membandingkan string dalam dua bahasa. Dalam C, string hanya sebuah pointer ke beberapa byte di suatu tempat di memori. Di Go, itu adalah jenis data yang nyata, dibangun di atas abstraksi tingkat rendah yang sama, tetapi memberikan lebih friendly interface-manusia. Bila menggunakan operator perbandingan yang normal di Go, akan mendapatkan hasil yang masuk akal mengingat isi semantik string. Jika dua string memiliki isi karakter yang sama, mereka dianggap sama. Kurang dan lebih besar daripada operator akan mengembalikan pemesanan berdasarkan pemesanan leksikal mereka. Sayangnya, hal ini menyoroti salah satu daerah di Go yang saat ini sangat lemah. String memerintahkan berdasarkan Unicode yang nilai-nilai karakter konstituen mereka. dalam beberapa lokal, ini benar, tetapi pada orang lain itu tidak. Misalnya, pemesanan antara E dan É sangat tergantung pada lokal. Dalam beberapa, mereka harus bersama-sama, tetapi lokal lain, karakter beraksen datang setelah semua karakter non-beraksen. Go saat ini tidak memberikan berarti lokal-sadar menyortir string. Dalam C++, bisa menggunakan operator overloading untuk mendefinisikan tipe string baru yang didukung lokal-sadar penyortiran. Kurangnya operator overloading di Go membuat ini mungkin.

• Pengolahan String Satu Karakter Sekaligus

func main() {

str := "Étoilé"

// Don’t do this!

for i := 0 ; i<len(str) ; i++ {

   fmt.Printf("%c", str[i])

}

fmt.Printf("\n")

// Do this instead

for _, c := range str {

   fmt.Printf("%c", c)

}

fmt.Printf("\n")

}

Outputnya adalah:

Ãtoilé

Étoilé

      Cara naif iterasi karakter dalam string akan menggunakan loop pengindeksan masing-masing karakter. Ini berjalan tetapi mengiterasi atas setiap byte, tidak setiap karakter. UTF-8 adalah cara pengkodean karakter Unicode. Ada beberapa pengkodean yang berbeda untuk  Unicode, dengan UTF-8 dan UTF-16 menjadi dua yang paling umum. Kedua hal ini adalah multibyte pengkodean karakter, yang berarti bahwa satu karakter dapat diwakili oleh lebih dari satu byte. Bahkan, mereka sama-sama variabel dan panjang pengkodean dengan baik. 8 dan 16 di nama mereka mengacu pada jumlah bit dalam pengkodean terkecil. Karakter dikodekan dalam UTF-8 adalah suatu tempat antara satu dan empat byte panjang, tergantung pada karakter. 128 karakter ASCII semua byte tunggal, sedangkan karakter lain yang lebih panjang. Iterate atas string menggunakan indeks byte, maka kode dapat bekerja. Hanya satu dari karakter dalam bagian sejauh ini memiliki encoding multibyte dalam UTF-8. Jika bahasa Inggris adalah bahasa asli, maka itu sangat mudah untuk menguji kode yang berurusan dengan string untuk input data yang terlihat representatif, dan kemudian memiliki waktu istirahat pertama pada orang lain yang menggunakannya.

• Processing a Partial String One Character at a Time

package
main
import "fmt"
import "unicode/utf8"
func main(){
str :="Étoilé"
rune:=make([]byte,0,4)
for i:=0;i<len(str);i++{
     rune=append(rune,str[i])
     if (utf8.FullRune(rune)){
          char,_:=utf8.DecodeRune(rune)
          fmt.Printf("%c",char)
          rune=rune[0:0]
     }
}
fmt.Printf("\n")
}
        Apabila memiliki string lengkap dalam memori, mudah untuk mengiterasi hal tersebut, tetapi apa yang terjadi ketika menerima teks dari jaringan, atau membaca dari disk? Dalam kedua kasus, biasanya akan berakhir dengan buffer byte penuh dalam UTF-8 format.
Dengan data ASCII, hal ini tidak akan menjadi masalah. Satu byte berarti satu karakter. Dengan UTF-8, satu byte mungkin karakter, atau mungkin byte pertama dalam karakter multibyte. Paket unicode / utf8 menyediakan beberapa manfaat fungsi untuk menyediakan dua apart. Contoh ini dari bagian awal menggunakan string statis, tetapi kode yang sama akan bekerja pada aliran byte yang diperoleh dari berbagai sumber. Ini mengumpulkan byte ke dalam buffer pendek sampai mereka
mewakili karakter lengkap, dan kemudian menerjemahkan mereka.Ini cukup rumit. Ini menunjukkan beberapa fasilitas manipulasi string di Go yang lebih rumit, tetapi dalam kode nyata akan jauh lebih mungkin untuk menggunakan sesuatu di sepanjang baris dari contoh partialStringIterate2.go.

func main() {
str := "Étoilé"
bytes := str[0:7]
str2 := string(bytes)
for i, c := range str2 {
     if (0xFFFD == c) {
          str2 = str2[i:]
          break
     } else {
          fmt.Printf("%c", c)
     }
}
fmt.Printf("\n")
}
        Ini menggunakan iterasi string normal, tetapi pemeriksaan nilai 0xFFFD untuk mewakili Rune tidak valid. Jika menemukan satu, maka menyimpan string parsial dan kemudian lolos dari loop. Untuk efisiensi, bisa melewatkan cek ini untuk sebagian besar string, dan hanya melakukan itu di beberapa byte terakhir. Jika menemukan Rune tidak valid di suatu tempat sebelum akhir string, itu berarti bahwa data masukan adalah contoh invalid. Ini mulai dengan mengiris string dalam urutan tengah multibyte, di tengah-tengah é membuntuti di Etoile. Hal ini sangat mudah dilakukan oleh error . Secara umum, harus menghindari string mengiris langsung. Paket utf8 berisi Iris () fungsi, yang irisan string pada saat run indeks, bukan pada indeks byte.

• Splitting and Trimming Strings

import "strings"

import "fmt"

func main() {

str := "\tThis is a string \n"

str = strings.Trim(str, " \t\n\r")

words := strings.Split(str, " ")

for _, word := range words {

    fmt.Printf("%s\n", word)

}

}

Paket string berisi beberapa fungsi yang membantu untuk memanipulasi data string . Ini termasuk pemecahan dan pencarian string. Salah satu kegiatan yang sangat umum adalah pemangkasan spasi dari ujung string. Baik contoh trimStrings.go dan splitString.go menunjukkan cara untuk melakukan ini. Yang pertama secara eksplisit menyatakan karakter untuk mengobati sebagai ruang: ruang, tab, carriage return, dan line feed. Yang kedua adalah lebih menarik. Ia menggunakan isspace () fungsi dari paket unicode. Fungsi ini mengidentifikasi apakah karakter Unicode digolongkan sebagai spasi. Dapat menggunakan mekanisme yang sama dengan fungsi lain untuk memangkas jenis leading dan trailing data. Paket unicode menyediakan beberapa fungsi lainnya yang dapat digunakan di sini, tetapi juga dapat menentukan sendiri, untuk menentukan satu set algoritma. Jika pernah menggunakan strtok () atau strsep () di C, maka akan memudahkan string membelah di Go. Fungsi Split () dari Paket string membagi string berdasarkan pemisah yang disediakan. Penggunaan untuk membagi string menjadi kata-kata, dipisahkan dengan spasi. Hasilnya adalah sepotong string, sehingga dapat dengan mudah beralih di atas hanya akan setiap slice lain. Memisahkan string pada indeks karakter tertentu adalah sedikit lebih susah. Contoh splitString.go menunjukkan apa yang terjadi ketika mendapatkan salah ini. Hal ini menunjukkan dua cara membelah setengah string .

package main

import "strings"

import "unicode"

import "exp/utf8string"

import "fmt"

func main() {

str := "\tthe important rôles of utf8 text\n"

str = strings.TrimFunc(str, unicode.IsSpace)

// The wrong way

fmt.Printf("%s\n", str[0:len(str)/2])

// The right way

u8 := utf8string.NewString(str)

FirstHalf := u8.Slice(0, u8.RuneCount()/2)

fmt.Printf("%s\n", FirstHalf)

}

outputnya :

the important r?

the important rô

• Menggakan String

str := "A string"

bytes := make([]byte, len(str))

copy(bytes, str)

strCopy := string(bytes)

       String di Go berubah, sehingga tidak perlu untuk menyalinnya. Fungsi Copy () builtin ini memungkinkan untuk menyalin string ke byte slice preallocated, mengembalikan jumlah byte yang disalin. Setelah punya data string dalam sepotong, dapat memodifikasi dengan cara apapun yang diinginkan. Kemudian dapat membuat string baru dari irisan dengan string standar () konversi. Juga dapat menggunakan append () untuk menambahkan string ke sepotong bytes. Catatan bahwa ketika melakukan hal ini data string akan disalin dua kali, sekali ke slice dan sekali untuk membuat string baru. Hal ini cukup efisien, sehingga harus dihindari kecuali untuk string pendek.

Penggunaan Array dan Slices pada bahasa Go

        Hampir semua bahasa pemrograman memiliki struktur bahasa yang disebut dengan array. Tetapi dalam penggunaan bahasanya sangat bervariasi. Oke langsung aja gan... ^_^, array adalah sebuah ukuran dinamis yang dapat diubah untuk menyimpan/mengoleksi benda-benda... dalam array, nilai disimpan dalam blok-blok memori. Dalam Go, array adalah struktur data dengan tingkat yang sangat rendah. Seperti bahasa C, array hanya berisi blok memori. Tetapi perlu diingat bahwa dalam bahasa Go tidak diijinkan melakukan  pointer aritmatika. Dalam Go, pointer dan array adalah jenis yang berbeda. Sehingga dalam penggunaan array dan pointer tidak dapat sembarangan.

Contoh penggunaanya sebagai berikut:

package main

import "fmt"

func main(){

    var a[2]int

    for i:=0;i<15;i++{

        fmt.Printf("element : %d %d",i,a[i])

    }

}

Outputnya adalah:

element:0 0

element:1 0

panic:runtime error:index out of range

Contoh diatas merupakan program sederhana untuk mengakses array dan kemudian mencetak output yang sebenarnya melebihi kapasitas variabel penyimpanan.... 

• Penulisan Array

var a1 [100]int

var matrix [4][4]float64

a2 := [...]int{1, 1, 2, 3, 5}

Seperti disebutkan sebelumnya, jenis array Go adalah kombinasi dari ukuran dan jenis elemen. Ini berarti bahwa ukuran dari array harus diketahui pada waktu kompilasi. Ketiga bentuk deklarasi array pada contoh di atas menunjukkan bagaimana untuk membuat sebuah array. Array dapat berisi tipe, termasuk pointer array. Contoh menciptakan array pada array untuk nilai floating-point. Semua array adalah nilai-nilai. Jika menetapkan dari satu array ke array yang lain, Berarti mendapatkan salinan dari array lain itu.

Contoh:

package main

import "fmt"

func main() {

   a1 := [...]int{1, 2}

   a2 := a1

   a2[0] = 3

   fmt.Printf("%d %d\n", a1[0], a2[0])

}

Outputnya adalah:

1 3

• Slicing Array

var a1 [100]int

firstHalf := a1[:50]

secondHalf := a1[50:]

middle := a1[25:75]

all := a1[:]

       Jika Agan pernah belajar bahasa C, Agan pasti pernah melihat idiom umum yang dipakai seperti melewati pointer dan panjang sebagai argumen untuk fungsi. Hal ini memungkinkan Agan untuk mengijinkan ukuran array yang sewenang-wenang pada Fungsi. Sebuah cara khusus dapat dengan mudah membuat Agan melewati ukuran yang sebenarnya, dan kemudian Agan mengembalikan ke korupsi memori/manipulasi memori. Jika Agan sudah menulis kode JavaScript dengan Ekstensi WebGL, maka ini sudah familiar untuk Agan: Slice Go secara konseptual mirip dengan ArrayBufferView object, sementara Go array mirip dengan ArrayBuffers. Jika Agan mengkompilasi dengan gccgo, maka Agan dapat memeriksa pelaksanaan slice dengan mudah. Ini hanya struktur C yang menyimpan pointer ke array, ukuran, dan kapasitasnya.

Contoh program:

func main() {

   s0 := make([]int, 2, 10)

   s1 := append(s0, 2)

   s2 := append(s0, 3)

   fmt.Printf("Element: %d %d\n", s1[2], s2[2])

   s0 = []int{0, 1}

   s1 = append(s0, 2)

   s2 = append(s0, 3)

   fmt.Printf("Element: %d %d\n", s1[2], s2[2])

}

Outputnya adalah:

Element: 3 3

Element: 2 3

• Truncating Slices

func truncate(slice []int) []int {
var s []int = make([]int, len(slice))
copy(s, slice)
return s

}
      Slice hanya sekilas tentang array. Ini berarti bahwa slice sangat mudah dalam pembuatannya. Ini adalah operasi waktu-konstan, tergantung pada ukuran slice. Sebaiknya, membuat salinan dari array linear waktu operasi, dan sebaiknya dihindari.

• Pengulangan menggunakan Array

package main

import "fmt"

import "time"

func main() {

   var a [100]int

   // The slow way

   for i := 1 ; i < 10 ; i++ {

      fmt.Printf("Element %d is %d\n", i, a[i])

   }

   // The fast way

   subrange := a[1:10]

   for i, v := range subrange {

      fmt.Printf("Element: %d %d\n", i, v)

   }

   // The parallel way

   for i, v := range subrange {

      go fmt.Printf("Element: %d %d\n", i, v)

   }

   time.Sleep(10000000)

}

Outputnya adalah:

Element 1 is 0
Element 2 is 0
Element 3 is 0
Element 4 is 0
Element 5 is 0
Element 6 is 0
Element 7 is 0
Element 8 is 0
Element 9 is 0
Element: 0 0
Element: 1 0
Element: 2 0
Element: 3 0
Element: 4 0
Element: 5 0
Element: 6 0
Element: 7 0
Element: 8 0
Element: 0 0
Element: 1 0
Element: 2 0
Element: 3 0
Element: 4 0
Element: 5 0
Element: 6 0
Element: 7 0
Element: 8 0