1. 整型

1.1 有符号整型

  • int：根据系统架构，通常为32或64位
  • int8：8位有符号整型（范围：-128 到 127）
  • int16：16位有符号整型（范围：-32768 到 32767）
  • int32：32位有符号整型（范围：-2147483648 到 2147483647）
  • int64：64位有符号整型（范围：-9223372036854775808 到 9223372036854775807）

1.2 无符号整型

  • uint：根据系统架构，通常为32或64位
  • uint8：8位无符号整型（范围：0 到 255）
  • uint16：16位无符号整型（范围：0 到 65535）
  • uint32：32位无符号整型（范围：0 到 4294967295）
  • uint64：64位无符号整型（范围：0 到 18446744073709551615）

1.3 特殊整型

  • byte：等同于uint8
  • rune：等同于int32，表示一个Unicode码点
package main

import "fmt"

func main() {
    var a int = 42
    var b int8 = -128
    var c uint16 = 65535
    var d byte = 255
    var e rune = '你' // Unicode码点

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
    fmt.Println(e)
}

2. 浮点型

  • float32：32位浮点数（IEEE-754标准）
  • float64：64位浮点数（IEEE-754标准）
package main

import "fmt"

func main() {
    var f1 float32 = 3.14
    var f2 float64 = 2.718281828

    fmt.Println(f1)
    fmt.Println(f2)
}

3. 复数类型

  • complex64：实部和虚部都是float32
  • complex128：实部和虚部都是float64
package main

import "fmt"

func main() {
    var c1 complex64 = 1 + 2i
    var c2 complex128 = 2 + 3i

    fmt.Println(c1)
    fmt.Println(c2)
}

4. 布尔型

布尔类型用于表示真值（true）和假值（false）。

package main

import "fmt"

func main() {
    var isTrue bool = true
    var isFalse bool = false

    fmt.Println(isTrue)
    fmt.Println(isFalse)
}

5. 字符串

字符串类型用于表示文本，由一串字符组成。

package main

import "fmt"

func main() {
    var str1 string = "Hello, Go!"
    var str2 string = `This is a raw string
literal which can span
multiple lines.`

    fmt.Println(str1)
    fmt.Println(str2)
}

字符串是不可变的，可以使用索引访问字符，但不能修改字符串内容。

package main

import "fmt"

func main() {
    var str string = "Hello"
    fmt.Println(str[1]) // 输出字符'e'的ASCII码

    // str[1] = 'a' // 这是非法操作，因为字符串是不可变的
}

6. 类型转换

Go是强类型语言，类型转换需要显式进行。

package main

import "fmt"

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

    fmt.Println(i)
    fmt.Println(f)
    fmt.Println(u)
}

7. 常量

常量使用const关键字声明。

package main

import "fmt"

const Pi = 3.14159
const Greeting = "Hello, World!"

func main() {
    fmt.Println(Pi)
    fmt.Println(Greeting)
}

常量可以是字符、字符串、布尔值或数值类型，且只能在编译时确定其值。

示例代码

以下是一个完整的示例，展示了各种基本数据类型的使用：

package main

import "fmt"

func main() {
    // 整型
    var i int = 42
    var j int8 = -128
    var k uint16 = 65535

    // 浮点型
    var f1 float32 = 3.14
    var f2 float64 = 2.718281828

    // 复数
    var c1 complex64 = 1 + 2i
    var c2 complex128 = 2 + 3i

    // 布尔型
    var b1 bool = true
    var b2 bool = false

    // 字符串
    var s1 string = "Hello, Go!"
    var s2 string = `This is a raw string
literal which can span
multiple lines.`

    // 类型转换
    var x int = 42
    var y float64 = float64(x)
    var z uint = uint(y)

    // 常量
    const Pi = 3.14159
    const Greeting = "Hello, World!"

    fmt.Println(i, j, k)
    fmt.Println(f1, f2)
    fmt.Println(c1, c2)
    fmt.Println(b1, b2)
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(x, y, z)
    fmt.Println(Pi)
    fmt.Println(Greeting)
}

版权声明：如无特殊说明，文章均为本站原创，转载请注明出处

本文链接：http://example.com/subject/article/89/

许可协议：署名-非商业性使用 4.0 国际许可协议