golang類型推斷與隱式類型轉(zhuǎn)換

更新時間：2022年06月29日 10:35:10 作者：??ysj????

這篇文章主要介紹了golang類型推斷與隱式類型轉(zhuǎn)換，golang類型推斷可以省略類型，像寫動態(tài)語言代碼一樣，讓編程變得更加簡單，同時也保留了靜態(tài)類型的安全性

前言

golang類型推斷可以省略類型，像寫動態(tài)語言代碼一樣，讓編程變得更加簡單，同時也保留了靜態(tài)類型的安全性。類型推斷往往也伴隨著類型的隱式轉(zhuǎn)換，二者均與golang的編譯器有關(guān)。在了解了golang的類型推斷與隱式類型轉(zhuǎn)換原理后，將對如下問題信手拈來——下述代碼能通過編譯嗎？b的值是什么類型？

// eg.1
a := 1.1
b := 1 + a
// eg.2
a := 1
b := 1.1 + a
// eg.3
a1 := 1
a2 := 1.1
b := a1 + a2
// eg.4
const b = 3 * 0.333
// eg.5
const a int = 1.0
const b = a * 0.333
// eg.6
const a = 1.0/3
b := &a

要弄清楚上述示例，在了解變量類型推斷之前，最好先了解常量的隱式類型轉(zhuǎn)換。

一、常量的隱式類型轉(zhuǎn)換

1.常量的聲明

未命名常量只在編譯期間存在，不會存儲在內(nèi)存中；而命名常量存在于內(nèi)存靜態(tài)區(qū)，不允許修改。

考慮如下代碼:

const k = 5

5就是未命名常量，而k即為命名常量，當(dāng)編譯后k的值為5，而等號右邊的5不再存在。

常量不允許取址。

const k = 5
addr := &k
// invalid operation: cannot take address of k (untyped int constant 5)

2.常量的類型轉(zhuǎn)換

兼容的類型可以進行隱式轉(zhuǎn)換。例如：

const c int = 123
const c int = 123.0
const c int = 123.1 // cannot use 123.1 (untyped float constant) as int value in constant declaration (truncated)

const c float64 = 123.0
const c float64 = 123

運算中的隱式轉(zhuǎn)換

例如：

const c = 1/2    // 1和2類型相同，無隱式轉(zhuǎn)換發(fā)生
const c = 1/2.0  // 整數(shù)優(yōu)先轉(zhuǎn)換為浮點數(shù)1.0， c的結(jié)果為0.5(float64)
const a int = 1
const c = a * 1.1 // *左邊的a是已定義類型的常量，因此1.1將被轉(zhuǎn)換為int，但浮點數(shù)1.1與整形不兼容，無法進行轉(zhuǎn)換，因此編譯器會報錯
//  (untyped float constant) truncated to int

除位運算、未定義常量外，運算符兩邊的操作數(shù)類型必須相同
如果運算符兩邊是不同類型的未定義常量(untyped constant)，則隱式轉(zhuǎn)換的優(yōu)先級為:
- 整數(shù)(int) <符文數(shù)(rune)<浮點數(shù)(float)<復(fù)數(shù)(Imag)

基于上述說明，前言中的示例4、5、6均可迎刃而解。

3.隱式轉(zhuǎn)換的原理

常量隱式轉(zhuǎn)換的統(tǒng)一在編譯時的類型檢查階段完成。通過defaultlit2函數(shù)進行處理。其中，l和r分別代表運算符左右兩邊的節(jié)點。

// go/src/cmd/compile/internal/typecheck/const.go
func defaultlit2(l ir.Node, r ir.Node, force bool) (ir.Node, ir.Node) {
	if l.Type() == nil || r.Type() == nil {
            return l, r
	}

	if !l.Type().IsInterface() && !r.Type().IsInterface() {
            // Can't mix bool with non-bool, string with non-string.
            if l.Type().IsBoolean() != r.Type().IsBoolean() {
                return l, r
            }
            if l.Type().IsString() != r.Type().IsString() {
                return l, r
            }
	}
	if !l.Type().IsUntyped() {
            r = convlit(r, l.Type())
            return l, r
	}
	if !r.Type().IsUntyped() {
            l = convlit(l, r.Type())
            return l, r
	}
	if !force {
            return l, r
	}
	// Can't mix nil with anything untyped.
	if ir.IsNil(l) || ir.IsNil(r) {
            return l, r
	}
	t := defaultType(mixUntyped(l.Type(), r.Type()))
	l = convlit(l, t)
	r = convlit(r, t)
	return l, r
}

從源代碼中可以看到，如果左右兩邊均不是接口類型，那么：

bool型不能與非bool型進行轉(zhuǎn)換，即

c := true + 12 // 錯誤

string型不能與非string型進行轉(zhuǎn)換, 即

c := "123" + 12 // 錯誤

nil不能與任意未定義類型進行轉(zhuǎn)換，即

c := nil + 12 // 錯誤

如果操作符左邊的節(jié)點有定義類型，則將操作符右邊的節(jié)點轉(zhuǎn)換為左邊節(jié)點的類型，即

const a int = 1
const b int = 1.0
const c = a + 1.0 // 1.0轉(zhuǎn)換為a的類型int
const c = a + b // b的類型已經(jīng)在前面轉(zhuǎn)換為int

如果操作符左邊的節(jié)點為未命名常量，而右邊的節(jié)點有定義類型，則將左邊節(jié)點的類型轉(zhuǎn)換為右邊節(jié)點的類型，即

const a int = 1
const c = 1.0 + a // 1.0轉(zhuǎn)換為a的類型int

綜上所述，可以得出:

任何時候，已定義類型的常量都不會發(fā)生類型轉(zhuǎn)換。換言之，編譯器不允許對變量標(biāo)識符引用的值進行強制類型轉(zhuǎn)換。即無關(guān)優(yōu)先級，下述c=xx代碼中的a、b均不會發(fā)生類型轉(zhuǎn)換，只能是為定義類型的常量1.0轉(zhuǎn)換為a、b的類型。

const a int = 1
const b int = 1.0
const c = a + 1.0
const c = a + b 
const c = 1.0 + b

二、變量的類型推斷

golang使用特殊的操作符":="用于變量的類型推斷，且其只能作用于函數(shù)或方法體內(nèi)部。

操作符":="在《go語言實戰(zhàn)》中有個名字叫“短變量聲明操作符”

初識go語言的人總是會有疑問，下面三個語句有啥差別:

a := 123 
var a = 123
var a int = 123.0

從結(jié)果上來說，上述三個語句是等效的。但編譯階段的執(zhí)行細節(jié)是不同的。

1.類型推斷的原理

編譯器的執(zhí)行過程為：詞法(token)解析->語法(syntax)分析->抽象語法樹(ast)構(gòu)建->類型檢查->生成中間代碼->代碼優(yōu)化->生成機器碼。

類型推斷發(fā)生于前四個階段，即詞法(token)解析->語法(syntax)分析->抽象語法樹(ast)構(gòu)建->類型檢查為例:

在詞法解析階段, 會將賦值語句右邊的常量123解析為一個未定義的類型，稱為未定義常量。編譯器會逐個讀取該常量的UTF-8字符，首個字符為"的則為字符串，首個字符為'0'-'9'的則為數(shù)字, 數(shù)字中包含"."號的則為浮點數(shù)。

// go/src/cmd/compile/internal/syntax/scanner.go
func (s *scanner) next() {
  ...
  switch s.ch {
	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
          s.number(false)

	case '"':
          s.stdString()

	case '`':
          s.rawString()

	case '\'':
          s.rune()
    ...
  }
}

在語法分析階段，會對解析的詞進行具體的語法分析。例如上述s.number(false)就是依次掃描123三個符文(rune)然后按照無小數(shù)點的數(shù)字來做具體分析。

當(dāng)無小數(shù)點符號.時，如果首字符為'0', 則掃描下一位字符，'x'、'o'、'b'分別代表我們寫的代碼表示的是十六進制、八進制及二進制數(shù)字。當(dāng)首字符不是'0'時，每一位字符均作為十進制數(shù)字進行處理。

當(dāng)有小數(shù)點時(seenPoint=true)，每一位字符均作為十進制浮點數(shù)字面類型處理(FloatLit)

// go/src/cmd/compile/internal/syntax/scanner.go
func (s *scanner) number(seenPoint bool) {
  ...
  base := 10        // number base
  ...
  // integer part
  if !seenPoint {
      if s.ch == '0' {
          s.nextch()
          switch lower(s.ch) {
          case 'x':
              s.nextch()
              base, prefix = 16, 'x'
          case 'o':
              s.nextch()
              base, prefix = 8, 'o'
          case 'b':
              s.nextch()
              base, prefix = 2, 'b'
          default:
              base, prefix = 8, '0'
              digsep = 1 // leading 0
          }
      digsep |= s.digits(base, &invalid)
      ...
      }
	...
  }
  // fractional part
  if seenPoint {
          kind = FloatLit
          digsep |= s.digits(base, &invalid)
  }
 ...
}

最后a := 123 整個語句會被解析為一個賦值語句AssignStmt，通過如下結(jié)構(gòu)體進行表示:

// go/src/cmd/compile/internal/syntax/nodes.go
type (
  ...
  AssignStmt struct {
      Op       Operator // 0 means no operation
      Lhs, Rhs Expr     // Rhs == nil means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
      simpleStmt
  }
  ...
)

基于語法分析的結(jié)果，整個代碼結(jié)構(gòu)會被構(gòu)建為一顆抽象語法樹(ast)。抽象語法樹是go編譯器的中間結(jié)果ir(intermediate representation)，賦值語句AssignStmt會被構(gòu)建為ir.AssignStmt，:=符號兩邊的字符被構(gòu)建為節(jié)點ir.Node。

// go/src/cmd/compile/internal/ir/node.go
// An AssignStmt is a simple assignment statement: X = Y.
// If Def is true, the assignment is a :=.
type AssignStmt struct {
  miniStmt
  X   Node
  Def bool
  Y   Node
}
// A Node is the abstract interface to an IR node.
type Node interface {
  ...
  // Source position.
  Pos() src.XPos
  SetPos(x src.XPos)
  ...
  // Fields specific to certain Ops only.
  Type() *types.Type
  SetType(t *types.Type)
  Val() constant.Value
  SetVal(v constant.Value)
  ...
  // Typecheck values:
  //  0 means the node is not typechecked
  //  1 means the node is completely typechecked
  //  2 means typechecking of the node is in progress
  //  3 means the node has its type from types2, but may need transformation
  Typecheck() uint8
  SetTypecheck(x uint8)
}

最后，編譯器會對抽象語法樹的節(jié)點進行類型檢查(typecheck)。檢查的過程中，會將右邊的節(jié)點rhs的類型r.Type()賦值給左邊的節(jié)點lhs，因此最終變量a的類型(Kind)即為123的類型，為整型(types.TINT, go/src/cmd/compile/internal/types/type.go)。

// go/src/cmd/compile/internal/typecheck/stmt.go
// type check assignment.
// if this assignment is the definition of a var on the left side,
// fill in the var's type.
func tcAssign(n *ir.AssignStmt) {
  ...
  lhs, rhs := []ir.Node{n.X}, []ir.Node{n.Y}
  assign(n, lhs, rhs)
  ...
}
func assign(stmt ir.Node, lhs, rhs []ir.Node) {
  ...
  assignType := func(i int, typ *types.Type) {
    checkLHS(i, typ)
    if typ != nil {
      checkassignto(typ, lhs[i])
    }
  }
  ...
  assignType(0, r.Type())
  ...
}

// go/src/cmd/compile/internal/typecheck/typecheck.go
func checkassignto(src *types.Type, dst ir.Node) {
  ...
  if op, why := Assignop(src, dst.Type()); op == ir.OXXX {
      base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
      return
  }
 }

三、類型推斷示例分析

根據(jù)上述原理，再看這三個表達式有何編譯的執(zhí)行過程有何不同：

a := 123 
var a = 123
var a int = 123.0

a := 123 會顯式的觸發(fā)類型推斷，編譯器解析右邊的每一個字符為十進制數(shù)字(IntLit)，然后構(gòu)建為一個整型節(jié)點，在類型檢查的時候，將其類型賦值給左邊的節(jié)點變量a。

由于var a = 123左邊的a未顯式指定其類型，因此仍然會觸發(fā)類型推斷，ir.AssignStmt.Def=false，過程同上，依然在類型檢查的時候，將123的類型賦值給左邊的a。

對于var a int = 123.0，由于123.0包含小數(shù)點'.'，編譯器解析右邊的每一個字符為十進制浮點數(shù)(FloatLit)，由于賦值操作符=左邊顯式定義了a的類型為int, 因此在類型檢查階段，右邊的123.0會發(fā)生隱式類型轉(zhuǎn)換，因為類型兼容，會轉(zhuǎn)換為整型123。因此對于顯式指定類型的表達式不會發(fā)生類型推斷。

同理，結(jié)合類型轉(zhuǎn)換的原理，前言中的示例1、2、3便可迎刃而解。

總結(jié)

常量不允許取址。
運算符兩邊的操作數(shù)類型必須相同。
如果運算符兩邊是不同類型的未定義常量(untyped constant)，則會發(fā)生隱式轉(zhuǎn)換，且轉(zhuǎn)換的優(yōu)先級為:
整數(shù)(int) <符文數(shù)(rune)<浮點數(shù)(float)<復(fù)數(shù)(Imag)。
如果運算符的某一邊是已定義類型常量(變量標(biāo)識符)，則該已定義類型的常量任何時候都不會發(fā)生類型轉(zhuǎn)換。因為編譯器不允許對變量標(biāo)識符引用的值進行強制類型轉(zhuǎn)換。
:=會顯式的觸發(fā)類型推斷，其只能作用于函數(shù)或方法體內(nèi)。
不指定類型的var變量聲明，也會觸發(fā)類型推斷，可聲明于局部也可聲明在全局。
指定類型的var變量聲明，不會觸發(fā)類型推斷(因為類型已經(jīng)顯式指定了)，但有可能發(fā)生類型隱式轉(zhuǎn)換。

到此這篇關(guān)于golang類型推斷與隱式類型轉(zhuǎn)換的文章就介紹到這了,更多相關(guān)golang類型轉(zhuǎn)換內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: