Быстрые функции сжатия пробелов и управляющих символов в строке

Delphi , Синтаксис , Текст и Строки

Автор: Александр Шарахов
WEB-сайт: http://delphibase.endimus.com

{ **** UBPFD *********** by delphibase.endimus.com ****
>> Быстрые функции сжатия пробелов и управляющих символов в строке.

Функции удаляют из строки начальные и конечные пробелы и управляющие
символы (меньшие пробела). Идущие подряд пробелы и управляющие символы
в середине строки заменяются одним пробелом.

Зависимости: нет
Автор:       Александр Шарахов, alsha@mailru.com, Москва
Copyright:   Александр Шарахов
Дата:        2 февраля 2003 г.
***************************************************** }

// Sha_SpaceCompress удаляет из Ansi-строки начальные и конечные пробелы
// и управляющие символы (меньшие пробела). Идущие подряд пробелы
// и управляющие символы в середине строки заменяются одним пробелом.
// Исходная строка при этом не изменяется. Эта функция работает
// медленнее, чем Sha_SpaceCompressInplace. С целью ускорения работы
// освобождение неиспользуемой памяти за пределами строки не производится.
// Если это критично, после вызова данной функции можно освободить память
// следующим образом: s2:=Sha_SpaceCompress(s1); SetLength(s2,Length(s2));
// Функция не работает, если нарушен формат Ansi-строки, в частности,
// если в конце строки отсутствует терминатор.

function Sha_SpaceCompress(const s: string): string;
var
  p, q, t: pchar;
  ch: char;
label
  rt;
begin
  ;
  p := pointer(s);
  q := nil;
  if p <> nil then
  begin
    ;
    t := p + (pinteger(p - 4))^;
    if p < t then
    begin
      ;
      repeat;
        dec(t);
        if p > t then
          goto rt;
      until (t^ > ' ');
      SetString(Result, nil, (t - p) + 1);
      q := pchar(pointer(Result));
      repeat;
        repeat;
          ch := p^;
          inc(p);
        until ch > ' ';
        repeat;
          q^ := ch;
          ch := p^;
          inc(q);
          inc(p);
        until ch <= ' ';
        q^ := ' ';
        inc(q);
      until p > t;
    end;
  end;
  rt:
  if q <> nil then
  begin
    ;
    dec(q);
    q^ := #0;
    (pinteger(pchar(pointer(Result)) - 4))^ := q - pointer(Result);
  end
  else
    Result := '';
end;

// Sha_SpaceCompressInplace удаляет из Ansi-строки начальные и конечные пробелы
// и управляющие символы (меньшие пробела). Идущие подряд пробелы
// и управляющие символы в середине строки заменяются одним пробелом.
// Результат замещает исходную строку. С целью ускорения работы
// освобождение неиспользуемой памяти за пределами строки не производится.
// Если это критично, после вызова данной функции можно освободить память
// следующим образом: Sha_SpaceCompressInpace(s); SetLength(s,Length(s));
// Процедура не работает, если нарушен формат Ansi-строки, в частности,
// если в конце строки отсутствует терминатор.

procedure Sha_SpaceCompressInplace(var s: string);
var
  p, q, t: pchar;
  ch: char;
label
  rt;
begin
  ;
  UniqueString(s);
  p := pointer(s);
  if p <> nil then
  begin
    ;
    t := p + (pinteger(p - 4))^;
    if p < t then
    begin
      ;
      q := p;
      repeat;
        dec(t);
        if p > t then
          goto rt;
      until (t^ > ' ');
      repeat;
        repeat;
          ch := p^;
          inc(p);
        until ch > ' ';
        repeat;
          q^ := ch;
          ch := p^;
          inc(q);
          inc(p);
        until ch <= ' ';
        q^ := ' ';
        inc(q);
      until p > t;
      dec(q);
      rt: q^ := #0;
      (pinteger(pchar(pointer(s)) - 4))^ := q - pointer(s);
    end;
  end;
end;

// Sha_SpaceCompressPChar удаляет из null-terminated строки начальные
// и конечные пробелы и управляющие символы (меньшие пробела), за исключением
// терминатора. Идущие подряд пробелы и управляющие символы в середине строки
// заменяются одним пробелом. Результат замещает исходную строку.
// Никакое перераспределения памяти не производится.
// Функция не работает с read-only строкой.

function Sha_SpaceCompressPChar(p: pchar): pchar;
var
  q: pchar;
  ch: char;
label
  rt;
begin
  ;
  Result := p;
  if (p <> nil) and (p^ <> #0) then
  begin
    ;
    q := p - 1;
    repeat;
      repeat;
        ch := p^;
        inc(p);
        if ch = #0 then
          goto rt;
      until ch > ' ';
      inc(q);
      repeat;
        q^ := ch;
        ch := p^;
        inc(q);
        inc(p);
      until ch <= ' ';
      q^ := ' ';
    until ch = #0;
    rt: if q < Result then
      inc(q);
    q^ := #0;
  end;
end;

Пример использования:

s2 := Sha_SpaceCompress(s1);
Sha_SpaceCompressInpace(s);
Sha_SpaceCompressPChar(pch); 

Here is a translation of the content into Russian:

В предоставленном коде есть три функции в Delphi, которые сжимают пробельные символы и символы управления в строке. Каждая функция имеет свой уникальный поведение:

1. Sha_SpaceCompress: эта функция принимает строку как входной параметр, удаляет leading и trailing whitespace и control characters, заменяет последовательные пробельные символы и символы управления на одиночный пробел, и возвращает полученную строку.
2. Sha_SpaceCompressInplace: это процедура модифицирует оригинальную строку, удаляя leading и trailing whitespace и control characters, заменяет последовательные пробельные символы и символы управления на одиночный пробел, и не возвращает никакого значения.
3. Sha_SpaceCompressPChar: эта функция принимает указатель на null-terminated строку как входной параметр, удаляет leading и trailing whitespace и control characters (исключая terminator), заменяет последовательные пробельные символы и символы управления на одиночный пробел, и возвращает модифицированную строку.

Код хорошо документирован, но есть некоторые комментарии, которые могли бы быть улучшены для ясности. Например, в Sha_SpaceCompressInplace комментарий "С целью ускорения работы освобождение неиспользуемой памяти за пределами строки не производится" мог бы быть переписан как "Эта процедура не освобождает неиспользуемую память вне строки для улучшения производительности".

Вот альтернативное решение с использованием регулярного выражения:

function Sha_SpaceCompress(const s: string): string;
begin
  Result := TRegex.Replace(s, '\s+', ' ');
end;

procedure Sha_SpaceCompressInplace(var s: string);
begin
  s := Sha_SpaceCompress(s);
end;

function Sha_SpaceCompressPChar(p: pchar): pchar;
var
  q: pchar;
  ch: char;
label
  rt;
begin
  if (p <> nil) and (p^ <> #0) then
  begin
    q := p - 1;
    repeat
      repeat
        ch := p^;
        inc(p);
        if ch = #0 then
          goto rt;
      until ch > ' ';
      inc(q);
      repeat
        q^ := ch;
        ch := p^;
        inc(q);
        inc(p);
      until ch <= ' ';
      q^ := ' ';
    until ch = #0;
    rt: if q < Result then
      inc(q);
    q^ := #0;
  end;
  Result := p;
end;

В этом решении используется класс TRegex из единицы RegEx для замены последовательных пробельных символов на одиночный пробел. Процедура Sha_SpaceCompressInplace идентична своей оригинальной версии, а функция Sha_SpaceCompressPChar была переписана с использованием того же регулярного выражения, что и первая функция.

Обратите внимание, что это решение предполагает, что используемая версия Delphi поддерживает регулярные выражения. Если не, то нужно было бы найти альтернативное решение.

Быстрые функции сжатия пробелов и управляющих символов в строке: Sha_SpaceCompress, Sha_SpaceCompressInplace и Sha_SpaceCompressPChar.

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: Текст и Строки ::