1.语言函数
1.定义函数
func max(num1, num2 int) int {
/* 声明局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}
定义函数用func 接下来函数名 定义变量 数据类型 (输出数据类型,输出数据的必要条件);
定义的函数也可以同时输出两个数据,例如(string,string)或(int,int);
函数传递时有值传递和引用传递,前者是将值复制一份代入函数,对值没有一影响;
后者是通过&a,&b即用指针将值的地址传到函数中,在函数中对值的修改将不再局限于函数。
2.闭包与方法
可以做到变量常驻内存但是不会污染全局。
闭包就是定义的匿名函数中返回一个函数,使定义的变量会绑定函数。
方法就是包含了接收者的函数。
这个接受体是一个自定义类型,但是不能是基础类型例如int。
package main
import (
"fmt"
)
/* 定义结构体 */
type Circle struct {
radius float64
}
func main() {
var c1 Circle
c1.radius = 10.00
fmt.Println("圆的面积 = ", c1.getArea())
}
//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
//c.radius 即为 Circle 类型对象中的属性
return 3.14 * c.radius * c.radius
}
2.GO语言变量作用域
1.在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,参数和返回值变量也是局部变量。
2.在函数体外声明的变量称之为全局变量,全局变量可以在整个包甚至外部包(被导出后)使用。
3.Go 语言程序中全局变量与局部变量名称可以相同,但是函数内的局部变量会被优先考虑
3.数组
1.定义数组
var variable_name [SIZE] variable_type
即: 定义 数组名 [长度] 数组数据类型
对于不确定长度的数组,可以用...代替数组的长度
2.二维数组
对于二维数组就是 name:= [2][3] int{}
也就是创造一个二行三列的表格,[ ]中的数字代表的是行或列的长度
a := [3][4]int{ {0, 1, 2, 3} , /* 第一行索引为 0 */ {4, 5, 6, 7} , /* 第二行索引为 1 */ {8, 9, 10, 11}, /* 第三行索引为 2 */ }
4.Go语言指针
1. 指针引用前需要声明,声明格式如下:
var var_name *var-type
即 :var 名字 *数据类型
使用指针
1)定义 2)赋值 3)使用
package main
import "fmt"
func main() {
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 )
}
2.Go空指针
空指针 名为nil,也就是说未赋值的指针地址为0,可以用来条件判断,if(name==nil)即表示当指针为空指针的情况。
3. 指针数组
指针数组 var zzsz [number] *int
则可创造一个指针数组,zzsz[0]即代表该数组中的第一个值
4.指向指针的指针
指针储存的是变量的地址,指向指针的指针即储存该地址的地址:
定义 : var ptr**int
5.go语言指针作为函数的参数
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int= 200
fmt.Printf("交换前 a 的值 : %d\n", a )
fmt.Printf("交换前 b 的值 : %d\n", b )
/* 调用函数用于交换值
* &a 指向 a 变量的地址
* &b 指向 b 变量的地址
*/
swap(&a, &b);
fmt.Printf("交换后 a 的值 : %d\n", a )
fmt.Printf("交换后 b 的值 : %d\n", b )
}
func swap(x *int, y *int) {
var temp int
temp = *x /* 保存 x 地址的值 */
*x = *y /* 将 y 赋值给 x */
*y = temp /* 将 temp 赋值给 y */
}
作用:可以利用函数改变变量的值并且影响到函数外的变量。
5.Go语言结构体
结构体就是包含了不同类型的结合,不局限于一种类型中。
定义 : type name struct{
变量1 数据类型
变量2 数据类型
}
如果要访问结构体成员
结构体.成员名
结构体函数参数
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* 声明 Book1 为 Books 类型 */
var Book2 Books /* 声明 Book2 为 Books 类型 */
/* book 1 描述 */
Book1.title = "Go 语言"
Book1.author = "www.runoob.com"
Book1.subject = "Go 语言教程"
Book1.book_id = 6495407
/* book 2 描述 */
Book2.title = "Python 教程"
Book2.author = "www.runoob.com"
Book2.subject = "Python 语言教程"
Book2.book_id = 6495700
/* 打印 Book1 信息 */
printBook(Book1)
/* 打印 Book2 信息 */
printBook(Book2)
}
func printBook( book Books ) {
fmt.Printf( "Book title : %s\n", book.title)
fmt.Printf( "Book author : %s\n", book.author)
fmt.Printf( "Book subject : %s\n", book.subject)
fmt.Printf( "Book book_id : %d\n", book.book_id)
}
!!!结构体指针!!!
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* 声明 Book1 为 Books 类型 */
var Book2 Books /* 声明 Book2 为 Books 类型 */
/* book 1 描述 */
Book1.title = "Go 语言"
Book1.author = "www.runoob.com"
Book1.subject = "Go 语言教程"
Book1.book_id = 6495407
/* book 2 描述 */
Book2.title = "Python 教程"
Book2.author = "www.runoob.com"
Book2.subject = "Python 语言教程"
Book2.book_id = 6495700
/* 打印 Book1 信息 */
printBook(&Book1)
/* 打印 Book2 信息 */
printBook(&Book2)
}
func printBook( book *Books ) {
fmt.Printf( "Book title : %s\n", book.title)
fmt.Printf( "Book author : %s\n", book.author)
fmt.Printf( "Book subject : %s\n", book.subject)
fmt.Printf( "Book book_id : %d\n", book.book_id)
}