Golang基础语法

一、各种符号

1、转义字符

以下是常用的转义字符(escape char)

\t   :一个制表位，实现对齐功能
\n   :换行符
\\   :代表一个\
\"   :代表一个"，注意不是单引号，Go里面没有 \' 这个转义字符
\r   :代表回车，用 \r 后面的字符替换前面的字符，如：fmt.Println("你好\r我"),实际上输出：我好

2、占位符(字符串格式化输出)

%b: 代表二进制整数
%c：代表根据unicode编码数字来打印对应的字符
%d：代表十进制整数
%o: 代表八进制整数
%x: 代表十六进制，对应a~f
%X: 代表十六进制，对应A~F
%f：代表浮点数据类型，默认显示6位小数
%.2f: 代表浮点数据类型，2代表数出两位小数
%s：代表字符串类型
%p：代表内存地址
%t: 代表布尔类型
%T：代表数据变量的数据类型

3、运算符

算术运算符

赋值运算符

 关系运算符

逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。

 位运算符

位运算符对整数在内存中的二进制位进行操作。

下表列出了位运算符 &, |, 和 ^ 的计算：

 其他运算符

 运算符优先级

下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

然后可以用()来改变优先级

二、关键字

1、关键字

2、其他标识符

三、基本数据类型

1、布尔类型：bool

取值：true、false

2、数字类型：

整数

类型	描述
int	与 uint 一样大小，32 或 64 位
int8	有符号 8 位整型 (-128 到 127)
int16	有符号 16 位整型 (-32768 到 32767)
int32	有符号 32 位整型 (-2147483648 到 2147483647)
int64	有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
uint	32 或 64 位
uint8	无符号 8 位整型 (0 到 255)
uint16	无符号 16 位整型 (0 到 65535)
uint32	无符号 32 位整型 (0 到 4294967295)
uint64	无符号 64 位整型 (0 到 18446744073709551615)

浮点数

类型	描述
float32	IEEE-754 32位浮点型数
float64	IEEE-754 64位浮点型数

复数

类型	描述
complex64	32 位实数和虚数
complex128	64 位实数和虚数

其他数字类型

类型	描述
byte	类似 uint8，是uint8的别称
rune	类似 int32，是uint32的别称
uintptr	无符号整型，用于存放一个指针

3、字符串：string

四、变量与常量

1、变量

概念：实质上是一小块内存，用于存数数据，在程序运行过程中数值可以改变

使用：

        1）变量的声明，也叫定义

        2）变量的访问，赋值和取值

注意事项：

        1）变量必须先声明才能使用

        2）go语言是静态语言，要求变量的类型和赋值的类型必须一致

        3）变量名不能冲突（同一个作用域内不能冲突）

        4）简短声明方式不能定义全局变量，且 := 的左边的变量名至少要有一个是新的

        5）变量声明后未赋值，会赋予默认值

        6）变量定义了就要使用，否则无法通过编译

func main() {
    // 第一种：声明变量，然后进行赋值
    var num1 int
    num1 = 20
    fmt.Printf("num1的数值是：%d", num1)
    // 声明并赋值写在同一行
    var num2 int = 15
    fmt.Printf("num2的数值是：%d", num2)
    // 第二种：类型推断，定义时不写类型
    var num3 = "24"  // 双引号是string类型
    var num4 = 'A'   // 单引号是int32类型
    fmt.Printf("num3的数据类型是：%T, 数值是%s\n", num3, num3)
    fmt.Printf("num4的数据类型是：%T, 数值是%d\n", num4, num4)
    // 第三种：简短声明，省略var关键字
    // 这种声明方式只能用在函数内部，而不可以用来声明全局变量
    num5 := 3.14
    fmt.Printf("num5的数据类型是：%T, 数值是%f\n", num5, num5)  // %f默认显示6位小数
    fmt.Printf("num5的数据类型是：%T, 数值是%.2f\n", num5, num5)  // %.2f显示2位小数

    // 多个变量同时声明，然后赋值
    var a, b, c int
    a = 1
    b = 2
    c = 3
    fmt.Println(a, b, c)
    // 多个变量在同一行声明并赋值
    var n1, f1, s1 = 100, 3.14, "Go"
    fmt.Println(n1, f1, s1)
    // 多个变量用括号括起来声明
    var (
        studentName = "梁子涵"
        sex = "女"
        age = 18
    )
    fmt.Printf("学生姓名：%s，性别：%s，年龄：%d，内存地址%p\n", studentName, sex, age, &age)
}

2、常量

概念：实质上是一个值的标识符；在程序运行时，其值不会被修改

const identifier [type] = value

使用：如下代码所示

注意事项：

        1）常量中的数据类型只能是布尔型、数字型（整型、浮点型、复数）和字符串型

        2）定义后的常量不被使用，在编译时不会报错

        3）显式指定类型时，必须确保 = 号左右的值类型一致，需要时可做显示类型转换。

func main() {
    // 1、声明常量
    // 显式声明常量
    const PATH string = "www.baidu.com"
    // 隐式声明常量
    const PI = 3.14

    // 2、常量的值在定义后不可修改
    // PATH = "www.sina.com"  //保错：cannot assign to PATH

    // 3、定义一组常量
    const C1, C2, C3 = 100, 3.14, "haha"
    const (
        MALE = 0
        FEMALE = 2
    )
    // 4、一组常量中，如果某个常量没赋初始值，默认和上一行的一致
    const (
        A int = 100
        B                   // B的值为100
        C string = "ruby"
        D                   // D的值为ruby
    )
    // 5、枚举类型：使用常量组作为枚举类型，表示一组相关数值的数据
    const (
    SPRING = 0
    SUMMER = 1
    AUTUMN = 2
    WINTER = 3
    )
}

特殊常量：iota关键字

iota：特殊常量，可以认为是一个可以被编译器修改的常量。

func main() {
    // iota可以被用作枚举值
    const (
        L = iota
        M = iota
        N = iota
    )
}

func main() {
    const (
        // 第一个iota等于0，每当iota在新的一行被使用时，其值都会自动加1
        A = iota    // A和iota的值为0
        B           // B和iota的值为1
        C = "HAHA"  // iota的值为2
        D           // D和iota的值为3
        E = 100     // iota的值为4
        F           // F和iota的值为5
        G = iota    // G和iota的值为6
        H           // H和iota的值为7
    )
    const (
        I = iota    // H和iota的值为0；因为在另外一组常量中，iota会重新置0
    )
}