Retrieving an Element of an Array: Difference between revisions
Thundergnat (talk | contribs) (blanked page since people can't / don't read) |
|||
(80 intermediate revisions by 31 users not shown) | |||
Line 1: | Line 1: | ||
{{ |
{{DeprecatedTask}} |
||
'''Please do not add new code, and merge existing code to the [[Arrays]] task.''' |
|||
In this task, the goal is to retrieve an element of an [[array]]. |
In this task, the goal is to retrieve an element of an [[array]]. |
||
==[[4D]]== |
|||
[[Category:4D]] |
|||
` first element |
|||
$elem:=$array{1} |
|||
==[[X86 assembly]]== |
|||
[[Category:x86 assembly]] |
|||
'''Assembler:''' nasm |
|||
mov esi, array_offset |
|||
mov ebx, 2 |
|||
mov eax, [esi+ebx*4] |
|||
==[[ActionScript]]== |
|||
[[Category:ActionScript]] |
|||
var arr:Array = new Array(1,2,3); |
|||
var myVar:Number = arr[1]; |
|||
// the value of myVar is: 2 |
|||
==[[Ada]]== |
|||
[[Category:Ada]] |
|||
Array indexed by an enumerated type. Ada enumerated types are discrete non-numeric types. |
|||
type Days is (Mon, Tue, Wed, Thu, Fri, Sat, Sun); |
|||
type Daily_Counts is array(Days) of Natural; |
|||
This_week : Daily_Counts := (200, 212, 175 220, 201, 120, 0); |
|||
Monday_Sales : Natural; |
|||
Monday_Sales := This_Week(Mon); |
|||
Monday_Sales is assigned 200 |
|||
==[[AppleScript]]== |
|||
[[Category:AppleScript]] |
|||
on getArrayValue(array, location) |
|||
-- very important -- The list index starts at 1 not 0 |
|||
return item location in array |
|||
end getArrayValue |
|||
==[[C]]== |
|||
[[Category:C]] |
|||
int array_index(int array[], int index) { |
|||
return array[index]; |
|||
} |
|||
==[[C sharp|C#]]== |
|||
[[Category:C sharp]] |
|||
int getArrayValue( int values[], int index ) { |
|||
return values[index]; |
|||
} |
|||
==[[C plus plus|C++]]== |
|||
[[Category:C plus plus]] |
|||
template<typename T> |
|||
T array_index(T array[], size_t index) { |
|||
return array[index]; |
|||
} |
|||
==[[ColdFusion]]== |
|||
[[Category:ColdFusion]] |
|||
<cfset arr = ArrayNew(1)> |
|||
<cfset arr[1] = "one"> |
|||
<cfset arr[2] = "2"> |
|||
<cfset arr[3] = 3> |
|||
<cfset var = arr[1]> |
|||
The value of '''var''' is "one" |
|||
''ColdFusion Arrays are '''NOT''' zero-based, their index begins at '''1''''' |
|||
==[[Common Lisp]]== |
|||
[[Category:Common Lisp]] |
|||
(defun array-value (array index) |
|||
(aref array index)) |
|||
==[[Delphi]]/[[Object Pascal]]/[[Turbo Pascal]]/Standard [[Pascal]]== |
|||
[[Category:Pascal]] |
|||
Array's in all the flavors of pascal can be of any valid base type, or user defined type ( which are all made up of base types ) and are multi-dimensional. With Delphi dynamic arrays were defined but had been used in pascal since its inseption. |
|||
A Static array defintion: |
|||
foo : array[1..10] of integer; { The base index is ONE } |
|||
The base index can be freely chosen: |
|||
foo: array[7 .. 16] of integer; { The base index is 7 } |
|||
Indeed, the "1 .. 10" resp. "7 .. 16" are actually ''types'': they are integer subrange types. Arrays can also be indexed by enumeration types or enumeration subrange types: |
|||
type |
|||
rainbowcolor = (red, orange, yellow, green, blue, violet); |
|||
var |
|||
foo: array[rainbowcolor] of integer; |
|||
bar: array[yellow .. blue] of integer; |
|||
i: integer |
|||
begin |
|||
i := foo[red]; { allowed indices are red, orange, yellow, green, blue, violet } |
|||
i := bar[green]; { allowed indices are yellow, green, blue } |
|||
end; |
|||
A Dynamic Array type in Delphi: |
|||
foo : array of integer ; // The base index is ZERO |
|||
An "old school" dynamic array in the various flavors of pascal |
|||
foo : array[0..0] of integer; // The base index is ZERO |
|||
A dynamic array in Extended Pascal: |
|||
type |
|||
intarray(n: integer) = array[1 .. n] of integer; { base index 1 } |
|||
var |
|||
foo: ^intarray; |
|||
begin |
|||
new(foo, 10); { foo now has index 1 to 10 } |
|||
i := foo[2]; |
|||
dispose(foo); { get rid of the array } |
|||
end; |
|||
In the case of the static array, the compiler generates the code to allocate the required memory to hold 10 integers. |
|||
In the Delphi style ---dynamic--- array you must set its length: |
|||
SetLength(foo,10); // this array will no hold 10 integers |
|||
In the "old school" style of dynamic arrays, you created a point to the zero length declaration and then allocated memory to it with GetMem |
|||
pFoo : ^Foo ; |
|||
Foo : array[0..0] of integer ; |
|||
All arrays are accessed the same way regardless of declaration method. |
|||
i : integer ; |
|||
i := foo[n] ; |
|||
where n is the array index who's base is either 1 or 0 depending on how it was declared. |
|||
==[[Erlang]]== |
|||
[[Category:Erlang]] |
|||
Erlang lists are 1-based which means that the index must be within the bounds (1 .. length(List)): |
|||
Value = lists:nth(Index, List). |
|||
==[[Forth]]== |
|||
[[Category:Forth]] |
|||
Forth does not have special syntax for array access. Address arithmetic is used to access contiguous memory. |
|||
create array 1 , 2 , 3 , 4 , |
|||
array 2 cells + @ . \ 3 |
|||
==[[IDL]]== |
|||
[[Category:IDL]] |
|||
; this is allowed: |
|||
result = arr(5) |
|||
; but this is preferred: |
|||
result = arr[5] |
|||
The form with square brackets is preferred as it unambiguously constitutes array access, while the version with round ones can conflict with a function call if there are both a function and an array with the same name <tt>arr</tt>. |
|||
==[[Java]]== |
|||
[[Category:Java]] |
|||
public Object getArrayElem(Object[] array, int pos) { |
|||
return array[pos]; |
|||
} |
|||
==[[JavaScript]]== |
|||
[[Category:JavaScript]] |
|||
var element = array[index]; |
|||
==[[MAXScript]]== |
|||
[[Category:MAXScript]] |
|||
item = arr[index] |
|||
==[[mIRC]]== |
|||
[[Category:mIRC Scripting Language]] |
|||
'''Interpeter:''' mIRC Script Editor |
|||
'''Library:''' [[mArray Snippet]] |
|||
[[Category:mArray Snippet]] |
|||
alias readmyarray { echo -a $array_read(MyArray, 2, 3) } |
|||
==[[Perl]]== |
|||
[[Category:Perl]] |
|||
'''Interpreter:''' [[Perl]] 5.8.8 |
|||
$elem = $array[0]; |
|||
==[[PHP]]== |
|||
[[Category:PHP]] |
|||
$array = array('php', 'has', 'arrays'); |
|||
// First element |
|||
$elem = $array[0]; |
|||
==[[Pop11]]== |
|||
[[Category:Pop11]] |
|||
lvars ar = {1 two 'three'}; |
|||
lvars elem; |
|||
;;; Access second element and assign to variable elem |
|||
ar(2) -> elem; |
|||
This example uses the simplest possible array (a vector). Pop11 has |
|||
more general arrays, but in all cases access follows the same pattern, |
|||
and look the same as procedure (function) call. |
|||
==[[Python]]== |
|||
[[Category:Python]] |
|||
'''Interpreter:''' Python 2.5 |
|||
The item is an element in a list at a given index |
|||
item = aList[index] |
|||
or |
|||
To use a list like a stack be it FIFO/LIFO |
|||
aList.pop() # Pop last item in a list |
|||
aList.pop(0) # Pop first item in a list |
|||
'''Note:''' When using the pop() method, the element is removed from the list. |
|||
==[[Ruby]]== |
|||
[[Category:Ruby]] |
|||
ary = ['Ruby','rules','big','time'] |
|||
#the first element |
|||
element = ary[0] |
|||
#or |
|||
element = ary.first |
|||
# => element = 'Ruby' |
|||
#the last element |
|||
element = ary[-1] |
|||
#or |
|||
element = ary.last |
|||
# => element = 'time' |
|||
#retrieving different values at once |
|||
elements = ary.values_at(0,2,3) |
|||
# => elements = ['Ruby','big','time'] |
|||
#select the first element of length 3 |
|||
element = ary.find{|el|el.length==3} |
|||
# => element = "big" |
|||
==[[Smalltalk]]== |
|||
[[Category:Smalltalk]] |
|||
#($a $b $c) at: 2 |
|||
==[[Tcl]]== |
|||
[[Category:Tcl]] |
|||
All arrays in Tcl are associative. If "key" is the variable that holds the key of the element to be retrieved, then |
|||
set result $array($key) |
|||
==[[Toka]]== |
|||
[[Category:Toka]] |
|||
This retrieves the value 20 from the second item in the array: |
|||
3 cells is-array table |
|||
( Populate the array ) |
|||
10 0 table array.put |
|||
20 1 table array.put |
|||
30 2 table array.put |
|||
table 1 array.get |
Latest revision as of 15:06, 29 November 2019
Please do not add new code, and merge existing code to the Arrays task.
Retrieving an Element of an Array was a programming task. It has been deprecated for reasons that are discussed in its talk page.
In this task, the goal is to retrieve an element of an array.