TStringList erzeugt Zeilenumbruch am Ende?

[NoGAD]

Hallo,

meine TStringList erzeugt einen Zeilenumbruch am Ende, obwohl ich diesen ausgeschlossen habe.

Hier ist der Code:

Delphi-Quellcode:

unit Unit_Funktionen_Strings;

interface

uses
  SysUtils, Classes, Graphics, Windows, Registry, ShellApi, TypInfo, Messages;

function CreateLoremipsum(var Stringlist: TStringList; Anzahl: Integer;
  Absatz: Integer = 1; DoppeltAbsatz: Boolean = True): Boolean;


const
  { Lorem Ipsum }
  LorenIpsum_Pre = 'Lorem ipsum ';
  LoremIspum: array [0 .. 177] of string = ('lorem', 'ipsum', 'dolor', 'sit',
    'amet', 'consectetur', 'adipiscing', 'elit', 'curabitur', 'vel',
    'hendrerit', 'libero', 'eleifend', 'blandit', 'nunc', 'ornare', 'odio',
    'ut', 'orci', 'gravida', 'imperdiet', 'nullam', 'purus', 'lacinia', 'a',
    'pretium', 'quis', 'congue', 'praesent', 'sagittis', 'laoreet', 'auctor',
    'mauris', 'non', 'velit', 'eros', 'dictum', 'proin', 'accumsan', 'sapien',
    'nec', 'massa', 'volutpat', 'venenatis', 'sed', 'eu', 'molestie', 'lacus',
    'quisque', 'porttitor', 'ligula', 'dui', 'mollis', 'tempus', 'at', 'magna',
    'vestibulum', 'turpis', 'ac', 'diam', 'tincidunt', 'id', 'condimentum',
    'enim', 'sodales', 'in', 'hac', 'habitasse', 'platea', 'dictumst', 'aenean',
    'neque', 'fusce', 'augue', 'leo', 'eget', 'semper', 'mattis', 'tortor',
    'scelerisque', 'nulla', 'interdum', 'tellus', 'malesuada', 'rhoncus',
    'porta', 'sem', 'aliquet', 'et', 'nam', 'suspendisse', 'potenti', 'vivamus',
    'luctus', 'fringilla', 'erat', 'donec', 'justo', 'vehicula', 'ultricies',
    'varius', 'ante', 'primis', 'faucibus', 'ultrices', 'posuere', 'cubilia',
    'curae', 'etiam', 'cursus', 'aliquam', 'quam', 'dapibus', 'nisl', 'feugiat',
    'egestas', 'class', 'aptent', 'taciti', 'sociosqu', 'ad', 'litora',
    'torquent', 'per', 'conubia', 'nostra', 'inceptos', 'himenaeos',
    'phasellus', 'nibh', 'pulvinar', 'vitae', 'urna', 'iaculis', 'lobortis',
    'nisi', 'viverra', 'arcu', 'morbi', 'pellentesque', 'metus', 'commodo',
    'ut', 'facilisis', 'felis', 'tristique', 'ullamcorper', 'placerat',
    'aenean', 'convallis', 'sollicitudin', 'integer', 'rutrum', 'duis', 'est',
    'etiam', 'bibendum', 'donec', 'pharetra', 'vulputate', 'maecenas', 'mi',
    'fermentum', 'consequat', 'suscipit', 'aliquam', 'habitant', 'senectus',
    'netus', 'fames', 'quisque', 'euismod', 'curabitur', 'lectus', 'elementum',
    'tempor', 'risus', 'cras');

implementation

function CreateLoremipsum(var Stringlist: TStringList; Anzahl: Integer;
  Absatz: Integer = 1; DoppeltAbsatz: Boolean = True): Boolean;
var
  x, y, z: Integer;
  s, t: string;
begin

  Randomize;
  z := 0;
  y := 0;

  if Absatz > 1 then
  begin
    y := Anzahl div Absatz;
    z := 1;
  end;

  Result := True;
  try
    s := LorenIpsum_Pre;
    Anzahl := Anzahl - 2;
    for x := 1 to Anzahl do
    begin
      t := LoremIspum[Random(High(LoremIspum))];
      if (Length(s) > 0) and (s[Length(Trim(s))] = '.') then
        t[1] := UpCase(t[1]);
      if x mod (Random(9) + (Random(2) + 1)) = 0 then
        case x mod (Random(9) + (Random(3) + 1)) of
          0:
            t := t + ',';
          3, 5:
            t := t + '.';
        end;
      if x mod (Random(9) + (Random(3) + 1)) = 0 then
        t[1] := UpCase(t[1]);
      s := s + t;

      case ((y > 0) and (z > 0)) and ((x) = (y * z)) of
        True:
          begin
            if s[Length(s)] = ',' then
              s[Length(s)] := '.'
            else
              s := s + '.';
            inc(z, 1);
            s := Trim(s);
            s[1] := UpCase(s[1]);
            Stringlist.Add(s);
            if DoppeltAbsatz then
              Stringlist.Add(sLineBreak);
            s := '';
          end;
        False:
          s := s + #32;
      end;
    end;
    if Stringlist.Count > 0 then
      if (Stringlist.Strings[Stringlist.Count - 1] = sLineBreak )or (Stringlist.Strings[Stringlist.Count - 1] = '')then
        Stringlist.Delete(Stringlist.Count - 1);
  except
    Result := False;
  end;

end;

end.

Aufruf:

Delphi-Quellcode:

var
  DummySL: TStringList;
begin
  randomize;
  DummySL := TStringList.Create;
  CreateLoremipsum(DummySL, random(225) + 2, random(5) + 2);
  Label1.Caption := DummySL.Text;
  DummySL.Free;

Das Label hat:

Autosize := True
WordWrap := False;

Und trotz if Stringlist.Count > 0 then
if (Stringlist.Strings[Stringlist.Count - 1] = sLineBreak )or (Stringlist.Strings[Stringlist.Count - 1] = '')then
Stringlist.Delete(Stringlist.Count - 1);

wird im Label immer eine Leerzeile am Ende erzeugt. Wo liegt mein Denkfehler?

LG Mathias

[Delphi.Narium]

Der Denkfehler liegt nicht bei Dir.

Am Ende von TStringList.Text ist immer ein Zeilenumbruch.

Delphi-Quellcode:

var
  sl : TStringList;
begin
  sl := TStringList.Create;
  for i := 1 to 100 do sl.Add(IntToStr(i));
  ShowMessage(sl.Text);
  sl.Free;
end;

Auch hier hat das Ende von Text im ShowMessage einen Zeilenumbruch, obwohl in der Schleife nicht ein einziger Zeilenumbruch programatisch eingefügt wird.

Vermeiden kannst Du das nur mit

Delphi-Quellcode:

Label1.Caption := Trim(DummySL.Text);

Unschön, aber eine andere Lösung wüsst ich nicht.

[NoGAD]

Vielen Dank :-)

LG Mathias

[Stevie]

TrailingLineBreak ;)

[NoGAD]

Hach, warum es doch immer nur so einfach ist und man nicht drauf kommt..


Dankeschön!


LG Mathias

[Redeemer]

Zitat:

Zitat von Delphi.Narium (Beitrag 1500888)

Am Ende von TStringList.Text ist immer ein Zeilenumbruch.

Das stimmt so nicht. Wenn Count = 0, dann ist kein Zeilenumbruch am Ende. (Und bei der Eigenschaft, die Stevie gepostet hat, und die es wohl seit Berlin gibt.)

[NoGAD]

Danke für den Hinweis. Wenn eine StringList einen Count von 0 hat, ist es ja auch eigentlich ohne Belang.

Das Thema kann bitte als gelöst markiert werden :-)

LG Mathias

[NoGAD]

Hallo, ich knüpfe hier einfach an, weil es sich um die gleiche Thematik handelt.

Meinen LoremIpsum Generator habe ich etwas verbessert.

Hier das Ergebnis.

Vielleicht möchte der Ein oder Andere sich um Fehlerkorrektur bemühen?

Delphi-Quellcode:

unit Unit_LoremIpsum;

interface

uses
  SysUtils, Classes;

type
  TLoremIpsumVariant = (Standard, Bavaria);

function CreateLoremIpsum(aWorte: Integer): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aUsePre: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aUsePre: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant): String; overload;
function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant; aPunktierung: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant; aPunktierung: Boolean; aKommata: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aPunktierung: Boolean; aKommata: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aPunktierung: Boolean; aKommata: Boolean): String; overload;
function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aUsePre: Boolean; aVariante: TLoremIpsumVariant; aPunktierung: Boolean; aKommata: Boolean): String; overload;

implementation

var
  Absatz: Integer;
  UsePre: Boolean;
  Variante: TLoremIpsumVariant;
  Punktierung: Boolean;
  Kommata: Boolean;

const
  LoremIpsum_Pre = 'Lorem ipsum ';
  LoremIpsum: Array [1 .. 117] of string = ('dolor', 'sit', 'amet', 'consetetur', 'sadipscing', 'elitr', 'sed', 'diam', 'nonumy', 'eirmod', 'tempor', 'invidunt', 'ut', 'labore', 'et', 'dolore', 'magna', 'aliquyam', 'erat',
    'voluptua', 'at', 'vero', 'eos', 'accusam', 'justo', 'duo', 'dolores', 'ea', 'rebum', 'stet', 'clita', 'kasd', 'gubergren', 'no', 'sea', 'takimata', 'sanctus', 'est', 'lorem', 'ipsum', 'duis', 'autem', 'vel', 'eum',
    'iriure', 'in', 'hendrerit', 'vulputate', 'velit', 'esse', 'molestie', 'consequat', 'illum', 'eu', 'feugiat', 'nulla', 'facilisis', 'eros', 'accumsan', 'iusto', 'odio', 'dignissim', 'qui', 'blandit', 'praesent',
    'luptatum', 'zzril', 'delenit', 'augue', 'te', 'feugait', 'facilisi', 'consectetuer', 'adipiscing', 'elit', 'nonummy', 'nibh', 'euismod', 'tincidunt', 'laoreet', 'aliquam', 'volutpat', 'wisi', 'enim', 'ad', 'minim',
    'veniam', 'quis', 'nostrud', 'exerci', 'tation', 'ullamcorper', 'suscipit', 'lobortis', 'nisl', 'aliquip', 'ex', 'commodo', 'nam', 'liber', 'cum', 'soluta', 'nobis', 'eleifend', 'option', 'congue', 'nihil', 'imperdiet',
    'doming', 'id', 'quod', 'mazim', 'placerat', 'facer', 'possim', 'assum', 'amet');

  LoremIpsum_Bavaria_Pre = 'Bavaria ipsum ';
  LoremIpsum_Bavaria: Array [1 .. 389] of string = ('ghupft', 'wia', 'gsprunga', 'pfiad', 'de', 'guad', 'freibia', 'eam', 'oa', 'meidromml', 'a', 'bissal', 'aba', 'fei', 'moand', 'deandlgwand', 'da', 'buachbinda',
    'wanninger', 'schneid', 'milli', 'maßkruag', 'wos', 'des', 'muas', 'ma', 'hoid', 'kenna', 'nix', 'gwiass', 'woass', 'ned', 'af', 'etza', 'kimmt', 'vergeltsgott', 'wann', 'griagd', 'nacha', 'z', 'dringa', 'leonhardifahrt',
    'ham', 'radi', 'resch', 'xaver', 'haferl', 'greichats', 'is', 'liab', 'griasd', 'eich', 'midnand', 'weißwiaschd', 'mim', 'radl', 'foahn', 'hendl', 'schdeckalfisch', 'gscheit', 'unbandig', 'maibam', 'mechad', 'gschicht',
    'sauba', 'scheans', 'marterl', 'woar', 'hod', 'dringma', 'aweng', 'maß', 'und', 'no', 'landla', 'gaudi', 'foidweg', 'hi', 'schdarmbeaga', 'see', 'mongdratzal', 'ewig', 'drei', 'dog', 'geh', 'mi', 'maderln', 'fingahaggln',
    'anbandeln', 'schmankal', 'radler', 'weibaleid', 'namidog', 'marei', 'i', 'bin', 'woschechta', 'bayer', 'ebba', 'klampfn', 'enzian', 'basd', 'scho', 'obazda', 'bitt', 'prosd', 'spernzaln', 'auffi', 'gidarn', 'auf',
    'gehds', 'beim', 'schichtl', 'allerweil', 'habedehre', 'ded', 'sog', 'schorsch', 'watschnpladdla', 'iabaroi', 'aasgem', 'pfenningguat', 'biakriagal', 'kummd', 'barfuaßat', 'umma', 'baamwach', 'ramasuri', 'wuascht',
    'liberalitas', 'bavariae', 'buam', 'jedza', 'ohrwaschl', 'om', 'n', 'gipfe', 'kirwa', 'sei', 'gehd', 'ollaweil', 'oans', 'zwoa', 'gsuffa', 'd', 'trihöleridi', 'dijidiholleri', 'schoo', 'gscheckate', 'edlweiss', 'nomoi',
    'zidern', 'woibbadinga', 'obacht', 'measi', 'liabs', 'deandl', 'goaßmaß', 'in', 'greana', 'au', 'diandldrahn', 'bradwurschtsemmal', 'daad', 'g', 'hupft', 'midanand', 'schüds', 'nei', 'noch', 'giasinga', 'heiwog',
    'breihaus', 'schuabladdla', 'fünferl', 'griasnoggalsubbm', 'do', 'bittschön', 'imma', 'mogsd', 'bussal', 'aso', 'nimma', 'hob', 'an', 'suri', 'wea', 'nia', 'ausgähd', 'kummt', 'hoam', 'ganze', 'hoiwe', 'haberertanz',
    'wiad', 'mordsgaudi', 'oba', 'schbozal', 'eana', 'hea', 'schee', 'fensdaln', 'hoggd', 'griaß', 'god', 'beinand', 'fias', 'sodala', 'hemad', 'glacht', 'helfgod', 'resi', 'fescha', 'bua', 'gstanzl', 'hog', 'di', 'singd',
    'kini', 'naa', 'kumm', 'sepp', 'abfieseln', 'schellnsau', 'charivari', 'zünftig', 'broadwurschtbudn', 'dahoam', 'samma', 'gamsbart', 'need', 'hallelujah', 'luja', 'koa', 'wuid', 'amoi', 'biagadn', 'von', 'gfreit', 'am',
    'acht', 'tag', 'schuf', 'gott', 'bia', 'hinter', 'm', 'berg', 'san', 'leit', 'hogg', 'uns', 'zamm', 'obandeln', 'hetschapfah', 'kloan', 'musi', 'so', 'schmarn', 'reiwadatschi', 'kuaschwanz', 'back', 'mas', 'gwihss',
    'wolln', 'ognudelt', 'moan', 'oiwei', 'jo', 'mei', 'gams', 'wo', 'großherzig', 'soi', 'biazelt', 'ledahosn', 'wolpern', 'semmlkneedl', 'servas', 'der', 'oim', 'gibt', 's', 'sünd', 'oachkatzlschwoaf', 'singan', 'legst',
    'nieda', 'es', 'zua', 'hab', 'heimatland', 'pfundig', 'biawambn', 'jodler', 'gwiss', 'schaugn', 'nimmds', 'vui', 'spezi', 'graudwiggal', 'kaiwe', 'spotzerl', 'zwedschgndadschi', 'ja', 'red', 'bloß', 'gmahde', 'wiesn',
    'sowos', 'weida', 'gelbe', 'rüam', 'schaung', 'kost', 'lem', 'lossn', 'umananda', 'denn', 'wiavui', 'gor', 'gar', 'narrisch', 'gean', 'wurscht', 'huift', 'auszutzeln', 'mehra', 'dee', 'schwoanshaxn', 'vasteh', 'waar',
    'soweid', 'sauakraud', 'trachtnhuat', 'baddscher', 'middn', 'guglhupf', 'steckerleis', 'schnacksln', 'weiznglasl', 'du', 'dadst', 'daugn', 'sammawiedaguad', 'heid', 'watschnbaam', 'mog', 'blärrd', 'kneedl', 'engelgwand',
    'sonn', 'spuiratz', 'owe', 'leck', 'oamoi', 'brezn', 'vo', 'heitzdog', 'greaßt', 'nachad', 'ozapfa', 'gfoids', 'sagrisch', 'almrausch', 'sauwedda', 'glei', 'brodzeid', 'gschmeidig', 'bladl', 'bravs', 'lewakaas', 'wui',
    'boarischer', 'hawadere', 'midananda', 'im', 'beidl', 'dei', 'mamalad', 'prosit', 'gmiadlichkeit', 'stubn', 'wirds', 'fui', 'lustiga', 'brotzeit', 'biaschlegl', 'oans');

function CreateLoremIpsum(aWorte: Integer): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, UsePre, Variante, Punktierung, Kommata);
end;

function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer): String;
begin
  Result := CreateLoremIpsum(aWorte, aAbsatz, UsePre, Variante, Punktierung, Kommata);
end;

function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aUsePre: Boolean): String;
begin
  Result := CreateLoremIpsum(aWorte, aAbsatz, aUsePre, Variante, Punktierung, Kommata);
end;

function CreateLoremIpsum(aWorte: Integer; aUsePre: Boolean): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, aUsePre, Variante, Punktierung, Kommata);
end;

function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant; aPunktierung: Boolean): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, UsePre, aVariante, aPunktierung, Kommata);
end;

function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant; aPunktierung: Boolean; aKommata: Boolean): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, UsePre, aVariante, aPunktierung, aKommata);
end;

function CreateLoremIpsum(aWorte: Integer; aVariante: TLoremIpsumVariant): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, UsePre, aVariante, Punktierung, Kommata);
end;

function CreateLoremIpsum(aWorte: Integer; aPunktierung: Boolean; aKommata: Boolean): String;
begin
  Result := CreateLoremIpsum(aWorte, Absatz, UsePre, Variante, aPunktierung, aKommata);
end;

function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aPunktierung: Boolean; aKommata: Boolean): String;
begin
  Result := CreateLoremIpsum(aWorte, aAbsatz, UsePre, Variante, aPunktierung, aKommata);
end;

function CreateLoremIpsum(aWorte: Integer; aAbsatz: Integer; aUsePre: Boolean; aVariante: TLoremIpsumVariant; aPunktierung: Boolean; aKommata: Boolean): String;
var
  Dummy_String: String;
  Dummy_Int: Integer;
  Dummy_Wort: String;
  Dummy_Absatz: Integer;

  Dummy_Komma: Boolean;
  Dummy_Punkt: Boolean;
begin
  Result := default (String);
  Dummy_String := default (String);
  Dummy_Absatz := default (Integer);
  Dummy_Punkt := default (Boolean);

  if aWorte < 1 then
  begin
    Exit;
  end; // if aWorte < 1 then

  Randomize;

  if aUsePre then
  begin
    case aVariante of
      Standard:
        begin
          Result := LoremIpsum_Pre;
        end; // Standard
      Bavaria:
        begin
          Result := LoremIpsum_Bavaria_Pre;
        end; // Bavaria
    end; // case aVariante of
  end; // if aUsePre then

  if aWorte = 1 then
  begin
    case aVariante of
      Standard:
        begin
          Dummy_String := LoremIpsum[Random(High(LoremIpsum))];
          if aAbsatz > 0 then
            if aUsePre then
              Dummy_String := sLineBreak + LoremIpsum[Random(High(LoremIpsum))];
        end; // Standard
      Bavaria:
        begin
          Dummy_String := LoremIpsum_Bavaria[Random(High(LoremIpsum_Bavaria))];
          if aAbsatz > 0 then
            if aUsePre then
              Dummy_String := sLineBreak + LoremIpsum_Bavaria[Random(High(LoremIpsum_Bavaria))];
        end; // Bavaria
    end; // case aVariante of
    if aPunktierung then
      Dummy_String := Dummy_String + '.';
  end; // if aWorte = 1 then

  if aWorte > 1 then
  begin
    if aAbsatz > 0 then
    begin
      Dummy_Absatz := aWorte div aAbsatz;
      if aAbsatz > aWorte then
      begin
        Dummy_Absatz := aWorte div 3;
      end; // if aAbsatz > aWorte then
    end; // if aAbsatz > 0 then

    for Dummy_Int := 1 to aWorte do
    begin
      case aVariante of
        Standard:
          begin
            Dummy_Wort := LoremIpsum[Random(High(LoremIpsum))];
          end; // Standard
        Bavaria:
          begin
            Dummy_Wort := LoremIpsum_Bavaria[Random(High(LoremIpsum_Bavaria))];
          end; // Bavaria
      end;

      if Dummy_Punkt or (Random(Dummy_Int) mod 4 = 2) then
      begin
        Dummy_Wort[1] := UpCase(Dummy_Wort[1]);
      end; // 1. Buchstabe GROß if Random(Dummy_Int) mod 4 = 2 then

      Dummy_Komma := default (Boolean);
      if aKommata then
      begin
        if Random(Dummy_Int) mod 7 = Random(2) then
        begin
          Dummy_Wort := Dummy_Wort + ',';
          Dummy_Komma := True;
        end; // if Random(Dummy_Int) mod 7 = Random(2) then
      end; // if aKommata then

      Dummy_Punkt := default (Boolean);
      if aPunktierung and (not Dummy_Komma) then
      begin
        if Random(Dummy_Int) mod 17 = Random(2) then
        begin
          Dummy_Wort := Dummy_Wort + '.';
          Dummy_Punkt := True;
        end; // if Random(Dummy_Int) mod 17 = Random(2) then
      end;

      Dummy_String := Dummy_String + Dummy_Wort + #32;

      if Dummy_Absatz > 0 then
      begin
        if Dummy_Int mod Dummy_Absatz = 0 then
        begin
          Dummy_String := Dummy_String + sLineBreak;
        end; // if Dummy_Int mod Dummy_Absatz = 0 then
      end; // if Dummy_Absatz > 0 then

    end; // for Dummy_Int := 1 to aWorte do
  end; // if aWorte > 1 then

  Result := Result + Dummy_String;
end;

end.

Aufruf:

Delphi-Quellcode:

  uses Unit_LoremIpsum;
{..}
  ShowMessage(CreateLoremIpsum(125));
  ShowMessage(CreateLoremIpsum(125, Bavaria));
  ShowMessage(CreateLoremIpsum(125, Bavaria, True, True));
  ShowMessage(CreateLoremIpsum(125, 4, True));
{..}

TODO:

1. Punktierung am Ende korrigieren
2. Bessere Absätze bilden
3. Andere Varianten

LG :-)

[himitsu]

Zum ursprünglichem Code aus #1:

Zitat:

Delphi-Quellcode:

function CreateLoremipsum(var Stringlist: TStringList; Anzahl: Integer; ...

Das VAR bei Objekten ist etwas ungünstig.
* erstmal willst du garnicht den Objektzeiger ändern
* und außerdem kann man so keine Property übergeben

Zusätzlich ist es besser hier den Vorfahren zu nutzen,
also TStrings, anstatt TStringList, denn du nutzt in deiner Funktion garnichts, wofür TStringList nötig ist, weil alles Verwendete bereits in TStrings deklaiert ist.

Delphi-Quellcode:

function CreateLoremipsum(var Stringlist: TStrings; Anzahl: Integer; ...


CreateLoremipsum(Memo1.Lines, 123456, ...);

Zitat:

Delphi-Quellcode:

  Result := True;
  try

  except
    Result := False;
  end;

Für soeine Fehlerbehandlung sollte man mindestens gesteinigt werden ein Paar auf den Popo bekommen.

Wenn dieser Code wirklich so schlecht ist, dass er einen Fehler auslösen kann, dann sollte man besser es knallen lassen, anstatt den Fehler zu verstecken. (weg mit dem Try-Except und weg mit dem unnützen Result ... entweder es ist True oder es knallt und ein halber Boolean ist nutzlos)


Randomize sollte man eigentlich niemals "ständig" aufrufen.
Die VCL ruft es beim Start bereits auf (in Konsolenanwendungen macht man es selber einmal zu Beginn).

Sei Froh, dass diese Funktion enorm beschleunigt wurde.
Früher war so ein Verhalten dafür Verantwortlich, dass "schnell" nacheinander mehrmals die selbe Zufallszahl(en) endstand(en).

Delphi-Quellcode:

Randomize;
a1 := Random;
b1 := Random;
c1 := Random;
Randomize;
a2 := Random;
b2 := Random;
c2 := Random;

Hier konnten (waren fast immer) die Werte *1 identlisch mit den *2,

wenn es schnell genug war, dass beide Random den selben Zeitstempel zur Initialisierung nutzten, so als würde man

Delphi-Quellcode:

RandSeed := 666; //Randomize;
a1 := Random;
b1 := Random;
c1 := Random;
RandSeed := 666; //Randomize;
a2 := Random;
b2 := Random;
c2 := Random;

machen.

Zitat:

Delphi-Quellcode:

if DoppeltAbsatz then
  Stringlist.Add(sLineBreak);

Klar, man könnte in eine Zeile einen Zeilenumbruch reinmachen,
aber etwas besser sollte es sein, wenn du dafür Leerzeilen einfügst.
(denn logisch entspticht ein .Line eine Zeile)

Delphi-Quellcode:

if DoppeltAbsatz then
begin
  Stringlist.Add('');
  Stringlist.Add('');
end;

Und anstatt am Ende die unnötigen Leerzeilen wieder zu entfernen,
wie wäre es, wenn man sie garnicht erst einfügt?

Delphi-Quellcode:

if DoppeltAbsatz and not (x = Anzahl) then
begin

Unnütze Units sind auch nicht das Wahre.
Graphics, Registry, ShellApi, TypInfo und Messages
hat nichts mit diesem Code zu tun (nichts davon wird verwendet)
Und wenn man auch noch Windows weg lässt, dann wäre dieser Code per se sogar für Linux/Mac/Android nutzbar.




[edit] ursprünglicher Post hier gelöscht, da er im falschen Thread war :oops:
https://www.delphipraxis.net/210865-...ml#post1507750

[NoGAD]

Hallo himitsu.

Danke für deine tollen Erläuterungen. Das hilft mir sehr beim Verstehen und lernen. Die unit aus #1 habe ich zwar mit Post #8 ersetzt, dennoch war es sehr aufschlussreich, um ähnliche Fehler in der Zukunft zu vermeiden.

Mit der Idee aus dem anderen Thread werde ich mit die unit noch einmal anschauen.

Vielen lieben Dank!

LG 😊👋🏻

[Blup]

Random(n) liefert einen Wert von 0 bis n-1, deine Array beginnen aber bei 1.

Vorschläge als Anregung:

Am Ende eines Absatzes sollte vor dem Zeilenumbruch kein Leerzeichen stehn.
Nach Ende des gesamten Textes sollte kein Leerzeichen oder Zeilenumbruch folgen.
Wenn Punktierung aktiv ist, sollte der Text in jedem Fall mit einem Punkt enden
und das erste Wort des gesamten Textes sollte auch mit einem Grossbuchstaben beginnen.
Innerhalb eines Teilsatzes(Komma) sollten nicht zwei gleiche Worte aufeinander folgen.

Wie die Bedingung für ein Satzende bzw. Komma wirken soll, ist mir nicht ganz verständlich.
Vieleicht sollte doch eher die Länge des Satzes bzw. des Teilsatzes in die Entscheidung einfließen.

Wenn ein Text mit nur nur einem Wort erzeugt werden soll und (Absatz > 0), wird vor dem Wort immer ein Zeilenumbruch eingefügt.
Egal ob ein Pre-Wort davor steht. Bei einem Text aus mehreren Worten steht dort niemals ein Zeilenumbruch.
Vieleicht besser: Wenn (Absatz > 0) sollte nach dem Pre-Wort immer ein Zeilenumbruch folgen, ohne Pre-Wort vor dem erste Wort in beiden Fällen nicht.
Damit könnte die Sonderbehandlung von einem Text mit nur einem Wort ganz entfallen.

Derzeit werden die statischen Variablen für die Formatierung einmal per Parameter gesetzt und dann einfach weiter zu verwendet, wenn der Parameter nicht angegeben wurde.
Die Varianten Standard und Bavaria an mehreren Stellen über case zu unterscheiden ist nicht gut gelöst.
Wenn mal eine weitere Variante hinzukommt, muss der vorhandene Quelltext erweitert werden und wird noch unübersichtlicher.
Das spricht für eine Klassenstruktur.
Man muss sich nur entscheiden ob direkt mit den Klassen gearbeitet wird oder Instanzen erzeugt werden müssen (jede mit eigenen Einstellungen für die Formatierung).

Delphi-Quellcode:

unit Unit_LoremIpsum;

interface

uses
  SysUtils, Classes, Types;

type
  TLoremIpsumCustom = class(TObject)
  protected
    class function GetPreText: string; virtual; abstract;
    class function GetRandomWord: string; virtual; abstract;
  public
    class var Absatz: Integer;
    class var UsePre: Boolean;
    class var Punktierung: Boolean;
    class var Kommata: Boolean;
    class function Generate(ACount: Integer): string;
  end;

  TLoremIpsum = class(TLoremIpsumCustom)
  protected
    class function GetPreText: string; override;
    class function GetRandomWord: string; override;
  end;

  TLoremIpsumBavaria = class(TLoremIpsumCustom)
  protected
    class function GetPreText: string; override;
    class function GetRandomWord: string; override;
  end;

implementation

const
  LoremIpsum_Pre = 'Lorem ipsum';
  LoremIpsum: Array [0 .. 116] of string = ('dolor', 'sit', 'amet', 'consetetur', 'sadipscing', 'elitr', 'sed', 'diam', 'nonumy', 'eirmod', 'tempor', 'invidunt', 'ut', 'labore', 'et', 'dolore', 'magna', 'aliquyam', 'erat',
    'voluptua', 'at', 'vero', 'eos', 'accusam', 'justo', 'duo', 'dolores', 'ea', 'rebum', 'stet', 'clita', 'kasd', 'gubergren', 'no', 'sea', 'takimata', 'sanctus', 'est', 'lorem', 'ipsum', 'duis', 'autem', 'vel', 'eum',
    'iriure', 'in', 'hendrerit', 'vulputate', 'velit', 'esse', 'molestie', 'consequat', 'illum', 'eu', 'feugiat', 'nulla', 'facilisis', 'eros', 'accumsan', 'iusto', 'odio', 'dignissim', 'qui', 'blandit', 'praesent',
    'luptatum', 'zzril', 'delenit', 'augue', 'te', 'feugait', 'facilisi', 'consectetuer', 'adipiscing', 'elit', 'nonummy', 'nibh', 'euismod', 'tincidunt', 'laoreet', 'aliquam', 'volutpat', 'wisi', 'enim', 'ad', 'minim',
    'veniam', 'quis', 'nostrud', 'exerci', 'tation', 'ullamcorper', 'suscipit', 'lobortis', 'nisl', 'aliquip', 'ex', 'commodo', 'nam', 'liber', 'cum', 'soluta', 'nobis', 'eleifend', 'option', 'congue', 'nihil', 'imperdiet',
    'doming', 'id', 'quod', 'mazim', 'placerat', 'facer', 'possim', 'assum', 'amet');

  LoremIpsum_Bavaria_Pre = 'Bavaria ipsum';
  LoremIpsum_Bavaria: Array [0 .. 388] of string = ('ghupft', 'wia', 'gsprunga', 'pfiad', 'de', 'guad', 'freibia', 'eam', 'oa', 'meidromml', 'a', 'bissal', 'aba', 'fei', 'moand', 'deandlgwand', 'da', 'buachbinda',
    'wanninger', 'schneid', 'milli', 'maßkruag', 'wos', 'des', 'muas', 'ma', 'hoid', 'kenna', 'nix', 'gwiass', 'woass', 'ned', 'af', 'etza', 'kimmt', 'vergeltsgott', 'wann', 'griagd', 'nacha', 'z', 'dringa', 'leonhardifahrt',
    'ham', 'radi', 'resch', 'xaver', 'haferl', 'greichats', 'is', 'liab', 'griasd', 'eich', 'midnand', 'weißwiaschd', 'mim', 'radl', 'foahn', 'hendl', 'schdeckalfisch', 'gscheit', 'unbandig', 'maibam', 'mechad', 'gschicht',
    'sauba', 'scheans', 'marterl', 'woar', 'hod', 'dringma', 'aweng', 'maß', 'und', 'no', 'landla', 'gaudi', 'foidweg', 'hi', 'schdarmbeaga', 'see', 'mongdratzal', 'ewig', 'drei', 'dog', 'geh', 'mi', 'maderln', 'fingahaggln',
    'anbandeln', 'schmankal', 'radler', 'weibaleid', 'namidog', 'marei', 'i', 'bin', 'woschechta', 'bayer', 'ebba', 'klampfn', 'enzian', 'basd', 'scho', 'obazda', 'bitt', 'prosd', 'spernzaln', 'auffi', 'gidarn', 'auf',
    'gehds', 'beim', 'schichtl', 'allerweil', 'habedehre', 'ded', 'sog', 'schorsch', 'watschnpladdla', 'iabaroi', 'aasgem', 'pfenningguat', 'biakriagal', 'kummd', 'barfuaßat', 'umma', 'baamwach', 'ramasuri', 'wuascht',
    'liberalitas', 'bavariae', 'buam', 'jedza', 'ohrwaschl', 'om', 'n', 'gipfe', 'kirwa', 'sei', 'gehd', 'ollaweil', 'oans', 'zwoa', 'gsuffa', 'd', 'trihöleridi', 'dijidiholleri', 'schoo', 'gscheckate', 'edlweiss', 'nomoi',
    'zidern', 'woibbadinga', 'obacht', 'measi', 'liabs', 'deandl', 'goaßmaß', 'in', 'greana', 'au', 'diandldrahn', 'bradwurschtsemmal', 'daad', 'g', 'hupft', 'midanand', 'schüds', 'nei', 'noch', 'giasinga', 'heiwog',
    'breihaus', 'schuabladdla', 'fünferl', 'griasnoggalsubbm', 'do', 'bittschön', 'imma', 'mogsd', 'bussal', 'aso', 'nimma', 'hob', 'an', 'suri', 'wea', 'nia', 'ausgähd', 'kummt', 'hoam', 'ganze', 'hoiwe', 'haberertanz',
    'wiad', 'mordsgaudi', 'oba', 'schbozal', 'eana', 'hea', 'schee', 'fensdaln', 'hoggd', 'griaß', 'god', 'beinand', 'fias', 'sodala', 'hemad', 'glacht', 'helfgod', 'resi', 'fescha', 'bua', 'gstanzl', 'hog', 'di', 'singd',
    'kini', 'naa', 'kumm', 'sepp', 'abfieseln', 'schellnsau', 'charivari', 'zünftig', 'broadwurschtbudn', 'dahoam', 'samma', 'gamsbart', 'need', 'hallelujah', 'luja', 'koa', 'wuid', 'amoi', 'biagadn', 'von', 'gfreit', 'am',
    'acht', 'tag', 'schuf', 'gott', 'bia', 'hinter', 'm', 'berg', 'san', 'leit', 'hogg', 'uns', 'zamm', 'obandeln', 'hetschapfah', 'kloan', 'musi', 'so', 'schmarn', 'reiwadatschi', 'kuaschwanz', 'back', 'mas', 'gwihss',
    'wolln', 'ognudelt', 'moan', 'oiwei', 'jo', 'mei', 'gams', 'wo', 'großherzig', 'soi', 'biazelt', 'ledahosn', 'wolpern', 'semmlkneedl', 'servas', 'der', 'oim', 'gibt', 's', 'sünd', 'oachkatzlschwoaf', 'singan', 'legst',
    'nieda', 'es', 'zua', 'hab', 'heimatland', 'pfundig', 'biawambn', 'jodler', 'gwiss', 'schaugn', 'nimmds', 'vui', 'spezi', 'graudwiggal', 'kaiwe', 'spotzerl', 'zwedschgndadschi', 'ja', 'red', 'bloß', 'gmahde', 'wiesn',
    'sowos', 'weida', 'gelbe', 'rüam', 'schaung', 'kost', 'lem', 'lossn', 'umananda', 'denn', 'wiavui', 'gor', 'gar', 'narrisch', 'gean', 'wurscht', 'huift', 'auszutzeln', 'mehra', 'dee', 'schwoanshaxn', 'vasteh', 'waar',
    'soweid', 'sauakraud', 'trachtnhuat', 'baddscher', 'middn', 'guglhupf', 'steckerleis', 'schnacksln', 'weiznglasl', 'du', 'dadst', 'daugn', 'sammawiedaguad', 'heid', 'watschnbaam', 'mog', 'blärrd', 'kneedl', 'engelgwand',
    'sonn', 'spuiratz', 'owe', 'leck', 'oamoi', 'brezn', 'vo', 'heitzdog', 'greaßt', 'nachad', 'ozapfa', 'gfoids', 'sagrisch', 'almrausch', 'sauwedda', 'glei', 'brodzeid', 'gschmeidig', 'bladl', 'bravs', 'lewakaas', 'wui',
    'boarischer', 'hawadere', 'midananda', 'im', 'beidl', 'dei', 'mamalad', 'prosit', 'gmiadlichkeit', 'stubn', 'wirds', 'fui', 'lustiga', 'brotzeit', 'biaschlegl', 'oans');

class function TLoremIpsumCustom.Generate(ACount: Integer): string;

  function UpCaseFirst(const AValue: string; AUpCase: Boolean): string;
  begin
    Result := AValue;
    if AUpCase and (Length(Result) > 0) then
      Result[1] := UpCase(Result[1]);
  end;

var
  i, n: Integer;
  SatzBegin: Boolean;
  SatzKomma: Boolean;
begin
  Result := '';

  if ACount < 1 then
    Exit;

  if UsePre then
  begin
    Result := GetPreText;

    if Absatz > 0 then
      Result := Result + sLineBreak
    else
      Result := Result + SPACE;
  end;

  {erstes Word beginnt mit Grossbuchstabe}
  Satzbegin := Punktierung;

  for i := 1 to ACount do
  begin
    {kein zusätzliches Trennzeichen am Textanfang}
    if i > 1 then
    begin
      var Trennzeichen: string := SPACE;
      if (Absatz > 0) and (i > 1) then
      begin
        if Absatz > ACount then
          n := 3
        else
          n := Absatz;

        n := ACount div n;

        if (i mod n) = 0 then
          Trennzeichen := sLineBreak;
      end;
      Result := Result + Trennzeichen;
    end;

    Result := Result + UpCaseFirst(GetRandomWord, Satzbegin);

    SatzKomma := False;
    {nicht am Textende}
    if Kommata and (i < ACount) then
    begin
      if Random(i) mod 7 = Random(2) then
      begin
        Result := Result + ',';
        SatzKomma := True;
      end;
    end;

    Satzbegin := False;
    if Punktierung and (not SatzKomma) then
    begin
      {Auf jeden Fall am Textende}
      if (i = ACount) or (Random(i) mod 17 = Random(2)) then
      begin
        Result := Result + '.';
        Satzbegin := True;
      end;
    end;
  end;
end;

class function TLoremIpsum.GetPreText: string;
begin
  Result := LoremIpsum_Pre;
end;

class function TLoremIpsum.GetRandomWord: string;
begin
  Result := LoremIpsum[Random(High(LoremIpsum))];
end;

class function TLoremIpsumBavaria.GetPreText: string;
begin
  Result := LoremIpsum_Bavaria_Pre;
end;

class function TLoremIpsumBavaria.GetRandomWord: string;
begin
  Result := LoremIpsum_Bavaria[Random(High(LoremIpsum_Bavaria))];
end;

end.

Delphi-Quellcode:

program LoremIpsum;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  Unit_LoremIpsum in 'Unit_LoremIpsum.pas';

begin
  try
    Randomize;

    TLoremIpsum.Absatz := 3;
    TLoremIpsum.Kommata := True;
    TLoremIpsum.UsePre := True;
    TLoremIpsum.Punktierung := True;

    writeln(TLoremIpsum.Generate(50));
    writeln;
    writeln(TLoremIpsumBavaria.Generate(50));
    readln;

  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

[NoGAD]

Hallo Blup,

vielen Dank für das Umschreiben in eine Klasse. Es ist somit tatsächlich übersichtlicher.

Ich muss das erst einmal verarbeiten :-)

LG und ein schönes Wochenende.

[NoGAD]

Neue Unit, eine erweiterte von Blup:


Neu:

1. Deutsch ist dabei
2. Bei einem Absatz ist bei Punktierung immer ein Punkt
3. Mit Absatz kein Komma mehr am Absatzende
4. Konjuktionen wurden hinzugefügt (Bindewörter) - dadurch wird z.B. ein deutscher Text 'ansehnlicher'
5. Kleinen Fehler behoben: { Keinen Absatz am Ende }

Für Anregungen und Kritik, auch gerne wieder Fehlerkorrekturen, bin ich sehr dankbar.


Die Unit ist jetzt als Anhang (zip), weil sie durch die dt. Wortliste zu lang geworden ist.


LG :-)

[freimatz]

Zitat:

Zitat von NoGAD (Beitrag 1507741)

TODO:
1. Punktierung am Ende korrigieren
2. Bessere Absätze bilden
3. Andere Varianten

4. Unit Tests :-D
5. Debuggen lernen. :-P

[NoGAD]

Zitat:

Zitat von freimatz (Beitrag 1507898)

4. Unit Tests :-D
5. Debuggen lernen. :-P

Hallo, leider wieß ich nicht, was Du meinst.

Bei mir funktioniert es, wie gewünscht.

LG