Modo migliore per progettare questa funzione?

Question

Ho una funzione che consiste principalmente in una grande quantità di chiamate (50+) a un'altra funzione che inserisce i dati in un array, con la logica qua e là che detta varie condizioni per inserire vari elementi nell'array (più un po ' alla fine che scrive il contenuto dell'array in un file). Mi chiedo se non c'è un modo migliore per fare questa funzione; Suppongo che potrei iniziare con la suddivisione logica dei set di comandi di inserimento dell'array nelle loro stesse funzioni, ma mi chiedo se c'è altro che posso fare. C'è?

Esempio:

function buildTable(fileName, data)
    local dataToWrite = {}
    table.insert(datTWrite, {
        Type = "type1",
        Key = "someKey",
        Value = data.SomethingInteresting
    })
    --and so on ad nauseum with an occasional but of actual logic to spice things up
    dataWriter:open(fileName .. ".bla")
    dataWriter:batchWrite(dataToWrite)
    dataWriter:close()
end

In questo caso, dataWriter è un'istanza di una classe predefinita che gestisce il processo di scrittura su un file.

Answer 1

La buona notizia è che non sei entrato direttamente nella comune pessimizzazione Lua di concatenare le stringhe in un buffer in un ciclo per creare il tuo output.

Vorrei scrivere il tuo campione in questo modo:

function buildTable(fileName, data)
    local t = {}
    t[#t+1] = {
        Type = "type1",
        Key = "someKey",
        Value = data.SomethingInteresting
    }
    --and so on ad nauseum with an occasional but of actual logic to spice things up
    dataWriter:open(fileName .. ".bla")
    dataWriter:batchWrite(t)
    dataWriter:close()
end

che ha il piccolo vantaggio di non usare un nome lungo incline alla digitazione per la tabella temporanea e usa il linguaggio t [# t + 1] per estendere la parte dell'array che dovrebbe essere più veloce di chiamando table.insert () .

Altrimenti, la fonte di eventuali miglioramenti strutturali sarà nel "e così via fino alla nausea". parte del codice.

• Cerca lì i calcoli e i frammenti comuni che possono essere raccolti nelle funzioni locali.
• Ricorda che puoi annidare le definizioni delle funzioni, quindi le funzioni di supporto possono essere limitate nell'ambito al luogo in cui vengono utilizzate.
• Cerca una logica troppo intelligente e riscrivila per essere sensibile a chiunque dovrà mantenerla l'anno prossimo.
• wiki: Lua Design Patterns
• wiki: Zen Of Lua
• wiki: Suggerimenti per l'ottimizzazione
• wiki: Codice Lua di profilazione

Soprattutto, attenzione all'ottimizzazione prematura. Confronta ciò che hai ora come punto di confronto e usalo come guida per trovare i colli di bottiglia delle prestazioni.

Answer 2

Di " e così via fino alla nausea con una logica occasionale ma reale per rendere le cose più intense " Presumo che tu intenda che hai molti blocchi come:

table.insert(datTWrite, {
    Type = "type1",
    Key = "someKey",
    Value = data.SomethingInteresting
})

L'unico aspetto di questo che è unico per la funzione è la tabella da riempire e l'oggetto data . La mia personale "migliore pratica" sarebbe estrarre tutto questo in una tabella separata come:

local entries = {
    {
        Type = "type1",
        Key = "someKey",
        ValueField = "SomethingInteresting",
    },
    {
        Type = "type2",
        Key = "someOtherKey",
        ValueField = "SomethingElse",
    },
    -- etc.
}

Questa tabella deve essere globale o in un ambito esterno a quello in cui è definita la funzione. Ora puoi riconfigurare più facilmente le voci senza apportare modifiche alla funzione che fa il lavoro effettivo. La funzione stessa è notevolmente semplificata ripetendo le voci in questo modo:

for i, entry in ipairs(entries) do
    table.insert(datTWrite, {
        Type = entry.Type,
        Key = entry.Key,
        Value = data[entry.ValueField]
    })
end

Per il "occasionale" logica, ogni voce potrebbe avere una funzione opzionale per darti informazioni interessanti nel ciclo. Per esempio:.

for i, entry in ipairs(entries) do
    if not entry.CheckSomething or entry.CheckSomething() then
        table.insert(datTWrite, {
            Type = entry.Type,
            Key = entry.Key,
            Value = data[entry.ValueField]
        })
    end
end

In alternativa, potresti anche consentire alle singole voci nella tabella di ESSERE funzioni se hai bisogno di maggiore personalizzazione. Ogni funzione di immissione restituisce una tabella (o meno).

for i, entry in ipairs(entries) do
    if type(entry) == "function" then
        local newEntry = entry()
        if newEntry then
            table.insert(datTWrite, newEntry)
        end
    else
        table.insert(datTWrite, {
            Type = entry.Type,
            Key = entry.Key,
            Value = data[entry.ValueField]
        })
    end
end

Answer 3

Senza nulla di specifico da fare, proverei a cercare odori di codice e guarda come confronta la tua funzione. Dai suoni delle cose, probabilmente c'è molto da fare per te. Esistono blocchi di codice simile / copiato isolati da una logica condizionale diversa? Anelli o condizionali nidificati? Questi sono alcuni semplici punti di partenza quando si cerca di dividere una grande funzione in parti.