Arrays

From Rosetta Code
Jump to: navigation, search
Task
Arrays
You are encouraged to solve this task according to the task description, using any language you may know.

This task is about arrays. For hashes or associative arrays, please see Creating an Associative Array.

In this task, the goal is to show basic array syntax in your language. Basically, create an array, assign a value to it, and retrieve an element. (if available, show both fixed-length arrays and dynamic arrays, pushing a value into it.)

Please discuss at Village Pump: Arrays. Please merge code in from obsolete tasks Creating an Array, Assigning Values to an Array, and Retrieving an Element of an Array.

See also

Contents

[edit] ACL2

;; Create an array and store it in array-example
(assign array-example
(compress1 'array-example
(list '(:header :dimensions (10)
:maximum-length 11))))
 
;; Set a[5] to 22
(assign array-example
(aset1 'array-example
(@ array-example)
5
22))
 
;; Get a[5]
(aref1 'array-example (@ array-example) 5)

[edit] ActionScript

//creates an array of length 10
var array1:Array = new Array(10);
//creates an array with the values 1, 2
var array2:Array = new Array(1,2);
//arrays can also be set using array literals
var array3:Array = ["foo", "bar"];
//to resize an array, modify the length property
array2.length = 3;
//arrays can contain objects of multiple types.
array2[2] = "Hello";
//get a value from an array
trace(array2[2]);
//append a value to an array
array2.push(4);
//get and remove the last element of an array
trace(array2.pop());

[edit] Ada

procedure Array_Test is
 
A, B : array (1..20) of Integer;
 
-- Ada array indices may begin at any value, not just 0 or 1
C : array (-37..20) of integer
 
-- Ada arrays may be indexed by enumerated types, which are
-- discrete non-numeric types
type Days is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
type Activities is (Work, Fish);
type Daily_Activities is array(Days) of Activities;
This_Week : Daily_Activities := (Mon..Fri => Work, Others => Fish);
 
-- Or any numeric type
type Fingers is range 1..4; -- exclude thumb
type Fingers_Extended_Type is array(fingers) of Boolean;
Fingers_Extended : Fingers_Extended_Type;
 
-- Array types may be unconstrained. The variables of the type
-- must be constrained
type Arr is array (Integer range <>) of Integer;
Uninitialized : Arr (1 .. 10);
Initialized_1 : Arr (1 .. 20) := (others => 1);
Initialized_2 : Arr := (1 .. 30 => 2);
Const  : constant Arr := (1 .. 10 => 1, 11 .. 20 => 2, 21 | 22 => 3);
Centered  : Arr (-50..50) := (0 => 1, Others => 0);
 
Result  : Integer
begin
 
A := (others => 0); -- Assign whole array
B := (1 => 1, 2 => 1, 3 => 2, others => 0);
-- Assign whole array, different values
A (1) := -1; -- Assign individual element
A (2..4) := B (1..3); -- Assign a slice
A (3..5) := (2, 4, -1); -- Assign a constant slice
A (3..5) := A (4..6); -- It is OK to overlap slices when assigned
 
Fingers_Extended'First := False; -- Set first element of array
Fingers_Extended'Last := False; -- Set last element of array
 
end Array_Test;

Arrays are first-class objects in Ada. They can be allocated statically or dynamically as any other object. The number of elements in an array object is always constrained. Variable size arrays are provided by the standard container library. They also can be implemented as user-defined types.

[edit] Aikido

Aikido arrays (or vectors) are dynamic and not fixed in size. They can hold a set of any defined value.

 
var arr1 = [1,2,3,4] // initialize with array literal
var arr2 = new [10] // empty array of 10 elements (each element has value none)
var arr3 = new int [40] // array of 40 integers
var arr4 = new Object (1,2) [10] // array of 10 instances of Object
 
arr1.append (5) // add to array
var b = 4 in arr1 // check for inclusion
arr1 <<= 2 // remove first 2 elements from array
var arrx = arr1[1:3] // get slice of array
var s = arr1.size() // or sizeof(arr1)
delete arr4[2] // remove an element from an array
 
var arr5 = arr1 + arr2 // append arrays
var arr6 = arr1 | arr2 // union
var arr7 = arr1 & arr2 // intersection
 
 

[edit] Aime

The aime list is a heterogeneous, dynamic sequence. No special creation procedure, only declaration is needed:

list l;

Values (numbers, strings, collections, functions, etc) can be added in a type generic fashion:

l_append(l, 3);
l_append(l, "arrays");
l_append(l, pow);

The insertion position can be specified:

l_push(l, 3, .5);
l_push(l, 4, __type(l));

More aptly, values (of selected types) can be inserted in a type specific fashion:

l_p_integer(l, 5, -1024);
l_p_real(l, 6, 88);

Similarly, values can be retrieved in a type generic fashion:

l_query(l, 5);

or is type specific fashion:

l_q_real(l, 6);
l_q_text(l, 1);

[edit] ALGOL 68

PROC array_test = VOID:
(
[1:20]INT a;
a := others; # assign whole array #
a[1] := -1; # assign individual element #
a[3:5] := (2, 4, -1); # assign a slice #
[1:3]INT slice = a[3:5]; # copy a slice #
 
REF []INT rslice = a[3:5]; # create a reference to a slice #
print((LWB rslice, UPB slice)); # query the bounds of the slice #
rslice := (2, 4, -1); # assign to the slice, modifying original array #
 
[1:3, 1:3]INT matrix; # create a two dimensional array #
REF []INT hvector = matrix[2,]; # create a reference to a row #
REF []INT vvector = matrix[,2]; # create a reference to a column #
REF [,]INT block = matrix[1:2, 1:2]; # create a reference to an area of the array #
 
FLEX []CHAR string := "Hello, world!"; # create an array with variable bounds #
string := "shorter" # flexible arrays automatically resize themselves on assignment #
)

Arrays in ALGOL 68 are first class objects. Slices to any portion of the array can be created and then treated equivalently to arrays, even sections of a multidimensional array; the bounds are queried at run time. References may be made to portions of an array. Flexible arrays are supported, which resize themselves on assignment, but they can't be resized without destroying the data.

[edit] AmigaE

DEF ai[100] : ARRAY OF CHAR, -> static
da: PTR TO CHAR,
la: PTR TO CHAR
 
PROC main()
da := New(100)
-> or
NEW la[100]
IF da <> NIL
ai[0] := da[0] -> first is 0
ai[99] := da[99] -> last is "size"-1
Dispose(da)
ENDIF
-> using NEW, we must specify the size even when
-> "deallocating" the array
IF la <> NIL THEN END la[100]
ENDPROC

[edit] App Inventor

Arrays in App Inventor are represented with Lists. Lists may be nested to any level and contain other Lists. All supported data types may be stored in a List. Basic List blocks

[edit] AppleScript

AppleScript arrays are called lists:

 set empty to {}
set ints to {1, 2, 3}

Lists can contain any objects including other lists:

 set any to {1, "foo", 2.57, missing value, ints}

[edit] Argile

Works with: Argile version 1.0.0
use std, array
 
(:::::::::::::::::
 : Static arrays :
 :::::::::::::::::)
let the array of 2 text aabbArray be Cdata{"aa";"bb"}
let raw array of real :my array: = Cdata {1.0 ; 2.0 ; 3.0} (: auto sized :)
let another_array be an array of 256 byte (: not initialised :)
let (raw array of (array of 3 real)) foobar = Cdata {
{1.0; 2.0; 0.0}
{5.0; 1.0; 3.0}
}
 
(: macro to get size of static arrays :)
=: <array>.length := -> nat {size of array / (size of array[0])}
printf "%lu, %lu\n" foobar.length (another_array.length) (: 2, 256 :)
 
(: access :)
another_array[255] = '&'
printf "`%c'\n" another_array[255]
 
 
(::::::::::::::::::
 : Dynamic arrays :
 ::::::::::::::::::)
let DynArray = new array of 5 int
DynArray[0] = -42
DynArray = (realloc DynArray (6 * size of DynArray[0])) as (type of DynArray)
DynArray[5] = 243
prints DynArray[0] DynArray[5]
del DynArray
Works with: Argile version 1.1.0
use std, array
let x = @["foo" "bar" "123"]
print x[2]
x[2] = "abc"


[edit] AutoHotkey

Works with: AutoHotkey_L

The current, official build of AutoHotkey is called AutoHotkey_L. In it, arrays are called Objects, and associative/index based work hand-in-hand.

myArray := Object() ; could use JSON-syntax sugar like {key: value}
myArray[1] := "foo"
myArray[2] := "bar"
MsgBox % myArray[2]
 
; Push a value onto the array
myArray.Insert("baz")

AutoHotkey Basic (deprecated) did not have typical arrays. However, variable names could be concatenated, simulating associative arrays. By convention, based on built-in function stringsplit, indexes are 1-based and "0" index is the length.

arrayX0 = 4      ; length
arrayX1 = first
arrayX2 = second
arrayX3 = foo
arrayX4 = bar
Loop, %arrayX0%
Msgbox % arrayX%A_Index%
source = apple bear cat dog egg fish
StringSplit arrayX, source, %A_Space%
Loop, %arrayX0%
Msgbox % arrayX%A_Index%

[edit] AutoIt

Create an userdefined array.

 
#include <Array.au3> ;Include extended Array functions (_ArrayDisplay)
 
Local $aInputs[1] ;Create the Array with just 1 element
 
While True ;Endless loop
$aInputs[UBound($aInputs) - 1] = InputBox("Array", "Add one value") ;Save user input to the last element of the Array
If $aInputs[UBound($aInputs) - 1] = "" Then ;If an empty string is entered, then...
ReDim $aInputs[UBound($aInputs) - 1] ;...remove them from the Array and...
ExitLoop ;... exit the loop!
EndIf
ReDim $aInputs[UBound($aInputs) + 1] ;Add an empty element to the Array
WEnd
 
_ArrayDisplay($aInputs) ;Display the Array
 

[edit] AWK

Every array in AWK is an associative array. AWK converts each array subscript to a string, so a[33], a["33"] and a[29 + 4] are the same element.

An ordered array just uses subscripts as integers. Array subscripts can start at 1, or any other integer. The built-in split() function makes arrays that start at 1.

BEGIN {
# to make an array, assign elements to it
array[1] = "first"
array[2] = "second"
array[3] = "third"
alen = 3 # want the length? store in separate variable
 
# or split a string
plen = split("2 3 5 7 11 13 17 19 23 29", primes)
clen = split("Ottawa;Washington DC;Mexico City", cities, ";")
 
# retrieve an element
print "The 6th prime number is " primes[6]
 
# push an element
cities[clen += 1] = "New York"
 
dump("An array", array, alen)
dump("Some primes", primes, plen)
dump("A list of cities", cities, clen)
}
 
function dump(what, array, len, i) {
print what;
 
# iterate an array in order
for (i = 1; i <= len; i++) {
print " " i ": " array[i]
}
}

Output:

The 6th prime number is 13
An array
  1: first
  2: second
  3: third
Some primes
  1: 2
  2: 3
  3: 5
  4: 7
  5: 11
  6: 13
  7: 17
  8: 19
  9: 23
  10: 29
A list of cities
  1: Ottawa
  2: Washington DC
  3: Mexico City
  4: New York

[edit] Babel

[edit] Create an array

[val 1 2 3]

OR

[ptr 1 2 3]

There are two kinds of array in Babel: value arrays and pointer arrays.

[edit] Get a single array element

[val 1 2 3] 1 th

Yields 2

[edit] Change an array element

[val 1 2 3] 7 1 paste

Yields [val 1 7 3]

[ptr 1 2 3] [ptr 7] 1 paste

Yields [ptr 1 7 3]

[edit] Select a range of an array

[ptr 'foo' 'bar' 'baz' 'bop'] 1 3 slice

Yields [ptr 'bar' 'baz']

[edit] Add a new element to an array

There is no direct method to add a new element to an array in Babel. Instead, you should convert the array to a list using the ar2ls operator, then add to the list. When you are finished manipulating the list, convert back to an array using either the bons operator or the ar2lf operator.

The other method is to create a new larger array and copy the old array into it, then add the additional element. However, this method is "un-Babelish":

 
[ptr 1 2 3] dup
<- arlen 1 + newin dup dup ->
0 paste
[ptr 4] 3 paste
 

Yields [ptr 1 2 3 4].

The Babelish method:

 
[ptr 1 2 3]
ar2ls (4) unshift bons

[edit] BASIC

Works with: QuickBasic version 4.5
Works with: PB version 7.1

The default array base (lower bound) can be set with OPTION BASE. If OPTION BASE is not set, the base may be either 0 or 1, depending on implementation. The value given in DIM statement is the upper bound. If the base is 0, then DIM a(100) will create an array containing 101 elements.

 OPTION BASE 1
DIM myArray(100) AS INTEGER

Alternatively, the lower and upper bounds can be given while defining the array:

 DIM myArray(-10 TO 10) AS INTEGER 

Dynamic arrays:

 'Specify that the array is dynamic and not static:
'$DYNAMIC
DIM SHARED myArray(-10 TO 10, 10 TO 30) AS STRING
REDIM SHARED myArray(20, 20) AS STRING
myArray(1,1) = "Item1"
myArray(1,2) = "Item2"

Array Initialization

Arrays are initialized to zero or zero length strings when created. BASIC does not generally have option for initializing arrays to other values, so the initializing is usually done at run time. DATA and READ statements are often used for this purpose:

 DIM month$(12)
DATA January, February, March, April, May, June, July
DATA August, September, October, November, December
FOR m=1 TO 12
READ month$(m)
NEXT m
Works with: FreeBASIC

FreeBASIC has an option to initialize array while declaring it.

 Dim myArray(1 To 2, 1 To 5) As Integer => {{1, 2, 3, 4, 5}, {1, 2, 3, 4, 5}} 
10 REM TRANSLATION OF QBASIC STATIC VERSION
20 REM ELEMENT NUMBERS TRADITIONALLY START AT ONE
30 DIM A%(11): REM ARRAY OF ELEVEN INTEGER ELEMENTS
40 LET A%(1) = -1
50 LET A%(11) = 1
60 PRINT A%(1), A%(11)
70 END
Works with: qbasic

[edit] Static

DIM staticArray(10) AS INTEGER
 
staticArray(0) = -1
staticArray(10) = 1
 
PRINT staticArray(0), staticArray(10)

[edit] Dynamic

Note that BASIC dynamic arrays are not stack-based; instead, their size must be changed in the same manner as their initial declaration -- the only difference between static and dynamic arrays is the keyword used to declare them (DIM vs. REDIM). QBasic lacks the PRESERVE keyword found in some modern BASICs; resizing an array without PRESERVE zeros the values.

REDIM dynamicArray(10) AS INTEGER
 
dynamicArray(0) = -1
PRINT dynamicArray(0)
 
REDIM dynamicArray(20)
 
dynamicArray(20) = 1
PRINT dynamicArray(0), dynamicArray(20)

[edit] BASIC256

# numeric array
dim numbers(10)
for t = 0 to 9
numbers[t] = t + 1
next t
 
# string array
dim words$(10)
# assigning an array with a list
words$ = {"one","two","three","four","five","six","seven","eight","nine","ten"}
 
gosub display
 
# resize arrays (always preserves values if larger)
redim numbers(11)
redim words$(11)
numbers[10] = 11
words$[10] = "eleven"
gosub display
 
end
 
display:
# display arrays
# using ? to get size of array
for t = 0 to numbers[?]-1
print numbers[t] + "=" + words$[t]
next t
return

[edit] Batch File

Arrays can be approximated, in a style similar to REXX

::arrays.cmd
@echo off
setlocal ENABLEDELAYEDEXPANSION
set array.1=1
set array.2=2
set array.3=3
set array.4=4
for /L %%i in (1,1,4) do call :showit array.%%i !array.%%i!
set c=-27
call :mkarray marry 5 6 7 8
for /L %%i in (-27,1,-24) do call :showit "marry^&%%i" !marry^&%%i!
endlocal
goto :eof
 
:mkarray
set %1^&%c%=%2
set /a c += 1
shift /2
if "%2" neq "" goto :mkarray
goto :eof
 
:showit
echo %1 = %2
goto :eof
 

Output:

array.1 = 1
array.2 = 2
array.3 = 3
array.4 = 4
"marry&-27" = 5
"marry&-26" = 6
"marry&-25" = 7
"marry&-24" = 8

[edit] BBC BASIC

      REM Declare arrays, dimension is maximum index:
DIM array(6), array%(6), array$(6)
 
REM Entire arrays may be assigned in one statement:
array() = 0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7
array%() = 0, 1, 2, 3, 4, 5, 6
array$() = "Zero", "One", "Two", "Three", "Four", "Five", "Six"
 
REM Or individual elements may be assigned:
array(2) = PI
array%(3) = RND
array$(4) = "Hello world!"
 
REM Print out sample array elements:
PRINT array(2) TAB(16) array(3) TAB(32) array(4)
PRINT array%(2) TAB(16) array%(3) TAB(32) array%(4)
PRINT array$(2) TAB(16) array$(3) TAB(32) array$(4)

[edit] bc

There are 26 arrays available (named 'a' to 'z') with all elements initialized to zero and an installation-specific maximum size (in GNU bc you can find out the limits of your installation (BC_DIM_MAX) by invoking the limits command). Array identifiers are always followed by square brackets ('[', ']') and need not be declared/defined before usage. Indexing starts at zero.

The following is a transcript of an interactive session:

/* Put the value 42 into array g at index 3 */
g[3] = 42
/* Look at some other elements in g */
g[2]
0
g[4342]
0
/* Look at the elements of another array */
a[543]
0
/* Array names don't conflict with names of ordinary (scalar) identifiers */
g
0
g = 123
g
123
g[3]
42

[edit] BML

Note: Variables in BML can either be placed in a prefix group($, @, and &) or in the world. Placing variables in the world is not recommended since it can take large sums of memory when using said variable.

 
% Define an array(containing the numbers 1-3) named arr in the group $
in $ let arr hold 1 2 3
 
% Replace the value at index 0 in array to "Index 0"
set $arr index 0 to "Index 0"
 
% Will display "Index 0"
display $arr index 0
 
% There is no automatic garbage collection
delete $arr
 

[edit] Bracmat

In Bracmat, an array is not a variable, but a stack of variables. In fact, local variables in functions are elements in arrays. Global variables are the zeroth element in such arrays. You can explicitly create an array of a specific size using the tbl function. Indexing is done by using the syntax integer$name. Indexing is modulo the size of the array. A negative integer counts from the end of the array and backwards. The last used index is remembered by the array. Arrays can grow and shrink by calling tbl with other values. When shrinking, the values of the upper elements are lost. When growing, the current values are kept and the new elements are initialised with 0. To delete and array (and therefore the variable with the array's name), call tbl with a size 0.

( tbl$(mytable,100)
& 5:?(30$mytable)
& 9:?(31$mytable)
& out$(!(30$mytable))
& out$(!(-169$mytable)) { -169 mod 100 == 31 }
& out$!mytable { still index 31 }
& tbl$(mytable,0)
& (!mytable & out$"mytable still exists"
| out$"mytable is gone"
)
);

Output:

5
9
9
mytable is gone

[edit] Boo

 
myArray as (int) = (1, 2, 3) // Size based on initialization
fixedArray as (int) = array(int, 1) // Given size(1 in this case)
 
myArray[0] = 10
 
myArray = myArray + fixedArray // Append arrays
 
print myArray[0]
 

[edit] C

Fixed size static array of integers with initialization:

int myArray2[10] = { 1, 2, 0 }; /* the rest of elements get the value 0 */
float myFloats[] ={1.2, 2.5, 3.333, 4.92, 11.2, 22.0 }; /* automatically sizes */

When no size is given, the array is automatically sized. Typically this is how initialized arrays are defined. When this is done, you'll often see a definition that produces the number of elements in the array, as follows.

#define MYFLOAT_SIZE (sizeof(myFloats)/sizeof(myFloats[0]))

When defining autosized multidimensional arrays, all the dimensions except the first (leftmost) need to be defined. This is required in order for the compiler to generate the proper indexing for the array.

long a2D_Array[3][5];    /* 3 rows, 5 columns. */
float my2Dfloats[][3] = {
1.0, 2.0, 0.0,
5.0, 1.0, 3.0 };
#define FLOAT_ROWS (sizeof(my2Dfloats)/sizeof(my2dFloats[0]))

When the size of the array is not known at compile time, arrays may be dynamically allocated to the proper size. The malloc(), calloc() and free() functions require the header stdlib.h.

int numElements = 10;
int *myArray = malloc(sizeof(int) * numElements); /* array of 10 integers */
if ( myArray != NULL ) /* check to ensure allocation succeeded. */
{
/* allocation succeeded */
/* at the end, we need to free the allocated memory */
free(myArray);
}
/* calloc() additionally pre-initializes to all zeros */
short *myShorts = calloc( numElements, sizeof(short)); /* array of 10 */
if (myShorts != NULL)....

Once allocated, myArray can be used as a normal array.

The first element of a C array is indexed with 0. To set a value:

myArray[0] = 1;
myArray[1] = 3;

And to retrieve it (e.g. for printing, provided that the stdio.h header was included for the printf function)

printf("%d\n", myArray[1]);

The array[index] syntax can be considered as a shortcut for *(index + array) and thus the square brackets are a commutative binary operator:

*(array + index) = 1;
printf("%d\n", *(array + index));
3[array] = 5;

There's no bounds check on the indexes. Negative indexing can be implemented as in the following.

#define XSIZE 20
double *kernel = malloc(sizeof(double)*2*XSIZE+1);
if (kernel) {
kernel += XSIZE;
for (ix=-XSIZE; ix<=XSIZE; ix++) {
kernel[ix] = f(ix);
....
free(kernel-XSIZE);
}
}

In C99, it is possible to declare arrays with a size that is only known at runtime (e.g. a number input by the user).

Typically dynamic allocation is used and the allocated array is sized to the maximum that might be needed. A additional variable is declared and used to maintain the current number of elements used. In C, arrays may be dynamically resized if they were allocated:

 
int *array = malloc (sizeof(int) * 20);
....
array = realloc(array, sizeof(int) * 40);
 

[edit] C++

Works with: C++11

C++ supports several types of array, depending on whether or not the size is known at compile time, and whether the array must be fixed-size or can grow.

std::array<T, N> is a fixed-size array of T objects. The size (N) must be known at compile time. It wraps a C array, and provides additional functionality and safety. Depending on how it is used, it may be dynamically allocated on the stack as needed, placed in read-only program memory at load time, or possibly may only exist during compilation and get optimized away, among other possibilities.

std::vector<T> is a resizable array of T objects. The memory for the array will be allocated from the heap (unless a custom allocator is used).

#include <array>
#include <vector>
 
// These headers are only needed for the demonstration
#include <algorithm>
#include <iostream>
#include <iterator>
#include <string>
 
// This is a template function that works for any array-like object
template <typename Array>
void demonstrate(Array& array)
{
// Array element access
array[2] = "Three"; // Fast, but unsafe - if the index is out of bounds you
// get undefined behaviour
array.at(1) = "Two"; // *Slightly* less fast, but safe - if the index is out
// of bounds, an exception is thrown
 
// Arrays can be used with standard algorithms
std::reverse(begin(array), end(array));
std::for_each(begin(array), end(array),
[](typename Array::value_type const& element) // in C++14, you can just use auto
{
std::cout << element << ' ';
});
 
std::cout << '\n';
}
 
int main()
{
// Compile-time sized fixed-size array
auto fixed_size_array = std::array<std::string, 3>{ "One", "Four", "Eight" };
// If you do not supply enough elements, the remainder are default-initialized
 
// Dynamic array
auto dynamic_array = std::vector<std::string>{ "One", "Four" };
dynamic_array.push_back("Eight"); // Dynamically grows to accept new element
 
// All types of arrays can be used more or less interchangeably
demonstrate(fixed_size_array);
demonstrate(dynamic_array);
}

[edit] C#

Example of array of 10 int types:

 int[] numbers = new int[10];

Example of array of 3 string types:

 string[] words = { "these", "are", "arrays" };

You can also declare the size of the array and initialize the values at the same time:

  int[] more_numbers = new int[3]{ 21, 14 ,63 };


For Multi-Dimensional arrays you declare them the same except for a comma in the type declaration.

The following creates a 3x2 int matrix

  int[,] number_matrix = new int[3,2];

As with the previous examples you can also initialize the values of the array, the only difference being each row in the matrix must be enclosed in its own braces.

  string[,] string_matrix = { {"I","swam"}, {"in","the"}, {"freezing","water"} };

or

 string[,] funny_matrix = new string[2,2]{ {"clowns", "are"} , {"not", "funny"} };
int[] array = new int[10];
 
array[0] = 1;
array[1] = 3;
 
Console.WriteLine(array[0]);

Dynamic

using System;
using System.Collections.Generic;
 
List<int> list = new List<int>();
 
list.Add(1);
list.Add(3);
 
list[0] = 2;
 
Console.WriteLine(list[0]);

[edit] Clean

Array denotations are overloaded in Clean, therefore we explicitly specify the types. There are lazy, strict, and unboxed array.

[edit] Lazy array

Create a lazy array of strings using an array denotation.

array :: {String}
array = {"Hello", "World"}

Create a lazy array of floating point values by sharing a single element.

array :: {Real}
array = createArray 10 3.1415

Create a lazy array of integers using an array (and also a list) comprehension.

array :: {Int}
array = {x \\ x <- [1 .. 10]}

[edit] Strict array

Create a strict array of integers.

array :: {!Int}
array = {x \\ x <- [1 .. 10]}

[edit] Unboxed array

Create an unboxed array of characters, also known as String.

array :: {#Char}
array = {x \\ x <- ['a' .. 'z']}

[edit] Clipper

Clipper arrays aren't divided to fixed-length and dynamic. Even if we declare it with a certain dimensions, it can be resized in the same way as it was created dynamically. The first position in an array is 1, not 0, as in some other languages.

   // Declare and initialize two-dimensional array
Local arr1 := { { "NITEM","N",10,0 }, { "CONTENT","C",60,0} }
// Create an empty array
Local arr2 := {}
// Declare three-dimensional array
Local arr3[2,100,3]
// Create an array
Local arr4 := Array(50)
 
// Array can be dynamically resized:
arr4 := ASize( arr4, 80 )

Items, including nested arrays, can be added to existing array, deleted from it, assigned to it

// Adding new item to array, its size is incremented
Aadd( arr1, { "LBASE","L",1,0 } )
// Delete the first item of arr3, The size of arr3 remains the same, all items are shifted to one position, the last item is replaced by Nil:
ADel( arr1, 1 )
// Assigning a value to array item
arr3[1,1,1] := 11.4

Retrieve items of an array:

   x := arr3[1,10,2]
// The retrieved item can be nested array, in this case it isn't copied, the pointer to it is assigned
 

There is a set of functions to manage arrays in Clipper, including the following:

// Fill the 20 items of array with 0, starting from 5-th item:
AFill( arr4, 0, 5, 20 )
//Copy 10 items from arr4 to arr3[2], starting from the first position:
ACopy( arr4, arr3[2], 1, 10 )
//Duplicate the whole or nested array:
arr5 := AClone( arr1 )
arr6 := AClone( arr1[3] )

[edit] Clojure

;clojure is a language built with immutable/persistent data structures. there is no concept of changing what a vector/list 
;is, instead clojure creates a new array with an added value using (conj...)
;in the example below the my-list does not change.
 
 
user=> (def my-list (list 1 2 3 4 5))
 
user=> my-list
(1 2 3 4 5)
 
user=> (first my-list)
1
 
user=> (nth my-list 3)
4
 
user=> (conj my-list 100) ;adding to a list always adds to the head of the list
(100 1 2 3 4 5)
 
user=> my-list ;it is impossible to change the list pointed to by my-list
(1 2 3 4 5)
 
user=> (def my-new-list (conj my-list 100))
 
user=> my-new-list
(100 1 2 3 4 5)
 
user=> (cons 200 my-new-list) ;(cons makes a new list, (conj will make a new object of the same type as the one it is given
(200 100 1 2 3 4 5)
 
user=> (def my-vec [1 2 3 4 5 6])
 
user=> (conj my-vec 300) ;adding to a vector always adds to the end of the vector
[1 2 3 4 5 6 300]

[edit] COBOL

In COBOL, arrays are called tables. Also, indexes begin from 1.

       IDENTIFICATION DIVISION.
PROGRAM-ID. arrays.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 fixed-length-table.
03 fixed-table-elt PIC X OCCURS 5 TIMES.
 
01 table-length PIC 9(5) VALUE 1.
01 variable-length-table.
03 variable-table-elt PIC X OCCURS 1 TO 5 TIMES
DEPENDING ON table-length.
 
01 initial-value-area.
03 initial-values.
05 FILLER PIC X(10) VALUE "One".
05 FILLER PIC X(10) VALUE "Two".
05 FILLER PIC X(10) VALUE "Three".
03 initial-value-table REDEFINES initial-values.
05 initial-table-elt PIC X(10) OCCURS 3 TIMES.
 
01 indexed-table.
03 indexed-elt PIC X OCCURS 5 TIMES
INDEXED BY table-index.
 
PROCEDURE DIVISION.
*> Assigning the contents of an entire table.
MOVE "12345" TO fixed-length-table
 
*> Indexing an array (using an index)
MOVE 1 TO table-index
MOVE "1" TO indexed-elt (table-index)
 
*> Pushing a value into a variable-length table.
ADD 1 TO table-length
MOVE "1" TO variable-table-elt (2)
 
GOBACK
.

[edit] CoffeeScript

array1 = []
array1[0] = "Dillenidae"
array1[1] = "animus"
array1[2] = "Kona"
alert "Elements of array1: " + array1 # Dillenidae,animus,Kona
 
array2 = ["Cepphus", "excreta", "Gansu"]
alert "Value of array2[1]: " + array2[1] # excreta

[edit] ColdFusion

Creating a one-dimensional Array:

<cfset arr1 = ArrayNew(1)>

Creating a two-dimensional Array in CFScript:

<cfscript>
arr2 = ArrayNew(2);
</cfscript>

ColdFusion Arrays are NOT zero-based, they begin at index 1

[edit] Common Lisp

(let ((array (make-array 10)))
(setf (aref array 0) 1
(aref array 1) 3)
(print array))

Dynamic

(let ((array (make-array 0 :adjustable t :fill-pointer 0)))
(vector-push-extend 1 array)
(vector-push-extend 3 array)
(setf (aref array 0) 2)
(print array))

Creates a one-dimensional array of length 10. The initial contents are undefined.

(make-array 10)

Creates a two-dimensional array with dimensions 10x20.

(make-array '(10 20))

make-array may be called with a number of optional arguments.

; Makes an array of 20 objects initialized to nil
(make-array 20 :initial-element nil)
; Makes an integer array of 4 elements containing 1 2 3 and 4 initially which can be resized
(make-array 4 :element-type 'integer :initial-contents '(1 2 3 4) :adjustable t)

[edit] Component Pascal

An arrays in Component Pascal are started from zero index.


 
MODULE TestArray;
(* Implemented in BlackBox Component Builder *)
 
IMPORT Out;
 
(* Static array *)
 
PROCEDURE DoOneDim*;
CONST M = 5;
VAR a: ARRAY M OF INTEGER;
BEGIN
a[0] := 100; (* set first element's value of array a to 100 *)
a[M-1] := -100; (* set M-th element's value of array a to -100 *)
Out.Int(a[0], 0); Out.Ln;
Out.Int(a[M-1], 0); Out.Ln;
END DoOneDim;
 
PROCEDURE DoTwoDim*;
VAR b: ARRAY 5, 4 OF INTEGER;
BEGIN
b[1, 2] := 100; (* second row, third column element *)
b[4, 3] := -100; (* fifth row, fourth column element *)
Out.Int(b[1, 2], 0); Out.Ln;
Out.Int(b[4, 3], 0); Out.Ln;
END DoTwoDim;
 
END TestArray.

[edit] D

// All D arrays are capable of bounds checks.
 
import std.stdio, core.stdc.stdlib;
import std.container: Array;
 
void main() {
// GC-managed heap allocated dynamic array:
auto array1 = new int[1];
array1[0] = 1;
array1 ~= 3; // append a second item
// array1[10] = 4; // run-time error
writeln("A) Element 0: ", array1[0]);
writeln("A) Element 1: ", array1[1]);
 
// Stack-allocated fixed-size array:
int[5] array2;
array2[0] = 1;
array2[1] = 3;
// array2[2] = 4; // compile-time error
writeln("B) Element 0: ", array2[0]);
writeln("B) Element 1: ", array2[1]);
 
// Stack-allocated dynamic fixed-sized array,
// length known only at run-time:
int n = 2;
int[] array3 = (cast(int*)alloca(n * int.sizeof))[0 .. n];
array3[0] = 1;
array3[1] = 3;
// array3[10] = 4; // run-time error
writeln("C) Element 0: ", array3[0]);
writeln("C) Element 1: ", array3[1]);
 
// Phobos-defined heap allocated not GC-managed array:
Array!int array4;
array4.length = 2;
array4[0] = 1;
array4[1] = 3;
// array4[10] = 4; // run-time exception
writeln("D) Element 0: ", array4[0]);
writeln("D) Element 1: ", array4[1]);
}
Output:
A) Element 0: 1
A) Element 1: 3
B) Element 0: 1
B) Element 1: 3
C) Element 0: 1
C) Element 1: 3
D) Element 0: 1
D) Element 1: 3

One more kind of built-in array:

import std.stdio, core.simd;
 
void main() {
// Stack-allocated vector for SIMD registers:
ubyte16 vector5;
vector5.array[0] = 1;
vector5.array[1] = 3;
// vector5.array[17] = 4; // Compile-time error.
writeln("E) Element 0: ", vector5.array[0]);
writeln("E) Element 1: ", vector5.array[1]);
}
Output:
E) Element 0: 1
E) Element 1: 3

[edit] Dao

# use [] to create numeric arrays of int, float, double or complex types:
a = [ 1, 2, 3 ] # a vector
b = [ 1, 2; 3, 4 ] # a 2X2 matrix
 
# use {} to create normal arrays of any types:
c = { 1, 2, 'abc' }
 
d = a[1]
e = b[0,1] # first row, second column
f = c[1]

[edit] Déjà Vu

In Déjà Vu, the relevant datatype is called list, which is basically a stack with random element access for getting and setting values.

#create a new list
local :l []
 
#add something to it
push-to l "Hi"
 
#add something else to it
push-to l "Boo"
 
#the list could also have been built up this way:
local :l2 [ "Hi" "Boo" ]
 
#this prints 2
!print len l
 
#this prints Hi
!print get-from l 0
 
#this prints Boo
!print pop-from l
 

[edit] Delphi

This example creates a static and dynamic array, asks for a series of numbers storing them in the static one, puts in the dynamic one the numbers in reverse order, concatenates the number in two single string variables and display those strings in a popup window.

 
procedure TForm1.Button1Click(Sender: TObject);
var
StaticArray: array[0..9] of Integer;
DynamicArray: array of Integer;
StaticArrayText,
DynamicArrayText: string;
lcv: Integer;
begin
// Setting the length of the dynamic array the same as the static one
SetLength(DynamicArray, Length(StaticArray));
// Asking random numbers storing into the static array
for lcv := 0 to Pred(Length(StaticArray)) do
begin
StaticArray[lcv] := StrToInt(
InputBox('Random number',
'Enter a random number for position',
IntToStr(Succ(lcv))));
end;
// Storing entered numbers of the static array in reverse order into the dynamic
for lcv := 0 to Pred(Length(StaticArray)) do
DynamicArray[Pred(Length(DynamicArray)) - lcv] := StaticArray[lcv];
// Concatenating the static and dynamic array into a single string variable
for lcv := 0 to Pred(Length(StaticArray)) do
begin
StaticArrayText := StaticArrayText + IntToStr(StaticArray[lcv]);
DynamicArrayText := DynamicArrayText + IntToStr(DynamicArray[lcv]);
end;
// Displaying both arrays (#13#10 = Carriage Return/Line Feed)
ShowMessage(StaticArrayText + #13#10 + DynamicArrayText);
end;

[edit] DWScript

 
// dynamic array, extensible, this a reference type
var d : array of Integer;
d.Add(1); // has various methods to add, delete, etc.
d.Add(2, 3);
 
// read and write elements by index
item := d[5];
d[6] := item+1;
 
// static, fixed-size array, arbitrary lower-bound, this is a value type
var s : array [2..4] of Integer;
 
// inline array constructor, works for both static and dynamic arrays
s := [1, 2, 3];
 

[edit] E

E's collection library emphasizes providing both mutable and immutable collections. The relevant array-like types are ConstList and FlexList.

Literal lists are ConstLists.

? def empty := []
# value: []
 
? def numbers := [1,2,3,4,5]
# value: [1, 2, 3, 4, 5]
 
? numbers.with(6)
# value: [1, 2, 3, 4, 5, 6]
 
? numbers + [4,3,2,1]
# value: [1, 2, 3, 4, 5, 4, 3, 2, 1]

Note that each of these operations returns a different list object rather than modifying the original. You can, for example, collect values:

? var numbers := []
# value: []
 
? numbers := numbers.with(1)
# value: [1]
 
? numbers with= 2 # shorthand for same
# value: [1, 2]

FlexLists can be created explicitly, but are typically created by diverging another list. A ConstList can be gotten from a FlexList by snapshot.

? def flex := numbers.diverge()
# value: [1, 2].diverge()
 
? flex.push(-3)
? flex
# value: [1, 2, -3].diverge()
 
? numbers
# value: [1, 2]
 
? flex.snapshot()
# value: [1, 2, -3]

Creating a FlexList with a specific size, generic initial data, and a type restriction:

([0] * 100).diverge(int)    # contains 100 zeroes, can only contain integers

Note that this puts the same value in every element; if you want a collection of some distinct mutable objects, see N distinct objects#E.

In accordance with its guarantees of determinism, you can never have an uninitialized FlexList in E.

[edit] EGL

Arrays in EGL are 1-based, so the first element of an array is placed in element [1].

Fixed-length array

 
array int[10]; //optionally, add a braced list of values. E.g. array int[10]{1, 2, 3};
array[1] = 42;
SysLib.writeStdout(array[1]);
 

Output

42

Dynamic array

array int[0]; // Array declared without elements.
array.appendElement(11); // Add an element to the array and provide a value at the samen time.
array.appendElement(new int{}); // Add an element with the correct type, but without a value.
array[2] = 18; // Set the value of the added element.
SysLib.writeStdout(array[1]);
SysLib.writeStdout(array[2]);

Output

11
18

[edit] Eiffel

 
class
APPLICATION
 
inherit
ARGUMENTS
 
create
make
 
feature {NONE} -- Initialization
make
-- Run application.
do
-- initialize the array, index starts at 1 (not zero) and prefill everything with the letter z
create my_static_array.make_filled ("z", 1, 50)
 
my_static_array.put ("a", 1)
my_static_array.put ("b", 2)
my_static_array [3] := "c"
 
-- access to array fields
print (my_static_array.at(1) + "%N")
print (my_static_array.at(2) + "%N")
print (my_static_array [3] + "%N")
 
-- in Eiffel static arrays can be resized in three ways
my_static_array.force ("c", 51) -- forces 'c' in position 51 and resizes the array to that size (now 51 places)
my_static_array.automatic_grow -- adds 50% more indices (having now 76 places)
my_static_array.grow (100) -- resizes the array to 100 places
end
 
my_static_array: ARRAY [STRING]
end
 

[edit] Elena

Static array

    #var anArray := (1, 2, 3).
 
system'console writeLine:(anArray@1).
 

Dynamic array

    #var anArray := system'Array new &length:5.
anArray setAt:0:2.
 
system'console writeLine:(anArray@0).
 

[edit] Erlang

 
%% Create a fixed-size array with entries 0-9 set to 'undefined'
A0 = array:new(10).
10 = array:size(A0).
 
%% Create an extendible array and set entry 17 to 'true',
%% causing the array to grow automatically
A1 = array:set(17, true, array:new()).
18 = array:size(A1).
 
%% Read back a stored value
true = array:get(17, A1).
 
%% Accessing an unset entry returns the default value
undefined = array:get(3, A1).
 
%% Accessing an entry beyond the last set entry also returns the
%% default value, if the array does not have fixed size
undefined = array:get(18, A1).
 
%% "sparse" functions ignore default-valued entries
A2 = array:set(4, false, A1).
[{4, false}, {17, true}] = array:sparse_to_orddict(A2).
 
%% An extendible array can be made fixed-size later
A3 = array:fix(A2).
 
%% A fixed-size array does not grow automatically and does not
%% allow accesses beyond the last set entry
{'EXIT',{badarg,_}} = (catch array:set(18, true, A3)).
{'EXIT',{badarg,_}} = (catch array:get(18, A3)).
 

[edit] Euphoria

 
--Arrays task for Rosetta Code wiki
--User:Lnettnay
 
atom dummy
--Arrays are sequences
-- single dimensioned array of 10 elements
sequence xarray = repeat(0,10)
xarray[5] = 5
dummy = xarray[5]
? dummy
 
--2 dimensional array
--5 sequences of 10 elements each
sequence xyarray = repeat(repeat(0,10),5)
xyarray[3][6] = 12
dummy = xyarray[3][6]
? dummy
 
--dynamic array use (all sequences can be modified at any time)
sequence dynarray = {}
for x = 1 to 10 do
dynarray = append(dynarray, x * x)
end for
? dynarray
 
for x = 1 to 10 do
dynarray = prepend(dynarray, x)
end for
? dynarray
 

Output

5
12
{1,4,9,16,25,36,49,64,81,100}
{10,9,8,7,6,5,4,3,2,1,1,4,9,16,25,36,49,64,81,100}

[edit] F#

Fixed-length arrays:

> Array.create 6 'A';;
val it : char [] = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]
> Array.init 8 (fun i -> i * 10) ;;
val it : int [] = [|0; 10; 20; 30; 40; 50; 60; 70|]
> let arr = [|0; 1; 2; 3; 4; 5; 6 |] ;;
val arr : int [] = [|0; 1; 2; 3; 4; 5; 6|]
> arr.[4];;
val it : int = 4
> arr.[4] <- 65 ;;
val it : unit = ()
> arr;;
val it : int [] = [|0; 1; 2; 3; 65; 5; 6|]

Dynamic arrays:

If dynamic arrays are needed, it is possible to use the .NET class System.Collections.Generic.List<'T> which is aliased as Microsoft.FSharp.Collections.ResizeArray<'T>:

> let arr = new ResizeArray<int>();;
val arr : ResizeArray<int>
> arr.Add(42);;
val it : unit = ()
> arr.[0];;
val it : int = 42
> arr.[0] <- 13;;
val it : unit = ()
> arr.[0];;
val it : int = 13
> arr.[1];;
> System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
Parameter name: index ...
> arr;;
val it : ResizeArray<int> = seq [13]

[edit] Factor

(cleave applies all the quotations to the initial argument (the array)) This demonstrates array litterals and writing/reading to the array

Directly in the listener :

{ 1 2 3 }
{
[ "The initial array: " write . ]
[ [ 42 1 ] dip set-nth ]
[ "Modified array: " write . ]
[ "The element we modified: " write [ 1 ] dip nth . ]
} cleave
   The initial array: { 1 2 3 }
   Modified array: { 1 42 3 }
   The element we modified: 42

Arrays of arbitrary length can be created with the <array> word :

   ( scratchpad - auto ) 10 42 <array> .
   { 42 42 42 42 42 42 42 42 42 42 }

Arrays can contain different types :

   { 1 "coucou" f [ ] }

Arrays of growable length are called Vectors.

V{ 1 2 3 }
{
[ "The initial vector: " write . ]
[ [ 42 ] dip push ]
[ "Modified vector: " write . ]
} cleave
   The initial vector: V{ 1 2 3 }
   Modified vector: V{ 1 2 3 42 }

Vectors can also be used with set-nth and nth.

   ( scratchpad - auto ) V{ } [ [ 5 5 ] dip set-nth ] [ . ] bi
   V{ 0 0 0 0 0 5 }

[edit] FBSL

Various types of FBSL's BASIC arrays are listed below:

#APPTYPE CONSOLE

DIM v[-1 TO 1] AS VARIANT ' static Variant
v[-1] = -1
v[0] = "zero"
v[1] = !1.0
FOR EACH DIM e IN v

PRINT e, " ";

NEXT
PRINT

DIM i[-1 TO 1] AS INTEGER ' static strong-type Integer/Quad/Single/Double/String
i[-1] = -1
i[0] = "zero"
i[1] = !1
FOR EACH e IN i

PRINT e, " ";

NEXT
PRINT

DIM d[] AS INTEGER ' dynamic growable strong-type Integer/Quad/Single/Double/String
d[] = -1
d[] = "zero"
d[] = !1
FOR EACH e IN d

PRINT e, " ";

NEXT
PRINT

DIM a[] AS VARIANT = {-1, "zero", !1} ' dynamic growable Variant w/ anonymous array initialization
FOR EACH e IN a

PRINT e, " ";

NEXT
PRINT

FOR EACH e IN {-1, "zero", !1} ' anonymous Variant

PRINT e, " ";

NEXT
PRINT

PAUSE

Output:

-1 zero 1.000000
-1 0 1
-1 0 1
-1 zero 1.000000
-1 zero 1.000000

Press any key to continue...


FBSL's Dynamic C supports static and dynamic initialized arrays. Dynamic variable-length arrays are not currently supported.

[edit] Forth

Forth has a variety of ways to allocate arrays of data as contiguous blocks of memory, though it has no built-in array handling words, favoring pointer arithmetic.

For example, a static array of 10 cells in the dictionary, 5 initialized and 5 uninitialized:

create MyArray 1 , 2 , 3 , 4 , 5 ,  5 cells allot
here constant MyArrayEnd
 
30 MyArray 7 cells + !
MyArray 7 cells + @ . \ 30
 
: .array MyArrayEnd MyArray do I @ . cell +loop ;
 
: array ( n -- )
create
dup , \ remember size at offset 0
dup cells here swap 0 fill \ fill cells with zero
cells allot \ allocate memory
does> ( i addr -- )
swap 1+ cells + ; \ hide offset=0 to index [0..n-1]
: [size] -1 ;
 
10 array MyArray
 
30 7 MyArray !
7 MyArray @ . \ 30
 
: 5fillMyArray 5 0 do I I MyArray  ! loop ;
: .MyArray [size] MyArray @ 0 do I MyArray @ . loop ;
 
.MyArray \ 0 0 0 0 0 0 30 0 0 0
5fillMyArray
.MyArray \ 1 2 3 4 5 0 30 0 0 0
 
 
: array create dup , dup cells here swap 0 fill cells allot ;
: [size] @ ;
: [cell] 1+ cells + ; \ hide offset=0 to index [0..n-1]
 
10 array MyArray
 
30 MyArray 7 [cell] !
MyArray 7 [cell] @ . \ 30
 
: 5fillMyArray 5 0 do I MyArray I [cell]  ! loop ;
: .MyArray MyArray [size] 0 do MyArray I [cell] @ . loop ;
 
.MyArray \ 0 0 0 0 0 0 30 0 0 0
5fillMyArray
.MyArray \ 1 2 3 4 5 0 30 0 0 0
 

[edit] Fortran

Works with: Fortran version 90 and later

Basic array declaration:

integer a (10)
integer :: a (10)
integer, dimension (10) :: a

Arrays are one-based. These declarations are equivalent:

integer, dimension (10) :: a
integer, dimension (1 : 10) :: a

Other bases can be used:

integer, dimension (0 : 9) :: a

Arrays can have any type (intrinsic or user-defined), e.g.:

real, dimension (10) :: a
type (my_type), dimension (10) :: a

Multidimensional array declaration:

integer, dimension (10, 10) :: a
integer, dimension (10, 10, 10) :: a

Allocatable array declaration:

integer, dimension (:), allocatable :: a
integer, dimension (:, :), allocatable :: a

Array allocation:

allocate (a (10))
allocate (a (10, 10))

Array deallocation:

deallocate (a)

Array initialisation:

integer, dimension (10) :: a = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
integer :: i
integer, dimension (10) :: a = (/(i * i, i = 1, 10)/)
integer, dimension (10) :: a = 0
integer :: i
integer, dimension (10, 10) :: a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))

Constant array declaration:

integer :: i
integer, dimension (10), parameter :: a = (/(i * i, i = 1, 10)/)

Element assignment:

a (1) = 1
a (1, 1) = 1

Array assignment:

a = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
a = (/(i * i, i = 1, 10)/)
a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))
a = 0

Array section assignment:

a (:) = (/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
a (1 : 5) = (/1, 2, 3, 4, 5/)
a (: 5) = (/1, 2, 3, 4, 5/)
a (6 :) = (/1, 2, 3, 4, 5/)
a (1 : 5) = (/(i * i, i = 1, 10)/)
a (1 : 5)= 0
a (1, :)= (/(i * i, i = 1, 10)/)
a (1 : 5, 1)= (/(i * i, i = 1, 5)/)

Element retrieval:

i = a (1)

Array section retrieval:

a = b (1 : 10)

Size retrieval:

i = size (a)

Size along a single dimension retrieval:

i = size (a, 1)

Bounds retrieval:

i_min = lbound (a)
i_max = ubound (a)

Bounds of a multidimensional array retrieval:

a = ubound (b)

[edit] Frink

In Frink, all arrays are dynamically resizable. Arrays can be created as literals or using new array

 
a = new array
a@0 = 10
a@1 = 20
println[a@1]
 
b = [1, 2, 3]
 

[edit] Gambas

In Gambas, there is no need to dimension arrays. The first element of an array is numbered zero, and the DIM statement is optional and can be omitted:

 
DIM mynumbers AS INTEGER[]
myfruits AS STRING[]
 
mynumbers[0] = 1.5
mynumbers[1] = 2.3
 
myfruits[0] = "apple"
myfruits[1] = "banana"
 

[edit] GAP

# Arrays are better called lists in GAP. Lists may have elements of mixed types, e$
v := [ 10, 7, "bob", true, [ "inner", 5 ] ];
# [ 10, 7, "bob", true, [ "inner", 5 ] ]
 
# List index runs from 1 to Size(v)
v[1];
# 10
 
v[0];
# error
 
v[5];
# [ "inner", 5 ]
 
v[6];
# error
 
# One can assign a value to an undefined element
v[6] := 100;
 
# Even if it's not after the last: a list may have undefined elements
v[10] := 1000;
v;
# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000 ]
 
# And one can check for defined values
IsBound(v[10]);
# true
 
IsBound(v[9]);
# false
 
# Size of the list
Size(v);
# 10
 
# Appending a list to the end of another
Append(v, [ 8, 9]);
v;
# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000, 8, 9 ]
 
# Adding an element at the end
Add(v, "added");
v;
# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000, 8, 9, "added" ]

[edit] GML

[edit] 1-Dimensional Array Examples

[edit] Example of Fixed Length Array

Array containing a space (" "), "A", "B", and "C":

array[0] = ' '
array[1] = 'A'
array[2] = 'B'
array[3] = 'C'

[edit] Example of Arbitrary Length Array

Array containing the set of all natural numbers from 1 through k:

for(i = 0; i < k; i += 1)
array[i] = i + 1

[edit] 2-Dimensional Array Examples

[edit] Example of Fixed Length Array

Array containing the multiplication table of 1 through 4 by 1 through 3:

array[1,1] = 1
array[1,2] = 2
array[1,3] = 3
array[1,4] = 4
array[2,1] = 2
array[2,2] = 4
array[2,3] = 6
array[2,4] = 8
array[3,1] = 3
array[3,2] = 6
array[3,3] = 9
array[3,4] = 12

[edit] Example of Arbitrary Length Array

Array containing the multiplication table of 1 through k by 1 through h:

for(i = 1; i <= k; i += 1)
for(j = 1; j <= h; j += 1)
array[i,j] = i * j

[edit] Go

package main
 
import (
"fmt"
)
 
func main() {
// creates an array of five ints.
// specified length must be a compile-time constant expression.
// this allows compiler to do efficient bounds checking.
var a [5]int
 
// since length is compile-time constant, len() is a compile time constant
// and does not have the overhead of a function call.
fmt.Println("len(a) =", len(a))
 
// elements are always initialized to 0
fmt.Println("a =", a)
 
// assign a value to an element. indexing is 0 based.
a[0] = 3
fmt.Println("a =", a)
 
// retrieve element value with same syntax
fmt.Println("a[0] =", a[0])
 
// a slice references an underlying array
s := a[:4] // this does not allocate new array space.
fmt.Println("s =", s)
 
// slices have runtime established length and capacity, but len() and
// cap() are built in to the compiler and have overhead more like
// variable access than function call.
fmt.Println("len(s) =", len(s), " cap(s) =", cap(s))
 
// slices can be resliced, as long as there is space
// in the underlying array.
s = s[:5]
fmt.Println("s =", s)
 
// s still based on a
a[0] = 22
fmt.Println("a =", a)
fmt.Println("s =", s)
 
// append will automatically allocate a larger underlying array as needed.
s = append(s, 4, 5, 6)
fmt.Println("s =", s)
fmt.Println("len(s) =", len(s), " cap(s) =", cap(s))
 
// s no longer based on a
a[4] = -1
fmt.Println("a =", a)
fmt.Println("s =", s)
 
// make creates a slice and allocates a new underlying array
s = make([]int, 8)
fmt.Println("s =", s)
fmt.Println("len(s) =", len(s), " cap(s) =", cap(s))
 
// the cap()=10 array is no longer referenced
// and would be garbage collected eventually.
}

Output:

len(a) = 5
a = [0 0 0 0 0]
a = [3 0 0 0 0]
a[0] = 3
s = [3 0 0 0]
len(s) = 4  cap(s) = 5
s = [3 0 0 0 0]
a = [22 0 0 0 0]
s = [22 0 0 0 0]
s = [22 0 0 0 0 4 5 6]
len(s) = 8  cap(s) = 10
a = [22 0 0 0 -1]
s = [22 0 0 0 0 4 5 6]
s = [0 0 0 0 0 0 0 0]
len(s) = 8  cap(s) = 8

[edit] Golfscript

In Golfscript, arrays are created writing their elements between []. Arrays can contain any kind of object. Once created, they are pushed on the stack, as any other object.

[1 2 3]:a; # numeric only array, assigned to a and then dropped
10,:a; # assign to a [0 1 2 3 4 5 6 7 8 9]
a 0= puts # pick element at index 0 (stack: 0)
a 10+puts # append 10 to the end of a
10 a+puts # prepend 10 to a

Append and prepend works for integers or arrays only, since only in these cases the result is coerced to an array.

[edit] Groovy

Arrays and lists are synonymous in Groovy. They can be initialized with a wide range of operations and Groovy enhancements to the Collection and List classes.

def aa = [ 1, 25, 31, -3 ]           // list
def a = [0] * 100 // list of 100 zeroes
def b = 1..9 // range notation
def c = (1..10).collect { 2.0**it } // each output element is 2**(corresponding invoking list element)
 
// There are no true "multi-dimensional" arrays in Groovy (as in most C-derived languages).
// Use lists of lists in natural ("row major") order as a stand in.
def d = (0..1).collect { i -> (1..5).collect { j -> 2**(5*i+j) as double } }
def e = [ [ 1.0, 2.0, 3.0, 4.0 ],
[ 5.0, 6.0, 7.0, 8.0 ],
[ 9.0, 10.0, 11.0, 12.0 ],
[ 13.0, 14.0, 15.0, 16.0 ] ]
 
println aa
println b
println c
println()
d.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }
println()
e.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }

Output:

[1, 25, 31, -3]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

[    2.0     4.0     8.0    16.0    32.0 ]
[   64.0   128.0   256.0   512.0  1024.0 ]

[    1.0     2.0     3.0     4.0 ]
[    5.0     6.0     7.0     8.0 ]
[    9.0    10.0    11.0    12.0 ]
[   13.0    14.0    15.0    16.0 ]

Here is a more interesting example showing a function that creates and returns a square identity matrix of order N:

def identity = { n ->
(1..n).collect { i -> (1..n).collect { j -> i==j ? 1.0 : 0.0 } }
}

Test program:

def i2 = identity(2)
def i15 = identity(15)
 
 
i2.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }
println()
i15.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }

Output:

[ 1.0  0.0 ]
[ 0.0  1.0 ]

[ 1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0 ]
[ 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0 ]

Groovy, like every other C-derived language in the known universe, uses ZERO-based array/list indexing.

def strings = ['Mary', 'had', 'a', 'little', 'lamb', ". It's", 'fleece', 'was', 'white', 'as', 'snow']
 
println strings
 
strings[0] = 'Arthur'
strings[4] = 'towel'
strings[6] = 'stain'
strings[8] = 'ripe'
strings[10] = 'strawberries'
 
println strings

Output:

["Mary", "had", "a", "little", "lamb", ". It's", "fleece", "was", "white", "as", "snow"]
["Arthur", "had", "a", "little", "towel", ". It's", "stain", "was", "ripe", "as", "strawberries"]

Negative indices are valid. They indicate indexing from the end of the list towards the start.

println strings[-1]

Output:

strawberries

Groovy lists can be resequenced and subsequenced by providing lists or ranges of indices in place of a single index.

println strings[0, 7, 2, 3, 8]
println strings[0..4]
println strings[0..3, -5]

Output:

["Arthur", "was", "a", "little", "ripe"]
["Arthur", "had", "a", "little", "towel"]
["Arthur", "had", "a", "little", "stain"]

[edit] GUISS

Graphical User Interface Support Script does not have variables or array storage of its own. However, it can make use of installed applications, so it is possible to utilize an installed spreadsheet application to create and manipulate arrays. Here we assume that a spreadsheet is installed and create an array containing three names:

Start,Programs,Lotus 123,Type:Bob[downarrow],Kat[downarrow],Sarah[downarrow]

[edit] Harbour

Harbour arrays aren't divided to fixed-length and dynamic. Even if we declare it with a certain dimensions, it can be resized in the same way as it was created dynamically. The first position in an array is 1, not 0, as in some other languages.

   // Declare and initialize two-dimensional array
local arr1 := { { "NITEM", "N", 10, 0 }, { "CONTENT", "C", 60, 0 } }
// Create an empty array
local arr2 := {}
// Declare three-dimensional array
local arr3[ 2, 100, 3 ]
// Create an array
local arr4 := Array( 50 )
 
// Array can be dynamically resized:
arr4 := ASize( arr4, 80 )

Items, including nested arrays, can be added to existing array, deleted from it, assigned to it

// Adding new item to array, its size is incremented
AAdd( arr1, { "LBASE", "L", 1, 0 } )
// Delete the first item of arr3, The size of arr3 remains the same, all items are shifted to one position, the last item is replaced by Nil:
ADel( arr1, 1 )
// Assigning a value to array item
arr3[ 1, 1, 1 ] := 11.4

Retrieve items of an array:

   x := arr3[ 1, 10, 2 ]
// The retrieved item can be nested array, in this case it isn't copied, the pointer to it is assigned
 

There is a set of functions to manage arrays in Clipper, including the following:

// Fill the 20 items of array with 0, starting from 5-th item:
AFill( arr4, 0, 5, 20 )
// Copy 10 items from arr4 to arr3[ 2 ], starting from the first position:
ACopy( arr4, arr3[ 2 ], 1, 10 )
// Duplicate the whole or nested array:
arr5 := AClone( arr1 )
arr6 := AClone( arr1[ 3 ] )

[edit] Haskell

You can read all about Haskell arrays here. The following example is taken from that page:

import Data.Array.IO
 
main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)
a <- readArray arr 1
writeArray arr 1 64
b <- readArray arr 1
print (a,b)

[edit] HicEst

REAL :: n = 3, Astat(n), Bdyn(1, 1)
 
Astat(2) = 2.22222222
WRITE(Messagebox, Name) Astat(2)
 
ALLOCATE(Bdyn, 2*n, 3*n)
Bdyn(n-1, n) = -123
WRITE(Row=27) Bdyn(n-1, n)
 
ALIAS(Astat, n-1, last2ofAstat, 2)
WRITE(ClipBoard) last2ofAstat ! 2.22222222 0

[edit] Icon and Unicon

[edit] Icon

record aThing(a, b, c)       # arbitrary object (record or class) for illustration
 
procedure main()
A0 := [] # empty list
A0 := list() # empty list (default size 0)
A0 := list(0) # empty list (literal size 0)
 
A1 := list(10) # 10 elements, default initializer &null
A2 := list(10, 1) # 10 elements, initialized to 1
 
# literal array construction - arbitrary dynamically typed members
A3 := [1, 2, 3, ["foo", "bar", "baz"], aThing(1, 2, 3), "the end"]
 
# left-end workers
# NOTE: get() is a synonym for pop() which allows nicely-worded use of put() and get() to implement queues
#
Q := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
x := pop(A0) # x is 1
x := get(A0) # x is 2
push(Q,0)
# Q is now [0,3, 4, 5, 6, 7, 8, 9, 10]
 
# right-end workers
x := pull(Q) # x is 10
put(Q, 100) # Q is now [0, 3, 4, 5, 6, 7, 8, 9, 100]
 
# push and put return the list they are building
# they also can have multiple arguments which work like repeated calls
 
Q2 := put([],1,2,3) # Q2 is [1,2,3]
Q3 := push([],1,2,3) # Q3 is [3,2,1]
Q4 := push(put(Q2),4),0] # Q4 is [0,1,2,3,4] and so is Q2
 
# array access follows with A as the sample array
A := [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
 
# get element indexed from left
x := A[1] # x is 10
x := A[2] # x is 20
x := A[10] # x is 100
 
# get element indexed from right
x := A[-1] # x is 100
x := A[-2] # x is 90
x := A[-10] # x is 10
 
# copy array to show assignment to elements
B := copy(A)
 
# assign element indexed from left
B[1] := 11
B[2] := 21
B[10] := 101
# B is now [11, 21, 30, 50, 60, 60, 70, 80, 90, 101]
 
# assign element indexed from right - see below
B[-1] := 102
B[-2] := 92
B[-10] := 12
# B is now [12, 21, 30, 50, 60, 60, 70, 80, 92, 102]
 
# list slicing
# the unusual nature of the slice - returning 1 less element than might be expected
# in many languages - is best understood if you imagine indexes as pointing to BEFORE
# the item of interest. When a slice is made, the elements between the two points are
# collected. eg in the A[3 : 6] sample, it will get the elements between the [ ] marks
#
# sample list: 10 20 [30 40 50] 60 70 80 90 100
# positive indexes: 1 2 3 4 5 6 7 8 9 10 11
# non-positive indexes: -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0
#
# I have deliberately drawn the indexes between the positions of the values.
# The nature of this indexing brings simplicity to string operations
#
# list slicing can also use non-positive indexes to access values from the right.
# The final index of 0 shown above shows how the end of the list can be nominated
# without having to know it's length
#
# NOTE: list slices are distinct lists, so assigning to the slice
# or a member of the slice does not change the values in A
#
# Another key fact to understand: once the non-positive indexes and length-offsets are
# resolved to a simple positive index, the index pair (if two are given) are swapped
# if necessary to yield the elements between the two.
#
S := A[3 : 6] # S is [30, 40, 50]
S := A[6 : 3] # S is [30, 40, 50] not illegal or erroneous
S := A[-5 : -8] # S is [30, 40, 50]
S := A[-8 : -5] # S is [30, 40, 50] also legal and meaningful
 
# list slicing with length request
S := A[3 +: 3] # S is [30, 40, 50]
S := A[6 -: 3] # S is [30, 40, 50]
S := A[-8 +: 3] # S is [30, 40, 50]
S := A[-5 -: 3] # S is [30, 40, 50]
S := A[-8 -: -3] # S is [30, 40, 50]
S := A[-5 +: -3] # S is [30, 40, 50]
end

[edit] Unicon

This Icon solution works in Unicon.

# Unicon provides a number of extensions
# insert and delete work on lists allowing changes in the middle
# possibly others
 
This example is in need of improvement:
Need code examples for these extensions

[edit] Io

foo := list("foo", "bar", "baz")
foo at(1) println // bar
foo append("Foobarbaz")
foo println
foo atPut(2, "barbaz") // baz becomes barbaz
Io> foo := list("foo", "bar", "baz")
==> list(foo, bar, baz)
Io> foo at(1) println // bar
bar
==> bar
Io> foo append("Foobarbaz")
==> list(foo, bar, baz, Foobarbaz)
Io> foo println
list(foo, bar, baz, Foobarbaz)
==> list(foo, bar, baz, Foobarbaz)
Io> foo atPut(2, "barbaz") // baz becomes barbaz
==> list(foo, bar, barbaz, Foobarbaz)
Io> 

[edit] J

In J, all data occurs in the form of rectangular (or generally orthotopic) arrays. This is true for both named and anonymous data.

   1                          NB. a stand-alone scalar value is an array without any axis
1
NB. invoking any array produces that array as the result
{. array=: 1 3, 6#0 NB. create, name, then get head item of the array: 1 3 0 0 0 0 0 0
1
0 { array NB. another way to get the head item
1
aword=: 'there' NB. a literal array
0 1 3 2 2 { aword NB. multiple items can be drawn in a single action
three
]twoD=: 3 5 $ 'abcdefghijklmnopqrstuvwxyz'
abcde
fghij
klmno
1 { twoD NB. item 1 from twoD - a list of three items
fghij
1 {"1 twoD NB. item 1 from each rank-1 item of twoD (i.e. column 1)
bgl
(<2 2){ twoD NB. bracket indexing is not used in J
m
'X' 1} aword NB. amend item 1
tXere
aword=: 'X' 1 4} aword NB. in-place amend of items 1 and 4
tXerX
'X' (0 0;1 1;2 2)} twoD NB. amend specified items
Xbcde
fXhij
klXno

Because arrays are so important in J, a large portion of the language applies to this topic.

[edit] Java

int[] array = new int[10]; //optionally, replace "new int[10]" with a braced list of ints like "{1, 2, 3}"
array[0] = 42;
System.out.println(array[3]);

Dynamic arrays can be made using Lists. Leave generics out for Java versions under 1.5:

ArrayList <Integer> list = new ArrayList <Integer>();//optionally add an initial size as an argument
list.add(5);//appends to the end of the list
list.add(1, 6);//assigns the element at index 1
System.out.println(list.get(0));

[edit] JavaScript

JavaScript arrays are Objects that inherit from Array prototype and have a special length property that is always one higher than the highest non–negative integer index. Methods inherited from Array.prototype are mostly generic and can be applied to other objects with a suitable length property and numeric property names. Note that if the Array constructor is provided with one argument, it is treated as specifying the length of the new array, if more than one argument is supplied, they are treated as members of the new array.

// Create a new array with length 0
var myArray = new Array();
 
// Create a new array with length 5
var myArray1 = new Array(5);
 
// Create an array with 2 members (length is 2)
var myArray2 = new Array("Item1","Item2");
 
// Create an array with 2 members using an array literal
var myArray3 = ["Item1", "Item2"];
 
// Assign a value to member [2] (length is now 3)
myArray[2] = 5;
 
var x = myArray[2] + myArray.length; // 8
 
// Elisions are supported, but are buggy in some implementations
var y = [0,1,,]; // length 3, or 4 in buggy implementations
 

[edit] jq

jq arrays have the same syntax as JSON arrays, and there are similarities with Javascript arrays. For example, the index origin is 0; and if a is an array and if n is an integer less than the array's length, then a[n] is the n-th element. The length of any array, a, can be ascertained using the length filter: a|length.

There are, however, some interesting extensions, e.g. [][4] = null creates an array of length 5 as explained below.
# Create a new array with length 0
[]
 
# Create a new array of 5 nulls
[][4] = null # setting the element at offset 4 expands the array
 
# Create an array having the elements 1 and 2 in that order
[1,2]
 
# Create an array of integers from 0 to 10 inclusive
[ range(0; 11) ]
 
# If a is an array (of any length), update it so that a[2] is 5
a[2] = 5;
 
# Append arrays a and b
a + b
 
# Append an element, e, to an array a
a + [e]
 
##################################################
# In the following, a is assumed to be [0,1,2,3,4]
 
# It is not an error to use an out-of-range index:
a[10] # => null
 
# Negative indices count backwards from after the last element:
a[-1] # => 4
 
# jq supports simple slice operations but
# only in the forward direction:
a[:1] # => [0]
a[1:] # => [1,2,3,4]
a[2:4] # => [2,3]
a[4:2] # null

[edit] Julia

Julia has both heterogeneous arrays and typed arrays.

julia> A = cell(3)   # create an heterogeneous array of length 3
3-element Array{Any,1}:
 #undef
 #undef
 #undef

julia> A[1] = 4.5 ; A[3] =  "some string" ; show(A)
{4.5,#undef,"some string"}

julia> A[1]          # access a value. Arrays are 1-indexed
4.5

julia> push!(A, :symbol) ; show(A)    # append an element
{4.5,#undef,"some string",:symbol}

julia> A[10]         # error if the index is out of range
ERROR: BoundsError()

For typed arrays, the type can be specified explicitely or infered from its elements.

julia> B = Array(String, 3) ; B[1]="first" ; push!(B, "fourth") ; show(B)
["first",#undef,#undef,"fourth"]

julia> push!(B, 3)   # type error
ERROR: no method convert(Type{String}, Int64)
 in push! at array.jl:488

julia> ['a':'c']     # type inference
3-element Array{Char,1}:
 'a'
 'b'
 'c'

[edit] KonsolScript

//creates an array of length 3
Array:New array[3]:Number;
 
function main() {
Var:Number length;
Array:GetLength(array, length) //retrieve length of array
Konsol:Log(length)
 
array[0] = 5; //assign value
Konsol:Log(array[0]) //retrieve value and display
}

[edit] LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
LabVIEW Arrays.png

[edit] lang5

[]
1 append
['foo 'bar] append
2 reshape
0 remove 2 swap 2 compress collapse .

[edit] Lasso

Lasso Array [1] objects store zero or more elements and provide random access to those elements by position. Positions are 1-based integers. Lasso Arrays will grow as needed to accommodate new elements. Elements can be inserted and removed from arrays at any position. However, inserting an element anywhere but at the end of an array results in all subsequent elements being moved down.

// Create a new empty array
local(array1) = array
 
// Create an array with 2 members (#myarray->size is 2)
local(array1) = array('ItemA','ItemB')
 
// Assign a value to member [2]
#array1->get(2) = 5
 
// Retrieve a value from an array
#array1->get(2) + #array1->size // 8
 
// Merge arrays
local(
array1 = array('a','b','c'),
array2 = array('a','b','c')
)
#array1->merge(#array2) // a, b, c, a, b, c
 
// Sort an array
#array1->sort // a, a, b, b, c, c
 
// Remove value by index
#array1->remove(2) // a, b, b, c, c
 
// Remove matching items
#array1->removeall('b') // a, c, c
 
// Insert item
#array1->insert('z') // a, c, c, z
 
// Insert item at specific position
#array1->insert('0',1) // 0, a, c, c, z

[edit] Static Arrays

Lasso also supports Static Arrays[2]. A Lasso staticarray is a container object that is not resizable. Staticarrays are created with a fixed size. Objects can be reassigned within the staticarray, but new positions cannot be added or removed.

// Create a staticarray containing 5 items
local(mystaticArray) = staticarray('a','b','c','d','e')
 
// Retreive an item
#mystaticArray->get(3) // c
 
// Set an item
#mystaticArray->get(3) = 'changed' // a, b, changed, d, e
 
// Create an empty static array with a length of 32
local(mystaticArray) = staticarray_join(32,void)

[edit] LFE

Using the LFE REPL, you can explore arrays in the following manner:

 
; Create a fixed-size array with entries 0-9 set to 'undefined'
> (set a0 (: array new 10))
#(array 10 0 undefined 10)
> (: array size a0)
10
 
; Create an extendible array and set entry 17 to 'true',
; causing the array to grow automatically
> (set a1 (: array set 17 'true (: array new)))
#(array
18
...
(: array size a1)
18
 
; Read back a stored value
> (: array get 17 a1)
true
 
; Accessing an unset entry returns the default value
> (: array get 3 a1)
undefined
 
; Accessing an entry beyond the last set entry also returns the
; default value, if the array does not have fixed size
> (: array get 18 a1)
undefined
 
; "sparse" functions ignore default-valued entries
> (set a2 (: array set 4 'false a1))
#(array
18
...
> (: array sparse_to_orddict a2)
(#(4 false) #(17 true))
 
; An extendible array can be made fixed-size later
> (set a3 (: array fix a2))
#(array
18
...
 
; A fixed-size array does not grow automatically and does not
; allow accesses beyond the last set entry
> (: array set 18 'true a3)
exception error: badarg
in (array set 3)
 
> (: array get 18 a3)
exception error: badarg
in (array get 2)
 
 

[edit] Liberty BASIC

Arrays of less than 10 terms need not be dimensioned.
Arrays may only be 1D or 2D.
An empty numeric array term returns '0'. Empty string array terms ="".
'redim'ming allows the array size to be extended, but all existing values are lost.
DATA is READ into variables. It cannot be READ directly into arrays.
To fill arrays with DATA items, first READ the item into a variable, then use that variable to fill an index of the array.

 
dim Array(10)
 
Array(0) = -1
Array(10) = 1
 
print Array( 0), Array( 10)
 
REDIM Array( 100)
 
print Array( 0), Array( 10)
 
Array( 0) = -1
print Array( 0), Array( 10)
 
 

[edit] Lisaac

+ a : ARRAY(INTEGER);
a := ARRAY(INTEGER).create 0 to 9;
a.put 1 to 0;
a.put 3 to 1;
a.item(1).print;

[edit]

array 5      ; default origin is 1, every item is empty
(array 5 0)  ; custom origin
make "a {1 2 3 4 5}  ; array literal
setitem 1 :a "ten  ; Logo is dynamic; arrays can contain different types
print item 1 :a  ; ten

[edit] LSE64

10 myArray :array
0 array 5 [] ! # store 0 at the sixth cell in the array
array 5 [] @ # contents of sixth cell in array

[edit] LSL

LSL does not have Arrays, but it does have lists which can function similar to a one dimensional ArrayList in Java or C#.

 
default {
state_entry() {
list lst = ["1", "2", "3"];
llSay(0, "Create and Initialize a List\nList=["+llList2CSV(lst)+"]\n");
 
lst += ["A", "B", "C"];
llSay(0, "Append to List\nList=["+llList2CSV(lst)+"]\n");
 
lst = llListInsertList(lst, ["4", "5", "6"], 3);
llSay(0, "List Insertion\nList=["+llList2CSV(lst)+"]\n");
 
lst = llListReplaceList(lst, ["a", "b", "c"], 3, 5);
llSay(0, "Replace a portion of a list\nList=["+llList2CSV(lst)+"]\n");
 
lst = llListRandomize(lst, 1);
llSay(0, "Randomize a List\nList=["+llList2CSV(lst)+"]\n");
 
lst = llListSort(lst, 1, TRUE);
llSay(0, "Sort a List\nList=["+llList2CSV(lst)+"]\n");
 
lst = [1, 2.0, "string", (key)NULL_KEY, ZERO_VECTOR, ZERO_ROTATION];
string sCSV = llList2CSV(lst);
llSay(0, "Serialize a List of different datatypes to a string\n(integer, float, string, key, vector, rotation)\nCSV=\""+sCSV+"\"\n");
 
lst = llCSV2List(sCSV);
llSay(0, "Deserialize a string CSV List\n(note that all elements are now string datatype)\nList=["+llList2CSV(lst)+"]\n");
}
}

Output:

Create and Initialize a List
List=[1, 2, 3]

Append to List
List=[1, 2, 3, A, B, C]

List Insertion
List=[1, 2, 3, 4, 5, 6, A, B, C]

Replace a portion of a list
List=[1, 2, 3, a, b, c, A, B, C]

Randomize a List
List=[2, 3, B, a, A, b, C, c, 1]

Sort a List
List=[1, 2, 3, a, A, b, B, c, C]

Serialize a List of different datatypes to a string
(integer, float, string, key, vector, rotation)
CSV="1, 2.000000, string, 00000000-0000-0000-0000-000000000000, <0.00000, 0.00000, 0.00000>, <0.00000, 0.00000, 0.00000, 1.00000>"

Deserialize a string CSV List
(note that all elements are now string datatype)
List=[1, 2.000000, string, 00000000-0000-0000-0000-000000000000, <0.00000, 0.00000, 0.00000>, <0.00000, 0.00000, 0.00000, 1.00000>]

[edit] Lua

Lua does not differentiate between arrays, lists, sets, dictionaries, maps, etc. It supports only one container: Table. Using Lua's simple yet powerful syntax, any of these containers can be emulated. All tables are dynamic. If a static array is necessary, that behavior can be created.

l = {}
l[1] = 1 -- Index starts with 1, not 0.
l[0] = 'zero' -- But you can use 0 if you want
l[10] = 2 -- Indexes need not be continuous
l.a = 3 -- Treated as l['a']. Any object can be used as index
l[l] = l -- Again, any object can be used as an index. Even other tables
for i,v in next,l do print (i,v) end

[edit] Mathematica

a = Array[Sin, 10]
a[[1]]
Delete[a, 2]
Output:
{Sin[1],Sin[2],Sin[3],Sin[4],Sin[5],Sin[6],Sin[7],Sin[8],Sin[9],Sin[10]}
Sin[1]
{Sin[1],Sin[3],Sin[4],Sin[5],Sin[6],Sin[7],Sin[8],Sin[9],Sin[10]}


[edit] MATLAB / Octave

Variables are not typed until they are initialized. So, if you want to create an array you simply assign a variable name the value of an array. Also, memory is managed by MATLAB so an array can be expanded, resized, and have elements deleted without the user dealing with memory. Array elements can be retrieved in two ways. The first way is to input the row and column indicies of the desired elements. The second way is to input the subscript of the array elements.

>> a = [1 2 35] %Declaring a vector (i.e. one-dimensional array)
 
a =
 
1 2 35
 
>> a = [1 2 35;5 7 9] % Declaring a matrix (i.e. two-dimensional array)
 
a =
 
1 2 35
5 7 9
 
>> a3 = reshape(1:2*3*4,[2,3,4]); % declaring a three-dimensional array of size 2x3x4
 
a3 =
 
ans(:,:,1) =
 
1 3 5
2 4 6
 
ans(:,:,2) =
 
7 9 11
8 10 12
 
ans(:,:,3) =
 
13 15 17
14 16 18
 
ans(:,:,4) =
 
19 21 23
20 22 24
 
 
>> a(2,3) %Retrieving value using row and column indicies
 
9
 
>> a(6) %Retrieving value using array subscript
 
ans =
 
9
 
>> a = [a [10;42]] %Added a column vector to the array
 
a =
 
1 2 35 10
5 7 9 42
 
>> a(:,1) = [] %Deleting array elements
 
a =
 
2 35 10
7 9 42

[edit] Maxima

/* Declare an array, subscripts run from 0 to max value */
array(a, flonum, 20, 20, 3)$
 
arrayinfo(a);
/* [complete, 3, [20, 20, 3]] */
 
a[0, 0]: 1.0;
 
listarray(a);
/* [1.0, 0.0, 0.0, ..., 0.0] */
 
/* Show all declared arrays */
arrays;
/* [a] */
 
 
/* One may also use an array without declaring it, it's a hashed array */
b[1]: 1000;
b['x]: 3/4; /* hashed array may have any subscript */
 
arrayinfo(b);
/* [hashed, 1, [1], [x]] */
 
listarray(b);
/* [1000, 3/4] */

[edit] Modula-3

VAR a: ARRAY [1..10] OF INTEGER;

Defines an array of 10 elements, indexed 1 through 10.

Arrays can also be given initial values:

VAR a := ARRAY [1..10] OF INTEGER {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
VAR arr1 := ARRAY [1..10] OF INTEGER {1, ..} (* Initialize all elements to 1. *)

To retrieve an element:

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

To assign a value to an element:

VAR arr := ARRAY [1..3] OF INTEGER;
arr[1] := 10;

[edit] Monte

var myArray := ['a', 'b', 'c','d']

To retrieve a value:

traceln(myArray[0])

To change a value:

myArray := myArray.with(3, 'z')

Now myArray is ['a','b','c','z'].

[edit] Neko

var myArray = $array(1);
 
$print(myArray[0]);

Output: 1

[edit] Nemerle

using System;
using System.Console;
using System.Collections;
 
module ArrayOps
{
Main() : void
{
def fives = array(10);
foreach (i in [1 .. 10]) fives[i - 1] = i * 5;
def ten = fives[1];
WriteLine($"Ten: $ten");
 
def dynamic = ArrayList();
dynamic.Add(1);
dynamic.Add(3);
dynamic[1] = 2;
foreach (i in dynamic) Write($"$i\t"); // Nemerle isn't great about displaying arrays, it's better with lists though
}
}

[edit] NetRexx

Note: Dynamic arrays can be simulated via the Java Collections Framework or by using NetRexx indexed strings (AKA: associative arrays).

/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
 
array = int[10]
array[0] = 42
 
say array[0] array[3]
say
 
words = ['Ogof', 'Ffynnon', 'Ddu']
 
say words[0] words[1] words[2]
say
 
-- Dynamic arrays can be simulated via the Java Collections package
splk = ArrayList()
splk.add(words[0])
splk.add(words[1])
splk.add(words[2])
splk.add('Draenen')
 
say splk.get(0) splk.get(3)
say splk.get(0) splk.get(1) splk.get(2)
say
 
-- or by using NetRexx "indexed strings" (associative arrays)
cymru = ''
cymru[0] = 0
cymru[0] = cymru[0] + 1; cymru[cymru[0]] = splk.get(0) splk.get(1) splk.get(2)
cymru[0] = cymru[0] + 1; cymru[cymru[0]] = splk.get(0) splk.get(3)
 
loop x_ = 1 to cymru[0] by 1
say x_':' cymru[x_]
end x_
 

Output:

42 0

Ogof Ffynnon Ddu

Ogof Draenen
Ogof Ffynnon Ddu

1: Ogof Ffynnon Ddu
2: Ogof Draenen

[edit] NewLISP

This creates an array of 5 elements, initialized to nil:

(array 5)
(nil nil nil nil nil)

The example below creates a multi-dimensional array (a 3-element array of 4-element arrays), initialized using the values returned by the function sequence (a list containing whole numbers from 1 to 12) and stores the newly created array in a variable called myarray. The return value of the set function is the array.

(set 'myarray (array 3 4 (sequence 1 12)))
((1 2 3 4) (5 6 7 8) (9 10 11 12))

[edit] Nimrod

var # fixed size arrays
x = [1,2,3,4,5,6,7,8,9,10] # type and size automatically inferred
y: array[1..5, int] = [1,2,3,4,5] # starts at 1 instead of 0
z: array['a'..'z', int] # indexed using characters
 
x[0] = x[1] + 1
echo x[0]
echo z['d']
 
x[7..9] = y[3..5] # copy part of array
 
var # variable size sequences
a = @[1,2,3,4,5,6,7,8,9,10]
b: seq[int] = @[1,2,3,4,5]
 
a[0] = a[1] + 1
echo a[0]
 
a.add(b) # append another sequence
a.add(200) # append another element
echo a.pop() # pop last item, removing and returning it
echo a

[edit] NSIS

Library: NSISArray

NSIS does not have native support for arrays. Array support is provided by the NSISArray plugin.

 
!include NSISArray.nsh
Function ArrayTest
Push $0
; Declaring an array
NSISArray::New TestArray 1 2
NSISArray::Push TestArray "Hello"
; NSISArray arrays are dynamic by default.
NSISArray::Push TestArray "World"
NSISArray::Read TestArray 1
Pop $0
DetailPrint $0
Pop $0
FunctionEnd
 

[edit] Objeck

 
bundle Default {
class Arithmetic {
function : Main(args : System.String[]), Nil {
array := Int->New[2];
array[0] := 13;
array[1] := 7;
(array[0] + array[1])->PrintLine();
}
}
}
 

[edit] Objective-C

// NSArrays are ordered collections of NSObject subclasses only.
 
// Create an array of NSString objects.
NSArray *firstArray = [[NSArray alloc] initWithObjects:@"Hewey", @"Louie", @"Dewey", nil];
 
// NSArrays are immutable; it does have a mutable subclass, however - NSMutableArray.
// Let's instantiate one with a mutable copy of our array.
// We can do this by sending our first array a -mutableCopy message.
NSMutableArray *secondArray = [firstArray mutableCopy];
 
// Replace Louie with Launchpad McQuack.
[secondArray replaceObjectAtIndex:1 withObject:@"Launchpad"];
 
// Display the first object in the array.
NSLog(@"%@", [secondArray objectAtIndex:0]);
 
// In non-ARC or non-GC environments, retained objects must be released later.
[firstArray release];
[secondArray release];
 
// There is also a modern syntax which allows convenient creation of autoreleased immutable arrays.
// No nil termination is then needed.
NSArray *thirdArray = @[ @"Hewey", @"Louie", @"Dewey", @1, @2, @3 ];
 

[edit] OCaml

in the toplevel:

# Array.make 6 'A' ;;
- : char array = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]
 
# Array.init 8 (fun i -> i * 10) ;;
- : int array = [|0; 10; 20; 30; 40; 50; 60; 70|]
 
# let arr = [|0; 1; 2; 3; 4; 5; 6 |] ;;
val arr : int array = [|0; 1; 2; 3; 4; 5; 6|]
 
# arr.(4) ;;
- : int = 4
 
# arr.(4) <- 65 ;;
- : unit = ()
 
# arr ;;
- : int array = [|0; 1; 2; 3; 65; 5; 6|]

[edit] ooRexx

ooRexx arrays hold object references. Arrays will automatically increase in size if needed.

   a = .array~new       -- create a zero element array 
b = .array~new(10) -- create an array with initial size of 10
c = .array~of(1, 2, 3) -- creates a 3 element array holding objects 1, 2, and 3
a[3] = "Fred" -- assign an item
b[2] = a[3] -- retrieve an item from the array
c~append(4) -- adds to end. c[4] == 4 now

The above Array class supports only one-dimensional arrays (vectors) with positive integer indexes. Much more powerful are stems such as a.i.j where i and j can be any string value. See category REXX for details. ooRexx introduces a notation a.[x,y] where x and y can actually be expressions. This way one can implement one- and multidimensional (associative) arrays. The indexes can be strings containing any characters including blanks. The total length of the stemmed variable (stem and index values separated by periods) must not be longer than 250.

[edit] OxygenBasic

 
 
'CREATING AN ARRAY
 
float f[100]
 
'SETTING INDEX BASE
 
indexbase 1 'default
 
'FILLING PART OF AN ARRAY
 
f[20]<=1,2,3,4,5,1.25
 
'MAPPING AN ARRAY TO ANOTHER
 
float *g
@g=@f[20]
print g[6] 'result 1.25
 
 

[edit] Oz

declare
Arr = {Array.new 1 %% lowest index
10 %% highest index
37} %% all 10 fields initialized to 37
in
{Show Arr.1}
Arr.1 := 64
{Show Arr.1}

[edit] PARI/GP

v=[];
v=concat(v,7);
v[1]

[edit] Pascal

A modification of the Delphi example:

 
Program ArrayDemo;
uses
SysUtils;
var
StaticArray: array[0..9] of Integer;
DynamicArray: array of Integer;
StaticArrayText,
DynamicArrayText: string;
lcv: Integer;
begin
// Setting the length of the dynamic array the same as the static one
SetLength(DynamicArray, Length(StaticArray));
// Asking random numbers storing into the static array
for lcv := 0 to Pred(Length(StaticArray)) do
begin
write('Enter a integer random number for position ', Succ(lcv), ': ');
readln(StaticArray[lcv]);
end;
// Storing entered numbers of the static array in reverse order into the dynamic
for lcv := 0 to Pred(Length(StaticArray)) do
DynamicArray[Pred(Length(DynamicArray)) - lcv] := StaticArray[lcv];
// Concatenating the static and dynamic array into a single string variable
StaticArrayText := '';
DynamicArrayText := '';
for lcv := 0 to Pred(Length(StaticArray)) do
begin
StaticArrayText := StaticArrayText + IntToStr(StaticArray[lcv]) + ' ';
DynamicArrayText := DynamicArrayText + IntToStr(DynamicArray[lcv]) + ' ';
end;
// Displaying both arrays
writeln(StaticArrayText);
writeln(DynamicArrayText);
end.
 

[edit] Perl

Dynamic

my @arr;
 
push @arr, 1;
push @arr, 3;
 
$arr[0] = 2;
 
print $arr[0];

[edit] Perl 6

Works with: Rakudo version #22 "Thousand Oaks"
my @arr;
 
push @arr, 1;
push @arr, 3;
 
@arr[0] = 2;
 
say @arr[0];

[edit] PHP

[edit] Writing To An Array

[edit] Single Dimension

$NumberArray = array(0, 1, 2, 3, 4, 5, 6);
$LetterArray = array("a", "b", "c", "d", "e", "f");

[edit] Multi-Dimensional

$MultiArray = array(
array(0, 0, 0, 0, 0, 0),
array(1, 1, 1, 1, 1, 1),
array(2, 2, 2, 2, 2, 2),
array(3, 3, 3, 3, 3, 3)
);

[edit] Reading From An Array

[edit] Single Dimension

Read the 5th value in the array:

echo $NumberArray[5]; // Returns 5
echo $LetterArray[5]; // Returns f

[edit] Multi-Dimensional

Read the 2nd line, column 5

echo $MultiArray[1][5]; // 2

[edit] Print a whole array

This is useful while developing to view the contents of an array:

print_r($MultiArray);

Which would give us:

Array(
0 => array(
0 => 0
1 => 0
2 => 0
3 => 0
4 => 0
5 => 0
)
1 => array(
0 => 1
1 => 1
2 => 1
3 => 1
4 => 1
5 => 1
)
2 => array(
0 => 2
1 => 2
2 => 2
3 => 2
4 => 2
5 => 2
)
3 => array(
0 => 3
1 => 3
2 => 3
3 => 3
4 => 3
5 => 3
)
)

[edit] Set custom keys for values

This example starts the indexing from 1 instead of 0

$StartIndexAtOne = array(1 => "A", "B", "C", "D");

This example shows how you can apply any key you want

$CustomKeyArray = array("d" => "A", "c" => "B", "b" =>"C", "a" =>"D");

To read the 3rd value of the second array:

echo $CustomKeyArray["b"]; // Returns C

[edit] Other Examples

Create a blank array:

$BlankArray = array();

Set a value for the next key in the array:

$BlankArray[] = "Not Blank Anymore";

Assign a value to a certain key:

$AssignArray["CertainKey"] = "Value";

[edit] PicoLisp

PicoLisp has no built-in array data type. Lists are used instead.

(setq A '((1 2 3) (a b c) ((d e) NIL 777)))  # Create a 3x3 structure
(mapc println A) # Show it

Output:

(1 2 3)
(a b c)
((d e) NIL 777)

Replace 'b' with 'B' in middle row:

(set (nth A 2 2) 'B)
(mapc println A)

Output:

(1 2 3)
(a B c)
((d e) NIL 777)

Insert '1' in front of the middle row:

(push (cdr A) 1)
(mapc println A)

Output:

(1 2 3)
(1 a B c)
((d e) NIL 777)

Append '9' to the middle row:

(queue (cdr A) 9)
(mapc println A)

Output:

(1 2 3)
(1 a B c 9)
((d e) NIL 777)

[edit] Pike

int main(){
// Initial array, few random elements.
array arr = ({3,"hi",84.2});
 
arr += ({"adding","to","the","array"}); // Lets add some elements.
 
write(arr[5] + "\n"); // And finally print element 5.
}

[edit] PL/I

/* Example of an array having fixed dimensions */
declare A(10) float initial (1, 9, 4, 6, 7, 2, 5, 8, 3, 10);
 
A(6) = -45;
 
/* Example of an array having dynamic bounds. */
get list (N);
 
begin;
declare B(N) float initial (9, 4, 7, 3, 8, 11, 0, 5, 15, 6);
B(3) = -11;
end;
 
/* Example of a dynamic array. */
declare C(N) float controlled;
get list (N);
allocate C;
C = 0;
c(7) = 12;

[edit] PostScript

 
%Declaring array
 
/x [0 1] def
 
%Assigning value to an element, PostScript arrays are 0 based.
 
x 0 3 put
 
%Print array
 
x pstack
[3 1]
 
%Get an element
 
x 1 get
 

[edit] PowerShell

Empty array:

$a = @()

Array initialized with only one member:

$a = ,2
$a = @(2) # alternative

Longer arrays can simply be created by separating the values with commas:

$a = 1,2,3

A value can be appended to an array using the += operator:

$a += 5

Since arrays are immutable this simply creates a new array containing one more member.

Values can be retrieved using a fairly standard indexing syntax:

$a[1]

Similarly, those values can also be replaced:

$a[1] = 42

The range operator .. can be used to create contiguous ranges of integers as arrays:

$r = 1..100

Indexing for retrieval allows for arrays as well, the following shows a fairly complex example combining two ranges and an arbitrary array in the indexer:

$r[0..9+25..27+80,85,90]

Indexing from the end of the array can be done with negative numbers:

$r[-1]  # last index

[edit] Prolog

Works with: SWI Prolog

Prolog Terms can be abused as array structure. Using functor/3 to create arrays and arg/3 to nondestructively retrieve and set elements.

 
singleassignment:-
functor(Array,array,100), % create a term with 100 free Variables as arguments
% index of arguments start at 1
arg(1 ,Array,a), % put an a at position 1
arg(12,Array,b), % put an b at position 12
arg(1 ,Array,Value1), % get the value at position 1
print(Value1),nl, % will print Value1 and therefore a followed by a newline
arg(4 ,Array,Value2), % get the value at position 4 which is a free Variable
print(Value2),nl. % will print that it is a free Variable followed by a newline
 

To destructively set an array element, which is the "normal" way to set an element in most other programming languages, setarg/3 can be used.

 
destructive:-
functor(Array,array,100), % create a term with 100 free Variables as arguments
% index of arguments start at 1
setarg(1 ,Array,a), % put an a at position 1
setarg(12,Array,b), % put an b at position 12
setarg(1, Array,c), % overwrite value at position 1 with c
arg(1 ,Array,Value1), % get the value at position 1
print(Value1),nl. % will print Value1 and therefore c followed by a newline
 

Lists can be used as arrays.

 
listvariant:-
length(List,100), % create a list of length 100
nth1(1 ,List,a), % put an a at position 1 , nth1/3 uses indexing from 1, nth0/3 from 0
nth1(12,List,b), % put an b at position 3
append(List,[d],List2), % append an d at the end , List2 has 101 elements
length(Add,10), % create a new list of length 10
append(List2,Add,List3), % append 10 free variables to List2 , List3 now has 111 elements
nth1(1 ,List3,Value), % get the value at position 1
print(Value),nl. % will print out a
 

[edit] PureBasic

Dim is used to create new arrays and initiate each element will be zero. An array in PureBasic can be of any types, including structured, and user defined types. Once an array is defined it can be resized with ReDim. Arrays are dynamically allocated which means than a variable or an expression can be used to size them.

  ;Set up an Array of 23 cells, e.g. 0-22
Dim MyArray.i(22)
MyArray(0) = 7
MyArray(1) = 11
MyArray(7) = 23

ReDim is used to 'resize' an already declared array while preserving its content. The new size can be both larger or smaller, but the number of dimension of the array can not be changed after initial creation.

  ;Extend the Array above to 56 items without affecting the already stored data
ReDim MyArray(55)
MyArray(22) = 7
MyArray(33) = 11
MyArray(44) = 23
  ;Find all 6 non-zero cells from the Array above
For i=0 To ArraySize(MyArray())
If MyArray(i)
PrintN(Str(i)+" differs from zero.")
EndIf
Next
  ; Now, set up a multi dimensional Array 
Dim MultiArray.i(800, 600)
MultiArray(100, 200) = 640
MultiArray(130, 40) = 120
Dim MultiArray2.i(64, 128, 32)
PrintN( Str(ArraySize(MultiArray2(), 2)) ; Will tell that second dimension size is '128'

[edit] Python

Python lists are dynamically resizeable.

array = []
 
array.append(1)
array.append(3)
 
array[0] = 2
 
print array[0]

A simple, single-dimensional array can also be initialized thus:

myArray = [0] * size

However this will not work as intended if one tries to generalize from the syntax:

myArray = [[0]* width] * height] # DOES NOT WORK AS INTENDED!!!

This creates a list of "height" number of references to one list object ... which is a list of width instances of the number zero. Due to the differing semantics of mutables (strings, numbers) and immutables (dictionaries, lists), a change to any one of the "rows" will affect the values in all of them. Thus we need to ensure that we initialize each row with a newly generated list.

To initialize a list of lists one could use a pair of nested list comprehensions like so:

myArray = [[0 for x in range(width)] for y in range(height)]

That is equivalent to:

myArray = list()
for x in range(height):
myArray.append([0] * width)

To retrieve an element in an array, use any of the following methods:

 
# Retrieve an element directly from the array.
item = array[index]
 
# Use the array like a stack. Note that using the pop() method removes the element.
array.pop() # Pop last item in a list
array.pop(0) # Pop first item in a list
 
# Using a negative element counts from the end of the list.
item = array[-1] # Retrieve last element in a list.
 

Python produces an IndexError when accessing elements out of range:

 
try:
# This will cause an exception, which will then be caught.
print array[len(array)]
except IndexError as e:
# Print the exception.
print e
 

[edit] R

Dynamic

arr <- array(1)
 
arr <- append(arr,3)
 
arr[1] <- 2
 
print(arr[1])

[edit] Racket

#lang racket
 
;; import dynamic arrays
(require data/gvector)
 
(define v (vector 1 2 3 4))  ; array
(vector-ref v 0)  ; 1
(vector-set! v 1 4)  ; 2 -> 4
 
(define gv (gvector 1 2 3 4)) ; dynamic array
(gvector-ref gv 0)  ; 1
(gvector-add! gv 5)  ; increase size
 

[edit] REBOL

 
a: [] ; Empty.
b: ["foo"] ; Pre-initialized.
 

Inserting and appending.

 
append a ["up" "down"] ; -> ["up" "down"]
insert a [left right] ; -> [left right "up" "down"]
 

Getting specific values.

 
first a ; -> left
third a ; -> "up"
last a ; -> "down"
a/2 ; -> right (Note: REBOL is 1-based.)
 

Getting subsequences. REBOL allows relative motion through a block (list). The list variable returns the current position to the end of the list, you can even assign to it without destroying the list.

 
a ; -> [left right "up" "down"]
next a ; -> [right "up" "down"]
skip a 2 ; -> ["up" "down"]
 
a: next a ; -> [right "up" "down"]
head a ; -> [left right "up" "down"]
 
copy a ; -> [left right "up" "down"]
copy/part a 2 ; -> [left right]
copy/part skip a 2 2 ; -> ["up" "down"]
 

[edit] Retro

Retro has a vocabulary for creating and working with arrays.

 
needs array'
 
( Create an array with four elements )
^array'new{ 1 2 3 4 } constant a
 
( Add 10 to each element in an array and update the array with the results )
a [ 10 + ] ^array'map
 
( Apply a quote to each element in an array; leaves the contents alone )
a [ 10 + putn cr ] ^array'apply
 
( Display an array )
a ^array'display
 
( Look for a value in an array )
3 a ^array'in?
6 a ^array'in?
 
( Look for a string in an array )
"hello" a ^array'stringIn?
 
( Reverse the order of items in an array )
a ^array'reverse
 
( Append two arrays and return a new one )
^array'new{ 1 2 3 } constant a
^array'new{ 4 5 6 } constant b
a b ^array'append constant c
 
( Create an array from the values returned by a quote )
[ 1 2 "hello" "world" ] ^array'fromQuote constant d
 
( Create a quote from the values in an array )
d ^array'toQuote
 

[edit] REXX

Strictly speaking, REXX doesn't have arrays, but it does have something that looks, feels, and tastes like arrays;
they're called stemmed arrays.

[edit] simple arrays

/*REXX program  demonstrates a  simple  array usage.                    */
a.='not found' /*value for all a.xxx (so far).*/
do j=1 to 100 /*start at 1, define 100 elements*/
a.j=-j*1000 /*define as negative J thousand. */
end /*j*/ /*the above defines 100 elements.*/
 
say 'element 50 is:' a.50
say 'element 3000 is:' a.3000
/*stick a fork in it, we're done.*/

output

element 50 is: -50000
element 3000 is: not found

[edit] simple arrays, mimic other languages

/*REXX program  demonstrates  array usage  with mimicry.                */
a. = 'not found' /*value for all a.xxx (so far). */
do j=1 to 100 /*start at 1, define 100 elements*/
a.j = -j * 100 /*define element as -J hundred. */
end /*j*/ /*the above defines 100 elements.*/
 
say 'element 50 is:' a(50)
say 'element 3000 is:' a(3000)
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────A subroutine────────────────────────*/
a: _a_ = arg(1); return a._a_
element 50 is: -5000
element 3000 is: not found

[edit] simple arrays, assigned default

/*REXX program  demonstrates  array usage  with mimicry.                */
a. = 'not found' /*value for all a.xxx (so far). */
do j=1 to 100 /*start at 1, define 100 elements*/
a.j = -j * 100 /*define element as -J hundred. */
end /*j*/ /*the above defines 100 elements.*/
 
say 'element 50 is:' a(50)
say 'element 3000 is:' a(3000)
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────A subroutine────────────────────────*/
a: _a_ = arg(1); return a._a_

output

element 50 is: -5000
element 3000 is: 00

[edit] arrays with non-unity index start

/*REXX program  demonstrates  array usage  (with elements out-of-range).*/
array. = 'out of range' /*define ALL elements to this. */
 
do j=-3000 to 3000 /*start at -3k, going up to +3k.*/
array.j=j**2 /*define element as its square. */
end /*j*/ /* [↑] defines 6,001 elements. */
g=-7
say g "squared is:" array.g
say 7000 "squared is:" array.7000
/*stick a fork in it, we're done.*/

output

-7 squared is: 49
7000 squared is: out of range

[edit] arrays, disjoint

/*REXX program  demonstrates  disjointed array usage.                   */
yr. = 'year not supported' /*value for all yr.xxx (so far).*/
 
do k=600 to 1100 /*a bunch of years prior to 1800.*/
yr.k=k "AD" /*Kth element as the year itself.*/
end /*k*/ /* [↑] defines 501 elements.*/
 
do j=1800 to 2100 /*start at 1800, define a bunch. */
yr.j=j 'AD' /*Jth element as the year itself.*/
end /*j*/ /* [↑] defines 301 elements.*/
 
year=1946
say 'DOB' year "is:" yr.year
 
year=1744
say 'DOB' year "is:" yr.year
/*stick a fork in it, we're done.*/

output

DOB 1946 is: 1946 AD
DOB 1744 is: year not supported

[edit] sparse arrays and special indices

/*REXX program  demonstrates  array usage:   sparse and disjointed.     */
yyy = -55 /*REXX must use this mechanism···*/
a.yyy = 1e9 /*··· when assigning neg indices.*/
 
a.1 = 1000
a.2 = 2000.0001
a.7 = 7000
a.2012 = 'out here in left field.'
a.cat = 'civet, but not a true cat ─── belonging to the family Viverridae'
a.civet = "A.K.A.: toddycats"
/*┌────────────────────────────────────────────────────────────────────┐
│ Array elements need not be continuous (nor even defined). They │
│ can hold any manner of numbers, or strings (which can include any │
│ characters, including null or '00'x characters). │
│ │
│ Array elements need not be numeric, as the above code demonstrates.│
│ Indeed, the element "name" can be ANYTHING, even non-displayable │
│ characters. To illustrate [↓]: │
└────────────────────────────────────────────────────────────────────┘*/

stuff=')g.u.t.s( or ½ of an intestine!'
a.stuff=44
/*┌────────────────────────────────────────────────────────────────────┐
│ where the element name has special characters: blanks, and the │
│ glyph of one-half (½), as well as the symbol used in REXX to │
│ identify stemmed arrays (the period). │
└────────────────────────────────────────────────────────────────────┘*/

/*stick a fork in it, we're done.*/

[edit] RLaB

 
// 1-D (row- or column-vectors)
// Static:
// row-vector
x = [1:3];
x = zeros(1,3); x[1]=1; x[2]=2; x[3]=3;
// column-vector
x = [1:3]'; // or
x = [1;2;3]; // or
x = zeros(3,1); x[1]=1; x[2]=2; x[3]=3;
// Dynamic:
x = []; // create an empty array
x = [x; 1, 2]; // add a row to 'x' containing [1, 2], or
x = [x, [1; 2]]; // add a column to 'x' containing [1; 2]
 
// 2-D array
// Static:
x = zeros(3,5); // create an zero-filed matrix of size 3x5
x[1;1] = 1; // set the x(1,1) element to 1
x[2;] = [1,2,3,4,5]; // set the second row x(2,) to a row vector
x[3;4:5] = [2,3]; // set x(3,4) to 2 and x(3,5) to 3
// Dynamic
x = [1:5]; // create an row-vector x(1,1)=1, x(1,2)=2, ... x(1,5)=5
x = [x; 2, 3, 4, 6, 7]; // add to 'x' a row.
 
// Accessing an element of arrays:
// to retrieve/print element of matrix 'x' just put this in a single line in the script
i=1;
j=2;
x[i;j]
 
 
 

[edit] RPG

Works with: ILE RPG
 
//-Static array
//--def of 10 el array of integers, initialised to zeros
D array...
D s 10i 0 dim(10)
D inz
//--def an el
D el_1...
D s 10i 0 inz
 
/free
 
//-assign first el
//--first element of RPG array is indexed with 1
array(1) = 111;
 
//-get first el of array
el_1 = array(1);
 
//--display it
dsply ('First el of array='+%char(el_1));
//--displays: First el of array=111
 
//---or shorter, without "el_1"
dsply ('First el of array='+%char(array(1)));
//--displays: First el of array=111
 
/end-free
 

[edit] Ruby

Dynamic

# create an array with one object in it
a = ['foo']
 
# the Array#new method allows several additional ways to create arrays
 
# push objects into the array
a << 1 # ["foo", 1]
a.push(3,4,5) # ["foo", 1, 3, 4, 5]
 
# set the value at a specific index in the array
a[0] = 2 # [2, 1, 3, 4, 5]
 
# a couple of ways to set a slice of the array
a[0,3] = 'bar' # ["bar", 4, 5]
a[1..-1] = 'baz' # ["bar", "baz"]
a[0] = nil # [nil, "baz"]
a[0,1] = nil # ["baz"]
 
# retrieve an element
puts a[0]

[edit] Run BASIC

print "Enter array 1 greater than 0"; : input a1
print "Enter array 2 greater than 0"; : input a2
 
dim chrArray$(max(a1,1),max(a2,1))
dim numArray(max(a1,1),max(a2,1))
 
chrArray$(1,1) = "Hello"
numArray(1,1) = 987.2
print chrArray$(1,1);" ";numArray(1,1)

[edit] Sather

-- a is an array of INTs
a :ARRAY{INT};
-- create an array of five "void" elements
a := #ARRAY{INT}(5);
-- static creation of an array with three elements
b :ARRAY{FLT} := |1.2, 1.3, 1.4|;
-- accessing an array element
c ::= b[0]; -- syntactic sugar for b.aget(0)
-- set an array element
b[1] := c; -- syntactic sugar for b.aset(1, c)
-- append another array
b := b.append(|5.5|);

[edit] Scala

Arrays are not used often in Scala, since they are mutable and act differently to other collections with respect to type erasure, but are necessary for interoperability with Java. Alternatives such as List, Seq, and Vector are more commonly used.

// Create a new integer array with capacity 10
val a = new Array[Int](10)
 
// Create a new array containing specified items
val b = Array("foo", "bar", "baz")
 
// Assign a value to element zero
a(0) = 42
 
// Retrieve item at element 2
val c = b(2)

Dynamic arrays can be made using ArrayBuffers:

val a = new collection.mutable.ArrayBuffer[Int] 
a += 5 // Append value 5 to the end of the list
a(0) = 6 // Assign value 6 to element 0

[edit] Scheme

Lists are more often used in Scheme than vectors.

(let ((array #(1 2 3 4 5))     ; vector literal
(array2 (make-vector 5)) ; default is unspecified
(array3 (make-vector 5 0))) ; default 0
(vector-set! array 0 3)
(vector-ref array 0)) ; 3

[edit] Scratch

Scratch Arrays.png

[edit] Seed7

By default array indices have the type integer and start from 1. Other index types and start values are also possible. E.g.: The famous arrays with indices starting from 0 are possible. Every type, which can be mapped to integer, can be used as index type.

$ include "seed7_05.s7i";
 
const type: charArray is array [char] string; # Define an array type for arrays with char index.
const type: twoDim is array array char; # Define an array type for a two dimensional array.
 
const proc: main is func
local
var array integer: array1 is 10 times 0; # Array with 10 elements of 0.
var array boolean: array2 is [0 .. 4] times TRUE; # Array with 5 elements of TRUE.
var array integer: array3 is [] (1, 2, 3, 4); # Array with the elements 1, 2, 3, 4.
var array string: array4 is [] ("foo", "bar"); # Array with string elements.
var array char: array5 is [0] ('a', 'b', 'c'); # Array with indices starting from 0.
const array integer: array6 is [] (2, 3, 5, 7, 11); # Array constant.
var charArray: array7 is ['1'] ("one", "two"); # Array with char index starting from '1'.
var twoDim: array8 is [] ([] ('a', 'b'), # Define two dimensional array.
[] ('A', 'B'));
begin
writeln(length(array1)); # Get array length (= number of array elements).
writeln(length(array2)); # Writes 5, because array2 has 5 array elements.
writeln(array4[2]); # Get array element ("bar"). By default array indices start from 1.
writeln(array5[1]); # Writes b, because the indices of array5 start from 0.
writeln(array7['2']); # Writes two, because the indices of array7 start from '1'.
writeln(array8[2][2]); # Writes B, because both indices start from 1.
writeln(minIdx(array7)); # Get minumum index of array ('1').
array3[1] := 5; # Replace element. Now array3 has the elements 5, 2, 3, 4.
writeln(remove(array3, 3)); # Remove 3rd element. Now array3 has the elements 5, 2, 4.
array1 := array6; # Assign a whole array.
array1 &:= [] (13, 17); # Append an array.
array1 &:= 19; # Append an element.
array1 := array3[2 ..]; # Assign a slice beginning with the second element.
array1 := array3[.. 5]; # Assign a slice up to the fifth element.
array1 := array3[3 .. 4]; # Assign a slice from the third to the fourth element.
array1 := array3[2 len 4]; # Assign a slice of four elements beginning with the second element.
array1 := array3 & array6; # Concatenate two arrays and assign the result to array1.
end func;

[edit] Sidef

# create an empty array
var arr = [];
 
# push objects into the array
arr.append("a"); # => ['a']
arr.append(1,2,3); # => ['a', 1, 2, 3]
 
# change an element inside the array
arr[2] = "b"; # => ['a', 1, 'b', 3]
 
# set the value at a specific index in the array (with autovivification)
arr[5] = "end"; # => ['a', 1, 'b', 3, nil, 'end']
 
# resize the array
arr.resizeTo(-1); # => []
 
# slice assignment
arr[0..2] = 'a'..'c'; # => ['a', 'b', 'c']
 
# any change made to the slice is visible in the original array
var slice = arr[2, 1]; # slice => ['c', 'b']
slice[1] = 'bar'; # array => ['a', 'bar', 'c']
 
# indices as arrays
var indices = [0, -1];
arr[indices] = ["foo", "baz"]; # => ['foo', 'bar', 'baz']
 
# retrieve an element
say arr[-1]; # => 'baz'

[edit] Slate

slate[1]> #x := ##(1 2 3). 
{1. 2. 3}
slate[2]> x
{1. 2. 3}
slate[3]> #y := {1 + 2. 3 + 4. 5}.
{3. 7. 5}
slate[4]> y at: 2 put: 99.
99
slate[5]> y
{3. 7. 99}
slate[6]> x first
1
slate[7]> x at: 0.
1

[edit] Smalltalk

The Array class represents fixed size vectors with polymorphic contents. Array indexing is ONE-based. Fixed size means, that once created it is expensive (although not strictly impossible), to resize it (not strictly impossible because we could allocate a new array and #become that the old one). Most Smalltalks also provide element type restricted arrays, which are tuned (usually space-wise) for particular elements. For example: ByteArray, IntegerArray, LongIntegerArray, FloatArray or DoubleArray. Instances of them are also used to pass bulk data in and out of FFI calls (for example, for OpenGL). Also Strings can be seen as arrays of characters. All collection classes share a rich common protocol, which includes enumeration, stream converting, concatenation, copying, replacing, searching etc.

Finally, there is OrderedCollection, which behaves similar to Array, but allows for the number of elements to be changed (i.e. elements can be added and removed later). Usually, adding/removing at either end is cheap, so they can be used to implement stacks and queues.

Literal Arrays (Array constants):

#(1 2 3 'four' 5.0 true false nil (10 20) $a)

a polymorphic array containing integers, a string, a float, booleans, a nil, another array with integers and a character constant.

Programatic use:

|array|
"creates an array that holds up to 20 elements"
array := Array new: 20 .
"access the first element: array base is 1"
(array at: 1) displayNl.
"put 100 as second value; you can put any object,
in particular SmallInteger"

array at: 2 put: 100.
"initialize an array from a 'constant' given array"
array := Array withAll: #('an' 'apple' 'a' 'day' 'keeps' 'the' 'doctor' 'away').
"Replacing apple with orange"
array at: 2 put: 'orange'.
"assigning values to an array"
"suppose array is bound to an array of 20 values"
array at: 5 put: 'substitute fifth element'.
 
[ array at: 21 put: 'error' ]
on: SystemExceptions.IndexOutOfRange
do: [ :sig | 'Out of range!' displayNl ].
"retrieving a value from an array"
#($a $b $c) at: 2

Enumeration:

array do:[:each | each printOn: aStream ]
array collect:[:each | each squared|
array select:[:each | each > 10]
Works with: Pharo
Works with: Smalltalk/X
Works with: Squeak

Constructing an Array from evaluated expressions:

{ Time now . 10 . Date today . 'foo' }

this construct evaluates each expression and creates a 4-element array containing a time, int, date and string object.

OrderedCollection:

oc := OrderedCollection withAll: #(4 5 6).
oc add:1. oc add:2. oc add:3.
foo := oc removeFirst.
oc addFirst:10.
oc removeLast.
oc at:2 put: 'someString'.
oc add:123 beforeIndex:10.
oc asArray printCR.
oc2 := oc copyFrom:5 to:10
oc indexOf: 'someString'
oc findFirst:[:el | el isString]
"hundreds of other methods skipped here.."
 

[edit] Suneido

array = Object('zero', 'one', 'two')
array.Add('three')
array.Add('five', at: 5)
array[4] = 'four'
Print(array[3]) --> 'three'

[edit] Tcl

Tcl's lists are really dynamic array values behind the scenes. (Note that Tcl uses the term “array” to refer to an associative collection of variables.)

set ary {}
 
lappend ary 1
lappend ary 3
 
lset ary 0 2
 
puts [lindex $ary 0]

Note also that serialization is automatic on treating as a string:

puts $ary; # Print the whole array

[edit] TI-83 BASIC

In TI-83 BASIC there are two sequenced data types: Lists and Arrays.
One dimensional Lists can be set as a whole with the syntax:

 
{1,2,3,4,5}→L1
 

using only numerical values separated by commas and enclosed by curly braces.
Lists can be accessed as a whole using L1-L6 or a custom list name using the L command in the "OPS" section of the "LIST" menu (2nd STAT (Right Arrow) B) . You can also retrieve a single value from a list using the name of the list and the position of the value, which starts at 1 on the left.

 
{1,2,3,4,5}→L1
Disp L1(3)
0→L1(4)
 

This would return 3 and set the fourth list element to 0.

Two dimensional Arrays are similar, set them and retrieve numbers using the syntax: [[11,21,31,41][12,22,32,42][13,23,33,43]]→[A] Disp [A](1,3) 0→[A](4,2) </lang> This would return 13 and set the element (4,2) to 0.

[edit] TorqueScript

Arrays in TorqueScript:

 
$array[0] = "hi";
$array[1] = "hello";
 
for(%i=0;%i<2;%i++)
echo($array[%i]);

=> hi

=> hello

 
$array["Greet",0] = "hi";
$array["Greet",1] = "hello";
 
for(%i=0;%i<2;%i++)
echo($array["Greet",%i]);

=> hi

=> hello

[edit] TXR

TXR has two kinds of aggregate objects for sequences: lists and arrays. There is some syntactic sugar to manipulate them in the same way.

[edit] Literals

In the pattern matching language, there are no list literals. A list like ("a" "b" "c") is actually being evaluated, as can be seen in a directive such as @(bind (a b) (c "d")) where (c "d") is a list consisting of the value of variable c and the string "d". This is subject to destructuring and the two values are assigned to the variables a and b

In TXR Lisp, there are literal lists introduced by a quote '(1 2 3 4). Vectors look like this: #(1 2 3 4).

[edit] Construction

Lists can be implicitly produced using pattern matching. Lists and vectors can be constructed using the functions of TXR Lisp. (vector 3) creates a vector of length three, whose elements are initialized to nil. (list 1 2 3) constructs the list (1 2 3).

[edit] Array Indexing Notation

The [] notation performs positional indexing on lists and arrays, which are both zero-based (element zero is the first element). Negative indices work from the tail of the list, whereby -1 denotes the last element of a sequence which has at least one element. Out of bounds access to arrays throws exceptions, but out of bounds access to lists produces nil. Out-of-bounds assignments are not permitted for either data type.

(defvar li (list 1 2 3))      ;; (1 2 3)
(defvar ve (vec 1 2 3)) ;; make vector #(1 2 3)
;; (defvar ve (vector 3)) ;; make #(nil nil nil)

[ve 0]    ;; yields 1
[li 0]    ;; yields 1
[ve -1]   ;; yields 3
[li 5]    ;; yields nil
[li -50]  ;; yields nil
[ve 50]   ;; error

(set [ve 2] 4) ;; changes vector to #(1 2 4).
(set [ve 3] 0) ;; error
(set [ve 3] 0) ;; error

[edit] Array Range Notation

Array range notation (slices) are supported, for both arrays and lists. An array range is a pair object denoted a .. b, which is a syntactic sugar for (cons a b). Therefore, a range constitutes a single argument in the bracket notation (allowing for straightforward future extension to multi-dimensional arrays indexing and slicing).

[ve 0..t]              ;; yield all of vector: t means "one position past last element"
[ve nil..nil]          ;; another way
[ve 1 3]               ;; yields #(2 3)
(set [ve 0 2] '(a b))  ;; changes vector to #(a b 3)
(set [ve 0 2] #(1 2))  ;; changes vector to #(1 2 3)
(set [li 0 1] nil)     ;; changes list to #(2 3), deleting 1.
(set [li t t] '(4 5))  ;; changes list to #(2 3 4 5), appending (4 5)
(set [ve 1 2] '(0 0))  ;; changes vector to #(1 0 0 3), replacing 2 with 0 0

[edit] In The Pattern Language

In the TXR pattern language, there is an array indexing and slicing notation supported in output variables. The following assumes that variable a holds a list.

@(output)
here is a[0] left-adjusted in a 10 character field:

  @{a[0] 10}.

here are a[1] through a[3] joined with a colon,
right-adjusted in a 20 character field:

  @{a[1..4] ":" -20}
@(end)

A complete program which turns comma-separated into tab-separated, where the first and last field from each line are exchanged:

@(collect)
@line
@(bind f @(split-str line ","))
@(output)
@{f[-1]}@\t@{f[1..-1] "\t"}@\t@{f[0]}
@(end)
@(end)

[edit] Other Kinds of Objects

The [] notation also works with strings, including ranges and assignment to ranges.

Hash tables can be indexed also, and the notation is meaningful for functions: [fun args ...] means the same thing as (call fun args ...), providing a Lisp-1 flavor within a Lisp-2 dialect.

[edit] UNIX Shell

Bash supports one-dimensional arrays, which are zero-indexed. Zero-indexing means that if the array has five items in it, the first item is at index 0, and the last item is at index 4.

Two-dimensional arrays can be accomplished using shell functions applied to arrays of array names. Basically, hiding the indirection within the shell function invocation.

You can read detailed explanations on everything concerning arrays in Bash.

To create an array:

alist=( item1 item2 item3 )  # creates a 3 item array called "alist"
declare -a list2 # declare an empty list called "list2"
declare -a list3[0] # empty list called "list3"; the subscript is ignored
 
# create a 4 item list, with a specific order
list5=([3]=apple [2]=cherry [1]=banana [0]=strawberry)

To obtain the number of items in an array:

count=${#alist[*]}
echo "The number of items in alist is ${#alist[*]}"

To iterate up over the items in the array:

x=0
while [[ $x < ${#alist[*]} ]]; do
echo "Item $x = ${alist[$x]}"
 : $((x++))
done

To iterate down over theitems in an array:

x=${#alist[*]}       # start with the number of items in the array
while [[ $x > 0 ]]; do # while there are items left
 : $((x--)) # decrement first, because indexing is zero-based
echo "Item $x = ${alist[$x]}" # show the current item
done

To append to an array, use the current number of items in the array as the next index:

alist[${#alist[*]}]=new_item

To make appending easier, use a little shell function, let's call it "push", and design it to allow appending multiple values, while also preserving quoted values:

# shell function to append values to an array
# push LIST VALUES ...
push() {
local var=${1:?'Missing variable name!'}
shift
eval "\$$var=( \"\${$var[@]}\" \"$@\" )"
}
 
push alist "one thing to add"
push alist many words to add

To delete a single array item, the first item:

unset alist[0]

To delete and return the last item in an array (e.g., "pop" function):

# pop ARRAY -- pop the last item on ARRAY and output it
 
pop() {
local var=${1:?'Missing array name'}
local x ; eval "x=\${#$var[*]}"
if [[ $x > 0 ]]; then
local val ; eval "val=\"\${$var[$((--x))]}\""
unset $var[$x]
else
echo 1>&2 "No items in $var" ; exit 1
fi
echo "$val"
}
 
alist=(a b c)
pop alist
a
pop alist
b
pop alist
c
pop alist
No items in alist

To delete all the items in an array:

unset alist[*]

To delete the array itself (and all items in it, of course):

unset alist

[edit] Vala

Non-dynamic arrays:

 
int[] array = new int[10];
 
array[0] = 1;
array[1] = 3;
 
stdout.printf("%d\n", array[0]);
 
Library: Gee

Dynamic Arrays with Gee:

 
var array = new ArrayList<int> ();
 
array.add(1);
array.add(3);
 
array[0] = 2;
 
stdout.printf("%d\n", array[0]);
 

[edit] Vim Script

Lists can be used for dynamic arrays. Indexing starts at 0.

" Creating a dynamic array with some initial values
let array = [3, 4]
 
" Retrieving an element

let four = array[1]
 
" Modifying an element

let array[0] = 2
 
" Appending a new element

call add(array, 5)
 
" Prepending a new element

call insert(array, 1)
 
" Inserting a new element before another element

call insert(array, 3, 2)
 
echo array
Output:
[1, 2, 3, 4, 5]

[edit] X86 Assembly

 
section .text
global _start
 
_print:
mov ebx, 1
mov eax, 4
int 0x80
ret
 
_start:
;print out our byte array. ergo, String.
mov edx, sLen
mov ecx, sArray
call _print
mov edx, f_len
mov ecx, f_msg
call _print
mov edx, 6 ;our array members length.
xor ecx, ecx
mov ecx, 4
;turnicate through the array and print all it's members.
;At an offset of *4, each array member is referenced
;at 1,2,3 and so on.
_out_loops:
push ecx
mov ecx, [fArray+esi*4]
call _print
inc esi
pop ecx
loop _out_loops
mov edx, u_len
mov ecx, u_msg
call _print
;Let's populate 'uArray' with something from sArray.
;mov edi, uArray
mov ecx, 4
xor esi, esi
_read_loops:
push dword [fArray+esi*4]
pop dword [uArray+esi*4]
inc esi
loop _read_loops
mov ecx, 4
xor esi, esi
_out_loops2:
push ecx
mov ecx, [uArray+esi*4]
call _print
inc esi
pop ecx
loop _out_loops2
push 0x1
mov eax, 1
push eax
int 0x80
 
section .data
sArray db 'a','r','r','a','y','s',' ','a','r','e',' ','f','u','n',0xa
sLen equ $-sArray
 
crap1 db "crap1",0xa
crap2 db "crap2",0xa
crap3 db "crap3",0xa
crap4 db "crap4",0xa
 
fArray dd crap1,crap2
dd crap3,crap4
 
f_msg db "fArray contents",0xa,"----------------------",0xa
f_len equ $-f_msg
u_msg db "uArray now holds fArray contents.. dumping..",0xa,"----------------------",0xa
u_len equ $-u_msg
 
section .bss
uArray resd 1
resd 1
resd 1
resd 1
 

Arrays in assembly are a reference to anything, from groups of data such as f/uArray to strings like _msg's or sArray. Mutlidimentional arrays don't exist in assembly. To make a reference to one from assembly, we use a format as such. "row * r_len + column * member_size".

[edit] XPL0

include c:\cxpl\codes;
char A(10); \creates a static array of 10 bytes, pointed to by "A"
char B; \declares a variable for a pointer to a dynamic array
[A(3):= 14;
B:= Reserve(10); \reserve 10 bytes and point to their starting address
B(7):= 28;
IntOut(0, A(3)+B(7)); \displays 42
]

[edit] zkl

Core zkl does not support arrays or vectors of one type. It does support heterogeneous lists, which are usually a super set at the cost of space.

var array=List();  // array of size 0
array=(0).pump(10,List().write,5).copy(); // [writable] array of size 10 filled with 5
array[3]=4;
array[3] //-->4
array+9; //append a 9 to the end, same as array.append(9)
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox