What is faster?

[Megafyr]

Local or global variables?

 

[Pharaoh_]

I had heard of globals being a faster way of variable-ing. That is why common GUI system uses global ones, when locals require custom script. The fact though, that they are not that flexible is another issue to consider.

 

[Rmx]

Globals are faster than locals.

 

[maskedpoptart]

I think locals are (insignificantly) faster to access than globals. However, this is offset by the fact that locals need to be created and destroyed, which takes up time. Local handle variables also need to be nulled at the end of the function to remove the reference leaks. When it comes down to it, it's much more efficient to recycle global variables than to keep creating and destroying locals. With the help of vJASS, you can make private globals in scopes that are a great replacement for locals and can be used in multiple functions.

 

[Silvenon]

Globals are faster concerning performance, but locals are often faster to work with.

 

[Eleandor]

locals are faster concerning performance, and locals are often faster to work with.
The difference between the two is negligible though, and if you're looking for performance bottlenecks, you're focussing on the wrong thing if you care about performance differences between locals and globals.

 

[Seth21]

Could reducing the number of globals and converting them to locals reduce in any way the loading time?

 

[Eleandor]

Probably, but it would be unnoticeable. Loading time is mainly influenced by the object editor & terrain.

 

[baassee]

globals/locals just effects the effiencty meaning the respons time of a spell for an example, some takes 0.01 sec some takes less to do their actions

to decrease loading time you'll need a third party program like widgetzer or SLK optimizer

 

[AKAIMAX]

Locals have the advantage of making things MUI while globals need to have all these extra variables stuff added and custom value to make MUI.

 

[Rmx]

Locals have the advantage of making things MUI while globals need to have all these extra variables stuff added and custom value to make MUI.

You mean Indexing in GUI or custom values using globals ext.

Well Locals are much easy to use, but for some people JASS is hard so the use one Local in a GUI trigger as a custom script, but it is only used if the trigger is small and not worth making it indexing, like when unit casts bezerk and you want his hand set up in flame then you make a local unit wait like 8 seconds then remove the hot ability from him ext.

 

[Alkonis]

I don't think there's a difference performance-wise. Locals are certainly easier to work with when you have just one function, but globals are easier when you have several. Locals take time to pass between different functions, whereas with globals, that's not necessary.

Here's the bad (but almost negligable) thing about globals: they never stop taking memory.

When you declare a local, it sets aside memory to use to store its information:

function forehead takes nothing returns nothing
    local integer i // Oh, hey, let's take away 32 bits of memory (or whatever warcraft ints use) to store this variable in.
endfunction //now we're done with it, give the 32 bits back

With globals, there's no endfunction that magically causes them all to disappear, they're there the entire game (unless you null them [handles only], which means they can't be used anymore). Also, handles such as units use a lot more memory than ints. It's not really worth considering most of the time, but when you have over 100 global variables that are only used in one trigger, it can eat up memory. But, like I said, most people don't have any problems running even the worst Warcraft maps anymore.

Of course, memory leaks with local handles are worse... you have to null those or the game never releases the memory (a unit variable isn't really a unit, it just "points" to the unit, which is actually a combination of reals/ints/bools, etc.) .

 

[spiwn]

I don't think there's a difference performance-wise. Locals are certainly easier to work with when you have just one function, but globals are easier when you have several. Locals take time to pass between different functions, whereas with globals, that's not necessary.

Here's the bad (but almost negligable) thing about globals: they never stop taking memory.

When you declare a local, it sets aside memory to use to store its information:

function forehead takes nothing returns nothing
    local integer i // Oh, hey, let's take away 32 bits of memory (or whatever warcraft ints use) to store this variable in.
endfunction //now we're done with it, give the 32 bits back

With globals, there's no endfunction that magically causes them all to disappear, they're there the entire game (unless you null them [handles only], which means they can't be used anymore). Also, handles such as units use a lot more memory than ints. It's not really worth considering most of the time, but when you have over 100 global variables that are only used in one trigger, it can eat up memory. But, like I said, most people don't have any problems running even the worst Warcraft maps anymore.

Of course, memory leaks with local handles are worse... you have to null those or the game never releases the memory (a unit variable isn't really a unit, it just "points" to the unit, which is actually a combination of reals/ints/bools, etc.) .

I fail to see any relation to the topic, except you expressing your personal opinion and then going off topic(more like spamming).

You are wrong about locas. As said a couple of times already, locas are slower than globals(insignificuntly but slower).
Here, I will explain to you(though it has already been said in the thread) in detail, using your own code.

function forehead takes nothing returns nothing
    local integer i // Oh, hey, let's take away 32 bits of memory (or whatever warcraft ints use) to store this variable in.
endfunction //now we're done with it, give the 32 bits back

Those comments. They are 100% True. And what is more, they almost exactly the same as what warcrafts instructs the CPU.
wc3:"Oh, hey, let's take away 32 bits of memory"
CPU: " Sure thing. Wait a sec for me to do it ... *processor working* ... Here, the adress of the memory is #####.
So that takes time. The same goes for your other comment. While with globals only once is space alocated to variables.

Now see, I say variables not Handles, not objects and etc. Variables as in either one of the primative variable type or the container/pointer of/to Handles.
Actual Handles are another story which has nothing to do with the current topic.