Golang - Bahasa Pemograman Go - Go Programming Language - Google Go

 

OS YG SAYA GUNAKAN

Ubuntu Mate 16.04, 64 bit
Development memakai editor Vim


ASAL USUL BAHASA GO

MENGAPA GO ?

Dari sekian banyak bahasa pemograman, mengapa memilih Go ?
Beberapa alasan:

1. Bahasa Go sederhana. Kalau Anda mengerti bahasa Java, Javascript, C, Objective-C, dll maka mempelajari bahasa Go bukanlah hal sulit.
2. Concurrent. Go dari sejak awal sudah memikirkan cara untuk membuat program yang berjalan dengan menggunakan kemampuan multi-core cpu. Dan kita tahu bahwa hampir semua komputer saat ini (bahkan Hand Phone) sudah multi-core.
3. Kompilasi yg sangat cepat dan effisien.
4. Memory safe
5. Garbage collection
6. Bagi saya Go berada antara pemograman low level dan high level. Ini akan sangat berpengaruh dalam membuat aplikasi, yang kadang kala kita harus masuk ke low level hardware dengan bahasa lain spt C. Dengan Go, semua nya menggunakan bahasa Go.
7. Cocok sekali untuk Cloud Computing. Kalau kita lihat yg menggunakan bahasa Go saat ini contohnya Dropbox, Google, SoundCloud, CloudFlare, Docker and Cloud Foundry; semua bergerak di cloud technology. Dan Cloud adalah masa depan.
8. Static type, compiled

INSTALASI

Download file go1.6.2.linux-amd64.tar.gz dari https://golang.org/dl/

Nb. file mungkin berbeda nama, bahasa Go  diupgrade setiap 6 bulan sekali, kira-kira setiap bulan Februari dan Agustus

Buka terminal, dan jalankan perintah sbb:
$ tar xvf go1.6.2.linux-amd64.tar.gz
$ cd go
$ vim hello.go     //atau gunakan editor lain
 

package main
import "fmt"

func main() {
       fmt.Printf("hello, world\n")
}

$ go run hello.go
hello, world

Kalau sudah mendapatkan output "hello, world" berarti installasi sudah ok

Tunggu dulu. Bukankah ini bahasa yg di compile lalu menghasilkan program yg bisa dijalankan (executable) ?

Ya, anda benar, go run adalah command bantu yg melakukan kompilasi dan menjalankan program anda. Go Run menggunakan directory sementara untuk kompilasi. Setelah program dijalankan, go run akan membersihkan directory tsb.

Mari kita buat executable program dg melakukan compile
$ go build hello.go      //go build adalah perintah untuk
                                   //kompilasi hello.go
$ ls -l hello
-rwxrwxr-x 1 shm shm 2,2M Jun 24 14:03 hello
(sukses compile & menghasilkan program hello yg bisa di jalankan melalui command di terminal)

$ ./hello
hello, world

Mari kita bahas program di atas:
ada : package main
         func main()

Ketika kita menjalankan go run, maka go run akan mencari fungsi main, yaitu func main, yang berada dalam package main.

fmt adalah salah satu standar library. Untuk menggunakan library ini, kita harus melakukan import, yaitu import "fmt"

fmt.Println adalah salah satu fungsi dalam standar library fmt

Ketika kita menjalankan program Go, maka pertama kali Go akan mencari func main(). Untuk melihat apakah memang benar go menjalankan func main, maka kita akan ubah sedikit program di atas:

package main 

import "fmt"

func index() {
       fmt.Printf("hello, world\n")
}

$ go run hello.go

runtime.main: call to external function main.main
runtime.main: main.main: not defined
runtime.main: undefined: main.main

Terbukti, ketika main() diubah menjadi index() maka  terjadi error runtime

Untuk mengetahui informasi ttg fmt.Println maka kita bisa melihat deskripsi dari fungsi tsb dg perintah:
$ godoc fmt Println

func Println(a ...interface{}) (n int, err error)
Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

Go sangat efisien, compiler akan memeriksa apakah program melakukan import atau mendeklarasi variable namun variable tsb tidak digunakan didalam program.
contoh:
Mari kita import library "os", tetapi kita tidak menggunakan library tsb dalam program yg kita buat.

package main 

import ( 

    "fmt"

    "os"

)  

func main() {
       fmt.Printf("hello, world\n")
}

$ go run hello.go
  # command-line-arguments
  ./hello.go:5: imported and not used: "os" 

Terjadi error karena kita import "os" namun library "os" tsb tidak digunakan.

Informasi tentang package lainnya dapat dilihat pada https://golang.org/pkg/

SETTING ENVIRONMENT

Untuk program yg sederhana dan ukuran nya kecil, kita bisa langsung membuat program spt diatas, di folder mana saja. Namun untuk program besar, maka kita harus membuat beberapa direktori. Go sudah menetapkan standar untuk itu. Supaya Go mengetahui directory tempat kita kerja (workspace) dan directory dimana binary file Go Language, maka kita edit .bashrc

$ cd  $HOME
$ vim .bashrc
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

Workspace terdiri dari 3 folder: bin, pkg, src. Maka kita harus buat ke 3 directory ini secara manual:
$ mkdir bin pkg src

Semua program/project kita letakkan di dalam directory src, dan masing-masing project harus dibuat directory.
contoh:
kita buat "hello world"
$ cd $GOPATH/src
$ mkdir hello
$ vim hello.go
 
   package main
   import "fmt"
   func main() {
       fmt.Println("hello world")
   }

$ go run hello.go    // output nya : "hello world"
$ go build             
$ ls -l            // akan ada file executable bernama "hello"

$ go install
go install akan menghasilkan file executable "hello" didalam directory
$GOPATH/bin

$ cd $GOPATH/bin
$ ls -l           // ada ada file executable bernama "hello"
file "hello" ini dapat dijalankan dari directory mana saja. Ingat sewaktu melakukan setup di atas kita menambah path menjadi  $GOPATH/bin

$ cd $HOME
hello           // menghasilkan output : "hello world"

TIPE

Go disebut dengan bahasa yg static type, artinya variable selalu mempunyai tipe tertentu, dan tipe ini tidak bisa diubah. Kalau kita mempunyai variable x bertipe string, lalu kita masukkan nilai integer kedalam x, maka akan error.

Apasaja tipe dari bahasa Go ?

integer

adalah nilai bulat, spt  -100, -99, -3,-2,-1,0,1,2,3,4,.....

Go mempunyai bbrp tipe integer yaitu: uint8, uint16, uint32, uint64, int8, int16, int32, int64  (uint adalah unsigned integer, hanya nilai positif, sedangkan int adalah signed integer : positif dan negatif. Sedangkan angka 8, 16, 32, 64 adalah jumlah bit yg digunakan

Jika kita membuat variable dg tipe int saja (tambah embel-embel 8,15,32,64), maka besarnya bit untuk variable tsb tergantung dari mesin yg kita pakai.

Selain uint dan int diatas, ada juga tipe byte dan rune.
Kedua tipe ini hanyalah alias dari uint dan int
   byte sama dengan uint8 ,  rune sama dengan int32

Floating point

adalah nilai pecahan, spt 1.10, 3.14, 0.005.  Ada dua tipe Floating Point yaitu float32, float64.  Selain itu ada tipe NaN, singkatan Not a Number, seperti  nilai bila 0 / 0  (nol dibagi nol)

Complex Number

Go mendukung complex number dg bilangan imaginer. Untuk menggunakan complex number, variable harus bertipe complex128 untuk 64 bit atau complex64 untuk 32bit

String
merupakan kumpulan karakter. Untuk mendefinisikannya digunakan double quotes contoh : "hello". Single quote digunakan untuk satu char, contoh: 'h', namun ini bukan string melainkan bertipe int32 atau rune
    contoh:
            s := "hello"; fmt.Println(s)    //output adalah "hello"
            c := 'h'       ; fmt.Println(c)   // output adalah 104

Boolean
merupakan nilai yg merepresentasikan benar atau salah (true or false).  Ada 3 tanda operator dalam boolean, yaitu:
         &&  adalah tanda AND
         ||     adalah tanda OR
          !     adalah tanda NOT

    untuk operator AND
        true && true   hasilnya true
        true && false                false
        false && false                false

    untuk operator OR
         true || true     hasilnya true
         true || false                  true
         false || false                 false

    untuk operator NOT
         ! true   hasilnya false
         ! false  hasilnya true

        

VARIABLE   

Variable adalah tempat penyimpanan sementara. Bbrp aturan yg harus ditaati saat menulis variable adalah sbb: huruf pertama variable adalah abjad, lalu diikuti oleh abjad lain, angka, atau underscore ( _ )

contoh variable yg benar:  nama, nomor_1

contoh variable yg salah:   1_angka, $hello

Ada berbagai cara untuk mendefinisikan variable:


cara 1:

var  namaVariable  type
var namaVariable type = value
contoh:
     var  salam  string
     var  salam  string = "Selamat pagi Indonesia"

cara 2:
var namaVariable = nilai, disini type tidak perlu ditulis
contoh:
     var salam = "Selamat pagi Indonesia"

cara 3:
namaVariable := nilai, disini kata var dan tipe tidak perlu ditulis
    salam := "Selamat pagi Indonesia"

Multiple variable/assignment

Beberapa cara mendefinisikan multiple variable:
contoh:
var a =1
var b = 2.5
var c = "hello"

dapat disingkat menjadi:
var (
     a = 1
     b = 2.5
     c = "hello"
)

dapat disingkat menjadi:
     var a,b,c = 1, 2.5, "hello"


contoh program

$ vim var.go

package main
import "fmt"

func main() {
    var a int                // tipe ditulis
    a = 100

    var b = 12.345    // tipe tidak ditulis
   
    var c,d uint64 = 1,2    //multivalue, c bernial 1, d bernilai 2
    fmt.Println(a,b,c,d)
}

$ go run var.go
100   12.345  1  2


Kita tidak dapat mendeklarasikan variable dua kali, contoh:
   sapa := "halo"
   sapa :=  "helo"    //error
tapi kita dapat melakukan begini:
   sapa := "halo"
   sapa = "helo"

Ada special variable yaitu underscore "_".  Apapun yg dimasukkan kedalam variable ini akan dibuang - tidak bisa digunakan.
contoh:
    a,b = 1,  "hello"    // a bernilai 1, sedangkan b bernilai "hello"
    _, b = 1, "hello"    // nilai 1 tidak digunakan, b bernilai "hello"


contoh program:
Kita akan hitung luas lingkaran, yaitu phi * r * r

package main

import (
    "fmt"
)

func main() {
    const phi = 22.0 / 7.0
    var r, luas float64

    fmt.Print("Masukkan jari-jari lingkaran: ")
    fmt.Scanf("%f", &r)    //Scanf adalah fungsi untuk meminta input dari keyboard
    luas = phi * r * r
    fmt.Println("Luas lingkaran adalah: ", luas, "\n")
}

Komentar  (comment)

Comment bahasa Go sama dengan bahasa C.
Ada 2 jenis komentar
1. komentar baris (line comment), di awali dengan tanda double slash (//)
2. komentar multiline, di awali dengan /* dan diakhiri */

contoh:

/*  ini adalah multiline comment
    program luas segiempat
    di program oleh : suheimi
    tgl buat              : 01/01/2016
*/

func main(){
   // ini adalah line comment
   // program ini menghitung luas segiempat panjang * lebar
   ...
}

 

CONSTANTS

constant adalah variable yg nilainya tidak bisa diubah lagi.
contoh:
   const PHI = 22.0 / 7.0
   const PHI2 = 3.14
   const satu, dua, tiga = "one", "two", "three"

STRING

string terdiri dari deretan character utf-8, didalam double quotes.
contoh:
sapa1 := "halo"
sapa2 := " apa kabar"
sapa = sapa1 + sapa2     //"halo apa kabar"

sapa = sapa1
            + sapa 2            // ini error

sapa = sapa1 +
            sapa2               // ini benar

Variable string tidak dapat diubah (immutable)
contoh:
s := "hello"
s[0] = "H"     //error

Untuk mengubah "hello" menjadi "Hello" kita dapat melakukan sbb:
    s:= "hello"
    s := "H" + s([1:len(s)])    // s bernilai "Hello"

atau kita dapat juga mengubah ke tipe rune terlebih dahulu
    s := "hello"
    c := []rune (s)
    c[0] = 'H'
    s = string(c)     // kembalikan kebentuk string

contoh program:
$ vim sapa.go

package main

import (
    "fmt"
    "os"
)

func main() {
    nama := os.Args[1]
    sapa1 := "halo"
    sapa2 := "apa kabar"
    sapa := sapa1 + " " + nama + ", " + sapa2
    fmt.Println(sapa)
}

$ go run sapa.go Suheimi
halo Suheimi, apa kabar

FUNCTION (fungsi)

Function memungkinkan kita untuk menyelesaikan pekerjaan yg besar menjadi beberapa pekerjaan kecil. Pekerjaan kecil-kecil ini dapat dibuat oleh kita sendiri, oleh tim kita bahkan oleh orang lain. Function merupakan hal penting dalam bahasa GO

Syntax:
func name (parameters) (result types) {

}

Perhatikan letak kurung kurawal {}. Go akan error bila Anda menulis sbb:
func name()
{
   //error
}

contoh:
func pangkat2 (x int) int {
    return x * x
}
fmt.Println(pangkat2(5))   //output: 25

Penjelasan: x adalah parameter bertipe integer
                   int adalah result type, tipe output yg dihasilkan

contoh:
func luas_segiempat(x, y float64) float64 {
     return x * y
}
fmt.Println(luas_segiempat(1.5, 4))  //output: 6

Penjelasan: x adalah lebar, y adalah panjang bertipe float 64 bit
                   output juga bertipe float64 bit

STRUKTUR

IF statement

if  <true> {
    statement
} else if <true> {
     statement
} else
      statement
}
contoh:
     if usia <= 5 {
         fmt.Println("balita")
     } else if usia <= 17 {
         fmt.Println("remaja")
     } else {
         fmt.Println("dewasa")
     }

Kita dapat melakukan initialize variable pada if statement.
contoh:
    if err:= file.Chmod(777); err != nil {
         log.Stderr(err)
         return err
    }

SWITCH statement

FOR   statement

Bahasa Go hanya punya satu statement untuk looping yaitu FOR loop. Tidak ada while, repeat, foreach dsb.

Beberapa bentuk For:
1. for init; condition; post {}
    contoh, print angka 1 s/d 10

    for i:=1; i<=10; i++ {    //kurung kurawal harus sejajar dg kata "for"
       fmt.Println(i)
    }

   // for loop berikut akan error krn kurung kurawal letaknya salah
   for i:=1; i<=10; i++
   {
       fmt.Println(i)
    }


2.  for condition {}
    ini spt while loop
    contoh:

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

3. for {}
    ini endless loop, tidak akan berhenti
    contoh:

     i:=1
     for {
        fmt.Println(i)
        i++
    }

4. for i, c := range(string) {}
    ini digunakan untuk looping variable string, list, array, etc
    contoh, cetak huruf "hello" satu persatu

         s := "hello"
         for pos, ch := range(s) {
               fmt.Println("Huruf ke : ", pos+1, " adalah ", string(ch))
         }

contoh program:
kita akan membalikkan kata "hello" menjadi "olleh"

package main
import "fmt"

func main() {
       s := "hello"
       a := []rune(s)   // string immutable, dijadikan array of int32 dulu
       for i,j := 0, len(a)-1; i<j; i,j = i+1, j-1 {
          a[i], a[j] = a[j], a[i]
       }
       fmt.Println(string(a))
}


ARRAYS