基本语法规则
- 在go语言中,语句末尾的分号;是可以省略的
- 在go语言中,代码片段的起始花括号{不能换行,否则程序报错。
- bool类型不能和其他类型运算 ,整型也不能强行转为bool, bool 初始值是 false
基本语法
基本数据类型
类型 长度(字节) 说明
bool 1 true, false。 不能把非零值当做true
byte 1 uint8 别名
rune 4 int32 别名。代表一个Unicode字符
int/uint 4 依据所运行的平台,可能是32bit或64bit。
int8/uint8 1 1-128 ~ 127; 0 ~ 255
int16/uint16 2 -32768 ~ 32767; 0 ~ 65535
int32/uint32 4 -21亿 ~ 21亿;0 ~ 42亿
complex64 8 复数类型,即32位实数+32位虚数
complex128 16 复数类型,即64位实数+64位虚数
uintptr 能够保存指针的32位或64位整数
array 数组,值类型,如:[2]int
struct 结构体,值类型
string 值类型
slice 引用类型,如:[]int
map 引用类型
channel 引用类型
Interface 接口类型
function 函数类型
查看变量类型(typeof)
package main // 声明 main 包
import (
"fmt" // 导入 fmt 包,打印字符串是需要用到
)
var name string = "jjj"
func main() { // 声明 main 主函数
fmt.Println(typeof(name))
}
func typeof(v interface{}) string {
return fmt.Sprintf("%T", v)
}
声明变量
- 变量声明了,必须使用
- 常量必须赋初值
package main
import "fmt"
// int 可以表示 负数 ; uint 不能表示负数
// float32 float64 表示浮点型
func main() {
var number1 int=123
var str1 string = "123"
var isTrue bool =false
var float1 float32=1.2
// 基本数据类型可以自动推导
var number=18
var str=19
var bool1=false
// 短变量声明 只能声明局部变量
number2 := 156
number3,str3 := 999,"kkk"
const NUM="cONST"
fmt.Println("hello word---",float1,NUM,number,str,bool1,number1,str1,isTrue,number2,number3,str3)
}
switch
- go里面switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case,而是跳出整个switch,但是可以使用fallthrough强制执行后面的case代码,fallthrough相当于去掉了case后面默认的break。
func main(){
i := 5
switch i{
case 1:
fmt.Println("i is equal to 1")
case 2:
fmt.Println("i is equal to 2")
case 3,4,5,6:
fmt.Println("i is equal to 3,4,5 or 6")
fallthrough
default:
fmt.Println("others")
}
}
for
func main(){
str := "Chain"
for i, j := 0, len(str); i < j; i++{
fmt.Println(string(str[i]))
}}
函数
package main
import "fmt"
func main(){
quotient, remainder := divide(5, 3)
fmt.Println("商为:", quotient, "余数为:", remainder)
result := sum(3,5,7,9)
fmt.Println("结果为:", result)
}
// 定义一个多返回值函数
func divide(a, b int)(int, int){
quotient := a / b
remainder := a % b
return quotient, remainder
}
// 不定参数
func sum(aregs ...int) int {
s := 0
fmt.Println("aregs为:", aregs) //aregs为: [3 5 7 9]
for _, number := range aregs{
s += number
}
return s
}
数组
- 值类型
package main
import (
"fmt"
)
func main(){
var a = [5]int{1,2,3,4,5}
e := a
e[2] = 10
fmt.Printf("a:%v\n", a) // a:[1 2 3 4 5]
fmt.Printf("e:%v\n", e) // e:[1 2 10 4 5]
//下标遍历数组
for i := 0; i < len(a); i++{
fmt.Printf("a[%d] = %d\n", i, a[i])
}
fmt.Println("")
// range关键字遍历
for i, v := range a{
fmt.Printf("a[%d] = %d\n", i, v)
}
}
slice(数组的扩展–切片)
- 引用类型
package main
import "fmt"
// 引用类型
func main(){
s1 := []int{1,2,3,4,5}
s2 := s1
s2[2] = 10
fmt.Println("s1: ", s1) // s1: [1 2 10 4 5]
fmt.Println("s2: ", s2) // s2: [1 2 10 4 5]
}
相关方法
package main
import "fmt"
func main() {
slice1:=[]int{1,2,3}
// 遍历
for _,val := range slice1 {
fmt.Println(val)
}
// 获取一部分
slice2 :=slice1[1:2]
// 添加
// append 也可以合并切片
slice1=append(slice1,4,5) // 末尾添加
// 复制
slice3:=make([]int,len(slice1),20)
copy(slice3,slice1)
// 删除
// 删除 index=2
slice1=append(slice1[:2],slice1[3:]...)
fmt.Println(slice1,slice2,slice3)
}
map
map是一个key-value的hash结构,是一个无序的数据的集合,通过键来进行索引得到对应的值。 这种方式可以加快查找速度。Map 通常称为 字典(dictionary) 或者哈希表(Hash table)。Map 现在是很多语言的标配
package main
import "fmt"
func main() {
map1 :=map[string]string{
"username": "hhh",
}
map1["age"]="18"
fmt.Println(map1)
}
综合案例
package main
import "fmt"
func main() {
userInfo := []map[string]string{
{
"username": "wxj",
"age":"26",
},
{
"username": "wxj1",
"age":"28",
},
}
fmt.Println(userInfo)
}
对象
golang是面向过程的语言,go中没有类,但go支持面向对象的编程,go中的struct就像其他语言中的类;go里没有继承,但可以通过组合来实现。
结构体–类
基本使用
package main
import "fmt"
type Person struct {
name string
age int
}
func (p Person) printInfo(name string)string{
p.name = name
fmt.Println(p.name,"---",p.age) // wxj123 --- 18
return name
}
func main() {
var person =Person{
name :"wxj",
age :18,
}
newname:=person.printInfo("wxj123")
fmt.Println(newname) // wxj123
}
接口
接口是一系列操作的集合,是一种约束。我们可以把它看作与其他对象通讯的协议。任何非接口类型只要拥有某接口的全部方法,就表示它实现了该接口,go中无需显式的在该类上添加接口声明。
线程
1.12 错误及异常处理
package main
import (
"errors"
"fmt"
)
func main(){
defer func(){
if err := recover(); err != nil{ //捕捉异常并处理
fmt.Println("err: ", err)
}
}()
if num, err := delive(20, -5); err == nil{
fmt.Printf("%f / %f = %f\n", 20.0, -5.0, num)
}else{
fmt.Println(err)
}
if num, err := delive(20, 0); err == nil{
fmt.Printf("%f / %f = %f\n", 20.0, 0.0, num)
}else{
fmt.Println(err)
}
}
func delive(numA, numB float32) (float32, error){
if numB < 0{
return 0, errors.New("被除数不能为负数")
}else if numB == 0{
panic("被除数不能为0") //抛出异常
}else{
return numA/numB, nil
}
}