progress-4gl
stringhe

introduzione

Osservazioni

Definizione, assegnazione e visualizzazione di una stringa

In generale, dovresti sempre definire tutte le variabili e i parametri come NO-UNDO meno che tu non ne abbia davvero bisogno.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

DISPLAY cString.

Concatenazione di stringhe

Usando l'operatore + puoi concatenare facilmente due o più stringhe.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

cString = cString + " " + "GOODBYE".

DISPLAY cString FORMAT "X(20)".

Manipolazione delle stringhe

Ci sono un paio di utili funzioni incorporate per lavorare con la stringa. Tutte le funzioni che lavorano con la posizione dei caratteri iniziano con l'indice 1 come primo carattere, non 0 come è comune in molte lingue.

STRING : converte qualsiasi valore in una stringa

Questo esempio converte il numero intero 2000 nella stringa "2000".

DEFINE VARIABLE i AS INTEGER     NO-UNDO.
DEFINE VARIABLE c AS CHARACTER   NO-UNDO.

i = 2000.

c = STRING(i).

DISPLAY c.

CHR e ASC - converte i singoli caratteri da e verso ASCII.

CHR (integer)

Restituisce la rappresentazione del carattere per il numero intero del codice ASCII

ASC (carattere)

Restituisce il valore intero ascii per il carattere

DEFINE VARIABLE ix     AS INTEGER   NO-UNDO.
DEFINE VARIABLE letter AS CHARACTER NO-UNDO FORMAT "X(1)" EXTENT 26.

DO ix = 1 TO 26:
  letter[ix] = CHR((ASC("A")) - 1 + ix).
END.

DISPLAY SKIP(1) letter WITH 2 COLUMNS NO-LABELS
  TITLE "T H E  A L P H A B E T".

LENGTH - restituisce la lunghezza di una stringa

LUNGHEZZA (stringa). // Restituisce un numero intero con la lunghezza della stringa.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

MESSAGE "The string " cString " is " LENGTH(cString) " characters long" VIEW-AS ALERT-BOX. 

SUBSTRING - restituisce o assegna una parte di una stringa

• SUBSTRING (stringa, posizione iniziale, lunghezza).

Restituisce i caratteri "lunghezza" da "stringa" a partire dalla posizione "posizione iniziale".

• SUBSTRING (stringa, posizione iniziale).

Restituisce il resto di "stringa", iniziando dalla posizione "posizione iniziale"

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".

DISPLAY SUBSTRING(cString, 4, 2). //Displays "DE" 
DISPLAY SUBSTRING(cString, 4). //Displays "DEFGH"

La sottostringa può anche essere utilizzata per sovrascrivere una parte di una stringa. Utilizza la stessa sintassi ma assegna invece la sottostringa:

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".
 
SUBSTRING(cString, 4, 2) = "XY". //Replaces position 4 and 5 with "XY" 

DISPLAY cString.  

C'è anche una funzione simile chiamata OVERLAY questo esempio della documentazione di Progress che copre le differenze tra OVERLAY e SUBSTRING :

/* This procedure illustrates the differences between the SUBSTRING and
   OVERLAY statements. */
DEFINE VARIABLE cOriginal  AS CHARACTER NO-UNDO INITIAL "OpenEdge".
DEFINE VARIABLE cSubstring AS CHARACTER NO-UNDO.
DEFINE VARIABLE cOverlay   AS CHARACTER NO-UNDO.
DEFINE VARIABLE cResults   AS CHARACTER NO-UNDO.

/* Default behavior without optional LENGTH. */
ASSIGN
 cSubstring              = cOriginal
 SUBSTRING(cSubstring,2) = "***"
 cOverlay                = cOriginal
 OVERLAY(cOverlay,2)     = "***"
 cResults                = "target = ~"OpenEdge~". ~n~n" 
  + "If you do not supply a length, SUBSTRING and OVERLAY default as follows:
  ~n~n" + "SUBSTRING(target,2) = ~"***~"  yields:  " + cSubstring + ". ~n" 
  + "OVERLAY(target,2)     = ~"***~"  yields:  " + cOverlay + ".".

/* Behavior with zero LENGTH. */
ASSIGN
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,0) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,0)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a zero length, SUBSTRING and OVERLAY behave as follows:  ~n~n" 
  + "SUBSTRING(target,2,0) = ~"***~"  yields:  " + cSubstring + ". ~n" 
  + "OVERLAY(target,2,0)     = ~"***~"  yields:  " + cOverlay + ".".

/* Behavior with LENGTH < replacement. */
ASSIGN 
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,1) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,1)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a length shorter than the replacement, SUBSTRING and OVERLAY behave
  as follows: ~n~n" + "SUBSTRING(target,2,1) = ~"***~"  yields:  " 
  + cSubstring + ". ~n" + "OVERLAY(target,2,1)     = ~"***~"  yields:  " 
  + cOverlay + ".".

/* Behavior with LENGTH = replacement. */
ASSIGN 
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,3) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,3)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a length equal to the replacement, SUBSTRING and OVERLAY behave as
  follows:  ~n~n" + "SUBSTRING(target,2,3) = ~"***~"  yields:  " 
  + cSubstring + ". ~n" + "OVERLAY(target,2,3)     = ~"***~"  yields:  " 
  + cOverlay + ".".

/* Behavior with LENGTH > replacement. */
ASSIGN 
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,6) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,6)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a length greater than the replacement, SUBSTRING and OVERLAY behave
  as follows:  ~n~n" + "SUBSTRING(target,2,6) = ~"***~"  yields:  " 
  + cSubstring + ". ~n" + "OVERLAY(target,2,6)     = ~"***~"  yields:  " 
  + cOverlay + ".".

MESSAGE cResults VIEW-AS ALERT-BOX.

INDICE : restituisce la posizione di una stringa in una stringa.

R-INDEX farà la stessa cosa ma cercherà da destra a sinistra.

INDICE (fonte, obiettivo)

Cerca il bersaglio all'interno della fonte (da sinistra a destra) e restituisce la sua posizione. Se manca manca 0.

INDICE (fonte, obiettivo, posizione di partenza).

Come sopra ma inizi a cercare in posizione iniziale

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.

str = "ABCDEFGH".

DISPLAY INDEX(str, "cd") INDEX(str, "cd", 4). //Will display 3 and 0

SOSTITUISCI - sostituisce una stringa all'interno di una stringa.

REPLACE (stringa, da stringa, stringa)

Sostituisce da stringa con stringa in stringa. From-string e to-string non hanno bisogno di essere della stessa lunghezza, to-string può anche essere nulla ("") per rimuovere un carattere.

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.

c = "ELLO".

DISPLAY REPLACE(c, "E", "HE"). // Displays "HELLO"

c = "ABABABA".

DISPLAY REPLACE(c, "B", ""). // Remove all Bs

TRIM - rimuove gli spazi bianchi iniziali e finali (o altri caratteri).

Questo può essere utile quando si pulisce indata.

TRIM (string)

Rimuove tutti gli spazi iniziali e finali, le schede, i feed riga, i ritorni a capo.

TRIM (stringa, carattere).

Rimuove tutti i "personaggi" iniziali e finali.

LEFT-TRIM e RIGHT-TRIM fanno la stessa cosa ma solo in testa o in coda.

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.

c = "__HELLO_WORLD_____".

DISPLAY TRIM(c, "_").
/*Displays HELLO_WORLD without all the leading and 
trailing underscores but leaves the one in the middle.
REPLACE would have removed that one as well */

SOSTITUISCI - sostituisce i parametri in una stringa.

SUBSTITUTE is a limited function for replacing up to nine preformatted parameters in a string.

SOSTITUTO (stringa, param1, param2, ..., param9).

I parametri devono essere nel formato &1 a &9 .

Se si desidera utilizzare una e commerciale nella stringa (e non utilizzarla come parametro), sfuggire con un'altra e commerciale: && .

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.
                                      
str = "&1 made &2 goals in &3 games playing for &4".

MESSAGE SUBSTITUTE(str, "Zlatan Ibrahimovic", 113, 122, "Paris Saint-Germain") VIEW-AS ALERT-BOX.
MESSAGE SUBSTITUTE(str, "Mats Sundin", 555, 1305, "Toronto Maple Leafs") VIEW-AS ALERT-BOX.

Un parametro può apparire più di una volta in una stringa, tutto verrà sostituito:

MESSAGE SUBSTITUTE("&1 &2 or not &1 &2", "To", "Be") VIEW-AS ALERT-BOX.

Stringhe CASE-SENSIBILI

Tutte le stringhe in corso ABL sono case sensitive, salvo diversamente specificato.

Questo esempio mostrerà una finestra di messaggio che dice che le stringhe sono identiche.

DEFINE VARIABLE str1 AS CHARACTER   NO-UNDO.
DEFINE VARIABLE str2 AS CHARACTER   NO-UNDO.

str1 = "abc".
str2 = "ABC".

IF str1 = str2 THEN 
    MESSAGE "The strings are identical" VIEW-AS ALERT-BOX.

Per dichiarare una stringa sensibile alla maiuscola basta aggiungere l'attributo CASE-SENSITIVE

DEFINE VARIABLE str1 AS CHARACTER   NO-UNDO CASE-SENSITIVE.
DEFINE VARIABLE str2 AS CHARACTER   NO-UNDO.

str1 = "abc".
str2 = "ABC".

IF str1 = str2 THEN 
    MESSAGE "The strings are identical" VIEW-AS ALERT-BOX.
ELSE 
    MESSAGE "There's a difference" VIEW-AS ALERT-BOX.

(È sufficiente che una delle stringhe ce l'abbia in questo caso).

INIZIA e MATCHES

BEGINS - restituisce TRUE se una stringa inizia con un'altra stringa.

string1 COMINCIA stringa2

Se stringa1 inizia con (o è uguale a) stringa2 questo restituirà true. Altrimenti restituirà false. Se la stringa due è vuota ("") restituirà sempre true.

BEGINS è molto utile nelle query in cui si desidera cercare l'inizio di qualcosa, ad esempio un nome. Ma è fondamentalmente una funzione che lavora su stringhe.

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.
DEFINE VARIABLE beg AS CHARACTER   NO-UNDO.

str = "HELLO".
beg = "HELLO".
DISPLAY str BEGINS beg. // yes

str = "HELLO".
beg = "H".
DISPLAY str BEGINS beg. // yes

str = "HELLO".
beg = "".
DISPLAY str BEGINS beg. // yes


str = "HELLO".
beg = "HELLO WORLD".
DISPLAY str BEGINS beg. // no

MATCHES restituisce true se determinati criteri jolly vengono soddisfatti in una stringa.

stringa1 MATCHES espressione

Restituisce true se stringa1 corrisponde all'espressione con caratteri jolly:

* (asterisco) = da 0 a n caratteri (praticamente qualsiasi stringa di qualsiasi lunghezza)

. (periodo) = carattere jolly per qualsiasi carattere (eccetto null)

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.
DEFINE VARIABLE beg AS CHARACTER   NO-UNDO.

str = "HELLO".
beg = "HELLO".
DISPLAY str MATCHES beg. // yes

str = "HELLO".
beg = "H*".
DISPLAY str MATCHES beg. // yes

str = "HELLO".
beg = "*O".
DISPLAY str MATCHES beg. // yes

str = "HELLO WORLD".
beg = "HELLO.WORLD".
DISPLAY str MATCHES beg. // yes

str = "HELLO WORLD".
beg = "*WORL..".
DISPLAY str MATCHES beg. // no

str = "*HELLO WORLD".
beg = "WOR*LD".
DISPLAY str MATCHES beg. // no

Conversione di lettere maiuscole e minuscole

Come accennato prima, le stringhe sono normalmente insensibili alle maiuscole e minuscole, ma riguarda solo il confronto delle stringhe. Ci sono funzioni incorporate per cambiare il caso.

CAPS (stringa)

Rende stringa maiuscola

LC (stringa)

Rende stringa minuscola

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.
DEFINE VARIABLE d AS CHARACTER   NO-UNDO.

c = "Hello".
d = "World".

DISPLAY CAPS(c) LC(d). // HELLO world

Ricorda che le stringhe normalmente non fanno distinzione tra maiuscole e minuscole

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.
DEFINE VARIABLE d AS CHARACTER   NO-UNDO.

c = "hello".
d = "hello".

DISPLAY CAPS(c) = LC(d). // yes

A meno che non sia specificato come CASE-SENSITIVE

DEFINE VARIABLE c AS CHARACTER   NO-UNDO CASE-SENSITIVE.
DEFINE VARIABLE d AS CHARACTER   NO-UNDO.

c = "hello".
d = "hello".

DISPLAY CAPS(c) = LC(d). // no

elenchi

Ci sono un certo numero di funzioni e metodi per lavorare con gli elenchi separati da virgola (o altri caratteri) in Progress 4GL.

NUM-ENTRIES Restituisce il numero di voci in un elenco. È possibile specificare facoltativamente il delimitatore, la virgola è predefinita

NUM-ENTRIES (stringa [, delimitatore])

Usando la virgola, il delimitatore predefinito:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY NUM-ENTRIES(cList). //3

Utilizzando un altro delimitatore, semilcolon:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye;cruel;world!".

DISPLAY NUM-ENTRIES(cList, ";"). //3

ENTRY - function - restituisce una voce specificata in un elenco

Come al solito la posizione di partenza è 1, non 0!

ENTRATA (voce, lista [, delimitatore]).

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY ENTRY(2, cList). //cruel

ENTRY - metodo - assegnazione del valore di una voce specificata in una lista

ENTRATA (voce, lista [, delimitatore]) = valore

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

ENTRY(1, cList) = "Hello".
ENTRY(2, cList) = "nice".

MESSAGE REPLACE(cList, ",", " ") VIEW-AS ALERT-BOX. //Hello nice world!

CERCA - controlla un elenco per una voce specifica. Restituisce la sua voce.

Se la stringa non è presente nella lista, la ricerca restituirà 0

CERCA (stringa, lista [, delimitatore])

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Hello,nice,world!".

MESSAGE LOOKUP("nice", cList) VIEW-AS ALERT-BOX. //2
MESSAGE LOOKUP("cruel", cList) VIEW-AS ALERT-BOX. //0

Caratteri speciali (e in fuga)

In Progress 4GL il modo normale di scrivere un carattere speciale è precederlo con un carattere tilde (~).

Questi sono i caratteri speciali predefiniti

Se vuoi visualizzare la tilde, deve essere sfuggito!

MESSAGE "A single tilde: ~~" VIEW-AS ALERT-BOX.

MESSAGE "At sign: ~100" SKIP
        "Tab~tseparated~twords!" SKIP
        "A linefeed:~n"
        "Escaping a quote sign: ~"This is a quote!~"" SKIP VIEW-AS ALERT-BOX.