Go programlama dili olarak da adlandırılan Golang, Google tarafından 2007 yılında tasarlanan açık kaynaklı bir programlama dilidir. Bu dilin 1.0 versiyonu 2012 yılında çıkmıştır. C gibi yapılandırılmış bir programlama dili olup ağ hizmetleri, bulut gibi farklı uygulama türlerine sahiptir. uygulamalar, web uygulamaları vb. Golang dili ile geliştirilebilir. Python gibi birçok paket türünü içerir. Öğrenmenin çok kolay olması bu dili yeni programcılar için popüler kılmaktadır. Bu eğitimde Golang'ı temel bilgilerden öğrenmek için 30 Golang programlama örneği açıklanmıştır.
Önkoşullar:
Golang farklı işletim sistemi türleri tarafından desteklenir. Eğitimin bu bölümünde Golang'ı Ubuntu'ya kurmanın yolu gösterilmiştir. Bu eğitimdeki örnekleri uygulamadan önce sistemi güncellemek ve Golang'ı sisteme yüklemek için aşağıdaki komutları çalıştırın.
$ sudo uygun güncelleme
$ sudo uygun düzenlemek büyümek
Golang'ın yüklü sürümünü kontrol etmek için aşağıdaki komutu çalıştırın.
$ versiyona git
- Merhaba merhaba dünya
- Golang dize değişkenleri
- Golang'ın dizeye int'si
- Golang dizesi içeri T
- Golang dizesi birleştirme
- Golang çok satırlı dize
- Golang bölünmüş dize
- Golang sprintf
- Golang numaralandırması
- Golang yapısı
- Golan dizisi
- Golang setleri
- Döngü için Golang
- Menzil için Golang
- Golang while döngüsü
- Golang devam ediyor
- Golang anahtar kutusu
- Golang rastgele sayı
- Golang uykusu
- altın Zaman
- Golang kullanıcı kimliği
- Golang dosyayı oku
- Golang dosyayı satır satır okur
- Golang dosyaya yaz
- Golang dosyanın mevcut olup olmadığını kontrol edin
- Golan csv'si
- Golang yaml
- Golang http isteği
- Golang komut satırı argümanları
- Golang hata işleme
Merhaba merhaba dünya
ana Golang paketi, Golang programlama için gerekli tüm paketleri içerir ve Golang betiğinin yürütülmesini başlatmak için gereklidir. fmt Terminalde biçimlendirilmiş dizeyi yazdırmak için paketin içe aktarılması gerekir. Aşağıdaki komut dosyasıyla bir Golang dosyası oluşturun. Komut dosyası çalıştırıldıktan sonra terminalde 'Merhaba Dünya.' dize değeri yazdırılacaktır.
//Çıktıyı yazdırmak için fmt paketini içe aktarın
içe aktarmak 'fmt'
//Yürütmeyi başlatmak için main() fonksiyonunu tanımlayın
işlev ana () {
//Yeni satırla basit bir mesaj yazdırıyoruz
fmt . Yazdır ( 'Selam Dünya.' )
}
Komut dosyasını yürütmek için aşağıdaki komutu çalıştırın. Burada, komut dosyası example1 go dosyasına kaydedilmiştir.
$ git example1.go'yu çalıştırGolang dosyasının ikili dosyasını oluşturmak için aşağıdaki komutu çalıştırın.
$ git example1.go'yu oluştur
Yürütülebilir dosyayı çalıştırmak için aşağıdaki komutu çalıştırın.
$ . / örnek 1Yukarıdaki komutlar yürütüldükten sonra aşağıdaki çıktı görünecektir,,
Golang dize değişkenleri
Dize değişkenleri, Golang'da veri türü tanımlanmadan ve veri türüyle birlikte kullanılabilir. Basit dize verilerini ve dize değişkenlerini içeren dize verilerini yazdıracak aşağıdaki komut dosyasıyla bir Golang dosyası oluşturun. Kullanımları Printf() Ve Println() fonksiyonlar komut dosyasında gösterilmiştir.
paket ana//Çıktıyı yazdırmak için fmt paketini içe aktarın
içe aktarmak 'fmt'
// main() fonksiyonunu tanımlayın
işlev ana () {
//Dize değerini yeni bir satırla yazdırıyoruz
fmt . Baskı ( 'LinuxHint.com'dan Golang'ı öğrenin. \N ' )
//İlk string değişkenini tanımlıyoruz
öyleydi str1 = 'Golang Programlama.'
//Değişkeni satırsonu olmadan yazdırıyoruz
fmt . Baskı ( '%s'yi öğrenin' , str1 )
//İkinci dize değişkenini tanımlayın
öyleydi str2 = 'öğrenmesi kolay.'
//Değişkeni yeni satırla yazdırıyoruz
fmt . Yazdır ( 'Bu' , str2 )
}
Yukarıdaki betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Birleştirilmiş iki dizenin çıktısı burada yazdırılır.
Golang'ın dizeye int'si
strconv.Choke() Ve strconv.FormatInt() tamsayıyı Golang'da bir dize değerine dönüştürmek için işlevler kullanılabilir. strconv.Choke() Tamsayı değerini bir sayı dizisine dönüştürmek için kullanılır. strconv.FormatInt() işlevi, ondalık tabanlı tamsayı değerlerini dizeye dönüştürmek için kullanılır. Yukarıda belirtilen işlevleri kullanarak tamsayıyı Golang'da bir dizeye dönüştürmenin yolunu gösteren aşağıdaki komut dosyasıyla bir Golang dosyası oluşturun. Kullanıcıdan bir sayı alınacak ve sayıya karşılık gelen string değeri çıktı olarak yazdırılacaktır.
//Ana paketi ekliyoruzpaket ana
//fmt ve strconv paketlerini içe aktarın
içe aktarmak (
'fmt'
'strconv'
)
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//Bir tamsayı değişkeni tanımlıyoruz
öyleydi N int
//Bir mesaj yazdır
fmt . Baskı ( 'Bir sayı girin: ' )
//Kullanıcıdan girdi alıyoruz
fmt . Tara ( & N )
//Itoa() işlevini kullanarak tamsayıyı dizeye dönüştürün
dönüştür1 := strconv . boğuldu ( N )
fmt . Baskı ( 'Itoa() kullanarak tamsayıyı dizeye dönüştürme: %s \N ' , dönüştür1 )
//Tamsayıyı FormatInt() işlevini kullanarak dizeye dönüştürün
dönüştür2 := strconv . FormatInt ( int64 ( N ), 10 )
fmt . Baskı ( 'FormatInt() kullanarak tamsayıyı dizeye dönüştürme: %s \N ' , dönüştür2 )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Numara. 45 dizeye dönüştürüldü. “45”.
Golang dizesini int'ye dönüştürmek
strconv.Atoi() işlevi, dizeyi Golang'da bir tam sayıya dönüştürmek için kullanılır. Tamsayıya dönüştürülecek bir dize değeri alır ve iki tür değer döndürür. Konuşma başarılıysa bir değer tam sayıdır ve konuşma başarısızsa başka bir değer hatadır, aksi halde sıfır değer döndürülecektir. Aşağıdaki komut dosyasıyla, bir dizi dize değerini bir tamsayıya dönüştürecek bir Golang dosyası oluşturun. strconv.Atoi() işlev. Çalıştırma sonrasında “342” string değeri 342 sayısına dönüştürülecek ve yazdırılacaktır.
//Ana paketi ekliyoruzpaket ana
//fmt ve strconv paketlerini içe aktarın
içe aktarmak (
'fmt'
'strconv'
)
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//Bir string değişkeni tanımlayalım
cadde := '342'
//Atoi() işlevini kullanarak dizeyi tamsayıya dönüştürün
fiyat , hata := strconv . römork ( cadde )
//hata olup olmadığını kontrol et
eğer hata == sıfır {
//Dönüştürülen değeri yazdırıyoruz
fmt . Baskı ( 'Kitabın fiyatı %d \N ' , fiyat )
} başka {
//Hata mesajını yazdırıyoruz
fmt . Yazdır ( hata )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Burada “342” string değeri 342'ye dönüştürülmüştür.
Golang dizesi birleştirme
Printf() işlevini kullanarak dizeleri '+' operatörüyle birleştirecek aşağıdaki komut dosyasıyla bir Golang dosyası oluşturun. Println() işlevi burada '+' operatörünü kullanarak birleştirilmiş dize değerini yazdırmak için kullanıldı ve Printf() işlevi burada '%s' belirticisini kullanarak birleştirilmiş dize değerini yazdırmak için kullanıldı. Komut dosyasında daha sonra birleştirilen iki dize değişkeni bildirildi.
//Ana paketi ekliyoruzpaket ana
//Çıktıyı yazdırmak için fmt paketini içe aktarın
içe aktarmak 'fmt'
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//İki string değişkeni tanımlıyoruz
öyleydi str1 , str2 sicim
//Dize değerlerini atayın
str1 = 'Golan'
str2 = 'Programlama'
//'+' operatörünü kullanarak dizeyi birleştiriyoruz
fmt . Yazdır ( ''+' operatörü kullanılarak birleştirilmiş dize değeri:' , str1 + str2 )
//'%s' belirticisini kullanarak dizeyi birleştiriyoruz
fmt . Baskı ( 'Biçim belirtici kullanılarak birleştirilmiş dize değeri: %s%s \N ' , str1 , str2 )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang çok satırlı dize
Aşağıdaki örnekte Golang betiğini kullanarak çok satırlı metni yazdırmanın üç farklı yolu gösterilmiştir. Çok satırlı metni oluşturmak için ilk dize değişkeninde '\n' karakteri kullanıldı. Çok satırlı metni yazdırmak için ikinci dizede geri tırnak işaretleri (`) kullanılmıştır. Çok satırlı metni yazdırmak için üçüncü dizede belirticili geri tırnak işaretleri (`) kullanılmıştır.
paket ana//Fmt paketini içe aktarıyoruz
içe aktarmak 'fmt'
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//'\n' karakteriyle çok satırlı bir dize değeri bildirin
str1 := 'Golang programlama çok kolaydır \N öğrenmek. \N \N '
fmt . Baskı ( str1 )
//Geri tıklamalarla(`) çok satırlı bir dize değeri bildirin
str2 := 'Öğren
Golang
itibaren
Linuxİpucu
Blog.'
fmt . Baskı ( '%S \N \N ' , str2 )
//İki string değeri tanımlıyoruz
dil := 'golan'
geliştirici := 'Google'
//Değişkenler ve geri işaretlerle bir dize değeri bildirin
str3 := `%s
dır-dir
gelişmiş
ile
%s.'
fmt . Baskı ( str3 , dil , geliştirici )
//Yeni bir satır ekliyoruz
fmt . Yazdır ()
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Çok satırlı dize değerlerini içeren üç dize değişkeninin çıktısı burada yazdırılmıştır.
Golang bölünmüş dize
strings.Split() işlevi, dize verilerini ayırıcıya göre bölmek için kullanılmıştır. Aşağıdaki komut dosyası kullanıcıdan bir dize değeri alacak ve dize değerini iki nokta üst üste (:) temel alarak bölecektir. Toplam bölme değeri sayısı ve ilk iki bölme değeri yürütmeden sonra yazdırılacaktır.
paket ana//fmt ve strings paketlerini içe aktar
içe aktarmak (
'fmt'
'Teller'
)
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//Bir string değişkeni tanımlayalım
öyleydi cadde sicim
//Bir bilgi istemi mesajı yazdır
fmt . Baskı ( 'İki nokta üst üste(:)-' ile bir dize girin )
//Kullanıcıdan girdi alıyoruz
fmt . Tara ( & cadde )
//Ayırıcıyı tanımlayın
ayırıcı := ':'
//Dize değerini böl
bölünmüş_değer := Teller . Bölmek ( cadde , ayırıcı )
//Bölünmüş değerlerin sayısını say
uzunluk := sadece ( bölünmüş_değer )
//Bölünmüş değerlerin sayısını yazdır
fmt . Baskı ( 'Toplam bölünmüş değer sayısı %d \N ' , uzunluk )
//Bölünmüş değerleri yazdır
fmt . Yazdır ( 'İlk bölünmüş değer:' , bölünmüş_değer [ 0 ])
fmt . Yazdır ( 'İkinci bölünmüş değer:' , bölünmüş_değer [ 1 ])
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Giriş değeri olan “golang:google” iki nokta üst üste(:) temel alınarak iki parçaya bölünmüştür.
Golang sprintf
Sprintf() işlevi, Golang'da biçimlendirilmiş dize değerlerini diğer standart programlama dilleri gibi bir değişkene depolamak için kullanılır. Aşağıdaki komut dosyasında bir dize ve bir tamsayı değişkeni bildirildi. Bu değişkenlerin değerleri Sprintf() işlevi kullanılarak biçimlendirilmiş ve bir değişkende saklanmıştır.
paket ana//Fmt paketini içe aktarıyoruz
içe aktarmak 'fmt'
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//İki değişken tanımlıyoruz
öyleydi cadde sicim
öyleydi birde int
//Dize değerini ata
cadde = 'golan'
//Sayı değerini ata
birde = 2012
//Birleştirilmiş dize değerini bir değişkende saklıyoruz
birleştirilmiş_str := fmt . Sprintf ( '%s uygulamasının ilk sürümü %d yılında yayınlandı.' , cadde , birde )
//Değişkeni yazdırıyoruz
fmt . Baskı ( 'Sprintf()'in çıktısı: \N %S \N ' , birleştirilmiş_str )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang numaralandırması
Numaralandırma veya numaralandırıcı, Golang'da ilgili sabit değerlerden oluşan bir grubun veri türünü bildirmek için kullanılmıştır. Golang'daki enum türünün bildirimi diğer programlama dillerinden farklıdır. 12 değerden oluşan bir numaralandırma türü bildirildi ve belirli numaralandırma değerinin sayısal değeri daha sonra yazdırıldı.
paket ana//Fmt paketini içe aktarıyoruz
içe aktarmak 'fmt'
//Ay değerini (1-12) sayısında saklayacak türü bildirin
tip Ay int
//1'den başlayarak her ayın değeri için sabitler bildirelim
yapı (
Ocak Ayı = azıcık + 1
Şubat
Mart
Nisan
Mayıs
Haziran
Temmuz
Ağustos
Eylül
Ekim
Kasım
Aralık
)
//Ana fonksiyonu tanımlıyoruz
işlev ana () {
//Değişkeni ay değeriyle tanımlıyoruz
öyleydi M_num = Mayıs
//Ayın karşılık gelen sayı değerini yazdırıyoruz
fmt . Yazdır ( 'Sayıdaki ay değeri: ' , M_num )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Mayıs ayının karşılık gelen sayısal değeri 5'tir.
Golang yapısı
Yapı veya yapı, Golang'da farklı türde değişkenler içeren bir tür bildirmek için kullanılır. Tablo halindeki verileri veya birden fazla kaydı depolamak için kullanışlıdır. Aşağıdaki komut dosyasında dört öğeden oluşan bir yapı değişkeni bildirildi. Daha sonra tanımlanan yapı değişkeni kullanılarak iki kayıt eklenmiştir. Komut dosyasının son bölümünde yapının değerlerinin farklı şekillerde yazdırılma şekli gösterilmiştir.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
//Dört elementten oluşan bir yapı tanımlıyoruz
tip Ürün yapı {
İD sicim
isim sicim
boyut sicim
fiyat int
}
işlev ana () {
//İlk yapı değişkenini tanımlıyoruz
ürün1 := Ürün { 'p-1209' , 'HDD' , '5TB' , 80 }
//İkinci yapı değişkenini tanımlıyoruz
ürün2 := Ürün { 'p-7342' , 'Fare' , '' , on beş }
//Yapı değişkenlerini yazdırıyoruz
fmt . Yazdır ( 'İlk ürün:' , ürün1 )
fmt . Yazdır ( 'İkinci ürün:' , ürün2 )
//İlk yapı değişkeninin dört değerini ayrı ayrı yazdırıyoruz
fmt . Yazdır ( 'İlk ürün detayları:' )
fmt . Yazdır ( 'Kimlik: ' , ürün1 . İD )
fmt . Yazdır ( 'İsim: ' , ürün1 . isim )
fmt . Yazdır ( 'Boyut: ' , ürün1 . boyut )
fmt . Yazdır ( 'Fiyat: ' , ürün1 . fiyat )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golan dizisi
Dizi değişkeni Golang'da diğer standart programlama dilleri gibi belirli bir veri türünün birden çok değerini depolamak için kullanılır. Bir dizi dize değerini ve bir dizi sayısal değeri bildirmenin ve bunlara erişmenin yolu kodda gösterilmiştir.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
//Dize değerlerinin bir dizisini bildiriyoruz
str_arr := [ 4 ] sicim { 'Google com' , 'ask.com' , 'bing.com' , 'sen.com' }
//Dize dizisini yazdırıyoruz
fmt . Yazdır ( 'Dize Dizisi değerleri: ' , str_arr )
//dizinin 3. elemanını yazdırıyoruz
fmt . Yazdır ( 'Dizinin 3. değeri:' , str_arr [ 2 ])
//Sayısal değerlerin bir dizisini bildiriyoruz
int_arr := [ 6 ] int { 65 , 3. 4 , 12 , 81 , 52 , 70 }
//Tamsayı dizisini yazdırıyoruz
fmt . Yazdır ( 'Tamsayı Dizisi değerleri: ' , int_arr )
//dizinin 4. elemanını yazdırıyoruz
fmt . Yazdır ( 'Dizinin 4. değeri' , int_arr [ 3 ])
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang setleri
Set, Golang'ın farklı değerlerin bir koleksiyonunu depolamak için kullandığı başka bir veri yapısıdır. Bir nesnedeki benzersiz değerleri depolamak için kullanılır. Golang'ın diğer programlama dilleri gibi yerleşik bir veri yapısı yoktur. Ancak bu özellik boş yapı{} ve harita kullanılarak uygulanabilir. Aşağıdaki komut dosyasında, boş yapıya sahip bir harita kullanılarak dizelerden oluşan bir küme değişkeni bildirildi. Daha sonra sete üç değer eklenmiş, bir değer silinmiş ve tekrar bir değer eklenmiştir. Setin değerleri birlikte ve ayrı ayrı basılmıştır.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
//Bir dizi dizi tanımlıyoruz
Sadece := harita [ sicim ] yapı {}{}
//Boş bir yapı kullanarak kümeye üç öğe ekleyin
Sadece [ 'Gitmek' ] = yapı {}{}
Sadece [ 'Bah' ] = yapı {}{}
Sadece [ 'Python' ] = yapı {}{}
//Kümenin mevcut mevcut elemanlarını yazdırıyoruz
fmt . Yazdır ( Sadece )
//kümeden bir elemanı çıkartıyoruz
silmek ( Sadece , 'Python' )
//kümeye yeni bir eleman ekliyoruz
Sadece [ 'Java' ] = yapı {}{}
//Elemanı çıkarıp ekledikten sonra ayarlanan değerleri yazdırıyoruz
fmt . Yazdır ( Sadece )
fmt . Baskı ( ' \N Ayar değerleri şunlardır: \N ' )
//Kümenin her elemanını ayrı ayrı yazdırıyoruz
için ben := menzil Sadece {
fmt . Yazdır ( ben )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Döngü için Golang
For döngüsü Golang'da farklı şekillerde ve farklı amaçlarla kullanılabilir. Aşağıdaki kodda döngü için üç ifadenin kullanımı gösterilmiştir. Döngü 5 kez tekrarlanarak 5 giriş değeri alınacak ve bu giriş değerlerinin toplamı daha sonra yazdırılacaktır.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
//Bir tamsayı değişkeni tanımlıyoruz
öyleydi sayı int
//Toplam değeri saklayacak bir değişken tanımlayalım
öyleydi toplam = 0
//For döngüsü tanımlıyoruz
için N := 1 ; n < = 5 ; N ++ {
//Bir bilgi istemi mesajı yazdır
fmt . Baskı ( 'Bir numara girin:' )
//Kullanıcıdan girdi alıyoruz
fmt . Tara ( & sayı )
//Giriş numarasını toplam değişkeniyle toplayın
toplam = toplam + sayı
}
//Toplama sonucunu yazdır
fmt . Baskı ( 'Beş giriş değerinin toplamı %d'dir \N ' , toplam )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. 6, 3, 4, 7 ve 9'un toplamı 29'dur.
Menzil için Golang
Aralık, dizeye, diziye ve haritaya erişmek için Golang'daki for döngüsüyle birlikte kullanılır. Aralıklı bir for döngüsü kullanarak bir dizi diziye erişmenin yolu aşağıdaki komut dosyasında gösterilmiştir. İlk for döngüsü yalnızca dizi değerlerini yazdıracak ve ikinci for döngüsü dizinin indekslerini ve değerlerini yazdıracaktır.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
//Bir dizi dizisi tanımlıyoruz
Çiçekler := [ 4 ] sicim { 'Gül' , 'Zambak' , 'Dalia' , 'Güneş Çiçeği' }
fmt . Yazdır ( 'Dizi değerleri:' )
//Dizi değerlerini yazdırıyoruz
için _ , val := menzil Çiçekler {
fmt . Yazdır ( val )
}
fmt . Yazdır ( 'Dizi indeksleri ve değerleri:' )
// Dizi değerlerini indekse göre yazdırıyoruz
için içinde , val := menzil Çiçekler {
fmt . Baskı ( '%d := %s \N ' , içinde + 1 , val )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang while döngüsü
Golang'ın diğer programlama dilleri gibi while döngüsü yoktur. Ancak while döngüsünün özelliği Golang'da for döngüsü kullanılarak uygulanabilir. For döngüsü kullanarak while döngüsünü gerçekleştirmenin yolu aşağıdaki kodda gösterilmiştir. For döngüsü 4 kez yinelenecek ve dört sayı alacaktır. Bu sayıların kesirli değeriyle toplamı daha sonra basılacaktır.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
tezgah := 1
toplam := 0 . 0
öyleydi sayı kayan nokta64
için sayaç < = 4 {
//Bir bilgi istemi mesajı yazdır
fmt . Baskı ( 'Bir sayı girin: ' )
//Kullanıcıdan girdi alıyoruz
fmt . Tara ( & sayı )
//Giriş numarasını toplam değişkeniyle toplayın
toplam = toplam + sayı
//Sayacı 1 artırıyoruz
tezgah ++
}
//Toplama sonucunu yazdır
fmt . Baskı ( 'Dört giriş değerinin toplamı %0,2f'dir \N ' , toplam )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. 6,8, 3,2, 8,5 ve 4,9'un toplamı 23,40'tır.
Golang devam ediyor
Continue ifadesi, herhangi bir döngüde, bir koşula dayalı belirli ifadeleri atlamak için kullanılır. Aşağıdaki scriptte, Continue ifadesini kullanarak dizinin 2. ve 4. değerlerinin değerlerini atlayacak döngüyü yinelemek için for döngüsü kullanılmıştır.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
tezgah := 1
toplam := 0 . 0
öyleydi sayı kayan nokta64
için sayaç < = 4 {
//Bir bilgi istemi mesajı yazdır
fmt . Baskı ( 'Bir sayı girin: ' )
//Kullanıcıdan girdi alıyoruz
fmt . Tara ( & sayı )
//Giriş numarasını toplam değişkeniyle toplayın
toplam = toplam + sayı
//Sayacı 1 artırıyoruz
tezgah ++
}
//Toplama sonucunu yazdır
fmt . Baskı ( 'Dört giriş değerinin toplamı %0,2f'dir \N ' , toplam )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang anahtar kutusu
Golang'daki switch-case ifadesi diğer programlama dillerine benzer ancak Golang'daki her case ifadesinde break ifadesi gerekmez. Switch bloğu içerisinde birden fazla durum değerinin nasıl tanımlanacağı aşağıdaki örnekte gösterilmiştir.
paket ana//Fmt paketini içe aktar
içe aktarmak 'fmt'
işlev ana () {
öyleydi N int
//Bir bilgi istemi mesajı yazdır
fmt . Baskı ( 'Ayın değerini sayı olarak girin: ' )
//Kullanıcıdan girdi alıyoruz
fmt . Tara ( & N )
//Eşleşen durum değerine göre mesajı yazdır
anahtar N {
dava 1 , 2 , 3 , 4 :
fmt . Yazdır ( 'Kış dönemi.' )
dava 5 , 6 , 7 , 8 :
fmt . Yazdır ( 'Yaz tatili.' )
dava 9 , 10 , on bir , 12 :
fmt . Yazdır ( 'Güz Dönemi.' )
varsayılan :
fmt . Yazdır ( 'Ay değeri aralık dışında.' )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang rastgele sayı
Math/Rand paketi Golang'da rastgele sayılar üretmek için kullanıldı. Dört tür rasgele sayı üretmenin yolu aşağıdaki kodda gösterilmiştir. Rand.Int() işlevi, uzun bir tamsayı rastgele sayı oluşturmak için kullanılır. Rand.Intn(n) işlevi, belirli bir aralıkta rastgele bir tam sayı oluşturmak için kullanılır ve en yüksek değer, işlevin bağımsız değişken değeri olarak iletilir. 999, komut dosyasında bağımsız değişken değeri olarak ayarlanır. Rand.Float32() işlevi kısa bir kesirli rasgele sayı oluşturmak için kullanılır ve rand.Float64() işlevi ise uzun bir kesirli rasgele sayı oluşturmak için kullanılır.
//Ana paketi eklepaket ana
//Gerekli modülleri içe aktar
içe aktarmak (
'fmt'
'zaman'
'matematik/rand'
)
işlev ana () {
//Rastgele bir sayı oluşturacak şekilde tohum ayarladık
rand . Tohum ( zaman . Şimdi () . UnixNano ())
//Oluşturulan rastgele tam sayıyı yazdır
fmt . Yazdır ( 'Rastgele tamsayı değeri: ' , rand . Dahili ())
//999'un içindeki rastgele tamsayıyı yazdır
fmt . Yazdır ( 'Aralıklı rastgele tamsayı değeri: ' , rand . Dahili ( 999 ))
//Rastgele 32 bitlik kayan noktayı yazdır
fmt . Yazdır ( 'Rastgele 32 bitlik kayan değer: ' , rand . Şamandıra32 ())
//Rastgele 64 bitlik kayan noktayı yazdır
fmt . Yazdır ( 'Rastgele 64 bit kayan değer: ' , rand . Şamandıra64 ())
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang uykusu
time.Sleep() işlevi, Golang'da betiğin yürütülmesini belirli bir süre duraklatmak için kullanılır. Aşağıdaki script üç sayının ortalamasını hesaplayacak ve scripti sonlandırmadan önce 3 saniye bekleyecektir.
//Ana paketi eklepaket ana
//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'zaman'
)
işlev ana () {
fmt . Yazdır ( 'Betiği çalıştırmaya başla...' )
//Üç değişken tanımlıyoruz
A := 40
B := 30
C := 29
//Değişkenleri yazdırıyoruz
fmt . Baskı ( 'Üç sayı: %d, %d, %d \N ' , A , B , C )
fmt . Yazdır ( 'Üç sayının ortalaması hesaplanıyor...' )
ortalama := ( A + B + C ) / 3
//3 saniye gecikme
zaman . Uyumak ( 3 * zaman . Saniye )
//Sonuçları yazdır
fmt . Baskı ( 'Ortalama değer %d'dir \N ' , ortalama )
fmt . Yazdır ( 'Program sonlandırıldı.' )
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
altın Zaman
Zaman paketi Golang'da geçerli tarih ve saati okumak için kullanılır. Bu pakette tarih ve saati farklı şekillerde okumak için birçok yöntem ve özellik bulunmaktadır. Tarih ve saat, 'Pzt Ocak 2 15:04:05 -0700 MST 2006' Golang'da tarih ve saate erişmek için referans değeri olarak kullanılır. Aşağıdaki örnekte time paketinin kullanımları gösterilmiştir.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'zaman'
)
işlev ana () {
//Geçerli tarih ve saati oku
Bugün := zaman . Şimdi ()
//Geçerli tarihi yazdır
fmt . Baskı ( 'Bugün %s. \N ' , Bugün . Biçim ( '02-Ocak-2006' ))
//Geçerli tarih ve saati yazdır
fmt . Baskı ( 'Geçerli tarih ve saat: %s \N ' , Bugün . Biçim ( zaman . RFC1123 ))
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang kullanıcı kimliği
UUID veya Evrensel Benzersiz Tanımlayıcı, Golang betiği tarafından oluşturulabilir. Bilgisayar sistemini tanımlayan 128 bitlik benzersiz bir değerdir. Uuid'yi şuradan indirmeniz gerekir: github.com/google/uuid Aşağıdaki betiği çalıştırmadan önce.
Golang betiği ile uuid oluşturmak için gerekli paketi indirmek için ana dizine gidin ve aşağıdaki komutları çalıştırın.
$ go mod başlangıç kullanıcı kimliği$ github.com'u al / google / kullanıcı kimliği
Aşağıdaki komut dosyasında, ilk uuid, benzersiz bir tanımlayıcı döndüren uuid.New() işlevi kullanılarak oluşturulur. İkinci uuid, iki değer döndüren uuid.NewUUID() işlevi tarafından oluşturulur. Değer benzersiz tanımlayıcıyı içerir ve ikinci değer, varsa hata mesajını içerir.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'github.com/google/uuid'
)
işlev ana () {
//New() fonksiyonunu kullanarak benzersiz bir kimlik oluşturun
yeni kimlik := uuid . Yeni ()
fmt . Baskı ( 'Oluşturulan ilk UUID: %s. \N ' , yeni kimlik )
//NewUUID() fonksiyonunu kullanarak benzersiz bir kimlik oluşturun
yeni kimlik , hata := uuid . YeniUUID ()
//Hatayı kontrol et
eğer hata == sıfır {
fmt . Baskı ( 'Oluşturulan ikinci UUID: %s. \N ' , yeni kimlik )
} başka {
fmt . Yazdır ( hata )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang dosyayı oku
io/ioutil Golang paketi bir dosyanın içeriğini okumak için kullanılır. Bu paketin ReadFile() işlevi bir dosyanın tüm içeriğini okur. Bu işlev, dosya mevcutsa dosyanın tüm içeriğini bir değişkene döndürür, aksi takdirde bir hata mesajı döndürülür. Mevcut bir metin dosyasının tüm içeriğini okumanın yolu aşağıdaki scriptte gösterilmiştir.
//Ana paketi eklepaket ana
//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'io/ioutil'
'fmt'
'kayıt'
)
işlev ana () {
//Bir metin dosyasını oku
metin , hata := Ioutil . Dosyayı Oku ( 'Diller.txt' )
//Hatayı kontrol et
eğer hata == sıfır {
fmt . Baskı ( 'Dosyanın içeriği: \N \N ' )
fmt . Yazdır ( sicim ( metin ))
} başka {
kayıt . Ölümcül ( 'Dosya okuma hatası: %v' , hata )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang dosyayı satır satır okur
Golang'ın “bufio” paketi bir dosyanın içeriğini satır satır okumak için kullanılır. Aşağıdaki komut dosyasında, dosyayı okuyacak bir nesne oluşturmak için bufio.NewScanner() kullanıldı. Daha sonra, dosyanın her satırını okumak ve yazdırmak için döngüyle birlikte Scan() işlevi kullanıldı.
//Ana paketi eklepaket ana
//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'Sen'
'bufio'
)
işlev ana () {
//Okumak için bir metin dosyası açıyoruz
fh , hata := Sen . Açık ( 'Diller.txt' )
//Hatayı kontrol et
eğer hata == sıfır {
//Dosya içeriğini tara
Okumak := bufio . YeniTarayıcı ( fh )
//Dosyayı satır satır oku
için Okumak . Tara () {
fmt . Yazdır ( Okumak . Metin ())
}
} başka {
fmt . Yazdır ( hata )
}
//Dosyayı kapat
ertelemek fh . Kapalı ()
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang dosyaya yaz
Sen Golang paketi bir dosyayı yazmak üzere açmak için kullanılır ve WriteString() işlevi bir dosyaya içerik yazmak için kullanılır. Üç satırlık bir metin dosyası oluşturmanın ve yazmanın yolu, Sen paket.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'Sen'
)
işlev ana () {
//Yazmak için bir dosya açıyoruz
fh , hata1 := Sen . Yaratmak ( 'öğeler.txt' )
//Dosya oluşturma hatasını kontrol et
eğer hata1 == sıfır {
//Dosyaya yazıyoruz
_ , hata2 := fh . YazmaDizesi ( 'Dolma kalem \N Kalem \N Cetvel \N ' )
//Dosya yazma hatasını kontrol et
eğer hata2 != sıfır {
fmt . Yazdır ( 'Dosya yazma hatası oluştu. \N ' )
}
} başka {
fmt . Yazdır ( 'Dosya oluşturma hatası oluştu. \N ' )
}
//Dosyayı kapat
ertelemek fh . Kapalı ()
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir. Çıktı, items.txt dosyasının başarıyla oluşturulduğunu gösterir.
Golang dosyanın mevcut olup olmadığını kontrol eder
Sen Golang paketi dosyanın varlığını kontrol etmek için kullanılabilir. Aşağıdaki scriptte dosya yolu scriptten alınacaktır. Yol mevcut değilse os.State() işlevi bir sonuç döndürecektir. os.ErrNotExist hata.
paket ana//Gerekli modülü içe aktar
içe aktarmak (
'hatalar'
'fmt'
'Sen'
)
işlev ana () {
öyleydi dosya yolu sicim
fmt . Baskı ( 'Mevcut bir dosya adını girin: ' )
//Kullanıcıdan dosya yolunu alıyoruz
fmt . Tara ( & dosya yolu )
//Dosya yolunu kontrol et
_ , hata := Sen . İstatistik ( dosya yolu )
//os.Stat çıktısını kontrol ediyoruz
eğer ! hatalar . Dır-dir ( hata , Sen . ErrNotExist ) {
fmt . Yazdır ( 'Dosya bulundu.' )
} başka {
fmt . Yazdır ( 'Dosya bulunamadı.' )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golan csv'si
“kodlama/csv” paket Golang'da CSV dosyasının içeriğini okumak için kullanılır. csv.NewReader() CSV dosyasını okumak için işlev kullanılır. Bu örneğin betiğini çalıştırmadan önce bir CSV dosyası oluşturun. Burada, müşteriler.csv dosyası CSV dosyasının okunma yolunu göstermek için kullanılmıştır.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'kodlama/csv'
'fmt'
'Sen'
)
işlev ana () {
//Okumak için bir CSV dosyası açıyoruz
fh , hata := Sen . Açık ( 'müşteriler.csv' )
//Hatayı kontrol et
eğer hata != sıfır {
fmt . Yazdır ( hata )
} başka {
//CSV dosyasını okumak için bir nesne oluşturun
tarayıcı := csv . YeniOkuyucu ( fh )
// CSV dosyasının tüm kayıtlarını oku
kayıtlar , _ := tarayıcı . Hepsini oku ()
// CSV dosyasını satır satır oku
için _ , R := menzil kayıtlar {
için _ , C := menzil R {
fmt . Baskı ( '%S,' , C )
}
fmt . Yazdır ()
}
}
//Dosyayı kapat
ertelemek fh . Kapalı ()
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang yaml
yaml.Marshal() Golang'da yaml verilerinin içeriğini okumak için işlev kullanılır. İndirmelisiniz yaml kullanmak için paket yaml.Marshal() . Ana dizine gidin ve indirmek için aşağıdaki komutu çalıştırın. yaml paket.
$ git al < A href = 'http://gopkg.in/yaml.v2' > gopkg.in / yaml.v2 A >Aşağıdaki komut dosyasında, daha sonra veri içeren bir yaml nesnesini tanımlamak için kullanılacak olan dört öğeden oluşan bir yapı değişkeni bildirildi. Daha sonra yaml verilerine erişmek için yaml.Marshal() işlevi kullanıldı.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'gopkg.in/yaml.v2'
)
//4 elementten oluşan bir yapı tanımlıyoruz
tip Kitap yapı {
Başlık sicim
Yazar sicim
Yayın sicim
Fiyat sicim
}
işlev ana () {
//Yapının bir nesnesini yaratıyoruz
1 kitap := Kitap {
Başlık : 'Gitmeyi Öğrenmek' ,
Yazar : 'John Bodner' ,
Yayın : 'O'Relly' ,
Fiyat : '39 dolar' ,
}
//yaml verisini yapıya göre oku
y_data , hata := yaml . Marshall ( &1 kitap )
//Hatayı kontrol et
eğer hata == sıfır {
//yaml verilerini yazdır
fmt . Yazdır ( sicim ( y_data ))
} başka {
fmt . Baskı ( 'Sıralama sırasında hata oluştu. %v' , hata )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang http isteği
ağ/http Golang paketi http isteklerini bir web sitesine göndermek için kullanılır. İsteği göndermek için http.Get() işlevi kullanılır. Siteden gelen yanıtı veya hata mesajını döndürür. http isteğinin siteye gönderilme şekli, https://example.com aşağıdaki komut dosyasında gösterilmiştir.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'net/http'
)
işlev ana () {
//Bir web sitesine GET isteği gönder
res , hata := http . Elde etmek ( 'https://example.com' )
//Hatayı kontrol et
eğer hata == sıfır {
//Web sitesi tarafından gönderilen yanıtı yazdırıyoruz
fmt . Yazdır ( res )
} başka {
//Hata mesajını yazdırıyoruz
fmt . Yazdır ( hata )
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang komut satırı argümanları
Komut dosyasının yürütülmesi sırasında iletilen değerlere komut satırı argüman değerleri denir. os paketi Golang'daki komut satırı argüman değerlerini okumak için kullanılır. Argüman değerleri Args[] dizisinde saklanır. Betikte, her satırda betik adı olmadan bağımsız değişken değerlerini yazdırmak için aralık içeren for döngüsü kullanılmıştır.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'fmt'
'Sen'
)
işlev ana () {
fmt . Yazdır ( 'Tüm bağımsız değişken değerleri:' )
//Tüm bağımsız değişken değerlerini komut dosyası adıyla yazdır
fmt . Yazdır ( Sen . Argümanlar )
fmt . Yazdır ( 'Argüman değerleri:' )
//Tüm bağımsız değişken değerlerini komut dosyası adı olmadan yazdır
için içinde , _ := menzil Sen . Argümanlar {
eğer içinde == 0 {
devam etmek
}
fmt . Yazdır ( Sen . Argümanlar [ içinde ])
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Golang hata işleme
Golang'ın diğer programlama dilleri gibi try-catch bloğu yoktur. Ancak hatalar paket, betikteki hataları işlemek için Golang'da kullanılabilir. Aşağıdaki scriptte kullanıcıdan bir tam sayı alınacaktır. Kullanıcı negatif bir sayı alırsa bir hata mesajı yazdırılacaktır. hatalar.Yeni() Burada hata mesajını oluşturmak için işlev kullanılmıştır.
paket ana//gerekli paketleri içe aktarıyoruz
içe aktarmak (
'hatalar'
'fmt'
)
işlev ana () {
öyleydi N int
fmt . Baskı ( 'Bir sayı girin: ' )
fmt . Tara ( & N )
//Giriş değerini kontrol ediyoruz
sonuç , hata := Pozitif ( N )
//Hatayı kontrol et
eğer hata != sıfır {
fmt . Yazdır ( hata )
} başka {
fmt . Baskı ( '%d %s \N ' , N , sonuç )
}
}
///Pozitif sayıyı kontrol edecek fonksiyonu tanımlayın
işlev Pozitif ( birde int ) ( sicim , hata ) {
eğer sayı < 0 {
geri dönmek '' , hatalar . Yeni ( 'Pozitif bir sayı yazın.' )
} başka {
geri dönmek 'sayı pozitif.' , sıfır
}
}
Betiği çalıştırdıktan sonra aşağıdaki çıktı görünecektir.
Çözüm:
Golang, Python programlama dili gibi birçok kullanışlı pakete sahip, artık popüler bir programlama dilidir. Her acemi kullanıcı Golang'ı ilk programlama dili olarak öğrenebilir çünkü öğrenmesi çok kolaydır. Bu eğitimde Golang'ı en baştan öğrenmek için temel 30 Golang örneği açıklanmıştır ve öğrenciler Golang'da programlar yazabilecektir. Bu dilin en büyük sınırlamalarından biri nesne yönelimli programlamanın özelliklerini içermemesi ancak yapılandırılmış programlamayı öğrenmek için iyi olmasıdır.