Handynummer zu ordnen

[QuickAndDirty]

Ja es wird dadurch vorwärts...weil in der Liste auch alle Ländercodes Vorwärts sind...
Diese Liste enthält alle Länder die die Italien Methode verwenden.

Ich habe das Problem mal eingegrenzt
hier folgende gedanken:

Problem Eingrenzung!!!!!!!!!
KnownNumber:
1.Enthält nie eine AMT
2.Enthält immer die Ortsvorwahl oder Handynetz-Vorwahl samt Präfix(z.B. 0) wenn Extern
3.Wenn Intern dann ist keine Ortsvorwhal oder Netzvorwahl angegeben

UnknownNumber:
1.Enthält AMT wenn von extern Angerufen wird und Amt eingestellt ist.
2.Enthält kein AMT wenn ein Anruf von Intern kommt.

A. Aus 1. und 2. -> Amt muss ermittelt und gegebenenfalls gelöscht werden

3.Enthält immer die Ortsvorwahl oder Handynetz-Vorwahl samt Präfix(z.B. 0) wenn Extern
4.Wenn 3. nicht Zutrifft kann Folgendes enthalten sein
(LandesVorwahl samt NationalExitCode)+(Ortsvorwahl ohne Präfix)

B. Aus 3. und 4. -> die Ortsvorwahl oder Handynetz Vorwahl samt Präfix muss
nicht ermittelt werden.
C. Aus 3. und 4. -> Es ist zu ermittlen ob die Nummer
(Lokale Landesvorwahl samt NationalExitCode) an 1. Stelle enthält
Wenn dem so ist ,dann
-Löschen von (Lokale Landesvorwahl samt NationalExitCode) in UnknownNumber
-Prüfen ob KnwonNumber Präfix enthält und gegebenenfalls löschen(Hier ist Italien nicht mit berücksichtigt)

D. Abschließend vergleichen der beiden Nummern.

[nahpets]

Hallo,

habe mal eine Frage:

Wird das Amt überhaupt irgendwann angezeigt? Kann mich nicht erinnern, diese bisher jemals auf dem Telefondisplay gesehen zu haben. Das Amt dürfte doch eigentlich nur als Kennung bis zur eigenen Telefonanlage gehen und die geht dann ohne das Amt raus in die Welt. Lösen wir hier eventuell ein Problem, das es garnicht gibt?

Kann nicht versprechen, dass ich morgen zum weiteren Testen unf Grübeln komme, werde mir aber Mühe geben

PS.: Irgendwie hatte die Forumssoftware mit dem Ursprungstext ein Probleme, sie hat nur den Smilie angezeigt.

[nahpets]

Hallo,

habe mich nochmal mit Deinen Ausführungen befasst und meine Testdaten dahingehend angepasst und folgende, fehlerhafte Ergebnisse gefunden:

interner ExitCode = 9
AreaCode = 0211
CountryCode = 0049
Nationaler ExitCode = 00

bekannt und unbekannt
0211123456 und 0123456 stimmen überein
0049211123456 und 0123456 stimmen überein
1123456 und 01123456 stimmen überein
123456 und 09123456 stimmen überein
09123456 und 123456 stimmen überein

interner ExitCode = 09
AreaCode = 0211
CountryCode = 0049
Nationaler ExitCode = 00

bekannt und unbekannt
0211123456 und 0123456 stimmen überein
0049211123456 und 0123456 stimmen überein
1123456 und 01123456 stimmen überein

interner ExitCode = 09
AreaCode = 030
CountryCode = 0049
Nationaler ExitCode = 00

bekannt und unbekannt
1123456 und 01123456 stimmen überein

interner ExitCode = 09
AreaCode = 040
CountryCode = 0049
Nationaler ExitCode = 00

bekannt und unbekannt
1123456 und 01123456 stimmen überein

interner ExitCode = 9
AreaCode = 040
CountryCode = 0049
Nationaler ExitCode = 00

bekannt und unbekannt
1123456 und 01123456 stimmen überein
123456 und 09123456 stimmen überein
09123456 und 123456 stimmen überein

interner ExitCode = 9
AreaCode = 040
CountryCode = 0039
Nationaler ExitCode = 00

bekannt und unbekannt
1123456 und 01123456 stimmen überein
123456 und 09123456 stimmen überein
09123456 und 123456 stimmen überein

interner ExitCode = 9
AreaCode = 040
CountryCode = 001
Nationaler ExitCode = 011

bekannt und unbekannt
1123456 und 01123456 stimmen überein
123456 und 09123456 stimmen überein
09123456 und 123456 stimmen überein

Es scheint so, dass die Prüfung nur dann fehlerhaft ist, wenn AMT <> 0 ist.

Wenn es gelingen könnte ohne Amt auszukommen, dürfte Deine Routine in Ordnung sein. Bei meinem ersten Arbeitgeber hatten wir als Amt die 10, so dass man hier nicht immer von der 0 oder einer einstelligen Zahl ausgehen kann.

[QuickAndDirty]

Also Amt wird in der Regel nicht durch die Telefonanlage weiter gegeben.
Wenn es Ausnahmnsweise doch so ist muss Amt angegeben werden.

Die Handynetzvorwahl oder die Ortsvorwahl werden bei allen von Extern kommenden Gesprächen angezeigt

habe noch mal von neu angefangen und verwende jetzt das hier:

Es funktioniert unter den diskutierten Bedingungen...und es funktioniert nicht in Italien...
ich glaube dem Problem stelle ich mich erst wenn einer unserer Italien Kunden das Telefonmodul einsetzt.

Delphi-Quellcode:

// Liefert die erste unterschiedliche Stelle oder 0 wenn
// keine Unterschiede bestehen.
Function EqualStr(a : String;
                  b : String) : Integer;
Var I               : Integer;
    L               : Integer;
    iLenA           : Integer;
    iLenB           : Integer;
Begin
  iLenA := Length(a);
  iLenB := Length(b);
  L := Min(iLenA,iLenB);
  For i := 1 to L Do
  Begin
    if a[i] <> b[i] then
    Begin
      result := i;
      exit;
    end;
  end;
  if iLenA <> iLenB then
  begin
    Result := succ(L);
    exit;
  end
  else
  begin
    Result := 0;
  end;
end;

Function FilterString(s,AllowedChars:String):String;
var i, j : integer;
    Erlaubt : boolean;
Begin
  Result := s;
  For i := 1 to length(s) do
  Begin
    Erlaubt := false;
    for j := 1 to Length(AllowedChars) do
    Begin
      if (Result[i] = AllowedChars[j]) then
      Begin
        Erlaubt  := true;
        Break;
      end
    end;
    if not erlaubt then
      delete(result,i,1);
  end;
end;


Function EqualCaller(NumberOfCaller,
                     CallingNumber,
                     InternExitCode,
                     AreaCode,
                     CountryCode,
                     NationalExitcode:String):boolean;

  function DetectCode(aNumber,aCode:string): Boolean;
  Begin
    If (ACode = '') then
      Result := False
    else
      Result := (EqualStr(aNumber,Acode) = succ(length(acode)));
  end;

Var InternExitCodeDetected:boolean;
    InternalCalling:Boolean;
    MobileInternationalCalling:Boolean;
    CallerNumberPrefix:Boolean;
Begin
  Result := false;
  NumberOfCaller := FilterString(StringReplace(NumberOfCaller,'+',NationalExitcode,[]),'1234567890');
  CallingNumber := FilterString(StringReplace(CallingNumber,'+',NationalExitcode,[]),'1234567890');
  If (NumberOfCaller <> '') and (CallingNumber <> '')  then
  begin
    //Amt elliminieren
    InternExitCodeDetected := DetectCode(CallingNumber,InternExitCode);
    If InternExitCodeDetected then
      delete(CallingNumber,1,length(internExitCode));
    //Amt Elliminiert

    InternalCalling := (not InternExitCodeDetected) and (InternExitCode<>'');


    If not InternalCalling then // Wenn Anruf von extern
    begin
      // Countrycode + AereaCode ohne Präfix elliminieren
      if length(CallingNumber) > Length(CountryCode) then
      begin
        MobileInternationalCalling := DetectCode(CallingNumber, CountryCode);
        if MobileInternationalCalling then
        Begin
          Delete(CallingNumber,1,length(CountryCode));
          CallerNumberPrefix := DetectCode(NumberOfCaller,'0'); //Prefix ermitteln
          if CallerNumberPrefix then
            Delete(NumberOfCaller,1,1) //Prefix löschen
          else
            exit;//Result := false; Weil ist InternalCaller aber nicht InternalCalling
        end;
      end;
      // Countrycode + AreaCode ohne Präfix elliminiert!
    end;
    Result := (NumberOfCaller = CallingNumber);
  end;//  If (NumberOfCaller <> '') and (CallingNumber <> '')  then
end;//Function EqualCaller(NumberOfCaller,....

[oki]

Hi Leute,

sorry, wenn ich jetzt einige Themen wiederhole, aber ich habe die vorherigen Threads nur diagonal gelesen. Folgendes von mir dazu:

Amt:
Wird eine Nebenstellenanlage zum telefonieren genutzt, so ist die Amtsholung nur intern. Es gibt Nebenstellenanlagen mit automatischer Amtsholung, Amtsholung mit 0, Amtsholung mit 99 und einstellbarer Kennziffer.
Alle haben aber eines gemeinsam, die Kennziffer für die Amtsholung wird nicht in das Amt weitergereicht. Damit kann die Vermittlungsstelle nämlich nichts anfangen.

Rufnummer:
Wie eine Rufnummer aufgebaut ist wurde schon beschrieben. Die eindeutige Identifizierung für die Wahl ist klar,
Festnetz:
[Exit-Code oder +][Länderkennung][Vorwahl][Rufnummer][Netzwerknummer]
Mobilnetz:
[Exit-Code oder +][Länderkennung][Rufnummer]

Imho liefern deutsche digitale Vermittlungsstellen mindestens die Teile Vorwahl und Rufnummer aus dem deutschen Netz. Auch wenn aus dem eigenen Ortsnetz telefoniert wird. Die Netzwerknummer nur bedingt (das ist die Durchwahl der Nebenstelle bei Anrufen aus Nebenstellenanlagen mit Anlagenanschluß). Die Weitergabe der Durchwahlnummer kann in Nebenstellenanlagen nämlich abgeschaltet werden.

Rufe aus dem Ausland werden immer in der Variante [Exit-Code oder +][Länderkennung][Vorwahl][Rufnummer] übermittelt.

Für das Mobilnetz gilt als Länderkennung immer das Land, in dem das Telefon angemeldet ist. Ruft also jemand mit einem in Deutschland angemeldeten Handy aus Frankreich an, so wird +49... übermittelt.

Ich würde davon abraten, von hinten zu identifizieren. Es gibt keine einheitliche Länge für eine Rufnummer, nur eine max. Länge.

Imho sollte der richtige Weg sein sich eine Tabelle alle ExitCodes und Ländercodes zu erstellen (findet man im I-Net?) und auf diese zu prüfen. Die sollten eindeutig sein. Sonst würde ja jemand zufällig mit einer Ortsvorwahl in Amerika landen. Die wird abgeschnitten wenn erkannt. Danach folgt in der Regel die Ortsvorwahl ohne 0. Bei dem Thema Ortsvorwahlen und 0 im Ausland bin ich aber auch nicht sattelfest.

Wer die entsprechenden Vorwahlverzeichnisse für die einzelnen Länder hat kann dann sicher noch auf die Vorwahl per Liste prüfen. Aber ich glaube, dass habt ihr schon.

Auf jeden Fall würde ich nie von hinten beginnend prüfen.

Jo, das von meiner Seite, sorry wenn ich was wiederholt habe,

Gruß oki

[nahpets]

Hallo,

nachdem ich mit den bisher erreichten Ergebnissen beim Vergleich von Telefonnummern nicht zufrieden war, hab' ich mir 'ne Komponente für diese Aufgabe geschrieben.

Eventuell hat ja noch jemand Interesse daran.

Delphi-Quellcode:

{
  Komponente zum Vergleich von Telefonnummern:
  Es wird davon ausgegangen, dass die bekannte Telefonnummer folgenden Aufbau hat:
  Nationaler Exitcode
+ Landesvorwahl
+ Ortsvorwahl (ohne führende 0, sofern national zulässig)
+ Telefonnummer
  Beispiele: 004930123456789, 003906123456789, 0049171123456789
}
unit CheckPhoneNumber;

interface

uses
  SysUtils, Classes;

type TTypeOfAreaCode = (acNormal, acItaly);

type
  TCheckPhoneNumber = class(TComponent)
  private
    { Private-Deklarationen }
    FNationalExitCode          : String; // 00  -> Vorwahl ins Ausland
    FReverseNationalExitCode   : String; // FNationalExitCode in umgekehrter Zeichenfolge
    FCountryCode               : String; // 49  -> Landesvorwahl
    FReverseCountryCode        : String; // FCountryCode in umgekehrter Zeichenfolge
    FAreaCode                  : String; // 0511 -> Vorwahl
    FReverseAreaCode           : String; // FAreaCode in umgekehrter Zeichenfolge
    FInternExitCode            : String; // Vorwahl für Amt
    FReverseInternExitCode     : String; // FInternExitCode in umgekehrter Zeichenfolge
    FPhoneNumber               : String; // Telefonnummer
    FReversePhoneNumber        : String; // FPhoneNumber in umgekehrter Zeichenfolge
    FUnknownPhoneNumber        : String; // Telefonnummer, die auf Gleichheit geprüft werden soll
    FReverseUnknownPhoneNumber : String; // FUnknownPhoneNumber in umgekehrter Zeichenfolge

    FTypeOfAreaCode            : TTypeOfAreaCode; // Art des Vergleiches
    FEqualPhoneNumbers         : Boolean;         // True wenn Telefonnummern übereinstimmen
  protected
    { Protected-Deklarationen }
    function  NormalizePhoneNumber(AValue : String) : String;
    function  ComparePhoneNumbers(No1 : String; No2 : String) : Integer; overload;
    function  ComparePhoneNumbers : Boolean; overload;
    function  AddFirst0(No : String) : String;
    function  RemoveFirst0(No : String) : String;

    procedure SetAreaCode(AValue : String);
    procedure SetCountryCode(AValue : String);
    procedure SetInternExitCode(AValue : String);
    procedure SetNationalExitCode(AValue : String);
    procedure SetPhoneNumber(AValue : String);
    procedure SetUnknownPhoneNumber(AValue : String);

    procedure SetTypeOfAreaCode(AValue : TTypeOfAreaCode);
    procedure SetEqualPhoneNumbers(AValue : Boolean);
  public
    { Public-Deklarationen }
  published
    { Published-Deklarationen }
    property AreaCode           : String Read FAreaCode           Write SetAreaCode;
    property CountryCode        : String Read FCountryCode        Write SetCountryCode;
    property InternExitCode     : String Read FInternExitCode     Write SetInternExitCode;
    property NationalExitCode   : String Read FNationalExitCode   Write SetNationalExitCode;
    property PhoneNumber        : String Read FPhoneNumber        Write SetPhoneNumber;
    property UnknownPhoneNumber : String Read FUnknownPhoneNumber Write SetUnknownPhoneNumber;
    property TypeOfAreaCode     : TTypeOfAreaCode Read FTypeOfAreaCode    Write SetTypeOfAreaCode;
    property EqualPhoneNumbers  : Boolean         Read FEqualPhoneNumbers Write SetEqualPhoneNumbers;
  end;

procedure Register;

implementation

Uses
     StrUtils, Math;

procedure Register;
begin
  RegisterComponents('TelTools', [TCheckPhoneNumber]);
end;

{ Die Funktion entfernt aus einer Telefonnummer alle Zeichen, bei denen
  es sich nicht um Ziffern handelt. Das Plus wird durch den konfigurierten
  nationalen Exitcode ersetzt.
~param AValue zu beabeitender Wert
~result Um alle "Nichtziffern" bereinigte Telefonnummer}
function  TCheckPhoneNumber.NormalizePhoneNumber(AValue : String) : String;
Var
          i            : Integer;
          s            : String;
begin
  s := '';
  AValue := StringReplace(AValue,'+',FNationalExitCode,[]);
  for i := 1 To Length(AValue) do begin
    Case AValue[i] of
      '0'..'9' : s := s + AValue[i];
    end;
  end;
  Result := s;
end;

{ Die Funktion vergleicht zwei Telefonnummern und liefert die Position des
  ersten Unterschiedes.
~param No1 1. zu vergleichende Telefonnummer
~param No2 2. zu vergleichende Telefonnummer
~result Position des ersten Unterschiedes }
function  TCheckPhoneNumber.ComparePhoneNumbers(No1 : String; No2 : String) : Integer;
Var
          i                   : Integer;
          iMinLength          : Integer;
          bNotEqual           : Boolean;
begin
  i := 1;
  bNotEqual := True;
  iMinLength := Min(Length(No1),Length(No2));
  if iMinLength > 0 then begin
    repeat
      bNotEqual := (No1[i] <> No2[i]);
      inc(i);
    until bNotEqual or (i > iMinLength);
  end;
  if bNotEqual then begin
    Dec(i);
    Result := i;
  end else begin
    Result := i;
  end; 
end;

{ Die Funktion entfernt die führende Vorwahlnull aus einer Telefonnummer,
  sofern dies konfiguriert ist, andernfalls wird sie unverändert zurückgegeben.
  Ist die übergebene Telefonnummer leer, so wird ein X zurückgegeben.
~param No zu bearbeitende Telefonnummer
~result bearbeitete Telefonnummer }
function  TCheckPhoneNumber.RemoveFirst0(No : String) : String;
begin
  // Hier gibt es jetzt noch länderspezifische Besonderheiten:
  // In vielen Ländern fällt im Zusammerhang mit der Landesvorwahl bei der
  // Ortsvorwahl die führende 0 weg, nicht so in Italien.
  Case FTypeOfAreaCode of
    acItaly  : begin // hier bleibt die führende 0 erhalten
               end;
    acNormal : begin
                 // führende 0 entfernen
                 if Length(No) > 0 then begin
                   Case No[Length(No)] of
                     '0' : begin
                             No := Copy(No,1,Length(No) - 1);
                           end;
                   end;
                 end else begin
                   No := 'X';
                 end;
               end;
  end;
  Result := No;
end;

{ Die Funktion fügt eine führende Vorwahlnull der Telefonnummer hinzu,
  sofern dies konfiguriert ist, andernfalls wird sie unverändert zurückgegeben.
~param No zu bearbeitende Telefonnummer
~result bearbeitete Telefonnummer }
function  TCheckPhoneNumber.AddFirst0(No : String) : String;
begin
  // Hier gibt es jetzt noch länderspezifische Besonderheiten:
  // In vielen Ländern fällt im Zusammerhang mit der Landesvorwahl bei der
  // Ortsvorwahl die führende 0 weg, nicht so in Italien.
  Case FTypeOfAreaCode of
    acItaly  : begin // hier bleibt die führende 0 erhalten
               end;
    acNormal : begin
                 No := No + '0';
               end;
  end;
  Result := No;
end;

{ Die Funktion vergleicht zwei Telefonnummern und liefert bei Übereinstimmung
  True als Rückgabewert.
~result True oder False }
function  TCheckPhoneNumber.ComparePhoneNumbers : Boolean;
Var
          i                   : Integer;
          bNotEqual           : Boolean;
          sPhoneNumber        : String;
          sUnknownPhoneNumber : String;
begin
  // Zuerst werden die vollständigen Nummern verglichen.
  bNotEqual := FReversePhoneNumber <> FReverseUnknownPhoneNumber;
  If not bNotEqual Then begin
    Result := Not bNotEqual;
    Exit;
  end;
  // Die Telefonnummer stimmen nicht überein:
  // i enthält die Position des ersten Unterschiedes
  i := ComparePhoneNumbers(FReversePhoneNumber,FReverseUnknownPhoneNumber);
  // Alles ab diesem Unterschied holen.
  sPhoneNumber        := Copy(FReversePhoneNumber,i,Length(FReversePhoneNumber));
  sUnknownPhoneNumber := Copy(FReverseUnknownPhoneNumber,i,Length(FReverseUnknownPhoneNumber));
  // Ist das Ergebnis unterschiedlich?
  bNotEqual := sPhoneNumber <> sUnknownPhoneNumber;
  if bNotEqual then begin
    // Ist der verbliebene Rest der unbekannten Telefonnummer leer
    // dann müssen wir prüfen,
    If (sUnknownPhoneNumber = '') then begin
      // ob die verbliebene Telefonnummer mit
      // der Vorwahl, der Landesvorwahl und dem ExitCode übereinstimmt.
      if (sPhoneNumber = RemoveFirst0(FReverseAreaCode) + FReverseCountryCode + FReverseNationalExitCode) then begin
        // Dann prüfen, ob die bekannte Telefonnummer mit der unbekannten
        // Telefonnummer, der Vorwahl, der Landesvorwahl und dem Exitcode übereinstimmt.
        bNotEqual := FReversePhoneNumber <> (FReverseUnknownPhoneNumber
                                           + RemoveFirst0(FReverseAreaCode)
                                           + FReverseCountryCode
                                           + FReverseNationalExitCode);
      end else
      // ob die verbliebene Telefonnummer mit
      // der Landesvorwahl und dem ExitCode übereinstimmt.
      if (sPhoneNumber = FReverseCountryCode + FReverseNationalExitCode) then begin
        // Dann prüfen, ob die bekannte Telefonnummer mit der unbekannten
        // um die führende Vorwahlnull erweiterte Telefonnummer, 
        // der Landesvorwahl und dem Exitcode übereinstimmt.
        bNotEqual := FReversePhoneNumber <> (AddFirst0(FReverseUnknownPhoneNumber)
                                           + FReverseCountryCode
                                           + FReverseNationalExitCode);
      end else
      // ob die verbliebene Telefonnummer mit
      // dem ExitCode übereinstimmt.
      if (sPhoneNumber = FReverseNationalExitCode) then begin
        // Dann prüfen, ob die bekannte Telefonnummer mit der unbekannten
        // Telefonnummer und dem Exitcode übereinstimmt.
        bNotEqual := FReversePhoneNumber <> (FReverseUnknownPhoneNumber
                                           + FReverseNationalExitCode);
      end;
    end else
    // Ist der verbliebene Rest der unbekannten Telefonnummer eine 0
    // dann müssen wir prüfen,
    If (sUnknownPhoneNumber = '0') then begin
      // ob die verbliebene Telefonnummer mit
      // der Landesvorwahl und dem ExitCode übereinstimmt.
      if (sPhoneNumber = FReverseCountryCode + FReverseNationalExitCode) then begin
        // Dann prüfen, ob die bekannte Telefonnummer mit der um die Vorwahlnull
        // gekürzten unbekannten Telefonnummer, der Landesvorwahl
        // und dem Exitcode übereinstimmt.
        bNotEqual := FReversePhoneNumber <> (RemoveFirst0(FReverseUnknownPhoneNumber)
                                           + FReverseCountryCode
                                           + FReverseNationalExitCode);
      end;
    end;
  end;
  Result := Not bNotEqual;
end;

procedure TCheckPhoneNumber.SetNationalExitCode(AValue : String);
begin
  FNationalExitCode          := NormalizePhoneNumber(AValue);
  FReverseNationalExitCode   := ReverseString(FNationalExitCode);
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetCountryCode(AValue : String);
begin
  FCountryCode               := NormalizePhoneNumber(AValue);
  FReverseCountryCode        := ReverseString(FCountryCode);
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetAreaCode(AValue : String);
begin
  FAreaCode                  := NormalizePhoneNumber(AValue);
  FReverseAreaCode           := ReverseString(FAreaCode);
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetInternExitCode(AValue : String);
begin
  FInternExitCode            := NormalizePhoneNumber(AValue);
  FReverseInternExitCode     := ReverseString(FInternExitCode);
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetPhoneNumber(AValue : String);
begin
  FPhoneNumber               := NormalizePhoneNumber(AValue);
  FReversePhoneNumber        := ReverseString(FPhoneNumber);
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetUnknownPhoneNumber(AValue : String);
begin
  FUnknownPhoneNumber        := NormalizePhoneNumber(AValue);
  FReverseUnknownPhoneNumber := ReverseString(FUnknownPhoneNumber);
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetTypeOfAreaCode(AValue : TTypeOfAreaCode);
begin
  FTypeOfAreaCode            := AValue;
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

procedure TCheckPhoneNumber.SetEqualPhoneNumbers(AValue : Boolean);
begin
  FEqualPhoneNumbers         := ComparePhoneNumbers;
end;

end.

[QuickAndDirty]

Sieht sehr sauber aus.
hast du schon Test Ergebnisse?

Warum soll der Vergleich weiterhin von hinten durchgeführt werden?

PS:
Mal so am Rande, ich brauche das um Anrufer für ein Sprach und Tastencode
geführtes Menü zu autorisieren (unerwünschte sollen abgewiesen werden,
erwünschte Anrufer sollen ihre eigenen Daten manipulieren oder Abrufen können)

[nahpets]

Hallo,

bei meinen paar Testdaten habe ich keine Fehler mehr feststellen können (aber das heißt bei 20 Testsätzen nichts).
Von hinten nach vorne erschien mir technisch einfacher, sonst müsste man halt Teilstrings von rechts nach links bilden und ich wollte nicht alles neu erfinden.
Naja, der Code ist halt beim Testen entstanden, zuerst hab' ich nur die Telefonnummern ohne Exitcode, Landesvorwahl und Vorwahl verglichen, dann mit Vorwahl, dann mit Landesvorwahl, dann mit Exitcode.
Beim letzteren bin ich mir nicht sicher, ob es sinnvoll ist, ihn zu speichern oder ob es nicht besser ist, dort nur das + zu speichern.
Im Zusammenhang mit Deiner Aufgabenstellung: Bekommst Du den Nationalen Exitcode überhaupt "zu sehen"? Dann muss er natürlich gespeichert werden.

Wenn ich Deine Aufgabenstellung richtig verstehe heißt das: Du brauchst eine 100%ige Sicherheit für die Prüfung, ein Ergebnis ala, das scheint zu passen, aber schau doch nochmal einer nach ist für Dich unbrauchbar. Andererseits kann man aber davon ausgehen, dass Du die Telefonnummern in einem einheitlichen Format erhälts. (Poste doch bitte mal ein paar Beispiele für die Telefonnummern, die Du bekommst und für die, die Du zum Abgleich zur Verfügung hast.)

Werde mal schauen, ob ich irgendwie an eine größere Menge von Testdaten komme.

[EDIT]
Habe jetzt mal gegen ein paar tausend Telefonnummern getestet, die Ergebnisse scheinen auf den ersten Blick zu stimmen, dort wo Unterschiede erkannt werden, sind auch welche vorhanden. Die Menge der übereinstimmenden Nummern kann ich nicht vollständig überprüfen, sie ist zu groß. Habe aber keinen Daten finden können, die fälschlich als übereinstimmend erkannt werden. Die Vorwahlbesonderheit von Italien wird korrekt erkannt. Auch die Änderung von Areacode oder Exitcode wird korrekt erkannt.
[/EDIT]

[QuickAndDirty]

Naja es geht ums an und abstempeln und um Zeitkonten abzurufen...also keine Bank- oder Vertragsdaten.
100% Sicherheit muss nicht sein. Ich denke ich habe soweit alles. Werde mir die Klasse trotzdem mal genauer anschauen und austesten.

Wozu brauchst du sie, die Telefonnummernvergleiche?

[nahpets]

Hallo,

naja, hänge immer wieder vor diversen Datenbeständen, die zusammengeführt werden sollen. Irgendwie müssen die Redundanzen raus oder zumindest minimiert werden. Was ist da (theoretisch) naheliegender, als die Telefonnummer, die ist ja eindeutig. Was man bei Namen und den vielfältigen Schreibweisen, für eigentlich identische Namen, nicht behaupten kann. Auch bei den übrigen Adressdaten ist's nicht trivial identische zu finden. SoundEx, Kölner Phonetik, Levenshteindistanz und was es da alles gibt, nix liefert mir Ergebnisse, mit denen ich zufrieden bin, aber alle zusammen sind schon eine Hilfe.
Na und so entstehen immer wieder mal Ideen, wie man etwas prüfen könnte und im Laufe der Zeit schafft man's dann doch, zumindest den größten Teil der Redundanzen zu erkennen. Und Deine Frage und die daraus resultierende Diskussion hab' ich einfach mal zum Anlass genommen, mir eine Routine zu schreiben, die bei der Problemlösung hilfreich sein könnte.