• 【golang】interface 如此动人，却被遗忘

     

    1. 不用接口，做普通的数据封装和访问，觉得很方便啊？

    1. package demo
    2.  
    3. import "fmt"
    4.  
    5.  
    6. type name struct {
    7.  firstname string
    8.  lastname  string
    9. }
    10.  
    11. // Go 中有一个习惯用法，用于创建一个“构造函数”函数，该函数的名称前面带有单词“ New”，如下所示:
    12. func NewName(first, last string) name {
    13.  return name{firstname: first, lastname: last}
    14. }
    15.  
    16. // 我现在有一个“构造函数”函数，但是我需要能够访问这些字段。为此，我需要一种“方法”:
    17.  
    18. func (n name) Fullname() string {
    19.  return fmt.Sprintf("name: %s %s", n.firstname, n.lastname)
    20. }
    21.  
    22.  
    23. // main 包
    24. func main() {
    25.  n := demo.NewName("Joe", "Soap")
    26.  fmt.Println(n.Fullname())
    27. }

    2. 嵌入类型，假设我有两种类型的人，一个雇员和一个客户。我可以做出这样的东西（也不需要接口）:

    1. type employee struct {
    2.  employeeID string
    3.  firstname  string
    4.  lastname   string
    5. }
    6.  
    7. func NewEmployee(id, first, last string) employee {
    8.  return employee{employeeID: id, firstname: first, lastname: last}
    9. }
    10. func (e employee) ID() string {
    11.  return e.employeeID
    12. }
    13.  
    14. func (e employee) Fullname() string {
    15.  return fmt.Sprintf("name: %s %s", e.firstname, e.lastname)
    16. }
    17.  
    18. type client struct {
    19.  clientID   string
    20.  firstname  string
    21.  lastname   string
    22. }
    23.  
    24. func NewClient(id, first, last string) client {
    25.  return client{clientID: id, firstname: first, lastname: last}
    26. }
    27. func (c client) ID() string {
    28.  return c.clientID
    29. }
    30. func (c client) Fullname() string {
    31.  return fmt.Sprintf("name: %s %s", c.firstname, c.lastname)
    32. }
    33.  
    34.  
    35. // main 包
    36. func main() {
    37.      employee1 := NewClient("C0001234", "Joe", "Soap")
    38.      client1 := NewEmployee("1122", "Fred", "Bloggs")
    39.      fmt.Println(employee1.ID())
    40.      fmt.Println(employee1.Fullname())
    41.      fmt.Println(client1.ID())
    42.      fmt.Println(client1.Fullname())
    43. }
    44.  
    45.  
    46. // 输出
    47. C0001234
    48. name: Joe Soap
    49. 1122
    50. name: Fred Bloggs

    但这样非常死板，如果我想添加一个字段，会发生什么？现在我有三个结构和三个方法要更新。语法很快变得复杂，有些东西可能会被遗漏。

    好了，是时候简化代码了。我只需要将name嵌入到雇员employee和客户client中，然后只需要一个 FullName ()函数:（注意：代码没有拆包，为了测试方便放到一个包里面了，后面一样。）

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type name struct {
    6.  firstname string
    7.  lastname  string
    8. }
    9.  
    10. func NewName(first, last string) name {
    11.  return name{firstname: first, lastname: last}
    12. }
    13.  
    14. func (n name) Fullname() string {
    15.  return fmt.Sprintf("name: %s %s", n.firstname, n.lastname)
    16. }
    17.  
    18. type employee struct {
    19.  employeeID string
    20.  name
    21. }
    22. func NewEmployee(id, first, last string) employee {
    23.  return employee{
    24.   employeeID: id,
    25.   name: name{
    26.    firstname: first,
    27.    lastname:  last,
    28.   },
    29.  }
    30. }
    31. type client struct {
    32.  clientID string
    33.  name
    34. }
    35. func NewClient(id, first, last string) client {
    36.  return client{
    37.   clientID: id,
    38.   name: name{
    39.    firstname: first,
    40.    lastname:  last,
    41.   },
    42.  }
    43. }
    44.  
    45. func (e employee) ID() string {
    46.  return e.employeeID
    47. }
    48.  
    49. func (c client) ID() string {
    50.  return c.clientID
    51. }
    52.  
    53.  
    54. func main() {
    55.      employee1 := NewClient("C0001234", "Joe", "Soap")
    56.      client1 := NewEmployee("1122", "Fred", "Bloggs")
    57.      fmt.Println(employee1.ID())
    58.      fmt.Println(employee1.Fullname())
    59.      fmt.Println(client1.ID())
    60.      fmt.Println(client1.Fullname())
    61. }

    上面可以进一步简化，上面代码仍然需要构造三次 name。我已经有了一个名称构造函数，所以我可以像这样直接将名称传递给 NewEmployee ()和 NewClient () :

    func NewEmployee(id string, name name) employee {
 return employee{
  employeeID: id,
  name:       name,
 }
}func NewClient(id string, name name) client {
 return client{
  clientID: id,
  name:     name,
 }
}

    修改后：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type name struct {
    6.  firstname string
    7.  lastname  string
    8. }
    9.  
    10. func NewName(first, last string) name {
    11.  return name{firstname: first, lastname: last}
    12. }
    13.  
    14. func (n name) Fullname() string {
    15.  return fmt.Sprintf("name: %s %s", n.firstname, n.lastname)
    16. }
    17.  
    18. type employee struct {
    19.  employeeID string
    20.  name
    21. }
    22.  
    23. type client struct {
    24.  clientID string
    25.  name
    26. }
    27.  
    28. func NewEmployee(id string, name name) employee {
    29.  return employee{
    30.   employeeID: id,
    31.   name:       name,
    32.  }
    33. }
    34. func NewClient(id string, name name) client {
    35.  return client{
    36.   clientID: id,
    37.   name:     name,
    38.  }
    39. }
    40.  
    41.  
    42. func (e employee) ID() string {
    43.  return e.employeeID
    44. }
    45.  
    46. func (c client) ID() string {
    47.  return c.clientID
    48. }
    49.  
    50.  
    51. func main() {
    52.      employee1 := NewClient("C0001234", NewName("Joe", "Soap"))
    53.      client1 := NewEmployee("1122", NewName("Fred", "Bloggs"))
    54.      fmt.Println(employee1.ID())
    55.      fmt.Println(employee1.Fullname())
    56.      fmt.Println(client1.ID())
    57.      fmt.Println(client1.Fullname())
    58. }

    3. name如果需要增加一个参数会怎么样？

    需要修改的地方：体验一般 ...7处改动，少改一个地方也不行

    type name struct {  // struct  
 salutation string
 firstname  string
 lastname   string
}
func NewName(sal, first, last string) name { // 构造函数 
 return name{
  salutation: sal,
  firstname:  first,
  lastname:   last,
 }
}func (n name) Fullname() string {  // 函数
 return fmt.Sprintf("name: %s %s %s", n.salutation, n.firstname, n.lastname)
}
还有：main方法的入参也要修改     
     employee1 := NewClient("C0001234", NewName("Dr","Joe", "Soap"))
     client1   := NewEmployee("1122", NewName("Mr","Fred", "Bloggs"))

    4.  继续抽象ID()方法

    看到ID方法做同样的事情。代码中有两个 ID：ClientID和 Employee.EmployeeID。它们都是字符串类型。因此，让我们创建一个带有构造函数和打印方法的通用 Type:

    效果就是：只保留一个ID函数即可。清理了每个type自己定义的ID()函数。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // add new Type id
    6. type id string
    7.  
    8. func NewID(id id) id {
    9.  return id
    10. }
    11.  
    12. func (i id) ID() string {
    13.  return string(i)
    14. }
    15.  
    16. type name struct {
    17.  firstname string
    18.  lastname  string
    19. }
    20.  
    21. func NewName(first, last string) name {
    22.  return name{firstname: first, lastname: last}
    23. }
    24.  
    25. func (n name) Fullname() string {
    26.  return fmt.Sprintf("name: %s %s", n.firstname, n.lastname)
    27. }
    28.  
    29. type employee struct {
    30.  id
    31.  name
    32. }
    33.  
    34. type client struct {
    35.  id
    36.  name
    37. }
    38.  
    39. func NewEmployee(id id, name name) employee {
    40.  return employee{
    41.   id:         id,
    42.   name:       name,
    43.  }
    44. }
    45. func NewClient(id id, name name) client {
    46.  return client{
    47.   id:       id,
    48.   name:     name,
    49.  }
    50. }
    51.  
    52.  
    53. func main() {
    54. 	 employee1 := NewClient(NewID("C0001234"), NewName("Joe", "Soap"))
    55. 	 client1 := NewEmployee(NewID("1122"), NewName("Fred", "Bloggs"))
    56.      fmt.Println(employee1.ID())
    57.      fmt.Println(employee1.Fullname())
    58.      fmt.Println(client1.ID())
    59.      fmt.Println(client1.Fullname())
    60. }

    5. 使用接口 interface 来进行优化

    前面几步都是使用Type做的简化；接口就是对一些共性的抽象；上面的我们定义了id类型（type id string），现在需求变更了，我们希望我们的 EmployeeID 是一个数字，并且我们希望以一个部门作为前缀。使用简单的字符串 Type 不再能cover住我们的变化了。我们希望能够存储代码和部门。我们还希望将 EmployeeID 显示为两个字段，用连字符分隔。为此，我们需要一个 struct 和一些新方法。 这意味着，我们前面定义的id类型将被废弃掉！（但是Client并没有需要扩展的需求，即ClientID还是一个字符串）换成如下 employeeID struct ....这样其实和name struct没有啥区别了.... 

    1. type employeeID struct {
    2.  department string
    3.  id         int
    4. }
    5. func NewEmployeeID(department string, id int) employeeID {
    6.  return employeeID{
    7.   department: department,
    8.   id:         id,
    9.  }
    10. }
    11. func (eid employeeID) ID() string {
    12.  return fmt.Sprintf("%s-%d", eid.department, eid.id)
    13. }

    思考下，如果我们能不能换成一个接口呢？需要及兼容clientID 的原有逻辑，又能承接employeeID新的数据类型，什么样的接口呢？ 这个接口肯定有ID()的输出能力...整理代码如下：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type name struct {
    6.  firstname string
    7.  lastname  string
    8. }
    9.  
    10. func NewName(first, last string) name {
    11.  return name{firstname: first, lastname: last}
    12. }
    13.  
    14. func (n name) Fullname() string {
    15.  return fmt.Sprintf("name: %s %s", n.firstname, n.lastname)
    16. }
    17.  
    18.  
    19.  
    20. // new Person interface
    21. type Person interface {
    22.  ID() string
    23. }
    24. //- ----------------------通用ID type begin--------------------------------------
    25.  
    26. // add new Type id
    27. type id string
    28.  
    29. func NewID(id id) id {
    30.  return id
    31. }
    32.  
    33. func (i id) ID() string {
    34.  return string(i)
    35. }
    36. //- ----------------------通用ID type end --------------------------------------
    37.  
    38.  
    39. // ------------------- employeeID begin------------------
    40.  
    41. type employeeID struct {
    42.  department string
    43.  id         int
    44. }
    45. func NewEmployeeID(department string, id int) employeeID {
    46.  return employeeID{
    47.   department: department,
    48.   id:         id,
    49.  }
    50. }
    51. func (eid employeeID) ID() string {
    52.  return fmt.Sprintf("%s-%d", eid.department, eid.id)
    53. }
    54. // ------------------- employeeID end ------------------
    55.  
    56. // add person to employee and client structs and constructors
    57. type employee struct {
    58.  Person
    59.  name
    60. }
    61.  
    62. type client struct {
    63.  Person
    64.  name
    65. }
    66.  
    67. func NewEmployee(person Person, name name) employee {
    68.  return employee{
    69.   Person: person,
    70.   name:   name,
    71.  }
    72. }
    73.  
    74. func NewClient(person Person, name name) client {
    75.  return client{
    76.   Person: person,
    77.   name:   name,
    78.  }
    79. }
    80.  
    81. func main() {
    82. 	 employee1 := NewClient(NewEmployeeID("Sales", 1234), NewName("Joe", "Soap"))
    83. 	 client1 := NewEmployee(NewID("1122"), NewName("Fred", "Bloggs"))
    84.      fmt.Println(employee1.ID())
    85.      fmt.Println(employee1.Fullname())
    86.      fmt.Println(client1.ID())
    87.      fmt.Println(client1.Fullname())
    88. }

    现在，看看这段代码，我们已经在员工和客户端中嵌入了 Person 接口，GOOD！但是我们可以进一步简化。首先，我们可以对 name struct 做同样的事情，就像我们对 id 所做的那样，添加一个接口，然后将这两个接口都嵌入。go语言定义接口，通常使用动词作为名称，例如，一个读取的接口是一个 Reader，一个写入的接口是一个 Writer，嵌入了 Reader 和 Writer 接口的接口被称为 ReadWriter。

    6. 全部接口化 interface 

    注意：NewEmployee ()和 NewClient 现在返回的接口是 Person，而不是像以前一样返回 Employee 和 client，这对于外面的框架使用提供了非常友好的便利。比如，外面统一接受person类型的参数，做通用的业务处理逻辑下面的 Details(p Person) 方法。现在我的代码更短、更清晰，希望更具描述性了。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // new interface embedding the interfaces Identifier and Namer 合并了所有接口
    6. type Person interface {
    7.  Identifier
    8.  Namer
    9. }
    10.  
    11.  
    12. // renaming Person as Namer  接口：实现 --------
    13. type Namer interface {
    14.  Fullname() string
    15. }
    16.  
    17. type name struct {
    18.  salutation string
    19.  firstname  string
    20.  lastname   string
    21. }
    22.  
    23. func NewName(sal, first, last string) name {
    24.  return name{
    25.   salutation: sal,
    26.   firstname:  first,
    27.   lastname:   last,
    28.  }
    29. }
    30.  
    31. func (n name) Fullname() string {
    32.  return fmt.Sprintf("name: %s %s %s", n.salutation, n.firstname, n.lastname)
    33. }
    34. // renaming Person as Namer  接口：实现 --------
    35.  
    36.  
    37. // ------ Identifier 接口 ：实现 -----------
    38. type Identifier interface {
    39.  ID() string
    40. }
    41. type employeeID struct {
    42.  department string
    43.  id         int
    44. }
    45. func NewEmployeeID(department string, id int) employeeID {
    46.  return employeeID{
    47.   department: department,
    48.   id:         id,
    49.  }
    50. }
    51. func (eid employeeID) ID() string {
    52.  return fmt.Sprintf("%s-%d", eid.department, eid.id)
    53. }
    54.  
    55. type id string
    56.  
    57. func NewID(id id) id {
    58.  return id
    59. }
    60.  
    61. func (i id) ID() string {
    62.  return string(i)
    63. }
    64. // ------ Identifier 接口 ：实现 -----------
    65.  
    66. type employee struct {
    67.  Identifier
    68.  Namer
    69. }
    70.  
    71. func NewEmployee(id Identifier, name Namer) Person {
    72.  return employee{
    73.   Identifier: id,
    74.   Namer:      name,
    75.  }
    76. }
    77.  
    78. type client struct {
    79.  Identifier
    80.  Namer
    81. }
    82.  
    83. func NewClient(id Identifier, name Namer) Person {
    84.  return client{
    85.   Identifier: id,
    86.   Namer:      name,
    87.  }
    88. }
    89.  
    90. func Details(p Person) {
    91. 	fmt.Printf("ID:[%s] Name: %s\n", p.ID(), p.Fullname())
    92. }
    93.  
    94. func main() {
    95. 	 employee1 :=NewEmployee(NewEmployeeID("Sales", 1234), NewName("Dr", "Joe", "Soap"))
    96.      client1 := NewClient(NewID("1122"), NewName("Mr",   "Fred", "Bloggs"))
    97.      id := NewID("foo")
    98.      fmt.Println(employee1.ID())
    99.      fmt.Println(employee1.Fullname())
    100.      fmt.Println(client1.ID())
    101.      fmt.Println(client1.Fullname())
    102.      fmt.Printf("%s\n", id.ID())
    103. 	
    104.      Details(employee1)
    105.      Details(client1)
    106. }
    107.  
    108. // output
    109. Sales-1234
    110. name: Dr Joe Soap
    111. 1122
    112. name: Mr Fred Bloggs
    113. foo
    114. ID:[Sales-1234] Name: name: Dr Joe Soap
    115. ID:[1122] Name: name: Mr Fred Bloggs

  • 相关阅读:
    超大规模和隐私保护，融云如何助力 Web3 社交
    有什么自定义表单工具功能较好？
    深度学习中的图像处理（基本介绍+示例代码）
    Java根据身份证号码提取出省市区，JSON数据格式
    Ubuntu 22.04 配置VirtualBox安装Windows 10虚拟机
    《Linux》day5--ssh——ssh登录与scp传文件
    Docker-desktop(Docker桌面版)——入门篇
    免费，C++蓝桥杯等级考试真题--第5级
    SpringCloud无介绍快使用，Nacos集群和Nginx代理（二十）
    2022年最新全国各省五级行政区划代码（省/市/区县/乡镇/村）
  • 原文地址：https://blog.csdn.net/qfzhangwei/article/details/126570068