×

Langue

Fermer
Atelier 801
  • Forums
  • Dev Tracker
  • Connexion
    • English Français
      Português do Brasil Español
      Türkçe Polski
      Magyar Română
      العربية Skandinavisk
      Nederlands Deutsch
      Bahasa Indonesia Русский
      中文 Filipino
      Lietuvių kalba 日本語
      Suomi עברית
      Italiano Česky
      Hrvatski Slovensky
      Български Latviešu
      Estonian
  • Langue
  • Forums
  • /
  • Transformice
  • /
  • Modules
  • /
  • Guías y Tutoriales
  • /
  • [Tutorial] Metatablas y metamétodos
[Tutorial] Metatablas y metamétodos
Yuir
« Héliaste »
1472583300000
    • Yuir#2211
    • Profil
    • Derniers messages
    • Tribu
#1
  0

Metatablas y Metamétodos

　En lua, hay diferentes tipos de metamétodos. Ellos realizan funciones dentro de una tabla, y esa tabla que contiene un metamétodo es llamada metatabla.

　"Esa metatabla es una tabla lua común que define el comportamiento del valor original sobre ciertas operaciones especiales. Usted puede cambiar varios aspectos del comportamiento de operaciones especiales sobre un valor especificando campos específicos en su metatabla.", (manual lua)

　Cada metamétodo es procedido por dos guiones bajos ( _ ) y el nombre del evento, como __event.

Resumen de funciones:
» getmetatable(tabla)
    - Si la tabla de argumento es una metatabla, esta función devolverá todos los metamétodos de esta tabla, excepto en el instante que exista un método llamado __metatabla, que sólo será retornada.
» setmetatable(tabla, metatabla)
    - Establece los nuevos metamétodos de la tabla insertada, pero en el caso del argumento metatabla será nil, los metamétodos de la tabla insertada serán removidos, en el caso de que exista el metamétodo __metatabla en la tabla original insertada (en caso de que no sea el primer metamétodo o una tabla ya sea metatabla), un error será retornado.
Resumen de metamétodos:
__index(list,index)
    - Se ejecuta cuando una tabla es llamada. Sus argumentos son list (tabla) y index (nombre de la variable)
    Ejemplo
    garbage = setmetatable({},{
      __index = function(list,index)
        return "Not Nil! Biiiirl! The monster!!!!!"
      end
    }    )

    garbage.Tig = 1
    garbage.Noob = 2

    print(garbage["Tig Noob"])
    print(garbage.Tig)
    print(garbage["Noob"])
    		　
__newindex(list,index,value)
    - Es ejecutado cuando una variable dentro de una tabla es creada. Sus argumentos son list (tabla), index (nombre de la variable) y value (valor de la nueva variable)
    Ejemplo
    calc = setmetatable({},{
      __newindex = function(list,index,value)
        if type(value[1]) == "number" and type(value[2]) == "number" then
          local math = {
            [1] = value[1],
            [2] = value[2],
            add = value[1] + value[2],
            sub = value[1] - value[2],
            mul = value[1] * value[2],
            div = value[1] / value[2],
          }
          rawset(list,index,math)
        else
          rawset(list,index,value)
        end
      end
    })

    calc.cake = {10,20}

    print(calc.cake[1])
    print(calc.cake[2])
    print(calc.cake.add)
    print(calc.cake.sub)
    print(calc.cake.mul)
    print(calc.cake.div)
    		　
__call(list,arg)
    - Es ejecutado cuando una tabla es llamada como función. Sus argumentos son list (tabla) y arg (argumentos que son pasados por la supuesta "función"), también puede ser representado por (...).
    Ejemplo
    local call = {
      __call = function(list,arg)
        print(("[%s [%dy]] %s!"):format(arg.name,arg.age,arg.quote))
      end
    }

    humanProfile = setmetatable({},{
      __newindex = function(list,index,value)
        rawset(list,index,setmetatable(value,call))
      end
    }    )

    humanProfile[1] = {
      name = "Homer Simpson",
      age = 40,
      quote = "I am sorry, God, but I do not trust you!",
    }


    humanProfile[1](humanProfile[1])
    		　
__concat(...)
    - Es ejecutado cuando ocurre una concatenación de valores diferentes (la tabla con una string). Su argumento es ..., donde pasan todos los valores que fueron concatenados. También es representado como o1, o2.
    Ejemplo
    local concat = {
      __concat = function(...)
        local values = {}
        local args = {...}
        for i = 1,#args do
          if type(args[i]) == "table" then
            for k,v in next,args[i] do
              values[#values + 1] = v
            end
          else
            values[#values + 1] = args[i]
          end
        end
        return table.concat(values,", ")
      end
    }

    list = setmetatable({},{
      concat,
      __newindex = function(list,index,value)
        if type(value) == "table" then
          rawset(list,index,setmetatable(value,concat))
        else
          rawset(list,index,value)
        end
      end
    }    )

    list.food = "pasta"
    list.soda = {"coke","grape"}
    list.trolls = {"Tigrounette","Pikashu"}

    print(list.soda .. list.trolls .. list.food)
    		　
__add(n1,n2)
    - Es ejecutado cuando ocurre una adición entre valores que no son numéricos (o uno numérico y otro no). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo sumados.
    Ejemplo
    sMath = setmetatable({},{
      __add = function(n1,n2)
        n1,n2 = (type(n1) == "table" and #n1 or n1),(type(n2) == "table" and #n2 or n2)
        return n1 + n2
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(sMath + sMath + 2)
    		　
__sub(n1,n2)
    - Es ejecutado cuando ocurre una sustracción entre valores que no son numéricos (o uno numérico y otro no). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo substraídos.
    Ejemplo
    sMath = setmetatable({},{
      __sub = function(n1,n2)
        n1,n2 = (type(n1) == "table" and #n1 or n1),(type(n2) == "table" and #n2 or n2)
        return n1 - n2
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(sMath - 3)
    		　
__mul(n1,n2)
    - Es ejecutado cuando ocurre una multiplicación entre valores no numéricos (o uno numérico y otro no). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo multiplicados.
    Ejemplo
    sMath = setmetatable({},{
      __mul = function(n1,n2)
        n1,n2 = (type(n1) == "table" and #n1 or n1),(type(n2) == "table" and #n2 or n2)
        return n1 * n2
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(sMath * 4)
    		　
__div(n1,n2)
    - Es ejecutado cuando ocurre una división entre valores no numéricos (o uno numérico y otro no). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo divididos.
    Ejemplo
    sMath = setmetatable({},{
      __div = function(n1,n2)
        n1,n2 = (type(n1) == "table" and #n1 or n1),(type(n2) == "table" and #n2 or n2)
        return n1 / n2
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(sMath / 4)
    		　
__pow(n1,n2)
    - Es ejecutado cuando ocurre una exponenciación (1²) entre valores no numéricos (o uno numérico y otro no). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo exponenciados.
    Ejemplo
    sMath = setmetatable({},{
      __pow = function(n1,n2)
        n1,n2 = (type(n1) == "table" and #n1 or n1),(type(n2) == "table" and #n2 or n2)
        return n1 ^ n2
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(sMath ^ 2)
    		　
__mod(n1,n2)
    - Es ejecutado cuando ocurre un mod (1%2 (recolectar el resto de la división entre 2 números)) entre valores no numéricos (o uno numérico y otro no). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo “modularizados".
    Ejemplo
    sMath = setmetatable({},{
      __mod = function(n1,n2)
        n1,n2 = (type(n1) == "table" and #n1 or n1),(type(n2) == "table" and #n2 or n2)
        return n1 % n2
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(sMath % 3)
    		　
__unm(n1)
    - Es ejecutado cuando ocurre que un valor que no es numérico es llamado por una sola unidad (en este caso, sería lo mismo que llamar "-var" para que el número de var sea negativo). Sus argumentos son n1 y n2, los dos "números" o "valores" que están siendo transformados en números negativos.
    Ejemplo
    sMath = setmetatable({},{
      __unm = function(n1)
        n1 = (type(n1) == "table" and #n1 or n1)
        return -n1
      end
    }    )

    sMath[1] = 0
    sMath[2] = 0
    sMath[3] = 0
    sMath[4] = 0

    print(-sMath)
    		　
__metatable()
    - Bloquea la función getmetatable para recolectar el metamétodo real de la tabla insertada, y, en lugar de ella, acaba mandando el metamétodo __metatable como forma de protección.
    Ejemplo
    str = setmetatable({},{
      __metatable = "Nothing here, noob!",
      __newindex = function(list,key,value)
        print(key .. " Biirl!")
        rawset(list,key,value)
      end
    }    )

    print(getmetatable(str))
    print(getmetatable(str).__newindex)

    str.test = '?'

    tbl = setmetatable({},{
      __newindex = function(list,key,value)
        print(key .. " Huuuu!")
        rawset(list,key,value)
      end
    }    )

    print(getmetatable(tbl))
    print(getmetatable(tbl).__newindex)

    tbl.test = '?'
    		　
Mustazza
« Censeur »
1483581360000
    • Mustazza#0000
    • Profil
    • Derniers messages
#2
  0
Buen tutorial Yuir!
  • Forums
  • /
  • Transformice
  • /
  • Modules
  • /
  • Guías y Tutoriales
  • /
  • [Tutorial] Metatablas y metamétodos
© Atelier801 2018

Equipe Conditions Générales d'Utilisation Politique de Confidentialité Contact

Version 1.27