方法

方法定义

跟go一样,在函数名前面加接收者,就是方法

接收者默认不可变,如果要修改接收者,要加上mut

结构体方法,可以定义在同一个模块目录的不同源文件中

  1. struct User {
  2. mut:
  3.     name string
  4.     age  int
  5. }
  7. fn (u User) get_name() string {
  8.     return u.name
  9. }
  11. fn (mut u User) set_name(name string) { //需要修改接收者,要加上mut
  12.     u.name = name
  13. }

除了可以给结构体添加方法外,还可以给以下类型添加方法:

  • 枚举
  • 类型别名
  • 函数类型
  • 联合类型
  • 自定义数组类型
  • 自定义字典类型
  1. module main
  3. struct Point {
  4.     x int
  5.     y int
  6. }
  8. enum Color {
  9.     white
  10.     black
  11.     blue
  12. }
  14. type Myint = int
  16. type MyFn = fn (int, int) int
  18. type Mysumtype = int | string
  20. pub fn (c Color) str() string { // 枚举的方法
  21.     return 'from color'
  22. }
  24. pub fn (m Myint) str() string { // 类型别名的方法
  25.     return 'from myint'
  26. }
  28. pub fn (myfn MyFn) str2() string { // 函数类型的方法
  29.     return 'from myfn'
  30. }
  32. pub fn (mysum Mysumtype) str() string { // 联合类型的方法
  33.     return 'from mysumtype'
  34. }
  36. pub fn (myarr []Point) point_arr_method() string { // 自定义数组类型的方法,接收者是对应的数组类型
  37.     return 'from []Point'
  38. }
  40. pub fn (mymap map[string]Point) point_map_method() string { // 自定义字典类型的方法,接收者是对应的字典类型
  41.     return 'from map[string]Point'
  42. }
  44. fn fn2(f MyFn) {
  45.     println(f(1, 3)) // 直接调用函数
  46.     println(f.str2()) // 调用函数类型的方法
  47. }
  49. fn add(x int, y int) int {
  50.     return x + y
  51. }
  53. fn main() {
  54.     // 枚举方法
  55.     c := Color.white
  56.     println(c.str())
  57.     // 类型别名方法
  58.     i := Myint(11)
  59.     println(i.str())
  60.     // 联合类型方法
  61.     mut m := Mysumtype{}
  62.     m = int(11)
  63.     println(m.str())
  64.     // 函数类型方法
  65.     fn2(add)
  66.     // 直接定义函数类型
  67.     f := MyFn(add)
  68.     println(f.str2()) // 调用函数类型的方法
  69.     // 自定义数组类型方法
  70.     p := Point{
  71.         x: 1
  72.         y: 2
  73.     }
  74.     mut p_array := []Point{}
  75.     p_array << p
  76.     println(p_array.point_arr_method())
  77.     // 自定义字典类型方法
  78.     mut mp := map[string]Point{}
  79.     println(mp.point_map_method())
  80. }

方法链式调用

方法支持链式调用

  1. module main
  3. struct DB {
  4. mut:
  5.     sql string
  6. }
  8. fn new() &DB { // &表示取地址,引用
  9.     return &DB{
  10.         sql: ''
  11.     }
  12. }
  14. fn (mut db DB) table(name string) &DB { // &表示取地址,引用
  15.     db.sql += name
  16.     return db
  17. }
  19. fn (mut db DB) where(condition string) &DB {
  20.     db.sql += condition
  21.     return db
  22. }
  24. fn (mut db DB) first() &DB {
  25.     db.sql += 'limit 1'
  26.     return db
  27. }
  29. fn main() {
  30.     mut db := new()
  31.     // 链式调用
  32.     db.table('select * from user ').where('where id=1 ').first()
  33.     println(db.sql) // 输出:select * from user where id=1 limit 1
  34. }