progress-4gl
Instrumentos de cuerda

Introducción

Observaciones

Definir, evaluar y mostrar una cadena.

En general, siempre debe definir todas las variables y parámetros como NO-UNDO menos que realmente lo necesite.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

DISPLAY cString.

Cuerdas de concatenacion

Usando el operador + puede concatenar fácilmente dos o más cadenas.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

cString = cString + " " + "GOODBYE".

DISPLAY cString FORMAT "X(20)".

Manipulación de cuerdas

Hay un par de funciones útiles para trabajar con cadenas. Todas las funciones que trabajan con la posición de los caracteres comienzan con el índice 1 como primer carácter, no 0 como es común en muchos idiomas.

STRING - convierte cualquier valor en una cadena

Este ejemplo convierte el entero 2000 a la cadena "2000".

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

i = 2000.

c = STRING(i).

DISPLAY c.

CHR y ASC : convierte caracteres individuales hacia y desde ascii.

CHR (entero)

Devuelve la representación de caracteres para el código entero ASCII.

ASC (personaje)

Devuelve el valor entero ascii para el carácter.

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

LONGITUD : devuelve la longitud de una cadena

LONGITUD (cadena). // Devuelve un entero con la longitud de la cadena.

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

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

SUBSTRING - devuelve o asigna una parte de una cadena

• SUBSTRING (cadena, posición inicial, longitud).

Devuelve los caracteres de "longitud" de "cadena" que comienza en la posición "posición de inicio".

• SUBSTRING (cadena, posición de inicio).

Devuelve el resto de "cadena", comenzando en la posición "posición inicial"

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".

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

La subcadena también se puede utilizar para sobrescribir una parte de una cadena. Use la misma sintaxis pero asigne esa subcadena en su lugar:

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

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

DISPLAY cString.  

También hay una función similar llamada OVERLAY Este ejemplo de la documentación de Progress cubre las diferencias entre OVERLAY y 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.

ÍNDICE - devuelve la posición de una cadena en una cadena.

R-INDEX hará lo mismo pero buscará de derecha a izquierda.

INDICE (origen, destino)

Busque el objetivo dentro de la fuente (de izquierda a derecha) y devuelva su posición. Si falta, devuelve 0.

ÍNDICE (origen, destino, posición inicial).

Igual que el anterior pero empieza a buscar en la posición inicial

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.

str = "ABCDEFGH".

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

REPLACE - reemplaza una cadena dentro de una cadena.

REEMPLAZAR (cadena, cadena desde, cadena a)

Reemplaza desde cadena a cadena en cadena. From-string y to-string no necesitan ser de la misma longitud, to-string tampoco puede ser nada ("") para eliminar un carácter.

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 : elimina los espacios en blanco iniciales y finales (u otros caracteres).

Esto puede ser útil al limpiar indata.

TRIM (cadena)

Elimina todos los espacios iniciales y finales, pestañas, avances de línea, retornos de carro.

TRIM (cadena, carácter).

Elimina todos los "caracteres" iniciales y finales.

LEFT-TRIM y RIGHT-TRIM hacen lo mismo pero solo lideran o arrastran.

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

SUSTITUTO : sustituye los parámetros en una cadena.

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

SUSTITUYE (cadena, param1, param2, ..., param9).

Los parámetros deben estar en el formato &1 a &9 .

Si desea utilizar un signo en la cadena (y no usarlo como parámetro), escúchelo con otro signo: && .

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 parámetro puede aparecer más de una vez en una cadena, todos serán reemplazados:

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

Cuerdas SENSIBLES AL CASO

Todas las cadenas en Progress ABL distinguen entre mayúsculas y minúsculas, a menos que se especifique lo contrario.

Este ejemplo mostrará un cuadro de mensaje que dice que las cadenas son idénticas.

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.

Para declarar que una cadena es sensible a mayúsculas y minúsculas, simplemente agregue el atributo 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.

(Basta con que una de las cuerdas lo tenga en este caso).

COMIENZOS Y PARTIDOS

COMIENZA : devuelve VERDADERO si una cadena comienza con otra cadena.

string1 COMIENZA string2

Si la cadena1 COMIENZA con (o es igual a) cadena2, esto devolverá verdadero. De lo contrario, devolverá falso. Si la cadena dos está vacía (""), siempre devolverá verdadero.

BEGINS es muy útil en consultas donde desea buscar el principio de algo, por ejemplo un nombre. Pero es básicamente una función que trabaja en cuerdas.

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 devuelve true si se cumplen ciertos criterios de comodín en una cadena.

string1 expresión MATCHES

Devuelve true si string1 coincide con la expresión de comodín:

* (asterisco) = 0 a n caracteres (básicamente cualquier cadena de cualquier longitud)

. (punto) = comodín para cualquier carácter (excepto nulo)

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

Convertir mayúsculas y minúsculas

Como se mencionó anteriormente, las cadenas normalmente no distinguen entre mayúsculas y minúsculas, pero eso solo se refiere a la comparación de cadenas. Hay funciones incorporadas para cambiar el caso.

CAPS (cadena)

Hace la cadena de mayúsculas

LC (cadena)

Hace minúsculas de cadena

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

Recuerde que las cuerdas normalmente son insensibles a mayúsculas

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 menos que se especifique como 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

Liza

Hay una serie de funciones y métodos para trabajar con listas separadas por comas (u otros caracteres) en Progress 4GL.

NUM-ENTRIES Devuelve el número de entradas en una lista. Opcionalmente puede especificar delimitador, la coma es por defecto.

NUM-ENTRIES (string [, delimitador])

Usando coma, el delimitador predeterminado:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY NUM-ENTRIES(cList). //3

Usando otro delimitador, semilcolon:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye;cruel;world!".

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

ENTRY - function - devuelve una entrada especificada en una lista

Como de costumbre, la posición inicial es 1, no 0!

ENTRADA (entrada, lista [, delimitador]).

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY ENTRY(2, cList). //cruel

ENTRY - method - asignando el valor de una entrada especificada en una lista

ENTRADA (entrada, lista [, delimitador]) = valor

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 - verifica una lista para una entrada específica. Devuelve su entrada.

Si la cadena no está presente en la búsqueda de lista, se devolverá 0

LOOKUP (cadena, lista [, delimitador])

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

Caracteres especiales (y escapando)

En Progreso 4GL, la forma normal de escribir un carácter especial es precediéndolo con un carácter de tilde (~).

Estos son los caracteres especiales por defecto.

Si desea mostrar tilde en absoluto, debe ser escapado!

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.