1.变量的赋值
package main
//引入包
import "fmt"
//包内变量赋值(不能使用 :=)
var (
a = 1
b = true
c = "我是你爸爸"
)
//变量赋值的方法(规定类型)
func aaa() {
//可以规定类型
var a, b, c int = 1, 2, 3
fmt.Println(a, b, c)
}
//变量赋值的方法(不规定类型)
func bbb() {
//可以不规定类型
var d, e, f = 1, true, "我是你爷"
fmt.Println(d, e, f)
}
//变量赋值的方法(简单,推荐) var 等价于 :=
func ccc() {
//首次变量定义
j, h, k := 2, true, "我是你奶奶"
//其他变量赋值
j = 12121212
fmt.Println(j, h, k)
}
func main() {
fmt.Print("hello, world\n")
aaa()
bbb()
ccc()
}
//Println和Print基本类似,但是Println可以换行,Print不会换行
结果展示:
2.常量与枚举
package main
import "fmt"
//常量也可以定义在外面
const (
d, e, f = 4, 5, 6
)
//常量的定义
func chang() {
const (
a, b, c = 111, 2222, 33333
)
g := a * d
fmt.Println(a, b, c, g)
}
func main() {
chang()
//枚举iota
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
j //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
k //100 iota +=1
h = iota //9,恢复计数
_ //10
_ //11
i //12
)
// 1 << (10 * iota)中 ,iota是枚举类型的自增型,0,1,2,3,4....
// << 则代表1的二进制转化后,向左面移动(10 * iota)位,剩余数位用0补全(相当于直接后面补了(10 * iota)个0)
// 最后再转化成10进制的值
const (
aa = 1 << (10 * iota)
bb
cc
dd
ee
ff
)
fmt.Println(a, b, c, d, e, j, f, g, k, h, i)
fmt.Println(aa, bb, cc, dd, ee, ff)
}
结果展示:
3.条件语句
package main
import (
"fmt"
"io/ioutil"
)
//在函数中的判断
func ffff(v int) int {
if v >= 100 {
return 100
} else if v >= 200 {
return 200
} else {
return v
}
}
func bbbb(number int) string {
g := ""
switch {
case number == 1:
g = "A"
case number == 2:
g = "B"
case number == 3:
g = "C"
default:
return "我不知道了"
}
return g
}
func cccc(number int) string {
switch number {
case 1, 0:
return "AA"
case 2, 3:
return "BB"
case 4, 5:
case 7, 8:
return "CC"
default:
return "我不会了"
}
return "结局了!!"
}
func main() {
fmt.Println(ffff(90))
// 查找文件并读取111.txt
const name = "111.txt"
// ioutil.ReadFile返回的参数有两个,即:内容和错误信息
content, err := ioutil.ReadFile(name)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s\n", content)
}
//这样的写法中,content是不能在外部调用的,他的生命周期只有在if中
if content, err := ioutil.ReadFile(name); err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s\n", content)
}
fmt.Println(bbbb(651561))
fmt.Println(cccc(4))
fmt.Println(cccc(7))
}
结果展示:
4.循环
package main
import (
"fmt"
"os"
"strconv"
)
//二进制的转化
func er(num int) string {
res := ""
//没有起始条件,但是";"需要写
for ; num > 0; num /= 2 {
lsb := num % 2
//转化为string
res = strconv.Itoa(lsb) + res
}
return res
}
//每句读文件爱你
func file(name string) {
file, err := os.Open(name)
if err != nil {
//打断并报错
panic(err)
}
for {
fmt.Println(1111)
}
fmt.Printf("%s\n", file)
}
func main() {
// a := 0
// for i := 0; i < 5; i++ {
// fmt.Println(i)
// }
// for a < 5 {
// fmt.Println(a)
// a++
// }
fmt.Println(
er(5),
)
file("11.txt")
}
结果展示:
5.函数
package main
import (
"fmt"
)
//函数的表达式
func aaa(a, b int, p string) int {
switch p {
case "+":
return a + b
case "-":
return a - b
case "*":
return a * b
case "/":
//调用其他的函数,'_'表示不需要的参数
c, _ := ccc(a, b)
return c
default:
panic("我错了,我传的是:" + p)
}
}
//返回两个参数
func eee(a, b int, op string) (int, error) {
switch op {
case "+":
return a + b, nil
case "-":
return a - b, nil
case "*":
return a * b, nil
case "/":
return a / b, nil
default:
return 0,
fmt.Errorf("你错了吧: %s", op)
}
}
//函数传递两个数值
func bbb(a, b int) (int, int) {
return a / b, a % b
}
//函数输出数值定义
func ccc(a, b int) (c, d int) {
c = a / b
d = a % b
return c, d
}
func ppp(a, b int) int {
return a * b
}
//函数作为参数,调用一个返回值
func ddd(op func(int, int) int, a, b int) int {
return op(a, b)
}
//函数作为参数,调用两个返回值
func aa(op func(a, b int, op string) (int, error), c, d int, pp string) (int, error) {
return op(c, d, pp)
}
func main() {
fmt.Println(aaa(12, 2, "*"))
fmt.Println(bbb(13, 3))
c, d := ccc(13, 3)
fmt.Println(c, d)
fmt.Println(aaa(12, 2, "/"))
fmt.Println(eee(12, 2, "@"))
// 外部判断
if reulet, err := eee(12, 2, "@"); err != nil {
fmt.Println("错误:", err)
} else {
fmt.Println(reulet)
}
//调用函数
fmt.Println(ddd(ppp, 3, 4))
fmt.Println(aa(eee, 13, 4, "*"))
}
结果展示:
6.指针
指针的定义指针就是一个存放地址的变量
当指针指向某个变量
这时这个指针里就存放了那个变量的地址
同时可以利用指针直接取变量中的值用 只要在指针前加 * 就是取其
真值了(也就是被指向的变量的值)
举个例子
int i=0,*p;
声明了一个 int 类型的 变量i和指针p
假设i在内存中所存在的地址为aaaaa(随便写的)
p->i 就是使指针p指向i
也就是说 指针p中存放了aaaaa这个地址
当你操作这个p时就是直接操作了aaaaa这个地址中存放的东西
间接操作了变量i,
这就是指针的作用
package main
import (
"fmt"
)
//一般交换
func aaa(a, b int) (int, int) {
return b, a
}
//利用指针交换
func bbb(a, b *int) {
*a, *b = *b, *a
}
//增加
func add(a *int) int {
*a = *a + 1
return *a
}
func main() {
a := 2
//定义指针b=指针a, fmt.Println(&a) == fmt.Println(b)
//&是可以把具体的值转化为指针
//*可以把指针转化对应的值
var b *int = &a
*b = 3
fmt.Println(*b)
fmt.Println(a)
fmt.Println(add(&a))
//a的 结果是3
// fmt.Println(a)
// fmt.Println(aaa(3, 6))
// //先转换
// c := 4
// d := 6
// bbb(&c, &d)
// //再输出
// fmt.Println(c, d)
}
结果展示:
