progress-4gl
strängar

Introduktion

Anmärkningar

Definiera, analysera och visa en sträng

Generellt sett bör du alltid definiera alla variabler och parametrar som NO-UNDO om du inte behöver det.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

DISPLAY cString.

Slå samman strängar

Med hjälp av + -operatören kan du enkelt sammanfoga två eller flera strängar.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

cString = cString + " " + "GOODBYE".

DISPLAY cString FORMAT "X(20)".

Strängmanipulation

Det finns ett par användbara inbyggda funktioner för att arbeta med sträng. Alla funktioner som arbetar med teckenpositionen börjar med index 1 som första tecken, inte 0 som är vanligt på många språk.

STRING - konverterar alla värden till en sträng

Detta exempel konverterar heltal 2000 till strängen "2000".

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

i = 2000.

c = STRING(i).

DISPLAY c.

CHR och ASC - konverterar enstaka tecken till och från ascii.

CHR (heltal)

Returnerar teckenrepresentationen för heltal för ascii-kod

ASC (tecken)

Returnerar ascii-heltalet för tecknet

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 - returnerar längden på en sträng

LÄNGD (sträng). // Returnerar ett heltal med strängens längd.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

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

SUBSTRING - returnerar eller tilldelar en del av en sträng

• SUBSTRING (sträng, startposition, längd).

Returnerar "längd" -tecken från "sträng" som börjar på position "startposition".

• SUBSTRING (sträng, startposition).

Returnerar resten av "sträng", börjar vid position "startposition"

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".

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

Substring kan också användas för att skriva över en del av en sträng. Använd samma syntax men tilldela istället den substring:

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

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

DISPLAY cString.  

Det finns också en liknande funktion som kallas OVERLAY Detta exempel från framstegsdokumentationen täcker skillnaderna mellan OVERLAY och 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 - returnera positionen för en sträng i en sträng.

R-INDEX kommer till samma sak men sök höger till vänster.

INDEX (källa, mål)

Sök i källan (från vänster till höger) och returnera dess position. Om det saknas returnera 0.

INDEX (källa, mål, startposition).

Samma som ovan men börja söka i startpositionen

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.

str = "ABCDEFGH".

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

Byt ut - ersätter en sträng inom en sträng.

Byt ut (sträng, från-sträng, till-sträng)

Ersätter från sträng till sträng i sträng. Från sträng och sträng behöver inte vara av samma längd, till-strängen kan också vara ingenting ("") för att ta bort ett tecken.

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 - tar bort ledande och efterföljande blanksteg (eller andra tecken).

Detta kan vara användbart vid rengöring av indata.

TRIM (sträng)

Tar bort alla ledande och efterföljande utrymmen, flikar, radmatningar, vagnen återgår.

TRIM (sträng, tecken).

Tar bort alla ledande och efterföljande "karaktärer".

LEFT-TRIM och RIGHT-TRIM gör samma sak men bara leder eller släpar.

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 - ersätter parametrar i en sträng.

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

SUBSTITUTE (sträng, param1, param2, ..., param9).

Parametrarna måste vara i formatet &1 till &9 .

Om du vill använda en ampersand i strängen (och inte använda den som en parameter) flyr den med en annan ampersand: && .

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.

En parameter kan visas mer än en gång i en sträng, alla kommer att ersättas:

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

CASE-Känsliga strängar

Alla strängar i Progress ABL är skiftlägeskänsliga om inte annat anges.

Detta exempel visar en meddelanderuta som säger att strängarna är identiska.

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.

För att förklara en CASE-SENSITIVE lägger du bara till attributet 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.

(Det räcker med att en av strängarna har det i det här fallet).

BEGYNGAR och MATCHES

BEGINS - returnerar SANT om en sträng börjar med en annan sträng.

string1 BEGINS string2

Om sträng1 BEGINS med (eller är lika med) sträng2 kommer detta att returnera true. Annars kommer det att returnera falskt. Om sträng två är tom ("") kommer den alltid att gälla.

BEGINS är mycket användbart i frågor där du vill söka i början på något, till exempel ett namn. Men det är i princip en funktion som arbetar med strängar.

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 returnerar sant om vissa jokertecken är uppfyllda i en sträng.

string1 MATCHES uttryck

Returnerar sant om sträng1 matchar jokerteckenuttrycket:

* (asterisk) = 0 till n tecken (i princip någon sträng av vilken längd som helst)

. (period) = jokertecken för alla tecken (utom noll)

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

Konvertera stora och små bokstäver

Som nämnts tidigare är strängar normalt okänsliga för fall men det gäller endast jämförelse av strängar. Det finns inbyggda funktioner för att ändra ärende.

CAPS (sträng)

Gör strängbokstäver

LC (sträng)

Gör sträng med små bokstäver

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

Kom ihåg att strängar normalt är okänsliga för versaler

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

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

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

Om inte specificeras som 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

listor

Det finns ett antal funktioner och metoder för att arbeta med komma (eller annat tecken) separerade listor i Progress 4GL.

NUM-ENTRIES Returnerar antalet poster i en lista. Du kan valfritt ange avgränsare, komma är standard

NUM-ENTRIES (string [, delimiter])

Med kommatecken är standardavgränsaren:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY NUM-ENTRIES(cList). //3

Med hjälp av en annan avgränsare, semilcolon:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye;cruel;world!".

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

ENTRY - funktion - returnerar en angiven post i en lista

Som vanligt startposition är 1, inte 0!

ENTRY (post, lista [, avgränsare]).

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY ENTRY(2, cList). //cruel

ENTRY - metod - tilldela värdet på en specificerad post i en lista

ENTRY (post, lista [, delimiter]) = värde

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 - kolla en lista för en specifik post. Returnerar posten.

Om strängen inte finns i listuppslaget returnerar 0

LOOKUP (sträng, lista [, avgränsare])

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

Specialtecken (och fly)

I Progress 4GL är det vanliga sättet att skriva ett specialtecken att föregå det med ett tilde-tecken (~).

Dessa är standard specialtecken

Om du överhuvudtaget vill visa tilde måste det rymmas!

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.