progress-4gl
Cordes

Introduction

Remarques

Définir, associer et afficher une chaîne

En général, vous devez toujours définir toutes les variables et tous les paramètres comme NO-UNDO sauf si vous en avez vraiment besoin.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

DISPLAY cString.

Chaînes concaténantes

En utilisant l'opérateur + , vous pouvez facilement concaténer deux chaînes ou plus.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

cString = cString + " " + "GOODBYE".

DISPLAY cString FORMAT "X(20)".

Manipulation de cordes

Il existe deux fonctions intégrées utiles pour travailler avec des chaînes. Toutes les fonctions fonctionnant avec la position des caractères commencent par l'index 1 en tant que premier caractère, et non 0, ce qui est courant dans de nombreuses langues.

STRING - convertit toute valeur en chaîne

Cet exemple convertit le nombre entier 2000 en chaîne "2000".

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

i = 2000.

c = STRING(i).

DISPLAY c.

CHR et ASC - convertit les caractères uniques en ascii.

CHR (entier)

Renvoie la représentation des caractères pour un entier de code ascii

ASC (caractère)

Renvoie la valeur entière ascii du caractère

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".

LONGUEUR - renvoie la longueur d'une chaîne

LONGUEUR (chaîne). // Retourne un entier avec la longueur de la chaîne.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

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

SUBSTRING - retourne ou assigne une partie d'une chaîne

• SUBSTRING (chaîne, position de départ, longueur).

Renvoie les caractères "length" à partir de "string" à partir de la position "start-position".

• SUBSTRING (chaîne, position de départ).

Renvoie le reste de "string", en commençant à la position "start-position"

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".

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

La sous-chaîne peut également être utilisée pour écraser une partie d'une chaîne. Utilisez la même syntaxe, mais affectez cette sous-chaîne à la place:

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

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

DISPLAY cString.  

Il existe également une fonction similaire appelée OVERLAY Cet exemple de la documentation Progress couvre les différences entre OVERLAY et 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.

INDEX - renvoie la position d'une chaîne dans une chaîne.

R-INDEX va à la même chose mais chercher de droite à gauche.

INDEX (source, cible)

Recherchez la cible dans la source (de gauche à droite) et retournez sa position. S'il manque le résultat 0.

INDEX (source, cible, position de départ).

Comme ci-dessus, mais commencez à chercher au départ

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.

str = "ABCDEFGH".

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

REPLACE - remplace une chaîne dans une chaîne.

REPLACE (chaîne, from-string, to-string)

Remplace de string par to-string dans string. From-string et to-string n'ont pas besoin d'avoir la même longueur, to-string peut aussi ne rien avoir ("") pour supprimer un caractère.

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 - supprime les espaces de début et de fin (ou autres caractères).

Cela peut être utile pour nettoyer l'indata.

TRIM (chaîne)

Supprime tous les espaces de début et de fin, les tabulations, les sauts de ligne et les retours chariot.

TRIM (chaîne, caractère).

Supprime tous les "caractères" de début et de fin.

LEFT-TRIM et RIGHT-TRIM font la même chose mais ne font que conduire ou suivre.

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 */

SUBSTITUTE - remplace les paramètres dans une chaîne.

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

SUBSTITUTE (chaîne, param1, param2, ..., param9).

Les paramètres doivent être au format &1 à &9 .

Si vous voulez utiliser une esperluette dans la chaîne (et ne pas l'utiliser comme paramètre), écartez-la avec une autre perluète: && .

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 paramètre peut apparaître plus d'une fois dans une chaîne, tous seront remplacés:

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

Cordes SENSIBLES

Toutes les chaînes dans Progress ABL sont sensibles à la casse, sauf indication contraire.

Cet exemple affiche une boîte de message indiquant que les chaînes sont identiques.

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.

Pour déclarer une chaîne sensible à la casse, ajoutez simplement l'attribut 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.

(Il suffit que l'une des chaînes l'a dans ce cas).

COMMENCE et MATCHS

BEGINS - renvoie TRUE si une chaîne commence par une autre chaîne.

string1 BEGINS string2

Si string1 COMMENCE avec (ou est égal à) string2, cela retournera true. Sinon, il retournera faux. Si la chaîne deux est vide (""), elle retournera toujours true.

BEGINS est très utile dans les requêtes où vous souhaitez rechercher le début de quelque chose, par exemple un nom. Mais c'est essentiellement une fonction travaillant sur des chaînes.

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 renvoie true si certains critères de caractères génériques sont remplis dans une chaîne.

string1 MATCHES expression

Renvoie true si string1 correspond à l'expression générique:

* (astérisque) = 0 à n caractères (essentiellement n'importe quelle chaîne de n'importe quelle longueur)

. (point) = caractère générique pour tout caractère (sauf 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

Conversion des majuscules et minuscules

Comme mentionné précédemment, les chaînes sont normalement insensibles à la casse mais cela ne concerne que la comparaison des chaînes. Il y a des fonctions intégrées pour changer de boîtier.

CAPS (chaîne)

Rend la chaîne supérieure

LC (chaîne)

Rend les cordes minuscules

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

Rappelez-vous que les chaînes sont normalement insensibles à la casse

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

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

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

Sauf spécification comme 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

Des listes

Il existe un certain nombre de fonctions et de méthodes permettant de travailler avec des listes séparées par des virgules (ou d'autres caractères) dans Progress 4GL.

NUM-ENTRIES Renvoie le nombre d'entrées dans une liste. Vous pouvez éventuellement spécifier le délimiteur, la virgule est la valeur par défaut

NUM-ENTRIES (chaîne [, délimiteur])

En utilisant la virgule, le délimiteur par défaut:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY NUM-ENTRIES(cList). //3

En utilisant un autre délimiteur, semilcolon:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye;cruel;world!".

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

ENTRY - function - retourne une entrée spécifiée dans une liste

Comme d'habitude la position de départ est 1, pas 0!

ENTRÉE (entrée, liste [, délimiteur]).

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY ENTRY(2, cList). //cruel

ENTRY - méthode - attribuer la valeur d'une entrée spécifiée dans une liste

ENTRY (entrée, liste [, délimiteur]) = valeur

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!

LOOKUP - vérifie une liste pour une entrée spécifique. Renvoie son entrée.

Si la chaîne n'est pas présente dans la liste, la recherche renvoie 0

LOOKUP (chaîne, liste [, délimiteur])

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

Caractères spéciaux (et échapper)

Dans Progress 4GL, la manière normale d'écrire un caractère spécial est de le précéder d'un caractère tilde (~).

Ce sont les caractères spéciaux par défaut

Si vous voulez afficher le tilde du tout, il doit être échappé!

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.