Jak używać stałych w Golang

Co to jest stała lub const w języku Go ? Oto, co musisz wiedzieć o korzystaniu ze stałych w języku Go .

Jak sama nazwa wskazuje, stały oznacza ustalony. Podobnie jest w językach programowania, tzn. gdy wartość stałej zostanie zdefiniowana, nie można jej już modyfikować. Może istnieć dowolny podstawowy typ danych stałej, taki jak stała całkowita, stała dynamiczna, stała znakowa lub ciąg znaków.

Jak deklarować: Stałe deklaruje się jak zmienne, ale do deklarowania stałych o określonym typie danych używa się słowa kluczowego const jako prefiksu. Stałych nie można deklarować stosując składnię „: = ”.

Na przykład:

package main

import "fmt"

const PI = 3.14

func main() 
{
	const GFG = "Quantrimang"
	fmt.Println("Hello", GFG)

	fmt.Println("Happy", PI, "Day")

	const Correct= true
	fmt.Println("Go rules?", Correct)
}

Wynik:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Rzeczy, które należy wiedzieć o stałych w Golangu

Stałe numeryczne bez typu i z typem

Stałe typowane zachowują się jak zmienne niezmienne, które mogą oddziaływać tylko z typami tego samego typu, a stałe beztypowe zachowują się jak stałe literalne, które mogą oddziaływać z podobnymi typami. W języku Go stałe można deklarować z typem lub bez niego. Poniższe przykłady pokazują stałe numeryczne typu i typu, nazwane i nienazwane.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Oto lista stałych w języku Go:

• Stałe (stałe całkowite, stałe dynamiczne, stałe zespolone)
• Ciąg znaków
• Stała Boole'a

Stała liczbowa

Stałe numeryczne to wartości o dużej precyzji. Ponieważ Go jest językiem statycznie typowanym, nie pozwala na wykonywanie operacji łączących typy liczbowe. Nie można dodawać float64do int, ani nawet int32do int. Niemniej jednak nadal można pisać 1e6*time.Second„lub math.Exp(1)”, „lub” i „nie 1<>”. W języku Go stałe, w przeciwieństwie do zmiennych, zachowują się jak zwykłe liczby.

Istnieją trzy typy stałych liczbowych:

1. liczba całkowita
2. zmiennoprzecinkowy
3. złożony

Stała całkowita:

• Prefiks określa podstawę: 0x lub 0X dla systemu szesnastkowego, 0 dla systemu ósemkowego i nic dla systemu dziesiętnego.
• Literał całkowity może mieć również sufiks będący kombinacją liter U (wielka) i L (mała), odpowiednio dla unsigned i long .
• Może to być stała dziesiętna, ósemkowa lub szesnastkowa.
• Typ int może przechowywać liczbę całkowitą do 64 bitów, a czasami mniej.

Oto kilka przykładów stałych całkowitych:

85 /* thập phân */
0213 /* bát phân */
0x4b /* thập lục phân */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
212 /* Hợp lệ */
215u /* Hợp lệ */
0xFeeL /* Hợp lệ */
078 /* Không hợp lệ: 8 không phải là chữ số bát phân */
032UU /* Không hợp lệ: không thể lặp lại hậu tố */

Stałe zespolone:

Stałe złożone działają bardzo podobnie do stałych zmiennoprzecinkowych. Jest to para uporządkowana lub para rzeczywista stałych całkowitych (lub parametrów). Stałe należy oddzielać przecinkami, a pary liczb umieszczać w nawiasach. Pierwsza stała to część rzeczywista, a druga stała to część urojona. Stała zespolona COMPLEX*8 zajmuje 8 bajtów pamięci.

Na przykład:

(0.0, 0.0) (-123.456E+30, 987.654E-29)

Stała typu dynamicznego:

• Stałe liczby rzeczywiste składają się z części całkowitej, części dziesiętnej, części ułamkowej i części wykładniczej.
• Można ją przedstawić jako stałą rzeczywistą w formie dziesiętnej lub wykładniczej.
• W przypadku wyrażenia w postaci dziesiętnej musi zawierać przecinek dziesiętny, wykładnik lub oba te elementy.
• A gdy jest wyrażona w formie wykładniczej, musi zawierać część całkowitą, część ułamkową lub obie.

Na przykład:

3.14159 /* Hợp lệ */
314159E-5L /* Hợp lệ */
510E /* Không hợp lệ: số mũ không đầy đủ */
210f /* Không hợp lệ: không có số thập phân hoặc số mũ */
.e55 /* Không hợp lệ: thiếu số nguyên hoặc phân số */

Ciąg znaków

• Język Go obsługuje dwa typy literałów ciągów, tj. ” ”(styl podwójnych cudzysłowów) i ‘ ‘(styl odwrotnych cudzysłowów).
• Ciągi znaków można łączyć za pomocą operatorów +i +=.
• Ciągi znaków zawierają znaki podobne do znaków literowych: znaki zwykłe, sekwencje specjalne i znaki uniwersalne. A to jest postać bez stylu.
• Wartość zerowa w typach string to pusty string, który może być reprezentowany przez ” ”lub ”w literałach.
• Wszystkie typy ciągów znaków można porównywać za pomocą operatorów takich jak ==, !=i (w celu porównania podobnych typów)

Składnia:

kiểu _string struct {
các phần tử *byte // các byte cơ bản
len int // số byte
}

Na przykład:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

Tutaj wszystkie trzy stwierdzenia są takie same, tzn. nie mają żadnego konkretnego typu.

Na przykład:

package main

import "fmt"

func main()
{
	const A = "GFG"
	var B = "GeeksforGeeks"
	
	// Chuỗi Concat.
	var helloWorld = A+ " " + B
	helloWorld += "!"
	fmt.Println(helloWorld) 
	
	// Chuỗi so sánh.
	fmt.Println(A == "GFG") 
	fmt.Println(B < a)="">

Wynik:

GFG Quantrimang!
true
false

Złożoność czasowa: O(1)
Przestrzeń pomocnicza: O(1)

Stała Boole'a

Stałe boolowskie są podobne do stałych łańcuchowych. Obowiązują te same zasady co stałe łańcuchowe. Jedyną różnicą jest to, że ma dwa const bez typu truei false.

package main

import "fmt"

const Pi = 3.14

func main() 
{
	const trueConst = true
	
	// Định nghĩa kiểu bằng từ khóa type
	type myBool bool 
	var defaultBool = trueConst // được phép
	var customBool myBool = trueConst // được phép
	
	// defaultBool = customBool // không được phép
	fmt.Println(defaultBool)
	fmt.Println(customBool) 
}

Wynik:

true
true

Złożoność czasowa: O(1)
Przestrzeń pomocnicza: O(1)

Stałe w Go: Go obsługuje stałe znakowe, łańcuchowe, logiczne i numeryczne. Const deklaruje wartość stałą. Instrukcja constmoże występować, gdy istnieje zmienna, i w związku z tym wykonywać operacje arytmetyczne bez ustalonej precyzji.

// Minh họa hằng số bằng cách dùng go.
package main

import (
	"fmt"
	"math"
)

const s string = "Quantrimang"

func main() {
	fmt.Println(s)

	const n = 5

	const d = 3e10 / n
	fmt.Println(d)

	fmt.Println(int64(d))

	fmt.Println(math.Sin(n))
}

Wynik:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Złożoność czasowa: O(1)
Przestrzeń pomocnicza: O(1)

Jeśli chcesz zdefiniować wiele stałych jednocześnie, możesz to zrobić za pomocą bloku nawiasów, jak pokazano poniżej.

package main

import "fmt"

const (
	GFG	 = "Quantrimang"
	Correct = true
	Pi	 = 3.14
)

// Hàm chính
func main() {

	fmt.Println("value of GFG : ", GFG)

	fmt.Println("value of Correct : ", Correct)

	fmt.Println("value of Pi : ", Pi)
}

Wynik:

value of GFG :  Quantrimang
value of Correct :  true
value of Pi :  3.14