go 学习之路（二）

一、文件名 关键字 标识符

1. 所有go源码都以.go结尾
2. 标识符以字母或下划线开头，大小写敏感

a.boy  b.Boy c.a+b d.0boy 

e._boy f.=_boy g._

　　以上变量c、d、f的命名是不正确的

　　_是特殊标识符，用来忽略结果

　　3.一些go保留的关键字

二、go程序的基本结构

1. 任何一个文件都隶属于一个包
2. 引入包

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)
}