我有一个巨大的（70GB），一行，文本文件，我想替换其中的一个字符串（令牌）。我想<unk>用另一个虚拟令牌替换该令牌（手套发行）。

我试过了sed：

sed 's/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

但是输出文件corpus.txt.new有零字节！

我也尝试使用perl：

perl -pe 's/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

但是我遇到了内存不足的错误。

对于较小的文件，以上两个命令均有效。

如何替换这样的文件字符串？ 这是一个相关的问题，但是没有一个答案对我有用。

编辑：将文件分成10GB（或其他大小）的块，然后分别应用于sed每个文件，然后与它们合并，该cat怎么办？那有意义吗？有没有更优雅的解决方案？

普通的文本处理工具并非旨在处理RAM中不适合的行。他们倾向于通过读取一条记录（一行），对其进行操作并输出结果，然后进行下一条记录（一行）来工作。

如果某个ASCII字符经常出现在文件中，而没有出现在<unk>或中<raw_unk>，则可以将其用作记录分隔符。由于大多数工具不允许自定义记录分隔符，因此请在该字符和换行符之间进行交换。tr处理字节而不是行，因此它不关心任何记录大小。假设可行;：

<corpus.txt tr '\n;' ';\n' |
sed 's/<unk>/<raw_unk>/g' |
tr '\n;' ';\n' >corpus.txt.new

您还可以锚定要搜索的文本的第一个字符，前提是该字符不会在搜索文本中重复出现并且显示频率很高。如果文件开头为unk>，请更改sed命令sed '2,$ s/…以避免虚假匹配。

<corpus.txt tr '\n<' '<\n' |
sed 's/^unk>/raw_unk>/g' |
tr '\n<' '<\n' >corpus.txt.new

或者，使用最后一个字符。

<corpus.txt tr '\n>' '>\n' |
sed 's/<unk$/<raw_unk/g' |
tr '\n>' '>\n' >corpus.txt.new

请注意，该技术假定sed在不以换行符结尾的文件上无缝运行，即，它处理最后的部分行而不会被截断，也不会添加最终的换行符。它与GNU sed一起使用。如果您可以选择文件的最后一个字符作为记录分隔符，则可以避免任何可移植性麻烦。

对于这么大的文件，Flex就是一种可能。令unk.l是：

%%
\<unk\>     printf("<raw_unk>");  
%%

然后编译并执行：

$ flex -o unk.c  unk.l
$ cc -o unk -O2 unk.c -lfl
$ unk < corpus.txt > corpus.txt.new

因此，您没有足够的物理内存（RAM）来一次容纳整个文件，但是在64位系统上，您有足够的虚拟地址空间来映射整个文件。在这种情况下，虚拟映射可用作简单的技巧。

所有必需的操作都包含在Python中。有一些烦人的微妙之处，但确实避免了编写C代码的麻烦。特别是，需要注意避免将文件复制到内存中，这将完全破坏这一点。从好的方面来说，您可以免费获得错误报告（python“ exceptions”）:)。

#!/usr/bin/python3
# This script takes input from stdin
# (but it must be a regular file, to support mapping it),
# and writes the result to stdout.

search = b'<unk>'
replace = b'<raw_unk>'


import sys
import os
import mmap

# sys.stdout requires str, but we want to write bytes
out_bytes = sys.stdout.buffer

mem = mmap.mmap(sys.stdin.fileno(), 0, access=mmap.ACCESS_READ)
i = mem.find(search)
if i < 0:
    sys.exit("Search string not found")

# mmap object subscripts to bytes (making a copy)
# memoryview object subscripts to a memoryview object
# (it implements the buffer protocol).
view = memoryview(mem)

out_bytes.write(view[:i])
out_bytes.write(replace)
out_bytes.write(view[i+len(search):])

我认为C版本的性能可能会更好：

#include <stdio.h>
#include <string.h>

#define PAT_LEN 5

int main()
{
    /* note this is not a general solution. In particular the pattern
     * must not have a repeated sequence at the start, so <unk> is fine
     * but aardvark is not, because it starts with "a" repeated, and ababc
     * is not because it starts with "ab" repeated. */
    char pattern[] = "<unk>";          /* set PAT_LEN to length of this */
    char replacement[] = "<raw_unk>"; 
    int c;
    int i, j;

    for (i = 0; (c = getchar()) != EOF;) {
        if (c == pattern[i]) {
            i++;
            if (i == PAT_LEN) {
                printf("%s", replacement);
                i = 0;
            }
        } else {
            if (i > 0) {
                for (j = 0; j < i; j++) {
                    putchar(pattern[j]);
                }
                i = 0;
            }
            if (c == pattern[0]) {
                i = 1;
            } else {
                putchar(c);
            }
        }
    }
    /* TODO: fix up end of file if it ends with a part of pattern */
    return 0;
}

编辑：根据评论的建议进行了修改。还修复了模式错误<<unk>。

replacemariadb-server / mysql-server软件包中有一个实用程序。它替换了简单的字符串（不是正则表达式），并且与grep / sed / awk不同，replace它不关心\nand \0。内存消耗对于任何输入文件都是恒定的（在我的机器上约为400kb）。

当然，您不需要运行mysql服务器即可使用replace，它仅以这种方式打包在Fedora中。其他发行版/操作系统可能会将其单独包装。

GNU grep可以向您显示“二进制”文件中的匹配偏移量，而无需将整行读入内存。然后，您可以使用dd来读取此偏移量，跳过匹配项，然后继续从文件中复制。

file=...
newfile=...
replace='<raw_unk>'
grep -o -b -a -F '<unk>' <"$file" |
(   pos=0
    while IFS=$IFS: read offset pattern
    do size=${#pattern}
       let skip=offset-pos
       let big=skip/1048576
       let skip=skip-big*1048576
       dd bs=1048576 count=$big <&3
       dd bs=1 count=$skip <&3
       dd bs=1 count=$size of=/dev/null <&3
       printf "%s" "$replace"
       let pos=offset+size
    done
    cat <&3
) 3<"$file" >"$newfile"

为了提高速度，我将其dd拆分为大块读取的块大小1048576和一次较小的读取的1字节，但是对于如此大的文件，此操作仍然会有点慢。的grep输出是，例如，13977:<unk>，这是由读取到变量对结肠分割offset和pattern。我们必须跟踪pos已经从文件中复制了多少字节。

这是另一个UNIX命令行，它可能比其他选项性能更好，因为您可以“寻找”性能良好的“块大小”。为了使这种方法更可靠，您需要知道每个X字符中至少有一个空格，其中X是您的任意“块大小”。在下面的示例中，我选择了1024个字符的“块大小”。

fold -w 1024 -s corpus.txt | sed 's/<unk>/<raw_unk>/g' | tr '/n' '/0'

在这里，fold 最多可以抓取1024个字节，但是-s可以确保它自上次中断以来至少有一个中断在一个空格上中断。

sed命令是您的命令，可以执行您期望的操作。

然后，tr命令将“展开”文件，将插入的换行符恢复为空。

您应该考虑尝试更大的块大小，以查看其执行速度是否更快。对于fold的-w选项，您可以尝试使用10240和102400和1048576而不是1024。

这是一个按步骤分解的示例，该步骤将所有N都转换为小写：

[root@alpha ~]# cat mailtest.txt
test XJS C4JD QADN1 NSBN3 2IDNEN GTUBE STANDARD ANTI UBE-TEST EMAIL*C.34X test

[root@alpha ~]# fold -w 20 -s mailtest.txt
test XJS C4JD QADN1
NSBN3 2IDNEN GTUBE
STANDARD ANTI
UBE-TEST
EMAIL*C.34X test

[root@alpha ~]# fold -w 20 -s mailtest.txt | sed 's/N/n/g'
test XJS C4JD QADn1
nSBn3 2IDnEn GTUBE
STAnDARD AnTI
UBE-TEST
EMAIL*C.34X test

[root@alpha ~]# fold -w 20 -s mailtest.txt | sed 's/N/n/g' | tr '\n' '\0'
test XJS C4JD QADn1 nSBn3 2IDnEn GTUBE STAnDARD AnTI UBE-TEST EMAIL*C.34X test

如果文件末尾有换行符，则需要在该文件的末尾添加换行符，因为tr命令将删除它。

使用 perl

管理自己的缓冲区

您可以使用IO::Handle的setvbuf管理默认的缓冲区，或者你可以管理自己的缓冲区sysread和syswrite。检查perldoc -f sysread并perldoc -f syswrite获得更多信息，从本质上讲，它们跳过了缓冲的io。

在这里，我们滚动了自己的缓冲区IO，但是我们手动且任意地对1024个字节进行操作。我们还打开了RW文件，因此我们一次在同一FH上完成所有操作。

use strict;
use warnings;
use Fcntl qw(:flock O_RDWR);
use autodie;
use bytes;

use constant CHUNK_SIZE => 1024 * 32;

sysopen my $fh, 'file', O_RDWR;
flock($fh, LOCK_EX);

my $chunk = 1;
while ( sysread $fh, my $bytes, CHUNK_SIZE * $chunk ) {
  if ( $bytes =~ s/<unk>/<raw_unk>/g ) {
    seek( $fh, ($chunk-1)* CHUNK_SIZE, 0 );
    syswrite( $fh, $bytes, 1024);
    seek( $fh, $chunk * CHUNK_SIZE, 0 );
  }
  $chunk++;
}

如果你要走这条路

1. 确保<unk>和<raw_unk>相同的字节大小。
2. CHUNKSIZE如果要替换的字节数超过1个字节，则可能需要确保我们的缓冲方法不会越界。

您可以尝试bbe（二进制块编辑器），“ sed用于二进制文件”。

我在没有EOL字符的7GB文本文件上使用它取得了成功，并用不同长度的字符串替换了多次出现的字符串。在不进行任何优化的情况下，它提供的平均处理吞吐量> 50MB / s。

使用perl，您可以处理固定长度的记录，例如：

perl -pe 'BEGIN{$/=\1e8}
          s/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

并希望<unk>这些100MB记录中的两个不会跨越。

这是一个执行任务（unk.go）的小型Go程序：

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
)

func main() {
    const (
        pattern     = "<unk>"
        replacement = "<raw_unk>"
    )
    var match int
    var char rune
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanRunes)
    for scanner.Scan() {
        char = rune(scanner.Text()[0])
        if char == []rune(pattern)[match] {
            match++
            if match == len(pattern) {
                fmt.Print(replacement)
                match = 0
            }
        } else {
            if match > 0 {
                fmt.Print(string(pattern[:match]))
                match = 0
            }
            if char == rune(pattern[0]) {
                match = 1
            } else {
                fmt.Print(string(char))
            }
        }
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

只需使用构建它go build unk.go并以身份运行它即可./unk <input >output。

编辑：

抱歉，我没有读到所有内容都在一行中，所以我现在尝试逐字符读取文件。

编辑二：

应用与C程序相同的修复程序。

对于70GB的文件和简单的搜索与替换来说，这可能是过大的杀伤力，但是Hadoop MapReduce框架现在可以免费解决您的问题（将其设置为在本地运行时选择“单节点”选项），并且可以将来可以扩展到无限容量，而无需修改代码。

https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html上的官方教程使用（极其简单）Java，但是您可以找到Perl或无论您使用哪种语言。

因此，如果以后发现您要对7000GB的文本文件执行更复杂的操作-并且每天必须执行100次此操作-您可以将工作负载分布在您配置的或由云自动配置的多个节点上，基于Hadoop集群。

之前的所有建议都需要读取整个文件并写入整个文件。这不仅需要很长时间，而且还需要70GB的可用空间。

1）如果我明白你特定情况下正确地会是可接受的，以取代<UNK>具有相同的长度的一些其它字符串？

2a）是否有多​​次出现？2b）如果是这样，您知道多少吗？

我确定您已经解决了今年以来的问题，并且我想知道您使用了哪种解决方案。

我提出了一个解决方案（最有可能在C中），该方案将读取文件的BLOCKS，并在每个字符串中搜索字符串，同时考虑到可能的块交叉。找到后，将字符串替换为SAME长度备用，并仅写入该BLOCK。持续已知的出现次数或直到文件结束。这将需要最少次数的写入，而最多需要两次写入（如果每个事件都被分成两个块）。这将不需要额外的空间！

如果我们有最低金额<unk>（如齐普夫定律所预期），

awk -v RS="<unk>" -v ORS="<raw_unk>" 1