11种编程语言中，返回多个不同类型的方法样例

本文分享自华为云社区《多语言编程 返回多个不同类型的方法样例》，作者： 张俭 。
背景

你可能会在一些场景下碰到需要返回多个不同类型的方法。比如协议解析读取报文时，更具体地像kubernetes在开始解析Yaml的时候，怎么知道这个类型是属于Deployment还是Service？
C

C语言通常通过使用Struct（结构体）和Union（联合体）的方式来实现这个功能，如下文例子

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
5. typedef enum {
6.     MONKEY,
7.     COW,
8.     UNKNOWN
9. } AnimalType;
11. typedef struct {
12.     char* description;
13. } Monkey;
15. typedef struct {
16.     char* description;
17. } Cow;
19. typedef struct {
20.     AnimalType type;
21.     union {
22.         Monkey monkey;
23.         Cow cow;
24.     };
25. } Animal;
27. Animal createAnimal(const char* animalType) {
28.     Animal animal;
29.     if (strcmp(animalType, "Monkey") == 0) {
30.         animal.type = MONKEY;
31.         animal.monkey.description = "I am a monkey!";
32.     } else if (strcmp(animalType, "Cow") == 0) {
33.         animal.type = COW;
34.         animal.cow.description = "I am a cow!";
35.     } else {
36.         animal.type = UNKNOWN;
37.     }
38.     return animal;
39. }
41. int main() {
42.     Animal animal1 = createAnimal("Monkey");
43.     if (animal1.type == MONKEY) {
44.         printf("%s\n", animal1.monkey.description);
45.     }
47.     Animal animal2 = createAnimal("Cow");
48.     if (animal2.type == COW) {
49.         printf("%s\n", animal2.cow.description);
50.     }
52.     Animal animal3 = createAnimal("Dog");
53.     if (animal3.type == UNKNOWN) {
54.         printf("Unknown animal type\n");
55.     }
57.     return 0;
58. }

复制代码

C++

在C++中，我们可以使用基类指针来指向派生类的对象。可以使用动态类型识别（RTTI）来在运行时确定对象的类型

1. #include <iostream>
2. #include <stdexcept>
4. class Animal {
5. public:
6.     virtual std::string toString() const = 0;
7. };
9. class Monkey : public Animal {
10. public:
11.     std::string toString() const override {
12.         return "I am a monkey!";
13.     }
14. };
16. class Cow : public Animal {
17. public:
18.     std::string toString() const override {
19.         return "I am a cow!";
20.     }
21. };
23. Animal* createAnimal(const std::string& animalType) {
24.     if (animalType == "Monkey") {
25.         return new Monkey();
26.     }
27.     if (animalType == "Cow") {
28.         return new Cow();
29.     }
30.     throw std::runtime_error("Unknown animal type: " + animalType);
31. }
33. int main() {
34.     try {
35.         Animal* animal1 = createAnimal("Monkey");
37.         if (Monkey* monkey = dynamic_cast<Monkey*>(animal1)) {
38.             std::cout << monkey->toString() << std::endl;
39.         }
40.         delete animal1;
42.         Animal* animal2 = createAnimal("Cow");
44.         if (Cow* cow = dynamic_cast<Cow*>(animal2)) {
45.             std::cout << cow->toString() << std::endl;
46.         }
47.         delete animal2;
48.     }
49.     catch (const std::runtime_error& e) {
50.         std::cerr << e.what() << std::endl;
51.     }
53.     return 0;
54. }

复制代码

使用SealedClass

1. package main
3. import (
4.     "fmt"
5. )
7. type Animal interface {
8.     String() string
9. }
11. type Monkey struct{}
13. func (m Monkey) String() string {
14.     return "I am a monkey!"
15. }
17. type Cow struct{}
19. func (c Cow) String() string {
20.     return "I am a cow!"
21. }
23. func createAnimal(typeName string) (Animal, error) {
24.     switch typeName {
25.     case "Monkey":
26.         return Monkey{}, nil
27.     case "Cow":
28.         return Cow{}, nil
29.     default:
30.         return nil, fmt.Errorf("Unknown animal type: %s", typeName)
31.     }
32. }
34. func main() {
35.     animal1, err := createAnimal("Monkey")
36.     if err != nil {
37.         fmt.Println(err)
38.         return
39.     }
41.     if monkey, ok := animal1.(Monkey); ok {
42.         fmt.Println(monkey)
43.     }
45.     animal2, err := createAnimal("Cow")
46.     if err != nil {
47.         fmt.Println(err)
48.         return
49.     }
51.     if cow, ok := animal2.(Cow); ok {
52.         fmt.Println(cow)
53.     }
54. }

复制代码

Python

Python是动态类型的语言，可以简单基于一些条件返回不同类型的对象，然后在接收到返回值之后使用type()函数或isinstance()函数来确定其类型

1. public class MultiTypeReturnExample {
2.     static class Monkey {
3.         @Override
4.         public String toString() {
5.             return "I am a monkey!";
6.         }
7.     }
9.     static class Cow {
10.         @Override
11.         public String toString() {
12.             return "I am a cow!";
13.         }
14.     }
16.     public static Object createAnimal(String type) throws IllegalArgumentException {
17.         switch (type) {
18.             case "Monkey":
19.                 return new Monkey();
20.             case "Cow":
21.                 return new Cow();
22.             default:
23.                 throw new IllegalArgumentException("Unknown animal type: " + type);
24.         }
25.     }
27.     public static void main(String[] args) throws Exception {
28.         Object animal1 = createAnimal("Monkey");
30.         // java8 写法，后面如果明确用做精确的类型，需要强制转换
32.         if (animal1 instanceof Monkey) {
33.             System.out.println(animal1);
34.         }
36.         Object animal2 = createAnimal("Cow");
37.         if (animal2 instanceof Cow) {
38.             System.out.println(animal2);
39.         }
41.         // java17 写法，不需要强制转换
42.         if (createAnimal("Monkey") instanceof Monkey animal3) {
43.             System.out.println(animal3);
44.         }
46.         if (createAnimal("Cow") instanceof Cow animal4) {
47.             System.out.println(animal4);
48.         }
49.     }
50. }

复制代码

Ruby

Ruby也较为简单，在方法内部直接返回不同类型的对象。然后，可以使用is_a方法或class方法来确定返回对象的实际类型。

1. class Animal {
2.     toString() {
3.         return 'I am an animal';
4.     }
5. }
7. class Monkey extends Animal {
8.     toString() {
9.         return 'I am a monkey';
10.     }
11. }
13. class Cow extends Animal {
14.     toString() {
15.         return 'I am a cow';
16.     }
17. }
19. function createAnimal(animalType) {
20.     switch (animalType) {
21.         case 'Monkey':
22.             return new Monkey();
23.         case 'Cow':
24.             return new Cow();
25.         default:
26.             throw new Error(`Unknown animal type: ${animalType}`);
27.     }
28. }
30. try {
31.     const animal1 = createAnimal('Monkey');
32.     if (animal1 instanceof Monkey) {
33.         console.log(animal1.toString());
34.     }
36.     const animal2 = createAnimal('Cow');
37.     if (animal2 instanceof Cow) {
38.         console.log(animal2.toString());
39.     }
41.     const animal3 = createAnimal('Dog');
42. } catch (error) {
43.     console.error(error.message);
44. }

复制代码

Rust

在Rust中，可以使用enum（枚举）来创建一个持有多种不同类型的数据结构。然后使用match语句来做模式匹配。
[code]use std::fmt;enum Animal {    Monkey,    Cow,}impl fmt:isplay for Animal {    fn fmt(&self, f: &mut fmt::Formatter