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.

How to use constants in Golang

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

Leave a Comment

Would Europe Be Drawn into a Hypothetical U.S.-Israel-Iran Nuclear War? NATO Rules Explained

Would Europe Be Drawn into a Hypothetical U.S.-Israel-Iran Nuclear War? NATO Rules Explained

A guide to NATO Articles 4 and 5, UN self-defense rules, and why consultation does not mean automatic European entry into war.

Could Iran Already Have Nuclear Weapons? How to Read the Evidence

Could Iran Already Have Nuclear Weapons? How to Read the Evidence

Assess claims about Iran in six steps, distinguishing uranium enrichment, weapons development and verified possession.

US and Israel Nuclear Authority: What Public Sources Actually Explain

US and Israel Nuclear Authority: What Public Sources Actually Explain

Understand nuclear decision authority in six steps, including US civilian control and the limits of public information about Israel.

Strait of Hormuz in 2026: What Official Sources Say About Shipping Disruption

Strait of Hormuz in 2026: What Official Sources Say About Shipping Disruption

A guide to official 2026 evidence on Hormuz shipping disruption, Iran-related claims, confirmed incidents, and what remains uncertain.

Would a Hypothetical U.S.-Israeli Nuclear Strike on Iran Cause World War 3?

Would a Hypothetical U.S.-Israeli Nuclear Strike on Iran Cause World War 3?

A source-based guide to nuclear escalation risks, UN Charter rules and NATO Article 5 in a strictly hypothetical Iran scenario.

How to Prepare for a Hypothetical EMP-Related Power Outage: 5 Civilian Steps

How to Prepare for a Hypothetical EMP-Related Power Outage: 5 Civilian Steps

Use five steps to prepare for an outage; nuclear and EMP scenarios are hypothetical, and official shelter instructions come first.

How to Assess Cyber Disruptions Without Assuming WW3: A 5-Step Guide

How to Assess Cyber Disruptions Without Assuming WW3: A 5-Step Guide

Use 5 defensive steps to verify a cyber disruption, protect household accounts, and avoid mistaking an outage for war.

Nuclear Winter: How to Assess the Global Climate Effects of a Hypothetical Iran Strike

Use these 5 steps to assess climate effects from a hypothetical Iran strike, compare model assumptions, and avoid unsupported predictions.

How Long Could Earth Take to Recover After a Hypothetical Nuclear War?

How Long Could Earth Take to Recover After a Hypothetical Nuclear War?

Explore six steps for reading research on climate, food and ecosystem recovery after a hypothetical nuclear conflict.

Nuclear Fallout Preparedness Checklist: Essential Supplies and Shelter Steps

Nuclear Fallout Preparedness Checklist: Essential Supplies and Shelter Steps

Build a practical fallout preparedness kit in six steps, with sealed food and water, a radio, medical supplies and shelter guidance.