[Delphi] Bardziej fachowy/krótszy sposób zapisu podanego k

Witam wszystkich

Czy da się to zapisać w inny bardziej przyjrzysty/krótszy sposób ??

W każdej opcji jedyna różnica jaka występuje to warunek "if".

case SearchType of
    opcja1:
      for i := 0 to Count - 1 do
      if Text[i] = FindText then begin
        SetLength(Result, Length(Result) + 1);
        Result[Length(Result) - 1] := Text[i];
      end;
    opcja2:
      for i := 0 to Count - 1 do
      if LowerCase(Text[i]) = LowerCase(FindText) then begin
        SetLength(Result, Length(Result) + 1);
        Result[Length(Result) - 1] := Text[i];
      end;
    opcja3:
      for i := 0 to Count - 1 do
      if LowerCase(Text[i]) <> LowerCase(FindText) then begin
        SetLength(Result, Length(Result) + 1);
        Result[Length(Result) - 1] := Text[i];
      end;
  end;

Pzdr

Niby mozna ale nie wiem czy to ma sens

var
	Bool: Boolean;
begin
	case SearchType of
		opcja1: Bool := Text[i] = FindText;
		opcja2: Bool := LowerCase(Text) = LowerCase(FindText);
		opcja3: Bool := LowerCase(Text) <> LowerCase(FindText);
	end;

	for i := 0 to Count - 1 do
		if Bool then begin
			SetLength(Result, Length(Result) + 1);
			Result[Length(Result) - 1] := Text[i];
		end;
end;

Powinno dzialac

Raczej nie, ponieważ Tekst[i] za każdym razem powinno być sprawdzone.

coś mi się Wolverine wydaje, że Twój kod to nie zadziała :P

drumers napisz, co to ma robić bo mam dziwne wrażenie, że nie musi to być aż takie zakręcone. Musisz porównywać po znaku? Jaki typ zwracasz (Result)

Przyszukuje tabelę (Text: array of String) w poszukiwaniu tekstu podanego w zmiennej FindText.
Dodatkowo jest jeszcze podawana wartość zmiennej SearchType w zależności od której porównuje się wielkość znaków, nie porównuje i inne..

Warunków w sekcji Case może być np. 4 lub więcej.

for i := 0 to Count - 1 do
begin
  case SearchType of
    opcja1: Bool := Text[i] = FindText;
    opcja2: Bool := LowerCase(Text[i]) = LowerCase(FindText);
    opcja3: Bool := LowerCase(Text[i]) <> LowerCase(FindText);
  end;
  if Bool then 
  begin
      SetLength(Result, Length(Result) + 1);
      Result[Length(Result) - 1] := Text[i];
  end;
end;

powinno zadziałać

for i := 0 to Count - 1 do
begin
if (Text[i] = FindText)or(LowerCase(Text[i]) = LowerCase(FindText))or(LowerCase(Text[i]) <> LowerCase(FindText)) then
begin
SetLength(Result, Length(Result) + 1);
Result[Length(Result) - 1] := Text[i];
end;
end;

Mniej więcej chyba o to mu chodzi, bo ma 3 warunki ale dla każdego robi to samo

daban napisał(a)

for i := 0 to Count - 1 do
begin
  if (Text[i] = FindText)or(LowerCase(Text[i]) = LowerCase(FindText))or(LowerCase(Text[i]) <> LowerCase(FindText)) then
  begin
      SetLength(Result, Length(Result) + 1);
      Result[Length(Result) - 1] := Text[i];
  end;
end;

Mniej więcej chyba o to mu chodzi, bo ma 3 warunki ale dla każdego robi to samo

no chyba nie bardzo bo ma to być jeden warunek w zależności od wartości zmiennej SearchType

Faktycznie przegapiłem warunek case-a, to w takim wypadku
if ((search_type=opcja1)and(warunek1))or
((search_type=opcja2)and(warunek2))
((search_type=opcja3)and(warunek3)) then

Dla mnie to nadal czysta logika, funkcję case używa się tylko po to by ustawić true lub false a potem na podstawie tej zmiennej cos robi. Bezproblemowe złożenie.
Zobacz co robi jego program, ustala jakieś warunki logiczne, a następnie na podstawie tego wyniku wykonuje zawsze tą samą procedurę.
Zamiast funkcji case która tak naprawdę jest skomplikowanym ifem, wystarczy jeden zwykły iF z warunkami. W tym programie funkcja case ma ify w sobie, wystarczy poskładać w jeden warunek logiczny, lub jak ktoś się boi logiki to może zamienić na 3 niezależne ify:
if ((search_type=opcja1)and(warunek1)) then
if ((search_type=opcja2)and(warunek2)) then
if ((search_type=opcja3)and(warunek3)) then
na to samo wyjdzie.

Deban wiem, też na to wpadłem jak już Ci odpisałem, że wystarczy warunek poprawić :P. A tak BTW to ten kod można jeszcze bardziej zoptymalizować - przecież tego ifa wystarczy raz sprawdzić a nie x razy (dla każdej lini)

if (SearchType = opcja1) and (Text[i] = FindText) or
   (SearchType = opcja2) and (AnsiLowerCase(Text[i]) = AnsiLowerCase(FindText)) or
   (SearchType = opcja3) and (AnsiLowerCase(Text[i]) <> AnsiLowerCaseFindText)) then
  for i := 0 to Count - 1 do
  begin
    SetLength(Result, Length(Result) + 1);
    Result[Length(Result) - 1] := Text[i];
  end;

PS drumers lepiej zamiast LowerCase używać AnsiLowerCase bo LowerCase nie zamienia znaków narodowych

Chyba masz rację, zasugerowałem sie twoim poprawionym programem, zamiast sprawdzić na pierwotnym, mea culpa, choć warto by przepytać autora co miał na myśli.
Jeżeli każy wiersz ma być tak samo obsłuzony na podstawie warunku z case - (pierwotny program) to najpierw if i w ifie pętla - oddaje to sens programu pierwotnego.
Jeżeli dla działań w pętli może pozmieniać się warunek case to tak jak napisałem.

Kończąc wątek wydaje mi się ze chodzi o zamianę literek, a opcja jest odgórnie ustalana, więc tak jak MisiekD mówi wersja z IFem na poczatku i pętlą w środku.

Misiekd napisał(a)

A tak BTW to ten kod można jeszcze bardziej zoptymalizować - przecież tego ifa wystarczy raz sprawdzić a nie x razy (dla każdej lini)

i zrobiłeś ten sam błąd co Wolverine w pierwszym poście, najpierw sprawdzasz warunek dla indexu jeszcze nie zadeklarowanego indexu "i" a dopiero potem go deklarujesz w pętli - tym bardziej dziwne że na początku sam o tym powiedziałeś a potem to samo zrobiłeś - warunek ma być spełniony właśnie dla konketnej linii "i" a nie dla jednej a potem wszystkie traktować tak jak pierwszą ...

poza tym miał kod być przejrzysty i krótszy (i oczywiście działający) więc tylko chyba drugi post w tym wątku Miśka spełnia te warunki i wydaje mi się że kompilator najmniej się zmęczy przy kodzie z tego posta

ech masz rację [browar] ostatnio zakręcony jestem ;)

Adamo napisał(a)

poza tym miał kod być przejrzysty i krótszy (i oczywiście działający) więc tylko chyba drugi post w tym wątku Miśka spełnia te warunki i wydaje mi się że kompilator najmniej się zmęczy przy kodzie z tego posta

Zalezy od sposobu wykorzystania w kodzie. Czasami sposoby bardziej meczace dla kompilatora sa prostsze w konserwacji - po to wymyslono programowanie obiektowe :)

Z latwoscia moge sobie wyobrazic sytuacje, w ktorej wlasciw(sz)e bedzie rozwiazanie:

type TCompareFunction = function( tekst, FindTekst: string ): byte;

[...]

function CompareLow( Tekst, FindTekst: string ): byte;

function CompareHigh( Tekst, FindTekst: string ): byte;

function CompareCostam( Tekst, FindTekst: string ): byte;

blah blah blah


var CompareFunction: TComparefunction

[...]

case warunek of
  warunek1: CompareFunction := CompareLow;
  warunek2: CompareFunction := CompareHigh;
  warunek3: ....
  else
  CompareFunction := CompareCostam;
end;

Wiecej klepania i kompilator sie meczy, ale jaka bajka w pozniejszej obsludze, dodawaniu nowych funkcji etc... :-)