How to use constants in Golang

What is a Constant or Const in Golang ? Here are the things you need to know about using constants in Go .

As the name suggests, constant means fixed. In programming languages, it means once the value of a constant is defined, it cannot be modified further. There can be any basic data type of constant like integer constant, dynamic constant, character constant or string.

Declaration: Constants are declared like variables but use the keyword const as a prefix to declare a constant with a specific data type. Constants cannot be declared using the syntax “: = ”.

For example:

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)
}

Result:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Things to know about constants in Golang

Numeric constants without type and with type

Typed constants work like immutable variables that can only interact with the same type, and untyped constants work like literal constants that can interact with similar types. Constants can be declared with or without a type in Go. Here are examples showing typed and untyped, named and unnamed numeric constants.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Here is the list of constants in Go Language:

• Constants (Integer Constants, Dynamic Constants, Complex Constants)
• String of characters
• Boolean constant

Number constant

Numeric constants are high-precision values. Since Go is a statically typed language, it does not allow operations that combine numeric types. You cannot add float64, intor even int32to int. However, it is still valid to write 1e6*time.Secondor math.Exp(1)or even 1<>. In Go, constants, unlike variables, behave like regular numbers.

Numeric constants are of three types:

1. integer
2. floating point
3. complex

Integer constant:

• The prefix specifies the base: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal.
• An integer literal can also have a suffix that is a combination of U (uppercase) and L (lowercase), for unsigned and long respectively.
• It can be a decimal, octal or hexadecimal constant.
• An int can store up to a 64-bit integer and sometimes less.

Here are some examples of Integer Constants:

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ố */

Complex constants:

A complex constant works very similar to a floating point constant. It is an ordered pair or real number of an integer constant (or parameter). And the constants are separated by commas, and the pair of numbers are enclosed in parentheses. The first constant is the real part, and the second constant is the imaginary part. A complex constant, COMPLEX*8, uses 8 bytes of storage.

For example:

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

Dynamic type constant:

• Real number constants have an integer part, a decimal part, a fractional part, and an exponent part.
• Can be represented as a real constant in decimal or exponential form.
• When expressed in decimal form, it must include a decimal point, an exponent, or both.
• And when expressed in exponential form, it must include an integer part, a fractional part, or both.

For example:

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ố */

String of characters

• Go supports two types of string literals, i.e. ” ”(double quote style) and ‘ ‘(backward quote style).
• +Strings can be concatenated with the and operators +=.
• Strings contain the same characters as literal characters: plain characters, escape sequences, and universal characters. And this is a character without a type.
• The zero value of string types is the empty string, which can be represented by ” ”or ”in literals.
• All string types can be compared using operators like ==, !=and (to compare similar types)

Syntax:

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

For example:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

Here, all three statements are same, that is, they do not have any specific type.

For example:

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)="">

Result:

GFG Quantrimang!
true
false

Time complexity: O(1)
Auxiliary space: O(1)

Boolean constant

Boolean constants are similar to string constants. They follow the same rules as string constants. The only difference is that they have two non-type consts, trueand 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) 
}

Result:

true
true

Time complexity: O(1)
Auxiliary space: O(1)

Constants in Go: Go has character, string, Boolean and numeric constants. Const declares a constant value. A statement that constcan occur when there is a variable and thus, performs arithmetic operations without any fixed precision.

// 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))
}

Result:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Time complexity: O(1)
Auxiliary space: O(1)

If you want to define multiple constants at once, you can do so using a block of parentheses as shown below.

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)
}

Result:

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