Variables and constants of go language foundation

Go Basic variables and constants of language

go Basic format of language

package main //main After the package representation, an executable file is generated // Import statement import "fmt"//  The outer edge of a function can only be declared //  Program entry func main()  {    fmt.Println("Hello world!")}

Variable

package mainimport "fmt"//  Variable declarations // var name string// var age int// var isOk boolvar student_name stringvar studentName string var StudentName string //  Batch statement var ( //  The default value is     name string // ""    age  int    // 0    isOk bool   // false)// go  Local variables declared in functions must use , But global variables do not have to be used \//  Variables with the same name cannot be declared repeatedly in the same scope func main() {    // var day int     name = "lixiang"    age = 18    isOk = true    //  Declare variables and assign values at the same time     var s1 string = "luozongwei"    fmt.Println(s1)    //  Type derivation     var s2  = 1232    fmt.Println(s2)    //  Short variable declaration , Can only be used in functions     s3 := " Hey, uh huh "    fmt.Println(s3)}

Anonymous variables

When using multiple assignments , If you want to ignore a value , have access to Anonymous variables （anonymous variable） . Anonymous variables are underlined _ Express , for example ：

package mainimport (    "fmt")func foo() (int, string){  //  In the second bracket is the return type of the function     return 10,  "Luozongwei"}func main()  {    x, _ := foo()    _, y := foo()    fmt.Println("x=", x)    fmt.Println("y=", y)}

Anonymous variables do not take up the namespace , Memory will not be allocated , So there is no duplicate declaration between anonymous variables . ( stay Lua And so on , Anonymous variables are also called dummy variables .)
matters needing attention ：

1. Every statement outside the function must start with a keyword （var 、const、func etc. ）

2. := Can't be used outside of a function .

3. _ It is often used for space occupying , Indicates the ignored value .

Constant

Relative to variables , A constant is a constant value , It is often used to define the values that will not change during the running of the program . The declaration of constants is very similar to the declaration of variables , Just put var Instead of const , Constants must be defined with values .

const pi = 3.1415const e = 2.7182

The statement pi and e After these two constants , Their values can no longer be changed during the entire program run .
Multiple constants can also be declared together ：

const (    pi = 3.1415    e = 2.7182)

const When multiple constants are declared at the same time , If the value is omitted, it means that it is the same as the value in the previous line . for example ：

const (    n1 = 100    n2    n3)

In the above example , Constant n1 、 n2 、 n3 The values are all 100.

iota

iota yes go Constant counter of language , Can only be used in constant expressions .
iota stay const The keyword will be reset to 0.const Every new line of constant declaration in will cause iota Count once (iota Can be understood as const Line index in statement block ). Use iota Can simplify the definition of , Useful when defining enumerations .
for instance ：

const (        n1 = iota //0        n2        //1        n3        //2        n4        //3    )

Several common iota Example :

Use _ Skip some values

const (        n1 = iota //0        n2        //1        _        n4        //3    )

iota Make a statement to jump in the middle

const (        n1 = iota //0        n2 = 100  //100        n3 = iota //2        n4        //3    )    const n5 = iota //0

Define the order of magnitude （ there << Indicates move left operation , 1<<10 It means that you will 1 The binary representation of is shifted to the left 10 position , That is, by 1 Turned into 10000000000 , That's decimal 1024. Empathy 2<<2 It means that you will 2 The binary representation of is shifted to the left 2 position , That is, by 10 Turned into 1000 , That's decimal 8.）

const (        _  = iota        KB = 1 << (10 * iota)        MB = 1 << (10 * iota)        GB = 1 << (10 * iota)        TB = 1 << (10 * iota)        PB = 1 << (10 * iota)    )

Multiple iota It's defined on one line

const (        a, b = iota + 1, iota + 2 //1,2        c, d                      //2,3        e, f                      //3,4    )

towards b Standing on the achievements of the old boy teacher Li Wenzhou ！！！
author ：asddsa1233122132

this paper [ Go Basic variables and constants of language ] Included in Game programming ️ - Go, A game development favorite ~

If the picture is not displayed for a long time , Please use Chrome browser .