我正在寻找一个命令，它将接受输入多行文本，每行包含一个整数，并输出这些整数的和。
作为一点背景，我有一个包含计时测量的日志文件，因此通过对相关行进行grepping，以及一点sed重新格式化，我可以列出该文件中的所有计时。不过，我想算出总数，我的脑子里一片空白，我可以把这个中间输出连接到任何命令上，以完成最后的求和。我过去一直使用expr，但除非它以rpn模式运行，否则我认为它无法应付这种情况(即使这样也很棘手)。
我错过了什么？考虑到可能有几种方法可以实现这一点，我很乐意阅读(并赞成)任何有效的方法，即使其他人已经发布了完成这项工作的不同解决方案。
相关问题：在Unix上计算输出列总和的最短命令？(安德鲁的学分)
更新：哇，正如预期的，这里有一些不错的答案。看来，作为一个通用的命令行工具，我一定要对awk进行更深入的检查！
这和我刚才问的一个问题非常相似：stackoverflow.com/questions/295781/&hellip；
我真的很喜欢这个问题，因为有很多可能的正确(或至少有效)答案。
这个问题对于代码高尔夫来说是个问题。codegolf.stackexchange.com:)
一点锥子应该做吗？
awk '{s+=$1} END {print s}' mydatafile
注意：如果要添加超过2^31(2147483647)的内容，一些版本的awk会有一些奇怪的行为。有关更多背景信息，请参见注释。一个建议是使用printf，而不是print：
awk '{s+=$1} END {printf"%.0f", s}' mydatafile
这个房间里有很多疯狂的爱！我喜欢这样一个简单的脚本如何被修改，仅仅通过将$1更改为$2就可以添加第二列数据。
锥子的极限是什么？也就是说，在死亡之前它能处理多少数据元素？或者成为使用小C代码片段的不太可取的方法？
没有实际限制，因为它将把输入作为流处理。所以，如果它能处理一个x行的文件，你可以很确定它能处理x+1。
我曾经写过一个基本的邮件列表处理程序，它有一个awk脚本，通过vaisage实用程序运行。好时光。：)
只是在a:count所有文档的页面中使用了这个脚本：EDOCX1[2]
是的，我要说的是你也可以把数据传输到awk…cat file.csv | cut -d, -f3 | awk '{s+=$1} END {print s}'
如何修改此项以使用浮动，例如包含123456.789之类数字的行？当你在会计系统中翻阅一大堆文件时，这段代码非常有用。
awk使用双精度浮点数，所以它应该可以正常工作。无论浮动是否适合会计核算，我都会让你来判断：)
对于像我这样不了解awk的人……查看此链接以获得超级快速介绍
awk断纸，适用于大量纸(注：Paste+BC继续工作)。
小心，它不能与大于2147483647(即2^31)的数字一起使用，这是因为awk使用32位有符号整数表示。用awk '{s+=$1} END {printf"%.0f", s}' mydatafile代替。
正如@giancarlosportelli所说，下面的解决方案更好——打印时不存在整数溢出，请参阅stackoverflow.com/a/25245025/992887
我想如果你有什么问题要问"我一直在寻找一个执行x的shell命令，但我找不到一个"。你或任何人应该得到的第一个回答是"你试过了吗？"
哈哈，我用锥子来提取这个有趣的数字。现在我看到Chrome实际上总共使用了几乎2GB的内存：)
@我只想加2美分。您可以在64位系统上使用"%ld"将数字保持为64位int，根本不需要转换。echo"2147483647
2147483647
2147483647
2147483647" | awk '{s+=$1} END {printf("%ld
", s)}'
与其他答案不同的是，即使数据中有空行，这个答案也能工作。
看看这个-在最后一个变量被打印出来之前，怎么"打印"一些东西呢？总共$I S
如果其中有不包含数字的行，会发生什么？如何过滤它们？
请注意，awk不知道整数是什么。它的所有数学运算都是双精度的。因此，只有达到2^53的所有数字才可表示。从那一点开始，它就错了：awk 'BEGIN{print 2^53-1, 2^53, 2^53+1}' => 9007199254740991 9007199254740992 9007199254740992。
粘贴通常合并多个文件的行，但也可用于将文件的单个行转换为单个行。分隔符标志允许您将x+x类型的公式传递给bc。
paste -s -d+ infile | bc
或者，当从stdin进行管道连接时，
| paste -s -d+ - | bc
很不错的！我本来会在"+"前面放一个空格，只是为了帮助我更好地解析它，但这对于通过粘贴和BC来传递一些内存号非常方便。
使用BC或DC的解决方案正是我所寻找的解决类似问题的方法。我不太了解它，而且它似乎还未被充分利用，所以很高兴看到别人知道如何使用它。我怀疑它比其他解决方案快得多，尤其是在输入中有很多行的情况下。
比awk解决方案更容易记住和输入。另外，请注意，paste可以使用破折号-作为文件名，这样您就可以将命令输出中的数字通过管道传输到Paste的标准输出中，而无需先创建文件：| paste -sd+ - | bc。
我发现这个解决方案比使用一种成熟的编程语言(如awk/perl/python)要简单得多。夸奖！
令人惊叹的！只是用这个来总结所有核心的bogomips:cat/proc/cpuinfo grep bogo cut-d:-f2 paste-sd+bc
我有一份有1亿个数字的档案。awk命令需要21秒；paste命令需要41秒。但是很好地满足了"paste"的要求！
@阿卜希：有趣的是：我想我要花20分钟才能弄清楚awk命令，这样它就均匀了，直到我尝试1亿和1个数字：d
@艾比：看看答案。在我的机器上，awk出现了大量故障，但paste和bc工作。
@乔治，你可以把埃多克斯一号(12号)排除在外。(如果您想将文件与stdin结合在一起，这很有用)。
这不喜欢文件中的"^m"字符，但一旦修复，快乐快乐快乐。
@在管道中使用时，不能遗漏-。echo -e"1
2
3" | paste -sd+不起作用，但额外的-起作用。
@markkcowan bc使用任意精度，我猜awk可能使用32或64位算术，可能导致溢出。
@因果关系，那么它可能是版本相关的；它在这里与gnu coreutils 8.24(fedora 23)一起工作；您在最后一个注释中的代码生成1+2+3。
请注意，有些shell中不包括bc，比如用于Windows的git bash。
@10basetom这是因为bc不是shell内置的(所以它不包括在任何shell中)，而是一个单独的程序(在任何un*x机器上都是相当标准的)
@UML&覜ute我知道为什么它不包含在某些shell中——我指出了这一点，这样人们就可以考虑其他解决方案，如果他们的目标是可移植性的话。
有没有安装BC的问题，最后用echo $(( $( | paste -s -d+ -) ))来评估答案
@乔治和@abhi…因此，awk解决方案更容易记住…更快。双赢。
python中的一行程序版本：
$ python -c"import sys; print(sum(int(l) for l in sys.stdin))"
上面的一行程序不适用于sys.argv[]中的文件，但它适用于stackoverflow.com/questions/450799/&hellip；
是的-作者说他将把另一个脚本的输出通过管道传输到命令中，我试图尽可能缩短它的长度：)
较短的版本是python -c"import sys; print(sum(map(int, sys.stdin)))"。
我喜欢这个答案，因为它易于阅读和灵活。我需要一组目录中小于10MB的文件的平均大小，并将其修改为：find . -name '*.epub' -exec stat -c %s '{}' \; | python -c"import sys; nums = [int(n) for n in sys.stdin if int(n) < 10000000]; print(sum(nums)/len(nums))"。
非常灵活的解决方案。也可用于浮点数，只需将int替换为float
如果在：import sys; print(sum(int(''.join(c for c in l if c.isdigit())) for l in sys.stdin))中混合了一些文本，也可以过滤掉非数字。
我将对普遍认可的解决方案提出一个重大警告：
awk '{s+=$1} END {print s}' mydatafile # DO NOT USE THIS!!
这是因为在这种形式中，awk使用32位有符号整数表示：对于超过2147483647(即2^31)的和，它将溢出。
更一般的答案(对于整数求和)是：
awk '{s+=$1} END {printf"%.0f
", s}' mydatafile # USE THIS INSTEAD
另外，我本想对第一个答案发表评论，但我没有足够的声誉。
为什么printf()在这里有帮助？int的溢出将在此之前发生，因为求和代码是相同的。
因为问题实际上是在"print"函数中。awk使用64位整数，但出于某种原因，print不将其定为32位。
打印错误似乎已被修复，至少对于awk 4.0.1&bash 4.3.11是这样，除非我弄错了：echo -e"2147483647
100" |awk '{s+=$1}END{print s}'显示2147483747。
使用浮动只会带来一个新问题：echo 999999999999999999 | awk '{s+=$1} END {printf"%.0f
", s}'产生1000000000000000000。
平原狂欢：
$ cat numbers.txt
1
2
3
4
5
6
7
8
9
10
$ sum=0; while read num; do ((sum += num)); done < numbers.txt; echo $sum
55
一个较小的一行程序：stackoverflow.com/questions/450799/&hellip；
@Rjack，num在哪里定义？我相信它与< numbers.txt的表达有某种联系，但不清楚是如何联系的。
@在while表达式中，它是read num的东西。
dc -f infile -e '[+z1
注意，以减号为前缀的负数应该翻译为dc，因为它使用_前缀，而不是-前缀。例如，通过tr '-' '_' | dc -f- -e '...'。编辑：因为这个答案得到了很多选票，所以下面是一个详细的解释：
表达式[+z1执行以下操作：
[ interpret everything to the next ] as a string
+ push two values off the stack, add them and push the result
z push the current stack depth
1 push one
is smaller
] end of the string, will push the whole thing to the stack
sr pop a value (the string above) and store it in register r
z push the current stack depth again
1 push 1
is smaller
p print the current top-of-stack
作为伪代码：
将"添加栈顶"定义为：
从堆栈中移除两个顶部值并将结果添加回
如果堆栈有两个或多个值，则递归运行"添加堆栈的顶部"
如果堆栈有两个或多个值，请运行"添加堆栈的顶部"
打印结果，现在是堆栈中唯一剩下的项
为了真正理解dc的简单性和强大性，这里有一个可工作的python脚本，它实现了dc中的一些命令，并执行了上述命令的python版本：
### Implement some commands from dc
registers = {'r': None}
stack = []
def add():
stack.append(stack.pop() + stack.pop())
def z():
stack.append(len(stack))
def less(reg):
if stack.pop() < stack.pop():
registers[reg]()
def store(reg):
registers[reg] = stack.pop()
def p():
print stack[-1]
### Python version of the dc command above
# The equivalent to -f: read a file and push every line to the stack
import fileinput
for line in fileinput.input():
stack.append(int(line.strip()))
def cmd():
add()
z()
stack.append(1)
less('r')
stack.append(cmd)
store('r')
z()
stack.append(1)
less('r')
p()
DC只是选择使用的工具。但我会用更少的堆栈操作来完成。假设所有行确实包含一个数字：(echo"0"; sed 's/$/ +/' inp; echo 'pq')|dc。
在线算法：dc -e '0 0 [+?z1。所以在处理之前，我们不保存堆栈上的所有数字，而是逐个读取和处理它们(更精确地说，逐行，因为一行可以包含多个数字)。注意，空行可以终止输入序列。
@伊克拉比，太好了。实际上，它可以再缩短一个字符：可以删除sed替换中的空格，因为dc不关心参数和运算符之间的空格。(echo"0"; sed 's/$/+/' inputFile; echo 'pq')|dc
使用JQ：
seq 10 | jq -s 'add' # 'add' is equivalent to 'reduce .[] as $item (0; . + $item)'
我喜欢这个，因为我想它是如此的清晰和简短，我可能真的能够记住它。
纯粹而短暂的狂欢。
f=$(cat numbers.txt)
echo $(( ${f//$'
'/+} ))
这是最好的解决方案，因为如果用f=$(替换第一行，它不会创建任何子进程。
有没有办法从stdin获得输入？就像从管子里？
@njzk2如果您将f=$(cat); echo $(( ${f//$'
'/+} ))放入脚本中，那么您可以将任何内容通过管道发送到该脚本，或者在没有用于交互式stdin输入的参数的情况下调用该脚本(使用control-d终止)。
@loentar the 是一个改进，但总的来说，这个解决方案只对小的输入文件有效；例如，对于1000个输入行的文件，我的机器上接受的awk解决方案大约快20倍，而且消耗的内存也更少，因为文件不是一次性读取的。
当我到达这个地方时，我几乎失去了希望。纯巴什！
我的使用停止：f=$(find-iname'*-2014-*'-exec du cut-f1)；echo$($f//$''+))。可能会帮助别人。
与awk解决方案相比，bash解决方案的一个优点是，它给出了一个整数结果，即使对于较大的数字也是如此。对于大数字，awk以科学记数法返回结果。
这个答案不是纯粹的bash，因为cat是一个外部调用。请参阅已接受的答案的awk '{s+=$1}END{printf"%f",s}' mydatafile，以获得在输入太大的情况下不会失败的更快解决方案。负载时间差异(cat的43K与mawk的128K甚至gawk的659K在我的系统上)永远无法克服性能差异…除非你经常这样做，在这种情况下，使用更多的awk或其他"真正的"语言。
perl -lne '$x += $_; END { print $x; }' < infile.txt
我已经移除了-l和
我把它们加回去："-l"确保输出以shell`` backticks和大多数程序预期的方式终止，并且"
你是对的。作为一个借口：PerlOne行程序中的每个字符都需要我进行心理工作，因此我更喜欢尽可能多地去掉字符。这种习惯在这种情况下是有害的。
不用担心，J.F.：)
少数不将所有内容加载到RAM中的解决方案之一。
我的十五美分：
$ cat file.txt | xargs | sed -e 's/\ /+/g' | bc
例子：
$ cat text
1
2
3
3
4
5
6
78
9
0
1
2
3
4
576
7
4444
$ cat text | xargs | sed -e 's/\ /+/g' | bc
5148
我的输入可能包含空行，所以我使用了你在这里发布的内容加上一个grep -v '^$'。谢谢！
真的！！你的回答太棒了！我个人的最爱
喜欢这个，管道+1。对我来说非常简单和简单的解决方案
bash解决方案，如果您想将其作为命令(例如，如果您需要经常这样做的话)：
addnums () {
local total=0
while read val; do
(( total += val ))
done
echo $total
}
然后使用：
addnums < /tmp/nums
我已经在现有答案上做了一个快速基准测试，
只使用标准工具(对lua或rocket之类的东西感到抱歉)。
是真正的一句话，
能够增加大量的数字(1亿)，以及
速度很快(我忽略了那些花了一分钟以上的时间)。
我总是添加1到1亿个数字，这在我的机器上可以在不到一分钟的时间内实现几个解决方案。
结果如下：Python
:; seq 100000000 | python -c 'import sys; print sum(map(int, sys.stdin))'
5000000050000000
# 30s
:; seq 100000000 | python -c 'import sys; print sum(int(s) for s in sys.stdin)'
5000000050000000
# 38s
:; seq 100000000 | python3 -c 'import sys; print(sum(int(s) for s in sys.stdin))'
5000000050000000
# 27s
:; seq 100000000 | python3 -c 'import sys; print(sum(map(int, sys.stdin)))'
5000000050000000
# 22s
:; seq 100000000 | pypy -c 'import sys; print(sum(map(int, sys.stdin)))'
5000000050000000
# 11s
:; seq 100000000 | pypy -c 'import sys; print(sum(int(s) for s in sys.stdin))'
5000000050000000
# 11s
AWK
:; seq 100000000 | awk '{s+=$1} END {print s}'
5000000050000000
# 22s
粘贴与BC
我的机器内存不足。它的工作规模只有输入的一半(5000万个数字)：
:; seq 50000000 | paste -s -d+ - | bc
1250000025000000
# 17s
:; seq 50000001 100000000 | paste -s -d+ - | bc
3750000025000000
# 18s
所以我想1亿个数字大概需要35秒。珀尔
:; seq 100000000 | perl -lne '$x += $_; END { print $x; }'
5000000050000000
# 15s
:; seq 100000000 | perl -e 'map {$x += $_} <> and print $x'
5000000050000000
# 48s
红宝石
:; seq 100000000 | ruby -e"puts ARGF.map(&:to_i).inject(&:+)"
5000000050000000
# 30s
C
为了比较起见，我编译了C版本并测试了它，只是想知道基于工具的解决方案有多慢。
#include
int main(int argc, char** argv) {
long sum = 0;
long i = 0;
while(scanf("%ld", &i) == 1) {
sum = sum + i;
}
printf("%ld
", sum);
return 0;
}
nbsp；
:; seq 100000000 | ./a.out
5000000050000000
# 8s
结论
c当然是8s速度最快的，但是pypy解决方案只增加了大约30%到11s的一点开销，但公平地说，pypy并不完全是标准的。大多数人只安装了cpython，它的速度明显较慢(22秒)，与流行的awk解决方案一样快。
基于标准工具的最快解决方案是Perl(15s)。
paste＋bc方法正是我想要求和十六进制值的方法，谢谢！
只是为了好玩，生锈的：use std::io::{self, BufRead}; fn main() { let stdin = io::stdin(); let mut sum: i64 = 0; for line in stdin.lock().lines() { sum += line.unwrap().parse::().unwrap(); } println!("{}", sum); }。
素巴什一衬
$ cat > /tmp/test
1
2
3
4
5
^D
$ echo $(( $(cat /tmp/test | tr"
""+" ) 0 ))
不需要猫：echo $(( $( tr"
""+" < /tmp/test) 0 ))。
tr并不是一个"普通的巴什/挑剔的人"
您可以使用num-utils，尽管它可能会对您需要的东西造成过度杀伤力。这是一组用于在shell中操作数字的程序，可以做一些漂亮的事情，当然包括将它们相加。这有点过时了，但它们仍然有效，如果你需要做更多的事情，它们也会很有用。
http://suso.suso.org/programs/num-utils/
示例：numsum numbers.txt。
bash中的以下工作：
I=0
for N in `cat numbers.txt`
do
I=`expr $I + $N`
done
echo $I
当文件可以任意大时，应小心使用命令扩展。如果numbers.txt为10MB，那么cat numbers.txt步骤将有问题。
然而，实际上(如果不是这里找到的更好的解决方案)，我会使用这个直到我真正遇到那个问题。
mywiki.wooledge.org/dontreadlineswithfor
我认为awk是你想要的：
awk '{sum+=$1}END{print sum}'
可以通过将数字列表通过标准输入传递或将包含数字的文件作为参数传递来使用此命令。
它是一个dup:stackoverflow.com/questions/450799/&hellip；
sed 's/^/.+/' infile | bc | tail -1
我意识到这是一个老问题，但我非常喜欢这个解决方案来分享它。
% cat > numbers.txt
1
2
3
4
5
^D
% cat numbers.txt | perl -lpe '$c+=$_}{$_=$c'
15
如果有兴趣，我会解释它是如何工作的。
请不要。我们喜欢假装-n和-p是很好的语义，而不仅仅是一些巧妙的字符串粘贴；)
是的，请解释一下：(我不是Perl类型的人。)
尝试运行"perl-mo=deparse-lpe'$c+=$u u=$c'"，查看输出，基本上-l使用换行符和输入和输出分隔符，并且-p打印每一行。但是为了做到"-p"，Perl首先添加了一些锅炉板(它-mo=deparse)将向您显示，但随后它只是替换并编译。因此，您可以使用""部分插入一个额外的块，并使其不在每行上打印，而是在最后打印。
纯bash和一行程序中：—)
$ cat numbers.txt
1
2
3
4
5
6
7
8
9
10
$ I=0; for N in $(cat numbers.txt); do I=$(($I + $N)); done; echo $I
55
为什么有两个((圆括号))？
好吧，我想(参考)。
mywiki.wooledge.org/dontreadlineswithfor
不是因为猫的缘故才有的。用$(< numbers.txt)取代cat，使之成为纯粹的bash
红宝石情人
ruby -e"puts ARGF.map(&:to_i).inject(&:+)" numbers.txt
可选纯Perl，可读性较好，不需要任何软件包或选项：
perl -e"map {$x += $_} <> and print $x" < infile.txt
或者稍微短一点：perl-e'map$x+=$<>；print$x'infile.txt
我的版本：
seq -5 10 | xargs printf"- - %s" | xargs | bc
较短：seq -s+ -5 10 | bc。
如果你觉得舒服，你可以用python来做：
未测试，只键入：
out = open("filename").read();
lines = out.split('
')
ints = map(int, lines)
s = sum(ints)
print s
塞巴斯蒂安指出，一行文字：
cat filename | python -c"from fileinput import input; print sum(map(int, input()))"
python-c"从fileinput导入输入；打印和(map(int，input()))"numbers.txt
或cat numbers.txt python-c"，来自…
如果你喜欢的话，在答案中包括上面的代码。
cat使用过度，将stdin从文件：python-c"…"@rjack:cat用于演示脚本对stdin和argv[]中的文件都有效(如perl中的while(<>))。如果输入在文件中，则不需要"
但是，< numbers.txt表明，它在stdin上的效果和cat numbers.txt |一样好。而且它也不会让人养成坏习惯。
以下内容应该有效(假设您的数字是每行的第二个字段)。
awk 'BEGIN {sum=0} \
{sum=sum + $2} \
END {print"tot:", sum}' Yourinputfile.txt
你不需要和=0部分
球拍中有一个衬垫：
racket -e '(define (g) (define i (read)) (if (eof-object? i) empty (cons i (g)))) (foldr + 0 (g))' < numlist.txt
C(不简化)
seq 1 10 | tcc -run
#include
int main(int argc, char** argv) {
int sum = 0;
int i = 0;
while(scanf("%d", &i) == 1) {
sum = sum + i;
}
printf("%d
", sum);
return 0;
}
EOF)
(是的，我觉得无聊，打了代码高尔夫)
无法避免提交此：
jot 1000000 | sed '2,$s/$/+/;$s/$/p/' | dc
在这里可以找到：最优雅的unix shell一行程序来求和任意精度的数字列表？
与awk、bc和friends相比，它的特殊优势如下：
它不依赖于缓冲，因此不会因输入太大而窒息。
这意味着没有特别的精度或整数大小限制。
如果需要添加浮点数，则无需使用不同的代码
请在答案中包含与问题相关的代码，不要引用链接
您可以使用首选的"expr"命令，只需先稍微混合一下输入即可：
seq 10 | tr '[
]' '+' | sed -e 's/+/ + /g' -e's/ + $/
/' | xargs expr
这个过程是：
"tr"用+符号替换eoln字符，
SED用两边的空格填充"+"，然后从行中去掉最后的"+"
xargs将管道输入插入到命令行中，以便expr使用。
实时总结，让您监控一些数字处理任务的进度。
$ cat numbers.txt
1
2
3
4
5
6
7
8
9
10
$ cat numbers.txt | while read new; do total=$(($total + $new)); echo $total; done
1
3
6
10
15
21
28
36
45
55
(在这种情况下，不需要将$total设置为零。完成后，您也不能访问$total。)
$ cat n
2
4
2
7
8
9
$ perl -MList::Util -le 'print List::Util::sum(<>)' < n
32
或者，您可以在命令行中键入数字：
$ perl -MList::Util -le 'print List::Util::sum(<>)'
1
3
5
^D
9
但是，这一个会弄脏文件，因此在大型文件上使用不是一个好主意。参见J_Random_Hacker的回答，避免含糊不清。
C++(简体)：
echo {1..10} | scc 'WRL n+=$0; n'
SCC项目-http://volnitsky.com/project/scc/
SCC是shell提示符下的C++代码段评估器
为backticks("`")的可读性提前道歉，但这些代码在bash之外的shell中工作，因此更易于粘贴。如果您使用接受它的shell，那么$(command…)格式的可读性(因而可调试)要比'command…'格式高得多，因此请随意修改以保持清醒。
我在bashrc中有一个简单的函数，它将使用awk计算一些简单的数学项。
calc(){
awk 'BEGIN{print '"$@"' }'
}
这将执行+、-、*、/、^、%、sqrt、sin、cos、括号….(以及更多操作，具体取决于您的awk版本)。您甚至可以对printf和格式浮点输出感兴趣，但这正是我通常需要的。
对于这个特定的问题，我只需为每一行执行以下操作：
calc `echo"$@"|tr"""+"`
因此，每行求和的代码块如下所示：
while read LINE || ["$LINE" ]; do
calc `echo"$LINE"|tr"""+"` #you may want to filter out some lines with a case statement here
done
如果你只想逐行求和的话。但是，对于数据文件中每个数字的总数
VARS=`
calc `echo ${VARS// /+}`
顺便说一句，如果我需要在桌面上快速地做一些事情，我使用这个：
xcalc() {
A=`calc"$@"`
A=`Xdialog --stdout --inputbox"Simple calculator" 0 0 $A`
[ $A ] && xcalc $A
}
你用的是哪种不支持$()的古贝壳？
使用env变量tmp
tmp=awk -v tmp="$tmp" '{print $tmp""$1}' |echo $tmp|sed"s/ /+/g"|bc
tmp=cat |awk -v tmp="$tmp" '{print $tmp""$1}'|echo $tmp|sed"s/ /+/g"|bc
谢谢。
为了完整起见，还有一个R解决方案
seq 1 10 | R -q -e"f
所有基于Fedora的系统(Fedora、Rhel、Centos、Korora等)上都有一个Lua解释器，因为它嵌入了RPM包(包管理器RPM的包)，即RPM Lua)，如果你想学习Lua，这种问题是理想的(你也可以完成你的工作)。
cat filname | lua -e"sum = 0;for i in io.lines() do sum=sum+i end print(sum)"
它起作用了。Lua很冗长，不过，你可能不得不忍受一些重复的键盘敲击伤害：)
您可以使用alacon命令行实用程序对alasql数据库执行此操作。
它与node.js一起工作，因此需要先安装node.js，然后安装alasql包：
要从stdin计算总和，可以使用以下命令：
> cat data.txt | node alacon"SELECT VALUE SUM([0]) FROM TXT()">b.txt
一个篮板内胆：
rebol -q --do 's: 0 while [d: input] [s: s + to-integer d] print s' < infile.txt
不幸的是，上面的代码还不能在REBOL3中工作(输入没有流式stdin)。
所以这里有一个临时的解决方案，也适用于REBOL 3：
rebol -q --do 's: 0 foreach n to-block read %infile.txt [s: s + n] print s'
…和PHP版本，只是为了完整性
cat /file/with/numbers | php -r '$s = 0; while (true) { $e = fgets(STDIN); if (false === $e) break; $s += $e; } echo $s;'
可以更短：seq 1 10_php-r'echo array_sum(file("php://stdin"))。吡喹酮；
#include
int main()
{
double x = 0, total = 0;
while (std::cin >> x)
total += x;
if (!std::cin.eof())
return 1;
std::cout << x << '
';
}
一个简单的解决方案是编写一个程序来为您完成这项工作。这可能在python中很快就能完成，比如：
sum = 0
file = open("numbers.txt","R")
for line in file.readlines(): sum+=int(line)
file.close()
print sum
我还没有测试过这个代码，但看起来不错。只需将numbers.txt更改为文件名，将代码保存到名为sum.py的文件中，并在控制台中键入"python sum.py"
调用readlines()将整个文件读取到内存中-最好使用"for line in file"
使用GNU datamash工具：
seq 10 | datamash sum 1
输出：
55
简单PHP
cat numbers.txt | php -r"echo array_sum(explode(PHP_EOL, stream_get_contents(STDIN)));"