I have been wondering what the differences are between Pcalls and Coroutines. What are the usage cases for each? Right now it seems that Pcalls are overall a better way to do coroutines...
pcall(function()
print("hi")
end)
coroutine.resume(coroutine.create(function()
print("hi")
end))
I also know that coroutines create a separate thread while pcalls skip the function if it errors.
Pcall is a function you can use for creating your own error handler. Pcall will execute a function and will return two values: a bool value to see if the function has successfully ran without any errors, and an error message, if there was an error.
function Func1()
print('Hi')
end
function Func2()
PRint('Hi')
end)
local success1, message1 = pcall(Func1)
local success2, message2 = pcall(Func2)
if success1 then
print('Successfully ran 1st func')
else
print('Failed to run 1st func: '..message1)
end
if success2 then
print('Successfully ran' 2nd func')
else
print('Failed to run 2nd func: '..message2)
end
This script above will print 'Successfully ran 1st func', but will print 'Failed to run 2nd func: error here's
Coroutines are useful for multi-threading. They allow you to execute code at the same time. Coroutines have the same purpose of Spawn()
local coro1 = coroutine.wrap(function()
for i = 1, 10 do
print(i)
wait(1)
end
end)
local coro2 = coroutine.wrap(function()
local i = 1
repeat
i = i+1
print(i)
wait(1)
until i <= 10
end)
coro1()
coro2()
This will run the for and repeat loop at the same time.
I really don't know how you find a similarity between these
To add, you can also see pcall short for protect call. :)
I'm not 100% sure, but pcalls return a false value if the function inside fails to execute for some reason (which allows for measures in case a crucial function fails, like saving a player's game) and coroutine allows you to run 2 functions at the same time? I don't think there's a relation between the two, and I also think coroutines are discouraged in favour of spawn().
pcall and coroutines are two completely different things.
##Pcall
pcall stands for protected call and accepts one input function optionally along with the paramters to be passed into the input function. Examples:
local success = pcall(print , "Hello world!")
local success = pcall(function(num1 , num2)
print(num1 + num2)
end , 5 , 8)
The purpose of pcall is to catch any errors that are thrown by the block of code inside the function given. Usually these errors aren't supposed to be syntax errors (for example a typo) or logic errors (your code works but it doesn't produce the expected result). pcall is typically used to catch errors that aren't in your control at all namely datastore and web api requests. pcall also returns two values. The first one indicates whether or not the function errored or not and the second value is the error message. If the function executed successfully however, the second value is the value the function would normally return. Keep in mind that if an error does get thrown, the script will continue on like normal instead of terminating the current thread hence the name protected call. Variants of pcall include xpcall and ypcall.
##Coroutines
Coroutines are lua's api so to speak to threading. For a much more detailed and comprehensive guide, I recommend reading this.
In a nutshell, coroutines allow you to have full control over multiple threads at once. Typically, one would use Roblox's own thread scheduler instead (wait, spawn, and delay). Using coroutines, you can yield and resume multiple threads via coroutine.resume and coroutine.yield. You can also pass values too and from a coroutine. Pcalls don't allow you to do any of this. There is way too much to cover here on the topic of coroutines in one answer let alone a brief paragraph so I'll leave it here.
Good luck!
This discussion is preserved as it was. New answers, comments, and votes are closed.
3 comments
omae wa mou shindeiru NANI
In what way do you consider this similar.
I mean I use them in a lot of similar ways. It is confusing.....