Go语言基础03-字面量类型

数值类型

分为整型，浮点，以及一些特殊的。

整型 浮点 其他

布尔类型

就是简单的 true 和 false。

string类型

声明：

var s1 str
s2 := "xxx"
s3 := `
ff
`

使用：
不支持修改值，需要通过转换成 []byte 进行操作。
可以进行拼接或者取长度：

s4 := s3 + s2  // 拼接
len(s4)        // 取长度

对字符串的更多操作，有专门的 strings 包。

package main
import s "strings" //strings取个别名
import "fmt"
//我们给 fmt.Println 一个短名字的别名，我们随后将会经常用到。
var p = fmt.Println
func main() {
//这是一些 strings 中的函数例子。注意他们都是包中的函数，不是字符串对象自身的方法，这意味着我们需要考虑在调用时传递字符作为第一个参数进行传递。
    p("Contains:  ", s.Contains("test", "es"))
    p("Count:     ", s.Count("test", "t"))
    p("HasPrefix: ", s.HasPrefix("test", "te"))
    p("HasSuffix: ", s.HasSuffix("test", "st"))
    p("Index:     ", s.Index("test", "e"))
    p("Join:      ", s.Join([]string{"a", "b"}, "-"))
    p("Repeat:    ", s.Repeat("a", 5))
    p("Replace:   ", s.Replace("foo", "o", "0", -1))
    p("Replace:   ", s.Replace("foo", "o", "0", 1))
    p("Split:     ", s.Split("a-b-c-d-e", "-"))
    p("ToLower:   ", s.ToLower("TEST"))
    p("ToUpper:   ", s.ToUpper("test"))
    p()
    p("Len: ", len("hello"))
    p("Char:", "hello"[1])
}
$ go run string-functions.go
Contains:   true
Count:      2
HasPrefix:  true
HasSuffix:  true
Index:      1
Join:       a-b
Repeat:     aaaaa
Replace:    f00
Replace:    f0o
Split:      [a b c d e]
toLower:    test
ToUpper:    TEST
Len:  5
Char: 101

数组类型

数组是一个字面量（值）类型，切片（slice）是引用类型。
数组在声明的时候需要指定长度，切片不指定。

操作：

// 声明（增）
[length]Type
[N]Type{v1, v2, ..., vn}
[...]Type{v1, v2, ..., vn}

// 赋值和修改（改）
arr[i] = vi

// 索引（查）
arr[start : end]
len(arr)

// 遍历
for i, v := range arr {
  xxx
}

更多操作见 slice。

struct

结构体(一定程度上，可以看做面向对象的类)。

声明

// 使用struct去创建结构体
// 这里创建了一个变量a
var a struct {
  name string
  type string
}

// 更多时候是和自定义类型type一起使用
// 创建一个名字为Animal的 struct 类型
type Animal struct{
  name string
  type string
}
b := Animal{
  name:  "momo",
  type:  "cat",
}

聚合和嵌入
其实可以把被嵌入的struct看成是被继承的内容。

// struct 定义
type People struct {
  Name string
  Age  int
}

Type Student struct {
  People  // 嵌入，把people 里的成员打散在Student里
  School string  // 聚合
}

// 创建变量
lily := Student{
  People{Name: "lily", Age: 20,},
  School: "龙泉寺大学",
}

// 访问，可以通过.直接访问嵌入里的字段
fmt.Println(lily.Name)
fmt.Println(lily.School)

// 如果外层有成员和嵌入的一样，访问嵌入的同名同类型成员则需要多一层.
// 这个可以看成继承的重载
Type Teacher struct {
  People  // 嵌入，把people 里的成员打散在Student里
  School string  // 聚合
  Name string
}

momo := Teacher{
  People{Name: "momo", Age: 40,},
  School: "龙泉寺大学",
  Name: "老莫",
}
fmt.Println(momo.Name)
fmt.Println(momo.People.Name)

带方法的结构体

// Struct 是字面量，这里传入表面值，如果修改的话，不会影响外面
func (s Student) Report() {
  fmt.Println("Name: " + s.Name + " Age: " + s.Age + " School: " + s.School)
}

// 传入指针，可以对struct内部信息进行修改
func (s *Student) ChangeName(name string) {
  // (*s).Name = name  // 其实应该这样写，但是这样写不被go语言推荐
  s.Name = name  // 等同于上一条语句，当使用.访问的时候，go会自动把指针的s转换成*s
}