0
点赞
收藏
分享

微信扫一扫

Head First Go - 第一部分语法基础

松鼠树屋 2022-04-30 阅读 120

文章目录


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(两个变量只赋值一个)一个变量赋值一个
fmt.Println(customerName) (删除使用变量的代码)所有声明的变量都必须使用,删除了也要把声明一起删除



11. 命名规则

Go有一套简单的规则,适用于变量、函数和类型的名称:

  • 名称必须以字母开头,并且可以有任意数量的额外的字母和数字
  • 如果变量、函数或者类型的名称以大写字母开头,则认为它是导出的,可以从当前包之外的包访问它。(这就是为什么fmt.Println中的P是大写的:这样它就可以在main包或者其他任何包中使用。)如果变量/函数/类型的名称是以小写字母开头的,则认为改名称是未导出的,只能在当前包使用。
合法的不合法的
length2stack(不能以数字开头)
stack2sales.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 类型会丢失小数点。





如有错误,欢迎指出!!!!

举报

相关推荐

0 条评论