StringList Buchstaben verbieten?

[zobien123]

Guten Morgen zusammen:-D,

ich lese alle Ordernamen in eine StringList ein. Nun möchte ich mit diesen weiter arbeiten, jedoch nur mit denen, die numerisch sind. Gibt es irgendwie eine Möglichkeit, mit der man bei einer StringListe nur numerische Einträge zulasssen kann? Oder muss ich im nachhinein die nicht numerischen Einträge irgendwie raussuchen und dann löschen?:pale:

Schon mal vielen Dank für eure Antworten:wink:

[haentschman]

Moin...:P

Zitat:

ich lese alle Ordernamen in eine StringList ein

...gut. :zwinker:

Zitat:

jedoch nur mit denen, die numerisch sind

...:gruebel: In der Liste stehen nur Buchstaben. Ob das ein Pfad ist oder die Farbe deiner Unterhosen ist mal egal. :zwinker:

Zitat:

Oder muss ich im nachhinein die nicht numerischen Einträge irgendwie raussuchen und dann löschen

...du mußt dir definieren was, in deinem Falle, "numerisch" eigentlich ist. Dann mußt du die Einträge "durchsuchen" was deinen Vorgaben entspricht. Und die Nicht gewollten löschen.
Sichwort: TSringList.Delete, Copy oder RexEx...

[Aviator]

Oder du machst dir eine Ableitung der TStringList und überschreibst die Add Methode. Hier kannst du direkt filtern was du zulassen möchtest und was nicht. Halte ich persönlich für die einfachste Variante ohne mir jetzt irgendwelchen SourceCode ausgedacht zu haben.

[zobien123]

Danke für eure schnellen Antworten :)

Zitat:

Oder du machst dir eine Ableitung der TStringList und überschreibst die Add Methode.

Puuuh... das hört sich für mich als Anfänger ziemlich schwer an:pale:

Ich probier es nun mal so:

Zitat:

...du mußt dir definieren was, in deinem Falle, "numerisch" eigentlich ist. Dann mußt du die Einträge "durchsuchen" was deinen Vorgaben entspricht. Und die Nicht gewollten löschen.
Sichwort: TSringList.Delete, Copy oder RexEx...

[DeddyH]

Für ersteren Vorschlag hab ich mal schnell etwas zusammengedengelt. Es geht auch eleganter, aber ich denke, so ist es halbwegs verständlich:

Delphi-Quellcode:

type
  TMyStringList = class(TStringList)
  public
    function Add(const S: string): Integer; override;
  end;

...

{ TMyStringList }

function TMyStringList.Add(const S: string): Integer;

  function IsNumeric(const s: string): Boolean;
  const
    NUMBERS = ['0'..'9'];
  var
    i: integer;
  begin
    Result := true;
    for i := 1 to Length(s) do
      if not (s[i] in NUMBERS) then
        begin
          Result := false;
          Exit;
        end;
  end;

begin
  if IsNumeric(S) then
    Result := inherited Add(S)
  else
    Result := -1;
end;

Wenn ich keinen Denkfehler gemacht habe, sollten nur noch Strings hinzugefügt werden, die komplett aus Ziffern bestehen.

[Christian Seehase]

Moin Jörn,

bitte denke dran:
Da Du, aller Voraussicht nach, Zeilen aus der Strlngliste
löschen wirst, solltest Du diese rückwärts durchgehen, also
von StringList.Count-1 to 0, da Du ansonsten auf einen Fehler
laufen wirst. (Index out of bounds)

[DeddyH]

downto ;)

[himitsu]

Zitat:

Rückwärts/downto

Oder eine While-Schleife.
Entweder Inc(Idx) oder SL.Delete(Idx) :stupid:


So, genug verwirrt ... viel Spaß noch damit.

[BrightAngel]

Zitat:

Zitat von DeddyH (Beitrag 1368047)

Delphi-Quellcode:

...
      if not (s[i] in NUMBERS) then
...

Das könnte man vermutlich noch effizienter machen, wenn man direkt die ASCII Randwerte

Delphi-Quellcode:

'0'

und

Delphi-Quellcode:

'9'

vergleicht.

Zur Erklärung grob vereinfacht: Jedes Zeichen entspricht einem numerischen Wert (also Strings sind eigentlich Zahlenketten; jede Zahl hat dann eine standardisierte Entsprechung). So weiß dann Windows oder dein Textzeichner deiner Wahl, welche Glyphe verwendet werden soll, die es zeichnen soll. So. Und jetzt ist das Schöne, dass die Zeichencodes von 0 bis 9 zufällig (?) nebeneinander liegen. Also 48 dezimal ist die '0', 49 ist die '1',..., 57 ist die '9'. Die verschiedenen Codierungen sollten bei den Ziffern zumindest noch keinen Unterschied machen. Du könntest also mit den Größer/Kleiner Operatoren schauen, ob

Delphi-Quellcode:

s[i]

im entsprechenden Zahlenabschnitt ist. Dadurch, dass du nur mit '0' und '9' vergleichen musst, wird die Prüfung ein wenig effizienter, als wenn du in einem

Delphi-Quellcode:

NUMBERS

Feld nachschaust (der

Delphi-Quellcode:

in

-Operator macht nach dem Übersetzen eine lineare Suche durch das Feld -> Aufwand ist multiplikativ mit der Länge des

Delphi-Quellcode:

NUMBERS

-Feldes verknüpft)

Wenn du natürlich auf beliebige bestimmte Zeichen testen musst, dann funktioniert dieser Trick unter Umständnen nicht mehr... :o
Hoffe, ich habe nicht mehr verwirrt, als geholfen. Im Zweifel diesen Post einfach ignorieren :P

Brighty

[p80286]

Zitat:

Zitat von DeddyH (Beitrag 1368047)

Wenn ich keinen Denkfehler gemacht habe, sollten nur noch Strings hinzugefügt werden, die komplett aus Ziffern bestehen.

nö sieht gut aus, aber der Fragesteller wird wahrscheinlich noch '/',':' und ggf. ' ' hinzufügen müssen, falls es sich um vollständige Pfadangaben handelt.
(wie sehen noch mal die UNC-Angaben aus?)
Gruß
K-H

[zobien123]

Wow vielen Danke für den ganzen Input:-D

Hab es jetzt so gemacht:

Zitat:

Das könnte man vermutlich noch effizienter machen, wenn man direkt die ASCII Randwerte '0' und '9' vergleicht.

Das klang für mich am einfachsten :stupid:

[Christian Seehase]

Moin Zusammen,

um die Verwirrung zu komplettieren:
Wenn es sich um reine Ordnernamen handelt, also ohne Pfadtrenner
könnte man auch TryStrToInt verwenden

[DeddyH]

Aber auch nur, solange die Zahl nicht zu groß ist.

[Blup]

Das ist doch mal eine Möglichkeit einen Enumerator zu verwenden:

Delphi-Quellcode:

type
  TNumericEnumerator = record
    constructor Create(AList: TStrings);
  private
    FIndex: Integer;
    FList: TStrings;
    function Accept(const AItem: string): Boolean; inline;
    function GetCurrent: string; inline;
  public
    function MoveNext: Boolean; inline;
    property Current: string read GetCurrent;
    function GetEnumerator: TNumericEnumerator;
  end;

{ TNumericEnumerator }

function TNumericEnumerator.Accept(const AItem: string): Boolean;
const
  NUMBERS = ['0'..'9'];
var
  i: Integer;
begin  
  for i := 1 to Length(AItem) do
  begin
    if not (AItem[i] in NUMBERS) then
    begin
      Result := False;
      Exit;
    end;
  end;
  Result := True;
end;

constructor TNumericEnumerator.Create(AList: TStrings);
begin
  FList := AList;
end;

function TNumericEnumerator.GetCurrent: string;
begin
  Result := FList[FIndex];
end;

function TNumericEnumerator.GetEnumerator: TNumericEnumerator;
begin
  Result := Self;
end;

function TNumericEnumerator.MoveNext: Boolean;
var
  i: Integer;
begin
  for i := FIndex + 1 to FList.Count - 1 do
  begin
    if Accept(FList[i]) then
    begin
      FIndex := i;
      Result := True;
      Exit; // ==>
    end;
  end;
  Result := False;
end;

{ Anwendung}

procedure TuWas(AList: TStrings);
var
  s: string;
begin
  for s in TNumericEnumerator.Create(AList) do
    TuWasMitNumeric(s);
end;

[hoika]

Hallo,
TryStrToInt wäre auch meine erste Wahl.

Ich nehme mal an, dass die Ziffern dann wohl noch ein Rolle spielen (Sortierung?),
dann spielt das Argument "Länge" (max. 4Mrd.) keine Rolle,
weil ja eh in Integer umgeformt werden muss.

[BrightAngel]

Zitat:

Zitat von hoika (Beitrag 1368130)

...weil ja eh in Integer umgeformt werden muss.

Muss es das? Aber ja, ist definitiv eine Möglichkeit, wenn man das vorhat :thumb:

[himitsu]

Zitat:

Zitat von BrightAngel (Beitrag 1368131)

Zitat:

Zitat von hoika (Beitrag 1368130)

...weil ja eh in Integer umgeformt werden muss.

Muss es das? Aber ja, ist definitiv eine Möglichkeit, wenn man das vorhat :thumb:

Wenn die Zahlen gleich viele Ziffern haben, bzw. links mit 0 aufgefüllt wurden,
dann könnte man sie auch direkt als Text/String vergleichen.

[Blup]

Es gibt auch "TryStrToInt64()", wenn es ein par Ziffern mehr sein dürfen.