go 学习之路（二）
一、文件名 关键字 标识符
- 所有go源码都以.go结尾
- 标识符以字母或下划线开头，大小写敏感
a.boy b.Boy c.a+b d.0boy e._boy f.=_boy g._
以上变量c、d、f的命名是不正确的
_是特殊标识符，用来忽略结果
3.一些go保留的关键字
二、go程序的基本结构
- 任何一个文件都隶属于一个包
- 引入包
import (
"fmt"
"os"
)
3.go可执行文件 package main，有且仅有一个入口函数main
4.包中函数调用
同一个包中函数，直接调用
不同包中函数，通过包名+.+函数名调用
5.包访问控制规则
大写意味着这个函数/变量是可导出的
example1：
给定一个数N,求所有两两相加等于N的组合
例如n=5
0+5=5
1+4=5
2+3=5
3+2=5
4+1=5
5+0=5
package main
import (
"fmt"
)
func sum(n int) {
for i := 0; i <= n; i++ {
fmt.Printf("%d+%d=%d\n", i, n-i, n)
}
}
func main() {
sum(10)
}
example2：
一个程序包含两个包add、main，其中add包中有两变量Name，age，main包中如何访问Name，age？
add包中add.go
package add var Name string = "tony" var age int = 10
main包中main.go
package main
import (
"fmt"
"go_dev/day2_practice/example2/add"
)
func main() {
fmt.Println("Name=", add.Name)
fmt.Println("age=", add.age)
}
这样执行是报错的，因为add.go中的age变量小写，私有，别的包中不能引用
example3：引用包的时候名字太长，用别名
package main
import (
"fmt"
a "go_dev/day2_practice/example2/add"
)
func main() {
fmt.Println("Name=", a.Name)
}
example4：init函数，自动被go运行框架调用
执行顺序：
初始化全局变量-->init函数-->main函数
三、函数声明和注释
函数声明：func 函数名 （参数列表） （返回值列表） { }
注释：//单行注释 /* */多行注释
example5：计算两个数的和
package main
import (
"fmt"
)
func add(a int, b int) int {
result := a + b
return result
}
func main() {
result := add(100, 200)
fmt.Println("sum=", result)
}
四、常量
常量使用const修饰，代表只读，不能修改
const只能修饰bool，number，string
语法: const identifier [type] = value,其中type可以省略
定义常量优雅的写法
const(
a = 0
b = 1
c = 2
)
const(
a = iota
b //1
c //2
)
example6:
定义两常量Female=2，Man=1，获取当前时间的秒数，如果能被female整除，打印female，否则man
五、变量
语法 var identifier type
var a int var b string var c string = "hello world"
var(
a int //默认0
b string //默认空
c bool //默认false
)
变量值引用类型和引用类型
值类型：变量直接存储值，内存通常在栈中分配
引用类型：变量存储的是一个地址，这个地址存储最终的值。内存通常在堆上分配，GC回收
package main
import "fmt"
func swap(a int, b int) {
tmp := b
b = a
a = tmp
return
}
func main() {
first := 4
second := 3
swap(first, second)
fmt.Println("first=", first)
fmt.Println("second=", second)
}
运行输出first=4，second=3。执行到swap(first,second)时，把first和second复制一份进去，不影响main里面的first，second
example7：交换两个整数的值，a=3,b=4，交换后，a=4,b=3
package main
import "fmt"
func swap(a *int, b *int) {
//交换地址指向的值
tmp := *b
*b = *a
*a = tmp
return
}
func main() {
first := 4
second := 3
swap(&first, &second) //传两个值的地址
fmt.Println("first=", first)
fmt.Println("second=", second)
}
另一种方法，不用修改a,b地址指向的值
package main
import (
"fmt"
)
func swap(a int, b int) (int, int) {
return b, a
}
func main() {
first := 4
second := 3
first, second = swap(first, second)
fmt.Println("first=", first)
fmt.Println("second=", second)
}
六、变量的作用域
在函数内部声明的变量叫局部变量，生命周期仅限于函数内部
在函数外部声明的变量叫全局变量，生命周期作用于整个包，如果是大写，作用于整个程序
package main
import (
"fmt"
)
var a = "G"
func main() {
n()
m()
n()
}
func n() {
fmt.Println(a)
}
func m() {
a := "O" //函数内部重新定义a变量并赋值
fmt.Println(a)
}
上面的例子输出GOG
package main
import (
"fmt"
)
var a = "G"
func main() {
n()
m()
n()
}
func n() {
fmt.Println(a)
}
func m() {
a = "O" //对全局变量a重新赋值
fmt.Println(a)
}
上面的例子输出GOO
package main
import (
"fmt"
)
var a string
func main() {
a = "G"
fmt.Println(a)
f1()
}
func f1() {
a := "O"
fmt.Println(a)
f2()
}
func f2() {
fmt.Println(a)
}
输出GOG
七、数据类型、操作符
1、逻辑操作符：==、！=、< 、>
package main
import (
"fmt"
)
func main() {
a := 10
if a > 5 {
fmt.Println(a)
}
}
2、数学操作符：+、-、*、/等
package main
import (
"fmt"
)
func main() {
a := 10
b := a + 10
fmt.Println("b=", b)
}
example：使用math/rand生成10个随机整数，10个小于100的随机整数以及10个随机浮点数
package main
import (
"fmt"
"math/rand"
"time"
)
func init() {
rand.Seed(time.Now().Unix())
}
func main() {
for i := 0; i < 10; i++ {
fmt.Println(rand.Int())
}
for i := 0; i < 10; i++ {
fmt.Println(rand.Intn(100))
}
for i := 0; i < 10; i++ {
fmt.Println(rand.Float32())
}
}
字符类型：var a byte
字符串类型：var str string
字符串的两种表示方式：
（一）双引号 （二）反引号
package main
import (
"fmt"
)
func main() {
var str string = "hello world"
var str1 string = `
床前明月光
疑是地上霜`
fmt.Println(str)
fmt.Println(str1)
}
字符串常见操作(切片，反转，拼接)
package main
import (
"fmt"
)
func reverse(str string) string {
var result string
strLen := len(str)
for i := 0; i < strLen; i++ {
result = result + fmt.Sprintf("%c", str[strLen-i-1])
}
return result
}
func main() {
str1 := "hello"
str2 := "world"
// str3 := str1 + " " + str2 字符串拼接
str3 := fmt.Sprintf("%s %s", str1, str2) //字符串拼接
fmt.Println("str3=", str3)
n := len(str3) //长度
fmt.Println("len(str3)=", n)
str4 := str3[0:5] // 切片
fmt.Println("str4=", str4)
str4 = str3[6:]
fmt.Println("str4=", str4)
result := reverse(str3) //字符串反转
fmt.Println("reverse=", result)
}
练习：
1、判断101-200之间有多少个素数，并输出所有素数
package main
import (
"fmt"
)
func main() {
var len int
for i := 101; i < 200; i++ {
var flag bool = true
for j := 2; j < i; j++ {
if i%j == 0 {
flag = false
}
}
if flag {
len += 1
fmt.Println(i)
}
}
fmt.Println("素数个数", len)
}
2、打印出100-999中所有的水仙花数（一个三位数，其各位数字立方和等于该数本身）
package main
import (
"fmt"
)
func isNumber(n int) bool {
var i, j, k int
i = n % 10
j = (n / 10) % 10
k = (n / 100) % 100
sum := i*i*i + j*j*j + k*k*k
return sum == n
}
func main() {
var n int
fmt.Scanf("%d", &n)
if isNumber(n) == true {
fmt.Println(n, "is shuixianhua")
} else {
fmt.Println(n, "is not shuixianhua")
}
}
3、对于一个数n，求n的阶乘之和
package main
import (
"fmt"
)
func sum(n int) uint64 {
var s uint64 = 1
var sum uint64
for i := 1; i <= n; i++ {
s = s * uint64(i)//前一个数的阶乘*当前数
sum += s
}
return sum
}
func main() {
var n int
fmt.Scanf("%d", &n)
s := sum(n)
fmt.Println(s)
}
