progress-4gl
Smyczki

Wprowadzenie

Uwagi

Definiowanie, przypisywanie i wyświetlanie łańcucha

Zasadniczo należy zawsze definiować wszystkie zmienne i parametry jako NO-UNDO chyba że naprawdę potrzebujesz.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

DISPLAY cString.

Łańcuchy łączące

Za pomocą operatora + można łatwo połączyć dwa lub więcej ciągów.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

cString = cString + " " + "GOODBYE".

DISPLAY cString FORMAT "X(20)".

Manipulacja ciągiem

Istnieje kilka przydatnych wbudowanych funkcji do pracy z łańcuchem. Wszystkie funkcje pracujące z pozycją znaków zaczynają się od indeksu 1 jako pierwszego znaku, a nie 0, jak to jest często w wielu językach.

STRING - konwertuje dowolną wartość na ciąg

W tym przykładzie liczba całkowita 2000 jest konwertowana na ciąg „2000”.

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

i = 2000.

c = STRING(i).

DISPLAY c.

CHR i ASC - konwertuje pojedyncze znaki do iz ascii.

CHR (liczba całkowita)

Zwraca reprezentację znaków dla liczby całkowitej kodu ascii

ASC (znak)

Zwraca wartość całkowitą ascii dla znaku

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

DŁUGOŚĆ - zwraca długość łańcucha

DŁUGOŚĆ (ciąg). // Zwraca liczbę całkowitą o długości ciągu.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

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

SUBSTRING - zwraca lub przypisuje część ciągu

• SUBSTRING (ciąg, pozycja początkowa, długość).

Zwraca „długość” znaków z „łańcucha” zaczynając od pozycji „pozycja początkowa”.

• SUBSTRING (ciąg, pozycja początkowa).

Zwraca resztę „łańcucha”, zaczynając od pozycji „pozycja początkowa”

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".

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

Podciąg może być również użyty do zastąpienia części ciągu. Użyj tej samej składni, ale zamiast tego przypisz ten podciąg:

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

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

DISPLAY cString.  

Istnieje również podobna funkcja o nazwie OVERLAY Ten przykład z dokumentacji postępu obejmuje różnice między OVERLAY i 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.

INDEKS - zwraca pozycję ciągu w ciągu.

R-INDEX będzie to samo, ale szukaj od prawej do lewej.

INDEKS (źródło, cel)

Wyszukaj cel w źródle (od lewej do prawej) i zwróć jego pozycję. Jeśli go brakuje, zwróć 0.

INDEKS (źródło, cel, pozycja początkowa).

To samo co powyżej, ale zacznij wyszukiwanie od pozycji początkowej

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.

str = "ABCDEFGH".

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

REPLACE - zastępuje ciąg w ciągu.

REPLACE (ciąg, od-ciągu, do-ciągu)

Zamienia ciąg z ciągiem na ciąg w ciągu. Długość ciągu i ciągu nie musi być tej samej długości, ciąg może także być niczym („”), aby usunąć znak.

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 - usuwa wiodące i końcowe białe spacje (lub inne znaki).

Może to być przydatne podczas czyszczenia indata.

TRIM (ciąg)

Usuwa wszystkie spacje wiodące i końcowe, tabulatory, przesunięcia wiersza, znaki powrotu karetki.

TRIM (ciąg, znak).

Usuwa wszystkie wiodące i końcowe „postacie”.

LEFT-TRIM i RIGHT-TRIM robią to samo, ale tylko na początku lub na końcu.

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 - zastępuje parametry w ciągu.

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

SUBSTITUTE (ciąg, param1, param2, ..., param9).

Parametry muszą mieć format od &1 do &9 .

Jeśli chcesz użyć ampersand w ciągu (i nie używaj go jako parametru), użyj innego 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.

Parametr może pojawić się więcej niż jeden raz w ciągu, wszystkie zostaną zastąpione:

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

Ciągi wrażliwe na wielkość liter

Wszystkie ciągi znaków w toku ABL rozróżniają małe i wielkie litery, chyba że określono inaczej.

W tym przykładzie zostanie wyświetlone okno komunikatu z informacją, że ciągi są identyczne.

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.

Aby zadeklarować rozróżnianie małych i wielkich liter, po prostu dodaj atrybut 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.

(Wystarczy, że w tym przypadku ma to jeden z ciągów).

POCZĄTKI I MECZE

POCZĄTKI - zwraca PRAWDA, jeśli jeden ciąg zaczyna się od drugiego.

string1 ROZPOCZĘCIA string2

Jeśli string1 ZACZYNA się z (lub jest równy) string2, to zwróci true. W przeciwnym razie zwróci false. Jeśli ciąg drugi jest pusty („”), zawsze zwróci true.

POCZĄTKI są bardzo przydatne w zapytaniach, w których chcesz wyszukać początek czegoś, na przykład nazwę. Ale w zasadzie jest to funkcja działająca na ciągach.

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 zwraca wartość true, jeśli określone kryterium wieloznaczne jest spełnione w ciągu.

wyrażenie string1 MATCHES

Zwraca true, jeśli string1 pasuje do wyrażenia wieloznacznego:

* (gwiazdka) = od 0 do n znaków (w zasadzie dowolny ciąg dowolnej długości)

. (kropka) = symbol wieloznaczny dla dowolnego znaku (z wyjątkiem 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

Konwersja wielkich i małych liter

Jak wspomniano wcześniej, łańcuchy zwykle nie uwzględniają wielkości liter, ale dotyczy to tylko porównania łańcuchów. Wbudowane funkcje zmiany wielkości liter.

CAPS (ciąg)

Sprawia, że ciąg jest pisany wielkimi literami

LC (ciąg)

Sprawia, że ciąg jest pisany małymi literami

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

Pamiętaj, że łańcuchy zwykle nie uwzględniają wielkości liter

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

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

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

Chyba że określony jako 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

Listy

Istnieje wiele funkcji i metod pracy z listami oddzielonymi przecinkami (lub innymi znakami) w toku 4GL.

NUM-ENTRIES Zwraca liczbę wpisów na liście. Możesz opcjonalnie określić ogranicznik, przecinek jest domyślny

NUM-ENTRIES (ciąg [, separator])

Używając przecinka, domyślny ogranicznik:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY NUM-ENTRIES(cList). //3

Używając innego separatora, semilcolon:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye;cruel;world!".

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

WEJŚCIE - funkcja - zwraca określony wpis na liście

Jak zwykle pozycja początkowa to 1, a nie 0!

WEJŚCIE (wpis, lista [, separator]).

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY ENTRY(2, cList). //cruel

WEJŚCIE - metoda - przypisanie wartości określonego wpisu na liście

WEJŚCIE (wpis, lista [, separator]) = wartość

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!

WYSZUKAJ - sprawdź listę dla konkretnego wpisu. Zwraca swój wpis.

Jeśli ciąg nie jest obecny na liście, wyszukiwanie zwróci 0

WYSZUKAJ (ciąg, lista [, separator])

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

Znaki specjalne (i ucieczka)

W toku 4GL normalnym sposobem pisania znaku specjalnego jest poprzedzenie go znakiem tyldy (~).

To są domyślne znaki specjalne

Jeśli chcesz w ogóle wyświetlać tyldy, musisz uciec!

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.