黯然#的苍凉 2024-07-13 19:45:32

仅当您的输入中没有空格时，以下内容才有效：

xargs -L 1
xargs --max-lines=1 # synonym for the -L option

从手册页：

-L max-lines
          Use at most max-lines nonblank input lines per command line.
          Trailing blanks cause an input line to be logically continued  on
          the next input line.  Implies -x.

The following will only work if you do not have spaces in your input:

xargs -L 1
xargs --max-lines=1 # synonym for the -L option

from the man page:

-L max-lines
          Use at most max-lines nonblank input lines per command line.
          Trailing blanks cause an input line to be logically continued  on
          the next input line.  Implies -x.

回复收藏 0 原文

北恋 2024-07-13 19:45:32

在我看来，这一页上所有现有的答案都是错误的，包括标记为正确的答案。这是因为这个问题的措辞含糊不清。

摘要： 如果您想执行命令“每行输入只执行一次”，将整行（不带换行符）作为单个参数传递给命令，那么这是最好的 UNIX 兼容方法：

... | tr '\n' '\0' | xargs -0 -n1 ...

如果您使用 GNU xargs 并且不需要与所有其他 UNIX（FreeBSD、Mac OS X 等）兼容，那么您可以使用GNU 特定选项 -d：

... | xargs -d\\n -n1 ...

现在进行详细解释……

使用 xargs 时需要考虑两个问题：

它如何将输入拆分为“参数”；以及
一次传递子命令的参数数量。

为了测试 xargs 的行为，我们需要一个实用程序来显示它被执行了多少次以及有多少个参数。我不知道是否有一个标准实用程序可以做到这一点，但我们可以很容易地在 bash 中对其进行编码：

#!/bin/bash
echo -n "-> "; for a in "$@"; do echo -n "\"$a\" "; done; echo

假设您将其另存为 show 在当前目录中并使其可执行，以下是如何执行的它有效：

$ ./show one two 'three and four'
-> "one" "two" "three and four"

现在，如果原来的问题确实是关于上面的第 2 点（正如我认为的那样，在读了几次之后），并且应该像这样阅读（更改为粗体）：

如何让 xargs 对给定输入的每个参数执行命令一次？它的默认行为是将输入分块为参数，并尽可能少地执行命令，并将多个参数传递给每个实例。嗯>

那么答案是-n 1。

让我们比较一下 xargs 的默认行为，它将输入围绕空格分割并尽可能少地调用命令：

$ echo one two 'three and four' | xargs ./show 
-> "one" "two" "three" "and" "four"

及其与 -n 1 的行为：

$ echo one two 'three and four' | xargs -n 1 ./show 
-> "one" 
-> "two" 
-> "three" 
-> "and" 
-> "four"

另一方面，如果原始问题是关于第1点.输入分割，它应该这样读（很多人来到这里似乎认为是这样，或者混淆了两个问题）：

如何让 xargs 对给定的每一行输入使用精确一个参数执行命令？它的默认行为是将行围绕空白进行分块。

那么答案就更微妙了。

人们可能会认为 -L 1 可能会有所帮助，但事实证明它不会改变参数解析。它只对每个输入行执行一次命令，并使用与该输入行上的参数一样多的参数：

$ echo 
不仅如此，如果一行以空格结尾，它会附加到下一行：
$ echo 
显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。
  以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。
  然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：
$ echo 
现在参数解析看起来没问题，包括尾随空格。
  最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：
$ echo 
如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：
$ echo 
one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four" 

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。
  以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。
  然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。
  最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" "two" 
-> "three" "and" "four" 

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。
  以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。
  然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。
  最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four" 

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。
  以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。
  然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。
  最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show 
-> "one " "two" "three and four" 

现在参数解析看起来没问题，包括尾随空格。
  最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 -n1 ./show -> "one " -> "two" -> "three and four"

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show -> "one " "two" "three and four"

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -d\\n -n1 ./show -> "one " -> "two" -> "three and four" one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show -> "one " "two" "three and four"

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 -n1 ./show -> "one " -> "two" -> "three and four"

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show -> "one " "two" "three and four"

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one \ntwo\nthree and four' | xargs -L 1 ./show -> "one" "two" -> "three" "and" "four"

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

one\ntwo\nthree and four' | xargs -L 1 ./show -> "one" -> "two" -> "three" "and" "four"

不仅如此，如果一行以空格结尾，它会附加到下一行：

显然， -L< /code> 并不是要改变 xargs 将输入拆分为参数的方式。

以跨平台方式（不包括 GNU 扩展）执行此操作的唯一参数是 -0，它将输入围绕 NUL 字节进行分割。

然后，只需在 tr 的帮助下将换行符转换为 NUL 即可：

现在参数解析看起来没问题，包括尾随空格。

最后，如果将此技术与 -n 1 结合起来，无论您有什么输入，每个输入行都会执行一个命令，这可能是查看原始问题的另一种方式（可能是最常见的）直观，给定标题）：

如上所述，如果您使用 GNU xargs，您可以将 tr 替换为 GNU 特定选项 -d >：

It seems to me all existing answers on this page are wrong, including the one marked as correct. That stems from the fact that the question is ambiguously worded.

Summary: If you want to execute the command "exactly once for each line of input," passing the entire line (without newline) to the command as a single argument, then this is the best UNIX-compatible way to do it:

... | tr '\n' '\0' | xargs -0 -n1 ...

If you are using GNU xargs and don't need to be compatible with all other UNIX's (FreeBSD, Mac OS X, etc.) then you can use the GNU-specific option -d:

... | xargs -d\\n -n1 ...

Now for the long explanation…

There are two issues to take into account when using xargs:

how does it split the input into "arguments"; and
how many arguments to pass the child command at a time.

To test xargs' behavior, we need an utility that shows how many times it's being executed and with how many arguments. I don't know if there is a standard utility to do that, but we can code it quite easily in bash:

#!/bin/bash
echo -n "-> "; for a in "$@"; do echo -n "\"$a\" "; done; echo

Assuming you save it as show in your current directory and make it executable, here is how it works:

$ ./show one two 'three and four'
-> "one" "two" "three and four"

Now, if the original question is really about point 2. above (as I think it is, after reading it a few times over) and it is to be read like this (changes in bold):

How can I make xargs execute the command exactly once for each argument of input given? Its default behavior is to chunk the input into arguments and execute the command as few times as possible, passing multiple arguments to each instance.

then the answer is -n 1.

Let's compare xargs' default behavior, which splits the input around whitespace and calls the command as few times as possible:

$ echo one two 'three and four' | xargs ./show 
-> "one" "two" "three" "and" "four"

and its behavior with -n 1:

$ echo one two 'three and four' | xargs -n 1 ./show 
-> "one" 
-> "two" 
-> "three" 
-> "and" 
-> "four"

If, on the other hand, the original question was about point 1. input splitting and it was to be read like this (many people coming here seem to think that's the case, or are confusing the two issues):

How can I make xargs execute the command with exactly one argument for each line of input given? Its default behavior is to chunk the lines around whitespace.

then the answer is more subtle.

One would think that -L 1 could be of help, but it turns out it doesn't change argument parsing. It only executes the command once for each input line, with as many arguments as were there on that input line:

$ echo 
Not only that, but if a line ends with whitespace, it is appended to the next:
$ echo 
Clearly, -L is not about changing the way xargs splits the input into arguments.
The only argument that does so in a cross-platform fashion (excluding GNU extensions) is -0, which splits the input around NUL bytes.
Then, it's just a matter of translating newlines to NUL with the help of tr:
$ echo 
Now the argument parsing looks all right, including the trailing whitespace.
Finally, if you combine this technique with -n 1, you get exactly one command execution per input line, whatever input you have, which may be yet another way to look at the original question (possibly the most intuitive, given the title):
$ echo 
As mentioned above, if you are using GNU xargs you can replace the tr with the GNU-specific option -d:
$ echo 
one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four" 

Not only that, but if a line ends with whitespace, it is appended to the next:

Clearly, -L is not about changing the way xargs splits the input into arguments.
The only argument that does so in a cross-platform fashion (excluding GNU extensions) is -0, which splits the input around NUL bytes.
Then, it's just a matter of translating newlines to NUL with the help of tr:

Now the argument parsing looks all right, including the trailing whitespace.
Finally, if you combine this technique with -n 1, you get exactly one command execution per input line, whatever input you have, which may be yet another way to look at the original question (possibly the most intuitive, given the title):

As mentioned above, if you are using GNU xargs you can replace the tr with the GNU-specific option -d:

one \ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" "two" 
-> "three" "and" "four" 

Clearly, -L is not about changing the way xargs splits the input into arguments.
The only argument that does so in a cross-platform fashion (excluding GNU extensions) is -0, which splits the input around NUL bytes.
Then, it's just a matter of translating newlines to NUL with the help of tr:

Now the argument parsing looks all right, including the trailing whitespace.
Finally, if you combine this technique with -n 1, you get exactly one command execution per input line, whatever input you have, which may be yet another way to look at the original question (possibly the most intuitive, given the title):

As mentioned above, if you are using GNU xargs you can replace the tr with the GNU-specific option -d:

one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four" 

Not only that, but if a line ends with whitespace, it is appended to the next:

Clearly, -L is not about changing the way xargs splits the input into arguments.
The only argument that does so in a cross-platform fashion (excluding GNU extensions) is -0, which splits the input around NUL bytes.
Then, it's just a matter of translating newlines to NUL with the help of tr:

Now the argument parsing looks all right, including the trailing whitespace.
Finally, if you combine this technique with -n 1, you get exactly one command execution per input line, whatever input you have, which may be yet another way to look at the original question (possibly the most intuitive, given the title):

As mentioned above, if you are using GNU xargs you can replace the tr with the GNU-specific option -d:

one \ntwo\nthree and four' | tr '\n' '\0' | xargs -0 ./show 
-> "one " "two" "three and four" 

Now the argument parsing looks all right, including the trailing whitespace.
Finally, if you combine this technique with -n 1, you get exactly one command execution per input line, whatever input you have, which may be yet another way to look at the original question (possibly the most intuitive, given the title):

As mentioned above, if you are using GNU xargs you can replace the tr with the GNU-specific option -d:

one\ntwo\nthree and four' | xargs -L 1 ./show 
-> "one" 
-> "two" 
-> "three" "and" "four"

Not only that, but if a line ends with whitespace, it is appended to the next:

Clearly, -L is not about changing the way xargs splits the input into arguments.

The only argument that does so in a cross-platform fashion (excluding GNU extensions) is -0, which splits the input around NUL bytes.

Then, it's just a matter of translating newlines to NUL with the help of tr:

Now the argument parsing looks all right, including the trailing whitespace.

Finally, if you combine this technique with -n 1, you get exactly one command execution per input line, whatever input you have, which may be yet another way to look at the original question (possibly the most intuitive, given the title):

As mentioned above, if you are using GNU xargs you can replace the tr with the GNU-specific option -d: