golang基础（二）：常量、类型、字符串常用操作

目录

一、定义常量

const 定义常量，不可更改。可以一次性定义多个常量，但必须都要赋值。

二、基础数据类型

1. 整型 int

2. 浮点型 float

3. 布尔型 bool

4. 字符串 string

三、字符串常用操作

1. 转义字符

2. 长度、拼接、判断等

---

一、定义常量

const 定义常量，不可更改。可以一次性定义多个常量，但必须都要赋值。

package main

import "fmt"

func main() {
    const username = "张三"
    fmt.Println(username)

    // 定义多个常量
    const (
        username = "张三"
        age      = 12
        sex      = "男"
    )
    fmt.Println(username, age, sex)

    // 多个常量第一个赋值后面的值跟第一个一致
    const (
        a = 1
        b
        c
    )
    fmt.Println(a, b, c) // 1 1 1
    const (
        a = 1
        b
        c = 2
    )
    fmt.Println(a, b, c) // 1 1 2
    
    // 定义常量iota函数，默认从0开始一直累加
    const (
        a = iota
        b
        c
    )
    fmt.Println(a, b, c) // 0 1 2 
    const (
        a = iota
        b
        c = 100
    )
    fmt.Println(a, b, c) // 0 1 100
    const(
        a = iota
        _
        c
    )
    fmt.Println(a, c) // 0 2
}

二、基础数据类型

1. 整型 int

int、uint 根据自身电脑系统决定是 int32、uint32 还是 int64、uint64

int8、uint8

int16、uint16

int32、uint32

int64、uint64

上述所有不在细讲，实际工作中如果用不到字符字节运算，上述类型做个了解即可。另外获取整形所占字节量，使用unsafe。

package main

import "fmt"

func main() {
    const a int = 1
    fmt.Println(unsafe.Sizeof(a)) // 1
}

2. 浮点型 float

浮点型也就是小数点类型，但是所有开发语言的浮点型精确度都有问题，需要单独运算。因为二进制转十进制的时候精度都会有问题。

package main

import "fmt"

func main() {
    const (
        a float32 = 8.2
        b float32 = 3.8
    )

    fmt.Println(a - b) // 4.3999996
}

3. 布尔型 bool

true\false

package main

import "fmt"

func main() {
    a := true
    fmt.Printf("%v -- %T", a, a) // true -- bool 这里的%v是获取a的值，%T是获取a的类型
}

4. 字符串 string

package main

import "fmt"

func main() {
    a := "hello golang"
    fmt.Printf("%v -- %T", a, a) // hello golang -- string
}

三、字符串常用操作

1. 转义字符

转义字符各语言都差不多，但是要在双引号内使用。

注：多行字符串输出方式

package main

import "fmt"

func main() {
    var str = `this is str
    this is str
        this is str
    this is str

    `
    fmt.Println(str)
}

2. 长度、拼接、判断等

len : 一个汉字占3个字节，一个英文占用一个。

package main

import "fmt"

func main() {
    var a = "你好"
    fmt.Println(len(a)) // 6
}

+ \ fmt.Sprintf()

package main

import "fmt"

func main() {
    str1 := "你好"
	str2 := "golang"

	fmt.Println(str1 + str2) // 你好golang

    str1 := "This is" +
		" golang " +
		"not php"
	fmt.Println(str1) // This is golang not php

    str1 := "你好"
	str2 := "golang"
	str3 := fmt.Sprintf("%v %v", str1, str2)
	fmt.Println(str3) // 你好 golang
}

strings.Split \ strings.Join

package main

import (
    "fmt"
    "strings"
)

func main() {
    str1 := "123-456-789"
	str2 := strings.Split(str1, "-") 
	fmt.Println(str2) // 得到切片[123 456 789] 也就是数组

	str3 := strings.Join(str2, "*")
	fmt.Println(str3) // 123*456*789
}

strings.Contains \ strings.HasPrefix \ strings.HasSuffix \ strings.Index \ strings.LastIndex

package main

import (
    "fmt"
    "strings"
)

func main() {
    str1 := "This is str"
	str2 := "is"
	str3 := "xxx"
	str4 := "This"
	fmt.Println(strings.Contains(str1, str2)) // true
	fmt.Println(strings.Contains(str1, str3)) // false

	fmt.Println(strings.HasPrefix(str1, str4)) // true
	fmt.Println(strings.HasSuffix(str1, str4)) // false
	// 都是从前往后数，从0开始
	fmt.Println(strings.Index(str1, str2))     // 2
	fmt.Println(strings.LastIndex(str1, str2)) // 5
}