Extrait une sous-chaîne d'une chaîne de caractères en Ruby à l'aide d'une expression régulière

Comment puis-je extraire une sous-chaîne dans une chaîne de caractères en Ruby?

Exemple:

String1 = "<name> <substring>"

Je veux extraire substring de String1 (c'est à dire tout à l'intérieur de la dernière occurrence de < et >).

InformationsquelleAutor Madhusudhan | 2010-11-06
  1. 115
    String1.scan(/<([^>]*)>/).last.first

    scan crée un tableau qui, pour chaque <item> dans String1 contient le texte entre les < et la > dans un élément de tableau (parce que lorsqu'il est utilisé avec une regex contenant la capture de groupes, de numérisation crée un tableau contenant les captures pour chaque match). last vous donne la dernière de ces tableaux et first vous donne ensuite la chaîne en elle.

    InformationsquelleAutor sepp2k
  2. 286
    "<name> <substring>"[/.*<([^>]*)/,1]
=> "substring"

    Pas besoin d'utiliser scan, si nous avons besoin d'un seul résultat.

    Pas besoin d'utiliser match, lorsque nous avons String[regexp,#].

    Voir: http://ruby-doc.org/core/String.html#method-i-5B-5D

    Remarque: str[regexp, capture] → new_str or nil

    • Pas besoin de discréditer les autres parfaitement valide (et pourrait-on me donner son avis, plus lisible) solutions.
    • si elles sont de meilleure qualité, s'il vous plaît, argument. Par exemple, sepp2k la solution est plus souple, et c'est pourquoi j'ai fait if we need only one result dans ma solution. Et match()[] est plus lent, parce que c'est deux méthodes au lieu d'un.
    • Ouais... disons que cette fonction soit 2 fois plus lent... et de leurs fonctions enfant trop... et les parents aussi... ils sont tellement rapide, que nous ne serons jamais d'avis... prennent une règle ne pas avoir peur de faire une fonction 2 fois plus lent!... quoi? notre chaîne de 10 fonctions sont maintenant plus lent en 1024 fois? fantastique...
    • C'est le plus rapide de toutes les méthodes présentées, mais même la méthode la plus lente prend seulement 4,5 microsecondes sur ma machine. Je n'aime pas spéculer pourquoi cette méthode est plus rapide. Dans la performance, la spéculation est inutile. Seuls les comptes de mesure.
    • Je trouve cette solution plus simple et au point (depuis que je suis de nouveau à Ruby). Merci.
    • La lisibilité peut l'emporter sur de minuscules différences de performances lors de l'examen la réussite de l'ensemble du produit et de l'équipe, de sorte coreyward fait un commentaire valide. Cela dit, je pense que string[regex] peut être tout aussi lisible dans ce scénario, c'est ce que j'utilise personnellement.
    • Avez-vous l'esprit en ajoutant depuis quelle version de ruby cette méthode est-elle valable? Je veux utiliser cette solution, mais maintenant j'ai besoin d'aller recherche de ce que la version ou acheter introduit string[regex] (pour autant que je sache il a toujours été là). Edit: je ne peux que trouver de l'api ruby docs > 2.0.0 où cette méthode est toujours valable, donc c'est probablement pas un problème pour l'utiliser: ruby-doc.org/core-2.0.0/String.html#method-i-5B-5D
    • si vous me demandez, alors jetez un oeil à la réponse d'horodatage -- ce code était valable en novembre 2010.
    • Ce n'est pas quelque chose que j'ai remarqué avant, mais bien sûr, il doit être valide pendant au moins aussi longtemps. Merci pour la réponse à cette question qui m'a aidé à résoudre mon problème.

    InformationsquelleAutor Nakilon
  3. 20

    Vous pouvez utiliser une expression régulière pour que assez facilement...

    Permettant espaces autour de la parole (mais pas les garder):

    str.match(/< ?([^>]+) ?>\Z/)[1]

    Ou sans les espaces autorisés: 

    str.match(/<([^>]+)>\Z/)[1]
    • Je ne suis pas sûr que la dernière <> doit être la dernière chose dans la chaîne. Si par exemple la chaîne de foo <bar> baz est autorisé (et censé donner le résultat bar), cela ne fonctionnera pas.
    • Je suis basé sur l'exemple de la chaîne qu'il avait fournis.
    InformationsquelleAutor coreyward
  4. 9

    Ici est un peu plus souple en utilisant l'approche de match méthode. Avec cela, vous pouvez extraire plus d'une corde:

    s = "<ants> <pants>"
matchdata = s.match(/<([^>]*)> <([^>]*)>/)

# Use 'captures' to get an array of the captures
matchdata.captures   # ["ants","pants"]

# Or use raw indices
matchdata[0]   # whole regex match: "<ants> <pants>"
matchdata[1]   # first capture: "ants"
matchdata[2]   # second capture: "pants"
    InformationsquelleAutor Grant Birchmeier
  5. 2

    Un simple scan serait: 

    String1.scan(/<(\S+)>/).last
    InformationsquelleAutor Navid