3

我们经常用另一个“好”字符替换文件中不需要的字符。

界面是：

procedure cleanfileASCII2(vfilename: string; vgood: integer; voutfilename: string);

用我们可以调用的空格替换所有不受欢迎的内容， cleanfileASCII2(original.txt, 32 , clean.txt)

问题是这需要相当长的时间。有比显示的更好的方法吗？

procedure cleanfileASCII2(vfilename: string; vgood: integer; voutfilename:
string);
var
  F1, F2: file of char;
  Ch: Char;
  tempfilename: string;
  i,n,dex: integer;
begin
   //original
    AssignFile(F1, vfilename);
    Reset(F1);
    //outputfile
    AssignFile(F2,voutfilename);
    Rewrite(F2);
      while not Eof(F1) do
      begin
        Read(F1, Ch);
        //
          n:=ord(ch);
          if ((n<32)or(n>127))and (not(n in [10,13])) then
             begin // bad char
               if vgood<> -1 then
                begin
                ch:=chr(vgood);
                Write(F2, Ch);
                end
             end
           else   //good char
            Write(F2, Ch);
      end;
    CloseFile(F2);
    CloseFile(F1);
end;
4

7 回答 7

6

问题与您如何处理缓冲区有关。内存传输是任何操作中最昂贵的部分。在这种情况下，您正在逐字节查看文件。通过更改为块读取或缓冲读取，您将实现速度的巨大提升。请注意，正确的缓冲区大小会根据您读取的位置而有所不同。对于网络文件，您会发现由于 TCP/IP 强加的数据包大小，非常大的缓冲区可能效率较低。即使这对于来自 gigE 的大数据包也变得有点模糊，但一如既往，最好的结果是对其进行基准测试。

为了方便起见，我从标准读取转换为文件流。您可以使用块读取轻松地做同样的事情。在这种情况下，我拿了一个 15MB 的文件并通过你的例程运行它。对本地文件执行操作花费了 131,478 毫秒。使用 1024 缓冲区，需要 258 毫秒。

procedure cleanfileASCII3(vfilename: string; vgood: integer; voutfilename:string);
const bufsize=1023;
var
  inFS, outFS:TFileStream;
  buffer: array[0..bufsize] of byte;
  readSize:integer;
  tempfilename: string;
  i: integer;
begin
   if not FileExists(vFileName) then exit;

   inFS:=TFileStream.Create(vFileName,fmOpenRead);
   inFS.Position:=0;
   outFS:=TFileStream.Create(vOutFileName,fmCreate);
   while not (inFS.Position>=inFS.Size) do
      begin
      readSize:=inFS.Read(buffer,sizeof(buffer));
      for I := 0 to readSize-1 do
          begin
          n:=buffer[i];
          if ((n<32)or(n>127)) and (not(n in [10,13])) and (vgood<>-1) then
             buffer[i]:=vgood;
          end;
      outFS.Write(buffer,readSize);
      end;
   inFS.Free;
   outFS.Free;
end;
于 2009-05-28T16:12:03.837 回答
2

多项改进：

  1. 缓冲数据，读取 2k 或 16k 或类似大小的块
  2. 使用查找表

这是一个未经测试的刺（现在我面前没有编译器）：

procedure cleanfileASCII2(vfilename: string; vgood: integer; voutfilename: string);
var
    f1, f2: File;
    table: array[Char] of Char;
    index, inBuffer: Integer;
    buffer: array[0..2047] of Char;
    c: Char;
begin
    for c := #0 to #31 do
        table[c] := ' ';
    for c := #32 to #127 do
        table[c] := c;
    for c := #128 to #255 do
        table[c] := ' ';
    table[#10] := #10; // exception to spaces <32
    table[#13] := #13; // exception to spaces <32

    AssignFile(F1, vfilename);
    Reset(F1, 1);
    AssignFile(F2,voutfilename);
    Rewrite(F2, 1);
    while not Eof(F1) do
    begin
        BlockRead(f1, buffer, SizeOf(buffer), inBuffer);
        for index := 0 to inBuffer - 1 do
          buffer[index] := table[buffer[index]];
        BlockWrite(f2, buffer, inBuffer);
    end;
    Close(f2);
    Close(f1);
end;
于 2009-05-28T16:07:37.590 回答
1

缓冲是做到这一点的正确方法。我修改了您的代码以查看差异：

procedure cleanfileASCII2(vfilename: string; vgood: integer; voutfilename:
string);
var
  F1, F2: file;
  NumRead, NumWritten: Integer;
  Buf: array[1..2048] of Char;
  Ch: Char;
  i, n: integer;
begin
    AssignFile(F1, vfilename);
    Reset(F1, 1); // Record size = 1
    AssignFile(F2, voutfilename);
    Rewrite(F2, 1); // Record size = 1
    repeat
      BlockRead(F1, Buf, SizeOf(Buf), NumRead);
      for i := 1 to NumRead do
      begin
        Ch := Buf[i];
        //
        n := ord(ch);
        if ((n<32)or(n>127))and (not(n in [10,13])) then
        begin // bad char
         if vgood <> -1 then
         begin
           ch := chr(vgood);
           Buf[i] := Ch;
         end
        //else   //good char
         //Write(F2, Ch);
        end;
      end;
      BlockWrite(F2, Buf, NumRead, NumWritten);
    until (NumRead = 0) or (NumWritten <> NumRead);
    CloseFile(F1);
    CloseFile(F2);
end;
于 2009-05-28T16:04:48.467 回答
1

您可以缓冲输入和输出，以便将一大块字符（甚至整个文件，如果它不是太大）读入数组，然后处理数组，然后将整个数组写入输出文件。

在大多数情况下，磁盘 IO 是瓶颈，如果可以少做大读取而不是大量小读取，速度会更快。

于 2009-05-28T15:28:29.697 回答
0

我是这样做的，确保文件 I/O 在处理之前一次性完成。该代码可以用于更新 unicode，但它可以处理令人讨厌的文本字符，例如 null，并为您提供 TStrings 功能。布里

procedure TextStringToStringsAA( AStrings : TStrings; const AStr: Ansistring);
// A better routine than the stream 'SetTextStr'.
// Nulls (#0) which might be in the file e.g. from corruption in log files
// do not terminate the reading process.
var
  P, Start, VeryEnd: PansiChar;
  S: ansistring;
begin
  AStrings.BeginUpdate;
  try
    AStrings.Clear;

    P := Pansichar( AStr );
    VeryEnd := P + Length( AStr );

    if P <> nil then
      while P < VeryEnd do
      begin
        Start := P;
        while (P < VeryEnd) and not CharInSet(P^, [#10, #13]) do
         Inc(P);
        SetString(S, Start, P - Start);
        AStrings.Add(string(S));
        if P^ = #13 then Inc(P);
        if P^ = #10 then Inc(P);
      end;
  finally
    AStrings.EndUpdate;
  end;
end;


procedure TextStreamToStrings( AStream : TStream; AStrings : TStrings );
// An alternative to AStream.LoadFromStream
// Nulls (#0) which might be in the file e.g. from corruption in log files
// do not terminate the reading process.
var
  Size : Integer;
  S    : Ansistring;
begin
  AStrings.BeginUpdate;
  try
    // Make a big string with all of the text
    Size := AStream.Size - AStream.Position;
    SetString( S, nil, Size );
    AStream.Read(Pointer(S)^, Size);

    // Parse it
    TextStringToStringsAA( AStrings, S );
  finally
    AStrings.EndUpdate;
  end;
end;

procedure LoadStringsFromFile( AStrings : TStrings; const AFileName : string );
// Loads this strings from a text file
// Nulls (#0) which might be in the file e.g. from corruption in log files
// do not terminate the reading process.
var
  ST : TFileStream;
begin
  ST := TFileStream.Create( AFileName, fmOpenRead + fmShareDenyNone);
  // No attempt is made to prevent other applications from reading from or writing to the file.
  try
    ST.Position := 0;
    AStrings.BeginUpdate;
    try
      TextStreamToStrings( ST, AStrings );
    finally
      AStrings.EndUpdate;
    end;

  finally
    ST.Free;
  end;
end;
于 2009-05-28T15:47:58.097 回答
0

不要在不知道在哪里的情况下尝试优化。

您应该使用 Sampling Profiler (delphitools.info) 来了解瓶颈在哪里。它很容易使用。

在循环之前预先计算 vgood chr 转换。

此外，您不需要一些转换：Ord() 和 Chr()。始终使用“Ch”变量。

if not (ch in [#10, #13, #32..#127]) then
于 2009-05-28T16:00:59.583 回答
0

可能最简单的方法是：

  1. 制作另一个文件（临时）
  2. 将基本文件的所有内容复制到临时文件中。文件（一行一行）
  3. 检测它何时读取要替换的字符或单词并停止复制
  4. 输入您的编辑（到临时文件）
  5. 继续并完成将基本复制到临时文件
  6. 重写（删除）基本文件的内容
  7. 将行从临时文件复制到基本文件
  8. 完毕！

如果对这篇文章有帮助，请投票+1

于 2013-01-10T19:02:53.297 回答