RPG Anfänger-Frage

[grunzheini]

Hallo zusammen!

Ich habe folgedes Problem:
Wir bekommen von einem Fremdsystem
Datengelifert, die ich in eine unserer Datenbanken einspielen soll.
Darunter ist ein Alpha-Feld für die Telefonnummer.
Also vom Fremdsystem kommt eine Alpha-Feld in dem alles mögloche drin stehen kann (z.B. '0123/4567')
Das feld auf unserem System, in die ich das übernehmen muss ist ein Decimal-Feld.
Meistens kommen die Zeichen /,*,- o. Blank das habe ich jetzt abgefangen(mit %SCAN),
aber wenn irgend ein anderes Zeichen kommt, mit dem ich nicht gerechnet habe, dann loost mein Programm ab, da ich ja nur die 4 erwähnten Zeichen prüfe.

Nur meine genaue Frage:

Alpha Feld = 0123/4567

Kann ich nicht einfach prüfen, ob sich irgend ein "Nichtnummerisches" Zeichen darin befindet und dies einfach rauswerfen?

Gibt es eine Built-In Function?

Bei Bedarf kann ich auch mal mein kleines Test PRGM einstellen.

Danke schon mal an alle, die mir helfen!

Grunzheini

[USDAVIS]

Hallo,

für Dein Problem bieten sich die OpCodes
CHECK oder (bedingt) TESTN an.

In neueren ILE-RPG-Versionen gibt es
auch die BIF %CHECK

%CHECK(comparator : base {: start})

gruss
Ulli

[grunzheini]

Hmmm...
weiss net ob das so hinhaut, da ich bei check ja wissen muss nach welchen Trennzeichen gesucht werden soll, diese Zeichen können ja alle möglichen sein.

Oder hab ich das jetzt flasch verstanden?



*..1....+....2....+....3....+....4....+....5....+. ...6....+....7...+....
*--------------------------------------------------
* A string contains a series of numbers separated
* by blanks and/or commas.
* Use %CHECK to extract the numbers
*--------------------------------------------------
D string s 50a varying
D inz('12, 233 17, 1, 234')
D delimiters C ' ,'
D digits C '0123456789'
D num S 50a varying
D pos S 10i 0
D len S 10i 0
D token s 50a varying

/free

// make sure the string ends with a delimiter
string = string + delimiters;

dou string = '';

// Find the beginning of the group of digits
pos = %check (delimiters : string);
if (pos = 0);
leave;
endif;

// skip past the delimiters
string = %subst(string : pos);

// Find the length of the group of digits
len = %check (digits : string) - 1;

// Extract the group of digits
token = %subst(string : 1 : len);
dsply ' ' ' ' token;

// Skip past the digits
if (len < %len(string));
string = %subst (string : len + 1);
endif;

enddo;

/end-free

[USDAVIS]

hallo,

etwa so:

D telefonstring s 50a varying
D digits C '0123456789'
D pos S 10i 0


pos = %check (digits : telefonstring);

Wenn alles numerisch ist, ist der Rückkehrcode 0, ansonsten (wenn ein nichtnumerisches Zeichen gefunden wurde) die Position des gefundenen Zeichens.

Das musst Du evtl. im Loop laufen lassen,
um die Art des nichtnumerischen Zeichens zu untersuchen (Trennung zwischen Ortwahl und Rufnummer?) und dann ab der gefundenen Position weitersuchen. Oder speicherst Du die komplette Telefonnummer in einem einzigen Feld ab?

ulli

[grunzheini]

Ja ich speichere die Telefonnummer in einem Feld.
also: 01234/56789
wird zu 0123456789

ich könnte aber dann, wenn ich eine zeichen gefunden habe über SUBST den ersten sauberen Teil in ein zwischenfeld wegschreiben und den rest der nummer nach dem Zeichen noch dazu.
Dann durch ein loob nach einem 2 .o 3 o. 4 zeichen im feld suchen.
durch check nochmal überprüfen, ob das feld saubver ist
richtig?

[USDAVIS]

ja, das sieht gut aus.
genauso würde ich das auch lösen
gruss
ulli

[grunzheini]

Hab das jetzt mal so umgesetzt, aber die
BLANKS bekomme ich dadurch nicht raus.
Werden die BLANKS nicht erkannt bei CHECK?

Ich könnte jetzt noch die Blanks mit %SCAN rausfiltern oder gibts da noch ne möglichkeit?

Danke auf jedenfall schon mal für den Weg hierhin!!!

[USDAVIS]

hallo nochmal,

also beim OpCode bemängelt der CHECK auch blanks und gibt einen entsprechenden Returncode. Bei der BIF-Funktion bin ich mir nicht ganz sicher, da ich diese noch nie benutzt habe (wegen zu niedrigen Versionsstand). Es müsste aber doch eigentlich analog zum OpCode funktionieren.

Ich teste das mal auf unserer Produktionsmaschine, die unter V5 läuft. Habe ich aber erst morgen Zeit für übrig (wegen Feierabend).

Bis dann
Ulli

[Fuerchau]

Ich würde mir das doch sehr einfach machen:

d MyNum 18p 0
d MyChar 18
d MyInd 5I 0
d MyDig 1

MyNum=*zero;
for MyInd=1 to %size(MyChar);
MyDig = %subst(MyChar:MyInd:1);
if %check('0123456789':myDig)=*zero;
MyNum = MyNum*10+%dec(MyDig:1:0);
endif;
next;

Nicht nur negativ denken, sondern positiv (also eher auf gültig als ungültig prüfen).

[USDAVIS]

Gutes Beispiel, womit dann auch bewiesen wäre, dass %CHECK auch mit blanks funktioniert.

Statt %size(MyChar) würde ich allerdings eher %len(%trimr(MyChar)) verwenden, um die Schleife zu optimieren.

ulli

[Fuerchau]

Die Performance ist da eher vernachlässigbar, da bei deiner Methode die Variable erst mal temporär in varsize umkopiert wird, die restlichen Leerzeichen entfernt werden, dann die länge berechnet und anschließend die Variable wieder verworfen wird.
Ausserdem werden die linksstehenden Leerzeichen ja trotzdem bearbeitet.

%size wird bereits zur Compile-Zeit ausgelöst.

Für die Performance-Freaks:

d MyDS DS
d MyNum 18p 0
d MyChar 18
d MyInd 5I 0
d MyDig 1
d MyZDig 1 0 overlay(MyDig)

:
MyNum = MyNum*10+MyZDig;
:

[B.Hauser]

Hallo,

Wenn's um die Performance geht, würde ich zunächst entweder die Built-in-Funktion %INT oder %DEC verwenden um die alphanumerische Nr. zu konvertieren. Sollten in dem String ungültige Zeichen vorhanden sein, erfolgt ein Abbruch. Diesen kann man über eine Monitor-Group abfangen werden. Anstatt im Fehlerfall jedes Zeichen einzeln zu prüfen, würde ich direkt nach den ungültigen Zeichen suchen und diese aus dem String entfernen.

D Digits          C                   const('1234567890 ')    
D Pos             S              3U 0                         
 *************************************************************
 /Free                                                        
  Monitor;  
    Clear MyNum;
    If MyAlpha <> *Blanks;
       MyNum = %Int(MyAlpha);
    EndIf;                                                  
  On-Error;                                     
    DoU Pos = *Zeros;                                         
        Pos = %Check(Digits: MyAlpha);                        
        If Pos <> *Zeros;                                     
           MyAlpha = %Replace('': MyAlpha: Pos: 1); //Entfernen ungült. Zeichen          
        EndIf;                                                
    EndDo;                                                    
    MyNum = %Int(MyAlpha);   
  EndMon;                                                     
/End-Free 

Birgitta