GO-变量、常量以及与其他语言的差异01

待我称王封你为后i 2024-04-08 09:19 79阅读 0赞

编写测试程序

1.源码文件以_ test结尾: xxx test. go
2.测试方法名以Test开头: func TestXXX(t *testing.T) …}

  1. package try_test
  2. import "testing"
  3. func TestName(t *testing.T) {
  4. t.Log("My first try")
  5. }

实现Fibonacci数列

1,1,2,3,5,8,13,

  1. package fib
  2. import (
  3. "fmt"
  4. "testing"
  5. )
  6. func TestFibList(t *testing.T) {
  7. //var a = 1;
  8. //var b = 1;
  9. var (
  10. a int = 1;
  11. //b int = 1;
  12. b = 1; // 俩个类型放一起,go有类型推断能力
  13. )
  14. /*a := 1
  15. b := 1*/ // 这样声明也ok
  16. fmt.Print(a)
  17. for i := 0; i < 5; i++ {
  18. fmt.Print(" ", b)
  19. tmp := a
  20. a = b
  21. b = tmp + a
  22. }
  23. fmt.Println()
  24. }
  25. package fib
  26. import (
  27. "testing"
  28. )
  29. func TestFibList(t *testing.T) {
  30. //var a = 1;
  31. //var b = 1;
  32. var (
  33. a int = 1;
  34. //b int = 1;
  35. b = 1; // 俩个类型放一起,go有类型推断能力
  36. )
  37. /*a := 1
  38. b := 1*/ // 这样声明也ok
  39. //fmt.Print(a)
  40. t.Log(a)
  41. for i := 0; i < 5; i++ {
  42. //fmt.Print(" ", b)
  43. t.Log(b)
  44. tmp := a
  45. a = b
  46. b = tmp + a
  47. }
  48. //fmt.Println()
  49. }

变量赋值

与其他主要编程语言的差异

  • 赋值可以进行自动类型推断
  • 在一个赋值语句中可以对多个变量进行同时赋值

    // 交换值2种写法
    func TestExchange(t *testing.T) {

    a:=1
    b:=2
    //tmp:=a
    //a=b
    //b=tmp
    a,b=b,a
    t.Log(a, b)
    }

常量定义

在这里插入图片描述

  1. package constant_test
  2. import "testing"
  3. const (
  4. Monday = 1 + iota
  5. Tuesday
  6. Wednesday
  7. )
  8. func TestConstantTry(t *testing.T) {
  9. t.Log(Monday, Tuesday, Wednesday)
  10. }

Result:

  1. === RUN TestConstantTry
  2. constant_try_test.go:12: 1 2 3
  3. --- PASS: TestConstantTry (0.00s)
  4. PASS

位与运算符(&)

  1. const (
  2. Readable = 1 << iota
  3. Writable
  4. Executable
  5. )
  6. /**
  7. 4.位与运算符(&)
  8. 运算规则:两个数都转为二进制,然后从高位开始比较,如果两个数都为1则为1,否则为0。
  9. 比如:129&128.
  10. 129转换成二进制就是10000001,128转换成二进制就是10000000。从高位开始比较得到,得到10000000,即128.
  11. */
  12. func TestConstantTry1(t *testing.T) {
  13. t.Log(Readable, Writable, Executable)
  14. a := 1 // 0001
  15. t.Log(a&Readable == Readable,a&Writable == Writable,a&Executable==Executable)
  16. b := 7 // 0111
  17. t.Log(b&Readable == Readable,b&Writable==Writable,b&Executable==Executable)
  18. }

Result:

  1. === RUN TestConstantTry1
  2. constant_try_test.go:18: 1 2 4
  3. constant_try_test.go:20: true false false
  4. constant_try_test.go:22: true true true
  5. --- PASS: TestConstantTry1 (0.00s)
  6. PASS

PS:学习笔记,侵删!

发表评论

表情:
评论列表 (有 0 条评论,79人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Go——变量常量

    1、变量 变量:使用一个名称来绑定一块内存地址,该内存地址中存放的数据类型由定义变量时指定的类型决定,该内存地址里面存放的内容可以改变。 1.1 显示的完整声明

    相关 Go语言基础】变量常量

    用Go语言编写的程序都是从基本组件构成,而构成这些基本组件的是标识符,本章中将介绍到Go语言中使用到变量,常量以及基本数据类型。 1. 标识符 标识符是函数、变量、常量

    相关 Go语言笔记--常量运算符

    1.常量的定义 1)常量的值再编译时就已经确定 2)常量的定义格式与变量基本相同 3)等号右侧必须是常量或者常量表达式 4)常量表达式中的函数必须是内置函数 例如