Seed7

Stringhe

Le stringhe sono sequenze finite di caratteri codificati secondo lo standard UTF-32. In Seed7 le stringhe non hanno terminatori, come ad esempio abbiamo invece nel linguaggio C, e possono contenere anche dati binari. Le stringhe sono delimitate da una coppia di doppi apici. Le stringhe le abbiamo in qualche modo già incontrate nel paragrafi precedenti per cui l'esempio dovrebbe essere immediatamente comprensibile:


  Esempio 5.1
1
2
3
4
5
6
7
8
9
10
11
12
$ include "seed7_05.s7i";
const proc: main is func
local
var string: s1 is "hello";
var string: s2 is "";
var string: s3 is "ciao";
begin
writeln(s1);
s2 := "world";
writeln(s2);
writeln(s3);
end func;

Nel capitolo 2 abbiamo visto l'elenco dei caratteri di escape, che possono essere inseriti all'interno delle nostre stringhe. Non sto a ripetere l'elenco e l'effetto è facilmente intuibile:

var string: s1 is "aa\nbbb"

viene stampata come:

aa
bbb


in quanto in essa abbiamo inserito il solito \n che, come noto, è il simbolo di newline, ovvero andare a capo. Potete provare cosa accade con altri caratteri, l'effetto non dovrebbe sorprendervi in quanto non si discosta da quanto già indicato.

L'accesso al singolo elemento di una stringa avviene attraverso il già noto operatore [ ]. Come abbiamo visto nel caso degli array anche gli elementi di una stringa sono indicizzati in maniera sequenziale col primo indice pari a 1. L'operatore [ ] è comunque più flessibile che in altri linguaggi come vedremo tra breve.

Le stringhe sono dotate di una lunga serie di operatori atti alla loro manipolazione:

operatore effetto ( + esempio)
& concatena due o più stringhe
<& concatenazione debole. In presenza di stringhe è perfettamente uguale a &. Ne riparleremo
mult moltiplica le stringhe:

var string: s1 is "aaa";
writeln(s1 mult 3);
 

stampa: aaaaaaaaa
lpad allinea a sinistra, inserendo degli spazi, purchè in presenza di un valore numerico > della lunghezza della stringa, altrimenti non ha effetto. Inoltre non funziona se usato all'interno di una concatenazione.

var string: s1 is "aaa";

s1 lpad 8 produce "     aaa" (5 spazi + la stringa, ovviamente senza apici)
s1 lpad 3 produce "aaa"
lpad0 come lpad solo che inserisce degli zero a sinistra invece che spazi.
rpad funziona come lpad ma inserisce gli spazi a destra in presenza di un valore numerico > della lunghezza della stringa
[a .. b] accede alla sottostringa avente indici da a fino b.

var string: s1 is "abdefgh";
writeln(s1[2 ..4]);


l'output è la stringa bde.
[a len b] accede alla sottostringa che parte da a per il numero di caratteri indicato da b
[a .. ] accede alla sottostringa a partire dalla posizione a fino alla fine
[ .. a ] accede alla sottostringa dall'inizio alla posizione a
length(A) restituisce la lunghezza della stringa A, ovvero il numero dei caratteri che la compongono.

var string: s1 is "abdefgh";
writeln(length(s1));

restituisce ovviamente il risultato 7.
pos(A, B) restituisce la posizione della prima occorrenza del carattere B ( o della stringa B) all'interno della stringa A. Nel caso della ricerca di una stringa il valore restituito è quello del primo indice.

var string: s1 is "abcdefgh";
writeln(pos(s1, 'c'));
writeln(pos(s1, "gh"));


i valori restituiti dalle due istruzioni precedenti sono 3 e 7.
pos(A,B,C) cerca la prima occorrenza di un dato carattere C, o di una stringa C nella stringa A a partire da un data posizione C.
rpos(A,B) funziona come pos(A,B) ma restituisce l'ultima occorrenza di B in A
rpos(A,B,C) funziona come pos(A,B,C) ma restituisce l'ultima occorrenza
replace(A,B,C) All'interno della stringa A rimpiazza il contenuto della sottostringa B con la stringa C

$ include "seed7_05.s7i";
const proc: main is func
local
var string: s1 is "abcdefgh";
begin
writeln(replace(s1,"abc","www"));
end func;
split(aA, B) Divide la stringa A in un array di stringhe usando il separatore B. Di seguito un esempio completo

$ include "seed7_05.s7i";
const proc: main is func
local
var string: s1 is "ab:cd:ef:gh";
var array string: arr1 is [] "";
var integer: x1 is 0;
begin
arr1 := split(s1, ':');
for x1 range 1 to length(arr1) do
writeln(arr1[x1]);
end for;
end func;
join(A,B) congiunge gli elementi (array di stringhe) di A usando B come separatore.

$ include "seed7_05.s7i";
const proc: main is func
local
var array string: arr1 is [] ("aa", "bb");

begin
writeln(join(arr1,':'));
end func;
trim(A) rimuove spazi ed eventuali caratteri di controllo davanti e dietro alla stringa.
str(A) Converte A in stringa.

$ include "seed7_05.s7i";
const proc: main is func
local
var boolean: b1 is TRUE;

begin
writeln(str(b1));
end func;
&:=(A, B) Appende B ad A. Equivale a A := A & B. B può essere una stringa o un carattere.
A@:=(B,C) Assegna C all'elemento B della stringa A.

N.B. se i valori restituiti dalla funzioni di ricerca di stringhe o caratteri come pos o rpos restituiscono 0 come risultato significa che la stringa o il carattere cercato non esistono.