Showing posts with label GOLANG. Show all posts
Showing posts with label GOLANG. Show all posts

Sunday, December 9, 2018

Pointer Golang

pointer golang

Pointer Golang

Pointer pada Pemrograman GO digunakan ketika kita memanggil fungsi dan digunakan untuk mengambil nilai atau argumen, argumen itu kemudian disalin ke fungsi, untuk contoh silakan ikuti coding berikut :
package main
import (
"fmt"
)
func zero(x int) { 
x = 0 } 
func main() {
x := 5 
zero(x) 
fmt.Println(x) // x akan tetap 5 
}

pointer golang
hasil coding



Dalam program diatas fungsi zero tidak akan mengubah variabel x asli di fungsi utama. Tetapi bagaimana jika kita menginginkannya untuk merubah nilai tersebut? Salah satu cara untuk melakukannya adalah dengan menggunakan tipe data khusus yang dikenal sebagai pointer pada coding menjadi 'Ptr', seperti coding berikut ini :

package main
import (
"fmt"
)
func zero(xPtr *int) { 
*xPtr = 0 

func main() { 
x := 5 
zero(&x) 
fmt.Println(x) // x menjadi 0 
}

pointer golang
hasil coding


Pointer akan mengambil nilai pada lokasi memori tempat nilai disimpan, dan mengecualikan tempat nilai itu sendiri.  Dengan menggunakan pointer (* int) fungsi zero dapat memodifikasi variabel asli dari nilai 5 menjadi 0.

Operator * dan &

Dalam Go, pointer diwakili dengan menggunakan karakter * (tanda bintang) diikuti oleh type nilai yang disimpan. Dalam fungsi nol xPtr adalah pointer ke int.

* Juga digunakan untuk variabel penunjuk “dereference”. Dereferencingkan pointer memberi kita akses ke nilai yang ditunjukkan oleh pointer. Ketika kita menulis * xPtr = 0 kita seperti memperintahkan "simpan int 0 di lokasi memori xPtr". Jika kita hanya menulis xPtr = 0 sebagai gantinya kita akan mendapatkan kesalahan kompilator karena xPtr tidak akan dianggap sebagai integer.

Kita menggunakan operator & untuk mencari alamat variabel. &x mengembalikan * int (pointer ke int) karena x adalah int. Ini membuat kita memungkinkan untuk memodifikasi variabel asli. &x di fungsi main dan xPtr di nol merujuk ke lokasi memori yang sama.

New

Cara lain untuk mendapatkan pointer adalah dengan menggunakan fungsi New bawaan, seperti coding berikut :

package main
import (
"fmt"
)
func one(xPtr *int) { 
*xPtr = 1 } 
func main() { 
xPtr := new(int) 
one(xPtr) 
fmt.Println(*xPtr) // x adalah 1 
}

pointer golang
hasil coding


New mengambil tipe sebagai argumen, mengalokasikan cukup memori agar sesuai dengan type pada nilai itu dan mengembalikan pointer.

Dalam beberapa bahasa pemrograman ada perbedaan yang signifikan antara penggunaan New dan &.

Pointer jarang digunakan dengan tipe bawaan pada pemrograman Go, tetapi yang akan kita lihat di materi selanjutnya, Pointer sangat berguna ketika dipasangkan dengan struct.

Thursday, December 6, 2018

Tunda, Panik & Pulihkan Golang

tunda panik pulihkan

Tunda, Panik & Pulihkan

Go memiliki pernyataan khusus yang disebut penundaan yang menjadwalkan panggilan fungsi untuk dijalankan setelah fungsi selesai. Perhatikan dan silakan ikuti contoh coding berikut:

package main 
import "fmt" 
func first() { 
fmt.Println("1st") } 
func second() { 
fmt.Println("2nd") } 
func main() { 
defer second() 
first()
}

Tunda, Panik & Pulihkan Golang
hasil coding


Program ini mencetak 1st diikuti oleh 2nd. Pada dasarnya menunda memindahkan panggilan kedua ke akhir fungsi, untuk sebaliknya silakan lihat contoh coding dibawah:
func main () {
second ()
first () }
tunda panik pulihkan golang
hasil coding


menunda sering digunakan ketika sumber daya harus dibebaskan dalam beberapa cara tertentu. Misalnya ketika kita membuka file, kita perlu memastikan untuk menutupnya nanti. Dengan penundaan seperti ini :
f, _: = os.Open (filename) tunda f.Close ()
Cara ini memiliki 3 keuntungan: 
  1. itu membuat panggilan close dekat dengan panggilan open, sehingga lebih mudah untuk dipahami, 
  2. jika fungsi memiliki beberapa pernyataan kembali (mungkin satu dalam if dan satu di lain) close akan terjadi sebelum keduanya dari printah tersebut terjadi, dan 
  3. fungsi yang ditangguhkan dijalankan bahkan jika terjadi panik run-time.

Panik & Pulih

Sebelumnya kita membuat fungsi yang disebut fungsi panik untuk menyebabkan kesalahan waktu proses. Kita dapat menangani panik run-time dengan fungsi pemulihan bawaan. memulihkan menghentikan kepanikan dan mengembalikan nilai yang dilewatkan ke panggilan untuk panik. Kita mungkin tergoda untuk menggunakannya seperti ini:

package main 
import "fmt" 
func main() { 
panic("PANIC") 
str := recover() 
fmt.Println(str) }


Tetapi panggilan untuk memulihkan tidak akan pernah terjadi dalam kasus ini karena panggilan untuk panik segera menghentikan eksekusi fungsi. Sebaliknya kita harus memasangkannya dengan penundaan seperti coding berikut:

package main
import "fmt"
func main() { 
defer func() { 
str := recover() 
fmt.Println(str) }()
panic("PANIC") }

Tunda, Panik & Pulihkan Golang
hasil coding


Kepanikan umumnya menunjukkan kesalahan programmer (misalnya mencoba mengakses indeks array yang di luar batas, lupa untuk menginisialisasi peta, dll) atau kondisi luar biasa yang tidak ada cara mudah untuk memulihkannya. (Oleh karena itu diberi nama "PANIC")

Wednesday, December 5, 2018

Rekursi GOLANG

REKURSI GOLANG

Rekursi

Rekursi adalah suatu fungsi yang dapat memanggil dirinya sendiri. Berikut ini adalah salah satu cara untuk menghitung faktorial angka, silakan masukkan coding berikut :
KALIAN BISA MENCOBANYA KLIK DISINI

package main
import (
"fmt"
)
func factorial(x uint) uint {
    if x == 0 {
        return 1
    }
    return x * factorial(x-1)
}
func main(){
    fmt.Println(factorial(2))
}

rekursi golang
hasil coding


fungsi diatas akan dapat menghitung nilai faktorial. Kita bisa menggunakan unit (unsigned integer) karena inputan harus berupa bilangan positif. Integer dapat menampung bilangan negatif dan positif oleh karena itu uint dapat dipilih sebagai tipe data untuk parameter.

Untuk lebih memahami bagaimana fungsi ini berfungsi, bahsa manusianya akan seperti ini :

  • Apakah x == 0? Tidak. (X adalah 2) 
  • Temukan faktorial x - 1 
  • Apakah x == 0? Tidak. (X adalah 1) 
  • Temukan faktorial x - 1 
  • Apakah x == 0? Ya, return 1. 
  • return 1 * 1 
  • return 2 * 1


Penutupan dan rekursi adalah teknik pemrograman yang kuat yang membentuk dasar paradigma yang dikenal sebagai pemrograman fungsional. Kebanyakan orang akan menemukan pemrograman fungsional lebih sulit dimengerti daripada pendekatan berdasarkan pada loop, if, variabel dan fungsi sederhana.

Tuesday, December 4, 2018

CLOSURE GOLANG

CLOSURE GOLANG

CLOSURE GOLANG

Dimungkinkan untuk membuat fungsi di dalam fungsi:
KALIAN BISA MENCOBANYA KLIK DISINI
func main() { 
add := func(x, y int) int { 
return x + y } 
fmt.Println(add(1,1)) }

CLOSURE GOLANG
hasil coding

add adalah variabel lokal yang memiliki tipe func (int, int) int (fungsi yang mengambil dua int dan mengembalikan int).

Ketika kamu membuat fungsi lokal seperti ini kamu juga memiliki akses ke variabel lokal lainnya (ingat ruang lingkup dari materi sebelumnya):

func main() { 
x := 0 
increment := func() int {
 x++ 
return x } 
fmt.Println(increment()) 
fmt.Println(increment()) }

closure golang
hasil coding


increment menambahkan 1 ke variabel x yang didefinisikan dalam ruang lingkup fungsi utama.

Variabel x ini dapat diakses dan dimodifikasi oleh fungsi increment. Inilah mengapa pertama kalinya kita memanggil increment, kita melihat 1 ditampilkan, untuk kedua kalinya kita menyebutnya, kita melihat 2 ditampilkan.

Fungsi seperti ini secara bersamaan dengan variabel non-lokal referensi dikenal sebagai closure.

Dalam hal ini increment dan variabel x membentuk closure.

Salah satu cara menggunakan closure adalah dengan menulis fungsi yang mengembalikan fungsi lain yang saat dipanggil dapat menghasilkan urutan angka. Misalnya coding dibawah ini adalah cara bagaimana kita dapat menghasilkan semua nomor genap:

func makeEvenGenerator() func() uint { 
i := uint(0) 
return func() (ret uint) { 
ret=i 
i+=2 
return } } 
func main() { 
nextEven := makeEvenGenerator() 
fmt.Println(nextEven()) // 0 
fmt.Println(nextEven()) // 2 
fmt.Println(nextEven()) // 4
 }

closure golang
hasil coding


makeEvenGenerator mengembalikan fungsi yang menghasilkan angka genap, setiap kali dipanggil menambah 2 ke variabel i lokal yang tidak seperti variabel lokal normal hanya bertahan antara panggilan, untuk lebih jelas silakan saja ganti angka 4 menjadi 5.

GOLANG Mengembalikan Banyak Nilai dan Fungsi Variadik

GOLANG Mengembalikan Banyak Nilai dan Fungsi Variadik

Mengembalikan Banyak Nilai

Go juga mampu mengembalikan beberapa nilai dari suatu fungsi, seperti koding berikut ini :
KALIAN BISA MENCOBANYA KLIK DISINI
func f() (int, int) {
return 5, 6}
 func main() {
x,y:= f()}

GOLANG
hasil coding


Tiga perubahan diperlukan: ubah jenis kembalian berisi beberapa jenis yang dipisahkan oleh tanda koma "," , ubah ekspresi setelah pengembalian sehingga berisi beberapa ekspresi yang dipisahkan , dan akhirnya ubah pernyataan penugasan sehingga beberapa nilai berada di sisi kiri := atau =.
Beberapa nilai sering digunakan untuk mengembalikan nilai kesalahan bersamaan dengan hasilnya (x, err:= f ()), atau boolean untuk menunjukkan keberhasilan (x, y:= f ()).

Fungsi Variadik

Ada formulir khusus yang tersedia untuk parameter terakhir dalam fungsi Go:
KALIAN BISA MENCOBANYA KLIK DISINI
func add(args ...int) int { 
 total := 0 
 for _, v := range args { 
 total += v } 
 return total } 
 func main() {
fmt.Println(add(1,2,3)) }

GOLANG
hasil coding

Dengan menggunakan ... sebelum nama jenis parameter terakhir kamu dapat menunjukkan bahwa dibutuhkan nol atau lebih dari parameter tersebut. Dalam hal ini kita mengambil nol atau lebih banyak int.

Kita menjalankan fungsi add seperti fungsi lain kecuali kita dapat melewati int sebanyak yang kita inginkan.

Inilah cara coding tepatnya bagaimana fungsi fmt.Println diimplementasikan:

func Println(a ...interface{}) (n int, err 
error)

Fungsi Println mengambil sejumlah nilai dari jenis apa pun. (Jenis antarmuka {} khusus akan dibahas lebih detail di materi selanjutnya.

Kita juga dapat mengirimkan sepotong int dengan mengikuti irisan dengan ...  seperti berikut :

func main() {
 xs := []int{1,2,3} 
fmt.Println(add(xs...)) }

golang
hasil coding


Monday, December 3, 2018

FUNCTIONS GOLANG

FUNCTIONS GOLANG

FUNCTIONS GOLANG

Functions atau fungsi adalah bagian independen dari kode yang memetakan nol atau lebih parameter input ke nol atau lebih banyak parameter output. 

Fungsi (juga dikenal sebagai prosedur atau subrutin) sering digambarkan sebagai kotak hitam: (kotak hitam mewakili fungsi)

Sampai materi ini program yang kita tulis di Go hanya menggunakan satu fungsi:

func main () {}

Kita sekarang akan mulai menulis program yang menggunakan lebih dari satu fungsi.

Fungsi Kedua 

Ingat program ini dari materi sebelumnya :
KALIAN BISA MENCOBANYA KLIK DISINI

func main() {
xs := []float64{98,93,77,82,83} 

total := 0.0 
for _, v := range xs {
 total += v }
 fmt.Println(total / float64(len(xs))) 
}

functions golang
hasil coding

Program ini menghitung rata-rata dari serangkaian angka. Menemukan rata-rata seperti ini adalah masalah yang sangat umum, jadi akan ideal untuk definisi sebagai fungsi.

Fungsi rata-rata perlu mengambil sepotong float64 dan mengembalikan satu float64.

Masukkan coding berikut ini sebelum fungsi utama:

func rata-rata(xs []float64) float64 { 
 panic("Not Implemented") }

Fungsi dimulai dengan fungsi kata kunci, diikuti oleh nama fungsi. Parameter (input) dari fungsi didefinisikan seperti ini : namatype, namatype , ….

Fungsi kita memiliki satu parameter (daftar skor) yang kita beri nama xs. Setelah parameter, kita masukkan jenis kembalinya. Secara kolektif parameter dan jenis kembalinya dikenal sebagai tanda tangan fungsi.

Akhirnya kita memiliki tubuh fungsi yang merupakan serangkaian pernyataan antara kurung kurawal "{}".

Dalam tubuh ini kita memanggil fungsi bawaan yang disebut panik yang menyebabkan kesalahan waktu proses. (Kita akan melihat lebih banyak lagi tentang kepanikan nanti di materi selanjutnya).

Menulis fungsi bisa jadi sulit, jadi adalah ide yang baik untuk memecah proses menjadi bagian yang dapat dikelola, daripada mencoba untuk mengimplementasikan semuanya dalam satu langkah besar.

Sekarang mari kita ambil kode dari fungsi utama kita dan pindahkan ke fungsi rata-rata kita:

func avarage(xs []float64) float64 {
 total := 0.0
 for _, v := range xs { 
 total += v }
 return total / float64(len(xs)) }

Perhatikan bahwa kita mengubah fmt.Println menjadi return. Pernyataan return menyebabkan fungsi untuk segera berhenti dan mengembalikan nilai setelah itu ke fungsi yang disebut seperti ini.

Ubah func main agar terlihat seperti ini:

func main () {
xs: = [] float64 {98,93,77,82,83}
fmt.Println (avarage (xs))}

functions golang
hasil coding

Menjalankan program ini seharusnya memberikan kamu hasil yang sama persis dengan yang asli.

Beberapa hal yang perlu diingat:

#Nama-nama parameter tidak harus cocok dalam fungsi panggilan. Misalnya contoh coding ini:
func main () {someOtherName: = [] float64 {98,93,77,82,83} fmt.Println (avarage (someOtherName))}
Dan program kita akan tetap berfungsi.

#Fungsi tidak memiliki akses ke apa pun dalam fungsi panggilan. Contoh coding ini tidak akan berfungsi:
func f () {fmt.Println (x)} func main () {x: = 5 f ()}

Kita seharusnya melakukan ini:
func f (x int) {fmt.Println (x)} func main () {x: = 5 f (x)}

Atau ini:
var x int = 5 func f () {fmt.Println (x)} func main () {f ()}


#Fungsi dibangun dalam "tumpukan". Misalkan kita menulis coding seperti ini:
func main () {fmt.Println (f1 ())} func f1 () int {return f2 ()} func f2 () int {return 1}

Setiap kali kita memanggil fungsi, kita mendorongnya ke tumpukan panggilan dan setiap kali kita kembali dari fungsi, kita memunculkan fungsi terakhir dari tumpukan.

#Kita juga dapat memberi nama jenis pengembalian:
func f2 () (r int) {r = 1 return}



Thursday, November 29, 2018

MAP Golang

map golang

MAP GOLANG

MAP adalah aneka koleksi pasangan kunci nilai yang tidak berurutan. Juga dikenal sebagai Array Asosiatif, tabel hash atau kamus. MAP digunakan untuk mencari nilai dengan kunci yang terkait. Berikut ini contoh MAP di Go  :
var x map [string] int
Type MAP diwakili oleh MAP kata kunci, diikuti oleh type kunci dalam tanda kurung dan akhirnya type nilai. Jika kamu membaca ini dengan bahasa manusia kamu bisa mengatakan "x adalah MAP string ke int."

Seperti MAP Array dan Sice dapat diakses menggunakan tanda kurung. Coba jalankan program berikut,KLIK DISINI UNTUK MENCOBANYA:
package main
import (
"fmt"
)
var x map [string]
int x ["key"] = 10
fmt.Println (x)
}
map golang

Kamu seharusnya melihat kesalahan yang seprti ini:
prog.go:27:20: syntax error: unexpected newline, expecting typeprog.go:28:1: syntax error: non-declaration statement outside function body
Saat ini kamu hanya melihat kesalahan waktu kompilasi. Ini adalah contoh kesalahan runtime. Seperti namanya akan menyiratkan, kesalahan runtime terjadi ketika kamu menjalankan program, sementara kesalahan waktu kompilasi terjadi ketika kamu mencoba untuk mengkompilasi program.

Masalah dengan program disini adalah MAP harus diinisialisasi sebelum bisa digunakan. Kita seharusnya mengcoding seperti ini:
package main
import (
"fmt"
)
func main() {
x:=make(map [string] int)
x ["key"] = 10
fmt.Println (x ["key"])
}
map golang

Jika kamu menjalankan program ini, kamu akan melihat 10 ditampilkan. Pernyataan x ["key"] = 10 mirip dengan apa yang kita lihat dengan Array tetapi kuncinya bukannya integer, tetapi string karena jenis kunci MAP adalah string. Kamu juga dapat membuat peta dengan jenis kunci int seperti ini :
package main
import (
"fmt"
)
func main() {
x:=make (map[int]int)
x [1] = 10
fmt.Println (x [1])
}
map golang

Ini terlihat sangat mirip dengan array tetapi ada beberapa perbedaan. 
  • Pertama pada panjang MAP ,Array harus ditentukan dengan melakukan len(x), tetapi pada MAP tidak dan dapat berubah ketika kita menambahkan item baru ke dalamnya. Ketika pertama kali dibuat memiliki panjang 0, setelah x [1] = 10 memiliki panjang 1. 
  • Kedua MAP tidak berurutan. Kita memiliki x [1], dan dengan larik yang menyiratkan harus ada x [0], tetapi peta tidak memiliki persyaratan ini.

Kamu juga dapat menghapus item dari MAP menggunakan fungsi hapus bawaan:
delete(x, 1)
Mari kita lihat contoh program lain yang menggunakan peta:
package main
import "fmt"
func main() {
elements := make(map[string]string)
elements["H"] = "Hydrogen"
elements["He"] = "Helium"
elements["Li"] = "Lithium"
elements["Be"] = "Beryllium"
elements["B"] = "Boron"
elements["C"] = "Carbon"
elements["N"] = "Nitrogen"
elements["O"] = "Oxygen"
elements["F"] = "Fluorine"
elements["Ne"] = "Neon"
fmt.Println(elements["Li"])
}
map golang

Elemen adalah MAP yang mewakili 10 unsur pertama yang diindeks oleh simbolnya. Ini adalah cara yang sangat umum menggunakan MAP: sebagai tabel pencarian atau kamus. Misalkan kita mencoba mencari elemen yang tidak ada:
fmt.Println (elemen ["Un"])
Jika kamu menjalankan ini, Kamu akan melihat undefined: elemen. Secara teknis, sebuah MAP mengembalikan nilai nol untuk jenis nilai (untuk string adalah string kosong). Meskipun kita dapat memeriksa nilai nol dalam suatu kondisi (elemen ["Un"] == "") Go menyediakan cara yang lebih baik:
name, ok:= elements ["Un"]
fmt.Println (name, ok)
map

atau ini
map


Mengakses elemen map dapat mengembalikan dua nila. Nilai pertama adalah hasil pencarian, yang kedua memberitahu kita apakah pencarian berhasil atau tidak. Di Go, kita sering melihat kode seperti ini:
if name, ok := elements["Un"]; ok {
fmt.Println(name, ok) }
Pertama kita mencoba mendapatkan nilainya dari map, maka jika berhasil kita menjalankan kode di dalam blok.

Seperti yang kita lihat dengan array, ada juga cara yang lebih pendek untuk membuat map :
package main
import "fmt"
func main() {
elements := map[string]string{
"H": "Hydrogen",
"He": "Helium",
"Li": "Lithium",
"Be": "Beryllium",
"B": "Boron",
"C": "Carbon",
"N": "Nitrogen",
"O": "Oxygen",
"F": "Fluorine",
"Ne": "Neon", }
fmt.Println(elements["Li"])
name, ok:= elements ["Li"]
fmt.Println (name, ok)
}
map
MAP juga sering digunakan untuk menyimpan informasi umum. Mari kita memodifikasi program kita sehingga hanya menyimpan nama elemen, kita menyimpan status standarnya juga:
package main
import "fmt"
func main() {
elements := map[string]map[string]string{
"H": map[string]string{
"name":"Hydrogen",
"state":"gas", },
"He": map[string]string{
"name":"Helium",
"state":"gas", },
"Li": map[string]string{
"name":"Lithium",
"state":"solid", },
"Be": map[string]string{
"name":"Beryllium",
"state":"solid", },
"B":  map[string]string{
"name":"Boron",
"state":"solid", },
"C":  map[string]string{
"name":"Carbon",
"state":"solid", },
"N":  map[string]string{
"name":"Nitrogen",
"state":"gas", },
"O":  map[string]string{
"name":"Oxygen",
"state":"gas", },
"F":  map[string]string{
"name":"Fluorine",
"state":"gas", },
"Ne":  map[string]string{
"name":"Neon",
"state":"gas", },
}
if el, ok := elements["Li"];
ok {
fmt.Println(el["name"],
el["state"]) }
}
Perhatikan bahwa jenis MAP telah berubah
map [string] string untuk memetakan [string] petakan string [string]. 

Kita sekarang memiliki map string untuk memetakan string ke string. map luar digunakan sebagai tabel pencarian berdasarkan simbol elemen, sedangkan map bagian dalam digunakan untuk menyimpan informasi umum tentang elemen. .

Tuesday, November 27, 2018

Slice Pada Golang

slice

Slice

Slice/Irisan adalah segmen array. Seperti array array dapat diindeks dan memiliki panjang. Tidak seperti array, panjang ini diperbolehkan untuk berubah. Berikut contoh slice golang :
 var x [] float64
Satu-satunya perbedaan antara slice dan array adalah panjang yang hilang di antara tanda kurung. Dalam hal ini x telah dibuat dengan panjang 0.

Jika kamu ingin membuat slice kamu harus menggunakan fungsi make built-in seperti berikut :
x: = buat ([] float64, 5)
Ini menciptakan sebuah slice yang terkait dengan array float64 yang mendasarinya 5. Slice selalu dikaitkan dengan beberapa array, dan meskipun mereka tidak pernah bisa lebih panjang dari array, tetapi mereka bisa lebih kecil. Fungsi make juga memungkinkan parameter ke-3 seperti ini :
x: = buat ([] float64, 5, 10)
10 mewakili kapasitas array yang mendasari  poin slice,dan 5 yang mengisinya.
urut

Cara lain untuk membuat slice/irisan adalah dengan menggunakan ekspresi [rendah: tinggi] seperti berikut :
arr: = [] float64 {1,2,3,4,5} x: = arr [0: 5]
rendah adalah indeks tempat memulai irisan dan tinggi adalah indeks tempat untuk mengakhirinya (tetapi tidak termasuk indeks itu sendiri). Misalnya ketika arr [0: 5] mengembalikan [1,2,3,4,5], arr [1: 4] mengembalikan [2,3,4].

Untuk kenyamanan kita juga diperbolehkan untuk menghilangkan rendah, tinggi atau bahkan rendah dan tinggi. arr [0:] sama dengan arr [0: len (arr)], arr [: 5] sama dengan arr [0: 5] dan arr [:] sama dengan arr [0: len (arr) )].

Fungsi Slice

Go mencakup dua fungsi built-in untuk membantu kamu menggunakan irisan: 
  1. Tambahkan 
  2. Salin

Berikut ini contoh Tambahan,KALIAN BISA MENCOBANYA DISINI KLIK INI :
package main
import (
"fmt"
)
func main() {
slice1 := []int{1,2,3}
slice2 := append(slice1, 4, 5)
fmt.Println(slice1, slice2) }
golang
Setelah menjalankan program ini, slice1 memiliki [1,2,3] dan slice2 memiliki [1,2,3,4,5]. append membuat irisan baru dengan mengambil slice yang ada (argumen pertama) dan menambahkan semua argumen berikut ke dalamnya.

Berikut ini contoh Salin:
package main
import (
"fmt"
)
func main() {
slice1 := []int{1,2,3}
slice2 := make([]int, 2)
copy(slice2, slice1)
fmt.Println(slice1, slice2) }
golang

Setelah menjalankan program ini, slice1 memiliki [1,2,3] dan slice2 memiliki [1,2]. Isi slice1 disalin ke slice2, tetapi karena slice2 memiliki ruang hanya untuk dua elemen, hanya dua elemen pertama dari slice1 yang disalin.😊

Sunday, November 25, 2018

Array Pada Golang

array golang

Array

Array adalah sebuah urutan bernomor elemen type tunggal dengan panjang yang tetap. Di Go bisa digunakan array seperti koding ini:
var x [5] int
Arti dari baris diatas yaitu x adalah contoh variabel array yang terdiri dari 5 urutan bertipe integer. Mari kita coba membuat codingan array kalian bisa mencobanya klik disini :
package main
import "fmt"
func main() {
var x [5]int
x[4] = 100
fmt.Println(x) }
hasil
Kamu akan melihat hasil output ini:
[0 0 0 0 100]
x [4] = 100 jika dibaca akan seperti ini "mengatur elemen ke-5 dari array x menjadi 100". Kelihatannya agak aneh bahwa x [4] mewakili elemen ke-5 dan bukannya yang ke-4. Untuk urutan array tidak sama seperti string, array diindeks mulai dari 0

Kita bisa mengubah fmt.Println (x) menjadi fmt.Println (x [4]) dan kita juga akan mendapatkan hasil yang sama yaitu 100.

Berikut ini contoh program lain yang menggunakan array:
package main
import "fmt"
func main() {
var x [5]float64
x[0] = 98
x[1] = 93
x[2] = 77
x[3] = 82
x[4] = 83
var total float64 = 0
for i := 0;
i < 5; i++ {
total += x[i] }
fmt.Println(total / 5)
}
golang
Program ini menghitung rata-rata dari serangkaian nilai tes. Jika kamu menjalankannya, kamu akan melihat 86.6. Mari kita telusuri arti dari program diatas:
  • Pertama-tama kita membuat larik panjang 5 untuk menahan nilai tes kita, kemudian kita mengisi setiap elemen dengan nilai 
  • Selanjutnya kita menyiapkan loop untuk menghitung skor total
  • Akhirnya kita membagi skor total dengan jumlah elemen untuk menemukan rata-rata

Program ini berfungsi, tetapi Go menyediakan beberapa fitur yang dapat kamu gunakan untuk lebih praktisnya. Pertama 2 bagian ini: i<5 dan total/5 harus menentukannya terlebih dahulu. Katakanlah kamu mengubah jumlah nilai dari 5 menjadi 6. Kamu juga perlu mengubah kedua bagian ini. Akan lebih baik menggunakan panjang dari array sebagai gantinya, Silakan lakukan perubahan ini dan jalankan program :
package main
import "fmt"
func main() {
var x [5]float64
x[0] = 98
x[1] = 93
x[2] = 77
x[3] = 82
x[4] = 83
var total float64 = 0
for i := 0;
i < len(x);
i++ { total += x[i] }
fmt.Println(total/len(x))
}
golang
Kamu pasti mendapatkan kesalahan:

invalid operation: total / len(x) (mismatched types float64 and int)

Masalahnya di sini adalah bahwa len (x) dan total memiliki tipe yang berbeda. total adalah float64 sementara len (x) adalah int. Jadi kita perlu mengonversi len (x) menjadi float64:
fmt.Println (total / float64 (len (x)))
golang
Ini adalah contoh konversi type. Secara umum untuk mengkonversi antar type kamu harus menggunakan nama type seperti fungsi.

Perubahan lain untuk program yang bisa kita buat adalah menggunakan bentuk khusus untuk loop:
var total float64 = 0
for i, value := range x {
total += value }
fmt.Println(total / float64(len(x)))
golang
Dalam hal ini untuk loop i mewakili posisi saat ini dalam array dan nilai adalah sama dengan x [i]. Kita menggunakan rentang kata kunci yang diikuti oleh nama variabel yang ingin kita alihkan.

Menjalankan program ini akan menghasilkan kesalahan lain:
prog.go:23:5: i declared and not used
Kompiler Go tidak akan memungkinkan kamu untuk membuat variabel yang tidak pernah kamu gunakan. Karena kita tidak menggunakan i di dalam lingkaran kita, kita perlu mengubahnya menjadi seperti ini:
var total float64 = 0
for _, value := range x {
total += value }
fmt.Println(total / float64(len(x)))
golang
Sebuah _ (underscore) digunakan untuk memberi tahu compiler bahwa kita tidak memerlukan ini. (Dalam hal ini kita tidak memerlukan variabel iterator).

Go juga menyediakan sintaks yang lebih pendek untuk membuat array:
x: = [5] float64 {98, 93, 77, 82, 83}
Kita tidak perlu lagi menentukan type karena Go bisa mengetahuinya. Terkadang array seperti ini bisa terlalu panjang untuk dipasang pada satu baris, jadi Go memungkinkan kamu untuk memecah dan menyingkatnya seperti ini:
x: = [5] float64 {98, 93, 77, 82, 83,}
 golang
Perhatikan trailing ekstra, setelah 83 tidak ada kendala yang terjadi karena Go sudah memahami bahwa baris tersebut adalah array. 

Untuk dengan mudah menghapus elemen dari array dengan cara mengomentari baris seperti ini:
x: = [4] float64 {98, 93, 77, 82, // 83,}

Wednesday, November 21, 2018

Switch Case Golang

switch case

Switch Case Golang

Pernyataan Switch hampir sama dengan Pernyataan IF. Sebagai contoh Switch dapat berguna untuk kita jika ingin membuat sebuah program yang mencetak nama-nama angka dalam bahasa Indonesia dan sebagainya. Mari kita coba peraktekan dengan coding dibawah berikut dengan menggunakan IF terlebih dahulu:
if i == 0 {     

fmt.Println("kosong") 
} else if i == 1 {    
fmt.Println("satu") 
} else if i == 2 {    
fmt.Println("dua") 
} else if i == 3 {    
fmt.Println("tiga") 
} else if i == 4 {     
fmt.Println("empat") 
} else if i == 5 {    
fmt.Println("lima") }
golang

Karena menulis program dengan cara diatas akan sangat membosankan. Mari kita coba dengan pernyataan switch. Kamu dapat menulis ulang program kamu agar terlihat lebih simple menggunakan Switch seperti ini:
switch i { 

case 0: fmt.Println("kosong") 
case 1: fmt.Println("satu") 
case 2: fmt.Println("dua") 
case 3: fmt.Println("tiga") 
case 4: fmt.Println("empat") 
case 5: fmt.Println("limat") 
default: fmt.Println("nomor tidak diketahui") }
golang

Sebuah pernyataan switch dimulai dengan kata kunci switch diikuti dengan ekspresi (dalam hal ini i) dan kemudian serangkaian kasus. Nilai ekspresi dibandingkan dengan ekspresi lainnya mengikuti setiap kata kunci kasus. Jika mereka setara maka pernyataan akan dieksekusi.

Seperti pernyataan if setiap kasus diperiksa dari atas ke bawah dan yang pertama untuk berhasil dipilih. Switch juga mendukung kasus default yang akan terjadi jika tidak ada kasus yang cocok dengan nilainya. (Mirip seperti else dalam pernyataan if).😊

IF Pada Golang

if golang

IF GOLANG

Mari kita memodifikasi program yang kita buat di materi sebelumnya sehingga program yang sebelumnya hanya mencetak angka 1-10 pada setiap baris, maka kita tambahkan untuk menentukan apakah angka tersebut genap atau ganjil. Seperti ini:
  1. ganjil
  2. genap
  3. ganjil
  4. genap
  5. ganjil
  6. genap
  7. ganjil
  8. genap
  9. ganjil
  10. genap

Pertama kita perlu tau cara menentukan apakah suatu angka genap atau ganjil. Cara mudah untuk mengatakan adalah membagi angka tersebut dengan 2. Jika tidak ada yang tersisa maka jumlahnya genap. Jadi bagaimana kita menemukan hasilnya menggunakan pembagian di Go? Mari kita gunakan operator%. 1%2 sama dengan 1, 2%2 sama dengan 0, 3%2 sama dengan 1 dan seterusnya.

Selanjutnya kita membutuhkan cara untuk memilih hasil berdasarkan suatu kondisi. Untuk itu kita akan menggunakan pernyataan if:
if i%2 == 0
{// even}
else {// odd}
Pernyataan if mirip dengan pernyataan for itu karena memiliki kondisi yang diikuti oleh blok hasil. Pernyataan if juga memiliki bagian opsional yang lain. kondisi if dievaluasi menjadi true, maka blok  hasil setelah kondisi akan dijalankan, jika tidak maka blok hasil tersebut akan dilewati dan pernyataan else if yang lain yang akan berjalan.

Pernyataan IF juga memiliki bagian lain yaitu ELSE IF :
if i%2 == 0 { 
//divisible by 2 }
else if i%3 == 0 { 
 //divisible by 3 }
else if i%4 == 0 { 
 // divisible by 4 }

Kondisinya akan dicentang dari atas ke bawah dan yang pertama menghasilkan true akan memiliki blok terkait yang dieksekusi. Tak satu pun dari blok lain akan tereksekusi meskipun kondisi bisa terpenuhi (Jadi misalnya nomor 8 dapat dibagi oleh 4 dan 2, tetapi // habis dibagi dengan 4 blok tidak akan pernah dieksekusi karena // habis dibagi 2 blok dilakukan oleh kondisi pertama)

Mari kita coba materi diatas pada coding program berikut :
package main
import (
"fmt"
)
func main() { 
for i := 1;
i <= 10; i++ { 
if i % 2 == 0 {         
fmt.Println(i, "GENAP")     
} else {         
fmt.Println(i, "GANJIL")     

}
}
golang
hasilnya akan memunculkan deret angka 1-10 dan status ganjil genap

Jika koding diatas diungkapkan dengan bahasa indonesia akan seperti ini :

  • Buat variabel i tipe int dan berikan nilai 1 
  • Apakah i kurang dari atau sama dengan 10? Jawaban Ya: jalankan bloknya
  • Apakah sisa i dibagi 2 sama dengan 0? Jawaban Tidak: lompat ke blok selanjutnya
  • Yaitu cetak i diikuti oleh kata ganjil 
  • Increment i (pernyataan setelah kondisi) 
  • Apakah i kurang dari atau sama dengan 10? Jawaban Ya: jalankan bloknya 
  • Apakah sisa i dibagi 2 sama dengan 0? Jawaban Ya: lompat ke blok if 
  • Print i diikuti dengan kata genap
  • ...
Sekian pembahasan kita tentang IF pada Golang. Lanjut dimateri selanjutnya ya 😊

Tuesday, November 20, 2018

Pernyataan FOR GOLANG

Pernyataan FOR GOLANG

Pernyataan FOR berguna untuk kita dapat mengulang daftar pernyataan yang lain beberapa kali. Mari kita coba contoh sederhana dari FOR dengan koding berikut:
package main
import "fmt"
func main() {   
i := 1   
for i <= 10 {       
fmt.Println(i)       
i = i + 1    } }
output membuat urutan angka 1-10

Pertama kita membuat variabel yang disebut i yang kita gunakan untuk menyimpan nomor yang ingin kita cetak. Kemudian kita buat for loop dengan menggunakan kata kunci FOR, selanjutnya kita membuat ekspresi kondisional yang benar atau salah untuk dieksekusi. FOR LOOP berfungsi seperti ini:
  1. Kita mengevaluasi ungkapan i <= 10 ("i kurang dari atau sama dengan 10"). Jika ini bernilai benar maka kita jalankan pernyataan di dalam blok. Kalau tidak, kita melompat ke baris berikutnya dari program setelah blok. (dalam hal ini tidak ada apa-apa setelah pengulangan sehingga kita keluar dari program)
  2. Setelah kita menjalankan pernyataan di dalam blok, kita kembali ke awal pernyataan awal dan ulangi langkah 1.

Garis i = i + 1 sangat penting, karena tanpa jika tidak , i <= 10 akan selalu mengevaluasi ke benar dan program tidak akan pernah berhenti. (Ketika ini terjadi, ini disebut sebagai loop tak terhingga)
Sebagai evaluasi, saya akan menjelaskan urutan program diatas seperti berikut :
  1. Buat variabel bernama i dengan nilai 1 
  2. Apakah i <= 10? jawabannya Iya . 
  3. Cetak i 
  4. Atur i menjadi i + 1 (sekarang i sama dengan 2) 
  5. Apakah i <= 10? jawabannya iya. 
  6. Cetak i 
  7. Atur i menjadi i + 1 (sekarang i sama dengan 3) 
  8. ... (sampai i sama dengan 10)
  9. Atur i menjadi i + 1 (sekarang i sama dengan 11) 
  10. Apakah i <= 10? Jawabannya Tidak. 
  11. Tidak ada yang tersisa untuk dilakukan, jadi program akan keluar


Bahasa pemrograman lain memiliki banyak tipe loop yang berbeda (While Do, Until, foreach, ...) tetapi Go hanya memiliki satu yang dapat digunakan dalam berbagai cara yang berbeda. Program sebelumnya juga bisa ditulis seperti berikut :
func main () {
for i:=1;
i<= 10;
i ++ {
fmt.Println (i)}}

Sekarang ekspresi kondisional juga mengandung dua pernyataan lain dengan titik koma di antara keduanya. Pertama kita memiliki inisialisasi variabel, kemudian kita memiliki kondisi untuk memeriksa setiap kali dan akhirnya kita "menambah" variabel. (menambahkan 1 ke variabel sangat umum sehingga kita memiliki operator khusus: ++. Demikian juga mengurangi 1 dapat dilakukan dengan -)

Kita akan melihat cara pengulangan di GO pada Materi Selanjutnya. 😊

TENTANG SITUS

SITUS INI ADALAH SITUS PEMBELAJARAN PEMROGRAMAN DAN JUGA PEMAHAMAN TERHADAP TEKNOLOGI KOMPUTER. KALIAN BISA MENGIKUTI PEMBELAJARAN PEMROGRAMAN DENGAN BERTAHAP PADA MATERI YANG SUDAH SAYA SEDIAKAN, JIKA ADA MATERI YANG MEMBINGUNGKAN SILAKAN LAKUKAN KOMENTAR PADA MATERI YANG ANDA TANYAKAN ATAU KALIAN BISA MENGHUBUNGI SAYA DIHALAMAN KONTAK.

https://smallseotools.com/