如何在二郎案件中的不同案件情况之间进行沟通

Posted 2021-04-13

我正在尝试做这样的事情：

test(Tester) ->
  case Tester of
         start -> X = 4 
         ok -> X = X + 5,
               Y = X/5;
         terminate -> Y
  end.

但不完全是这个。我知道它可以用尾部或简单的递归来实现。通常X和Y是未绑定的。

在没有使用erlang全局变量的情况下，有没有办法在这些情况下进行通信？

答案

Erlang是一种函数式语言，它意味着我们不在代码的不同部分之间进行通信，或者在没有目的的情况下将值存储在变量中，我们只是计算返回值（有时会产生一些副作用）。如果我们在不同的代码分支中有共同的计算，我们可以简单地将它放在通用函数中。

test(Tester) ->
  case Tester of
         start     -> 4;
         ok        -> computeY();
         terminate -> computeY()
  end.

computeY() ->
    X = 4 + 5,
    X/5.

另一答案

如果需要访问case语句的任何子句主体中的变量，则必须在case语句之前分配它，或者有时可以在case子句模式中分配它：

test(Arg) ->
    Size = get_size(Arg), % I will use 'Size' in each clause body
    case Arg of
        #{foo := Foo} -> % if Arg is an Erlang map and has key 'foo'
            % I can use 'Foo' only here:
            io:format("It's a map with size ~p and has key foo with value ~p
", [Size, Foo]);
        [Baz|_] -> % if Arg is an Erlang list with at least one element
            % I can use 'Baz' only here and for example i can NOT use 'Foo' here:
            io:format("It's a list with size ~p and its first element is ~p
", [Size, Baz]);
        _ ->
            io:format("Unwanted argument ~p with ~p size
", [Arg, Size])
    end.

get_size(X) when is_map(X)  -> map_size(X);
get_size(X) when is_list(X) -> length(X);
get_size(_)                 -> unknown.

我把上面的代码放在一个名为fun的Erlang Test中，在shell中使用它而不需要编译模块文件：

1> Test([5,4,3,2,1]).
It's a list with size 5 and its first element is 5
ok

2> Test(#{key => value, foo => ':)'}).
It's a map with size 2 and has key foo with value ':)'
ok

3> Test([]).                          
Unwanted argument [] with 0 size
ok

4> Test(#{key => value}).             
Unwanted argument #{key => value} with 1 size
ok

5> Test(13).              
Unwanted argument 13 with unknown size
ok

如果您对变量绑定感到好奇，我建议您阅读this article

另一答案

要在Erlang中执行此操作，您将启动（生成）一个将在内存中保存X的进程以及它应该回复的进程的PID（进程ID），除非您希望每次都将其传递给不同的PID启动/ OK /终止。 Erlang中的进程有自己的内存，状态或循环数据。在您生成一个知道如何处理特定消息的进程后，您将消息传递给它，然后通过发回消息进行回复。

start_test() ->
  TestPID = spawn(?MODULE, test, [self()]),
  TestPID ! start,
  receive
    X -> io:format("X is: ~p~n",[X]
  end,
  TestPID ! ok,
  receive
    {X,Y} -> io:format("X is: ~p, Y is: ~p~n",[X, Y]
  end,
  TestPID ! terminate,
  receive
    Y -> io:format("Y is: ~p~n",[Y]
  end.

test(PID) -> 
  receive
   start -> PID ! 4,
     test(4, undefined, PID);
   terminate -> undefined
  end.

test(X, Y, PID) ->
  receive
    ok -> PID ! {X+5, (X+5)/5},
      test(X+5, (X+5)/5, PID);
    terminate -> PID ! Y
  end.

不要忘记创建模块并导出start_test / 0和test / 1

如果你运行start_test（），你应该得到一个输出

X is: 4
X is: 9, Y is: 1.8
Y is: 1.8