I'm trying to do script for game which replaces avalible function with created function. So this is my LUA code:
function ifEmotePlayed(playerName, emoteID)
if emoteID == 0 then
print(playerName.." is dancing!")
end
end
return
function eventEmotePlayed(playerName, emoteID)
end
Exactly thing i want to do is to replace eventEmotePlayed function with ifEmotePlayed function likely
function ifEmotePlayed(playerName, emoteID)
if emoteID==0 then
print(playerName.." is dancing!")
end
end
Instead of
function eventEmotePlayed(playerName, emoteID)
if emoteID==0 then
print(playerName.." is dancing!")
end
end
Does anyone know how to do it?
If you want to rename a function you simply do it like that:
myNewFunctionName = originalFunctionName
Then calling myNewFunctionName() will be identical to calling originalFunctionName() as myNewFunctionName now refers to the same function as originalFunctionName.
In Lua functions are variables.
You could also define a function that calls the original function and pass the parameters like:
function myNewFunction(a,b)
return originalFunction(a,b)
end
But this is obviously not as efficient as you have to do one additional function call.
If you want to replace a function with your own function so the original function will not be executed but yours instead you simply assign your function to the original functions "name" (actually you make the variable that referred to the original function from now on refer to your own function)
function originalFunction(a,b)
return a + b
end
function myOwnFunction(a,b)
return a * b
end
originalFunction = myOwnFunction
Now originalFunction refers to your function and calling originalFunction(a,b) will return the product of a and b instead of the sum. It's the same as in the first example, just the other way around.
Related
I would like to store methods that are associated with a table, so that I can randomly select one of the function using math.random. Storing functions in a table and calling those functions is straight forward, as shown below:
function funcA()
print("A")
end
functionTable = {funcA}
functionTable[1]()
However, I cannot store a function from a table (a method?) in a new table. The following code will return in an Error (Lua 5.4): function arguments expected near '}'
local functionStore = {}
function functionStore:funcA()
print("A")
end
functionStore:funcA()
functionTable = {functionsStore:funcA}
functionTable[1]()
I think the colon (:) means that I'm already calling the function?, and then the error would make sense, but I would like to store the function in the table.
What Am I doing wrong here?
The problem is that the colon is a special syntactic sugar for function calls to pass the variable / expression preceding it as first argument to the function; it can not be used as an expression. You can however write yourself a function that "curries" the self argument, creating a closure:
local function curry_self(self, methodname)
return function(...) return self[methodname](self, ...) end
end
then you can use this as follows:
functionStore:funcA()
functionTable = {curry_self(functionsStore, "funcA")}
functionTable[1]()
Alternatively, you may pass self as you invoke the function:
functionStore:funcA()
functionTable = {functionStore.funcA}
functionTable[1](functionStore) -- pass functionStore as `self`
In your case, you don't need the colon at all though - you don't even use self in your function! Thus, you may use:
local functionStore = {}
function functionStore.funcA()
print("A")
end
functionStore.funcA()
functionTable = {functionsStore.funcA}
functionTable[1]()
you can put functions in a table without using the colon, using just the dot to assign them to table fields.
I'm still ramping up in lua, and I am not quite familiar with this syntax. What is happening when you pass in a function as a parameter like below?
Comm.setRouting(function(url)
for i = 1,4 do
local portIndex = "Path"..i
if url:match(portConfig[portIndex]) ~= nil then
return Comm.slots()[1], Comm.groups()[i]
end
end
end)
The other answers are correct, but it might help you if you wrote your own function that calls another function:
function CallAFunction(func_to_call)
func_to_call()
end
You could pass a named function (an anonymous function assigned to a variable) or an anonymous function written on the fly.
function SayHello()
print("Hello!")
end
--[[
^This is equivalent to:
SayHello = function()
print("Hello!")
end
]]--
CallAFunction(SayHello)
CallAFunction(function()
print("Goodbye!")
end)
output:
Hello!
Goodbye!
and this can be done with parameters
function CallAFunction(func)
func("Bonjour")
end
CallAFunction(function(parameter)
print(parameter)
end)
Here, func is the anonymous function, which accepts 1 parameter parameter.
When you call func("Bonjour") you are passing Bonjour as parameter, like a normal function call.
Here you're passing an argument to setRouting that is an "anonymous function"
Functions are first-class values in Lua and can be stored in local variables, global variables and table fields. Here the function is being passed anonymously on the call stack to the setRouting function.
setRouting would be called a "higher-order function" because it accepts a function as its input.
The following page has some more information about functions in Lua:
https://www.lua.org/pil/6.html
A couple of things are happening in this example:
You're passing a function as a parameter. The callee (e.g. setRouting()) can invoke that function. This is often referred to as a callback function.
You're defining the function itself, on-the-fly. This is an example of an "anonymous function", or a lambda function.
What is the syntax to create the function, but then add it's implementation further down in code?
So roughly like this:
Define function doX
Call doX (further down in the code)
doX implemention (i.e. all functions down at the bottom of the file)
You only need to have a variable to reference. local funcName is sufficient for your purposes with one caveat. This will work:
local funcName
function callIt()
print(funcName())
end
function defineIt()
funcName = function() return "My Function" end
end
defineIt()
callIt()
As long as you define it (defineIt) before you call it (callIt), it should work as expected. You can't do something like this though (and this is the caveat):
local funcName
print(funcName())
funcName = function() return "My Function" end
You will get an error: attempt to call local 'funcName' (a nil value).
oh...so there's really no way to call funcName prior to having actually defined the function then? i.e. you still need to make sure defineIt is called before your first call to funcName itself?
I wanted to clarify this point, and I felt that an answer would be the better way than a comment.
Lua is a much simpler language than C or C++. It is built on some simple foundations, with some syntactic sugar to make parts of it easier to swallow.
There is no such thing as a "function definition" in Lua. Functions are first-class objects. They are values in Lua, just like the number 28 or the string literal "foo" are values. A "function definition" simply sets a value (namely, the function) into a variable. Variables can contain any kind of value, including a function value.
All a "function call" is is taking the value from a variable and attempting to call it. If that value is a function, then the function gets called with the given parameters. If that value is not a function (or a table/userdata with a __call metamethod), then you get a runtime error.
You can no more call a function that hasn't been set in a variable yet than you can do this:
local number = nil
local addition = number + 5
number = 20
And expect addition to have 25 in it. That's not going to happen. And thus, for the same reason, you can't do this:
local func = nil
func(50)
func = function() ... end
As Paul pointed out, you can call a function from within another function you define. But you cannot execute the function that calls it until you've filled in that variable with what it needs to contain.
As others have written, you cannot call a function at runtime that has not been assigned prior to the call. You have to understand that:
function myFunc() print('Something') end
Is just a syntax sugar for this:
myFunc = function() print('Something') end
Now, it makes sense that this kind of code would not work the way you want it to:
print(greeter(io.read())) -- attempt to call global 'greeter' (a nil value)
function greeter(name) return 'Hello '..name end
When you use the greeter variable, its value is nil, because its value is set only on the next line.
But if you want to have your "main" program on the top and the functions at the bottom, there is simple way to achieve this: create a "main" function and call it as the last thing on the bottom. By the time the function is called, all the functions will be set to the corresponding global variables:
-- start of program, your main code at the top of source code
function main()
local name = readName()
local message = greeter(name)
print(message)
end
-- define the functions below main, but main is not called yet,
-- so there will be no errors
function readName() io.write('Your name? '); return io.read() end
function greeter(name) return 'Hello, ' .. name end
-- call main here, all the functions have been assigned,
-- so this will run without any problems
main()
how can one get the caller of function within a function in lua?
Specifically I'm looking (for debug purposes in the command output, e.g. print) the ability to log when a common function is called, with an indication of where it was called from.
This could be just the filename of where it was called from for example
i.e.
File 1 - Has commonly used function
File 2 - Calls of the the file one functions
PS Mud - I actually get a nil when doing this - is this normal then? No way to get more info in this case:
Called file;
SceneBase = {}
function SceneBase:new(options)
end
return SceneBase
Calling file:
require("views.scenes.scene_base")
local scene = SceneBase.new()
debug.getinfo(2).name will give you the name of the calling function if it has one and it is a string. If it's an anonymous function, you'll get nil, if it's stored in a table using something other than a string key, you'll get ?.
function foo() print(debug.getinfo(2).name) end
-- _G["foo"] => function name is a string
function bar() foo() end
bar() --> 'bar'
-- _G[123] => function name is a number
_G[123] = function() foo() end
_G[123]() --> '?'
-- function has no name
(function() foo() end)() --> 'nil'
The Lua debug library lets you get the stack trace.
Say I declare a lua function using the : operator like so:
function ClassName:myFunc( stuff )
--do stuff
end
And then say I store that function in a table like so:
someTable = {
ClassName.myFunc,
someGlobalFunc,
}
And then, say I have another function that goes through the table and attempts to call the given functions.
function ClassName:callStuffInThisTable(table)
-- I go through the table, which might be someTable above, and call all the functions
end
My question is, how do I know if a function in the table is owned by ClassName, so that I can call it using self?
You don't. At least, Lua isn't going to tell you.
function ClassName:myFunc( stuff ) is just syntactic sugar as far as Lua is concerned. It's no different from this: ClassName.myFunc = function (self, stuff). The functions are equivalent.
Likewise for the : call syntax, ClassName:myFunc(stuff) is semantically equivalent to ClassName.myFunc(ClassName, stuff).
It is up to you to know what your functions are and what they do. This requires coding discipline. If you have a list of functions that you need to call in a loop, then they should be designed to be called with the same parameters.
There are two ways to do this. One way is to make all of the functions "class functions":
someTable = {
ClassName.myFunc,
function(self, ...) return someGlobalFunc(...) end,
}
This way, the self parameter is ignored. Obviously, you could create a special function table object that has functions for inserting "global" functions into the table that will automatically generate the wrapper:
function insertFuncIntoTable(self, func)
self[#self + 1] = function(self, ...) func(...) end
end
insertFuncIntoTable(someTable, someGlobalFunc)
Note: there is a difference between these, assuming "someGlobalFunc" is actually a member of the global table (rather than a local). This version will take the value that _G["someGlobalFunc"] currently has, just as your original code does. However, the first version takes the value that it has at the time it is called, which may be a different function from the one it was at the time someTable was created.
So this version is safer.
Alternatively, you can make it so that any "class functions" in the table are explicitly bound to an object instance:
someTable = {
function(self, ...) ClassName.myFunc() end,
function(self, ...) return someGlobalFunc(...) end,
}
BTW, in general, if you declare a function using : syntax, you're supposed to use that function that way, via instance:myFunc(...). Obviously it's just a Lua function like any other, so you can do what you like. But misuse can make understanding what's going on harder.
Lua affords you a lot of power. But you're still required to exercise judgement and discipline when coding. Lua will not save you from yourself (entirely).
One way to tell if the function is "owned" by ClassName would be to scan and check.
ClassName = {}
function ClassName:fn(self) ... end
t = { function() ... end , ClassName.fn() }
function has_value( klass, value )
for k,v in pairs(klass) do
if v==value then return true
end
return false
function ClassName:callStuffInThisTable(table)
for k,v in pairs(table) do
if has_value(ClassName, v) then
v(self)
else
v()
end
end
end
This has O(n^2) behaviour though due to the table scan. We can reduce this to O(n log(n)) ) by using the functions in ClassName as a new table
function ClassName:callStuffInThisTable(table)
local t = {}
for k,v in pairs(ClassName) do
t[v] = 1
end
for k,v in pairs(table) do
if t[v]==1 then
v(self)
else
v()
end
end
end