AppDividend
Latest Code Tutorials

Golang Constants Tutorial With Example | Constants in Go

0

Golang Constants Tutorial With Example | Constants in Go is today’s topic. Go supports the constants of character, string, boolean, and numeric values. Constants are created at compile time, even when defined as locals in functions, and can only number, characters (runes), strings or booleans. Because of Golang’s compile-time restriction, the expressions that define them must be constant expressions which is evaluated by the compiler.

Golang Constants Tutorial

The const declares a constant value. Constant expressions perform arithmetic with arbitrary precision. The numeric constant has no type until it’s given, such as by an explicit cast.

A number can be given the type by using it in a context that requires one, such as the variable assignment or a function call.

In Golang, we use a term constant represent fixed (unchanging) values such as 3.14, 21, “Hello,” etc.

Literals are constants. All the literals in Go, be it integer literals like 21, 46, or floating-point literals like 3.14, 19.21, or boolean literals like true, false, or string literals like “Krunal,”Ankit” are constants.

Declaring a Constant in Golang

We can declare a constant and give it a name, and you can use the keyword const like the following.

const blog = "AppDividend"
const flag = true

You can also specify the type in the declaration like the following code.

const x int = 1921
const y string = "Krunal"

We can also define multiple constants. See the following code.

// hello.go

package main

import "fmt"

func main() {
	const name, country = "Krunal", "India"

	const (
		stockName  string  = "Infosys"
		stockPrice float64 = 702.50
	)
	fmt.Println(stockName, stockPrice)
        fmt.Println(name, country)
}

See the below output.

Golang Constants Tutorial With Example

 

Now, let’s try to modify the value of the constants and see the result.

// hello.go

package main

import "fmt"

func main() {
	const name, country = "Krunal", "India"
	name = "Ankit"
	fmt.Println(name, country)
}

See the below output.

change the value of the constants

 

So, we have got the error like Cannot assign the constant.

Typed and Untyped Constants

Go is the statically typed programming language. Which means that a type of every variable is known or inferred by the compiler at the compile time. But it goes beyond that step with its type system and doesn’t even allow us to perform the operations that mix numeric types. For example, We cannot add the float64 variable to an int, or yet an int64 variable to an int. See the following code.

// hello.go

package main

func main() {
	var floatVal float64 = 3.14
	var intVal int = 19
	var int64Val int64 = 21

	var o1 = floatVal + intVal
	var o2 = intVal + int64Val
}

See the below output.

Typed and Untyped Constants

 

So, we have got the error like invalid operation. Golang doesn’t provide an implicit type conversion, and it requires you to do the explicit type casting whenever we mix the variables of multiple types in the operation.

Untyped Constants in Golang

Any constant in Go, named or unnamed, is an untyped unless given a type explicitly. See the following examples.

21       // untyped integer constant
1.9     // untyped floating-point constant
false    // untyped boolean constant
"Cloud"

See the untyped constants even after you give the name.

const x = 19
const y = 2.1
const z = false
const w = "Zing"

Let’s now see the example of an untyped string constant.

In Go, you can create the type alias using the type keyword like the following.

type AppDividend string

Given the strongly typed nature of the Golang, you can’t assign the string variable to an AppDividend variable.

// hello.go

package main

func main() {
	type AppDividend string
	var mString string = "Hello"
	var mStringA AppDividend = mString
}

See the below output.

Untyped Constants in Golang

 

Untyped constants are a fantastic design decision taken by Go creators. Although Go has a robust type system, You can use the untyped constants to escape from the Go’s type system and have more flexibility when working with a mixed data types in any expression.

Typed Constants in Golang

In Go, Constants are typed when you explicitly specify a type in the declaration like the following syntax.

const typedInt int = 21

Just like the variables, all the rules of Go’s type system applies to the typed constant. For example, you cannot assign the typed integer constant to a float variable. See the following code.

var myFloat64 float64 = typedInt  // Compiler Error

With the typed constants, you lose all the flexibility that comes with the untyped constants like assigning them to any variable of the compatible type or mixing them in the mathematical operations. So you should declare the type for a constant only if it’s necessary. Otherwise, declare constants without a type.

Conclusively, Golang Constants Tutorial With Example | Constants in Go post is over.

Leave A Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.