变量

  1. 变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
  3. 通过变量名访问变量中的数据
  5. Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
  7. 声明变量的一般形式是使用 var 关键字：
  9. 例子:
  10.     常规定义： var 变量名称 type
  11.     自动推导： 变量名称 := (数据函数中使用)
  13. 组合：
  14. var (
  15.     a,b string
  16.     c bool
  17.     d int
  18. )
  19. var e,f = 123, "1234"
  22. 函数中使用：
  23. g, h := 123, "hello"

基础数据类型

int,bool,string,bytes

派生据类型

一维数组

  1. // 一维数组
  4. // 输出数据类型
  5. var names [1]string
  6. fmt.Printf("%T\n", names)
  8. // 实例 使用... 自动推导后面的数据得到数组长度
  9. name := [...]string{"1", "2", "123", "3", "4", "5"}
  10. fmt.Printf("%T", name)
  11. fmt.Println(name)
  14. // 取值
  15. fmt.Println("切片的值为：", name[2])
  18. // 对指定位置的数据进行初始化  如下对长度为"3，1，4" 位置的数据进行修改
  19. passwd := [10]int{3: 1111, 1: 222, 4: 333}
  20. fmt.Println("访问和修改，长度为3的值：", passwd[3])
  23. // 获取数组的长度 长度为10
  24. fmt.Println("数组长度：", len(passwd))
  27. // 数组切片
  28. groups := [...]string{"python", "golang", "java", "C#", "groovy"}
  29. fmt.Println(groups[2:3]) // [开始:结束]
  32. // 遍历数组
  33. for i := 0; i < len(groups); i++ {
  34.     fmt.Printf("第[%d]位数: %s\n", i, groups[i])
  35. }
  38. // 第二种遍历
  39. for i, v := range groups {
  40.     fmt.Printf("[%d]: %s\n", i, v)
  41. }

多维数组

  1. //  多维数组
  2. // 多为数组的长度只有一维可以自动推导，二维必须定义长度
  3. langes1 := [...][3]string{{"golang", "python", "groovy"}, {"java", "golang", "C++"}}
  4. langes2 := [3][3]string{{"windows项目", "shell", "groovy"}, {"java", "golang", "C++"}}
  5. langes3 := [3][3]string{0: {"windows项目", "shell", "groovy"}, 2: {"java", "golang", "C++"}}
  6. langes4 := [4][3]string{0: {0: "windows项目", 2: "shell", 1: "groovy"}, 1: {"java", "golang", "C++"}, 3: {"php", "javascriptr", "html"}}
  8. // 输出类型
  9. fmt.Printf("数组： \n%T\n%T\n%T\n%T\n", langes1, langes2, langes3, langes4)
  10. // 输出值
  11. fmt.Printf("%q\n", langes1)
  13. // 多为数组访问
  14. devops := langes1[0][0:2]
  15. fmt.Printf("运维开发需要掌握的语言：%s\n", devops)
  16. dev := langes2[1][0:3] // 一般结束位都需要按照下标+1
  17. fmt.Printf("开发需要掌握的语言：%s\n", dev)
  19. // 多维数组修改
  20. fmt.Printf("更正前- 运维开发需要掌握的语言为：%s\n", langes1[0])
  21. langes1[0][2] = "shell"
  22. fmt.Printf("更正后- 运维开发需要掌握的语言为：%s\n", langes1[0])
  24. fmt.Println("----------------------")
  25. fmt.Printf("更正前- 运维开发需要掌握的技能为：%s\n", langes2[0])
  26. langes2[0] = [3]string{"linux", "database", "CICD"}
  27. fmt.Printf("更正后- 运维开发需要掌握的技能为：%s\n", langes2[0])
  29. // 多维数组遍历
  30. // langes3 := [3][3]string{0: {"windows项目", "shell", "groovy"}, 2: {"java", "golang", "C++"}}
  31. for i, line := range langes3 {
  32.     // pkg_fmt.Printf("第一次遍历：%s\n", line)
  33.     for ii, vv := range line {
  34.         // pkg_fmt.Printf("第二次遍历: %s\n", vv)
  35.         fmt.Printf("langes3数组中的值为：[%d %d %s]\n", i, ii, vv) // 此处需要多注意
  36.     }
  37. }
  39. // 多为数组遍历第二遍测试
  40. for i, line := range langes1 {
  41.     // pkg_fmt.Printf("第一次遍历：%s\n", line)
  42.     for ii, vv := range line {
  43.         // pkg_fmt.Printf("第二次遍历: %s\n", vv)
  44.         fmt.Printf("langes1数组中的值为：[%d %d %s]\n", i, ii, vv) // 此处需要多注意
  45.     }
  46. }

切片

  1. // 切片  切片是长度可变的数组，数组在定义好之后长度不可变
  5. // 声明切片 nil切片
  6. var slice1 []string 
  7. fmt.Printf("%T,%t,%v\n", slice1, slice1 == nil, slice1)
  11. // 初始化 使用make函数初始化切片
  12. slice2 := make([]string, 10)
  13. slice3 := []string{"1", "3", "2"}
  15. arrs := [...][3]string{{"golang", "python", "groovy"}, {"java", "golang", "C++"}}
  16. // 切片类型
  17. fmt.Printf("切片：%q   类型: %T\n", slice3, slice3)
  19. // 切片类型
  20. fmt.Printf("切片：%T， 无固定长度\n", slice2)
  22. // 数组类型
  23. fmt.Printf("数组：%T， 必须有长度\n", arrs)
  27. /* 
  28. 切片和数组的区别：
  29.     数组是长度固定的元素序列 切片：[]string
  30.     切片是长度可变的元素序列 数组：[2][3]string
  31. */
  35. /*
  36. 切片初始化后才能用 否则无法使用
  38. make([]数据类型, 长度, 步长)  
  39. */
  40. stu := make([]string, 3, 5)  
  41. fmt.Printf("步长: %d\n长度: %d\n", len(stu), cap(stu))
  42. fmt.Printf("%q,%q\n", stu[0], stu[1:5])
  46. //  切片定义
  47. stu2 := []string{"golang", "java", "python", "C#", "C++"} 
  50. // 修改切片中的值
  51. stu[0] = "golang"
  52. stu[1] = "python"
  53. fmt.Printf("%q,%q\n", stu[0], stu[1])
  54. fmt.Printf("%T : %q\n", stu2, stu2)
  58. // 切片遍历第一种方式
  59. for index, value := range stu2 {
  60.     fmt.Printf("切片第一种遍历: %d %s\n", index, value)
  61. }
  64. // 切片遍历第二种方式
  65. for i := 0; i < len(stu2); i++ {
  66.     fmt.Printf("切片第二种遍历: %s\n", stu2[i])
  67. }
  72. // 切片添加元素 append
  73. stu2 = append(stu2, "shell")
  74. fmt.Println(stu2)
  76. // 可以将string拼接到byte切片
  77. slice := make([]byte, 10)
  78. var a string = "Hi "
  79. var b string = "YY"
  80. slice = append([]byte(a), b...)
  81. fmt.Println("切片追加，解包的方式： ", string(slice))
  86. /* 
  87. 切片删除元素
  88. stu2[start:end] stu2中，从start开始到end-1所有元素组成的切片
  89. 以索引进行删除
  90. */
  92. stu2 = stu2[0:4] 
  93. fmt.Println(stu2)
  97. // 删除第一个元素，删除最后一个元素
  98. //  切片定义
  99. stu3 := []string{"golang", "java", "python", "C#", "C++"}
  100. stu4 := stu3[1:len(stu3)]
  102. fmt.Println(stu3)
  103. fmt.Printf("stu4: %s\n", stu4)
  104. stu5 := stu3[0:len(stu3)]
  105. fmt.Printf("stu5: %s\n", stu5)
  110. // 删除中间一个数据 删除3
  111. nums1 := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
  112. // copy(dst,src) src > dst
  113. nums2 := []int{10, 11, 12, 13, 15, 15, 16}
  114. copy(nums1, nums2) // 按照索引进行复制对应起来
  115. fmt.Println(nums1, nums2)

映射

  2. // 映射map 类似py字典
  5. // 定义map 第一种
  7. // 声明定义
  8. var Iaas map[string]string                                           
  9. Iaas = map[string]string{"name": "alinx", "age": "28", "site": "cn"}
  12. /*
  13. 直接使用make进行初始化创建map
  14. 定义map 第二种
  15. */
  16. man := make(map[string]string)
  17. fmt.Printf("%T,%q\n%T\n", Iaas, Iaas, man)
  19. // 定义map 第三种
  20. wom := map[string]string{}
  21. fmt.Printf("%T\n", wom)
  28. // 操作map
  29. langes := map[string]string{"dev": "golang,java,,,,python", "ops": "shell,python,golang", "devops": "golang,shell"}
  30. fmt.Println(strings.Split(langes["dev"], ",")) // 数据分割
  31. fmt.Printf("长度: %d\n", len(langes))
  34. // map 获取值
  35. dev, ok := langes["dev"]
  36. fmt.Printf("map取值：\n  存在吗:%t\n  取出值:%v\n", ok, dev)
  39. // 修改值
  40. langes["ops"] = "java,C++"
  41. fmt.Printf("修改后的值：%s\n", langes)
  44. // 删除值
  45. delete(langes, "dev")
  46. fmt.Printf("删除后的值：%s\n", langes)
  49. // 遍历map(映射)
  50. for k, v := range langes {
  51.     fmt.Printf("遍历map数据: %s %s\n", k, v)
  52. }

列表

  1. package main
  3. import (
  4.     "container/list"
  5.     "fmt"
  6. )
  8. func main() {
  9.     // 列表的定义
  10.     var name list.List // 生成列表类型
  11.     names := list.New() // 返回列表对应的指针
  12.     fmt.Printf("%T,%#v\n", name,name)
  13.     fmt.Printf("%T,%#v\n", names,names)
  15.      for i := 1; i < 10; i++ {
  16.          names.PushBack(i)
  17.      }
  19.      //插入值
  20.      first :=  names.PushFront(0)
  22.      // 删除值
  23.      names.Remove(first)
  25.      // 遍历值
  27.      // Front函数获取列表的头元素 Next() 函数依次往下遍历
  28.      for l := names.Front(); l != nil ; l = l.Next() {
  29.         fmt.Print(l.Value, " ")
  30.     }
  31. }


结构体

认识结构体

  1. package main
  3. import "fmt"
  5. /* 结构体是一些列属性组成的复合数据类型，每个属性都具有名称
  6. 语法：
  7.     type TypeName formatter
  8. */
  10. // 基于现有数据类型定义结构体
  11. type Counters int
  12. var num int = 10
  16. // 基于现有类型定义
  17. type User map[string]string 
  20. // 别名类型定义
  21. type Counter = int 
  24. // 函数类型定义
  25. type Callback func() error 
  27. func main() {
  28.     var counter Counter
  29.     fmt.Printf("%T,%v\n", counter, counter)
  30.     // var user User
  31.     // user["id"] = "1" //无法直接赋值，需要使用make初始化之后才能使用
  32.     var user User = make(User)
  33.     user["id"] = "1"
  34.     fmt.Printf("%T,%v\n", user, user)
  36.     // 函数类型使用
  37.     callbacks := map[string]Callback{}
  38.     callbacks["users"] = func() error {
  39.         fmt.Println("add")
  40.         return nil
  41.     }
  42.     // 调用 函数类型结构体
  43.     callbacks["users"]()
  45.     // 特殊类型 别名
  46.     var (
  47.         r rune
  48.         b byte
  49.     )
  50.     fmt.Printf("%T, %T", r, b)
  51. }

结构体组合

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. // 组合类型结构体
  9. type User struct {
  10.     // 定义结构体属性
  11.     id       int
  12.     name     string
  13.     addr     string
  14.     tel      string
  15.     birthday time.Time
  16. }
  18. func main() {
  19.     // 定义结构体类型的变量
  20.     var user User
  21.     // 零值是由各元素的零值组成的一个结构体的变量
  22.     fmt.Printf("%T,%#v\n", user, user)
  23.     // 字面量初始化方式( 必须严格按照结构体定义顺序指定 ，且每一个属性都必须指定值)
  24.     user = User{10, "alinx", "xxxx", "138", time.Now()}
  25.     fmt.Printf("%T,%#v\n", user, user)
  27.     // 按照属性名定义字面量,可以无序
  28.     user = User{id: 1, name: "alinxsss", addr: "999", tel: "112123123"}
  29.     fmt.Printf("%T, %#v\n", user, user)
  31.     // 属性访问和修改
  32.     // 访问
  33.     fmt.Println(user.id)
  34.     fmt.Println(user.name)
  35.     fmt.Println(user.tel)
  36.     // 修改
  37.     user.id = 9999
  38.     user.name = "good"
  39.     user.birthday = time.Now()
  40.     fmt.Printf("%T, %#v\n", user, user)
  41. }

结构体指针

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. // 面向对象：  封装，继承，多态
  10. // 结构体类似与面向对象中的类定义
  11. /*
  12. 结构体 =>  类
  13.     构造函数 => 创建类对于的实例
  15.     方法
  19. */
  20. type User struct {
  21.     id       int
  22.     name     string
  23.     tel      string
  24.     addr     string
  25.     birthday time.Time
  26. }
  28. //  New函数定义  ，定义一个结构体
  30. func NewUser(id int, name, tel, addr string, birthday time.Time) User {
  31.     return User{id, name, tel, addr, birthday}
  32. }
  34. // 指针类使用方式
  35. // func NewUser(id int, name, tel, addr string, birthday time.Time) *User {
  36. //     return &User{id, name, tel, addr, birthday}
  37. // }
  38. func main() {
  39.     // 结构体指针
  40.     // 指针类型,直接取地址 &引用
  41.     // var user *User = &User{id: 999, name: "alinx"}
  42.     //  *User 可以省略
  43.     var user = &User{id: 888, name: "Love"}
  44.     fmt.Printf("%T\n%#v", user, user)
  46.     // 结构体  new函数初始化
  47.     user = new(User)
  48.     fmt.Printf("%T\n,%#v\n", user, user)
  50.     u2 := new(User)
  51.     fmt.Printf("%T,\n%#v\n", u2, u2)
  53.     // 属性访问
  54.     fmt.Println(u2.name)
  55.     u2.id = 9999999999
  56.     u2.name = "gooooood"
  57.     fmt.Println(u2.name, u2.id)
  59.     u3 := NewUser(1, "2222", "", "", time.Now())
  60.     fmt.Printf("%T,%#v\n", u3, u3)
  61. }

匿名结构体

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  9.     c := func() {
  10.         fmt.Println("匿名函数")
  11.     }
  12.     fmt.Printf("%T\n", c)
  14.     // 匿名结构体, 一般用于配置类
  15.     var user struct {
  16.         id       int
  17.         name     string
  18.         tel      string
  19.         addr     string
  20.         birthday time.Time
  21.     }
  22.     fmt.Printf("%T,%#v\n", user, user)
  24.     user.id = 123
  25.     user.name = "sadfasdf"
  26.     fmt.Printf("%T,%#v\n", user, user)
  28.     // 初始化，零值，字面量  使用
  29.     user = struct {
  30.         id       int
  31.         name     string
  32.         tel      string
  33.         addr     string
  34.         birthday time.Time
  35.     }{111, "alinx", "123123", "sdddd", time.Now()} // 结构体类型
  36.     fmt.Printf("%T,%#v\n", user, user)
  38.     // 定义时 就进行初始化
  40.     var u2 struct {
  41.         id   int
  42.          name string
  43.     } = struct {
  44.         id   int
  45.          name string
  46.     }{123, "alinx"}
  47.     fmt.Printf("%T,%#v\n", u2, u2)
  49.     // 简写 指针加&即可 ，  一般作为数据传递
  50.     var u2 = struct {
  51.         id   int
  52.         name string
  53.     }{id: 111, name: "ddd"}
  54.     fmt.Printf("%T,%#v\n", u2, u2)
  55.     var u2 = &struct {
  56.         id   int
  57.          name string
  58.     }{id: 111, name: "ddd"}
  59.     fmt.Printf("%T,%#v\n", u2, u2)
  60. }

组合结构体

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. type Addr struct {
  9.     province string
  10.     street   string
  11.     no       string
  12. }
  14. type Tel struct {
  15.     prefix string
  16.     number string
  17. }
  19. // 命名组合(嵌入)
  20. type User struct {
  21.     id       int
  22.     name     string
  23.     addr     *Addr // 组合Addr结构体
  24.     tel      *Tel  // 组合Tel结构体
  25.     birthday time.Time
  26. }
  28. func main() {
  29.     // 初始化使用
  30.     var user User = User{id: 1, name: "alinx", addr: &Addr{}, tel: &Tel{}, birthday: time.Now()}
  31.     fmt.Printf("%T,%#v", user, user)
  32.     // 写入 和读取  如果是指针就加指针进行调用即可  &Addr
  33.     var users User = User{addr: &Addr{province: "贵州省"}}
  35.     // 访问
  36.     fmt.Println(users.addr.province)
  37.     // pkg_fmt.Printf("%T,%#v", users, users)
  38. }

匿名组合结构体

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. type Addr struct {
  9.     province string
  10.     street   string
  11.     no       string
  12. }
  14. type Tel struct {
  15.     prefix string
  16.     number string
  17. }
  19. // 匿名组合结构体
  20. type User struct {
  21.     id       int
  22.     name     string
  23.     Addr     // 只指定类型，会自动定义属性名为类型名
  24.     Tel      // 只指定类型
  25.     birthday time.Time
  26. }
  28. func main() {
  29.     // 初始化使用
  30.     var user User = User{Addr: Addr{province: "guizhou"}}
  31.     fmt.Printf("%T,%#v\n", user, user)
  32.     fmt.Println(user.province)
  33.     user.province = "广东省"
  34.     fmt.Println(user.province)
  36.     // 访问和修改
  37.     user.Addr.province = "贵州省"
  38.     fmt.Println(user.Addr.province)
  40.     fmt.Println(user)
  42. }

使用实例

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. type Users struct { //值类型
  9.     id         int
  10.     name       string
  11.     addr       string
  12.     tel        string
  13.     birthday   time.Time
  14.     created_at time.Time
  15.     updated_at time.Time
  16.     flag       bool
  17.     status     int
  18.     deleted_at *time.Time
  19. }
  21. func main() {
  22.     // 指针
  23.     var t *time.Time
  24.     fmt.Println(t) // 零值nil
  26.     // 定义User类型的变量
  27.     var u Users // 所有属性的零值组成的一个Users类型变量值
  28.     fmt.Printf("%T\n", u)
  29.     fmt.Printf("%v\n", u) // 拿到结构体初始化
  30.     fmt.Printf("%#v\n", u)
  32.     // 赋值 按照顺序 需要给所有属性都进行赋值
  33.     u = Users{1, "alinx", "贵州", "188xxxxxx", time.Now(), time.Now(), time.Now(), false, 0, nil}
  34.     fmt.Printf("%#v\n", u)
  36.     // 指定名称进行赋值
  37.     u = Users{id: 2, name: "alinx"}
  38.     fmt.Printf("%#v\n", u)
  40.     // 属性访问
  41.     fmt.Println(u.id)
  42.     fmt.Println(u.name)
  43.     fmt.Println(u.birthday.Clock())
  45.     // 值类型 修改
  46.     u.id = 999999
  47.     fmt.Println(u.id)
  49.     // 指针类型
  50.     var u3 *Users
  51.     fmt.Printf("%T, %v\n", u3, u3)
  52.     // 指针赋值
  53.     u3 = &u
  54.     fmt.Println("%#v\n", u3)
  56.     // new 申请空间并对元素使用0值进行初始化，取地址，赋值
  57.     var u4 *Users = new(Users)
  58.     var u5 *Users = &Users{} // 类似new
  59.     fmt.Printf("%#v\n", u4)
  60.     fmt.Printf("%#v\n", u5) // 初始化值取0值
  61. }

接口

接口是一个实现了功能的组合调用对象

  2. 接口是对行为的抽象 => 实现行为的对象
  4. 定义
  5.     接口： 定义的一些函数
  6.         签名： 参数列表，返回值列表
  7.     关键字： interface
  8.     type TypeName Formatter
  9.     type interfaceName interface {
  10.         方法签名
  11.     }

接口使用实例

  1. package main
  3. import "fmt"
  5. // 接口定义
  6. type User struct {
  7.     Id int
  8.     Name string
  9. }
  11. // 定义接口 Persistent
  13. /* 行为：  
  14.     Save保存
  15.     User切片
  16. */
  19. type Persistent interface {
  20.     // 方法名称  返回值类型  接口中所定义的方法，需要有确切的实现，否则异常
  21.     Save([]User,string) error
  22.     Load(string) ([]User,error)
  23. }
  26. // 实现原则： 定义了GObPersustent 所有接口 就叫GObPersustent实现了Persistent接口
  30. // 第一个结构体实现 Persistent接口
  31. type GObPersustent struct {} 
  34. // 基于GObPersustent结构体 实现Save方法
  35. func (p GObPersustent) Save(users []User,path string) error {
  36.     fmt.Printf("\ngob persistent save")
  37.     return nil
  38. }
  39. // 基于GObPersustent结构体 实现Load方法
  40. func (p GObPersustent) Load(path string) ([]User,error) {
  41.     fmt.Printf("\ngob persistent load")
  42.     return nil,nil
  43. }
  48. // 第二个结构体实现 Persistent接口
  49. type CsvPersistent struct{}
  51. // 基于CsvPersistent结构体 实现Save方法
  52. func (p CsvPersistent) Save(users []User,path string) error {
  53.     fmt.Println("csv persistent save")
  54.     return nil
  55. }
  56. // 基于CsvPersistent结构体 实现Load方法
  57. func (p CsvPersistent) Load(path string) ([]User, error) {
  58.     fmt.Println("csv persistent load")
  59.     return nil,nil
  60. }
  65. // 此处使用接口作为类型  对接起来调用测试 
  66. func call(persistent Persistent) {
  67.     fmt.Println("\ncall:")
  68.     persistent.Save(nil,"")
  69.     persistent.Load(":")
  70. }
  74. // 调用CsvPersistent结构体实现了 Persistent 接口的方法
  75. func Csv() {
  76.     var persistent Persistent
  77.     fmt.Printf("%T,%#v\n", persistent, persistent)
  78.     persistent = CsvPersistent{}
  79.     persistent.Load("")
  80.     persistent.Save(nil,"")
  81.     /* 
  82.     接口 不能直接通过接口类型进行初始化对象
  83.     结构体使用实现行为（实现接口的所有方法，某个对象的类型定义了接口中所有的方法）的对象
  84.     */
  85. }
  87. // 调用GObPersustent结构体实现了 Persistent 接口的方法
  88. func GOb() {
  89.     var persistent Persistent
  90.     fmt.Printf("%T,%#v\n", persistent, persistent)
  91.     persistent = GObPersustent{}
  92.     persistent.Load("")
  93.     persistent.Save(nil,"")
  94.     /* 
  95.     接口 不能直接通过接口类型进行初始化对象
  96.     结构体使用实现行为（实现接口的所有方法，某个对象的类型定义了接口中所有的方法）的对象
  97.     */
  98. }
  103. func main() {
  104.     // 调用  默认是值类型调用
  105.     Csv()
  106.     GOb()
  109.     /* 
  110.     接口 不能直接通过接口类型进行初始化对象
  111.     */
  114.     // 在类型上 值类型会自动 生成指针类型  指针接收者无法生成值接收者
  115.     var persistent Persistent
  116.     fmt.Printf("%T,%#v\n", persistent, persistent)
  119.     call(GObPersustent{})
  120.     call(CsvPersistent{})
  121.     /* 
  122.     定义类型与接口是否实现  无语法上直接关联
  123.         鸭子类型： 你怎么判断一个动物是否是一个鸭子
  124.         根据行为判断： 游泳，嘎嘎叫 都是鸭子
  126.     总结： 根据以上知识  只要结构体实现了接口中定义的方法 那就是接口类型，就能赋值进行调用
  127.     */
  130.     // 指针对象  自动生成的指针类型调用
  131.     persistent = new(CsvPersistent)
  132.     fmt.Println("指针类型：\n\n%T,%#v\n", persistent,persistent)
  133.     persistent.Load("")
  134.     persistent.Save(nil,"")
  135.     call(&CsvPersistent{})
  136.     call(&GObPersustent{})
  138. }