Tentativo di indicizzare un valore nullo in uno script

Question

Sto provando a scrivere uno script lua per assistere nella modifica di un gioco e continua a interrompersi su una riga specifica di una delle mie librerie di aiuto.

odfWriter.lua:

require 'loopsetup' 
require 'ioWriter' 
local open = {} 
odfWriter = class{ 
    writer = false 
} 
odfWriter[open] = false 

function odfWriter:open(name) 
    if not self[open] then 
     self.writer = ioWriter() 
     self.writer:open(name) 
     self[open] = true 
    else 
     error("tried to open an already open writer") 
    end 
end 

function odfWriter:write(args) 
    self.writer:write(args.Key .. " = ") --<-- error is here, when trying to access args 
    if args.Type == "seqstrings" then 
     for k,v in pairs(args.Value) do 
      self.writer:write("\"" .. v .. "\" ") 
     end 
    elseif args.Type == "string" then 
     self.writer:write("\"" .. args.Value .. "\"") 
    elseif args.Type == "seqnumbers" then 
     for k,v in pairs(args.Value) do 
      self.writer:write(tostring(v) .. " ") 
     end 
    elseif args.Type == "number" then 
     self.writer:write(tostring(args.Value)) 
    elseif args.Type == "boolean" then 
     if args.Value == true then 
      self.writer:write("1") 
     elseif args.Value == false then 
      self.writer:write("0") 
     end 
    end 
    self.writer:write("\n") 
end 
function odfWriter:close() 
    if self[open] then 
     self.writer:close() 
     self.writer = false 
     self[open] = false 
    else 
     error("tried to close an already closed writer") 
    end 
end 

loopSetup.lua

----------------------------------------------------------------------- 
-- file  : loopsetup.lua 
-- description : provides global access to all of the (known) members 
--    of the loop.simple code (for easier access) 
----------------------------------------------------------------------- 
require 'loop.simple' 
class = loop.simple.class 
classof = loop.simple.classof 
initclass = loop.simple.initclass 
instanceof = loop.simple.instanceof 
isclass = loop.simple.isclass 
memberof = loop.simple.memberof 
members = loop.simple.members 
new = loop.simple.new 
rawnew = loop.simple.rawnew 
subclassof = loop.simple.subclassof 
superclass = loop.simple.superclass 

ioWriter.lua: codice

local loaded = require('loopsetup') 
assert(loaded, 'loopsetup not loaded') 
local open = {} 
ioWriter = class{ 
    stream = false 
} 
ioWriter[open] = false 
function ioWriter:open(name) 
    if not self[open] then 
     self.stream = io.open(name, "w") 
     self[open] = true 
    else 
     error("attempted to open an already open writer") 
    end 
end 
function ioWriter:write(str) 
    self.stream:write(str) 
end 
function ioWriter:writeLine(str) 
    self.stream:write(str .. '\n') 
end 
function ioWriter:close(self) 
    if self[open] then 
     self.stream:flush() 
     self.stream:close() 
     self.stream = false 
     self[open] = false 
    else 
     error("attempted to close an already closed writer") 
    end 
end 

prova:

require 'loopsetup' 
require 'odfWriter' 
local odf = odfWriter() 
odf:open('test.odf') 
local line1Data = { 
    Type = "seqstrings", 
    Key = "engineTargetHardpoints", 
    Value = {"hp01", "hp02", "hp03"} 
} 
odf:write(line1data) 
odf:close() 

Perché ho questo errore quando sto passando in modo chiaro una tabella valida a odfwriter.write?

Answer 1

Almeno nel codice di prova, voi hanno un errore di battitura:

line1data ~= line1Data 

Hai anche un errore di battitura nel ioWriter.lua nel metodo close:

function ioWriter:close(self) 

dovrebbe essere

function ioWriter:close() 

Answer 2

Non è stato verificato in modo esplicito che tutto ciò che implementa odf:open() è riuscito. La mia preoccupazione è che sembra che l'intero controllo del flusso in odf:open() sembra presupporre che tutto sia andato a buon fine. E 'possibile che non sia così, e come risultato che alla linea indicata l'errore è causato dal tentativo di indicizzare self.writer contenente nil?

Potrebbe essere nil al contrario di false se odfWriter:open() non è stato eseguito con successo il costruttore self.writer = ioWriter() per esempio. Non sono un utente abituale del ciclo, quindi potrei essere abbaiare sull'albero sbagliato, ma ...

Se ciò accadesse, sarebbe facile ottenere un messaggio confuso su quale indice era in difetto .

Forse ridurre le chiamate a assert() in alcuni punti di scelta sarebbe produttivo.