Gierig vs. Zurückhaltend vs. Possessive Quantoren
Fand ich diese Super tutorial auf reguläre Ausdrücke und während ich intuitiv verstehen, was "gierig", "zurückhaltend" und "besitzergreifend" Quantoren tun, scheint es eine ernsthafte Lücke in meinem Verständnis.
Insbesondere im folgenden Beispiel:
Enter your regex: .*foo //greedy quantifier
Enter input string to search: xfooxxxxxxfoo
I found the text "xfooxxxxxxfoo" starting at index 0 and ending at index 13.
Enter your regex: .*?foo //reluctant quantifier
Enter input string to search: xfooxxxxxxfoo
I found the text "xfoo" starting at index 0 and ending at index 4.
I found the text "xxxxxxfoo" starting at index 4 and ending at index 13.
Enter your regex: .*+foo //possessive quantifier
Enter input string to search: xfooxxxxxxfoo
No match found.Der Erklärung erwähnt Essen die gesamte Eingabe-Zeichenfolge, die Buchstaben wurden verbraucht, matcher Rückendeckung aus, am weitesten rechts liegenden vorkommen von "foo" wurde wiedergekäut, etc.
Leider, trotz der schönen Metaphern, ich verstehe immer noch nicht, was gegessen wird, von wem... kennen Sie ein tutorial, das erklärt (kurz und prägnant) wie reguläre Ausdrücke Motoren arbeiten?
Alternativ, wenn jemand erklären kann, in etwas unterschiedlichen Formulierungen der folgende Absatz, das wäre sehr geschätzt:
Das erste Beispiel verwendet den gierigen
Quantifizierer .* Sie finden "alles", null
oder mehrmals, gefolgt von den Buchstaben
"f" "o" "o". Da der Quantifizierer ist
gierig, die .* Teil des
Ausdruck zuerst isst die gesamte Eingabe
string. An dieser Stelle, die insgesamt
Ausdruck kann nicht gelingen, weil die
letzten drei Buchstaben ("f" "o" "o")
die bereits verbraucht wurde (von wem?). Damit der matcher
langsam Rücken (von rechts nach Links?) ein Brief zu einem Zeitpunkt,
bis die am weitesten rechts liegenden vorkommen von
"foo" wurde regurgitated (was bedeutet das?), an die
Punkt das match gelingt und die
Suche endet.Dem zweiten Beispiel, jedoch ist
nur ungern, so dass es beginnt mit dem ersten
verbraucht wird (von wem?) "nichts". Weil "foo"
nicht erscheinen am Anfang der
string, es ist gezwungen zu schlucken (wer schluckt?) die
ersten Buchstaben (ein "x"), die Auslöser
das erste Spiel bei 0 und 4. Unser test
Kabelbaum wird der Prozess fortgesetzt, bis
der input-string ist erschöpft. Es
findet ein weiteres Spiel bei 4 und 13.Dritten Beispiel nicht zu finden
Spiel, weil die Quantifizierer ist
besitzergreifend. In diesem Fall wird die gesamte
input-string ist verbraucht .*+, (wie?)
es blieb nichts übrig, um zu befriedigen
"foo" am Ende der
Ausdruck. Verwenden Sie ein besitzergreifend
Quantifizierer für Situationen, in denen Sie
ergreifen wollen alle etwas, ohne
je Schutzfolie (was bedeutet wieder aus bedeuten?); es wird übertreffen
das entspricht gierigen Quantifizierer im
Fälle, in denen das Spiel nicht
sofort fand.
*, +, und ? sind gierig. Minimal Quantoren wie *?, +?, und ?? sind faul. Besitzergreifend Quantoren wie *+, ++, und ?+ sind klebrig.Diese Frage wurde Hinzugefügt, um den Stapel-Überlauf Regulären Ausdruck FAQ, unter "Quantoren > Mehr auf die Unterschiede...".
InformationsquelleAutor Regex Rookie | 2011-03-16
Du musst angemeldet sein, um einen Kommentar abzugeben.
Werde ich give it a shot.
Einen gierig Quantifizierer ersten Spiele so viel wie möglich. Also die
.*entspricht die gesamte Zeichenfolge. Dann wird der matcher versucht, dieffolgenden, aber es gibt keine Zeichen nach Links. So ist es "backtracks", die den gierigen Quantifizierer match eine Sache weniger (wobei das "o" am Ende der Zeichenfolge unerreicht). Dass noch nicht mit derfim regex, so ist es "backtracks" ist ein weiterer Schritt, so dass Sie die gierigen Quantifizierer match eine Sache weniger wieder (wobei das "oo" am Ende der Zeichenfolge unerreicht). Dass noch nicht mit derfim regex, so dass es backtracks einen Schritt mehr (wobei das "foo" am Ende der Zeichenfolge unerreicht). Nun, die matcher schließlich entspricht diefim regex, und dieound die nächstenoabgestimmt sind auch. Erfolg!Einen ungern oder "nicht-greedy" - Quantifizierer ersten Spiele so wenig wie möglich. Also die
.*passt nichts auf den ersten, so dass die ganze Zeichenkette unübertroffen. Dann wird der matcher versucht, dieffolgenden, aber den unerreichten Teil der string beginnt mit "x", so dass nicht funktioniert. Damit der matcher backtracks, so dass die nicht-gierige Quantifizierer match noch eine Sache (nun mit der "x" verlassen "fooxxxxxxfoo" unmatched). Dann es versucht, dief, der es gelingt, und dieound die nächstenoim regex-match. Erfolg!In deinem Beispiel, es startet dann den Prozess über und über mit dem nicht passenden Teil der Zeichenkette, nach dem gleichen Prozess.
Einen besitzergreifend Quantifizierer ist nur, wie der gierige Quantifizierer, aber es funktioniert nicht ansetzen. Also es beginnt mit
.*passenden die gesamte Zeichenfolge, so dass nichts unübertroffen. Dann gibt es nichts mehr, was es in übereinstimmung mit derfim regex. Da die possessive Quantifizierer nicht backtrack, das Spiel scheitert es.ein bisschen spät, aber besitzergreifend Teil, ich denke, du meintest Also es beginnt mit
.*+(man beachte das "+")was genau macht das possessive Quantifizierer dann tun? wenn diese nicht übereinstimmen? (Ich meine, was ist der Punkt, wenn Sie können nicht Zeichen, nachdem es)
Sie würde es nutzen, in einer situation, wo Sie wissen, dass backtracking nicht helfen, wahrscheinlich nicht mit
.*+dass passt alles. Zum Beispiel, wenn Sie ein Muster haben[xyz]*foogibt es keine Möglichkeit, dass backtracking die x -, y -, und z ist abgestimmt durch die[xyz]*bit wird jemals zulassen, die folgendenfoobit übereinstimmen, so können Sie die Dinge beschleunigen, indem es besitzergreifend.es sind keine Fälle je (mathematische Tatsache), wo die possessive Quantoren erzeugt eine match, die nicht in die Produktion durch einfache greedy-Quantoren. Es gibt gelegentliche Fälle, in denen Sie erzeugt eine kein Treffer, wenn gierige Quantoren erzeugen würde, eine übereinstimmen. in ALLEN anderen Fällen (wo gierig und besitzergreifend, produzieren die gleichen Ergebnisse), possessive Quantoren geben ein performance-Gewinn.
InformationsquelleAutor Anomie
Es ist nur meine Praxis-Ausgang zur Visualisierung der Szene-
Außer, dass ich glaube, der Letzte Fall, besitzergreifend, sollte nicht n geht -- nehmen Sie einfach den gesamten string auf einmal.
Ich denke, es ist jetzt ok?
InformationsquelleAutor SIslam
Ich habe nicht gehört, die exakt die Begriffe "wiederkäuen" oder "backing-off" - vor; der Satz ersetzen würde diese "backtracking", sondern "wiederkäuen" scheint wie ein Satz, wie jeder für die Inhalte, die hatte gewesen unter VORBEHALT akzeptiert werden, bevor backtracking warf es wieder Weg".
Die wichtige Sache zu erkennen, über die die meisten regex-engines ist, dass Sie backtracking: Sie vorläufig akzeptieren einen möglichen, teilweisen übereinstimmung, während der versucht, den gesamten Inhalt der regex. Wenn die regex nicht vollständig abgestimmt auf den ersten Versuch, dann die regex-engine backtrack auf eines seiner matches. Er wird versuchen, die passende
*,+,?, Wechsel oder{n,m}Wiederholung anders ist, und versuchen Sie es erneut. (Und ja, dieser Prozess kann eine lange Zeit dauern.)Den letzten drei Buchstaben,
f,o, undowaren bereits verbraucht, die von der ursprünglichen.*Teil der Regel. Aber das nächste element in der regex -f, hat nichts mehr in der input-string. Der Motor wird gezwungen sein, zu backtrack auf seine erste.*übereinstimmen, und versuchen Sie, passend zu allen-aber-das-Letzte Zeichen. (Es könnte sein smart und wieder ansetzen, um alle-aber-die-letzten-drei, denn es hat drei literalen ausgedrückt, aber ich bin nicht bewusst auf details zur Implementierung auf dieser Ebene.)Dies bedeutet, dass die
foohatte vorläufig wurden, einschließlich, wenn zutreffend.*. Weil dieser Versuch gescheitert war, die regex-engine versucht, die Annahme einer weniger Zeichen in.*. Hätte es ein erfolgreiches match vor die.*in diesem Beispiel, dann würde der Motor wahrscheinlich versuchen, die Verkürzung der.*übereinstimmen (von rechts nach Links, wie Sie darauf hingewiesen, weil es ist ein gieriger qualifier), und wenn es nicht in der Lage war, um nach übereinstimmung im gesamten Eingänge, dann könnte es gezwungen sein, neu zu bewerten, was es hatte abgestimmt vor die.*in meinem hypothetischen Beispiel.Den ersten ist nichts verbraucht
.?*, was verbraucht der kürzestmöglichen alles, erlaubt dem rest der regex entsprechen.Wieder die
.?*verbraucht das erste Zeichen, nach dem backtracking auf den ersten Fehlschlag zu entsprechen, das ganze mit regex kürzester match. (In diesem Fall die regex-engine erweitert das Spiel um.*?von Links nach rechts, weil.*?nur ungern.)Einen
.*+verbraucht so viel wie möglich, und nicht backtrack, neue Kombinationen zu finden, wenn der reguläre Ausdruck als ganzes fehlschlägt, um eine übereinstimmung zu finden. Weil die besitzanzeigende form nicht durchführen backtracking, werden Sie wahrscheinlich nicht finden Sie viele Anwendungen mit.*+, sondern vielmehr mit Charakter-Klassen oder ähnliche Einschränkungen:account: [[:digit:]]*+ phone: [[:digit:]]*+.Dies kann drastisch beschleunigen regex-matching, weil Sie erzählt die regex-engine, es sollte nie backtrack über mögliche übereinstimmungen, wenn eine Eingabe nicht übereinstimmen. (Wenn Sie schreiben musste, alle passenden code von hand, das würde ähnlich sein, aber niemals mit
putc(3)zu 'push-back' einen input-Charakter. Es wäre sehr ähnlich zu der naiv-code könnte man schreiben über einen ersten Versuch. Außer regex Motoren sind viel besser als ein einzelnes Zeichen des push-back, Sie können Zurückspulen alle auf null zurück und versuchen Sie es erneut. 🙂Aber mehr als die potentielle Geschwindigkeit ups, dieses auch können Sie schreiben regexs entsprechen genau das, was Sie brauchen, zu entsprechen. Ich habe Probleme, kommen mit einem einfachen Beispiel 🙂 schreib doch einen regex verwenden besitzergreifend vs gierigen Quantoren können Ihnen verschiedene Spiele und die eine oder andere besser geeignet sein können.
"Backing-off" in diesem Kontext bedeutet "backtracking" -- wegwerfen einer vorläufigen teilweisen übereinstimmung, um zu versuchen, eine weitere teilweise übereinstimmung, die möglicherweise oder möglicherweise nicht erfolgreich.
Bestätigt: "das ist das, was atomic grouping und possessive Quantifizierer sind für: Effizienz durch das Verbot backtracking." von regular-expressions.info So die Aussage in dieser Antwort "Aber mehr als die potentielle Geschwindigkeit ups, dieses auch können Sie schreiben regexs entsprechen genau das, was Sie brauchen, zu entsprechen." eigentlich nicht ganz richtig.
danke für die Kommentare; das mag erklären, warum ich hatte Mühe, kommen mit einem Beispiel. Hehe.
InformationsquelleAutor sarnold
http://swtch.com/~rsc/regexp/regexp1.html
Ich bin nicht sicher, dass das die beste Erklärung, die auf dem internet, aber es ist Recht gut geschrieben und angemessen detailliert, und ich komme immer wieder darauf zurück. Möchten Sie vielleicht check it out.
Wenn Sie wollen, eine höhere Ebene (weniger detaillierte Erklärung), für einfache reguläre Ausdrücke wie die, die Sie suchen, ist ein regulärer Ausdruck Motor arbeitet durch backtracking. Im wesentlichen, Sie wählt ("frisst") ein Abschnitt der Zeichenfolge und versucht, mit dem regulären Ausdruck übereinstimmen, die gegen diesen Abschnitt. Wenn es passt, toll. Wenn nicht, wird der Motor verändert seine Wahl der Abschnitt der Zeichenfolge und versucht, auf die regexp, die gegen diesen Abschnitt, und so weiter, bis es versucht, jede mögliche Wahl.
Dieser Prozess wird rekursiv verwendet: in seinem Versuch, eine Zeichenfolge suchen, die mit einem bestimmten regulären Ausdruck, der Motor teilt den regulären Ausdruck in Stücke und wenden Sie den Algorithmus auf jedes Stück einzeln.
Den Unterschied zwischen greedy, reluctant, und possessive Quantoren kommt, wenn der Motor macht seine Entscheidungen von dem, was Teil der Zeichenfolge, um zu versuchen, um dagegen, und wie zu ändern, dass die Wahl, falls es nicht funktioniert die erste Zeit. Die Regeln sind wie folgt:
Ein gieriger Quantifizierer sagt, den Motor zu starten mit dem gesamte string (oder zumindest alle, dass es nicht bereits abgestimmt, die von früheren Teile des regulären Ausdrucks) und zu überprüfen, ob Sie mit der regexp. Wenn ja, toll, der Motor kann weiterhin mit dem rest der regexp. Wenn nicht, versucht er es nochmals, aber das trimmen eines Zeichens (der letzten) aus dem Abschnitt der Zeichenfolge, die geprüft werden. Wenn das nicht funktioniert, es beschneidet ein weiteres Zeichen, etc. So ein gieriger Quantifizierer prüft mögliche übereinstimmungen in der Reihenfolge vom längsten zum kürzesten.
Ungern Quantifizierer sagt, den Motor zu starten mit dem kürzesten Stück der saite. Wenn es passt, kann der Motor weiter; wenn nicht, ist es fügt ein Zeichen, um den Abschnitt der Zeichenfolge, die überprüft wird und versucht, dass, und so weiter, bis es eine übereinstimmung findet, oder die gesamte Zeichenfolge verwendet wurde. So ungern Quantifizierer prüft mögliche übereinstimmungen in der Reihenfolge von der kürzesten zur längsten.
Einen possessive Quantifizierer ist wie ein gieriger Quantifizierer auf den ersten Versuch: er erzählt den Motor zu starten, durch überprüfen der gesamten Zeichenfolge. Der Unterschied ist, dass wenn es nicht funktioniert, das possessive Quantifizierer Berichte, dass das Spiel gescheitert, genau dann und dort. Der Motor ändert sich nicht, der Abschnitt der Zeichenfolge, gesehen zu werden, und dabei spielt es keine versuche mehr.
Dies ist der Grund, warum die possessive Quantifizierer match schlägt in deinem Beispiel: die
.*+wird geprüft gegen die gesamte Zeichenfolge, die es passt, aber dann wird der Motor geht an, um zusätzliche Zeichenfoodanach - aber natürlich nicht finden, weil Sie bereits am Ende der Zeichenfolge. Wenn es ein gieriger Quantifizierer, es würde ansetzen und versuchen, die.*nur bis zum vorletzten Zeichen, dann die Dritte bis zum letzten Zeichen, dann bis zu dem vierten bis zum letzten Zeichen, der es gelingt, denn nur dann gibt es einefooLinks nach der.*hat "gefressen", die früher Teil der Zeichenfolge.Rookie: froh, es gefällt Euch 🙂 Nachdem ich über diese Website, obwohl, ich denke ich sollte klar machen, dass Ihr Zweck ist die Förderung einer alternativen Implementierung einer engine für reguläre Ausdrücke. Der backtracking Algorithmus, den ich (teilweise) und andere Antworten beschreiben, ist die langsam Art und Weise; es ist eine völlig separate Algorithmus aus der NFA/DFA-Idee beschrieben, die in der web-Seite. Backtracking ist nur einfacher zu verstehen, was ist der Grund, warum das ist, wie regexps sind in der Regel erklärt für Anfänger.
Zaslavsky: Gute Erklärung. Ihre Kommentare in Klammern "Ein gieriger Quantifizierer sagt, den Motor zu starten mit den ganzen string (oder zumindest alle, dass es nicht bereits abgestimmt, die von früheren Teile des regulären Ausdrucks)" wichtig sind. Sie gelten auch widerstrebend und possessive Quantifizierer. Das macht Ihre Erklärung, kompatibel mit, was passiert, wenn wir ändern unser Beispiel Muster von (".*foo"; ".*?foo"; und ".*+foo") , ("foo.*"; "foo.*?"; und "foo.*+").
Eigentlich xfooxxxxxxfoo übereinstimmt .*foo im normalen (computer science Bedeutung) eines regulären Ausdrucks. Die NFA wäre ein Zustand, wo es Schleifen unter sich mit einem beliebigen Zeichen und dann kann es springen zu foo. Die DFA-wäre eine direkte übersetzung des NFA. Es kann getan werden, in 8 Staaten.
ja, denn das ist nicht eine possessive Quantifizierer.
InformationsquelleAutor David Z
Hier ist mein nehmen mit der Zell-und Index-Positionen (Siehe die Diagramm hier zu unterscheiden, eine Zelle aus einem Index).
Gierig - Spiel so viel wie möglich, um die gierigen Quantifizierer und die gesamte regex. Wenn keine übereinstimmung vorhanden ist, backtrack auf die gierigen Quantifizierer.
Input String: xfooxxxxxxfoo
Regex: .*foo
Den oben Regex hat zwei Teile:
(i)'.*' und
(ii)'foo'
Jeder der Schritte analysieren, die sich in zwei Teile. Zusätzliche Kommentare für ein Spiel auf 'Pass' oder 'Fail' ist, erklärt in Klammern.
Schritt 1:
(i) .* = xfooxxxxxxfoo - PASS ('.*' ist ein gieriger Quantifizierer, und nutzen die gesamte Eingabe String)
(ii) foo = Keine Zeichen nach Links zum Spiel nach index-13 - FAIL
Match gescheitert.
Schritt 2:
(i) .* = xfooxxxxxxfo - PASS (Backtracking auf die gierigen Quantifizierer '.*')
(ii) foo = o - FAIL
Match gescheitert.
Schritt 3:
(i) .* = xfooxxxxxxf - PASS (Backtracking auf die gierigen Quantifizierer '.*')
(ii) foo = oo - FAIL
Match gescheitert.
Schritt 4:
(i) .* = xfooxxxxxx - PASS (Backtracking auf die gierigen Quantifizierer '.*')
(ii) foo = foo - PASS
Bericht MATCH
Ergebnis: 1 match(es)
Ich fand den text "xfooxxxxxxfoo" starting at index 0 and ending at index 13.
Ungern - Spiel so wenig wie möglich, um den widerstrebenden Quantifizierer und übereinstimmung mit dem gesamten regex. wenn keine übereinstimmung vorhanden ist, fügen Sie Zeichen an den zurückhaltend-Quantifizierer.
Input String: xfooxxxxxxfoo
Regex: .*?foo
Den obigen regex hat zwei Teile:
(i) '.*?' und
(ii) 'foo'
Schritt 1:
.*? = " (leer) - PASS (Match so wenig wie möglich, um den widerstrebenden Quantifizierer '.*?'. Index 0 haben " ist ein Spiel.)
foo = xfo - FAIL (Zelle 0,1,2 - ich.e-index zwischen 0 und 3)
Match gescheitert.
Schritt 2:
.*? = x - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 0 mit 'x' ist ein Spiel.)
foo = foo - PASS
Bericht MATCH
Schritt 3:
.*? = " (leer) - PASS (Match so wenig wie möglich, um den widerstrebenden Quantifizierer '.*?'. Index 4 haben " ist ein Spiel.)
foo = xxx - FAIL (Zelle 4,5,6 - ich.e-index zwischen 4 und 7)
Match gescheitert.
Schritt 4:
.*? = x - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 4.)
foo = xxx - FAIL (Zelle 5,6,7 - ich.e-index zwischen 5 und 8)
Match gescheitert.
Schritt 5:
.*? = xx - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 4 bis 5.)
foo = xxx - FAIL (Cell-6,7,8 - ich.e-index zwischen 6 und 9)
Match gescheitert.
Schritt 6:
.*? = xxx - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 4 bis 6.)
foo = xxx - FAIL (Zelle 7,8,9 - ich.e-index zwischen 7 und 10)
Match gescheitert.
Schritt 7:
.*? = xxxx - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 4 bis 7.)
foo = xxf - FAIL (Zelle 8,9,10 - ich.e-index zwischen 8 und 11)
Match gescheitert.
Schritt 8:
.*? = xxxxx - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 4 bis 8.)
foo = xfo - FAIL (Zelle 9,10,11 - ich.e-index zwischen 9 und 12)
Match gescheitert.
Schritt 9:
.*? = xxxxxx - PASS (Add-Zeichen, um den widerstrebenden Quantifizierer '.*?'. Zelle 4 bis 9.)
foo = foo - PASS (Zelle 10,11,12 - ich.e-index zwischen 10 und 13)
Bericht MATCH
Schritt 10:
.*? = " (leer) - PASS (Match so wenig wie möglich, um den widerstrebenden Quantifizierer '.*?'. Index 13 leer ist.)
foo = Keine Zeichen nach Links, um Spiel - FAIL (Es gibt nichts nach dem index 13 übereinstimmen)
Match gescheitert.
Ergebnis: 2 match(es)
Ich fand den text "xfoo" starting at index 0 and ending at index 4.
Ich fand den text "xxxxxxfoo" starting at index 4 and ending at index 13.
Besitzergreifend - Spiel so viel wie möglich, um die besitzergreifend quantifer und übereinstimmung mit dem gesamten regex. NICHT backtrack.
Input String: xfooxxxxxxfoo
Regex: .*+foo
Den obigen regex hat zwei Teile: '.*+' und 'foo'.
Schritt 1:
.*+ = xfooxxxxxxfoo - PASS (Spiel, so viel wie möglich, um die possessive Quantifizierer '.*')
foo = Keine Zeichen nach Links, um Spiel - FAIL (Nichts zum Spiel nach index 13)
Match gescheitert.
Hinweis: Backtracking ist nicht erlaubt.
Ergebnis: 0 match(es)
InformationsquelleAutor raka
Gierig: "match die längstmögliche Folge von Zeichen"
Zurückhaltend: "match der kürzest möglichen Folge von Zeichen"
Besitzergreifend: Das ist ein bisschen seltsam, wie es NICHT (im Gegensatz zu gierig und nur ungern) versuchen, eine übereinstimmung zu finden für den ganzen regex.
Übrigens: Keine regex-pattern-matcher Implementierung wird jemals verwenden backtracking. Alle real-life-pattern-matcher extrem schnell sind - fast unabhängig von der Komplexität des regulären Ausdrucks!
InformationsquelleAutor Tilo Koerbs
Gierig Quantifizierung beinhaltet pattern-matching mit allen übrigen nicht überprüfte Zeichen eines string während einer iteration. Nicht überprüfte Charaktere beginnen in der aktive Sequenz. Jedes mal, wenn ein Spiel nicht stattfindet, werden die Zeichen am Ende ist unter Quarantäne und die Prüfung wird erneut durchgeführt.
Wenn nur die führenden Bedingungen der regex-Muster zufrieden sind, die durch die aktive Sequenz ist, wird ein Versuch gemacht wird, zu validieren die Wirksamkeit der übrigen Bestimmungen gegen die Quarantäne. Wenn diese überprüfung erfolgreich ist, die erkannten Zeichen in der Quarantäne überprüft werden und die restlichen unvergleichliche Charaktere bleiben nicht überprüfte und werden verwendet, wenn der Prozess beginnt von neuem in der nächsten iteration.
Den Fluss der Zeichen ist von der aktiven Sequenz in die Quarantäne. Das resultierende Verhalten ist, wie viel von der ursprünglichen Sequenz enthalten ist in einem Spiel wie möglich.
Ungern Quantifizierung ist meist der gleiche wie gierig sich die Qualifikation-mit Ausnahme der Textfluss ist das Gegenteil, das heißt, Sie beginnen in der Quarantäne und fließen in die aktive Sequenz. Das resultierende Verhalten ist, wie wenig von der ursprünglichen Sequenz enthalten ist in einem Spiel wie möglich.
Besitzergreifend Quantifizierung keinen Quarantäne und enthält alles, was in einer festen aktive Sequenz.
InformationsquelleAutor Chad Philip Johnson