Array: Difference between revisions
No edit summary |
No edit summary |
||
| Line 53: | Line 53: | ||
'''The difference between '=' and '[[set]]'.''' | '''The difference between '[[ cond_set | =]]' and '[[set]]'.''' | ||
It is important at this point to recognise the difference between two commands, '''[[set]]''' and '''[[=]]''' . | It is important at this point to recognise the difference between two commands, '''[[set]]''' and '''[[ cond_set | =]]''' . | ||
If you think about it, there are two ways we could set ''_array2'' to [ [[player]]] from its previous value of [5]. We could say ''_array2'' '''[[=]]''' [ [[player]]] or we could say ''_array2'' '''[[set]]''' [0, [[player]]]. | If you think about it, there are two ways we could set ''_array2'' to [ [[player]]] from its previous value of [5]. We could say ''_array2'' '''[[ cond_set | =]]''' [ [[player]]] or we could say ''_array2'' '''[[set]]''' [0, [[player]]]. | ||
The difference is very important. | The difference is very important. | ||
If you use '''[[=]]''' to change ''_array2'', you will find that ''_array1'' and ''_array2'' now have different values completely; ''_array1'' is still [5] but ''_array2'' is [ [[player]]]. | If you use '''[[ cond_set | =]]''' to change ''_array2'', you will find that ''_array1'' and ''_array2'' now have different values completely; ''_array1'' is still [5] but ''_array2'' is [ [[player]]]. | ||
If you use '''[[set]]''', then both ''_array1'' and ''_array2'' store [ [[player]]]. | If you use '''[[set]]''', then both ''_array1'' and ''_array2'' store [ [[player]]]. | ||
| Line 66: | Line 66: | ||
The reason for this lies in what you're doing with the equals. | The reason for this lies in what you're doing with the equals. | ||
When you say ''_array2'' '''[[=]]''' [ [[player]]], you are creating an entirely new array, and assigning ''_array2'' as the variable that points to it. | When you say ''_array2'' '''[[ cond_set | =]]''' [ [[player]]], you are creating an entirely new array, and assigning ''_array2'' as the variable that points to it. | ||
''_array2'' is stripped away from the array that it was originally pointing to (but which ''_array1'' still points to). | ''_array2'' is stripped away from the array that it was originally pointing to (but which ''_array1'' still points to). | ||
| Line 73: | Line 73: | ||
The equals command has a slighly different meaning - here is a summary: | The equals command has a slighly different meaning - here is a summary: | ||
''_a1'' [[=]] [1,2,3] | ''_a1'' [[ cond_set | =]] [1,2,3] | ||
The variable _a1 points to a new array which is created at the end of this statement | The variable _a1 points to a new array which is created at the end of this statement | ||
''_a2'' [[=]] ''_a1'' | ''_a2'' [[ cond_set | =]] ''_a1'' | ||
No new array is created, but the variable ''_a2'' now refers to the same array that ''_a1'' refers to. | No new array is created, but the variable ''_a2'' now refers to the same array that ''_a1'' refers to. | ||
''_a2'' [[=]] ''+_a1'' | ''_a2'' [[ cond_set | =]] ''+_a1'' | ||
A new array is created which is an identical clone of the array that ''_a1'' points to. | A new array is created which is an identical clone of the array that ''_a1'' points to. | ||
''_a2'' points to this new array. | ''_a2'' points to this new array. | ||
''_a1'' points to the old one | ''_a1'' points to the old one | ||
''_a2'' [[=]] ''_a1'' + [2] | ''_a2'' [[ cond_set | =]] ''_a1'' + [2] | ||
A new array is created which is the same as array ''_a1'' plus an extra element. | A new array is created which is the same as array ''_a1'' plus an extra element. | ||
| Line 93: | Line 93: | ||
Because arrays are 'returned by reference' (not by value), the equality ([[==]]) operator behaves differently. | Because arrays are 'returned by reference' (not by value), the equality ([[ cond_equal | ==]]) operator behaves differently. | ||
Testing our two numbers, ''_num1'' and ''_num2'', we know that ''_num1'' [[==]] ''_num2'' is true when ''_num1'' and ''_num2'' are storing the same value. | Testing our two numbers, ''_num1'' and ''_num2'', we know that ''_num1'' [[ cond_equal | ==]] ''_num2'' is true when ''_num1'' and ''_num2'' are storing the same value. | ||
The same is '''not''' true of arrays. | The same is '''not''' true of arrays. | ||
| Line 100: | Line 100: | ||
If we had two separate arrays, and both had identical values e.g. [3,4,2]. | If we had two separate arrays, and both had identical values e.g. [3,4,2]. | ||
''_firstArray'' [[==]] ''_secondArray'' would return false, even though the values are identical. | ''_firstArray'' [[ cond_equal | ==]] ''_secondArray'' would return false, even though the values are identical. | ||
When used with arrays, the equality ([[==]]) operator compares two references and checks if they point to the same thing. | When used with arrays, the equality ([[ cond_equal | ==]]) operator compares two references and checks if they point to the same thing. | ||
From our example above, ''_array1'' [[==]] ''_array2'' would return true, because both ''_array1'' and ''_array2'' point to the same array. | From our example above, ''_array1'' [[ cond_equal | ==]] ''_array2'' would return true, because both ''_array1'' and ''_array2'' point to the same array. | ||
Another interesting thing is what happens when we delete a variable pointing to an array. | Another interesting thing is what happens when we delete a variable pointing to an array. | ||
Returning to our two arrays, supposing we do: | Returning to our two arrays, supposing we do: | ||
''_array2'' [[=]] [[nil]] | ''_array2'' [[ cond_set | =]] [[nil]] | ||
The array is not deleted. | The array is not deleted. | ||
Revision as of 18:16, 15 April 2006
Description: Array of items, each may be of any type.
Arrays are somewhat different from other variable types.
Arrays are returned by reference.
What does this mean?
It means that the variable name you give to an array (for example myArray, or _units) references an array of values in the computer's memory.
Suppose you have two numbers, _num1 and _num2.
You set _num1 to equal 5, and _num2 equal to _num1.
What do you have?
You have two completely separate variables, which store a number each, and which are both currently storing the number 5.
But what happens if you do a similar thing with a pair of arrays?
For Example:
_array1 = [5]
_array2 = _array1
What do you have now?
You have two variables, but each one points to the same data, in this case an array containing a single variable of type number, with the value of 5.
You can understand the difference when you try to change the two variable types around.
Taking our number type variables:
Suppose we set _num2 to zero.
Now we have _num2 equal to zero, but _num1 still equal to 5.
Now take the two arrays.
Supposing we set _array2 to [ player].
What does _array1 equal?
_array1 also equals [ player].
We have modified the array that both _array1 and _array2 refer to.
Exactly the same thing would happen if we set _array1 to [ player] instead of _array2.
Both our variables, _array1 and _array2 are two labels for the same thing.
The difference between ' =' and 'set'.
It is important at this point to recognise the difference between two commands, set and = . If you think about it, there are two ways we could set _array2 to [ player] from its previous value of [5]. We could say _array2 = [ player] or we could say _array2 set [0, player].
The difference is very important.
If you use = to change _array2, you will find that _array1 and _array2 now have different values completely; _array1 is still [5] but _array2 is [ player].
If you use set, then both _array1 and _array2 store [ player].
The reason for this lies in what you're doing with the equals.
When you say _array2 = [ player], you are creating an entirely new array, and assigning _array2 as the variable that points to it.
_array2 is stripped away from the array that it was originally pointing to (but which _array1 still points to).
The equals command has a slighly different meaning - here is a summary:
_a1 = [1,2,3] The variable _a1 points to a new array which is created at the end of this statement
_a2 = _a1 No new array is created, but the variable _a2 now refers to the same array that _a1 refers to.
_a2 = +_a1 A new array is created which is an identical clone of the array that _a1 points to. _a2 points to this new array. _a1 points to the old one
_a2 = _a1 + [2] A new array is created which is the same as array _a1 plus an extra element.
_a2 set [0, player] The array which _a2 references is modified. Its zero element is set to 'player'. All variables referencing this array will return the changed array.
Because arrays are 'returned by reference' (not by value), the equality ( ==) operator behaves differently.
Testing our two numbers, _num1 and _num2, we know that _num1 == _num2 is true when _num1 and _num2 are storing the same value.
The same is not true of arrays.
If we had two separate arrays, and both had identical values e.g. [3,4,2].
_firstArray == _secondArray would return false, even though the values are identical. When used with arrays, the equality ( ==) operator compares two references and checks if they point to the same thing.
From our example above, _array1 == _array2 would return true, because both _array1 and _array2 point to the same array.
Another interesting thing is what happens when we delete a variable pointing to an array.
Returning to our two arrays, supposing we do: _array2 = nil
The array is not deleted. It helps to think of _array1 and _array2 as labels or arrows, pointing to a chunk of data (the array). Deleting _array2 removes one of the arrows pointing to the array. _array1, however, still points to the array as per usual.
(An array is normally destroyed, and its memory reclaimed, when there are no more labels pointing to it).