Skip to content

O'zgaruvchilar, butun va haqiqiy sonlar

O'zgaruvchilar

O'zgaruvchi - xotiraning nomlangan qismi bo'lib, o'zida ma'lum bir toifadagi qiymatlarni saqlaydi. O'zgaruvchining nomi va qiymati bo'ladi. O'zgaruvchining nomi orqali qiymat saqlanayotgan xotira qismiga murojaat qilinadi. dastur ishlashi jarayonida o'zgaruvchining qiymatini o'zgartirish mumkin. Har qanday o'zgaruvchini ishlatishdan oldin, uni e'lon qilish lozim. Quyida butun sonlardan foydalanish uchun b, haqiqiy sonlardan foydalanish uchun h o'zgaruvchilarini e'lon qilish keltirilgan.

O'zgaruvchini e'lon qilish

  • b int;
  • h float;

Butun sonlarni ifodalash uchun int va haqiqiy sonlarni ifodalash uchun float xizmatchi so'zlaridan foydalanilad *

O'zgarmaslar (const)

Hisoblash jarayonida qiymatini o'zgartirmaydigan kattaliklarga aytiladi.

  • float const pi = 3.14;

Goda asosiy ma'lumot turlari

1. Raqamli turlar(numeric types):

Signed Integers(musbat va manfiy butun sonlar)

  • int8 - 8-bit signed integer
    • Kompyuter xotirasida egallagan hajmi: 8 bits
    • Qabul qiladigan qiymatlar oralig'i: -128 to 127
  • int16 - 16-bit signed integer
    • Kompyuter xotirasida egallagan hajmi: 16 bits
    • Qabul qiladigan qiymatlar oralig'i: -32,768 to 32,767
  • int32 - 32-bit signed integer
    • Kompyuter xotirasida egallagan hajmi: 32 bits
    • Qabul qiladigan qiymatlar oralig'i: -2,147,483,648 to 2,147,483,647
  • int64 - 64-bit signed integer
    • Kompyuter xotirasida egallagan hajmi: 64 bits
    • Qabul qiladigan qiymatlar oralig'i: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Kompyuterga bog'liq turlar

  • uint - Unsigned integers (kompyuterga bog'liq turlar)
  • int - Signed integers (kompyuterga bog'liq turlar)
  • uintptr - Pointer(ko'rsatkich)

Unsigned Integers(musbat butun sonlar)

  • uint8 - 8-bit unsigned integer
    • Kompyuter xotirasida egallagan hajmi: 8 bits
    • Qabul qiladigan qiymatlar oralig'i: 0 to 255
  • uint16 - 16-bit unsigned integer
    • Kompyuter xotirasida egallagan hajmi: 16 bits
    • Qabul qiladigan qiymatlar oralig'i: 0 to 65,535
  • uint32 - 32-bit unsigned integer
    • Kompyuter xotirasida egallagan hajmi: 32 bits
    • Qabul qiladigan qiymatlar oralig'i: 0 to 4,294,967,295
  • uint64 - 64-bit unsigned integer
    • Kompyuter xotirasida egallagan hajmi: 64 bits
    • Qabul qiladigan qiymatlar oralig'i: 0 to 18,446,744,073,709,551,615

Floating Point Numbers

  • float32 - 32-bit floating-point number
    • Kompyuter xotirasida egallagan hajmi: 32 bits
  • float64 - 64-bit floating-point number
    • Kompyuter xotirasida egallagan hajmi: 64 bits

Complex

  • complex64 - Complex number with float32 real and imaginary parts
    • Kompyuter xotirasida egallagan hajmi: 64 bits (32 bits for real, 32 bits for imaginary)
  • complex128 - Complex number with float64 real and imaginary parts
    • Kompyuter xotirasida egallagan hajmi: 128 bits (64 bits for real, 64 bits for imaginary)

2. Mantiqy tur:

  • bool - Mantiqiy qiymatlar (true(rost) yoki false(yolg'on))

3. Matnli tur:

  • string - Belgilar ketma-ketligi

4. Derived turlar:

  • array - aniq o'lchamga ega massiv
  • slice - Dinamik o'lchamli, massiv elementlariga moslashuvchan.
  • map - Kalit-qiymat to'plami
  • struct - Nomlangan madonlar turi
  • pointer - O'zgaruvchining xotiradagi manzili

5. Maxsus turlar:

  • chan - Gorutinlar orasidagi aloqa uchun kanal turi
  • func - Funktsiya turi
  • interface - Usullar to'plamini ifodalovchi mavhum tip
  • nil - Qiymat yoki ko'rsatgich yo'qligini ifodalaydi

6. Boshqa turlar:

  • byte - Alias for uint8
    • Kompyuter xotirasida egallagan hajmi: 8 bits
    • Qabul qiladigan qiymatlar oralig'i: 0 to 255
  • rune - Alias for int32; represents a Unicode code point
    • Kompyuter xotirasida egallagan hajmi: 32 bits
    • Qabul qiladigan qiymatlar oralig'i: -2,147,483,648 to 2,147,483,647

Jadval ko'rinishida

Ma'lumot turi Ta'rif E'lon qilinshiga misol
int Signed integer var x int
int8 8-bit signed integer var x int8
int16 16-bit signed integer var x int16
int32 32-bit signed integer var x int32
int64 64-bit signed integer var x int64
uint Unsigned integer var x uint
uint8 8-bit unsigned integer var x uint8
uint16 16-bit unsigned integer var x uint16
uint32 32-bit unsigned integer var x uint32
uint64 64-bit unsigned integer var x uint64
float32 32-bit floating-point number (float) var x float32
float64 64-bit floating-point number (double) var x float64
bool Boolean (true/false) var x bool
string String var x string
byte Alias for uint8 var x byte
rune Represents a Unicode code point var x rune
complex64 Complex number with float32 real/imag var x complex64
complex128 Complex number with float64 real/imag var x complex128

32 bit va 64 bit bular nima degani?

"32-bit" va "64-bit" atamalari kompyuter protsessorining (CPU) axborotni qayta ishlash usulini anglatadi. Ushbu atamalar odatda kompyuter arxitekturasi va dasturiy ta'minotning muvofiqligi kontekstida qo'llaniladi.

Har birining qisqacha izohi:

  • 32 bit

    • 32 bitli tizimda protsessor bir vaqtning o'zida 32 bitli ma'lumotlarni qayta ishlay oladi.
    • 32-bitli tizimdagi xotira manzillari 32 bit uzunlikda boʻlib, protsessorga toʻgʻridan-toʻgʻri 4 gigabayt (2^32 bayt) operativ xotiraga murojaat qilish imkonini beradi.
    • Eski kompyuterlar va operatsion tizimlar asosan 32 bitli edi.

  • 64 bit

    • 64 bitli tizimda protsessor bir vaqtning o'zida 64 bit ma'lumotlarni qayta ishlaydi.
    • 64 bitli tizimdagi xotira manzillari 64 bit uzunlikda bo'lib, manzilli xotira maydonini ancha kattaroq qilish imkonini beradi. Nazariy jihatdan, 64-bitli tizim 18,4 million terabayt operativ xotiraga (2^64 bayt) murojaat qilishi mumkin.
    • Zamonaviy kompyuterlar va operatsion tizimlar ish faoliyatini yaxshilash va katta hajmdagi operativ xotirani boshqarish qobiliyati uchun 64-bitli arxitekturadan tobora ko'proq foydalanmoqda.

32-bitli hisoblashdan 64-bitli kompyuterga oʻtishga koʻproq ishlov berish quvvati va katta hajmdagi xotiradan foydalanishga bo'lgan ehtiyoj sabab bo'ladi chunki video tahrirlash, oʻyin oʻynash va katta hisoblash resurslarini talab qiluvchi ilmiy simulyatsiyalar kabi ilovalar ko'proq resurs talab qiladi.

Identifikator

Dasturchi tomonidan dastur elementlari (funksiya, o'zgaruvchilar, o'zgarmaslar …) uchun ixtiyoriy tanlangan nom.

Identifikator tanlaganda quyidagilarga ahamiyat berish kerak:

  • Identifikator lotin harflaridan boshlanishi shart;
  • Ikkinchi simvoldan boshlab raqamlardan foydalanish mumkin;
  • Go da katta kichik harflar farq qiladi. Ya'ni quyidagilarning har biri alohida identifikator hisoblanadi: KATTA, katta, KaTTa, kAttA, Katta, KattA, ...
  • identifikatorda probeldan foydalanib bo'lmaydi;
  • Go da zahiraga olingan kalit so'zlaridan identifikator sifatida foydalanib bo'lmaydi.

Golangda zahiraga olingan Kalit so'zlari

Kalit so'zlar Kalit so'zlar Kalit so'zlar Kalit so'zlar
break default func interface
select case defer go
map struct chan else
goto package switch const
fallthrough if range type
continue for import return
var

Amaliyot

Go (Golang) da int ma'lumotlar turi imzolangan butun sonni ifodalaydi va uning o'lchami asosiy tizim arxitekturasiga bog'liq. Bu 32 bit yoki 64 bit bo'lishi mumkin.

Bundan tashqari, Go int8, int16, int32 va int64 kabi aniq o'lchamdagi butun son turlarini taqdim etadi. Ushbu turlar butun sonni ifodalash uchun ishlatiladigan bitlar sonini aniq ko'rsatadi, ya'ni ular musbat va manfiy qiymatlarni ifodalashi mumkin.

Quyida Goda o'zgaruvchilarni e'lon qilishga misol keltirilgan:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main

import "fmt"

func main() {
    // int ga misol
    var a int = 42
    fmt.Println("int:", a)

    // int8  ga misol
    var b int8 = 127
    fmt.Println("int8:", b)

    // int16 ga misol
    var c int16 = 32767
    fmt.Println("int16:", c)

    // int32 ga misol
    var d int32 = 2147483647
    fmt.Println("int32:", d)

    // int64 ga misol
    var e int64 = 9223372036854775807
    fmt.Println("int64:", e)

    // string ga misol
    var f string = "string"
    fmt.Println("string:", f)

    // bool ga misol
    var g bool = "string"
    fmt.Println("bool:", g)

    // float32 ga misol
    var k float32 = 3.14
    fmt.Println("float32:", k)
}

Ushbu turlar bilan ishlashda siz qabul qilish oralig'idan oshib ketishi mumkin bo'lgan muammolarni yodda tutishingiz kerak. Agar siz butun son turi oralig'idan oshib ketsangiz, kutilmagan xatolarga duch kelishingiz mumkin. Go har xil o'lchamdagi butun sonlar turlarini avtomatik ravishda aylantirmaydi, shuning uchun kerak bo'lganda aniq konvertatsiya talab qilinadi. Masalan:

1
2
3
4
5
6
package main

func main() {
    var a int32 = 100
    var b int64 = int64(a) // int32 dan int64 ga konvertatsiya qilindi.
}

Info

Ma'lumot turini tanlashda har doim ma'lumot hajmi va diapazoniga bo'lgan talabni hisobga olish zarur.

Go dasturlash tilini boshqa dasturlash tiliaridan ajratib turadigan yana bir xususiyatlaridan biri, uning e'lon qilingan ammo foydalanilmayotgan o'zgaruvchilarni aniqlab kompilyatsiyadan o'tqazmasligi. Misol uchun:

yuz.go
1
2
3
4
5
6
package main

func main() {
    // ushbu dasturni ishga tushirib ko'ring.
    var yuz int32 = 100
}

Yuqoridagi dasturni ishga tushirgan vaqtizmida quyidagicha xatolik xabarini olamiz.

yuz declared and not used

Printf chop qilish funksiyasi

Goda fmt paketidan formatlangan chop etish uchun Printf funksiyasini taqdim etadi. Printf funksiyasi standart chiqish (odatda konsolga) qiymatlarni formatlash va chop etish imkonini beradi. U C tilining printf funksiyasiga o'xshaydi. Misol:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
    // Oddiy foydalanish
    name := "John"
    age := 25
    fmt.Printf("Name: %s, Age: %d\n", name, age)

    // turlar bo'yicha formatlash
    pi := 3.14159
    fmt.Printf("Pi (float): %f\n", pi)
    fmt.Printf("Pi (2 decimal places): %.2f\n", pi)

    // Turni aniqlasj uchun %T dan foydalanish
    var flag bool = true
    fmt.Printf("Qiymat: %t, Tur: %T\n", flag, flag)
}
Yuqoridagi misolda:

  • %s - Satrlar uchun(string).
  • %d - Butun sonlar uchun(int).
  • %f - Haqiqiy sonlar uchun(float).
  • %t - Mantiqiy qiymatlar uchun(bool).
  • %T - Turni aniqlash uchun(type).
  • \n - Yangi qatorga o'tish(new line).

O'zgaruvchilarni turini aniqlash

E'lon qilgan o'zgaruvchini turini aniqlash uchun Printf chop etish funksiyasidan foydalanamiz.

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
  var yuz float64 = 100.12
  fmt.Printf("Type: %T", yuz)
}

Natija:

Type: float64

Turlarni kompyuter xotirasida egallagam xajmini aniqlash

Turlarni kompyuter xotirasida egallagam xajmini aniqlashimiz uchun unsafe paketini import qilishimiz va unsafe paketining Sizeof funksiyasi yordamida aniqlashimiz mumkin.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package main

import "fmt"
import "unsafe"

func main() {
    var a int = 125
    var b float32 = 3.14
    var c string = "foo"
    var d bool = false

    fmt.Printf("a: %T, %d byte\n", a, unsafe.Sizeof(a))
    fmt.Printf("b: %T, %d byte\n", b, unsafe.Sizeof(b))
    fmt.Printf("c: %T, %d byte\n", c, unsafe.Sizeof(c))
    fmt.Printf("d: %T, %d byte\n", d, unsafe.Sizeof(d))
}

Natija: 

a: int, 8 byte
b: float32, 4 byte
c: string, 16 byte
d: bool, 1 byte

O'zgaruvchilarni e'lon qilishni boshqa usullari

Yuqoridagi misollarimizda o'zgaruvchilarni turi bilan yozdik, Go o'zgaruvchini turisiz e'lon qilish imkonini beradi. Misol uchun:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {
  var on = 100
  var pi = 3.14
  fmt.Printf("on=%d, Type: %T\n", on, on)
  fmt.Printf("pi=%f:2, Type: %T", pi, pi)
}

Natija:

on=100, Type: int
pi=3.140000, Type: float64

Yuqoridagi misolda hech hech qanday tur nomini yozmadik, o'zgaruvchini turini Goni o'zi qiymatga qarab aniqladi. Agar qiymat haqiqiy son bo'lsa float32 deb qabul qildi, butun sonni esa int.

Go da o'zgaruvchilarni e'lon qilishni yana bir usuli bu quyidagicha, bu usuldaham o'zgaruvchi turi va var kalit so'zi yozilmaydi. O'zgaruvchi qiymatiga asosan Goning o'zi aniqlaydi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {
  on := 100
  pi := 3.14
  fmt.Printf("on=%d, Type: %T\n", on, on)
  fmt.Printf("pi=%f:2, Type: %T", pi, pi)
}

Bu usuldan funksiyalar ichida foydalanish tavfsiya qilinadi.

O'zgarmaslar(const)

Hisoblash jarayonida qiymatini o'zgartirmaydigan kattaliklarga aytiladi.

Misol:

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
    const PI float32 = 3.14
    fmt.Println(PI)
}
O'zgarmaslar har qanday asosiy ma'lumotlar turlaridan bo'lishi mumkin, masalan, int, float, string.

Info

Malakali dasturchilar o'zgarmaslarni katta harf(uppercase) bilan nomlashni tavfsiya qilishadi.