文章目录
1. 典型的Go文件布局
package main //package子句
import "fmt" //import部分
func main() {
fmt.Println("Hello, Go!") //实际代码
}
2. 调用函数
fmt.Println("Hello, Go!")
这个句子中,Println是函数名,括号内是接收的参数,可以有一个或者多个。当然了也可以使用 + 号,效果和 java 的一样。
2.1 Println函数
当需要查看程序在做什么的时候,就可以使用这个函数。可以在终端显示出来参数,每个参数之间使用空格分开,打印完之后跳到新的一行。( ln )
使用函数之前,先导入包,Println 要导入 fmt 包,并且使用 fmt.Println() 来调用。下面是导入 math 和 strings 包,就可以使用里面的函数了。并且和 java 也一样函数的返回值可以直接传递输出。
package main
import (
"fmt"
"math"
"strings"
)
func main() {
fmt.Println(math.Floor(2.75)) //向下取整
fmt.Println(strings.Title("head first go")) //转化大写
}
3. 字符串
我们将字符串作为参数传递给Println,双引号之间的文本,Go把它们视为字符串。
转义序列 | 值 |
---|---|
\n | 换行符 |
\t | 制表符 |
\" | 双引号 |
\\ | 反斜杠 |
package main
import (
"fmt"
)
func main() {
fmt.Println("Hello, \nGo!")
fmt.Println("Hello, \tGo!")
fmt.Println("Quotes: \"\"")
fmt.Println("Backslash: \\")
/**
Hello,
Go!
Hello, Go!
Quotes: ""
Backslash: \
*/
}
4. 符文
Go的符文(runc)通常用于表示单个字符。使用 (')包围。Go使用 Unicode 标准来存储 rune,rune被保存为数字代码,而不是字符本身,Go程序几乎可以表示地球上任何语言的任何字符。
package main
import (
"fmt"
)
func main() {
fmt.Println('a'); //97
fmt.Println('广'); //24191
fmt.Println('\t'); //9
}
5. 布尔值
true 或者 false,和 java 的判断语句一样。
package main
import (
"fmt"
)
func main() {
fmt.Println(1 == 2); //false
fmt.Println(2 + 2 == 5); //false
fmt.Println(4 <= 6); //true
}
6. 数字
和 java 的输入一样的,运算也是。
package main
import (
"fmt"
)
func main() {
fmt.Println(1+2); //3
fmt.Println(5.4-2.2); //3.2
fmt.Println(3*4); //12
fmt.Println(7.5/5); //1.5
}
7. 类型
下面通过一个例子引出:
package main
import (
"fmt"
"math"
"strings"
)
func main() {
fmt.Println(math.Floor("Head first go"))
fmt.Println(strings.Title(2.72))
}
math.Floor接收一个字符串类型的数据或者strings.Title 接收一个数字类型的会爆错。Go是静态类型的,如果在错误的位置使用了错误的类型,Go就会报错。
我们可以通过把值传给 reflect 包的 TypeOf 函数,来查看它们的类型。
package main
import (
"fmt"
"reflect"
)
func main() {
fmt.Println(reflect.TypeOf(42)) //int
fmt.Println(reflect.TypeOf(3.1415)) //float64, float64是因为要用64位的数据来保存数字,这意味者在四舍五入之前可以达到很精确的程度
fmt.Println(reflect.TypeOf(true)) //bool
fmt.Println(reflect.TypeOf("Hello GO")) //string
}
8. 声明变量
声明变量的格式:var 变量名 类型(可省略) = 值
不省略类型
package main
import (
"fmt"
)
func main() {
var a1 int = 4
var length, width float64 = 1.2, 1.3 //一次性赋值多个
var custName string = "Hello Go"
fmt.Printf("a1: %v\n", a1)
fmt.Printf("length: %v\n", length)
fmt.Printf("width: %v\n", width)
fmt.Printf("custName: %v\n", custName)
/*
a1: 4
length: 1.2
width: 1.3
custName: Hello Go
*/
}
省略类型:
package main
import (
"fmt"
)
func main() {
var a1 = 4
var length, width = 1.2, 1.3
var custName = "Hello Go"
fmt.Printf("a1: %v\n", a1)
fmt.Printf("length: %v\n", length)
fmt.Printf("width: %v\n", width)
fmt.Printf("custName: %v\n", custName)
/*
a1: 4
length: 1.2
width: 1.3
custName: Hello Go
*/
}
先声明变量然后赋值
package main
import (
"fmt"
)
func main() {
var a1 int
var a2 string
var a3 float32
a1 = 1
a2 = "aaa"
a3 = 3.13
fmt.Printf("a1: %v\n", a1) //1
fmt.Printf("a2: %v\n", a2) //aaa
fmt.Printf("a3: %v\n", a3) //3.13
}
9. 零值
package main
import (
"fmt"
)
func main() {
var myInt int
var myFloat float64
var myString string
var myBool bool
fmt.Printf("myInt: %v\n", myInt) //myInt: 0 0
fmt.Printf("myFloat: %v\n", myFloat) //myFloat: 0 0
fmt.Printf("myString: %v\n", myString) //myString: 空串
fmt.Printf("myBool: %v\n", myBool) //myBool: false false
}
10. 短变量声明
如果是声明变量的时候知道了初值是多少,那么就可以使用短变量声明
package main
import (
"fmt"
)
func main() {
a1 := 4
a2, a3 := 1.2, 1.3
a4 := "aaa"
fmt.Printf("a1: %v\n", a1) //4
fmt.Printf("a2: %v\n", a2) //1.2
fmt.Printf("a3: %v\n", a3) //1.3
fmt.Printf("a4: %v\n", a4) //aaa
}
不需要明确声明变量的类型,赋值给变量的值就是变量的类型。
失败情况 | 原因 |
---|---|
a1 := 4 a1:=4(同一个变量添加第二个声明) | 一个变量只能声明一次(只要位于不同作用域) |
quantity = 4 (从一个短变量声明中删除) | 这个是赋值语句,前面要先声明 |
quantity := 4 quantity = “a” (将字符串赋值给int变量) | 只能给变量赋相同类型的值 |
length, width := 1.2(两个变量只赋值一个) | 一个变量赋值一个 |
所有声明的变量都必须使用,删除了也要把声明一起删除 |
11. 命名规则
Go有一套简单的规则,适用于变量、函数和类型的名称:
- 名称必须以字母开头,并且可以有任意数量的额外的字母和数字
- 如果变量、函数或者类型的名称以大写字母开头,则认为它是导出的,可以从当前包之外的包访问它。(这就是为什么fmt.Println中的P是大写的:这样它就可以在main包或者其他任何包中使用。)如果变量/函数/类型的名称是以小写字母开头的,则认为改名称是未导出的,只能在当前包使用。
合法的 | 不合法的 |
---|---|
length | 2stack(不能以数字开头) |
stack2 | sales.total(不能访问其他包中的任何内容,除非它们的名称的首字母大写) |
sales.Total |
这些是该语言强制执行的唯一规则,但是Go社区还有一些额外的约定。
- 如果一个名称由多个单词组成,那么第一个单词之后的每个单词都应该首字母大写,并且它们应该连接在一起,中间没有空格,这点和java一样。驼峰命名法。
- 当名称的含义在上下文中很明显,Go社区的惯例是缩写,使用 i 代表index,max代表maximum等等
只有名称是以大写字母开头的变量、函数或者类型才被认为是可以导出的:可以从当前包之外的包访问
12. 转换
Go中的数学运算符和比较运算符要求包含相同的类型,否则报错
可以使用括号强制转换
package main
import (
"fmt"
)
func main() {
var length float64 = 1.2
var width int = 2
fmt.Println("length * float64(width): %v", length * float64(width)) //length * float64(width): %v 2.4
fmt.Println("width > length: %v", width > int(length)) //width > length: %v true
fmt.Println(width > int(length)) //true
}
我们可以看看输出的类型
package main
import (
"fmt"
"reflect"
)
func main() {
//var length float64 = 1.2
var width int = 2
fmt.Println(reflect.TypeOf(width)); //int
fmt.Println(reflect.TypeOf(float64(width))); //float64
}
在进行转换的时候,注意 float 转化成 int 类型会丢失小数点。
如有错误,欢迎指出!!!!