Go语言七篇入门教程二程序结构与数据类型

目录

  • 1. 程序结构
    • 1.1 名称
    • 1.2 声明
    • 1.3 注释
    • 1.4 单双引号
    • 1.5 输出
  • 2. 数据类型
    • 2.1 整型
    • 2.2 浮点型
    • 2.3 复数
    • 2.4 布尔型
    • 2.5 字符串
    • 2.6 常量
    • 2.7 数组
    • 2.8 切片
    • 2.9 map
    • 2.10 结构体
    • 2.11 JSON
  • 3. 流程控制
    • 3.1 条件语句
    • 3.2 选择语句
    • 3.3 循环语句
  • 如何学习Go

    1. 程序结构
    1.1 名称
    如果一个实体名称在函数中声明,它只在函数局部有效。如果声明在函数外,它将对包里面的所有源文件可见。
    实体第一个字母的大小写决定其可见性是否跨包。如果名称是以大写字母的开头,它是导出的,意味着它对外包来说是可见的可访问的,可以被自己包外的其他程序所引用。
    大写可以!
    Go语言七篇入门教程二程序结构与数据类型
    文章图片

    小写不行!
    Go语言七篇入门教程二程序结构与数据类型
    文章图片

    并且Go语言常常会使用驼峰式的风格命名
    func main() { FanOne := "666" //大驼峰 (注意!一般函数内部都是用小驼峰,局部变量,大驼峰一般用于函数的命名,需要外包的导出) fanOne := "666" //小驼峰}

    当然可以使用下划线比如,不过我还是比较驼峰式~
    【Go语言七篇入门教程二程序结构与数据类型】Go语言七篇入门教程二程序结构与数据类型
    文章图片


    1.2 声明
    go语言可通过var进行变量的声明
    var 变量名 类型
    例如:
    func main(){ var fanOne string var xiaoSheng int var a,b,c = true , 6.6 , "fanOne" //bool ,float , string}

    当然也可以使用:=
    例如
    func main(){ fanOne:="666" //string字符串 xiaoSheng := 666//int整型 a,b,c := true , 6.6 ,"fanOne"//bool ,float , string}


    1.3 注释
    可以用
    //单行注释/*多行注释*/


    1.4 单双引号
    func main(){ var d rune d = '1' a := 'a' b := "a" c := `'a'':"b"`//可以把单引号和双引号整括起来 fmt.Printf("%T\n",d)// int32 fmt.Printf("%T\n",a)// int32 fmt.Printf("%T\n",b)// string fmt.Printf("%T\n",c)// string}


    1.5 输出
    //Println 自带换行 Printf 格式化输出

    Go语言七篇入门教程二程序结构与数据类型
    文章图片

    Go语言七篇入门教程二程序结构与数据类型
    文章图片


    2. 数据类型
    2.1 整型
    整型数据可以分为两类,有符号和无符号两种类型
    有符号: int, int8, int16, int32, int64
    无符号: uint, uint8, uint16, uint32, uint64, byte
    另外rune是int32的别名
    在保证程序正确运行下,尽量使用占用空间小的数据类型
    • 不同位数的整型区别在于能保存整型数字范围的大小;
    • 有符号类型可以存储任何整数,无符号类型只能存储自然数
    • int和uint的大小和系统有关,32位系统表示int32和uint32,如果是64位系统则表示int64和uint64
    • byte与uint8类似,一般用来存储单个字符

    2.2 浮点型
    float64float32 两种
    • float64的精度要比float32的要准确
    • 如果我们要保存一个精度高的数,则应该选择float64
    浮点型的存储分为三部分:符号位+指数位+尾数位,在存储过程中,精度会有丢失
    Go的浮点型默认为float64类型

    2.3 复数
    complex64complex128 , 二者分别由float32float64 构成,内置的complex函数根据给定的实部和虚部创建复数,而内置的real函数和img函数则分别提取复数的实部和虚部:
    var x complex128 = complex(1,2) //1+2ivar y complex128 = complex(3,4) //3+4ifmt.Println(x*y)//-5+10ifmt.Println(real(x*y))//-5fmt.Println(imag(x*y))//10

    当然我们也可以像这样
    x := 1 + 2iy := 3 + 4i


    2.4 布尔型
    只有两种可能true或者式false
    var fanOne truevar xiaoSheng false


    2.5 字符串
    func main(){ s:="FanOne" fmt.Println(len(s)) //6 fmt.Println(s[:3])//Fan fmt.Println(s[1],s[2]) // 97 110}

    字符串拼接
    func main(){ s:="FanOne" b := "666" y := s + b fmt.Println(y) //FanOne666}

    字符串转int
    num,err:=strconv.Atoi("666")//num就是整型

    int 转 字符串
    str := strconv.Itoa(666) //str是字符串


    2.6 常量
    const a = 666fmt.Println(a) //666


    2.7 数组
    var a [3]int //3个整数的数组for i , v := range a { fmt.Println(i,v)}

    var fan [3]int{1,2,3}var one [3]int{1,3}t := [...]int{1,2,3} //省略号fmt.Printf("%T",t)//[3]int

    go语言的数组的长度是固定的,所以在某些场景下数组存在着它的局限性
    而切片的存在就解决了数组长度局限的问题,切片可以看做一个可以自动扩容的数组,但是它跟数组还是有着区别。

    2.8 切片
    可以通过make切片字面量来创建和初始化切片,也可以利用现有数组或切片直接创建切片(Go语言中的引用类型(slice、map、chan)不能使用new进行初始化)。
    使用make时,需要传入一个参数指定切片的长度,如果只指定长度,则切片的容量和长度相等。也可以传入两个参数分别指定长度和容量。不允许创建容量小于长度的切片。
    // make只传入一个参数指定长度,则容量和长度相等。以下输出:"len: 10, cap: 10"s := make([]int, 10)fmt.Printf("len: %d, cap: %d\n", len(s), cap(s))// make 传入长度和容量。以下输出:"len: 10, cap: 15"s := make([]int, 10, 15)fmt.Printf("len: %d, cap: %d\n", len(s), cap(s))// 不允许创建容量小于长度的切片。下面语句编译会报错:"len larger than cap in make([]int)"s := make([]int, 10, 5)

    通过切片字面量来声明切片。
    // 通过字面量声明切片,其长度和容量都为5。以下输出:“len: 5, cap: 5”s := []int{1, 2, 3, 4, 5}fmt.Printf("len: %d, cap: %d\n", len(s), cap(s))// 可以在声明切片时利用索引来给出所需的长度和容量。// 通过指定索引为99的元素,来创建一个长度和容量为100的切片s := []int{99: 0}

    基于现有数组或切片来创建切片的方法为:s := baseStr[low:high:max],low指定开始元素下标,high指定结束元素下标,max指定切片能增长到的元素下标。这三个参数都可以省略,low省略默认从下标0开始,high省略默认为最后一个元素下标,max省略默认是底层数组或切片的容量(这里也要注意max不能小于high)。这种方式下,切片的长度和容量的计算方式为:
    len = hith - lowcap = max - lows1 := baseStr[1:3:10]fmt.Printf("len: %d, cap: %d\n", len(s1), cap(s1)) // len: 2, cap: 9s2 := baseStr[1:3]fmt.Printf("len: %d, cap: %d\n", len(s2), cap(s2)) // len: 2, cap: 9s3 := baseStr[:3]fmt.Printf("len: %d, cap: %d\n", len(s3), cap(s3)) // len: 3, cap: 10ss1 := s1[2:5]ss2 := s1[3:8]fmt.Printf("len: %d, cap: %d\n", len(ss1), cap(ss1)) // len: 3, cap: 7fmt.Printf("len: %d, cap: %d\n", len(ss2), cap(ss2)) // len: 5, cap: 6

    增加可以用append
    // 创建一个整型切片// 其长度和容量都是5个元素slice := []int{1, 2, 3, 4, 5}// 创建一个新切片// 其长度为2 个元素,容量为4个元素newSlice := slice[1:3]// 使用原有的容量来分配一个新元素// 将新元素赋值为 60newSlice = append(newSlice, 6)fmt.Printf("slice: %v\n", slice)// slice: [1 2 3 6 5]fmt.Printf("newSlice: %v\n", newSlice) // newSlice: [2 3 6]


    2.9 map
    Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据,key 类似于索引,指向数据的值。
    Map 是一种集合,所以我们可以像迭代数组和切片那样迭代它。不过,Map 是无序的,我们无法决定它的返回顺序,这是因为 Map 是使用 hash 表来实现的。
    声明
    /* 声明变量,默认 map 是 nil */var map_variable map[key_data_type]value_data_type/* 使用 make 函数 */map_variable := make(map[key_data_type]value_data_type)

    var fan map[string]string //创建集合 fan = make(map[string]string) //map插入key-value对 fan [ "One" ] = "666" fan [ "Four" ] = "999" //使用键输出 for value := range fan {fmt.Println(value, "is", fan [value]) } //查看元素在集合中是否存在 val, ok := fan [ "Two" ] //如果确定是真实的,则存在,否则不存在 if ok {fmt.Println("fanTwo is", val) } else {fmt.Println("fanTwo not exist") }

    delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。
    可以使用delete方法删除
    delete(fan , "One")


    2.10 结构体
    结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型,结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下:
    type Person struct{ name string age int sex string}func main(){ person := Person{//初始化name: "fanOne",age:16,sex:"male", } fmt.Println(person.name)//引用}


    2.11 JSON
    type Person struct{ Name string `json:"name"` //序列化成string类型 Age int `json:"age"` Sex string `json:"sex"`}func main(){ person := &Person{} //创建一个对象 var data = https://www.it610.com/article/`{"name":"fanOne","age":"11","sex":"male"}` _ = json.Unmarshal([]byte(data), &person)//将这个data序列化成person的结构体,并传入其中 fmt.Println(person.Name)}


    3. 流程控制
    3.1 条件语句
    func main(){ x :=1 if x == 1 {fmt.Println("666") } else {fmt.Println("999") }}


    3.2 选择语句
    switch i { case 0:fmt.Printf("0") case 1:fmt.Printf("1") case 2:fmt.Printf("2") case 3:fmt.Printf("3") case 4, 5, 6:fmt.Printf("4, 5, 6") default:fmt.Printf("Default") }


    3.3 循环语句
    sum := 0 for i := 0; i < 10; i++ {sum += i }

    s := [3]int{1,2,3} for _,item := range s{fmt.Println(item) }

    以上就是Go语言七篇入门程序结构与数据类型的详细内容,更多关于Go语言程序结构与数据类型的资料请关注脚本之家其它相关文章!

    如何学习Go 如果你是小白,你可以这样学习Go语言~
    七篇入门Go语言
    第一篇:Go简介初识
    第三篇:函数方法接口的介绍
    第四篇:通道与Goroutine的并发编程
    第五篇:文件及包的操作与处理
    第六篇:网络编程
    第七篇:GC垃圾回收三色标记

      推荐阅读