0
点赞
收藏
分享

微信扫一扫

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

松鼠树屋 2022-04-30 阅读 121
golang开发语言后端

文章目录

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 类型会丢失小数点。





如有错误，欢迎指出！！！！

举报

相关推荐

第一部分：Java基础编程-Java基本语法

java开发语言

AWS Lambda - 第一部分

awsaws认证saplambda

Promise 重写 （第一部分）

前端javascriptvue.js原力计划

垃圾回收算法（第一部分）

算法java面试

R语言：第一部分 入门

R数据数组数据集编程语言

JavaScript对象类型第一部分

字符串添加属性构造函数JavaScript对象类型前端开发

Java第一部分学习总结

java开发语言后端

spring5-第一部分

intellij-ideajavaspring

类和对象（中）----第一部分

c++开发语言后端c语言

javascript复习资料第一部分

javascript前端
0 条评论