Zerlegt eine Zeichenkette in eine Liste, aber halten Sie die split-Muster

Derzeit bin ich splitten eines string-Muster, wie hier:

outcome_array=the_text.split(pattern_to_split_by)

Das problem ist, dass die Muster selbst, dass ich split durch, bekommt immer weggelassen.

Wie bekomme ich bei der split-Muster selbst?

Sie möchten, speichern Sie die beiden Zeichenfolgen , die aufgeteilt ein und unsplitted ist, dass das, was Sie suchen?
Wo wollen Sie beinhalten die Muster? innerhalb der Zeichenfolge?
ich will die split-Muster zurück, wie gut.. innerhalb der Zeichenfolge.
Könnte Sie geben beispielsweise input-und output?
Warum würden Sie sich 'split it ' split von 'here and '?
Eingabe = "split es hier und hier okay", splitter = 'hier'. würde die Ausbeute Ausgabe = ['split ', 'hier und ', 'hier okay]

InformationsquelleAutor Hermann Ingjaldsson | 2011-08-05

26

Vielen Dank an Mark Wilkins für inpsiration, aber hier ist eine kürzere bit-code, es zu tun:
```
irb(main):015:0> s = "split on the word on okay?"
=> "split on the word on okay?"
irb(main):016:0> b=[]; s.split(/(on)/).each_slice(2) { |s| b << s.join }; b
=> ["split on", " the word on", " okay?"]
```
oder:
```
s.split(/(on)/).each_slice(2).map(&:join)
```
Siehe weiter unten für eine Erklärung.

Hier ist, wie diese funktioniert. Zuerst teilten wir uns auf "auf", sondern wickeln Sie es in Klammern, um es in einer übereinstimmungsgruppe ist. Wenn es eine übereinstimmung gibt Gruppe im regulären Ausdruck übergeben split Ruby gehören, die Gruppe in der Ausgabe:
```
s.split(/(on)/)
# => ["split", "on", "the word", "on", "okay?"
```
Nun wollen wir verbinden jede Instanz von "on" mit der vorstehenden Zeichenfolge an. each_slice(2) hilft, indem Sie zwei Elemente zu einem Zeitpunkt auf seinen block. Lasst uns einfach aufrufen each_slice(2) zu sehen, welche Ergebnisse. Da each_slice, wenn Sie angerufen werden, ohne einen block, gibt einen enumerator, wir wenden to_a auf den Zähler, so dass wir sehen können, was der Enumerator wird enumerator über:
```
s.split(/(on)/).each_slice(2).to_a
# => [["split", "on"], ["the word", "on"], ["okay?"]]
```
Sind wir immer in der Nähe. Alles was wir jetzt tun müssen ist, verbinden Sie die Wörter zusammen. Und das bringt uns der Lösung oben. Ich werde es Auspacken in einzelne Linien zu machen, es leichter zu Folgen:
```
b = []
s.split(/(on)/).each_slice(2) do |s|
  b << s.join
end
b
# => ["split on", "the word on" "okay?"]
```
Aber gibt es eine nette Weise zu beseitigen, die temporäre b und verkürzen den code erheblich:
```
s.split(/(on)/).each_slice(2).map do |a|
  a.join
end
```
map übergibt jedes element der Eingabe-array, um den block; das Ergebnis der Sperrung wird das neue element an dieser position im Ausgabe-array. Bei MRI >= 1.8.7, kürzen kann man es noch mehr zu den äquivalenten:
```
s.split(/(on)/).each_slice(2).map(&:join)
```
- +1 Sehr schön. Ich mag Ruby; es ist kurz und doch lesbaren syntax.
- Es gibt jetzt eine längere Erklärung.
- die längere Erklärung ist sehr geschätzt. danke.
InformationsquelleAutor David Grayson
6

Könntest du einen regulären Ausdruck verwenden assertion suchen Sie den split-Punkt, ohne konsumieren des Eingangs. Unten wird eine positive look-behind assertion split nur nach 'on':
```
s = "split on the word on okay?"
s.split(/(?<=on)/)
=> ["split on", " the word on", " okay?"]
```
Oder eine positive look-ahead-split kurz vor 'auf':
```
s = "split on the word on okay?"
s.split(/(?=on)/)
=> ["split ", "on the word ", "on okay?"]
```
Mit so etwas wie diesem, möchten Sie vielleicht, um sicherzustellen, 'on' war nicht Teil eines größeren Wortes vorhanden (z.B. 'assertion'), und auch das entfernen von Leerzeichen am split:
```
"don't split on assertion".split(/(?<=\bon\b)\s*/)
=> ["don't split on", "assertion"]
```
- Sie können eine Kombination von diesen, um in der Mitte geteilt, zum Beispiel: "dieses><ist><es".split(/(?<=>)(?=<")/) => ["dies>", "<ist>", "< "es"]
InformationsquelleAutor fastryan
4

Wenn Sie ein Muster mit Gruppen, wird es wieder das Muster in den Ergebnissen als auch:
```
irb(main):007:0> "split it here and here okay".split(/(here) /)
=> ["split it", "here", "and", "here", "okay"]
```
Bearbeiten Die zusätzliche information angegeben, dass das Ziel ist, den Gegenstand, auf dem es aufgeteilt wurde, mit einer der Hälften der split-Objekte. Ich würde denken, es ist ein einfacher Weg, das zu tun, aber ich kenne es nicht und hatte noch keine Zeit, heute zu spielen. So in der Abwesenheit von der cleveren Lösung, im folgenden wird ein Weg, um brute-force-it. Verwenden Sie die split Methode, wie oben beschrieben, umfassen die geteilten Elemente im array. Dann das array Durchlaufen und verbinden jeden zweiten Eintrag (der ist per definition die split-Wert) mit dem vorherigen Eintrag.
```
s = "split on the word on and include on with previous"
a = s.split(/(on)/)

# iterate through and combine adjacent items together and store
# results in a second array
b = []
a.each_index{ |i|
   b << a[i] if i.even?
   b[b.length - 1] += a[i] if i.odd?
   }

print b
```
Ergebnisse, in:
```
["split on", " the word on", " and include on", " with previous"]
```
- was ist, dass " irb(main):007:0>', was?
- in diesem Fall hätte ich gerne 'hier' als ein Teil der entweder eine Zeichenkette ist, aufteilen.
- Es ist die interaktive Ruby-shell. Type "irb" an einer Eingabeaufforderung, und Sie können geben Sie Ruby-Befehle on-the-fly.
- Aus der hand ich weiß nicht, die syntax zu bekommen. Wenn Sie eine spezifische ist, denke ich, könnte es möglich sein, mit den entsprechenden regex. Allerdings könnte es einfacher sein, nur um "Iteration" über die Schnur und manuell gespalten. Wenn ich eine Zeit habe, werde ich darüber nachdenken müssen, etwas mehr. Interessantes problem.
InformationsquelleAutor Mark Wilkins

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.