Go开发纪要01_基础类型

目录

01.命名方法

文件名

函数或方法

常量

变量

02.变量

03.变量声明

Go的语言结构

GO语言变量声明的方式

03.变量初始化

二 :=陷阱

04. 变量赋值

要点

示例

分号

变量类型

06. 匿名变量

07.常量

字面常量(常量值)

结构体

数组和切片

字典

快捷方式

 

2、枚举类型注意事项

3.1 枚举类型实现

3.2 iota的优势

3.3 如何使用多个iota

3.4 枚举类型定义二

3.5 总结

 08.基础数据类型

09.格式化输出输入

 

2.5.1 格式说明

2.5.2 输出

2.5.3 输人

10.类型转换

底层类型(Underlying type)

可赋值性(Assignability)

常量

数字类型

浮点数(floating-point number) -> 整数(integer)

指针

字符串

整数 -> 字符串

对 strings 的简要介绍

string ↔ slice of bytes

string ↔ slice of runes

类型别名

类型命名和类型声明的区别

类型循环

可导出性

方法集

byte 和 rune 类型

---

01.命名方法

文件名

• 整个应用或包的主入口文件应当是 main.go 或与应用名称简写相同。例如：Gogs 的主入口文件名为 gogs.go。

函数或方法

• 若函数或方法为判断类型（返回值主要为 bool 类型），则名称应以 Has, Is, Can 或 Allow 等判断性动词开头：

  func HasPrefix(name string, prefixes []string) bool { ... }
  func IsEntry(name string, entries []string) bool { ... }
  func CanManage(name string) bool { ... }
  func AllowGitHook() bool { ... }
  

常量

• 常量均需使用全部大写字母组成，并使用下划线分词：

  const APP_VER = "0.7.0.1110 Beta"
  

• 如果是枚举类型的常量，需要先创建相应类型：

  type Scheme string
  
  const (
      HTTP  Scheme = "http"
      HTTPS Scheme = "https"
  )
  

• 如果模块的功能较为复杂、常量名称容易混淆的情况下，为了更好地区分枚举类型，可以使用完整的前缀：

  type PullRequestStatus int
  
  const (
      PULL_REQUEST_STATUS_CONFLICT PullRequestStatus = iota
      PULL_REQUEST_STATUS_CHECKING
      PULL_REQUEST_STATUS_MERGEABLE
  )
  

变量

• 变量命名基本上遵循相应的英文表达或简写。

• 在相对简单的环境（对象数量少、针对性强）中，可以将一些名称由完整单词简写为单个字母，例如：

  • user 可以简写为 u
  • userID 可以简写 uid

• 若变量类型为 bool 类型，则名称应以 Has, Is, Can 或 Allow 开头：

  var isExist bool
  var hasConflict bool
  var canManage bool
  var allowGitHook bool
  

• 上条规则也适用于结构定义：

  // Webhook represents a web hook object.
  type Webhook struct {
      ID           int64 `xorm:"pk autoincr"`
      RepoID       int64
      OrgID        int64
      URL          string `xorm:"url TEXT"`
      ContentType  HookContentType
      Secret       string `xorm:"TEXT"`
      Events       string `xorm:"TEXT"`
      *HookEvent   `xorm:"-"`
      IsSSL        bool `xorm:"is_ssl"`
      IsActive     bool
      HookTaskType HookTaskType
      Meta         string     `xorm:"TEXT"` // store hook-specific attributes
      LastStatus   HookStatus // Last delivery status
      Created      time.Time  `xorm:"CREATED"`
      Updated      time.Time  `xorm:"UPDATED"`
  }
  

变量命名惯例

变量名称一般遵循驼峰法，但遇到特有名词时，需要遵循以下规则：

• 如果变量为私有，且特有名词为首个单词，则使用小写，如 apiClient。
• 其它情况都应当使用该名词原有的写法，如 APIClient、repoID、UserID。

下面列举了一些常见的特有名词：

// A GonicMapper that contains a list of common initialisms taken from golang/lint
var LintGonicMapper = GonicMapper{
    "API":   true,
    "ASCII": true,
    "CPU":   true,
    "CSS":   true,
    "DNS":   true,
    "EOF":   true,
    "GUID":  true,
    "HTML":  true,
    "HTTP":  true,
    "HTTPS": true,
    "ID":    true,
    "IP":    true,
    "JSON":  true,
    "LHS":   true,
    "QPS":   true,
    "RAM":   true,
    "RHS":   true,
    "RPC":   true,
    "SLA":   true,
    "SMTP":  true,
    "SSH":   true,
    "TLS":   true,
    "TTL":   true,
    "UI":    true,
    "UID":   true,
    "UUID":  true,
    "URI":   true,
    "URL":   true,
    "UTF8":  true,
    "VM":    true,
    "XML":   true,
    "XSRF":  true,
    "XSS":   true,
}

02.变量

Go语言变量有固定的数据类型，决定了变量内存的长度和存储格式。Go变量只能修改变量值，不能改变变量的数据类型。Go编译器会把未使用的局部变量当做错误，未使用的全局变量不受影响。

// 声明包main
package main
// 导入包
import(
    "fmt"
)
// 定义变量
var a int // 初始化为二进制零值
var b = false // 显示初始化变量的值，可以省略变量类型，由编译器自动类型推断
var c, d = 100, "hello" // 一次定义多个变量，数据类型可以不同
// 定义多个变量，建议使用组的形式定义多个变量
var (
    e, f int
    g, h = 100, "hello"
)

// 定义函数main
func main() {
    // 简短模式声明变量
    i := 100
    /**
     *简短模式声明变量，有以下3个条件
     *显示初始化
     *不能显示指定数据类型
     *只能在函数内部使用
     */
     // 多变量赋值
     x, y := 1, 10
     x, y = x+10, y+1 // 先计算右值，然后再对左边变量赋值，必须保证左右值得数据类型相同
    // 打印变量的值
    fmt.Println(a);
    fmt.Println(b);
    fmt.Println(c, d)
    fmt.Println(e, f)
    fmt.Println(g, h)
    fmt.Println(i)
    fmt.Println(x, y)
}

 

03.变量声明

Go的语言结构

1、Go的语言基础部分由这几个部分组成

• 包声明

• 引入包

• 函数

• 变量

• 语句&表达式

• 注释

比如下面这个简单的代码：

func main() {
    fmt.Println("第一个程序")
}

需要注意的是，如果想把单独的.go文件作为独立的可执行文件的时候。需要在代码的第一行加上

package main

文件的入口方法为：

func main(){
    
}

go的语法和c是很像的，但是又没有c那么底层。所以有c基础的人，学习go会特别的快。需要注意的一点是：

go声明变量的时候是把变量类型放在变量的后面的，就像这样：

var a string = "abc"

go也可以不指定数据类型，但是必须要赋值。如果不赋值，自动类型检查就无法起到作用

哪怕你直接这样：

var a=""

附一个空格值给变量也是可以的，就是不能不赋值，也不能为null。而且在go中也没有null的概念，取而代之的是nil：意思为0、无的意思。

还可以使用默认值，就像这样：

var a bool

输出为：false

GO语言变量声明的方式

• 指定变量类型，声明后如果不做赋值，那么使用默认值。

//没有进行赋值，但是指明了是什么类型、go会自动加上空值。
var a string

• 不指定变量类型，需要进行赋值操作。

//可以不指定变量类型，通过变量值，go会自行判断该变量的类型。
var a=1

• 不使用var关键字，直接:=对变量进行赋值操作。

//这种方式是省略了var，但是这种方式能对新的变量使用，对已经声明的变量使用会报错。
a:=1

注：

三种变量的声明形式的作用都是一样的，要么赋值可自动判断其类型，要么不赋值，指定变量类型，就这么两点。还需要注意的是，go的变量是如果被声明了，那么必须使用，不然会报错，如果不想使用可以加上_=varName,表示为已抛弃的变量。

//已声明，但未使用
var a=1
//标识为已抛弃的变量。
_=a

还需要重点强调的点：

• go的变量在已经被声明后，是不能使用:=再次赋值的。

//这样是错误的
var a=1
a:=2

但是可以使用=为已声明的变量赋新的值。

//这样做是可以的。
var a=1
a=2

而且如果变量值没被使用，那么请加上以抛弃的标识。

_=a

go可以直接声明多个变量，通过函数可以返回多个返回值，比如：

//一次性声明所有的变量类型为string类型
var name1,var name2,var name3 string

//函数返回多个返回值
func getName(name1,name2,name3,name4){
    return "aa","bb","cc","dd"
}

//返回多个返回的值的函数需要用多个变量进行接受
var a, b, c, d = getName()

go可使用var关键字声明全局变量，但是:=这种方式是不能用在全局变量中的。:=只能用在函数体内部。

var (
    a int
    b bool
    xx,yy,dd string="xx","yy","dd"
    //这里省略变量类型也是可以的。
    zz,aa="zz","aa"
)

比如像这样，这样做会报语法错误

var(
    a:=1
)

03.变量初始化

操作 := 只能用于方法内部, 声明并初始化新的变量

v := 3

但是不能用于已声明变量赋值, 下面的做法编译器会报错误"no new variables on left side of :="

var v int = 0
v := 1

通过错误可以了解到, := 操作左边必须要有新变量, 那么多个变量初始化只需要满足左边至少有一个新变量即可

err := errors.New("error1")
ret, err := test_fun()

这种做法是合法的, 因为ret是新变量, 这样就很方便了, 因为go方法经常会返回错误err, 那么在同一个方法内

只需要声明一个err变量即可

 

二 :=陷阱

由于:=只能用于局部变量, 那么下面的代码会发生什么情况呢?

var out int = 1

func test() {
    out, in := 2, 3