Go learning notes - constants

background —— Everything must have a background

Years ago , I ordered a few flag, It includes mastering a new back-end language . The direction set at that time was Java perhaps Go, in consideration of C# and Java There are many interlinked places , And the latest dotnet core The framework and java Of spring boot It's like , I want to study deeply Java. But then I thought ,Java Although for me , It may be less difficult to get started , But its huge and mature ecological circle , It will definitely cause some resistance to later learning , and , When you put it in , It may be difficult for me to take care of both C# and java Two directions , And my current job uses Microsoft's technology stack , With dotnet Mainly , So I still want to consider the following other directions .

And the current go The market is extremely hot , It belongs to the period of rapid development , The ecological circle is in its infancy , Include go The language itself is constantly updating and iterating , Cut in during the period of rapid development , follow-up go Our ecological circle will surely gradually improve , And I am using and learning go Will gradually understand go The ecosystem . So from all aspects , At present, it is still suitable to copy the bottom go Language direction ~

Before we get to the point

My study notes , Just simple notes , Because I'm distracted when I read a book or an article , Use this way to force yourself to study , There will also be a little personal summary , therefore , Great God, please give me some advice .

Then the learning path is geek time Tony Bai The teacher's 《

Go Language lesson one

》, Because it doesn't have go Basics , I don't know if the class is good , I look very easy to understand , Here is also a real name recommendation for this course ~

Notes

One 、 The benefits of constants

• It is created at the beginning of compilation , The value remains unchanged throughout the life cycle , The advantage is concurrent scenarios , Don't consider the synchronization of constants , This is basically the same as the constant definition of other languages

• Native support , Type safety

• go Language provides many innovations about constants , It is convenient for applications in different scenarios , Here I personally like to use constants to implement the enumeration feature .

Two 、go Innovation of constants in language

• Untyped constant
  , seeing the name of a thing one thinks of its function , That is, constants that do not seem to define numeric types （ Here's a little more ,go The constant definition of language only supports strings , Numeric and Boolean types ）, But in fact, the value type will be automatically assigned according to the initial value .

package main
import "fmt"

const n = 1 // Define a typeless constant , According to the initial value, we will give n Defined as int type

func main() {
 var a int = 5
 fmt.printIn(a + n) // Output 6
}

• Implicit conversion

Implicit transformation means , Evaluate expressions without type constants ,Go  The compiler will base on the type information in the context , Automatically convert the untyped constant to the corresponding type , Then participate in the evaluation calculation , This transformation is implicit .

-- Excerpt from 《

Go Language lesson one

》 The first 14 Introduction to constant innovation in the lecture

package main
import "fmt"

type myInt int // Custom numeric type , The bottom layer is int

const n = 2 // Define a typeless constant , According to the initial value, we will give n Defined as int type

func main() {
 var a myInt = 5
 fmt.printIn(a + n) // Output 7
}

• Implement enumeration

• go Language primitives have no enumeration types （enum）

• Go  Of  const  Syntax provides “ Implicitly repeats the previous non empty expression ” The mechanism of

• Go  On the basis of the above features, it also provides “ Artifact ”：iota,

iota  yes  Go  A predefined identifier for the language , It means  const  Declaration block （ Including a single statement ） in , The offset value of the position of each constant in the block （ Starting from scratch ）. meanwhile , In each line  iota  It is also a typeless constant itself , It can be like the untyped constant we mentioned earlier , Automatically participate in different types of evaluation process , There is no need for us to explicitly transform it .

-- Excerpt from 《

Go Language lesson one

》 The first 14 Introduction to constant innovation in the lecture

This example , Put the three scenes into one example , Steal laziness , Understand everything .

package main

import "fmt"

const (
Apple, Banana = iota, iota + 10 // 0, 10 (iota = 0)
Strawberry, Grape // 1, 11 (iota = 1)
Pear, Watermelon // 2, 12 (iota = 2)
)

const (
_ = iota // 0, White space characters
Pin1
Pin2
Pin3
_ // Use white space characters , skip Pin4, But then Pin5 The value of is still on time 5, Follow the standard library code $GOROOT/src/syscall/net_js.go
Pin5 // 5
)

//iota Better application scenarios , such as , The first enumeration type is only X,M,L, And if you want to add a new size later , Just add a new type to the corresponding enumeration
// In the previous way, all constants need to be manually modified
const (
_ = iota
S
M
//XM
L
)

func main() {
fmt.Println(Apple)
fmt.Println(Banana)
fmt.Println(Pear)
fmt.Println(Watermelon)

fmt.Println(Pin1)
fmt.Println(Pin5)

fmt.Println(S)
fmt.Println(L) // You can let go XM After the comments , see L It's going to change
}


Um. , This section is about that ~