string - concatenating - print format lua

¿Separar una cuerda en Lua?

Question

Necesito hacer una simple división de una cadena, pero no parece haber una función para esto, y la forma manual que probé no pareció funcionar. ¿Cómo lo haría?

Answer 1

Aquí está la función:

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

Llámalo así:

list=split(string_to_split,pattern_to_match)

p.ej:

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

Para más ir aquí:
http://lua-users.org/wiki/SplitJoin

Answer 2

Aquí está mi solución realmente simple. Use la función de coincidencia para capturar cadenas que contengan al menos UN carácter de CUALQUIER COSA que no sea el separador deseado. El separador es CUALQUIER espacio en blanco (% s en Lua) por defecto:

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

Answer 3

Así como string.gmatch encontrará patrones en una cadena, esta función encontrará las cosas entre patrones:

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

Por defecto, devuelve lo que está separado por espacios en blanco.

Answer 4

Debido a que hay más de una manera de despellejar a un gato, este es mi enfoque:

Código :

#!/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

Salida : 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. 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.

Explicación

La función gmatch funciona como un iterador, recupera todas las cadenas que coinciden con regex . La regex toma todos los caracteres hasta que encuentra un separador.

Answer 5

Me gusta esta solución corta

function split(s, delimiter)
    result = {};
    for match in (s..delimiter):gmatch("(.-)"..delimiter) do
        table.insert(result, match);
    end
    return result;
end

Answer 6

Muchas de estas respuestas solo aceptan separadores de un solo carácter, o no se ocupan bien de los bordes (p. Ej., Separadores vacíos), así que pensé en proporcionar una solución más definitiva.

Aquí hay dos funciones, gsplit y split , adaptadas del code en la extensión Scribunto MediaWiki , que se usa en wikis como Wikipedia. El código está licenciado bajo GPL v2 . Cambié los nombres de las variables y agregué los comentarios para hacer que el código sea un poco más fácil de entender, y también he cambiado el código para usar patrones regulares de Lua en lugar de los patrones de Scribunto para cadenas Unicode. El código original tiene casos de prueba here .

-- 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

Algunos ejemplos de la función split en uso:

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

Answer 7

Por favor, lea Splitting Strings :

Aquí hay varias formas de dividir una cadena en una lista de subcadenas, rompiendo la cadena original en las ocurrencias de algún separador (carácter, juego de caracteres o patrón). Esto se conoce comúnmente como una función de división de cuerdas [2].

Answer 8

Puedes usar este método:

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) 

Answer 9

Si está dividiendo una cadena en Lua, debe probar los métodos string.gmatch () o string.sub (). Utilice el método string.sub () si conoce el índice en el que desea dividir la cadena, o use el string.gmatch () si analizará la cadena para encontrar la ubicación donde dividir la cadena.

Ejemplo usando string.gmatch () de Lua 5.1 Manual de referencia :

 t = {}
 s = "from=world, to=Lua"
 for k, v in string.gmatch(s, "(%w+)=(%w+)") do
   t[k] = v
 end

Answer 10

Si solo quieres iterar sobre los tokens, esto es bastante claro:

line = "one, two and 3!"

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

Salida:

uno,

dos

y

3!

Breve explicación: el patrón "[^% s] +" coincide con cada cadena no vacía entre los caracteres espaciales.

Answer 11

Simplemente sentado en un delimitador

local str = ''one,two''
local regxEverythingExceptComma = ''([^,]+)''
for x in string.gmatch(str, regxEverythingExceptComma) do
    print(x)
end

Answer 12

Usé los ejemplos anteriores para crear mi propia función. Pero la pieza que faltaba para mí escapaba automáticamente de los personajes mágicos.

Aquí está mi contribución:

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