Telefonnummern Parsen

[bikerboy]

ja aber was soll ich denn machen die Anwendung braucht halt die nummer in 4 teilen. das war bis jetzt immer so und wird sich auch nicht ändern.

Und bitte nennt mich nicht mehr Radlbub!!! Ich habe doch schon meinen vollständigen Namen unter den Post. Und ich mag den Namen. Es geht hier um Motorrad fahren, nicht um Fahräder !

[flaite]

Um ausloten zu können, inwieweit sich regex über LS2J für solche Anwendungsfälle nutzen lassen, schreib ich ein kleines Stück wiederverwendbaren Code.
Gleichzeitig hab ich aber z.Zt. wenig Zeit. Schätze aber, dass ich das morgen als .nsf posten kann.

Hier schonmal ein Beispiel wie die Regex aussehen könnte und die Ergebnisse.
Geprüft (und formatiert ) werden soll auf deutsche Festnetznummern.
 

Code

1. (0049)02234 64480
2. 49223464480
4. 00496 2234 64480
5. 0049 (0)2234 64480
6. 02234 644480
~~~~
^((\(?(00)?49\)?)?(-|\s)?((0|\(0\))?\s?[0-9]{3,4})((-|\s)?[0-9]{5,8})){1}$

Überhalb von ~~~~ sind ein paar Beispieleingaben. Dadrunter die regex selbst.
Die Regex meint ungefähr:
((\(?(00)?49\)?)? -> für Ländervorwahl.
((0|\(0\))?\s?[0-9]{3,4}) -> für Ortsvorwahl.
[0-9]{5,8} -> für Nummer.

hier die Ergebnisse:

Code

C:\eclipse33\eclipse\workspace\Regex\src\in.txt
*************************
1. (0049)02234 64480
Regular expression: "^((\(?(00)?49\)?)?(-|\s)?((0|\(0\))?\s?[0-9]{3,4})((-|\s)?[0-9]{5,8})){1}$"
Match "(0049)02234 64480" at postion 0-16
m.group(1)=(0049)02234 64480
m.group(2)=(0049)
m.group(3)=00
m.group(4)=null
m.group(5)=02234
m.group(6)=0
m.group(7)= 64480
*************************
2. 49223464480
Regular expression: "^((\(?(00)?49\)?)?(-|\s)?((0|\(0\))?\s?[0-9]{3,4})((-|\s)?[0-9]{5,8})){1}$"
Match "49223464480" at postion 0-10
m.group(1)=49223464480
m.group(2)=49
m.group(3)=null
m.group(4)=null
m.group(5)=2234
m.group(6)=null
m.group(7)=64480
*************************
3. 00496 2234 64480
Regular expression: "^((\(?(00)?49\)?)?(-|\s)?((0|\(0\))?\s?[0-9]{3,4})((-|\s)?[0-9]{5,8})){1}$"
NO MATCH
*************************
4. 0049 (0)2234 64480
Regular expression: "^((\(?(00)?49\)?)?(-|\s)?((0|\(0\))?\s?[0-9]{3,4})((-|\s)?[0-9]{5,8})){1}$"
Match "0049 (0)2234 64480" at postion 0-17
m.group(1)=0049 (0)2234 64480
m.group(2)=0049
m.group(3)=00
m.group(4)= 
m.group(5)=(0)2234
m.group(6)=(0)
m.group(7)= 64480
*************************
5. 02234 644480
Regular expression: "^((\(?(00)?49\)?)?(-|\s)?((0|\(0\))?\s?[0-9]{3,4})((-|\s)?[0-9]{5,8})){1}$"
Match "02234 644480" at postion 0-11
m.group(1)=02234 644480
m.group(2)=null
m.group(3)=null
m.group(4)=null
m.group(5)=02234
m.group(6)=0
m.group(7)= 644480

Wie man sieht ist die Länderkennzeicheneingabe optional.
Punkt 3 ist ein NO MATCH. (Das Länderkennzeichen von Deutschland ist 0049, wobei 00 optional sind.
Feste Standards für die Eingabe, würden die Regex erleichtern. Regexs können sowas extrem gut prüfen. In einer Messagebox kann dem Anwender die richtige Formatierung mitgeteilt werden, falls der Text auf die Regex fehlschlägt.
Mir schwebte aber wie oben angedeutet etwas anderes vor. Das System akzeptiert sehr verschiedene Formatierungen, formatiert es dann aber in einer Art Eingabeumsetzung einheitlich. Mal schauen wie weit man damit kommt. Dafür dieses ganze groups-Zeugs (ist ein Regex-Feature).
In der .nsf sollen dann beide Anwendungsszenarien unterschützt werden.

Hier ist noch der Java Code für den Test selbst:

Code

package de.spi.regex;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TestRegularExpression {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		File file = new File("src/in.txt");
		System.out.println(file.getAbsolutePath());
		List input = new ArrayList();
		List regex = new ArrayList();
		BufferedReader bufInputReader = new BufferedReader(new FileReader(file));
		String line;
		boolean isInput = true;
		while ((line = bufInputReader.readLine()) != null) {
			if (line.startsWith("~~~")) {
				isInput = false;
			} else if (isInput) {
				input.add(line);
			} else {
				regex.add(line);
			}
		}
		if ((input.size() == 0) || (regex.size() == 0)) {

			System.out.println("No input or regex");
			System.exit(0);
		}

		for (int i = 0; i < input.size(); i++) {
			String inputS = input.get(i).toString();
			System.out.println("*************************");
			System.out.println(inputS);
			
			for (int j = 0; j < regex.size(); j++) {
				String regexS = regex.get(j).toString();
				System.out.println("Regular expression: \"" + regexS + "\"");
				Pattern p = Pattern.compile(regexS);
				Matcher m = p.matcher(inputS);
				boolean match=false;
				while (m.find()) {
					match = true;
					System.out.println("Match \"" + m.group()
							+ "\" at postion " + m.start() + "-"
							+ (m.end() - 1));
					for (int k=1;k<m.groupCount();k++) {
						System.out.println("m.group(" + k + ")=" + m.group(k));
					}
					
				}
				if (!match) {
					System.out.println("NO MATCH");
				}

			}
		}

	}

}

Gruß Axel