定义变量，常量以及输出

package main
​
import (
    "fmt"
    "strconv"
    "strings"
    "unsafe"
)
​
var hm = 11 //全局变量   hm := 11 全局变量不能用短变量声明
// 注意变量不能重复声明
// 定义方法
func getinfo() (string, int) {
    return "hello world", 100
}
func main() {
    // var a int //常规定义变量 变量定义之后必须使用
    // a:=1 //类型推导方式定义变量
    // var (
    //     a int
    //  b int
    //     c int
    // )
    // var a,b,c string //一次定义多个变量
    // a,b,c:=1,2,3 // 定义加赋值
    // var a int=1
    // var a=1
    const pi = 3.1415926 //定义常量 必须直接赋值 赋值不能更改
    const (
        A = "A"
        B = "B"
        C
    ) //多个常量定义 不赋值默认跟上一行同值
    const (
        A1 = iota
        B2
        C3
        D
    )
    //iota初始为0 自增
    //println 可以换行 多数据输出有空格 print不会换行 多数据输出没有空格
    fmt.Printf("%s,%s,%s\n", A, B, C)
    fmt.Printf("%d,%d,%d\n", A1, B2, C3)
    fmt.Println("Hello, world!")
    fmt.Print("Hello", "world")
    fmt.Printf("Hello, %s!\n", "world")
​
    a := 10
    var b int = 20
    var c int = 30
    fmt.Println("a =", a, "b =", b, "c =", c)
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
    s, i := getinfo() //使用方法返回值定义变量
    fmt.Println(s, i)
    s2, _ := getinfo() //只定义一个变量 用 _ 代表匿名变量
    fmt.Println(s2)
    //int类型
    //有符号的类型
    var num int8 = 127                   //范围 -128到127   1个字节
    var num2 int16 = 32767               //范围 -32768到32767 2个字节
    var num3 int32 = 2147483647          //范围 -2147483648到2147483647 4个字节
    var num4 int64 = 9223372036854775807 //范围 -9223372036854775808到9223372036854775807 8个字节
    //没有符号的类型
    //范围 0到255   1个字节
    var num5 uint8 = 255
    //范围 0到65535   2个字节
    var num6 uint16 = 65535
    //范围 0到4294967295   4个字节
    var num7 uint32 = 4294967295
    //范围 0到18446744073709551615   8个字节
    var num8 uint64 = 18446744073709551615
    //类型转换 需要注意字节够不够
    var num9 = int16(num)
    //%T 得到数据类型
    fmt.Printf("num=%v 类型：%T, num2=%v 类型：%T, num3=%v 类型：%T, num4=%v 类型：%T, num5=%v 类型：%T, num6=%v 类型：%T, num7=%v 类型：%T, num8=%v 类型：%T, num9=%v 类型：%T\n", num, num, num2, num2, num3, num3, num4, num4, num5, num5, num6, num6, num7, num7, num8, num8, num9, num9)
    fmt.Println(unsafe.Sizeof(num4)) //unsafe.Sizeof 得到字节长度
    //Printf %v 原样输出; %d 10进制输出; %b 2进制输出; %o 8进制输出; %x 16进制输出;
    num10 := 100 //32位操作系统表示类型为int32 64位操作系统表示类型为int64
    fmt.Printf("num10=%v 类型：%T\n", num10, num10)
    //float类型
    var float1 float32 = 3.14 // float32 占4个字节
    var float2 float64 = 3.14 // float64 占8个字节 64位操作系统默认
    //Printf %v 原样输出; %f 保留6位小数; %.2f 保留两位; %.4f 保留4位;带f格式化输出 都是四舍五入
    var f1 float32 = 3.14e2  //表示赋值3.14 * 10的二次方 3.14*100
    var f2 float64 = 3.14e-2 //表示赋值3.14 / 10的二次方 3.14/100
    fmt.Printf("float1=%v 类型：%T, float2=%v 类型：%T, f1=%v 类型：%T, f2=%v 类型：%T\n", float1, float1, float2, float2, f1, f1, f2, f2)
    ff := float64(f1) //转换flaot64类型 需要处理float精度丢失问题
    fmt.Printf("ff=%v 类型：%T\n", ff, ff)
    //布尔类型
    var bol bool //默认为false 整数类型无法转换为布尔类型
    fmt.Printf("值: %v , 类型: %T", bol, bol)
    //字符串类型
    var str string = "Hello, World!"
    str2 := `Hello, World!
    Hello, World!
    Hello, World!
    ` //多行字符串
    // \r 回车 \n 换行符 \t 制表符
    fmt.Println(len(str2))                  //len得到字符串长度 一个汉字3个字节 unsafe.Sizeof无法查看字符串占用的存储空间
    fmt.Println(str + str2)                 //+ 号拼接字符串
    str3 := fmt.Sprintf("%s %s", str, str2) //fmt.Sprintf也能拼接字符串
    arr := strings.Split(str, ",")          //strings.Split 切割字符串 切片
    str = strings.Join(arr, ",")            //strings.Join 切片转换为字符串
    arr2 := []string{"Hello", "World!"}     //定义切片
    flag := strings.Contains(str, "H")      //strings.Contains 是否包含某个字符串 返回bool
    flag2 := strings.HasPrefix(str, "H")    //前缀是否包含 返回bool
    flag3 := strings.HasSuffix(str, "!")    //后缀是否包含 返回bool
    snum := strings.Index(str, "H")         //查找目标字符串出现在某字符串的位置 返回第一次出现的下标 找不到返回-1 下标从0开始 strings.LastIndex 返回最后一次出现的下标
    fmt.Printf("str=%s, str2=%s, str3=%s, arr=%v, flag=%v, flag2=%v, flag3=%v, snum=%v\n", str, str2, str3, arr, flag, flag2, flag3, snum)
    fmt.Println(arr2)
    //字符 byte uint8类型 代表ASCII码字符 rune 代表UTF-8字符
    aa := 'a' //字符用单引号定义 只能是一个字符 字符值为int类型   %c可以原样输出
    ss := "big"
    bytes := []byte(ss)
    bytes[0] = 'p'
    ss = string(bytes) //修改字符串 big 为 pig
    fmt.Printf("aa=%c, ss=%s\n", aa, ss)
    s3 := "大家好"
    runes := []rune(s3)
    runes[0] = '小'
    s3 = string(runes) //修改字符串 大家好 为 小家好
    fmt.Printf("s3=%s\n", s3)
    var ii int = 10
    var f float32 = 3.14
    var t bool = true
    var b2 byte = 'a'
    str1 := fmt.Sprintf("ii=%d, f=%f, t=%t, b2=%c", ii, f, t, b2) //fmt.Sprintf 将各种类型转换为字符串 int对应%d float对应%f bool对应%t byte对应%c
    fmt.Printf("i=%d, f=%f, t=%t, b=%c\n", i, f, t, b)
    fmt.Println(str1)
    //strconv 将数值，浮点类型转换为字符串
    var i2 int = 10
    var f3 float32 = 3.14
    //参数1：需要转换的int64类型数字，参数2：进制
    str20 := strconv.FormatInt(int64(i2), 10)
    /*参数1：需要转换的float64类型浮点值
    参数2：fmt格式化类型，'f'：普通十进制表示（如 "123.456"）。
       'e'/'E'：科学计数法（如 "1.2345e+02"/"1.2345E+02"）。
       'g'/'G'：智能选择最短表示（自动在 'f' 和 'e'/'E' 间切换）。
       'b'：二进制科学计数法（如 "7074237762510336p-51"），用于精确表示浮点数底层结构•。
    参数3：精度，即小数点后保留几位(-1 不对小数点格式化)
    参数4：32：按 float32 的精度处理（单精度，约 6-7 位有效数字）。
           64：按 float64 的精度处理（双精度，约 15-16 位有效数字）。
    */
    str30 := strconv.FormatFloat(float64(f3), 'f', 2, 32)
    fmt.Printf("str20=%s, str30=%s\n", str20, str30)
​
}
​

延伸阅读

学习golang(伍)

golang连接数据库 增删改查以及事物

学习golang(八)

学习golang(七)

学习golang(十一)