Go 语言上手-基础语言 | 青训营笔记

用户5816721114756
129 阅读5分钟

一、本堂课重点内容：

课前导学

【Go 语言原理与实践学习资料】第三届字节跳动青训营-后端专场 - 掘金

实战课程代码

github.com/wangkechun/…

课程PPT

Go语言基础上手

学习资料

Go 语言学习线路图

Go 语言圣经（中文版）

本节课程主要分为三个方面：

  1. Go 语言简介
  2. Go 语言开发入门
  3. Go 实战

二、详细知识点介绍及例子：

1 变量

声明变量的一般形式是使用 var 关键字：

var identifier type

可以一次声明多个变量：

var identifier1, identifier2 type
identifier1, identifier2 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3
vname1, vname2, vname3 := v1, v2, v3

如果没有初始化

  • 数值类型（包括complex64/128）为 0

  • 布尔类型为 false

  • 字符串为 "" （空字符串）

  • 以下其他类型为 nil：

    var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

第二种，根据值自行判定变量类型。

var v_name = value

第三种，使用:=

v_name := value

常量的定义格式：

const identifier [type] = value

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义： const b string = "abc"
  • 隐式类型定义： const b = "abc

2 if else

if后面没有括号

if i==0 {
​
}

1.1.3 for

for后面没有括号

for{}//代表死循环
// a traditional "while" loop
for condition {
    // ...
}

没有while

for循环的另一种形式, 在某种数据类型的区间（range）上遍历，如字符串或切片。

for _, arg := range os.Args[1:] {
        s += sep + arg
        sep = " "
}

1.1.4 switch

switch a {
    case1:
        ...
    default:
        ...
}

1.5 数组

语法格式如下：

var variable_name [SIZE] variable_type

var a[5]int

var v = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

命令行参数：输出所有的命令行参数

func main() {
    fmt.Println(strings.Join(os.Args[1:], " "))
}

长度不确定，用 ...

var v = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
​
// 指定下标来初始化: 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

1.1.6 切片(可变长度数组)

定义

1.用未指定大小的数组来定义切片：

var identifier []type

2.使用 make() 函数来创建切片:

var slice1 []type = make([]type, len)
slice1 := make([]type, len)

3.也可以指定容量，capacity可选

make([]T, length, capacity)

初始化

s :=[] int {1,2,3 } 
s := arr[startIndex:endIndex]
s := arr[:] 
s1 := s[startIndex:endIndex]

==len() 和 cap() ==

len(s)
cap(s)

切片在未初始化之前默认为 nil，长度为 0

切片截取

截取切片 [lower-bound:upper-bound]

numbers[1:4]

append() 和 copy()

/* 向切片添加一个元素 */
numbers = append(numbers, 1)
/* 同时添加多个元素 */
numbers = append(numbers, 2,3,4)
/* 拷贝 numbers 的内容到 numbers1 */
copy(numbers1,numbers)

1.1.7 map

map_variable := make(map[key_data_type]value_data_type)

m := make(map[string]int)
m["one"]=1

delete() 函数用于删除集合的元素

delete(aMap, "key")

1.1.8 range

range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素

for key, value := range oldMap {
    newMap[key] = value
}

如果只想读取 key：

for key := range oldMap

或者这样：

for key, _ := range oldMap

如果只想读取 value：

for _, value := range oldMap

1.1.9 函数

Go 语言函数定义格式如下：

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

func add(a int,b int)int{
​
}

Go 函数可以返回多个值：

func swap(x, y string) (string, string) {
   return y, x
}

Go 语言可以作为另外一个函数的实参：

package main
​
import (
   "fmt"
)
​
func main(){
   /* 函数变量 */
   getSelf := func(x int) int {
      return x
   }
   
   fmt.Println(getSelf(9))
​
}

给定类型的方法：

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}

eg:

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

1.1.10 指针

*&

整型指针数组：

var ptr [MAX]*int;

1.1.11 结构体

结构体的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

type user struct{
    name string
    password string
}

1.1.12 错误处理

error类型是一个接口类型，这是它的定义：

type error interface {
    Error() string
}

函数通常在最后的返回值使用errors.New 可返回错误信息

func add(a int,b int)(int a,err error){
    return 0,errors New("not found")
​
}
​
...
result, err:= add(1,2)
if err != nil {
   fmt.Println(err)
}

1.1.13 字符串操作

Strings包中函数

fmt包中字符串格式化类型

%v：值的默认格式，变量的自然形式（natural format）；
%+v：当打印结构体时，输出结构体成员名与值;
%#v：当打印结构体时，输出结构体类型名、成员名与值
%T：打印类型（相应值的类型）；
%%：打印百分号；
%p：打印指针的地址（以0x开始）

1.1.14 JSON操作

参考链接www.php.cn/be/go/44136…

要保证结构体公开字段首字母大写。

Go json包

Marshal()：Go数据对象 -> json数据

UnMarshal()：Json数据 -> Go数据对象

​
func Marshal(v interface{}) ([]byte, error)
​
func Unmarshal(data []byte, v interface{}) error

package main
​
import (
    "encoding/json"
    "fmt"
)
​
type Post struct {
    Id      int
    Content string
    Author  string
}
​
func main() {
    post := &Post{1, "Hello World", "userA"}
​
    b, err := json.Marshal(post)
​
    if err != nil {
​
        fmt.Println(nil)
​
    }
​
    fmt.Println(string(b))
    
}
​

输出

{"Id":1,"Content":"Hello World","Author":"userA"}

1.1.15 时间处理

time包中函数

具体参考c.biancheng.net/view/5392.h…

now := time.Now()

1.1.16 数字解析

stronv包

具体参考c.biancheng.net/view/5112.h…

stronv.ParseFloat(.., ..)

1.1.17 进程信息

”os" "os/exec"包

os.Args;

1.18 其他

输入输出

package main
​
import (
    "bufio"
    "fmt"
    "os"
)
​
​
func main() {
    input := bufio.NewScanner(os.Stdin)
    var result string
    if input.Scan(){
        result = input.Text()
    }
    fmt.Println(result)
}

行分隔符

在 Go 程序中，一行代表一个语句结束

字符串连接

Go 语言的字符串可以通过 + 实现

格式化字符串

package main
​
import (
    "fmt"
)
​
func main() {
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"//格式，作为一个参数输入
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

类型转换

type_name(expression)

接口

把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}
​
/* 定义结构体 */
type struct_name struct {
   /* variables */
}
​
/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}
​
/* 那么 */
func main(){
    var i interface_name;
    i = new (struct_name);
    i.method_name1();
}

三、引用参考：

Go语言中处理json数据的方法

菜鸟go教程

【Go 语言原理与实践学习资料（上）】第三届字节跳动青训营-后端专场

avatar
文章
阅读
粉丝