Jak znaleźć igłę w stogu siana?

Z trzech wolę opcję # 3.

Zasada pojedynczej odpowiedzialności sprawia, że nie chcę umieszczać możliwości wyszukiwania w moich DTOs lub modelach. Ich obowiązkiem jest być danymi, a nie znaleźć się, ani igły nie powinny wiedzieć o stogach siana, ani stogi siana nie wiedzą o igłach.

Jeśli to coś warte, myślę, że większość praktyków OO zajmuje dużo czasu, aby zrozumieć, dlaczego #3 jest najlepszym wyborem. Robiłem OO przez 10 lat, pewnie, zanim naprawdę zgrzytałem to.

@ wilhelmtell, C++ jest jednym z niewielu języków o specjalizacji szablonów, które sprawiają, że taki system faktycznie działa. Dla większości języków metoda "znajdź" ogólnego przeznaczenia byłaby okropnym pomysłem.

Istnieje inna alternatywa, którą jest podejście używane przez STL C++:

find(haystack.begin(), haystack.end(), needle)

Myślę, że to świetny przykład C++ krzyczącego " in your face!"do OOP. Chodzi o to, że OOP nie jest srebrną kulą jakiegokolwiek rodzaju; czasami rzeczy najlepiej opisują się w kategoriach działań, czasami w kategoriach przedmiotów, czasami żadne, a czasami oba.

Bjarne Stroustrup powiedział w TC++PL, że projektując system należy dążyć do odzwierciedlenia rzeczywistości pod ograniczeniami skuteczny i wydajny kod. Dla mnie oznacza to, że nigdy nie powinieneś podążać za niczym ślepo. Zastanów się nad tym, co jest pod ręką (stóg siana, igła) i kontekstem, w którym się znajdujemy (szukanie, o to chodzi w wyrażeniu).

Jeśli nacisk jest na wyszukiwanie, to za pomocą algorytmu (akcji), który podkreśla wyszukiwanie (tzn. jest elastyczny, aby dopasować stogi siana, oceany, pustynie, połączone listy). Jeśli nacisk dotyczy stogu siana, należy zamknąć metodę find wewnątrz obiektu stogu siana, a więc on

Postępuj zgodnie z tymi wytycznymi, a Twój kod będzie jaśniejszy i, cóż, piękniejszy.

Powiedziałbym, że opcja 1 jest całkowicie wyłączona. Kod powinien być czytany w sposób, który powie Ci, co robi. Opcja 1 sprawia, że myślę, że ta igła znajdzie mi stóg siana.

Opcja 2 wygląda dobrze, jeśli stóg siana ma zawierać igły. ListCollections zawsze będą zawierały listy, tak jak collection.find (item) jest naturalny i wyrazisty.

Myślę, że wprowadzenie obiektu helpera jest odpowiednie, gdy:

1. nie kontrolujesz implementacja danych obiektów
   IE: Szukaj.find (ObsecureOSObject, file)
2. nie ma regularnej lub sensownej relacji między obiektami
   IE: nameMatcher. find(domy, trees.name)

Jestem z Bradem. Im bardziej pracuję nad niezwykle złożonymi systemami, tym bardziej widzę potrzebę prawdziwego oddzielenia obiektów. Ma rację. To oczywiste, że igła nie powinna wiedzieć nic o stogu siana, więc 1 na pewno odpada. Ale stóg siana nie powinien wiedzieć nic o igle.

Gdybym modelował stóg siana, mógłbym zaimplementować go jako zbiór -- ale jako zbiór siana lub słomy -- a nie zbiór igieł! Jednak wziąłbym pod uwagę zastanów się, że rzeczy gubią się w stogu siana, ale nie wiem nic o tym, co dokładnie. Myślę, że lepiej nie zmuszać stogu siana do szukania przedmiotów w sobie (jak smart to i tak stóg siana). Właściwe podejście do mnie polega na tym, aby stóg siana prezentował zbiór rzeczy, które się w nim znajdują, ale nie są słomą, sianem czy czymkolwiek, co nadaje stogowi jego istotę.

class Haystack : ISearchableThingsOnAFarm {
   ICollection<Hay> myHay;
   ICollection<IStuffSmallEnoughToBeLostInAHaystack> stuffLostInMe;

   public ICollection<Hay> Hay {
      get {
         return myHay;
      }
   }

   public ICollection<IStuffSmallEnoughToBeLostInAHayStack> LostAndFound {
      get {
        return stuffLostInMe;
      }
   }
}

class Needle : IStuffSmallEnoughToBeLostInAHaystack {
}

class Farmer {
  Search(Haystack haystack, 
                 IStuffSmallEnoughToBeLostInAHaystack itemToFind)
}

Właściwie jest więcej, które chciałem wpisać i streszczenie w interfejsach i wtedy zdałem sobie sprawę, jak wariowałam. Czułem się, jakbym był w klasie CS na studiach... : P

Jeśli zarówno igła, jak i stóg siana są DAOs, to opcje 1 i 2 nie wchodzą w grę.

Powodem tego jest to, że DAOs powinien być odpowiedzialny tylko za utrzymywanie właściwości obiektów świata rzeczywistego, które modelują, i mieć tylko metody getter i setter (lub po prostu bezpośredni dostęp do właściwości). To sprawia, że serializowanie DAOs do pliku lub tworzenie metod dla ogólnego porównania / ogólnej kopii jest łatwiejsze do napisania, ponieważ kod nie zawiera całej gamy poleceń "if", aby pominąć te metody pomocnicze.

Pozostaje tylko opcja 3, która większość zgodziłaby się na prawidłowe zachowanie.

Wariant 3 ma kilka zalet, z największą zaletą jest testowanie jednostkowe. Dzieje się tak, ponieważ zarówno obiekty igłowe, jak i stóg siana mogą być teraz łatwo wyśmiewane, podczas gdy jeśli użyto opcji 1 lub 2, stan wewnętrzny igły lub stogu siana musiałby zostać zmodyfikowany przed wykonaniem wyszukiwania.

Po drugie, z wyszukiwarką teraz w osobnej klasie, wszystkie wyszukiwania kod może być przechowywany w jednym miejscu, w tym wspólny kod wyszukiwania. Podczas gdy gdyby Kod wyszukiwania został umieszczony w DAO, wspólny kod wyszukiwania byłby albo przechowywany w skomplikowanej hierarchii klas, albo i tak z klasą pomocniczą SearchEra.

To całkowicie zależy od tego, co się zmienia, a co pozostaje takie samo.

Na przykład, pracuję nad (non-OOP) framework gdzie algorytm find różni się w zależności od rodzaju igły i stogu siana. Oprócz faktu, że wymagałoby to podwójnego wysłania w środowisku obiektowym, oznacza to również, że nie ma sensu zapisywać ani needle.find(haystack), ani haystack.find(needle).

Z drugiej strony, Twoja aplikacja może z radością delegować znalezienie do albo z obu klas, albo trzymać się jednego algorytmu w ogóle, w którym to przypadku decyzja jest arbitralna. W takim razie wolałbym sposób haystack.find(needle), ponieważ bardziej logiczne wydaje się zastosowanie znaleziska do stogu siana.

Podczas wykonywania poszukiwań igłowych stóg siana w sposób obiektowy, zasadniczo masz trzy "alternatywy": {]}

1. Igła.find (stóg siana)

2. Stóg siana.find (igła)

3. Poszukiwacz.find (igła, stóg siana)

Które wolisz i dlaczego?

Popraw mnie, jeśli się mylę, ale we wszystkich trzech przykładach już masz odniesienie do igły, której szukasz, więc nie jest to jak szukanie okularów, kiedy siedzą ci na nosie? : P

Kalambur na bok, myślę, że to naprawdę zależy od tego, co uważasz za odpowiedzialność stogu siana, aby być w danej domenie. Czy tylko troszczymy się o nią w tym sensie, że jest rzeczą, która zawiera igły (w zasadzie zbiór)? Potem stóg siana.find (needlePredicate) jest w porządku. Inaczej, farmerze.znajdź (predykat, stóg siana) może być bardziej odpowiedni.

Cytując wielkich autorów SICP ,

programy muszą być pisane dla ludzi do czytania, a tylko nawiasem mówiąc dla maszyn do wykonywania

Wolę mieć obie metody 1 i 2 pod ręką. Używając ruby jako przykładu, pochodzi z .include?, który jest używany w ten sposób

haystack.include? needle
=> returns true if the haystack includes the needle

Czasami jednak, tylko ze względu na czytelność, chcę to odwrócić. Ruby nie ma metody in?, ale jest to metoda jednowierszowa, więc często robię to:

needle.in? haystack
=> exactly the same as above

Jeśli to "ważniejsze" dla podkreślenia stogu siana, czyli operacji wyszukiwania, wolę napisać include?. Często jednak ani stóg siana, ani wyszukiwanie nie jest tym, na czym Ci zależy, tylko to, że obiekt jest obecny - w tym przypadku uważam, że in? lepiej oddaje znaczenie programu.

To zależy od twoich wymagań.

Na przykład, jeśli nie dbasz o właściwości poszukiwacza (np. Siła poszukiwacza, wzrok itp.), wtedy powiedziałbym stóg siana.find (igła) będzie najczystszym roztworem.

Ale, jeśli zależy ci na właściwościach wyszukiwarki (lub jakichkolwiek innych właściwościach w tym zakresie), wstrzyknęłbym interfejs ISearcher do konstruktora stogów siana lub funkcji, aby to ułatwić. Obsługuje zarówno projektowanie obiektowe (stóg siana posiada igiełki) oraz inwersję wtrysku sterowania / zależności (ułatwia testowanie jednostkowe funkcji "find").

Myślę o sytuacjach, w których jeden z dwóch pierwszych smaków ma sens:

1. Jeśli igła wymaga wstępnego przetwarzania, tak jak w algorytmie Knutha-Morrisa-Pratta, needle.findIn(haystack) (LUB pattern.findIn(text)) ma sens, ponieważ obiekt igła posiada tabele pośrednie utworzone dla algorytmu do skutecznego działania

2. Jeśli stóg siana wymaga wstępnego przetworzenia, jak np. w Trie, haystack.find(needle) (lub words.hasAWordWithPrefix(prefix)) działa lepiej.

W obu powyższych przypadkach, jeden z igieł lub stóg siana jest świadomy poszukiwań. Ponadto oboje są świadomi siebie nawzajem. Jeśli chcesz, aby igła i stóg siana nie były świadome siebie lub wyszukiwania, searcher.find(needle, haystack) byłoby właściwe.

Łatwe: spalić stóg siana! Następnie pozostanie tylko igła. Możesz też spróbować magnesów.

Trudniejsze pytanie: Jak znaleźć jedną konkretną igłę w Puli igieł?

Odpowiedź: każdy wątek i dołącz drugi koniec każdego wątku do posortowanego indeksu (tj. wskaźników)

Odpowiedź na to pytanie powinna zależeć od domeny, dla której implementowane jest rozwiązanie.
Jeśli zdarzy ci się symulować fizyczne poszukiwanie w fizycznym stogu siana, możesz mieć klasy

• przestrzeń
• Słoma
• igła
• Poszukiwacz

Przestrzeń
wie, które obiekty znajdują się przy jakich współrzędnych
realizuje prawa natury(zamienia energię, wykrywa kolizje itp.)

Igła , Słoma
znajdują się w przestrzeni
reaguj na siły

Poszukiwacz
współdziała z przestrzenią:
    porusza się ręką, stosuje pole magnetyczne, spala siano, stosuje promienie rentgenowskie, szuka igły ...

Zatem seeker.find(needle, space) LUB seeker.find(needle, space, strategy)

seeker.find(needle, haystack) lub seeker.find(needle, haystack, strategy)

Ale matrix był domeną, która powinna być zastąpiona przez stóg siana, jeśli twoja igła nie może być nigdzie indziej.

• Robić igły, które potrafią się odnaleźć, np. regularnie zadają sobie pytanie: czy jestem zagubiony? Jeśli odpowiedź brzmi "tak", wysyłają komuś swoją pozycję obliczoną przez GPS albo zaczynają pisać, czy coś:
  needle.find(space) lub needle.find(haystack) (rozwiązanie 1)

• Install a stogu siana z kamerą na każdej słomce, potem można zapytać ula stogu siana umysł, czy widział igłę ostatnio:
  stóg siana.find (needle) (rozwiązanie 2)

• Przymocuj znaczniki RFID do igieł, aby łatwo je triangulować

Więc zdecyduj według swojej domeny:

• czy celem stogu siana są igły? Następnie przejdź do rozwiązania 2.
• czy to naturalne, że igła ginie gdziekolwiek? Następnie przejdź do rozwiązania 1.
• czy igła zgubiła się przypadkiem w stogu siana? Następnie przejdź do rozwiązania 3. (lub rozważyć inną strategię odzyskiwania)

Stóg siana.znajdź (igła), ale powinno być pole wyszukiwania.

Wiem, że dependency injection to cała furia, więc mnie nie dziwi, że stóg siana Mike 'a Stone' A.znajdź (needle, searcher) został zaakceptowany. Ale się nie zgadzam: wybór tego, co jest używane, wydaje mi się decyzją na stóg siana.

Rozważmy dwa Izearchery: MagneticSearcher iteruje nad objętością, przesuwając i przesuwając magnes w sposób zgodny z siłą magnesu. QuickSortSearcher dzieli stos na dwie części, aż igła jest widoczna w jednym z podtypów. Właściwy wybór wyszukiwarki może zależeć od tego, jak duży jest stóg siana (w stosunku do pola magnetycznego, na przykład), jak igła dostała się do stogu siana (tj.), itp.

Jeśli masz stóg siana.znajdź (needle, searcher), mówisz " wybór, który jest najlepszą strategią wyszukiwania najlepiej zrobić poza kontekstem stogu siana."Nie sądzę, że to prawdopodobnie ma rację. Myślę, że bardziej prawdopodobne jest, że " stogi siana wiedzą, jak najlepiej szukać siebie."Dodaj Ustawiacz, a nadal możesz ręcznie wstrzyknąć wyszukiwarkę, jeśli chcesz nadpisać lub przetestować.

Osobiście lubię drugą metodę. Moim rozumowaniem jest to, że główne interfejsy API, z którymi pracowałem, wykorzystują to podejście i uważam, że ma to największy sens.

Jeśli masz listę rzeczy (stóg siana), poszukaj (znajdź ()) igły.

@ Peter Meyer

Rozumiesz. Myślę, że bycie tak luźno sprzężonym, jak to możliwe, jest dobrą rzeczą, ale może trochę mnie poniosło! :)

Errr... tak... Myślę, że IStuffSmallEnoughToBeLostInAHaystack to czerwona flaga: -)

Masz też czwartą alternatywę, która moim zdaniem byłaby lepsza od alternatywy 3:

haystack.find(needle, searcher)

Rozumiem twój punkt widzenia, ale co jeśli searcher zaimplementuje interfejs wyszukiwania, który pozwala na przeszukiwanie innych typów obiektów niż stogi siana i znajdowanie w nich innych rzeczy niż igły?

Interfejs może być również zaimplementowany za pomocą różnych algorytmów, na przykład:

binary_searcher.find(needle, haystack)
vision_searcher.find(pitchfork, haystack)
brute_force_searcher.find(money, wallet)

Ale, jak już zauważyli inni, myślę również, że jest to pomocne tylko wtedy, gdy w rzeczywistości mają wiele algorytmów wyszukiwania lub wiele klas z możliwością przeszukiwania lub znajdowania. Jeśli nie, zgadzam się {[3] } jest lepsza ze względu na swoją prostotę, więc jestem gotów poświęcić dla niej trochę "poprawności".

class Haystack {//whatever
 };
class Needle {//whatever
 }:
class Searcher {
   virtual void find() = 0;
};

class HaystackSearcher::public Searcher {
public:
   HaystackSearcher(Haystack, object)
   virtual void find();
};

Haystack H;
Needle N;
HaystackSearcher HS(H, N);
HS.find();

Mieszanka 2 i 3, naprawdę.

Niektóre stogi siana nie mają wyspecjalizowanej strategii wyszukiwania; przykładem tego jest tablica. Jedynym sposobem na znalezienie czegoś jest rozpoczęcie od początku i przetestowanie każdego przedmiotu, aż znajdziesz ten, który chcesz.

Do tego typu rzeczy, wolna funkcja jest chyba najlepsza (jak C++).

Niektóre stogi siana mogą mieć nałożoną wyspecjalizowaną strategię wyszukiwania. Tablica może być posortowana, pozwalając na użycie na przykład wyszukiwania binarnego. A free funkcja (lub para wolnych funkcji, np. sort i binary_search) jest prawdopodobnie najlepszą opcją.

Niektóre stogi siana mają zintegrowaną strategię wyszukiwania jako część ich implementacji; na przykład kontenery asocjacyjne (zaszyfrowane lub uporządkowane zestawy i mapy). W tym przypadku znalezienie jest prawdopodobnie podstawową metodą wyszukiwania, więc prawdopodobnie powinna to być metoda, tj. stóg siana.znajdź (igła).

Stóg siana może zawierać rzeczy jednym z rodzajów rzeczy jest igła finder to coś, co odpowiada za Wyszukiwanie rzeczy finder może przyjąć stertę rzeczy jako źródło, gdzie znaleźć rzecz finder może również zaakceptować opis rzeczy, które musi znaleźć

Więc najlepiej dla elastycznego rozwiązania zrobiłbyś coś takiego: Interfejs IStuff

Stóg Siana = IList Igła: IStuff

Finder .Find (IStuff stuftolookfor, IList stuffsToLookIn)

W tym przypadku Twoje rozwiązanie nie zostanie powiązane tylko z igłą i stogiem siana, ale jest użyteczne dla każdego typu, który implementuje interfejs

Więc jeśli chcesz znaleźć rybę w Oceanie, możesz.

Var results = Finder.Find (fish, ocean)

Jeśli masz odniesienie do obiektu igłowego, dlaczego go szukasz? :) Problem i przypadki użycia mówią, że nie potrzebujesz dokładnej pozycji igły w stogu siana (jak to, co można uzyskać z listy.indexOf (element)), wystarczy igła. I jeszcze go nie masz. Więc moja odpowiedź brzmi mniej więcej tak

Needle needle = (Needle)haystack.searchByName("needle");

Lub

Needle needle = (Needle)haystack.searchWithFilter(new Filter(){
    public boolean isWhatYouNeed(Object obj)
    {
        return obj instanceof Needle;
    }
});

Lub

Needle needle = (Needle)haystack.searchByPattern(Size.SMALL, 
                                                 Sharpness.SHARP, 
                                                 Material.METAL);

Zgadzam się, że jest więcej możliwych rozwiązań, które opierają się na różnych strategiach wyszukiwania, więc wprowadzają poszukiwacz. Było sporo komentarzy na ten temat, więc nie zwracam na to uwagi. Chodzi mi o powyższe rozwiązania - po co szukać czegoś, jeśli już masz do tego odniesienie? W najbardziej naturalnym przypadku nie masz jeszcze igły, więc nie używasz zmiennej igły.

Brad Wilson wskazuje, że przedmioty powinny mieć jedną odpowiedzialność. W skrajnym przypadku przedmiot ma jedną odpowiedzialność, a nie państwo. Wtedy może się stać... funkcja.

needle = findNeedleIn(haystack);

Albo możesz napisać to tak:

SynchronizedHaystackSearcherProxyFactory proxyFactory =
    SynchronizedHaystackSearcherProxyFactory.getInstance();
StrategyBasedHaystackSearcher searcher =
    new BasicStrategyBasedHaystackSearcher(
        NeedleSeekingStrategies.getMethodicalInstance());
SynchronizedHaystackSearcherProxy proxy =
    proxyFactory.createSynchronizedHaystackSearcherProxy(searcher);
SearchableHaystackAdapter searchableHaystack =
    new SearchableHaystackAdapter(haystack);
FindableSearchResultObject foundObject = null;
while (!HaystackSearcherUtil.isNeedleObject(foundObject)) {
    try {
        foundObject = proxy.find(searchableHaystack);
    } catch (GruesomeInjuryException exc) {
        returnPitchforkToShed();  // sigh, i hate it when this happens
        HaystackSearcherUtil.cleanUp(hay); // XXX fixme not really thread-safe,
                                           // but we can't just leave this mess
        HaystackSearcherUtil.cleanup(exc.getGruesomeMess()); // bug 510000884
        throw exc; // caller will catch this and get us to a hospital,
                   // if it's not already too late
    }
}
return (Needle) BarnyardObjectProtocolUtil.createSynchronizedFindableSearchResultObjectProxyAdapterUnwrapperForToolInterfaceName(SimpleToolInterfaces.NEEDLE_INTERFACE_NAME).adapt(foundObject.getAdaptable());

Stóg siana nie powinien wiedzieć o igle, a igła nie powinna wiedzieć o stogu siana. Poszukiwacz musi wiedzieć o obu, ale to, czy stóg siana powinien wiedzieć, jak szukać, jest prawdziwym punktem sporu.

Więc wybrałbym mieszankę 2 i 3; stóg siana powinien być w stanie powiedzieć komuś innemu, jak go przeszukać, a poszukiwacz powinien być w stanie użyć tych informacji, aby przeszukać stóg siana.

haystack.magnet().filter(needle);

Czy kod próbuje znaleźć konkretną igłę, czy tylko dowolną igłę? Brzmi jak głupie pytanie, ale zmienia problem.

Szukanie konkretnej igły kod w pytaniu ma sens. Szukając jakiejkolwiek igły to byłoby bardziej jak

needle = haystack.findNeedle()

Lub

needle = searcher.findNeedle(haystack)

Zdecydowanie trzeci, IMHO.

Kwestia igły w stogu siana jest przykładem próby znalezienia jednego obiektu w dużej kolekcji innych, co wskazuje, że będzie potrzebował skomplikowanego algorytmu wyszukiwania (prawdopodobnie z magnesami lub (bardziej prawdopodobnymi) procesami potomnymi) i nie ma większego sensu oczekiwać, że stóg siana będzie zarządzał wątkami lub realizował złożone wyszukiwania.

Obiekt wyszukiwania jest jednak dedykowany do wyszukiwania i można się spodziewać, że będzie wiedział, jak aby zarządzać wątkami potomnymi dla szybkiego wyszukiwania binarnego, lub użyj właściwości szukanego elementu, aby zawęzić obszar (np. magnes, aby znaleźć elementy żelazne).

Innym możliwym sposobem może być utworzenie dwóch interfejsów dla przeszukiwalnego obiektu np. stóg siana i szukanego obiektu np. igła. Tak więc można to zrobić w ten sposób

public Interface IToBeSearched
{}

public Interface ISearchable
{

    public void Find(IToBeSearched a);

}

Class Needle Implements IToBeSearched
{}

Class Haystack Implements ISearchable
{

    public void Find(IToBeSearched needle)

   {

   //Here goes the original coding of find function

   }

}

haystack.iterator.findFirst(/* pass here a predicate returning
                               true if its argument is a needle that we want */)

iterator może być interfejsem do dowolnej niezmiennej kolekcji, przy czym zbiory mają wspólną metodę findFirst(fun: T => Boolean) wykonującą zadanie. Tak długo, jak stóg siana jest niezmienny, nie trzeba ukrywać żadnych przydatnych danych z "zewnątrz". I, oczywiście, nie jest dobrze powiązać implementację niestandardowej nietrywialnej kolekcji i kilka innych rzeczy, które mają haystack. Dziel i rządź, dobrze?

W większości przypadków wolę wykonywać proste operacje pomocnicze, takie jak ta na obiekcie core, ale w zależności od języka, dany obiekt może nie mieć wystarczającej lub rozsądnej metody dostępnej.

Nawet w językach takich jak JavaScript), które pozwalają na rozszerzanie / Rozszerzanie wbudowanych obiektów, uważam, że może to być zarówno wygodne, jak i problematyczne (np. jeśli przyszła wersja języka wprowadzi bardziej wydajną metodę, która zostanie nadpisana przez niestandardowe jeden).

Ten artykuł dobrze opisuje takie scenariusze.