当青训营遇上码上掘金
go语言结构
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头, 可以被外部代码使用(像面向对象语言中的 public), 如果以小写字母开头，则对包外是不可见的像面向对象语言中的 protected)
基础语法
在 Go 程序中，一行代表一个语句结束。
Printf实例
func main() {
// %d 表示整型数字，%s 表示字符串
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
fmt.Printf(url,stockcode,enddate)
}
// 输出:Code=123&endDate=2020-12-31
变量:
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字
var a string = "Runoob" // 声明一个变量
var b, c int = 1, 2 // 声明多个变量并赋值
没有初始化的变量会默认赋值: (0, false, "",nil)
以下几种为nil
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口
intVal := 1 相当于 var intValue = 1 //声明了一个新的变量并且赋值 注意: 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误, 但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值
可以将 var f string = "Runoob" 简写为 f := "Runoob"
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
func main(){
// 方法写在这里
}
go语言中的常量
// 定义的格式
const identifier [type] = value
- 显式类型定义： const b string = "abc"
- 隐式类型定义： const b = "abc"
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)
const (
a = iota // 0
b = iota // 1
c = iota // 2
)
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i) // 0 1 2 ha ha 100 100 7 8
if语句
相当于java来说没有了()
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else {
/* 在布尔表达式为 false 时执行 */
}
switch语句
匹配项后面也不需要再加 break
switch var1 {
case val1:
...
case val2:
...
default:
...
}
使用 fallthrough 会强制执行后面的 case 语句
switch {
case false:
fmt.Println("1、case 条件语句为 false")
fallthrough
case true:
fmt.Println("2、case 条件语句为 true")
fallthrough
case false:
fmt.Println("3、case 条件语句为 false")
fallthrough
case true:
fmt.Println("4、case 条件语句为 true")
case false:
fmt.Println("5、case 条件语句为 false")
fallthrough
default:
fmt.Println("6、默认 case")
}
/*
2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true
*/
循环语句
- For 循环有 3 种形式，只有其中的一种使用分号
for init; condition; post { }
for condition { }
for { }
- for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环
for key, value := range oldMap {
newMap[key] = value
}
// 理解:
- 循环嵌套
for [condition | ( init; condition; increment ) | Range]
{
for [condition | ( init; condition; increment ) | Range]
{
statement(s);
}
statement(s);
}
for i=2; i < 100; i++ {
for j=2; j <= (i/j); j++ {
if(i%j==0) {
break; // 如果发现因子，则不是素数
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素数\n", i);
}
}
break 经常用于中断当前 for 循环或跳出 switch 语句
continue 跳过当前循环的剩余语句，然后继续进行下一轮循环。
- 无线循环
func main() {
for true {
fmt.Printf("这是无限循环。\n");
}
}
函数
java中都没有函数, 都是定义在类中的方法
python中的def所定义的函数和go语言类似
func main(){
// 调用其他函数
} // 无参数, 无返回值类型
func max(num1, num2 int) int {
}
- 函数可以返回多个值(和python一样, 和java不同)
- 值传递和引用传递(一个相当于传递的是备份, 另一个传递的是指针)
func swap(x, y int) int {
var temp int
temp = x /* 保存 x 的值 */
x = y /* 将 y 值赋给 x */
y = temp /* 将 temp 值赋给 y*/
return temp;
}
func swap(x *int, y *int) {
var temp int
temp = *x /* 保持 x 地址上的值 */
*x = *y /* 将 y 值赋给 x */
*y = temp /* 将 temp 值赋给 y */
}
数组
- 声明
var variable_name [SIZE] variable_type
var balance [10] float32
- 初始化
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} // 快速初始化
//如果数组长度不确定，可以使用 ... 代替数组的长度
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小
- 索引赋值
// 将索引为 1 和 3 的元素初始化
balance3 := [5]float32{1:2.0,3:7.0}
for k = 0; k < 5; k++ {
fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
}
/*
balance3[0] = 0.000000
balance3[1] = 2.000000
balance3[2] = 0.000000
balance3[3] = 7.000000
balance3[4] = 0.000000
*/
指针
有**为内容值, 没表示地址
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
func main() {
var a int = 10
fmt.Printf("变量的地址: %x\n", &a )
}
// 变量的地址: 20818a220
好久没有使用指针了,回顾一下
var a int= 20 /* 声明实际变量 */
var ip *int /* 声明指针变量 */
ip = &a /* 指针变量的存储地址 */
fmt.Printf("a 变量的地址是: %x\n", &a )
/* 指针变量的存储地址 */
fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *ip )
结构体
变量类型在变量名后面
使用方法 变量名. 的形式
