Go 基础教程--4-常量与运算符

笔记地址：www.cnblogs.com/ghj1976/archive/20...

常量的定义

1. 常量的值在编译时就已经确定
2. 常量的定义格式与变量基本相同
3. 等号右侧必须是常量或者常量表达式
4. 常量表达式中的函数必须是内置函数

示例1：

package main
import(
    "fmt"
)
const a int = 1
const b = "A"
const (
    c = a
    d = a + 1
    e = 3
)

func main() {
    fmt.Println(a)
    fmt.Println(d)
}

示例2：

package main
import(
    "fmt"
)
const a, b, c = 1,2,'A'
const (
    d,e,f = 1,2,3
)

func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
//1
//2
//65  为什么是65？？

示例3：

在定义常量组时，如果不提供初始值，则表示将使用上行的表达式

package main
import(
    "fmt"
)
const (
    a =1
    b
    c
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
//1
//1
//1

示例4：

等号右侧必须是常量或者常量表达式，不能是运行时才能取得的变量

sss 在编译时不存在

package main
import(
    "fmt"
)
var sss = "123"
const  (
    a = len(sss)
    b
    c
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
// const initializer len(sss) is not a constant
//常量的初始值不是一个常量

调整后

package main
import(
    "fmt"
)
const (
    a = "123"
    b = len(a)
    c
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
//123
//3
//3

错误示范：

const (
    a, b = 1, '2'
    c
)

func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
//extra expression in const declaration
const声明中的额外表达式
在定义常量组时，如果不提供初始值，则表示将使用上行的表达式，但是个数必须一致

正确示范：

const (
    a, b = 1, '2'
    c , d
)

func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
//1
//50
//1

问题：fmt.Println(b)得到的为什么是50呢？

const (
    a, b = 1, "2"
    c , d
)

func main() {
    fmt.Println(b)
}
//2

在Go中单引号和双引号的区别

常量的初始化规则与枚举

1. 在定义常量组时，如果不提供初始值，则表示将使用上行的表达式
2. 使用相同的表达式不代表具有相同的值
3. iota是常量的计数器，从0开始，组中每定义1个常量自动递增1
4. 通过初始化规则与iota可以达到枚举的效果
5. 每遇到一个const关键字，iota就会重置为0

示范1：

iota是常量的计数器，从0开始，组中每定义1个常量自动递增1

const (
    a = "A"
    b
    c = iota
    d = 'A'
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}
//A
//A
//2 计数器从0开始，每定义一次变量就加一，这里是第三次调用，是2
//65 单引号和双引号的区别

示例2：

const (
    a = "A"
    b
    c = iota
    d = 'A'
)

const (
    e
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}
// missing value in const declaration
变量没有定义，因为没有上一行

运算符

==Go中的运算符均是从左至右结合==

==优先级（从高到低）==

^      !                                           （一元运算符）
*       /    %    <<    >>    &      &^
+      -     |      ^                              （二元运算符）
==   !=   <    <=    >=    >
<-                                                 （专门用于channel）
&&
||

示范1：

1 << 10 
1左移10位， = 1024
0000 0001

与或非等

  6 : 0110
  10: 1011
&     0010 两个都为1才是1
|     1111 有一个是1就为1
^     1101 不同的时候才为1

&^    0100  如果在第二个数上的一位上面是1，就要把第一个数上的一位强制改为0

示例3：&&

func main() {
    a := 0
    if  a > 0 && (10/a) > 1 {
        fmt.Println("ok")
    }
}
&&的作用：
a>0 成立才执行后面的，不成立就不执行

作业

请尝试结合常量的iota与<<运算符实现计算机储存单位的枚举

package main

import "fmt"
const (
    B float64 = 1 << (iota * 10)
    KB
    MB
    GB
)
func main() {
    fmt.Println(GB)
}
//1.073741824e+09

本作品采用《CC 协议》，转载必须注明作者和本文链接