8.3.1. Редактирование строк

Функция Length(S : String) возвращает текущую длину строки S. Вообще говоря, можно вместо нее пользоваться конструкцией Ord( S[0] ), что то же самое.

Функция Concat производит слияние переданных в нее строк. Вместо нее всегда можно пользоваться операцией «+»:

S3 := Concat( S1,S2 ); { то же, что S3 := S1 + S2 }

S3 := Concat( S3,S1,S2 ); { то же, что S3 := S3 + S1 + S2 }

Если сумма длин строк в Concat превысит максимальную длину строки в левой части присваивания, то излишек будет отсечен.

8.3.1.3. Функция Сору(S : String; Start, Len : Integer) позволяет выделить из строки последовательность из Len символов, начиная с символа Start. Если Start больше длины всей строки S, то функция вернет пустую строку, а если Len больше, чем число символов от Start до конца строки S, то вернется остаток строки S от Start до конца. Например:

SCopy = Сору( 'АВС***123', 4, 3 ) { SСору='***' }

SCopy = Copy( 'ABC', 4, 3 ) { SCopy=' '}

SCopy = Copy( 'ABC***123', 4,11 ) { SCopy='***123' }

- 155 -

Используя процедуру Copy, построим игровой пример появления строки на экране (рис. 8.4).

| USES CRT; { используется модуль CRT }

| { Процедура выводит строку S в позиции (X,Y), }

| { с эффектом раздвижения и звуковым сигналом. }

| PROCEDURE ExplodeString(X,Y: Byte; S: String; С: Word );

| VAR

| i,L2 : Byte;

| BEGIN

| L2 := (Length(S) div 2 ) + 1; { середина строки }

| if X < L2 then

| X:=L2; { настройка X }

| for i:=0 to L2-1 do

| begin { цикл вывода: }

| GotoXY( X-i, Y ); { начало строки }

| { Вывод расширяющейся центральной части строки: }

| Write( Copy( S, L2-i, 2*i+1 ));

| Sound(i*50); { подача звука }

| Delay(С); { задержка С мс }

| NoSound { отмена звука }

| end { конец цикла }

| END;

| { ========= ПРИМЕР ИСПОЛЬЗОВАНИЯ ПРОЦЕДУРЫ ======== }

| BEGIN

| ClrScr; { очистка экрана }

| ExplodeString( 40, 12, '12345678900987654321', 30);

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.4

8.3.1.4. Процедура Delete( VAR S : String; Start, Len : Integer ) видоизменяет сроку S, стирая Len символов, начиная с символа с номером Start:

S := 'СТРОКА';

Delete(S, 2, 4); {S='CA'}

После стирания подстроки ее оставшиеся части как бы склеиваются.

Если Start=0 или превышает длину строки S, то строка не изменится. Также не изменит строку значение Len=0. При Len, большем чем остаток строки, будет удалена подстрока от Start и до конца S. Это можно использовать при «подрезании» строк до заданной величины:

- 156 -

Delete( S, 16, 255)

Здесь строки S длиною менее 17 символов пройдут через процедуру неизменными, а все остальные будут укорочены до длины в 16 символов.

8.3.1.5. Процедура Insert( Subs : String; VAR S : String; Start: Integer) выполняет работу, противоположную той, что делает Delete. Insert вставляет подстроку Subs в строку S, начиная с позиции Start:

S: = 'Начало-конец';

Insert( 'середина-', S, 8 );

{ теперь S = 'Начало-середина-конец' }

Если измененная строка S оказывается слишком длинной, то она автоматически укорачивается до объявленной длины S (при этом, как всегда, «теряется» правый конец).

Пример использования пары процедур Insert и Delete можно увидеть на рис, 8.5, где приводится функция создания строки с текстом посередине.

| { Функция возвращает строку длиной Len, заполненную символом Ch, со вставленной в середину подстрокой S }

| FUNCTION CenterStr( S: String; Len: Byte; Ch: Char ) : String;

| VAR

| fs : String; { промежуточная строка-буфер }

| ls, l2 : Byte; { вспомогательные переменные }

| BEGIN

| FillChar(fs[1], Len, Ch); { заполнение строки fs Ch }

| fs[0] := Chr( Len ); { восстановление длины fs }

| ls := Length( S ); { длина входной подстроки S }

| if ls>=Len then

| begin { если некорректны параметры}

| CenterStr:=S; Exit { то ничего с S не делается }

| end;

| l2 := ( Len-ls } div 2 +1;{место начала вставки в fs }

| Delete( fs, l2, ls ); {очистка места в центре fs }

| Insert( S, fs, l2 ); {и вставка туда строки S }

| CenterStr := fs {итоговое значение функции }

| END;

| {=== ПРИМЕР ВЫЗОВА ФУНКЦИИ ===}

| BEGIN

| WriteLn(CenterStr( 'Работает!', 80, '='));

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.5

- 157 -

8.3.1.6. Функции Pos(Subs, S : String) : Byte возвращает номер символа в строке S, с которого начинается включение в S подстроки Subs. Если же S не содержит в себе Subs, то функция вернет 0. Пример использования функции дан на рис. 8.6, где построена модификация процедуры преобразования Str.

| { Процедура преобразования числа X в строку S}

| { Вход : X — числовое значение; }

| { F — полная длина поля числа; }

| { N — число цифр после запятой. }

| { Выход: строка S, в которой предшествующие }

| { числу пробелы заменены на 0. }

| PROCEDURE ZStr( X : Real; F,N : Byte; VAR S : String );

| VAR p : Byte;

| BEGIN

| Str( X:F:N, S ); { строка с пробелами }

| { Цикл замены пробелов на нули : }

| while Pos(' ', S) > 0 do S[Pos(' ', S)] := '0';

| p := Pos('-',S); { позиция минуса в числе }

| if р <> 0 then begin

{ Если минус имеется, то }

| S[p] := '0'; S[1] := '-' { переместить его в нача-}

| end; { ло строки S. }

| END;

| { ======= ПРИМЕРЫ ВЫЗОВОВ ФУНКЦИИ ======= }

| CONST

| r : Real = 123.456;

| b : Byte = 15;

| i : Integer = -3200;

| St : String = ' ';

| BEGIN

| ZStr( r, 10, 5, St ); WriteLn( St ); { 0123.4560 }

| ZStr{ b, 10, 1, St ); WriteLn( St ); { 0000015.0 }

| ZStr( i, 10, 0, St ); WriteLn( St ); { -00003200 }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.6

Очевидным недостатком функции Pos является то, что она возвращает ближайшую стартовую позицию Subs в S от начала строки, т.е. вызов

P := Pos( 'noo', 'Boonoonoonoos');

завершит свою работу, вернув значение 4, хотя есть еще и 7, и 10.

- 158 -

На рис. 8.7 приведен вариант функции, использующей функцию Pos и возвращающей позицию любого вхождения Subs в S, если оно существует.

| { Функция возвращает номер символа, с которого начинается N-e вхождение подстроки Subs в строку S. Одновременно возвращается общее число вхождений Count. При неудаче поиска функция возвращает значение 0. }

| FUNCTION PosN( Subs, S : String; N : Byte;

| VAR Count : Byte ) : Byte;

| VAR

| p, PN : Byte; { вспомогательные переменные }

| BEGIN

| Count:=0; PN:=0;

| repeat { Цикл по вхождениям : }

| p := Pos( Subs, S ); { поиск вхождения }

| if Count<N then Inc(PN,p);{ суммирование позиций }

| Inc( Count ); { счетчик вхождений }

| Delete( S, 1, p ) { уменьшение строки }

| until p=0; { конец цикла, если р=0 }

| Dec( Count ); { надо уменьшить Count }

| if N<=Count { N не больше, чем Count? }

| then PosN := PN {Да, возвращаем позицию }

| else PosN := 0; { Нет, возвращаем 0 }

| END;

| VAR { ===== ПРИМЕР ВЫЗОВА ФУНКЦИИ ===== }

| C : Byte; {количество вхождений подстроки в строку }

| BEGIN

| WriteLn('3-я позиция noo в Boonoonoonoos начинается',

| ' с символа ', PosN('noo','Boonoonoonoos',3,С):3);

| WriteLn( 'Всего найдено вхождений : ', С );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.7