Go语言入门01—开发环境、数据类型、运算符

头像
CodeJR
     湖北
    阅读 7 分钟
    头图

    1 开发环境、基本语法

    1.1 go语言开发包

    下载地址：https://go.dev/dl/

    进入官网选择对应的版本和系统下载并安装即可。

    1.2 编辑器

    GoLand：https://www.jetbrains.com/go/

    1.2.1 新建项目

    image.png

    1.2.2 HelloWorld

    image.png

    通过以上步骤能够正确打印出hello world程序则表示go开发环境搭建成功。

    1.2 Go基本语法

    package main

import "fmt"

func main() {
  fmt.Println("hello world")
}

    代码解析：

    1. package main：通过package关键字指定包名，在go文件中，必须要在代码一行指定当前文件属于哪个包名，包名可以自定义，但是一个go语言程序中必须有一个main包。
    2. import "fmt"：导入fmt包，导入之后在该文件中即可使用fmt包中的函数，fmt包中主要有格式化IO输入输出函数。
    3. func main()：main函数，一个go语言程序中必须包含一个main主函数，该函数是程序运行时执行的第一个函数（如果有init函数则第一个执行init函数）。
    4. fmt.Println("hello world")：调用fmt包中的打印函数Println，该函数可将其中的字符串打印到控制台上，并且在打印完成之后换行。

    2 数据类型

    2.1 常见基本数据类型

    • uint8：无符号8位整形，取值范围：0-255
    • uint16：无符号16位整形，取值范围：0-65535
    • uint32：无符号32位整形，取值范围：0-4294967295
    • uint64：无符号64位整形，取值范围：0-18446744073709551615
    • uint：32 或 64 位
    • int8：有符号8位整形，取值范围：-128-127
    • int16：有符号16位整形，取值范围：-32768-32767
    • int32：有符号32位整形，取值范围：-2147483648-2147483647
    • int64：有符号64位整形，取值范围：-9223372036854775808-9223372036854775807
    • int：与uint一样大小
    • byte：类似 uint8
    • rune：类似 int32
    • float32：32位浮点类型
    • float64：64位浮点类型
    • string：字符串
    • bool：布尔类型，取值true或false

    2.2 变量

    Go 语言变量名由字母、数字、下划线组成，首字符不能为数字，不能使用关键字作为变量名。

    Go语言中的25个关键字：

    image.png

    2.2.1 使用关键字var，并指定变量类型

    // 声明单个变量
var 变量名 变量类型
// 声明多个变量
var 变量名1, 变量名2 变量类型

    初始化变量

    // 声明并初始化单个变量
var 变量名 变量类型 = 值
// 声明并初始化多个变量
var 变量名1, 变量名2 变量类型 = 值1, 值2

    示例1，当只声明不初始化变量时，则输出默认值，int类型默认值为0，string默认值为""空字符串，bool类型默认false

    package main

import "fmt"

func main() {
  var s string
  fmt.Println(s)            // 输出
  var a, b int
  fmt.Println(a, b)          // 输出0 0
}

    示例2：声明并初始化变量

    package main

import "fmt"

func main() {
  var s string = "hello world"
  fmt.Println(s)            // 输出hello world
  var a, b int = 1, 2
  fmt.Println(a, b)          // 输出1 2
}

    2.2.2 使用关键字var，不指定类型

    var 变量名 = 值

    示例：

    package main

import "fmt"

func main() {
  var s = "hello world"
  fmt.Println(s)        // 输出hello world
  var a, b = 1, 2
  fmt.Println(a, b)      // 输出1 2
}

    2.2.3 使用:=

    变量名 := 值

    示例：

    package main

import "fmt"

func main() {
  s := "hello world"
  fmt.Println(s)        // 输出hello world
  a, b := 1, 2
  fmt.Println(a, b)      // 输出1 2
}

    使用该方法，如果某个变量在之前已经使用var的方式进行了声明，再使用:=方式会出现编译错误，但是可以使用=进行复制不会报错。

    2.2.4 多变量声明

    该方法声明变量多用于声明全局变量

    var(
    变量名1 变量类型 = 值1    // 同样可以不指定变量类型，使用 变量名 = 值 的形式，但是不能使用 := 
    变量名2 变量类型 = 值2
)

    示例：

    package main

import "fmt"

var (
  s string = "hello world"
  a int = 1
  b int = 2
)

func main() {
  fmt.Println(s)        // 输出hello world
  fmt.Println(a, b)      // 输出1 2
}

    2.2.5 变量注意事项

    1. 在GO语言中，如果声明了一个变量，就必须使用，如果变量声明了但是不使用就会报错。
    2. 全局变量可以只声明不使用不会报错。

    2.3 常量

    常量就是不会改变的值，一般用于用于在程序运行期间不会被改变的值，常量和变量的声明类似，只是将var关键字变成了const。与变量不同的是，常量在声明的时候必须赋值。

    2.3.1 使用const定义常量

    示例：

    package main

import "fmt"

// 多常量声明
const (
  s = "hello world"
  a = 1
)

func main() {
  const PI = 3.1415              // 不指定常量类型
  const E float32 = 2.7182      // 指定常量类型
  fmt.Println(s)                // 输出hello world
  fmt.Println(a)                // 输出1
  fmt.Println(PI)                // 输出3.14
  fmt.Println(E)                // 输出2.7182
}

    2.3.2 iota

    iota是Go语言中的常量计数器，只能在常量的表达式中使用，iota在const出现时被初始化为0，在const中每增加一个常量定义，则iota加1。

    示例：

    package main

import "fmt"

// 多常量声明
const (
  a = 1          // iota = 0
  b = 2          // iota = 1
  c = iota        // iota = 2
)

func main() {
  const d = iota      // iota = 0
  fmt.Println(d)      // 输出0
  fmt.Println(c)      // 输出2
}

    3 运算符

    3.1 算术运算符

    假设a为3，b为2

    运算符描述示例
    +加法运算符a + b = 5
    -减法运算符a - b = 1
    *乘法运算符a * b = 6
    /除法运算符a / b = 1
    %取余运算符a % b = 1
    ++自增运算符a++ = 4
    --自减运算符b-- = 1

    代码示例：

    package main

import "fmt"

func main() {
  a := 3
  b := 2
  fmt.Println("a + b = ", a + b)
  fmt.Println("a - b = ", a - b)
  fmt.Println("a * b = ", a * b)
  fmt.Println("a / b = ", a / b)
  fmt.Println("a % b = ", a % b)
  a++
  b--
  fmt.Println("a ++ = ", a)
  fmt.Println("b -- = ", b)
}

    运行结果：

    image.png

    3.2 关系运算符

    假设a为3，b为2

    运算符描述示例
    ==判断两个值是否相等，如果相等返回true，否则返回falsea == b 为 false
    !=判断两个值是否不相等，如果不相等返回true 否则返回falsea != b 为 true
    >判断左边值是否大于右边值，如果是返回true 否则返回falsea > b 为 true
    <判断左边值是否小于右边值，如果是返回true 否则返回falsea < b 为 false
    >=判断左边值是否大于等于右边值，如果是返回true 否则返回falsea >= b 为 true
    <=判断左边值是否小于等于右边值，如果是返回true 否则返回false。a <= b 为 false

    代码示例：

    package main

import "fmt"

func main() {
  a := 3
  b := 2
  fmt.Println("a == b : ", a == b)
  fmt.Println("a != b : ", a != b)
  fmt.Println("a > b : ", a > b)
  fmt.Println("a < b : ", a < b)
  fmt.Println("a >= b : ", a >= b)
  fmt.Println("a <= b : ", a <= b)
}

    运行结果：

    image.png

    3.3 逻辑运算符

    假设a为true，b为false

    运算符描述实例
    &&逻辑与运算符，如果两边都为true，则为true，否则为falsea && b 为 false
    ||逻辑或运算符，如果两边有一边为true，则为true，否则为falsea || b 为 true
    !逻辑非运算符，如果为true，返回false，如果为false，返回true!a 为 false， !b 为true

    代码示例：

    package main

import "fmt"

func main() {
  a := true
  b := false
  fmt.Println("a && b : ", a && b)
  fmt.Println("a || b : ", a || b)
  fmt.Println("!a : ", !a)
  fmt.Println("!b : ", !b)
}

    运行结果：

    image.png

    注意：逻辑运算符通常用于在if条件中做判断使用，并且逻辑运算符可以与关系运算符结合使用，例如 a > b && b > c，当a 大于 b，并且b 大于 c 时则为true，否则为false。

    3.4 位运算符

    位运算符是对整数的二进制进行计算

    假设a为3，b为2

    则a转为二进制为：0011，b的二进制为：0010

    a & b的计算方式步骤：
第一步：将a和b转为二进制
a = 0011    b = 0010
第二步：将转为二进制的两个数进行按位与运算
按位与运算规则：对应的两位数都为1则结果为1，计算结果如下
a:   0011
b:   0010
&   ------
结果：0010
    运算符描述实例
    &按位与运算符，将两边的整数作为二进制进行按位与运算，两位都为1则为1a & b = 2，二进制为0010
    |按位或运算符，将两边的整数作为二进制进行按位或运算，两位其中一个为1，则为1a | b = 3，二进制为0011
    ^异或运算符，将两边的整数作为二进制进行按位或运算，两位不相同则为1a ^ b = 1，二进制为0001
    <<左移运算符，将左边的数转为二进制后向左位移右边指定的位数，左移n位就是乘以2的n次方a << 2 结果为12 ，二进制为 1100
    >>右移运算符，将左边的数转为二进制后向右位移右边指定的位数，右移n位就是除以2的n次方a >> 2 结果为0 ，二进制为 0000

    示例代码：

    package main

import "fmt"

func main() {
  a := 3
  b := 2
  fmt.Println("a & b = ", a & b)
  fmt.Println("a | b = ", a | b)
  fmt.Println("a ^ b = ", a ^ b)
  fmt.Println("a << 2 = ", a << 2)
  fmt.Println("a >> 2 = ", a >> 2)
}

    运行结果：

    image.png

    3.5 赋值运算符

    运算符描述实例
    =赋值运算符，将右边表达式的值赋值给左边变量c = a + b => 表达式 a + b的结果赋值给变量c
    +=相加后再赋值a += b => a = a + b
    -=相减后再赋值a -= b => a = a - b
    *=相乘后再赋值a = b => a = a b
    /=相除后再赋值a /= b => a = a / b
    %=求余后再赋值a %= b => a = a % b
    <<=左移后赋值a <<= 2 => a = a << 2
    >>=右移后赋值a >>= 2 => a = a >> 2
    &=按位与后赋值a &= 2 => a = a & 2
    ^=按位异或后赋值a ^= 2 => a = a ^ 2
    |=按位或后赋值a |= 2 = > a = a | 2

    代码示例：

    package main

import "fmt"

func main() {
  a := 3
  b := 2
  var c int
  c = a + b
  fmt.Println("c = ", c)
  a += b
  fmt.Println("a = ", a)
  a -= b
  fmt.Println("a = ", a)
  a *= b
  fmt.Println("a = ", a)
  a /= b
  fmt.Println("a = ", a)
}

    运行结果：

    image.png

    3.6 运算符优先级

    由上到下代表优先级从高到低，相同优先级的运算符在计算的过程中按照从左往右依次计算，同时还可以临时使用小括号提高优先级。

    优先级运算符
    5* / % << >> & &^
    4+ -
    3== != < <= > >=
    2&&
    1||

    代码示例：

    package main

import "fmt"

func main() {
  a := 20
  b := 10
  c := 15
  d := 5
  fmt.Println("(a + b) * c / d = ", ( a + b ) * c / d)
  fmt.Println("((a + b) * c) / d = ", (( a + b) * c) / d)
  fmt.Println("(a + b) * (c / d) = ", (a + b) * (c / d))
  fmt.Println("a + (b * c) / d = ", a + (b * c) / d)
}

    运行结果：
    image.png

    本文参与了SegmentFault 思否写作挑战赛活动，欢迎正在阅读的你也加入。
    challengego后端
    CodeJR
    12 声望0 粉丝
    下一篇 »
    Go语言入门02—条件和循环

    引用和评论

    推荐阅读
    头像
    浅谈Java虚拟机（JVM）

    CodeJR阅读 669

    头像
    在Java程序中监听mysql的binlog

    huan1993赞 11阅读 2k

    头像
    2023 re:Invent 用 Amazon Q 打造你的知识库

    robin赞 8阅读 24.5k评论 13

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 5阅读 1.7k

    头像
    Go 语言-计算密集型服务 性能优化

    Jesse赞 4阅读 5.3k

    头像
    IO 密集型服务 耗时优化

    Jesse赞 4阅读 4.4k

    头像
    Go 语言 JSON 与 Cache 库 调研与选型

    Jesse赞 2阅读 4.2k

    0 条评论
    得票最新