【Go语言】基本使用

变量声明

1、变量声明

	var a int  //声明一个整形的变量，可以保存整数数值
	var b string //声明一个字符串类型的变量
	var c []float32 //声明一个32为浮点切片类型的变量

    // 声明一个返回值为布尔类型的函数变量
	var d func() bool    

	var e struct{   //声明一个结构体类型的变量，这个结构体拥有一个整型的x字段
		x int 
        }

变量声明的格式：

var  变量名  变量类型

批量格式

var(
    a int
    b string
    c []float32
    e struct{
    x int
    }
)

Go在声明变量时，自动对变量对应的内存区域进行初始化操作。每个变量会初始化其类型的默认值。如：

整型和浮点型变量的默认值为0

字符串变量的默认值为空字符串

布尔型变量默认为false

切片、函数、指针变量的默认为nil

2、变量初始化

标准格式：

var 变量名 类型 =表达式

编译器推到类型的格式：

var 变量名=表达式

短变量申明并初始化：

变量名 ：=表达式

3、多变量赋值

Go语言具有“多重赋值”的特性，节约内存资源

func main() {
var a int=100
var b int=200
b,a=a,b
fmt.Println(a,b)

结果如下：
200 100

4、匿名变量——没有名字的变量

匿名变量表现为"_"下划线，不用接收变量时，可使用匿名变量。

数据类型

Go语言中丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串型外，还有切片、结构体、函数、map、通道（channel）

由于基本字符和其他类型大同小异，举一些例子介绍。

例1  布尔型

package main

import "fmt"

func main() {
	//Go语言中不允许将整型强制转换为布尔类型
	var n bool
	fmt.Println(int(n))
}

 编译错误：

cannot convert n (type bool) to type int

例2  字符串转义符

package main

import "fmt"

func main() {
	//Go语言中的转移符号代码
fmt.Println("str :=\"c:\\Go\\bin\\go.exe\"")
}

代码输出如下：

str :="c:\Go\bin\go.exe"

例3  多行字符串

package main

import "fmt"

func main() {
	//Go语言定义多行字符串
const str=`第一行
第二行
第三行
\r\n
`
fmt.Println(str)
}

代码输出如下：

第一行
第二行
第三行
\r\n  

例4  字符

package main

import "fmt"

//使用fmt.Printf中的%T动词可以输出变量的实际类型，使用这个方法可以查看byte和rune的本来类型
func main() {
var a byte ='a'
fmt.Printf("%d %T\n",a,a)

var b rune ='你'
fmt.Printf("%d %T\n",b,b)
}

输出结果：

97 uint8
20320 int32

例5 切片

package main

import "fmt"

func main() {
str :="hello world"
fmt.Println(str[6:])
}

输出结果：

world

例5 不同数据类型转换

package main

import (
	"fmt"
	"math"
)

func main() {
	//输出各数值范围
fmt.Println("int8 range:",math.MinInt8,math.MaxInt8)
fmt.Println("int8 range:",math.MinInt16,math.MaxInt16)
fmt.Println("int8 range:",math.MinInt32,math.MaxInt32)
fmt.Println("int8 range:",math.MinInt64,math.MaxInt64)

//初始化一个32位整型值
var a int32=1047483647
//输出变量的十六进制形式和十进制形式
fmt.Printf("int32:0x%x %d\n",a,a)

//将a变量数值转化为十六进制，发生数值截断
b:=int16(a)
//输出变量的十六进制形式和十进制值
fmt.Printf("int32:0x%x %d\n",b,b)

//将常量保存为float32类型
var c float32=math.Pi
//转换为int类型，浮点发生精度丢失
fmt.Println(int(c))
}

输出结果：

int8 range: -128 127
int8 range: -32768 32767
int8 range: -2147483648 2147483647
int8 range: -9223372036854775808 9223372036854775807
int32:0x3e6f54ff 1047483647
int32:0x54ff 21759
3

例6 指针

package main

import "fmt"

func main() {
	var cat int = 1
	var str string = "banana"
	Cat := &cat
	Str := &str
	fmt.Printf("%p %p %d %s\n", &cat, &str, *Cat, *Str)
}

输出结果：

0xc000014088 0xc000036230 1 banana

例7 字符串遍历

package main

import "fmt"

func main() {
	var a string = "你好，Let's go!"
	//便利每一个ASCII字符
	for i := 0; i < len(a); i++ {
		fmt.Printf("%d :%c\n", i, a[i])
	}
	//按Unicode字符遍历字符串
	//如果不需要使用变量时，可用下划线代替，同理在函数返回值等地方也可用到
	for _,s:=range a{
		fmt.Printf("%c\n",s)
	}

}

输出结果：

0 :ä
1 :½
2 : 
3 :å
4 :¥
5 :½
6 :ï
7 :¼
8 :
9 :L
10 :e
11 :t
12 :'
13 :s
14 :
15 :g
16 :o
17 :!
你
好
，
L
e
t
'
s

g
o
!

例8获取某段字符

注意UTF8中文字符是一个中文字符占三个字节。

package main

import (
	"fmt"
	"strings"
)

func main() {
	tracer := "你好，这里是go"
	comma := strings.Index(tracer, "，")
	pos := strings.Index(tracer[comma:], "这里是")
	fmt.Println(comma, pos,tracer[comma+pos:])
}

输出结果：

6 3 这里是go

这里comma := strings.Index(tracer, "，")的逗号是tracer中内容的逗号，并且这里的字符串不能出错。

例9修改字符串

package main

import "fmt"

func main() {
	s1 := "Hello，this is go"
	//将字符串转换为字符串数组
	s2 := []byte(s1)
	for i:=5;i<=11;i++{
		s2[i]=' '
	}
	fmt.Println(string(s2))
}

输出结果：

Hello        is go

例10 链接字符串

package main

import (
	"bytes"
	"fmt"
)

func main() {
	a1 := "安徽省"
	a2 := "合肥市"
	var aa bytes.Buffer

	aa.WriteString(a1)
	aa.WriteString(a2)
	fmt.Println(aa.String())
}

输出结果：

安徽省合肥市