go time时间偏移_go-1

第一篇

一：GO基本概念

Golang⽬录结构划分

• 个人项目

• 公司项目

包的概念

1. 和python⼀样，把相同功能的代码放到⼀个⽬录，称之为包

2. 包可以被其他包引⽤

3. main包是⽤来⽣成可执⾏⽂件，每个程序只有⼀个main包

4. 包的主要⽤途是提⾼代码的可复⽤性

Go 基本命令介绍

a. go run 快速执⾏go⽂件，就像执⾏脚本⼀样

b. go build 编译程序，⽣成⼆进制可执⾏⽂件

c. go install 安装可执⾏⽂件到bin⽬录

d. go test 执⾏单元测试或压⼒测试

e. go env 显示go相关的环境变量

f. go fmt 格式化源代码

Go程序结构

a. go源码按package进⾏组织，并且package要放到⾮注释的第⼀⾏

b. ⼀个可执⾏程序只有⼀个main包和⼀个main函数

c. main函数是程序的执⾏⼊⼝

golang语⾔特性

1. 垃圾回收

a. 内存⾃动回收，再也不需要开发⼈员管理内存

b. 开发⼈员专注业务实现，降低了⼼智负担

c. 只需要new分配内存，不需要释放 golang语⾔特性

2. 天然并发

a. 从语⾔层⾯⽀持并发，⾮常简单。只需要go⼀下

b. goroutine，轻量级线程，创建成千上万个goroute成为可能

func calc() {  //⼤量计算 } 
func main() {  go calc() }

3. channel

a. 管道，类似unix/linux中的pipe

b. 多个goroute之间通过channel进⾏通信

c. ⽀持任何类型

4. 多返回值

a. ⼀个函数返回多个值

5. 编译型语⾔

a. 性能只⽐C语⾔差10%

b. 开发效率和python、php差不多

二：GO 数据类型 变量 常量

go中标识符和关键字

1. 标识符是⽤来表示Go中的变量名或者函数名，以字⺟或_开头。后⾯跟着字⺟ 、_或数字

A. 88ab(错) B. _ab28 C. ab_28

2. 关键字是Go语⾔预先定义好的，有特殊含义的标识符。共25 个

3 变量

语法：var identifier type

var a int
var b string
var c bool
var d int = 8
var e string = “hello”

或者是

var (
 a int //0
 b string //“”
 c bool //false
 d int = 8 // 8
 e string = “hello” //hello
)

4 常量

常量使⽤const 修饰，代表永远是只读的，不能修改。

语法：const identifier [type] = value，其中type可以省略。

举例： const b string = “hello world”
const b = “hello world”
const Pi = 3.1414926
const a = 9/3

优雅的写法:

const(
 a = 1
 b = 2
 c = 3
)

更加专业的写法

const (
 a = iota
 b
 c
)
const(
 a = 1 << iota
 b
 c
)

三 go中的数据类型与操作符

1 布尔类型

2. 整数和浮点数类型

3. 字符串类型

1. 布尔类型

a. var b bool 和 var b bool = true 和 var b = false 
b. 操作符 == 和 !=
c. 取反操作符： !b 数据类型和操作符 
d. && 和 || 操作符 
e. 格式化输出占位符: %t

2. 整数和浮点数类型

http://www.360doc.com/content/20/0218/08/33093582_892845322.shtml
a. int8、int16、int32、int64
b. uint8、uint16、uint32、uint64
c. int 和 uint，和操作系统平台相关
d. float32 和 float64浮点类型
e. 所有整数 初始化为0，所有浮点数初始化为0.0，布尔类型初始化为false

a. Go是强类型语⾔言，不不同类型相加以及赋值是不不允许的
b. 那怎么样才能实现，不不同类型相加呢?
c. 输出占位符:整数%d，%x⼗十六进制，%f浮点数 3. 字符串类型

a. var str string
b. var str string = “hello world”
c. 字符串串输出占位符 %s
d. 万能输出占位符: %v

%c

字符串的两种表示方式

a. 双引号， “”，可以包含控制字符
b. 反引号， ``，所有字符都是原样输出

字符串串常⽤用操作

a. ⻓长度:len(str)
b. 拼接:+，fmt.Sprintf
c. 分割:strings.Split
d. 包含: strings.Contains
e. 前缀或后缀判断:strings.HasPrefix, strings.HasSuffix 
f. ⼦子串串出现的位置: strings.Index(), strings.LastIndex() 
g. join操作: strings.Join(a[]string, sep string)

操作符

a. 逻辑操作符， == 、 != 、<、<=、>=
b. 算数操作符， +、-、*、/、%

go程序的基本结构

1 任何⼀一个代码⽂文件⾪隶属于⼀一个包

package main 
import “fmt” 
func main() {
  fmt.Println(“hello, world”) 
}

2. import 关键字，引⽤用其他包:

3. 开发可执⾏行行程序，package main， 并且有且只有⼀一个main⼊入⼝口函数

4. 包中函数调⽤用:
a. 同⼀一个包中函数，直接⽤用函数名调 b. 不不同包中函数，通过包名+点+
函数名进⾏行行调⽤用

5. 包访问控制规则:
a. ⼤大写意味着这个函数/变量量是可导出 b. ⼩小写意味着这个函数/变量量是私有的
包外部不不能访问

四: 字符串原理 时间 日期

1.字符串串原理理解析

1. 字符串串底层就是⼀一个byte数组，所以可以和[]byte类型互相转换
2. 字符串串之中的字符是不不能修改的，那怎么修改呢 转成字符切片
3. 字符串串是由byte字节组成，所以字符串串的⻓长度是byte字节的⻓长度
4. rune类型⽤用来表示utf8字符，⼀一个rune字符由1个或多个byte组成

2 时间和日期类型

1. time包
2. time.Time类型，⽤用来表示时间
3. 获取当前时间， now := time.Now()
4. time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()
5. 格式化，fmt.Printf(“%02d/%02d%02d %02d:%02d:%02d”, now.Year()...)
6. 获取当前时间戳，time.Now().Unix()。
7. 时间戳转Time类型。
8. time.Duration⽤用来表示纳秒

五: 流程控制

 if condition {
    //do something
 } else if condition {
      //do something
 } else {
    //do something
 }

或者:
if statement; condition {
}

package main
   import (
  "fmt"
  )
func main() {
    
    
if num:=10; num % 2 == 0 {
     //checks if number is even
       
fmt.Println(num,"is even")
    } else{
    
   
    fmt.Println(num,"is odd")
    
}
}

循环

 for initialisation; condition; post {
 }

例子

package main
   import (
  "fmt"
  )
 func main() {
      
for i:=1; i<= 10；i ++ { 
          fmt.Printf(" %d",i)
      }
}
  

break，终⽌止循环

package main

import ( 
   "fmt"
)
func main() {
    
   for i:=1; i<=10;i++ {
     if i > 5 {
        break
     }
     fmt.Printf("%d",i)
   }
  
   fmt.Printf("nline after for loop")
 }   
12345  "nline after for loop"

continue，终⽌止本次循环

package main

import ( "fmt" )
func main() {
  for i :=1;i<=10;i++ {
    if i%2 == 0 {
      continue
    }
    fmt.Printf("%d", i)
  }
}  
13579

练习一: 可以在上面定义i初始值

package main
import (
   "fmt"
)

function main() {
   i :=0 
   for ;i<=10; {
      fmt.Printf("%d", i)
      i += 2
   }
} 
0 2 4 6 8 10

练习二

package main

import ('fmt')
func main() {
  i:=0
  for i <= 10 {
   fmt.Printf('%d ', i)
   i += 2
  }
}
0 2 4 6 8 10

练习三 多个变量

package main

import (fmt')

func main() {
  for no, i:=10,1; i<=10 && no <=19; i, no = i+1,no+1 {
     fmt.Printf("%d * %d = %dn", no, i, no*i)
  }
}

Switch 语句

package main
   import (
    "fmt"
   )

func main() {
  finger:=4
   
  switch finger {
   
    case 1:
   
      fmt.Println("Thumb")
      
    case 2:
   
      fmt.Println("Index")
      
    case 3:
   
      fmt.Println("Middle")
      
    case 4:
   
      fmt.Println("Ring")
      
    case 5:
   
      fmt.Println("Pinky")
  }
}

package main
   import (
  "fmt"
  )
func main() {
    
switch finger
  
case 1:
   
fmt.Println("Thumb")
      
case 2:
   
fmt.Println("Index")
      
case 3:
   
fmt.Println("Middle")
      
case 4:
   
fmt.Println("Ring")
      
case 5:
   
fmt.Println("Pinky")
      
default: //default case
   
fmt.Println("incorrect finger number")
      
}
  

六: 函数介绍

1. 定义:有输⼊入、有输出，⽤用来执⾏行行⼀一个指定任务的代码块。

 func functionname([parametername type]) [returntype] {
         //function body
 }
//其中参数列列表和返回值列列表是可选

例如：
 func add(a int, b int) int {
      Return a + b
 }

⽆无参数和返回值的函数

 func functionname() {
     //function body
 }

如果连续的一系列参数的类型是一样，前面的类型可以不写，例如:

 func add(a, b int) int {
      Return a + b
 }

函数调用

 func add(a, b int) int {
   Return a + b
 }
func main() {
  sum := add(2, 3)

}

多返回值

 func calc(a, b int) (int, int) {
      sum := a + b
      sub := a - b
   return sum, sub
 }
func main() {
   sum, sub := add(2, 3)

}

对返回值进行命名

 func calc(a, b int) (sum int, sub int) {
      sum = a + b
      sub = a - b
      return
 }
func main() {
    sum, sub := add(2, 3)

}

_标识符 这样就会忽略sub的值

 func calc(a, b int) (sum int, sub int) {
      sum = a + b
      sub = a - b
      return
 }
func main() {
    sum, _ := add(2, 3)

}
 

可变参数

func calc_v1(b ...int) (sum int, sub int) {
   sum:=0
   for i :=0; i<len(b);i++ {
     sum = sum =b[i]
   }
   return sum
}
func calc_v2(a int, b ...int) (sum int, sub int) {
return
}
func calc_v3(a int, b int, c ...int) (sum int, sub int) {
return
}

b其实是数组

defer语句

延迟执行语句，在函数返回之后会调用,用来释放一些资源

 func calc_v1(b ...int) (sum int, sub int) {
      defer fmt.Println(“defer”)
      return