【GO基础】GO基础语法一

package main //包,表名代码所在的模块(包)

import "fmt" //引入代码依赖

//功能实现
func main(){
    fmt.Println("Hello,World!")

}

func main~~(arg []string)~~

package test

import (
    "log"
    "testing"
)

func TestFirstTry(T *testing.T){

    log.Print("My first try!")
}

package fib

import (
  "testing"
)

// TestFibList 是测试斐波那契数列生成函数的单元测试函数
func TestFibList(t *testing.T) {
  var a int = 1
  var b int = 1

  // 另一种变量声明方式：
  // var (
  //     a int = 1
  //     b     = 1
  // )

  // 或者使用短变量声明方式：
  // a := 1
  // b := 1

  // 输出变量 a 的值
  t.Log(a)

  // 循环生成斐波那契数列的前5个数并输出
  for i := 0; i < 5; i++ {
    // 输出变量 b 的值
    t.Log(b)

    // 交换 a 和 b 的值，生成下一个斐波那契数
    tmp := a
    a = b
    b = tmp + a
  }
}

package fib

import (
  "testing"
)

// TestExChange 是测试变量交换函数的单元测试函数
func TestExChange(t *testing.T) {
  // 初始化两个变量 a 和 b 的值
  a := 1
  b := 2

    //temp :=a  
  //a=b
  //b=temp

  // 使用短变量声明方式，同时交换 a 和 b 的值
  // 在 Go 中，可以通过这种方式轻松地实现两个变量的值交换
  a, b = b, a

  // 输出交换后的变量值
  t.Log(a, b)
}

package constan_test

import "testing"

// 第一个常量组，使用 iota 枚举星期几
const (
  Monday    = iota + 1
  Tuesday
  Wednesday
)

// 第二个常量组，使用 iota 创建一组表示文件权限的常量
const (
  Readable  = 1 << iota // 位运算左移，表示可读
  Writable              // 位运算左移，表示可写
  Executable            // 位运算左移，表示可执行
)

// TestConstanTry 是测试星期几常量的单元测试函数
func TestConstanTry(t *testing.T) {
  // 输出星期几的常量值
  t.Log("星期一：", Monday)
  t.Log("星期二：", Tuesday)
  t.Log("星期三：", Wednesday)
}

// TestConstanTry1 是测试文件权限常量的单元测试函数
func TestConstanTry1(t *testing.T) {
  //a:=7 // 二进制表示为 0111 TRUE TRUE  TRUE 
  a := 1 // 二进制表示为 0001 true false false

  // 使用位运算检查文件权限
  t.Log("可读：", a&Readable == Readable) 
  t.Log("可写：", a&Writable == Writable)
  t.Log("可执行：", a&Executable == Executable)
}

package math_constants

import (
    "fmt"
    "math"
)

func ExampleMaxInt64() {
    // 输出 int64 类型的最大值
    fmt.Printf("int64 类型的最大值：%d\n", math.MaxInt64)
}
func ExampleMaxFloat64() {
  // 输出 float64 类型的最大值
  fmt.Printf("float64 类型的最大值：%f\n", math.MaxFloat64)
}
func ExampleMaxUint32() {
  // 输出 uint32 类型的最大值
  fmt.Printf("uint32 类型的最大值：%d\n", math.MaxUint32)
}

func main() {
    ExampleMaxInt64()
    ExampleMaxFloat64()
    ExampleMaxUint32()
}

package pointer_test

import "testing"

// TestPointerArithmetic 是测试指针运算的单元测试函数
func TestPointerArithmetic(t *testing.T) {
  // 定义一个整数变量 x，并赋值为 10
  x := 10

  // 定义一个指向整数的指针变量 p，指向 x 的内存地址
  p := &x

  // 尝试进行指针运算（不允许的操作），这将导致编译错误
  // p = p + 1  // 这行代码会导致编译错误

  // 输出 x 的值和指针变量 p 的值
  t.Logf("x 的值：%d，指针变量 p 的值：%p", x, p)
}

package string_test

import "testing"

// TestStringInitialization 是测试 string 初始化的单元测试函数
func TestStringInitialization(t *testing.T) {
    // 声明一个字符串变量 s，其默认初始化值为空字符串
    var s string

    // 输出字符串变量 s 的值
    t.Logf("字符串变量 s 的值：%q", s)
}

package arithmetic_operators

import "fmt"

func main() {
  // 定义两个整数变量
  a := 10
  b := 5

  // 加法
  sum := a + b
  fmt.Printf("加法结果：%d\n", sum)

  // 减法
  difference := a - b
  fmt.Printf("减法结果：%d\n", difference)

  // 乘法
  product := a * b
  fmt.Printf("乘法结果：%d\n", product)

  // 除法
  quotient := a / b
  fmt.Printf("除法结果：%d\n", quotient)

  // 求余
  remainder := a % b
  fmt.Printf("求余结果：%d\n", remainder)

  // 自增
  a++
  fmt.Printf("自增后的值：%d\n", a)

  // 自减
  b--
  fmt.Printf("自减后的值：%d\n", b)
}

package test

import (
  "fmt"
  "testing"
)

func TestArrayComparison(t *testing.T) {
  // 定义两个数组
  array1 := [3]int{1, 2, 3}
  array2 := [3]int{1, 2, 3}
  array3 := [3]int{4, 5, 6}

  // 使用 == 比较数组
  equal1 := array1 == array2
  equal2 := array1 == array3

  // 输出比较结果
  fmt.Printf("array1 是否等于 array2：%t\n", equal1)
  fmt.Printf("array1 是否等于 array3：%t\n", equal2)
}

func TestLogical(t *testing.T) {
  // 定义两个布尔变量
  isTrue := true
  isFalse := false

  // 逻辑与
  andResult := isTrue && isFalse
  fmt.Printf("逻辑与结果：%t\n", andResult)

  // 逻辑或
  orResult := isTrue || isFalse
  fmt.Printf("逻辑或结果：%t\n", orResult)

  // 逻辑非
  notResult := !isTrue
  fmt.Printf("逻辑非结果：%t\n", notResult)
}

func TestBitwiseClear(t *testing.T) {
  // 定义两个整数变量
  a := 5    // 二进制: 0101
  b := 3    // 二进制: 0011

  // 使用 &^ 按位清零
  result := a &^ b

  // 输出结果
  fmt.Printf("a &^ b 按位清零结果：%d\n", result) // 0100 (4)
}

  // 基本的 for 循环
  for i := 1; i <= 5; i++ {
    fmt.Println(i)
  }

func TestFor(t *testing.T) {
  // 使用 for range 遍历数组
  numbers := []int{1, 2, 3, 4, 5}
  for index, value := range numbers {
    fmt.Printf("索引：%d，值：%d\n", index, value)
  }

  // 使用 for range 遍历字符串
  message := "Hello, Go!"
  for index, char := range message {
    fmt.Printf("索引：%d，字符：%c\n", index, char)
  }
}

func TestFor01(t *testing.T) {
  // 模拟 while 循环
  counter := 1
  for counter <= 5 {
    fmt.Println(counter)
    counter++
  }
}

func TestFor02(t *testing.T) {
    // 无限循环
    counter := 0
    for {
        fmt.Println("无限循环")
        counter++

        if counter == 3 {
            break // 终止循环
        }
    }
}

// 基本的 if 语句
x := 10

if x > 5 {
    fmt.Println("x 大于 5")
} else {
    fmt.Println("x 不大于 5")
}

// if 语句的条件包含初始化语句
  if x := 10; x > 5 {
    fmt.Println("x 大于 5")
  } else {
    fmt.Println("x 不大于 5")
  }
  

  // 多个 if 语句的嵌套
  x := 10

  if x > 5 {
    fmt.Println("x 大于 5")

    if x > 8 {
      fmt.Println("x 大于 8")
    }
  } else {
    fmt.Println("x 不大于 5")
  }

func TestSwitch(t *testing.T) {
  var x interface{} = "hello"

  switch x.(type) {
  case int:
    fmt.Println("x 是一个整数")
  case string:
    fmt.Println("x 是一个字符串")
  default:
    fmt.Println("未知类型")
  }

}

func TestSwitch2(t *testing.T) {
  num := 2

  switch num {
  case 1, 2:
    fmt.Println("数字是1或2")
  case 3:
    fmt.Println("数字是3")
  default:
    fmt.Println("未知数字")
  }

}

func TestSwitch3(t *testing.T) {
  day := "Monday"
  switch day {
  case "Monday":
    fmt.Println("星期一")
  case "Tuesday":
    fmt.Println("星期二")
  default:
    fmt.Println("其他日子")
  }
}

func TestSwitch4(t *testing.T) {
  num := 2

  switch {
  case num > 5:
    fmt.Println("数字大于5")
  case num > 0:
    fmt.Println("数字大于0")
  default:
    fmt.Println("未知数字")
  }
}