Tenter d'indexer une valeur nulle dans un script

Question

J'essaye d'écrire un script lua pour aider à modifier un jeu, et il continue de se casser sur une ligne particulière d'une de mes bibliothèques auxiliaires.

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 

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

Pourquoi ai-je cette erreur lorsque je passe clairement une table valide à odfwriter.write?

Answer 1

au moins dans votre code de test, vous avez une faute de frappe:

line1data ~= line1Data 

Vous avez également une faute de frappe dans ioWriter.lua dans la méthode close:

function ioWriter:close(self) 

devrait être

function ioWriter:close() 

Answer 2

Vous n'avez pas vérifié explicitement que tout ce qui implémente odf:open() a réussi. Mon inquiétude est qu'il semble que tout le contrôle de flux de odf:open() semble supposer que tout a réussi. Est-il possible que ce ne soit pas le cas et que, par conséquent, à la ligne indiquée, l'erreur soit causée par la tentative d'indexer self.writer contenant nil?

Il pourrait être nil par opposition à false si odfWriter:open() n'a pas réussi à exécuter le constructeur self.writer = ioWriter() par exemple. Je ne suis pas un utilisateur régulier de la boucle, donc je pourrais aboyer le mauvais arbre, mais ...

Si cela se produisait, il serait facile d'obtenir un message qui est confus au sujet de l'index qui était en faute . Peut-être laisser tomber les appels à assert() dans quelques endroits de choix serait productif.