Chaîne fendue dans Lua?

160

J'ai besoin de faire un simple fractionnement d'une chaîne, mais il ne semble pas y avoir de fonction pour cela, et la méthode manuelle que j'ai testée ne semble pas fonctionner. Comment le ferais-je?

RCIX
la source
S'il vous plaît voir Splitting Strings
Andrew Hare

Réponses:

96

Voici ma solution vraiment simple. Utiliser la fonction de gmatch à des chaînes de capture qui contiennent au moins un caractère de quoi que ce soit autre que le séparateur désiré. Le séparateur est ** n'importe quel * espace (% s en Lua) par défaut:

function mysplit (inputstr, sep)
        if sep == nil then
                sep = "%s"
        end
        local t={}
        for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
                table.insert(t, str)
        end
        return t
end

.

Adrian Mole
la source
1
Merci. Juste ce que je cherchais.
Nicholas
3
Wow, la première réponse à toute cette question qui a en fait une fonction qui renvoie une table. Notez cependant que t et moi avons besoin du modificateur "local", car vous écrasez les globaux. :)
cib
3
Comme d'autres l'ont souligné, vous pouvez simplifier cela en utilisant table.insert (t, str) au lieu de t [i] = str et alors vous n'avez pas besoin de i = 1 ou i = i +1
James Newton
2
Ne fonctionne pas si la chaîne contient des valeurs vides, par exemple. 'foo,,bar'. Vous obtenez {'foo','bar'}au lieu de{'foo', '', 'bar'}
andras
5
C'est vrai. La prochaine version fonctionnera dans ce cas: function split(inputstr, sep) sep=sep or '%s' local t={} for field,s in string.gmatch(inputstr, "([^"..sep.."]*)("..sep.."?)") do table.insert(t,field) if s=="" then return t end end end
bart
33

Si vous divisez une chaîne dans Lua, vous devriez essayer les méthodes string.gmatch () ou string.sub (). Utilisez la méthode string.sub () si vous connaissez l'index dans lequel vous souhaitez diviser la chaîne, ou utilisez la chaîne string.gmatch () si vous analyserez la chaîne pour trouver l'emplacement à partir duquel diviser la chaîne.

Exemple utilisant string.gmatch () du manuel de référence de Lua 5.1 :

 t = {}
 s = "from=world, to=Lua"
 for k, v in string.gmatch(s, "(%w+)=(%w+)") do
   t[k] = v
 end
gwell
la source
J'ai quand même "emprunté" une implémentation à cette page utilisateurs lua
RCIX
24

Si vous souhaitez simplement parcourir les jetons, c'est plutôt chouette:

line = "one, two and 3!"

for token in string.gmatch(line, "[^%s]+") do
   print(token)
end

Production:

une,

deux

et

3!

Brève explication: le motif "[^% s] +" correspond à toutes les chaînes non vides entre les espaces.

Hugo
la source
2
Le modèle %Sest égal à celui que vous avez mentionné, tout comme %Sla négation de %s, comme l' %Dest la négation de %d. De plus, %west égal à [A-Za-z0-9_](d'autres caractères peuvent être pris en charge en fonction de vos paramètres régionaux).
Lars Gyrup Brink Nielsen
14

Tout comme string.gmatchtrouvera des motifs dans une chaîne, cette fonction trouvera les choses entre les motifs:

function string:split(pat)
  pat = pat or '%s+'
  local st, g = 1, self:gmatch("()("..pat..")")
  local function getter(segs, seps, sep, cap1, ...)
    st = sep and seps + #sep
    return self:sub(segs, (seps or 0) - 1), cap1 or sep, ...
  end
  return function() if st then return getter(st, g()) end end
end

Par défaut, il renvoie tout ce qui est séparé par des espaces.

Norman Ramsey
la source
6
+1. Note à tous les autres débutants de Lua: cela renvoie un itérateur, et «entre les motifs» inclut le début et la fin de la chaîne. (En tant que débutant, je devais l'essayer pour comprendre ces choses.)
Darius Bacon
12

Voici la fonction:

function split(pString, pPattern)
   local Table = {}  -- NOTE: use {n = 0} in Lua-5.0
   local fpat = "(.-)" .. pPattern
   local last_end = 1
   local s, e, cap = pString:find(fpat, 1)
   while s do
      if s ~= 1 or cap ~= "" then
     table.insert(Table,cap)
      end
      last_end = e+1
      s, e, cap = pString:find(fpat, last_end)
   end
   if last_end <= #pString then
      cap = pString:sub(last_end)
      table.insert(Table, cap)
   end
   return Table
end

Appelez ça comme:

list=split(string_to_split,pattern_to_match)

par exemple:

list=split("1:2:3:4","\:")


Pour en savoir plus, rendez-vous ici:
http://lua-users.org/wiki/SplitJoin

Faisal Hanif
la source
7

J'aime cette solution courte

function split(s, delimiter)
    result = {};
    for match in (s..delimiter):gmatch("(.-)"..delimiter) do
        table.insert(result, match);
    end
    return result;
end
Ivo Beckers
la source
C'est mon préféré, car il est si court et simple. Je ne comprends pas très bien ce qui se passe, quelqu'un pourrait-il m'expliquer?
hexagonest
2
Cela échoue lors de l'utilisation du point comme délimiteur (ou potentiellement tout autre caractère magique de motif)
TurboHz
6

Parce qu'il y a plus d'une façon d'écorcher un chat, voici mon approche:

Code :

#!/usr/bin/env lua

local content = [=[
Lorem ipsum dolor sit amet, consectetur adipisicing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna 
aliqua. Ut enim ad minim veniam, quis nostrud exercitation 
ullamco laboris nisi ut aliquip ex ea commodo consequat.
]=]

local function split(str, sep)
   local result = {}
   local regex = ("([^%s]+)"):format(sep)
   for each in str:gmatch(regex) do
      table.insert(result, each)
   end
   return result
end

local lines = split(content, "\n")
for _,line in ipairs(lines) do
   print(line)
end

Sortie : Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

Explication :

La gmatchfonction fonctionne comme un itérateur, elle récupère toutes les chaînes qui correspondent regex. Le regexprend tous les caractères jusqu'à ce qu'il trouve un séparateur.

Diego Pino
la source
5

Vous pouvez utiliser cette méthode:

function string:split(delimiter)
  local result = { }
  local from  = 1
  local delim_from, delim_to = string.find( self, delimiter, from  )
  while delim_from do
    table.insert( result, string.sub( self, from , delim_from-1 ) )
    from  = delim_to + 1
    delim_from, delim_to = string.find( self, delimiter, from  )
  end
  table.insert( result, string.sub( self, from  ) )
  return result
end

delimiter = string.split(stringtodelimite,pattern) 
krsk9999
la source
5

Beaucoup de ces réponses n'acceptent que les séparateurs à un seul caractère, ou ne traitent pas bien les cas de bord (par exemple, les séparateurs vides), j'ai donc pensé que je fournirais une solution plus définitive.

Voici deux fonctions, gsplitet split, adaptées du code dans le extension Scribunto MediaWiki , qui est utilisée sur des wikis comme Wikipedia. Le code est sous licence GPL v2 . J'ai changé les noms des variables et ajouté des commentaires pour rendre le code un peu plus facile à comprendre, et j'ai également changé le code pour utiliser des modèles de chaînes Lua réguliers au lieu des modèles de Scribunto pour les chaînes Unicode. Le code d'origine a des cas de test ici .

-- gsplit: iterate over substrings in a string separated by a pattern
-- 
-- Parameters:
-- text (string)    - the string to iterate over
-- pattern (string) - the separator pattern
-- plain (boolean)  - if true (or truthy), pattern is interpreted as a plain
--                    string, not a Lua pattern
-- 
-- Returns: iterator
--
-- Usage:
-- for substr in gsplit(text, pattern, plain) do
--   doSomething(substr)
-- end
local function gsplit(text, pattern, plain)
  local splitStart, length = 1, #text
  return function ()
    if splitStart then
      local sepStart, sepEnd = string.find(text, pattern, splitStart, plain)
      local ret
      if not sepStart then
        ret = string.sub(text, splitStart)
        splitStart = nil
      elseif sepEnd < sepStart then
        -- Empty separator!
        ret = string.sub(text, splitStart, sepStart)
        if sepStart < length then
          splitStart = sepStart + 1
        else
          splitStart = nil
        end
      else
        ret = sepStart > splitStart and string.sub(text, splitStart, sepStart - 1) or ''
        splitStart = sepEnd + 1
      end
      return ret
    end
  end
end

-- split: split a string into substrings separated by a pattern.
-- 
-- Parameters:
-- text (string)    - the string to iterate over
-- pattern (string) - the separator pattern
-- plain (boolean)  - if true (or truthy), pattern is interpreted as a plain
--                    string, not a Lua pattern
-- 
-- Returns: table (a sequence table containing the substrings)
local function split(text, pattern, plain)
  local ret = {}
  for match in gsplit(text, pattern, plain) do
    table.insert(ret, match)
  end
  return ret
end

Quelques exemples de la splitfonction utilisée:

local function printSequence(t)
  print(unpack(t))
end

printSequence(split('foo, bar,baz', ',%s*'))       -- foo     bar     baz
printSequence(split('foo, bar,baz', ',%s*', true)) -- foo, bar,baz
printSequence(split('foo', ''))                    -- f       o       o
Jack Taylor
la source
5

une voie que l'on ne voit pas chez les autres

function str_split(str, sep)
    if sep == nil then
        sep = '%s'
    end 

    local res = {}
    local func = function(w)
        table.insert(res, w)
    end 

    string.gsub(str, '[^'..sep..']+', func)
    return res 
end
Hohenheim
la source
4

Assis simplement sur un délimiteur

local str = 'one,two'
local regxEverythingExceptComma = '([^,]+)'
for x in string.gmatch(str, regxEverythingExceptComma) do
    print(x)
end
Jérôme Anthony
la source
3

J'ai utilisé les exemples ci-dessus pour créer ma propre fonction. Mais la pièce manquante pour moi était d'échapper automatiquement aux personnages magiques.

Voici ma contribution:

function split(text, delim)
    -- returns an array of fields based on text and delimiter (one character only)
    local result = {}
    local magic = "().%+-*?[]^$"

    if delim == nil then
        delim = "%s"
    elseif string.find(delim, magic, 1, true) then
        -- escape magic
        delim = "%"..delim
    end

    local pattern = "[^"..delim.."]+"
    for w in string.gmatch(text, pattern) do
        table.insert(result, w)
    end
    return result
end
intrépide
la source
C'était aussi mon gros problème. Cela fonctionne très bien avec des personnages magiques, gentil
Andrew White
1

Vous pouvez utiliser la bibliothèque penlight . Cela a une fonction pour diviser la chaîne en utilisant un délimiteur qui génère une liste.

Il a implémenté de nombreuses fonctions dont nous pourrions avoir besoin lors de la programmation et manquantes dans Lua.

Voici l'exemple pour l'utiliser.

> 
> stringx = require "pl.stringx"
> 
> str = "welcome to the world of lua"
> 
> arr = stringx.split(str, " ")
> 
> arr
{welcome,to,the,world,of,lua}
> 

la source
0

Selon le cas d'utilisation, cela peut être utile. Il coupe tout le texte de chaque côté des drapeaux:

b = "This is a string used for testing"

--Removes unwanted text
c = (b:match("a([^/]+)used"))

print (c)

Production:

string
verdure
la source
0

Super tard à cette question, mais au cas où quelqu'un voudrait une version qui gère le nombre de fractionnements que vous souhaitez obtenir .....

-- Split a string into a table using a delimiter and a limit
string.split = function(str, pat, limit)
  local t = {}
  local fpat = "(.-)" .. pat
  local last_end = 1
  local s, e, cap = str:find(fpat, 1)
  while s do
    if s ~= 1 or cap ~= "" then
      table.insert(t, cap)
    end

    last_end = e+1
    s, e, cap = str:find(fpat, last_end)

    if limit ~= nil and limit <= #t then
      break
    end
  end

  if last_end <= #str then
    cap = str:sub(last_end)
    table.insert(t, cap)
  end

  return t
end
Benjamin Vison
la source
0

Si vous programmez en Lua, vous n'avez pas de chance ici. Lua est LE langage de programmation qui se trouve être notoirement tristement célèbre parce que ses auteurs n'ont jamais implémenté "la" fonction de fractionnement dans la bibliothèque standard, et ont plutôt écrit 16 écrans pleins d'explications et d'excuses boiteuses pour expliquer pourquoi ils ne l'ont pas fait et ne le seraient pas, entrecoupé de nombreux exemples à moitié fonctionnels qui sont pratiquement garantis de fonctionner pour presque tout le monde mais qui se cassent dans votre cas du coin. C'est juste l'état de l'art de Lua, et tous ceux qui programment en Lua finissent simplement par serrer les dents et itérer sur les personnages. Il existe de nombreuses solutions qui sont parfois meilleures, mais exactement aucune solution qui est sûrement meilleure.

Szczepan Hołyszewski
la source