Versuch, einen Nullwert in einem Skript zu indexieren

Question

Ich versuche, ein Lua-Skript zu schreiben, um beim Modifizieren eines Spiels zu helfen, und es bricht immer wieder in einer bestimmten Zeile einer meiner Assistentenbibliotheken.

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:

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 

Testcode:

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

Warum habe ich diesen Fehler, wenn ich eine gültige Tabelle eindeutig an odfwriter.write übergebe?

Answer 1

Mindestens in Ihrem Testcode, haben Sie einen Tippfehler:

line1data ~= line1Data 

Sie haben auch einen Tippfehler in ioWriter.lua in der Nähe Methode:

function ioWriter:close(self) 

sollte

function ioWriter:close() 

Answer 2

Sie haben nicht explizit überprüft, dass alles implementiert odf:open() erfolgreich war. Meine Sorge ist, dass es so aussieht, als ob die gesamte Flusskontrolle in odf:open() davon ausgeht, dass alles erfolgreich war. Ist es möglich, dass es nicht, und als Folge, dass in der angegebenen Zeile der Fehler durch den Versuch verursacht wird, self.writer mit nil indexieren?

Es könnte nil im Gegensatz zu false sein, wenn odfWriter:open() den Konstruktor self.writer = ioWriter() zum Beispiel nicht erfolgreich ausgeführt hat. Ich bin kein regelmäßiger Benutzer der Schleife, also könnte ich den falschen Baum bellen, aber ...

Wenn das passierte, wäre es leicht, eine Nachricht zu erhalten, die verwirrt ist, welcher Index fehlerhaft war .

Vielleicht Anrufe zu assert() in ein paar ausgewählte Spots fallen würde produktiv sein.