Próba indeksu wartości zerowej w skrypcie

Question

Próbuję napisać skrypt lua, aby pomóc w modyfikacji gry, i nadal łamie się na jednej linii jednej z moich bibliotek asystenta.

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

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 

Test:

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

Dlaczego pojawia się ten błąd, gdy wyraźnie przekazuję poprawną tabelę do odfwriter.write?

Answer 1

Przynajmniej w kodzie testowym, masz literówkę:

line1data ~= line1Data 

masz również literówkę w ioWriter.lua w ścisłej metody:

function ioWriter:close(self) 

powinny być

function ioWriter:close() 

Answer 2

Nie zaznaczyliście wyraźnie, że wszystko, co wykonano, to odf:open(). Obawiam się, że wygląda na to, że cała kontrola przepływu w odf:open() wydaje się zakładać, że wszystko się udało. Czy to możliwe, że tak się nie stało, i że w linii wskazanej błąd jest spowodowany przez próbę indeksowania self.writer zawierającą nil?

Może to być nil w przeciwieństwie do false, jeśli odfWriter:open() nie zakończyło się pomyślnie na przykład konstruktorem self.writer = ioWriter(). Nie jestem zwykłym użytkownikiem pętli, więc mogę szczekać na niewłaściwe drzewo, ale ...

Gdyby tak się stało, łatwo byłoby uzyskać komunikat, który jest niejasny co do tego, który indeks był wadliwy .

Być może spadek liczby połączeń do assert() w kilku miejscach może być opłacalny.