JASS:
function myF takes nothing returns nothing
local unit u = CreateUnit(Player(0), 'hfoo', 0, 0, 0)
call KillUnit(u)
call RemoveUnit(u)
if u == null then
call BJDebugMsg("null")
else
call BJDebugMsg("not null")
endif
endfunction
//===========================================================================
function InitTrig_Untitled_Trigger_002 takes nothing returns nothing
call myF()
endfunction
prints not null.
This is because the interpreter does not change what given handle points to from natives, ever.
Basically you removed the unit, but the local variable still points there, hence the memory cant be freed, because if you try to call SetUnitFacing(u, 5) and the memory was already removed from RAM, you would get segfault(trying to access memory that was not allocated to your process) if lucky, if not you would possibly allow for security holes, like chaning stuff in wc3's memory that should not be changed.
The second question:
Lets see what you do:
You first create a group in the memory, take the memory address where the group is stored, and say to G1 "can you please point to this? Thank you", and so G1 will point to the memory allocated for that group(not the group itself, so if you pass G1 into function, you only pass the memory address it is stored inside, so calling DestroyGroup from given function will destroy group stored inside G1 as well).
Then you try to call function DestroyGroup with a group stored where the G1 points to. The game takes that data and does something to it(may call constructor if it is C++ code, etc). The variable G1 is not updated, so it still points to that memory address, so you cant deallocate it(I can give you reason why if you want).
Then you say to G1 "Ok, all's fine, now point to nothing", and so G1 changes the memory address it should point to to null. In programming languages null is usually defined as memory address at 0(0x00000000 or on 64bit architecture 0x0000000000000000), which is kind of special memory address(please note that depending on the OS as well as the architecture, it could point to anything).
Under the hood, before the interpreter changes what G1 points to, it goes to the object G1 pointed to, and says: "Ok, listen, this dude is no longer pointing his giant finger at you, so we can say that there is one less dude pointing at you." Then if there are 0 dudes pointing into that memory address, the interpreter goes "ok, listen, noone has any interest in you anymore, so you can go fuck yourself now", and so it goes.
The second code:
We create and store the pointer as per usual.
But then you actually say to G1 to point to null, while the group being pointed at still lives, even if it ref-count goes down by 1(to 0 in this case), but Jass has no garbage collector, so there is noone going over the allocated memory looking at ref-count and removing the blocks that have 0 ref-count(this is also not safe to do, since the variable can be still used, like units, you dont want units disappearing from your map just because no variable points to them).
So now you have some unreachable memory address which holds the group, and G1 pointing into null.
Now you call DestroyGroup(G1), and what you actually are trying to do is destroy a group stored inside "null" memory address, and for security reasons, there is a null check inside the code, so nothing happens.
After that G1 still points to null, and the last created group is lost forever(until wc3 closes).
So as you can see, the first alternative is the better one, the second is a group leak.
