Shulou(Shulou.com)06/03 Report--

Golang types and variables and constant example analysis, I believe that many inexperienced people do not know what to do, so this article summarizes the causes of the problem and solutions, through this article I hope you can solve this problem.

Basic type

1. List of basic types

The code is as follows:

Type length description

Bool 1 true/false, default false, cannot treat non-zero values as true (no numbers represent true/false)

Byte 1 uint8 alias

Rune 4 int32 alias. Represents a unicode code point

The platform on which int/unit runs, 32bit/64bit

Int8/uint8 1-128-127; 0-255

Int16/uint16 2-32768 ~ 32767; 0 ~ 65535

Int32/uint32 4-2.1 billion ~ 2.1 billion, 0 ~ 4.2 billion

Int64/uint64 8

Float32 4 is accurate to 7 decimal places, equivalent to the float of c

Float64 8 is accurate to 15 decimal places, equivalent to the double of c

Complex64 8

Complex128 16

Uintptr is sufficient to hold 32-bit and 64-bit integers of pointers, pointers (integers that can store pointers)

Array value type, array

Struct value type, structure

String value type, string type, commonly used

Slice reference types, slicin

Map reference types, dictionaries

Channel reference type, channel

Interface interface type, interface

Function function type, function

two。 Type conversion

Implicit type conversion is not supported. Explicit type conversion must be performed.

Conversion only occurs between two types that are compatible with each other: all kinds of int are not allowed to assign values or operate to each other, otherwise they will make mistakes in the compilation time.

The code is as follows:

(expression)

Example

The code is as follows:

Package main

Import "fmt"

Func main () {

A: = 0x1234

B: = 1234.56

C: = 256

Fmt.Printf ("% x\ n", uint8 (a))

Fmt.Printf ("% d\ n", int (b))

Fmt.Printf ("% f\ n", float64 (c))

}

Result

The code is as follows:

thirty-four

1234

256.000000

3. Type alias

The code is as follows:

Type t_str string

Var b t_str = "a str"

4. Type default value

Declaration does not assign a value, type zero, non-null, but the declared default value

The code is as follows:

Bool: false

Integers: 0

Floats: 0.0

String: ""

Pointers,functions,interfaces,slices,channels,maps: nil

Reserved word

The code is as follows:

Break case chan const continue

Default defer else fallthrough for

Func go goto if import

Interface map package range return

Select struct switch type var

Variable

1. Variable declaration

The code is as follows:

/ / first, specify the variable type. If no value is assigned after declaration, the default value is used.

Var v_name v_type

V_name = value

/ / second, determine the variable type according to the value

Var v_name = value

/ / third, omit var, note: the variable on the left side of = should not have been declared, otherwise it will result in a compilation error.

V_name: = value

E.g.

Var an int = 10

Var b = 10

C: = 10

Example:

The code is as follows:

Package main

Var a = 1234

Var b string = "hello"

Var c bool

Func main () {

Println (a, b, c)

}

Results:

The code is as follows:

1234 hello false

two。 Multivariable declaration:

The code is as follows:

/ / multiple variables of the same type, non-global variables

Var vname1, vname2, vname3 type

Vname1, vname2, vname3 = v1, v2, v3

Var vname1, vname2, vname3 = v1, v2, v3 / / is very similar to python, which does not need to display the declared type and infers automatically.

Vname1, vname2, vname3: = v1, v2, v3 / / the variable to the left of: = should not have been declared, otherwise it will result in a compilation error

/ / multiple variables with different types, global variables and local variables cannot be used in this way

Var (

Vname1 v_type1

Vname2 v_type2

)

Example:

The code is as follows:

Package main

Var x, y int

Var (/ / this can only be found in global variables, and is not supported in the function body.

An int

B bool

)

Var c, d int = 1,2

Var e, f = 123, "hello"

/ / this kind of non-declarative format can only appear in the function body

/ / g, h: = 123, "hello"

Func main () {

G, h: = 123, "hello"

Println (x, y, a, b, c, d, e, f, g, h)

}

Results:

The code is as follows:

0 0 0 false 12 123 hello 123 hello

Note:

a. When multiple variables are assigned, the values of all left variables are calculated first, and then assigned.

The code is as follows:

I: = 0

I, l [I] = 1,2

/ / get I = 1, l [0] = 2

Sc [0], sc [0] = 1,2

/ / get sc [0] = 2

b. Trash can _

The code is as follows:

Func test () (int, string) {

Return 123, "abc"

}

A, _: = test ()

c. Variables that are declared but not used will report errors at compile time, which is more stringent than Python

Constant

Constants can be characters, strings, Boolean or numbers

Constant assignment is a behavior at compile time.

1. Constant declaration

A value that can be determined at compile time and cannot be changed at run time

Constants can be defined as numeric, Boolean, or string types

The copy code is as follows:

Const constantName = value

Const Pi float32 = 3.1415926

Const c_name [type] = value

Const c_name1, c_name2 = value1, value2

Const (

C_name1 = vluae1

C_name2 = value2

)

To the right, it must be a constant or constant expression, and if a function is used, it must be a built-in function (compile-time behavior)

Const I = 10000

Description:

The code is as follows:

a. Constants must be Number (char/integer/float/complex), String and bool that can be determined at compile time

b. When defining a constant array, if you do not provide an initialization value, it is exactly the same as the upstream constant type, value,

Const (

A = "abc"

B

)

/ / then b = "abc"

c. Constants you can use len (), cap (), unsafe.Sizeof () constants to evaluate the value of an expression. In a constant expression, the function must be a built-in function, otherwise it cannot be compiled

Package main

Import "unsafe"

Const (

A = "abc"

B = len (a)

C = unsafe.Sizeof (a)

)

Func main () {

Println (a, b, c)

}

Results: abc 3 16

Enumerate

Iota, a special constant, can be thought of as a constant that can be modified by the compiler

When each const keyword appears, it is reset to 0, and then before the next const appears, each time iota appears, the number it represents automatically increases by 1.

If no initial value is provided, the expression of the previous line is used

1. Declaration:

Iota generates an auto-growing enumeration value starting at 0, which means that there is one more enumeration value, iota+=1, whether or not you use the

Basic grammar

The code is as follows:

Const (

A = 1

B = 2

)

Const (

A = iota / / 0

B / / 1

C / / 2

)

Const (

_ = iota

A / / 1

B / / 2

)

Iota usage

The code is as follows:

Func main () {

Const (

A = iota / / 0

B / / 1

C / / 2

D = "ha" / / Independent value, iota + = 1

E / / "ha" iota + = 1

F = 100 / / iota + = 1

G / / 100 iota + = 1

H = iota / / 7, restore count

I / / 8

)

}

Const (

X = iota / / 0

Y = iota / / 1

Z = iota / / 2

W / / omitted, default is the same literal value as before, w = iota, that is, 3

)

Const v = iota / / encountered the const keyword, iota reset

Note: the number of variables in each row must be the same as const (A, B = iota, iota C, DE, F)

The copy code is as follows:

Func main () {

Println (A, Magi B, C, D, E, F)

}

/ / results: 0 0 1 1 2 2 [respective growth]

Operator

Go operators are all joined from left to right

Operator overloading is not supported

The code is as follows:

Precedence operator description

High * /% > & & ^ (AND NOT)

+ -! ^

=! =

< >

=

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.