Golang

Golang基础

第一个Go程序

package main

import "fmt"

func main() {
    fmt.Println("Hello, world!")
}
  • package: Go源文件开头必须使用package声明代码所属包,包是Go代码分发的最基本单位,若程序需要运行包名必须为main
  • import: 用于导入程序依赖的所有的包,此程序依赖于fmt包
  • func: 用于定义函数,main函数是程序的入口,若程序需要运行必须声明main函数,main函数无参数也无返回值
  • fmt.Println: 调用fmt.Println函数将参数信息打印到控制台

编译,运行

  • go build: 用于编译,链接程序或包

    • go build -work -x -o hello main.go
  • go run: 用于直接运行程序

    • go run -work -x main.go
  • go clean: 清除编译文件

常用参数

  • -x: 打印编译过程执行的命令,并完成编译或运行
  • -n: 只打印编译过程执行命令
  • -work: 打印编译过程的临时目录
  • -o: 指定编译结果文件

程序结构

  Go源文件以package声明开头,说明源文件所属的包,接着使用import导入依赖的包,其次为包级别的变量,常量,类型和函数的声明与赋值,函数中可定义局部的变量,常量

基本组成元素

标识符

  标识符是编程时所使用的名字,用于给变量,常量,函数,类型,接口,包名等进行命名,以建立名称和使用之间的关系,Go语言标识符的命名规则:

  • 只能由非空字母(Unicode),数字,下划线(_)组成
  • 只能以字母或下划线开头
  • 不能使用Go语言关键字
  • 避免使用Go语言预定义标识符
  • 建议使用驼峰式
  • 标识符区分大小写

  Go语言提供一些预先定义的标识符用来表示内置的常量,类型,函数,在自定义标识符时应避免使用:

  • 内置常量: true, false, nil, iota
  • 内置类型: bool, byte, rune, int, int8, int16, int32, int64, uint, uint8, unit16, unit32, unit64, uintptr, float32, float64, complex64, complex128, string, error
  • 内置函数: make, len, cap, new, append, copy, close, delete, complex, real, imag, panic, recover
  • 空白标识符: _

关键字

  关键字用于特定的语法结构,Go语言定义25关键字:

  • 声明: import, package
  • 实体声明和定义: chan, const, func, interface, map, struct, type, var
  • 流程控制: break, case, continue, default, defer, else, fallthrough, for, go, goto, if, range, return, select, switch

字面量

  字面量是值的表示方法,常用与对变量/常量进行初始化,主要分为:

  • 标识基础数据类型值的字面量,例如: 0, 1.1, true, 3 + 4i, 'a', "我爱中国"
  • 构造自定义的复合数据类型的类型字面量,例如: type Interval int
  • 用于表示符合数据类型值的复合字面量,用来构造array, slice, map, struct的值,例如: {1, 2, 3}

操作符

  • 算术运算符: +, -, *, /, %, ++, --
  • 关系运算符: >, >=, <, <=, ==, !=
  • 逻辑运算符: &&, ||, !
  • 位运算符: &, |, ^, <<, >>, &^
  • 赋值运算符: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
  • 其他运算符: &(单目), *(单目), .(点), -(单目), , <-

分割符

小括号(), 中括号[], 大括号{}, 分号;, 逗号,

声明

  声明语句用于定义程序的各种实体对象,主要有:

  • 声明变量的var
  • 声明常量的const
  • 声明函数的func
  • 声明类型的type

变量

  变量是指对一块存储空间定义名称,通过名称对存储空间的内容进行访问或修改,使用var进行变量声明,常用的语法为:

  • var 变量名 变量类型 = 值

    • 定义变量并进行初始化,例如: var name string = "silence"
  • var 变量名 变量类型

    • 定义变量使用零值进行初始化,例如: var age int
  • var 变量名 = 值

    • 定义变量,变量类型通过值类型进行推导,例如: var isBoy = true
  • var 变量名1, 变量名2 , …, 变量名n 变量类型

    • 定义多个相同类型的变量并使用零值进行初始化,例如: var prefix, suffix string
  • var变量名1, 变量名2 , …, 变量名n 变量类型 = 值1, 值2, …, 值n

    • 定义多个相同类型的变量并使用对应的值进行初始化,例如: var prev, next int = 3, 4
  • var变量名1, 变量名2 , …, 变量名n = 值1, 值2, …, 值n

    • 定义多个变量并使用对应的值进行初始化,变量的类型使用值类型进行推导,类型可不相同,例如: var name, age = "silence", 30
  • 批量定义

    • var (
        变量名1 变量类型1 = 值1
        变量名2 变量类型2 = 值2
      )
    • 定义多个变量并进行初始化,批量复制中变量类型可省略,例如:

      var (
          name string = "silence"
          age int = 30
      )

初始化表达式可以使用字面量, 任何表达式, 函数

  • 变量定义示例
package main

import "fmt"

var v1 int
var v2 int = 10
var v3 = 12
var v4 = "Hello, Golang!"

var v5, v6 = 123, "Python"

var v7, v8 = 14, 34

var (
    v11 = 12
    v12 = "Ruby"
    v13 = v2 + v3
)

func main() {
    v9 := 35
    v10 := "Java"
    fmt.Println(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
}

简短声明

  在函数内可以通过简短声明语句声明并初始化变量,可通过简短声明同时声明和初始化多个变量,需要注意操作符左侧的变量至少有一个未定义过

package main

import "fmt"

func main() {
    v1, v2 := 35, "Hello"
    v3, v4 := "Java", "Golang"
    v5, v6 := 10, 20
    fmt.Println(v1, v2, v3, v4, v5, v6)
}

赋值

  可以通过赋值运算=更新变量的值,Go语言支持通过元组赋值同时更新多个变量的值,例如:

  • n1, n2 = 1, 2, 可用于两个变量的交换x, y = y, x
package main

import "fmt"

func main() {
    n1, n2 := 35, 45
    fmt.Println(n1, n2)
    n1, n2 = n2, n1
    fmt.Println(n1, n2)
}

常量

  常量用于定义不可被修改的的值,需要在编译过程中进行计算,只能为基础的数据类型布尔,数值,字符串,使用const进行常量声明,常用语法:

  • const 常量名 类型 = 值

    • 定义常量并进行初始化,例如: const pi float64 = 3.1415926
  • const 常量名 = 值

    • 定义常量类型通过值类型进行推导,例如: const e = 2.7182818
  • 批量定义

    • const (

      &nbsp;&nbsp;常量名1类型1 = 值1
      &nbsp;&nbsp; 常量名2类型2 = 值2

      )

      定义多个变量并进行初始化,批量赋值中变量类型可省略,并且除了第一个常量之外其他常量可同时省略类型和值,表示使用前一个常量的初始化表达式,例如:

const (
    name string = "silence"
    age int = 30
)
const (
    name string = "silence"
    desc
)

  常量之间的运算,类型转换,以及对常量调用函数len, cap, real, imag, complex, unsafe.Sizeof得到的结果依然为常量

package main

import "fmt"

const c1 int = 100
const c2 = 10 - 1

const c3, c4 int = 20, 30
const c5, c6 = "Golang", c3 + c4

func main() {
    const (
        c7 int = 40
        c8
    )
    fmt.Println(c1, c2, c3, c4, c5, c6, c7, c8)
}

c8的输出结果即为c7的值

作用域

  作用域指变量可以使用范围,go语言使用大括号显示的标识作用域范围,大括号内包含一连串的语句,叫做语句块.语句块可以嵌套,语句块内定义的变量不能在语句块外使用

常见隐式语句块

  • 全语句块
  • 包语句块
  • 文件语句块
  • if, switch, for, select, case语句块

  作用域内定义变量只能被声明一次且变量必须使用,否则编译错误.在不同作用域可定义相同的变量,此时局部将覆盖全局

package main

import "fmt"

func main() {
    outer := 10
    {
        inner := 20
        fmt.Println(outer, inner)
        outer := 30
        fmt.Println(outer, inner)
    }
    fmt.Println(outer)
}

注释

Go支持两种注释方式,行注释和块注释:

  • 行注释: 以//开头,例如: //我是行注释
  • 块注释: 以/*开头,以*/结尾,例如: /*我是块注释*/
package main

import "fmt"

// 这是注释
// 程序入口,main函数
func main() {
    outer := 10
    {
        inner := 20
        fmt.Println(outer, inner)
        outer := 30
        fmt.Println(outer, inner)
    }
    fmt.Println(outer)
}

/*
这是注释块
*/

问题跟踪

  最基本的问题跟踪方式为打印日志,我们可以fmt包中提供的Println,Print,Printf函数用于将信息打印到控制台,帮助我们进行问题调试,基本使用方法:

package main

import "fmt"

func main() {
    var name = "s4lm0x"
    age := 24

    fmt.Println("name=", name, "age=", age)
    fmt.Printf("name=%v, age=%d\n", name, age)
    fmt.Printf("name=%T, age=%T\n", name, age)
}
微信扫一扫,向我赞赏

微信扫一扫,向我赞赏

微信扫一扫,向我赞赏

支付宝扫一扫,向我赞赏

回复

This is just a placeholder img.