Idź - zmienne

Zmienna to nic innego jak nazwa nadana obszarowi pamięci, którym programy mogą manipulować. Każda zmienna w Go ma określony typ, który określa rozmiar i układ pamięci zmiennej, zakres wartości, które mogą być przechowywane w tej pamięci oraz zestaw operacji, które można zastosować do zmiennej.

Nazwa zmiennej może składać się z liter, cyfr i znaku podkreślenia. Musi zaczynać się od litery lub podkreślenia. Wielkie i małe litery są różne, ponieważ w Go jest rozróżniana wielkość liter. W oparciu o podstawowe typy wyjaśnione w poprzednim rozdziale, będą następujące podstawowe typy zmiennych -

Sr.No	Typ i opis
1	byte Zwykle pojedynczy oktet (jeden bajt). To jest typ bajtowy.
2	int Najbardziej naturalny rozmiar liczby całkowitej dla maszyny.
3	float32 Wartość zmiennoprzecinkowa o pojedynczej precyzji.

Język programowania Go pozwala również na definiowanie różnych innych typów zmiennych, takich jak Enumeration, Pointer, Array, Structure i Union, które omówimy w kolejnych rozdziałach. W tym rozdziale skupimy się tylko na podstawowych typach zmiennych.

Definicja zmiennej w Go

Definicja zmiennej informuje kompilator, gdzie i ile pamięci ma utworzyć dla zmiennej. Definicja zmiennej określa typ danych i zawiera listę co najmniej jednej zmiennej tego typu w następujący sposób -

var variable_list optional_data_type;

Tutaj, optional_data_type jest prawidłowym typem danych Go, w tym bajt, int, float32, complex64, boolean lub dowolny obiekt zdefiniowany przez użytkownika itp. oraz variable_listmoże składać się z jednej lub więcej nazw identyfikatorów oddzielonych przecinkami. Tutaj pokazano kilka ważnych deklaracji -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

Twierdzenie “var i, j, k;”deklaruje i definiuje zmienne i, j oraz k; co instruuje kompilator, aby utworzył zmienne o nazwach i, j i k typu int.

Zmienne można zainicjować (przypisać wartość początkową) w ich deklaracji. Typ zmiennej jest automatycznie oceniany przez kompilator na podstawie przekazanej do niej wartości. Inicjator składa się ze znaku równości, po którym następuje stałe wyrażenie w następujący sposób -

variable_name = value;

Na przykład,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

W przypadku definicji bez inicjatora: zmienne ze statycznym czasem trwania są niejawnie inicjowane z wartością zero (wszystkie bajty mają wartość 0); początkowa wartość wszystkich innych zmiennych jest zerową wartością ich typu danych.

Statyczna deklaracja typu w Go

Deklaracja zmiennej typu statycznego zapewnia kompilatorowi, że dostępna jest jedna zmienna o podanym typie i nazwie, dzięki czemu kompilator może przystąpić do dalszej kompilacji bez wymagania pełnych szczegółów zmiennej. Deklaracja zmiennej ma swoje znaczenie tylko w momencie kompilacji, kompilator potrzebuje rzeczywistej deklaracji zmiennej w momencie linkowania programu.

Przykład

Wypróbuj poniższy przykład, w którym zmienna została zadeklarowana z typem i zainicjowana wewnątrz funkcji głównej -

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

20
x is of type float64

Dynamiczna deklaracja typu / wnioskowanie o typie w Go

Deklaracja zmiennej typu dynamicznego wymaga, aby kompilator zinterpretował typ zmiennej w oparciu o przekazaną do niej wartość. Kompilator nie wymaga, aby zmienna miała statyczny typ jako wymaganie konieczne.

Przykład

Wypróbuj poniższy przykład, w którym zmienne zostały zadeklarowane bez żadnego typu. Zauważ, że w przypadku wnioskowania o typie zainicjowaliśmy zmiennąy gdzie: = operator, podczas gdy x jest inicjowany za pomocą operatora =.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

20
42
x is of type float64
y is of type int

Deklaracja zmiennych mieszanych w Go

Zmienne różnych typów można deklarować za jednym razem za pomocą wnioskowania o typie.

Przykład

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Kiedy powyższy kod jest kompilowany i wykonywany, daje następujący wynik -

3
4
foo
a is of type int
b is of type int
c is of type string

L-wartości i r-wartości w Go

W Go są dwa rodzaje wyrażeń -

lvalue- Wyrażenia odnoszące się do lokalizacji pamięci nazywane są wyrażeniem „lwartość”. Wartość l może pojawić się po lewej lub prawej stronie przypisania.
rvalue- Termin rvalue odnosi się do wartości danych przechowywanych pod jakimś adresem w pamięci. Wartość r to wyrażenie, które nie może mieć przypisanej wartości, co oznacza, że wartość r może pojawić się po prawej, ale nie po lewej stronie przypisania.

Zmienne to lvalues, więc mogą pojawiać się po lewej stronie przydziału. Literały numeryczne są wartościami r, więc nie można ich przypisywać i nie mogą pojawiać się po lewej stronie.

Poniższe oświadczenie jest ważne -

x = 20.0

Poniższe stwierdzenie jest nieprawidłowe. Generowałoby to błąd w czasie kompilacji -

10 = 20