go语言基础

1, go环境与编辑工具安装

2, hello,word

3, 数据类型

4, 变量与常量

5, 流程控制与循环语句

6, 函数

7, 包

8, 数组

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1, go环境与编辑工具安装

下载地址: https://golang.org/dl/

下载地址: https://golang.google.cn/dl/

下载后点击注册机,点击next,直到完成安装, 将安装完成的文件Goin添加到计算环境变量中即可.在命令行可以测试,输入go env.安装完成将会go语言的环境配置. 其中GOPATH:是go文件编辑存储路径, GOROOT:是go环境路径

下在Go的编辑器: https://www.jetbrains.com/go/. 无脑下一步即可,

2, hello, word!

go的第一个程序:

Go 语言的基础组成有以下几个部分：

包声明
引入包
函数
变量
语句 & 表达式
注释

让我们来看下以上程序的各个部分：

第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符。
使用 fmt.Print("hello, world ") 可以得到相同的结果。
Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。
当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 private ）

// 单行注释
/*
多行注释
 */
package main  // 表示当前go 属于哪个文件

import "fmt"  // 导包

func main() {
    fmt.Println("Hello World")
}

3, 数据类型

go的数据类型分为4大类:

1 布尔类型

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。

2, 数字类型

整型 int 和浮点型 float，Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。

有符号与无符号数:

uint8: 无符号 8 位整型 (0 到 255)

uint16:无符号 16 位整型 (0 到 65535)

uint32:无符号 32 位整型 (0 到 4294967295)

uint64:无符号 64 位整型 (0 到 18446744073709551615)

int8:有符号 8 位整型 (-128 到 127)

int16:有符号 16 位整型 (-32768 到 32767)

int32:有符号 32 位整型 (-2147483648 到 2147483647)

int64: 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)　

浮点型与虚数:

float32: 32位浮点型数

float64:64位浮点数

complex64: 32位虚数和实数

complex128: 64位虚数和实数

其他数据类型:

byte: 和uint8相同.

rune和int32相同,

uint,....

3, 字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

4, 派生类型

(a) 指针类型（Pointer）(b) 数组类型 (c) 结构化类型(struct) (d) 联合体类型 (union) (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型 (i) Channel 类型

4, 变量与常量

定义变量的三种形式

变量只能声明一次, 可以在重新赋值使用. 没有声明的变量不能使用.声明后没有使用,将会报错.

package main

import "fmt"

func main()  {
    // var声明, age变量名, int变量类型 10变量初始值
    var age int = 10
    // var声明, age变量名, 10变量初始值
    var age  = 10
    // age变量名  := 变量声明赋值  变量值
    age := 10
    fmt.Println("my age is", age)
}

变量多个变量赋值

    name,age :="go", 10
    fmt.Println("my age is", age)
    fmt.Println("my name is", name)

Go常量是一个简单值的标识符，在程序运行时，不会被修改的量。常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

// 定义格式
const identifier [type] = value
// 多个相同类型
const c_name1, c_name2 = value1, value2

// 案例

package main

import (
   "fmt"
)

func main() {
   const a = 5
   var intVar int = a
   var int32Var int32 = a
   var float64Var float64 = a
   var complex64Var complex64 = a
   fmt.Println("intVar",intVar, "
int32Var", int32Var, "
float64Var", float64Var, "
complex64Var",complex64Var)
}

5, 流程控制与循环语句

if 语句 由一个布尔表达式后紧跟一个或多个语句组成。后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。并且在if或 else if 可以嵌套多个if, else if语句.

switch 语句用于基于不同条件执行不同动作。

package main

import "fmt"

func main()  {
    var sign = true
    i := 0
    for sign {
        i += 1
        fmt.Println(sign)
        if i == 4 {
            continue
        }
        if i == 10 {
            sign = false
        }
        switch i {
        case 1:
            fmt.Println("这是:",i,"
")
        case 2:
            fmt.Println("这是:",i,"
")
        case 3:
            fmt.Println("这是:",i,"
")

        case 10:
            fmt.Println("这是:",i, "
")
            fallthrough  // 机床
        case 11:
            fmt.Println("这是:",i, "
")
        }
    }
}

if与switch 案例

for语句:重复执行语句块, 也可嵌套多个for循环

break语句: 经常用于中断当前 for 循环或跳出 switch 语句

continue语句: 跳过当前循环语句,执行下次循环.

package main

import "fmt"

func main() {
    sum := 0
    // 赋值i=0 判断i小于等于3 i自＋
    for i := 0; i <= 3; i++ {
        sum += i
        if i == 5 {
            continue
        }
        if i == 8 {
            break
        }
    }
    fmt.Println(sum)
}

6, 函数

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数字，则返回数组中包含的函数个数。

func function_name( [parameter list] ) [return_types]{
   函数体
}

函数定义解析：

func：函数由 func 开始声明
function_name：函数名称，函数名和参数列表一起构成了函数签名。
parameter list]：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。

案例

package main

import "fmt"

var a, b, c int
func main() {
    //var jiSuan func(a,b,c int)(x,y,int)
    x, y := sumExp(1,2,3)
    fmt.Print(x,"
",y)
}

func sumExp(a,b,c int)(x int,y int){
    x = a*a + b*b + c*c
    y = a*a*a + b*b*b + c*c*c
    return x, y
}

7, 包

导入其他go文件包.

|-Go1

　　|- geometry

　　　　|-rectangle

　　　　　　|-rectprops.go

ps: 被导入文件函数,变量名首字母大写才能使用

package rectangle

import "math"
import "fmt"

func init()  {
    fmt.Print(1111)
}

func Area(len, wid float64) float64 {
    area := len * wid
    return area
}

func Diagonal(len, wid float64) float64 {
    diagonal := math.Sqrt((len * len) + (wid * wid))
    return diagonal
}

被导入包rectangle

// geometry.go
package main

import (
    "Go1/geometry/rectangle" // 导入自定义包
    "fmt"
)

func main() {
    var rectLen, rectWidth float64 = 6, 7
    fmt.Println("Geometrical shape properties")
    /*Area function of rectangle package used*/
    fmt.Printf("area of rectangle %.2f
", rectangle.Area(rectLen, rectWidth))
    /*Diagonal function of rectangle package used*/
    fmt.Printf("diagonal of the rectangle %.2f ", rectangle.Diagonal(rectLen, rectWidth))
}

执行文件/geometry.go

8, 数组

Go语言数组,

Go 语言提供了数组类型的数据结构。数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。相对于去声明number0, number1, ..., and number99的变量，使用数组形式numbers[0], numbers[1] ..., numbers[99]更加方便且易于扩展。数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推。

语法格式

var variable_name [SIZE] variable_type

案例

package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d
", j, n[j] )
   }
}

数组

9, 切片

Go 语言切片是对数组的抽象。Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片两种

// 定义未指顶大小的切片
var a []int
// 使用make函数创建切片, 3 为切片长度
var a []int = make([]int, 3)
// 定义并赋初值

a := [1,2,3,]

package main

import (
    "fmt"
)

func main() {
    // 定义切片的种方法
    var a []int

    a := [1,2,3,]
    a := []int{1,2,3,4}
    a := [...]int{1,2,3,4}
    a1 := a[0:1]
    a2 := a[2:]

    fmt.Println(a1, a2)   // [1] [3 4]
    fmt.Println(len(a1),len(a2))  // 1 2
    fmt.Println(cap(a1),cap(a2))  // 4 2


// 容量最大控制个数, 长度表示现在值的数量
    a := make([]int, 2, 4)
    a = append(a, 1,2,3)
    fmt.Println(a)
    fmt.Println(len(a))
    fmt.Println(cap(a))
}

切片

ps: 切片本身不拥有任何数据,它只是对现有数组的一个引用. 切片由[]T表示, T表示

10, maps

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义map

使用内建函数make也可使用map关键字来定义map

var a map[string]int
a = make(map[string]int)

package main

import "fmt"

func main() {
    // 定义map方式
    var a map[string]int
    a = make(map[string]int)
    // 添加值
    a["z"] = 1
    a["x"] = 0
    a["c"] = 2
    // 删除
    delete(a, "x")
    fmt.Println(a)
}

11, 字符串

go语言字符串, 可以用双引号(" "), 三引号(``` ```).表示字符串. go语言中字符串使用utf-8编码. 字符占用一个字节, 但是汉字占用三个字节.对中文字符的处理需要注意.

package main

import (
    "fmt"
    "unicode/utf8"
)

var name string = "my name is 怀信"

func main()  {
    // 计算字节长度
    fmt.Println(len(name))  // 17
    // 计算字符长度
    fmt.Println(utf8.RuneCountInString(name)) // 13 
    // 使用range来循环
    for _,v :=range name{

        fmt.Println(string(v))  // 获取到字符串每个值
    }
}

12, 指针

变量是一种使用方便的占位符，用于引用计算机内存地址。Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址.

package main

import "fmt"

func main() {
    // 测试变量
    a := 10
    // 定义指针
    var ip*int
    // 指针赋值
    ip = &a    // 显示指针地址
    fmt.Println(ip)
    // 反解指针地址对应的值
    fmt.Println(*ip)
}

13, 结构体

go语言也有面向对象的思想. 其中结构体便是一种提现. 它包含封装, 继承, 多态的特性.

定义结构体关键字type, struck, 在结构体类写变量属性, 可以将结构体实例化赋值给变量.

package main

import "fmt"

// 定义结构体关键字: type, struct
type sub struct {
    id int
    name string
}

type obj struct {
    name string
    age int
    gender uint8
    hobby sub
}

func main() {
    // 第一种赋值方式
    var obj1 obj
    obj1.name = "怀信"
    obj1.age = 23
    obj1.gender = 1
    obj1.hobby.name="听歌"
    // 第二种赋值方式
    obj1 := obj{name:"怀信",age:23,gender:1}
    obj1 := obj{name:"怀信",age:23,gender:1,hobby:sub{id:1,name:"看书"}}

    fmt.Println(obj1)
}