Retrieving an Element of an Array: Difference between revisions

` first element

$elem:=$array{1}

<lang actionscript>

var arr:Array = new Array(1,2,3);

</lang>

Array indexed by an enumerated type. Ada enumerated types are discrete non-numeric types.

<lang ada>

Monday_Sales is assigned 200

{{trans|FORTRAN}}

</pre>

on getArrayValue(array, location)

-- very important -- The list index starts at 1 not 0

end getArrayValue

Arrays use one-based indexing. Array0 contains the number of elements.

<lang autohotkey>string = abcde

MsgBox, % array%A_Index%</lang>

This shows how a string is split into elements of the array a, which is iterated over, and its elements printed to stdout. Note that the order is not as original, because the array is implemented as a hash table.

$ awk 'BEGIN{split("a b c d",a);for(i in a)print a[i]}'

c

<lang c> int array_index(int array[], int index) {

return array[index];

}</lang>

int getArrayValue( int values[], int index ) {

return values[index];

}

<lang cpp> template<typename T>

}</lang>

<cfset arr = ArrayNew(1)>

<cfset arr[1] = "one">

''ColdFusion Arrays are '''NOT''' zero-based, their index begins at '''1'''''

(defun array-value (array index)

(aref array index))

Generic, template-based method. Allows retriving elements

of arrays and objects having opIndex method implemented.

</lang>

Arrays 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 inception.

where n is the array index who's base is either 1 or 0 depending on how it was declared.

<lang e>def value := array[index]</lang>

:''Array module work with arrays'':

Value = array:get(Index, Array).

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

In ANSI Fortran 90 or later:

real, dimension(-10:20) :: a ! a one-dimensional real array indexed from -10 to 20

Define an array

arr = ['groovy', 'is', 'a', 'great', 'language']

arr[0..2, -1] // *** ['groovy', 'is', 'a', 'language']

Arrays can have arbitrary bounds (not restricted to integer values, any instance of ''Ix'' will do):

Here, ''result'' will be equal to "an". It should be noted that in Haskell lists are often used instead of arrays.

; this is allowed:

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>.

Arrays are the only way J handles data, so every program that produces a portion of a given array is relevant here. In these few examples emphasis is on the primary verb <tt>{</tt> ("from").

30 31

Object element = array[index];

var element = array[index];

print item 1 {10 20 30} ; 10

10 array :array

array 5 [] @ # contents of sixth cell in array

<lang Mathematica>

element = array[[index]]

First index is 1, negative indices count from the back, -1 being the last element. [ [ 0 ] ] returns the head. The [ [ ] ]-command (Part) works not only on a list, it works on everything: graphics, equations, matrices of any dimension et cetera. To dig deeper you can specifiy multiple indices [ [ a, b, c ] ] to get the c^th element of the b^th element of the a^th element. For any level you can specify a range using ;;, i.e.: a;;b;;c would give elements a through b in steps of c. If a is not given it will assume 1, if b is not give it will be -1, if c is not given it will be 1.

item = arr[index]

{{works with|mIRC Script Editor}}

{{works with|mArray Snippet}}

alias readmyarray { echo -a $array_read(MyArray, 2, 3) }

<pre>

VAR arr := ARRAY [1..3] OF INTEGER {1, 2, 3};

</pre>

Nial is an array programming language. Thus it has a variety of ways

to retrieve elements of an (even multi-dimensional) array.

There are quite a few others (too large to list here).

{{works with|GNUstep}}

id element = [array objectAtIndex:index];</lang>

let element = array.(index)

<lang octave>a = [1:10];

{{works with|Perl|5.8.8}}

$elem = $array[0];

<lang php> $array = array('php', 'has', 'arrays');

// First element

$elem = $array[0];</lang>

lvars ar = {1 two 'three'};

lvars 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.

{{works with|Python|2.5}}

The item is an element in a list at a given index

'''Note:''' When using the pop() method, the element is removed from the list.

An element from a vector can be retrieved with the []; slices can be taken using ranges or another vector of indexes.

print(a[2,1])</lang>

<lang ruby> ary = ['Ruby','rules','big','time']

#the first element

# => element = "big"</lang>

Lists are more often used in Scheme than vectors

<lang scheme> (vector-ref array index)</lang>

<lang slate>{$a. #(1 2). 'b'. True} at: 2</lang>

<lang smalltalk> #($a $b $c) at: 2</lang>

val element = Array.sub (array, index)

All arrays in Tcl are associative. If "key" is the variable that holds the key of the element to be retrieved, then

<lang tcl>set result $array($key)</lang>

<lang tcl>set result [lindex $list $index]</lang>

This retrieves the value 20 from the second item in the array:

table 1 array.get

{{works with|nasm}}