go 基础语法

 变量

// 变量定义
// 方式一   先定义， 在赋值
var value string
value = "dddd"
fmt.Printf("value is :%s\n", value)

// 方式二  定义直接复制
var value2 string = "heihei"
fmt.Printf("value2:%s\n", value2)

// 方式三  定义直接赋值，使用自动推导 :=    主推这种
value3 := "ddd"
fmt.Printf("value3: %s\n", value3)

// 变量引用
test(value3, 110)

// 平行赋值
i, j := "this is i", "this is j"
fmt.Printf("i: %s, j: %s\n", i, j)

// 交叉赋值
i, j = j, i
fmt.Printf("i: %s, j: %s\n", i, j)

d := 10
fmt.Println("d: ", d)

 

基础数据类型

/*
	基础数据类型:

	int8 int16 int32 int64

	unit8 ... unit64

	float32  float64

	true/false
*/

 

自增语法

// 自增语法
// 只有：i++ 或 i-- 其他的--i， ++i都没有
// PS 自增语法必须单独一行，否则语法报错
ii := 20
// ii++
fmt.Printf("ii: %d\n", ii)

 

go 指针/* go 指针：

	/*
		go 指针：
		结构体成员调用时： c中 P->name,    go中 P.name
		go使用指针时会自动调用内部的垃圾回收机制（gc: garbage collector），开发人员不需要手动释放内存
		c语言不允许返回栈上指针，go语言可以返回栈上指针，程序会在编译的时候确定变量的分配位置
		编译的时候，如果发现有必要的话，就将变量分配到堆上
	*/
	// 定义指针方式一
	name := "liming"
	prt := &name
	fmt.Printf("指针变量： %s\n", *prt)
	fmt.Println("指针地址：", &name)

	// 定义指针方式二
	name2prt := new(string)
	*name2prt = "xiaohua"
	fmt.Println("name2:", *name2prt)
	fmt.Println("name2prt:", name2prt)

	// 可以返回栈上指针，编译器在编译时，会自动判断这段代码，将city变量分配在堆上
	resp := test_city()
	fmt.Println("city: ", *resp, "address: ", resp)

	// 空指针， c 中 null ， go 中 nil
	// 判断空指针，if 两端不用加()，即使有一行代码，也必须使用{}
	if resp == nil {
		fmt.Println("resp 是空指针")
	} else {
		fmt.Println("resp 是非空指针")
	}


// 定义一个返回sting指针的函数， go返回值写在参数 后面
func test_city() *string {
	city := "成都"
	prt := &city
	return prt
}

 

字符串

// 字符串
// 1、原生输出(使用反引号 `` )
str := `
usage: 
	-a    this is all
	-h    this is help
	-v    version
`
fmt.Println("name str: ", str)

// 长度， len()
l1 := len(str)
fmt.Println("l1: ", l1)

// for 不需要加（）
names := "limiang"
for i := 0; i < len(names); i++ {
	fmt.Printf("i: %d,  v: %c\n", i, names[i])
}

// 字符串拼接
str1 := "ddd"
str2 := "ooo"
fmt.Println("str1 + str2 = ", str1+str2)

 

不支持语法

// 不支持的语法
/*
	1、自增自减： ++i， --i
	2、不支持地址加减
	3、不支持三目运算符 ？：（如：x:= 10 > 12 ? 10 : 12）
	4、只有false才能逻辑假， nil 和 0 都不能
*/

 

权限

/*
访问权限：

1、在go中访问权限是通过首字母大写来控制的
2、import ===> 如果包名不同， 只有首字母大写的才是public的
3、对于结构体（类）中的方法、属性，只有首字母大写才能在其他包中引用
*/

 

结构体（类）

package main

import (
	"fmt"
)

/*
继承--操作
*/

// 被继承的结构体（父类）
type Human struct {
	name   string
	age    int
	gender string
}

// 继承结构体（子类）
type Teacher struct {
	Human   // 直接写为继承，  hum: Human --> 包含hum变量，此时为类的嵌套
	subject string
}

func main() {
	// 实例化时指定参数
	t := Teacher{
		Human: Human{
			name:   "笑话",
			age:    5,
			gender: "dog",
		},
		subject: "旺旺",
	}
	fmt.Println("t: ", t)
	fmt.Println("t: ", t.Human.name)
	t.age = 3 // 相同的属性， 子类会覆盖父类
	fmt.Println("t: ", t.Human.age)

	t2 := Teacher{}
	t2.name = "limin"
	t2.age = 16
	t2.gender = "女"
	t2.subject = "数学"
	fmt.Println("t2 : ", t2)
	fmt.Println("t2.Hume.age", t2.Human.age)
}

打印结果：