Ruby String divisé avec regex

C'est Ruby 1.8.7 mais doit être la même que pour la 1.9.x

Je suis en train de découper une chaîne par exemple:

a = "foo.bar.size.split('.').last"
# trying to split into ["foo", "bar","split('.')","last"]

Fondamentalement, le fractionnement des commandes qu'il représente, je suis en train de le faire avec des Regexp mais vous ne savez pas comment, l'idée était d'utiliser les regexp

a.split(/[a-z\(\)](\.)[a-z\(\)]/)

Ici pour essayer de groupe (\.) à split avec, mais cela ne semble pas être la bonne approche.

source d'informationauteur Haris Krajina

24

Je pense que ce serait-il le faire:
```
a.split(/\.(?=[\w])/)
```
Je ne sais pas combien vous en savez sur les regex, mais le (?=[\w]) est une anticipation qui dit que "seul match à la dot si le caractère suivant est une lettre type de personnage". Une antémémoire ne sera pas réellement saisir le texte qu'elle correspond. C'est juste "look". Ainsi, le résultat est exactement ce que vous cherchez:
```
> a.split(/\.(?=[\w])/)
 => ["foo", "bar", "size", "split('.')", "last"] 
```

J'ai peur que les expressions régulières ne vous prendra pas très loin. Considérez par exemple les expressions suivantes (qui sont également valables Ruby)

"(foo.bar.size.split( '.' )).last"
"(foo.bar.size.split '.').last"
"(foo.bar.size.split '( . ) . .(). .').last"

Le problème, c'est que la liste des appels est en fait un arbre d'appels. La solution la plus simple dans la vue est probablement d'utiliser un Rubis et l'analyseur de transformer l'arbre d'analyse en fonction de vos besoins (dans cet exemple, nous sommes la descente récursive dans l'arbre d'appel, la collecte des appels dans une liste):

# gem install ruby_parser
# gem install awesome_print
require 'ruby_parser'
require 'ap'

def calls_as_list code
    tree = RubyParser.new.parse(code)

    t = tree
    calls = []

    while t
        # gather arguments if present
        args = nil
        if t[3][0] == :arglist
            args = t[3][1..-1].to_a
        end
        # append all information to our list
        calls << [t[2].to_s, args]
        # descend to next call
        t = t[1]
    end

    calls.reverse
end

p calls_as_list "foo.bar.size.split('.').last"
#=> [["foo", []], ["bar", []], ["size", []], ["split", [[:str, "."]]], ["last", []]]
p calls_as_list "puts 3, 4"
#=> [["puts", [[:lit, 3], [:lit, 4]]]]

Et de montrer l'arbre d'analyse de n'importe quelle entrée:

ap RubyParser.new.parse("puts 3, 4")

3
```
a = "foo.bar.size.split('.').last"
p a.split(/(?<!')\.(?!')/)

#=> ["foo", "bar", "size", "split('.')", "last"]
```
Vous êtes à la recherche pour l'Anticipation et les assertions arrières.
http://www.regular-expressions.info/lookaround.html
2

ici je n'ai pas de ruby env. J'ai essayé avec python re.split().
```
In : re.split("(?<!')\.(?!')",a)
Out: ['foo', 'bar', 'size', "split('.')", 'last']
```
l'expression régulière ci-dessus a d'anticipation négatif ET lookbehind, assurez-vous que le "point" de entre guillemets simples ne fonctionnent pas comme séparateur.

bien sûr, pour l'exemple donné par vous, l'un des lookbehind ou d'anticipation n'est suffisante. vous pouvez choisir la bonne voie pour votre condition.

Vous devez vous connecter pour publier un commentaire.