176

如何用空格连接列表中的两个字符串，例如：

["StringA", "StringB"]

变成

"StringA StringB"
4

9 回答 9

246

如果您只想加入一些任意列表：

"StringA" <> " " <> "StringB"

或者只使用字符串插值：

 "#{a} #{b}"

如果您的列表大小是任意的：

Enum.join(["StringA", "StringB"], " ")

...上述所有解决方案都将返回

"StringA StringB"
于 2013-12-29T19:43:17.513 回答
64

如果你有一个任意列表，那么你可以使用Enum.join，但如果它只是两个或三个，显式字符串连接应该更容易阅读

"StringA" <> " " <> "StringB"

但是，如果您要通过例如网络输出它，通常不需要将它作为单个字符串保存在内存中。在这种情况下，使用 iolist（一种特定类型的深度列表）可能是有利的，它可以避免复制数据。例如，

iex(1)> IO.puts(["StringA", " ", "StringB"])
StringA StringB
:ok

由于您会将这些字符串作为变量在某处使用，因此通过使用深层列表，您可以避免分配一个全新的字符串只是为了将其输出到其他地方。elixir/erlang 中的许多函数都理解 iolist，因此您通常不需要做额外的工作。

于 2013-12-31T14:11:34.880 回答
10

为了完整起见，您还可以使用字符串插值：

iex(1)> [a, b] = ["StringA", "StringB"]
iex(2)> "#{a} #{b}"
"StringA StringB"
于 2016-11-06T15:28:21.777 回答
9

有许多方法，但是知道它如何处理 nil 值可以确定您应该选择哪种方法。

这将引发错误

iex(4)> "my name is " <> "adam"
"my name is adam"

iex(1)> "my name is " <> nil
** (ArgumentError) expected binary argument in <> operator but got: nil
    (elixir) lib/kernel.ex:1767: Kernel.wrap_concatenation/3
    (elixir) lib/kernel.ex:1758: Kernel.extract_concatenations/2
    (elixir) lib/kernel.ex:1754: Kernel.extract_concatenations/2
    (elixir) expanding macro: Kernel.<>/2
    iex:1: (file)

这只会插入一个空白的 "" 字符串：

iex(1)> "my name is #{nil}"
"my name is "

就像这样：

iex(3)> Enum.join(["my name is", nil], " ")
"my name is "

还要考虑类型。与<>您一起没有任何免费铸造：

iex(5)> "my name is " <> 1
** (ArgumentError) expected binary argument in <> operator but got: 1
    (elixir) lib/kernel.ex:1767: Kernel.wrap_concatenation/3
    (elixir) lib/kernel.ex:1758: Kernel.extract_concatenations/2
    (elixir) lib/kernel.ex:1754: Kernel.extract_concatenations/2
    (elixir) expanding macro: Kernel.<>/2
    iex:5: (file)

iex(5)> "my name is #{1}"
"my name is 1"

iex(7)> Enum.join(["my name is", 1], " ")
"my name is 1"

实践中的表现似乎大致相同：

iex(22)> :timer.tc(fn -> Enum.each(1..10_000_000, fn _ -> "my name is " <> "adam" end) end)
{8023855, :ok}
iex(23)> :timer.tc(fn -> Enum.each(1..10_000_000, fn _ -> "my name is " <> "adam" end) end)
{8528052, :ok}
iex(24)> :timer.tc(fn -> Enum.each(1..10_000_000, fn _ -> "my name is " <> "adam" end) end)
{7778532, :ok}
iex(25)> :timer.tc(fn -> Enum.each(1..10_000_000, fn _ -> "my name is #{"adam"}" end) end)
{7620582, :ok}
iex(26)> :timer.tc(fn -> Enum.each(1..10_000_000, fn _ -> "my name is #{"adam"}" end) end)
{7782710, :ok}
iex(27)> :timer.tc(fn -> Enum.each(1..10_000_000, fn _ -> "my name is #{"adam"}" end) end)
{7743727, :ok}

因此，实际上取决于当插值是nil或错误类型时是否要崩溃。

于 2020-01-07T23:30:58.660 回答
7

这取决于你想要做什么。如果您只是想写出一个新变量，那么只需使用：

  • 字符串插值

    a = "StringA"
b = "StringB"
"#{a} #{b}"

  • 字符串连接："StringA" <> " " <> "StringB

  • Enum.join()：["StringA", "StringB"] |> Enum.join(" ")

但是，正如 Uri 所提到的，也可以使用 IOLists：

["StringA", " ", "StringB"] |> IO.iodata_to_binary

如果您需要关心资源消耗，IOList 实际上将是性能最高的。Big Nerd Ranch 对使用IOList 的性能提升有很好的描述。

于 2018-10-03T20:57:49.097 回答
5

如果您可以在列表中添加空格，则可以将其视为 iolist：

["StringA", " ", "StringB"] |> IO.iodata_to_binary # "StringA StringB"

这会给您一些性能提升，因为您不会复制内存中的任何字符串。

于 2016-09-28T18:56:08.727 回答
4

Enum.reduce 也适用于您的示例，不是吗？

iex(4)> Enum.reduce(["StringA", "StringB"], fn(x, acc) -> x <> " " <> acc end) "StringB StringA"

于 2014-03-10T17:40:34.730 回答
0

你也可以做'string A' ++ ' ' ++ 'string B'

于 2014-04-01T07:27:33.127 回答
0

考虑使用 IO 列表，如果您有 ["String1", "string2"] 并且在其上使用 iolist_to_binary/1，那么您会将这些字符串复制到一个新字符串中。如果你有一个 IO 列表，你可以在大多数情况下输出它，它会在端口上连接它。这是关键，运行时不需要复制数据，因此它比串联更有效。

于 2018-10-22T09:40:36.140 回答