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)

}

巴特西

go 学习之路（二）

一、文件名关键字标识符

二、go程序的基本结构

三、函数声明和注释

四、常量

五、变量

六、变量的作用域

七、数据类型、操作符

最新文章

热门文章

巴特西

go 学习之路（二）

一、文件名 关键字 标识符

二、go程序的基本结构

三、函数声明和注释

四、常量

五、变量

六、变量的作用域

七、数据类型、操作符

最新文章

热门文章

一、文件名关键字标识符