1.利用格式化字符串打印变量类型

在python中，可用type()函数取得变量类型。golang中，利用fmt.printf，在里面格式化加上%T,注意大写，可以获得变量类型

例子:

grade:="A"
fmt.Printf("grade的变量类型是 %T",grade)

会在控制台打印 string

另外变量.(type) 只能在switch语句中使用来获取接口申明的变量类型，例子:

func demo1()  {
	var x interface{}
	x = "A"
	switch i := x.(type) {
	case nil:
		fmt.Printf(" x 的类型 :%T",i)
	case int:
		fmt.Printf("x 是 int 型")
	case float64:
		fmt.Printf("x 是 float64 型")
	case func(int) float64:
		fmt.Printf("x 是 func(int) 型")
	case bool, string:
		fmt.Printf("x 是 bool 或 string 型" )
	default:
		fmt.Printf("未知型")
	}
}

2.循环的写法

golang中好像没有了常规的while语句了，只剩下一个for了。

for大概有三种用法 ，跟常规语言类似。

2.1 比如实现的一个递增取值的函数:

func add(num int)  int{
	ret :=0
	for i:=0;i<num;i++{
		ret+=i
	}
	return ret
}

2.2 循环条件为true实现while 1

func while()  {
	for true{
		println(1)
	}
}

2.3遍历一个数组对象，配上range关键字。跟python里面的range还是差别很多。我个人更喜欢for in语句

var string1 = []string{"google", "runoob"}

func range_demo()  {
	strings := []string{"google", "runoob"}
	a := []int{1,2,3}
	println(len(strings))
	println(len(a))
	println(string1)

	for i,x:=range string1{
		println(i,x)
	}
}

3.函数定义中参数传递，值传递与引用传递。python中都是值传递的，golang中常规传参也是值传递，易语言中是引用传递。

golang中用指针传递的话是引用传递。下面demo可以很好的看出来:

package main

import "fmt"

func swap1(a int,b int)  (int,int){
	tmp := a
	a = b
	b = tmp
	return a,b
}
func swap2(a *int,b *int)(int,int)  {
	tmp := *a
	*a  = *b
	*b = tmp
	return *a,*b
}
func main() {
	fmt.Println("Hello, World!")
	x := 1
	y:=2
	a,b := swap1(x,y)
	println(a,b)
	println(x,y)
	a,b = swap2(&x,&y)
	println(a,b)
	println(x,y)
	x,y = y,x
	println(x,y)
}

当然，这只是一个举例而已，最快的变量交换方法还是只需要一行代码就Ok了，和python一样:

x,y = y,x

4.数组定义。

关于golang数组初始化，直接申明一个全局变量，应该是需要给出来数组的尺寸的。而定义一个局部变量数组并有值的话，应该可以省略[]里面...

package main

import (
	"fmt"
	"strconv"
)

var tmp_ar [10]string

func auto1() [10]string {
	for i:=0;i<10;i++{
		tmp_ar[i] = strconv.Itoa(i*i)
	}
	return tmp_ar
}
func auto2()  {
	a := []int{1,2,3,4}
	println(len(a))
}
func main() {
	fmt.Println("Hello, World!")
	tmp_ar = auto1()
	println(len(tmp_ar))
	println(tmp_ar[9])
	auto2()
}

比如我的auto2函数，a是一个整数型数组，我并没有在int前面写[4]或者[...]也不会报错。而菜鸟教程里面的写法是需要加尺寸的

go 打印 bytes golang打印变量类型_go 打印 bytes

至于多维数组，其实对我而言在python中是比较常用的，我喜欢列表里面嵌套列表。golang也差不多，无非是前面多几个中括号，后面多几个花括号。

一个5*3的字符串数组例子:

func dwsz2()  {
	a := [][]string{
		{"1","2","3"},
		{"1","2","8"},
		{"1","2","4"},
		{"1","2","3"},
		{"1","2","3"},
	}
	println(len(a))
	println(a[2][2])
}

 一个2*4*3整数型数组的例子：

func dwsz3()  {
	b :=[][][]int{
		{
			{1,2,3},
			{1,2,3},
			{1,2,3},
			{1,2,3},
		},
		{
			{1,2,3},
			{1,8,3},
			{1,2,3},
			{1,2,3},
		},
	}
	println(b[1][1][1])

}

5.特殊的指针数组遍历:

正确写法:

func ts2()  {
	const max = 3
	number := [max]int{5, 6, 7}
	var ptrs [max]*int //指针数组
	//将number数组的值的地址赋给ptrs
	for i := range number {
		ptrs[i] = &number[i]
	}
	for i, x := range ptrs {
		fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d\n", i, *x, x)
	}

}

错误写法:

const max = 3

func main() {
    number := [max]int{5, 6, 7}
    var ptrs [max]*int //指针数组
    //将number数组的值的地址赋给ptrs
    for i, x := range &number {
        ptrs[i] = &x
    }
    for i, x := range ptrs {
        fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d\n", i, *x, x)
    }
}

延伸出来对循环for的补充:

func for2(){
	a := []int{8,6,4,3,5}
	for i,x:= range a{
		println(i,x)
	}
	for i:=range a{
		x:=a[i]
		println(i,x)
	}
}