Arrays: Difference between revisions
m
→{{header|Ada}}
Puppydrum64 (talk | contribs) m (→Array Alignment: this was meant to be a subsection of z80 assembly) |
m (→{{header|Ada}}) |
||
(41 intermediate revisions by 25 users not shown) | |||
Line 1:
{{task|Basic language learning}}
This task is about arrays.
Line 31:
{{trans|Python}}
<
array.append(1)
array.append(3)
Line 44:
V width = 3
V height = 4
V myArray2 = [[0] * width] * height // create array of arrays</
{{out}}
Line 55:
=={{header|360 Assembly}}==
<
ARRAYS PROLOG
* we use TA array with 1 as origin. So TA(1) to TA(20)
Line 84:
J DC F'4'
YREGS
END ARRAYS</
=={{header|6502 Assembly}}==
===One-Dimensional Arrays===
An array is little more than just a contiguous section of memory. Whether or not an array is mutable depends solely on whether it is defined in ROM or RAM. The syntax will be discussed in further detail in the Two-Dimensional Arrays section.
<syntaxhighlight lang="6502asm">Array:
db 5,10,15,20,25,30,35,40,45,50</syntaxhighlight>
Side note: Some systems, such as the Nintendo Entertainment System or other ROM cartridge-based computers, cannot use the above declaration to initialize an array in RAM at assemble time; only in ROM. While the label "Array" can be given to an arbitrary RAM location on any system, you won't be able to define a data block in RAM the same way you would on an assembly program meant to run on the Apple II or Commodore 64 for example. The examples below will still work on any system, you just won't be able to "see" the array before running the program, if that makes sense. Clearing the system ram will suffice to initialize the array to zero.
Looking up a value in an array is fairly straightforward. The best addressing modes for doing so are <code>LDA $????,x</code>,<code>LDA $????,y</code>, and <code>LDA ($??),y</code>. In this case, x or y represents the index into the array. To put it in terms of C:
<syntaxhighlight lang="c"> char foo()
{
char array[5] = {3,6,9,12,15};
return array[2];
}</syntaxhighlight>
would (theoretically) compile to the following in 6502 Assembly:
<syntaxhighlight lang="6502asm">
foo:
LDX #2 ;load the desired index
LDA array,x ;load the second (zero-indexed) entry in array, i.e. 9
RTS ;return. The return value is stored in A.
array: ;this is the array we're reading from.
db 3,6,9,12,15</syntaxhighlight>
===Arrays in the Zero Page - A Word of Warning===
One important thing to note is a hardware bug involving <code>LDA $??,x</code>. If the sum of $?? and x would exceed 255, instead of continuing past $100, the CPU will actually wrap around back to $00. This does not happen with absolute addressing modes or indexed indirect with Y. Here's an example:
<syntaxhighlight lang="6502asm">LDX #$80
LDA $80,x ;evaluates to LDA $00
LDA $0480,x ;evaluates to LDA $0500</syntaxhighlight>
If you really want to read from an array in the zero page like this (and chances are you won't since that array also starts to overlap with the hardware stack), you can use an absolute addressing mode in the zero page. Beware - some assemblers will forcibly optimize <code>LDA $00??</code> into <code>LDA $??</code> so you may have to inline the bytecode for it directly. If you stick to arrays outsize the zero page you don't need to worry about index wraparound.
===Arrays of 16-Bit Data===
You can have arrays of 16-bit data as well as 8-bit ones. There are a few ways to do this, and we'll go over the "naive" way first:
<syntaxhighlight lang="6502">wordArray:
dw $ABCD,$BEEF,$CAFE,$DADA</syntaxhighlight>
The 6502 is little-endian, so the above would be exactly the same as the following:
<syntaxhighlight lang="6502">wordArray:
db $CD,$AB,$EF,$BE,$FE,$CA,$DA,$DA</syntaxhighlight>
To properly index a 16-bit array that's formatted as in the above example, you'll need to double your index. In this example, we'll be loading the offset of <code>$BEEF</code>:
<syntaxhighlight lang="6502">LDX #2 ;load the 1st (zero-indexed) WORD from the array (which is why this is 2 not 1)
LDA wordArray,X ;evaluates to LDA #$EF
STA $00 ;store in a zero page temporary variable
INX ;point X to the high byte
LDA wordArray,X ;evaluates to LDA #$BE
STA $01 ;store in a different zero page temporary variable. If your word data is a pointer you want to dereference,
;you'll need to store the low byte in $nn and the high byte in $nn+1 like I did here.</syntaxhighlight>
There are a few downsides in 6502 assembly to storing word data in this format. A minor one is the need to double your index. This isn't a big deal, it doesn't take long to do that. The bigger problem is that the 6502 has a soft array length cap of 256 bytes. If your code is running in ROM and you're not able to use self-modifying code to adjust the base address, or you're not willing to use the slower <code>LDA ($??),y</code>, you're mostly limited to 256 bytes or 128 words.
However, if you split the word table into two byte tables, you can actually get more bang for your buck, and it takes the same amount of memory no matter which way you store the data.
<syntaxhighlight lang="6502asm">wordArray_Lo:
db $CD,$EF,$FE,$DA
wordArray_Hi:
db $AB,$BE,$CA,$DA ;both this version and the above versions are 8 bytes of memory.</syntaxhighlight>
If both wordArray_Lo and wordArray_Hi were 256 bytes each, you'd be able to index both of them no problem, where you wouldn't be able to do that if it were one array. Let's try loading <code>$BEEF</code> again:
<syntaxhighlight lang="6502">LDX #1 ;with split arrays we DON'T need to double our index.
LDA wordArray_Lo,x ;evaluates to LDA #$EF
STA $00
LDA wordArray_Hi,x ;evaluates to LDA #$BE
STA $01</syntaxhighlight>
Both tables share the same index, which means you can do the lookup without destroying your index (not that it was that difficult to retrieve the original index to begin with), but on 8-bit computers you want to be as efficient as possible, using the hardware's strengths to your advantage. Splitting your "wider" arrays into multiple 8-bit tables is often the best approach.
===Two-Dimensional Arrays===
I'll let you in on a little secret: two-dimensional arrays don't exist. This is just as true for modern computers as it is the 6502.
In the first section I had this example of an array:
<syntaxhighlight lang="6502asm">Array:
db 5,10,15,20,25,30,35,40,45,50</syntaxhighlight>
In the eyes of the CPU, this is the same as ANY of the following:
<syntaxhighlight lang="6502asm">Array:
db 5
db 10
db 15
db 20
db 25
db 30
db 35
db 40
db 45
db 50</syntaxhighlight>
<syntaxhighlight lang="6502asm">Array:
db 5,10
db 15,20
db 25,30
db 35,40
db 45,50</syntaxhighlight>
or any other way to write it you can imagine. All that matters is the order of the bytes in the array - as long as that is the same you can write it however you want. It's best to write it in the way it's meant to be interpreted, however. But in order to explain that to the computer you'll need a little bit of finesse. Let's pretend that the "correct" interpretation is this 5 by 2 array:
<syntaxhighlight lang="6502asm">Array:
db 5,10
db 15,20
db 25,30
db 35,40
db 45,50</syntaxhighlight>
For this example, we want row 3 and column 1 (zero-indexed for both) which means we want to load 40.
<syntaxhighlight lang="6502">
LDA #3 ;desired row
ASL A ;Times 2 bytes per row (if the array's row size wasn't a multiple of 2 we'd need to actually do multiplication)
;which the 6502 doesn't have in hardware but can be simulated by repeated adding.
CLC
ADC #1 ;desired column (since it's 1 byte per column, we can skip the part where we multiply desired column by bytes per column)
TAX ;move A to X so we can use it as the index
LDA Array,x ;evaluates to LDA #40</syntaxhighlight>
You may be wondering, why not just treat the array as though it were one-dimensional? Reason is, you won't always know in advance what you want from your array, it may depend on 2 variables in your program (such as X/Y coordinates, etc.), so you might need to use this method rather than just treating it as linear data.
=={{header|68000 Assembly}}==
Creating an array is as simple as declaring its base address. Note that all bounds checking must be done by the programmer and is not built in by default. You also will need to have some sort of knowledge about what is stored nearby, so that you don't clobber it.
<syntaxhighlight lang="68000devpac">MOVE.L #$00100000,A0 ;define an array at memory address $100000</syntaxhighlight>
Defining an array in ROM (or RAM if you're making a program that is loaded from disk) is very simple:
<syntaxhighlight lang="68000devpac">;8-bit data
MyArray:
DC.B 1,2,3,4,5
DC.B 6,7,8,9,10
DC.B 11,12,13,14,15
EVEN ;needed to ensure proper alignment after a byte array with an odd number of entries.
;16-bit data
MyArrayW:
DC.W 1,2,3,4,5
DC.W 6,7,8,9,10
DC.W 11,12,13,14,15
;32-bit data
MyArrayL:
DC.L 1,2,3,4,5
DC.L 6,7,8,9,10
DC.L 11,12,13,14,15
</syntaxhighlight>
Strings are also arrays and most assemblers accept single or double quotes. The following are equivalent:
<syntaxhighlight lang="68000devpac">MyString:
DC.B "Hello World",0
even
MyString2:
DC.B 'H','e','l','l','o',' ','W','o','r','l','d',0
even</syntaxhighlight>
The assembler will automatically substitute each letter with its ASCII equivalent. Notice the lack of quotes around the null terminator 0. If it had quotes, it would be assembled as 0x30 instead of 0. Not good if your printing routine expects a 0 as the terminator byte.
The above declarations are useful as compile-time constants or mutable pre-loaded values. Whether an array is mutable or not depends solely on whether it is stored in ROM or RAM.
<i>Side note: Some systems, such as the Sega Genesis or other ROM cartridge-based computers, cannot use the above declaration to initialize an array in RAM at assemble time; only in ROM. While an array can be declared at any arbitrary RAM location on any system, you won't be able to define a data block in RAM the same way you would on an assembly program meant to run on the Macintosh or Commodore Amiga for example. The examples below will still work on any system, you just won't be able to "see" the array before running the program, if that makes sense. A simple alternative can be to define the array in ROM then copy it to RAM and work with it there.</i>
The data type associated with the elements of an array is determined by the move operation used to assign elements to an array. The language does not prohibit you from storing
The base address can be offset by the value in a data register, to allow for assigning values to an array. The offset is always measured in bytes, so if your array is intended to contain a larger data size you will need to adjust it accordingly.
<
LEA myArray,A0 ;load the base address of the array into A0
Line 100 ⟶ 261:
LSL.W #2,D0 ;this array is intended for 32-bit values.
MOVE.L #23,D1 ;load decimal 23 into D1
MOVE.L D1,(A0,D0) ;store #23 into the 3rd slot of the array (arrays are zero-indexed in assembly)</
This is the equivalent of the [[C]] code:
<
myArray[3] = 23;</
Loading an element is very similar to storing it.
<
;load element 4
Line 114 ⟶ 275:
MOVE.W #4,D0 ;load the desired offset into D0
LSL.W #2,D0 ;this array is intended for 32-bit values.
MOVE.L (A0,D0),D1 ;load the 4th element into D1.</
Inserting an element at a desired position is a bit more tricky. First of all, an array has no "end" in hardware. So how do you know where to stop? For this example, assume this array is currently contains 6 total elements (0,1,2,3,4,5) and we want to extend it.
<
;insert a new element into the 2nd slot and push everything behind it back.
Line 147 ⟶ 308:
MOVE.L (A0,D0),(4,A0,D0)
ADDA.L #4,A0
DBRA D2,LOOP</
The use of the number 4 in <code>(4,A0,D0)</code> and <code>ADDA.L #4,A0</code> was because we were working with <code>MOVE.L</code> commands to store 32-bit values. If your data size was 16 bit you would replace the 4s with 2s, and if it was 8 bit you would use 1s.
Line 157 ⟶ 318:
<li>In external RAM - element retrieval/altering is most efficiently done sequentially, necessary for large arrays or peripherals</ul>
Dynamic (resizable) arrays are possible to implement, but are error-prone since bounds checking must be done by the programmer.
<
myarray db 'Array' ; db = define bytes - initializes 5 bytes with values 41, 72, 72, etc. (the ascii characters A,r,r,a,y)
myarray2 dw 'A','r','r','a','y' ; dw = define words - initializes 5 words (1 word = 2 bytes) with values 41 00 , 72 00, 72 00, etc.
Line 248 ⟶ 409:
pop dph
</syntaxhighlight>
=={{header|8th}}==
Arrays are declared using JSON syntax, and are dynamic (but not sparse)
<
[ 1 , 2 ,3 ] \ an array holding three numbers
1 a:@ \ this will be '2', the element at index 1
Line 268 ⟶ 429:
\ arrays don't have to be homogenous:
[1,"one", 2, "two"]
</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program areaString64.s */
Line 418 ⟶ 579:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|ABAP}}==
There are no real arrays in ABAP but a construct called internal tables.
<syntaxhighlight lang="abap">
TYPES: tty_int TYPE STANDARD TABLE OF i
WITH NON-UNIQUE DEFAULT KEY.
Line 436 ⟶ 597:
cl_demo_output=>display( itab ).
cl_demo_output=>display( itab[ 2 ] ).
</syntaxhighlight>
{{out}}
Line 449 ⟶ 610:
=={{header|ACL2}}==
<
(assign array-example
(compress1 'array-example
Line 463 ⟶ 624:
;; Get a[5]
(aref1 'array-example (@ array-example) 5)</
=={{header|Action!}}==
<
BYTE i
Line 525 ⟶ 686:
PrintF("c(%B)=%B ",i,c(i))
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Arrays.png Screenshot from Atari 8-bit computer]
Line 549 ⟶ 710:
=={{header|ActionScript}}==
<
var array1:Array = new Array(10);
//creates an array with the values 1, 2
Line 564 ⟶ 725:
array2.push(4);
//get and remove the last element of an array
trace(array2.pop());</
=={{header|Ada}}==
<
A, B : Example_Array_Type;
-- Ada array indices may begin at any value, not just 0 or 1
C : array (-37..20) of
-- Ada arrays may be indexed by enumerated types, which are
Line 595 ⟶ 757:
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
Line 605 ⟶ 767:
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(Fingers'First) := False; -- Set first element of array
Fingers_Extended(Fingers'Last) := False; -- Set last element of array
end Array_Test;</syntaxhighlight>
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.
=={{header|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)
Line 631 ⟶ 793:
var arr7 = arr1 & arr2 // intersection
</syntaxhighlight>
# retrieve an element
Line 638 ⟶ 800:
=={{header|Aime}}==
The aime ''list'' is a heterogeneous, dynamic sequence. No special creation procedure, only declaration is needed:
<syntaxhighlight lang
Values (numbers, strings, collections, functions, etc) can be added in a type generic fashion:
<
l_append(l, "arrays");
l_append(l, pow);</
The insertion position can be specified:
<
l_push(l, 4, __type(l));</
More aptly, values (of selected types) can be inserted in a type specific fashion:
<
l_p_real(l, 6, 88);</
Similarly, values can be retrieved in a type generic fashion:
<syntaxhighlight lang
or is type specific fashion:
<
l_q_text(l, 1);</
=={{header|ALGOL 60}}==
{{trans|Simula}}
<
comment arrays - Algol 60;
Line 689 ⟶ 851:
dynamic(5)
end arrays </
{{out}}
<pre>
Line 697 ⟶ 859:
=={{header|ALGOL 68}}==
<
(
[1:20]INT a;
Line 716 ⟶ 878:
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.
=={{header|ALGOL W}}==
<
% declare an array %
integer array a ( 1 :: 10 );
Line 738 ⟶ 900:
% as parameters to procedures %
% multi-dimension arrays are supported %
end.</
=={{header|AmigaE}}==
<
da: PTR TO CHAR,
la: PTR TO CHAR
Line 757 ⟶ 919:
-> "deallocating" the array
IF la <> NIL THEN END la[100]
ENDPROC</
=={{header|AntLang}}==
<
arr: <1;2;3>
Line 772 ⟶ 934:
/ Get the nth element (index origin = 0)
nth:arr[n]</
=={{header|Apex}}==
<
array[0] = 42;
System.debug(array[0]); // Prints 42</
Dynamic arrays can be made using <code>List</code>s. <code>List</code>s and array can be used interchangeably in Apex, e.g. any method that accepts a <code>List<String></code> will also accept a <code>String[]</code>
<
aList.add(5);// appends to the end of the list
aList.add(1, 6);// assigns the element at index 1
System.debug(list[0]); // Prints 5, alternatively you can use list.get(0)</
=={{header|APL}}==
Arrays in APL are one dimensional matrices, defined by seperating variables with spaces. For example:
<syntaxhighlight lang
Is equivalent to <
=={{header|App Inventor}}==
Line 797 ⟶ 959:
=={{header|AppleScript}}==
AppleScript arrays are called lists:
<
set ints to {1, 2, 3}</
Lists can contain any objects including other lists:
<
Items can be appended to the beginning or end of a list:
<
set beginning of any to false
set end of any to Wednesday
return any
--> {false, 1, "foo", 2.57, missing value, {1, 2, 3}, Wednesday}</
Or a new list containing the items can be created through concatenation:
<
set any to false & any & Wednesday
--> {false, 1, "foo", 2.57, missing value, {1, 2, 3}, Wednesday}</
However, this isn't usually as efficient and it's important to be aware of the coercion rules associated with AppleScript concatenations, which may lead to unexpected results!
Line 823 ⟶ 985:
List indices are 1-based and negative numbers can be used to index items from the end of the list instead of from the beginning. Items can be indexed individually or by range:
<
item -1 of any --> {1, 2, 3}
items 1 thru 3 of any --> {1, "foo", 2.57}</
If required, items can be specified by class instead of the generic 'item' …
<
number 2 of any -- 2.57 (ie. the second number in the list)</
… and some fairly complex range specifiers are possible:
<
integers from text 1 to list 1 of any --> {5, 4, 38}</
The length of a list can be determined in any of three ways, although only the first two below are now recommended:
<
length of any -- Property.
number of any -- Property.</
The number of items of a specific class can also be obtained:
<
length of any's integers</
A list's other properties are its <code>rest</code> (which is another list containing all the items except for the first) and its <code>reverse</code> (another list containing the items in reverse order).
Line 852 ⟶ 1,014:
Through AppleScriptObjC, AppleScript is also able to make use of Objective-C arrays and many of their methods, with bridging possible between lists and NSArrays:
<
use framework "Foundation" -- Allows access to NSArrays and other Foundation classes.
Line 858 ⟶ 1,020:
set myNSArray to current application's NSArray's arrayWithArray:myList -- Bridge the list to an NSArray.
set arrayLength to myNSArray's |count|() -- Get the array's length using its 'count' property.
--> 5</
=={{header|Arendelle}}==
Line 895 ⟶ 1,057:
=={{header|Argile}}==
{{works with|Argile|1.0.0}}
<
(:::::::::::::::::
Line 925 ⟶ 1,087:
DynArray[5] = 243
prints DynArray[0] DynArray[5]
del DynArray</
{{works with|Argile|1.1.0}}
<
let x = @["foo" "bar" "123"]
print x[2]
x[2] = "abc"</
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program areaString.s */
Line 1,123 ⟶ 1,285:
.Ls_magic_number_10: .word 0x66666667
</syntaxhighlight>
=={{header|Arturo}}==
<
arrA: []
Line 1,141 ⟶ 1,303:
; retrieve an element at some index
print arrB\1</
{{out}}
Line 1,152 ⟶ 1,314:
{{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[1] := "foo"
myArray[2] := "bar"
Line 1,158 ⟶ 1,320:
; 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.
<
arrayX1 = first
arrayX2 = second
Line 1,172 ⟶ 1,334:
StringSplit arrayX, source, %A_Space%
Loop, %arrayX0%
Msgbox % arrayX%A_Index%</
=={{header|AutoIt}}==
Create an userdefined array.
<syntaxhighlight lang="autoit">
#include <Array.au3> ;Include extended Array functions (_ArrayDisplay)
Line 1,191 ⟶ 1,353:
_ArrayDisplay($aInputs) ;Display the Array
</syntaxhighlight>
=={{header|Avail}}==
Avail supports tuples as its primary ordered collection.
<
Tuple indices (officially referred to as "subscripts") are 1-based. One can provide an alternative if there is no element at a subscript using an else clause.
<
<3, 2, 1>[100] else [0]</
Tuples are immutable, however one can quickly create a new tuple with a specified element replaced.
<
=={{header|AWK}}==
Line 1,209 ⟶ 1,371:
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.
<
# to make an array, assign elements to it
array[1] = "first"
Line 1,238 ⟶ 1,400:
print " " i ": " array[i]
}
}</
{{out}}
Line 1,264 ⟶ 1,426:
=={{header|Axe}}==
<
2→{L₁+1}
3→{L₁+2}
Line 1,271 ⟶ 1,433:
Disp {L₁+1}►Dec,i
Disp {L₁+2}►Dec,i
Disp {L₁+3}►Dec,i</
=={{header|Babel}}==
Line 1,279 ⟶ 1,441:
There are two kinds of array in Babel: value-arrays and pointer-arrays. A value-array is a flat array of data words. A pointer-array is an array of pointers to other things (including value-arrays). You can create a data-array with plain square-brackets. You can create a value-array with the [ptr ] list form:
<syntaxhighlight lang
<syntaxhighlight lang
===Get a single array element===
<
{{Out}}
Line 1,295 ⟶ 1,457:
Changing a value-array element:
<
</syntaxhighlight>
{{Out}}
Line 1,303 ⟶ 1,465:
Changing a pointer-array element:
<
{{Out}}
Line 1,310 ⟶ 1,472:
===Select a range of an array===
<
{{Out}}
Line 1,319 ⟶ 1,481:
You can concatenate arrays of same type:
<
<
Concatenation creates a new array - it does not add to an array in-place. Instead, Babel provides operators and standard utilities for converting an array to a list in order to manipulate it, and then convert back.
Line 1,329 ⟶ 1,491:
Convert a value-array to a list of values:
<
{{Out}}
Line 1,336 ⟶ 1,498:
Convert a list of values to a value-array:
<
{{Out}}
Line 1,343 ⟶ 1,505:
Convert a pointer-array to a list of pointers:
<
{{Out}}
Line 1,350 ⟶ 1,512:
Convert a list of pointers to a pointer-array:
<
{{Out}}
Line 1,361 ⟶ 1,523:
Note: We need to use quotes in DATA
<
DATA "January", "February", "March", "April", "May", "June", "July"
DATA "August", "September", "October", "November", "December"
Line 1,370 ⟶ 1,532:
PRINT dat$[i]
NEXT
</syntaxhighlight>
2.) A modern BaCon approach to do arrays using strings
<
DECLARE A$[11] = {"January", "February", "March", "April", "May", \
"June", "July", "August", "September", "October", "November", "December"} TYPE STRING
Line 1,384 ⟶ 1,546:
INCR i
WEND
</syntaxhighlight>
Line 1,390 ⟶ 1,552:
name this '''split.bac'''
<
SPLIT ARGUMENT$ BY " " TO TOK$ SIZE len_array
Line 1,396 ⟶ 1,558:
PRINT TOK$[i]
NEXT i
</syntaxhighlight>
in the terminal
<
./split January February March April May June July August September October November December
</syntaxhighlight>
Notes: if you want to take a string from the command line
Line 1,414 ⟶ 1,576:
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.
<
DIM myArray(100) AS INTEGER </
Alternatively, the lower and upper bounds can be given while defining the array:
<
Dynamic arrays:
<
'$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'''
Line 1,433 ⟶ 1,595:
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:
<
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.
<
<
20 REM ELEMENT NUMBERS TRADITIONALLY START AT ONE
30 DIM A%(11): REM ARRAY OF ELEVEN INTEGER ELEMENTS
Line 1,451 ⟶ 1,613:
50 LET A%(11) = 1
60 PRINT A%(1), A%(11)
70 END</
{{works with|qbasic}}
Line 1,457 ⟶ 1,619:
===Static===
<
staticArray(0) = -1
staticArray(10) = 1
PRINT staticArray(0), staticArray(10)</
===Dynamic===
Line 1,468 ⟶ 1,630:
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 (<code>DIM</code> vs. <code>REDIM</code>). [[QBasic]] lacks the <code>PRESERVE</code> keyword found in some modern BASICs; resizing an array without <code>PRESERVE</code> zeros the values.
<
dynamicArray(0) = -1
Line 1,476 ⟶ 1,638:
dynamicArray(20) = 1
PRINT dynamicArray(0), dynamicArray(20)</
==={{header|Applesoft BASIC}}===
<
20 LET A%(0) = -1
30 LET A%(11) = 1
40 PRINT A%(0), A%(11)</
==={{header|Commodore BASIC}}===
same as Applesoft BASIC
==={{header|Quite BASIC}}===
<syntaxhighlight lang="basic">10 ARRAY A
20 DIM B(10)
30 DIM C(3,2)
40 LET A[4711] = 17
50 LET B(3) = 5
60 LET B[7] = 3
70 LET C(3,2) = 1
80 PRINT C(3,2) + B(7) + B[3] + A(4711)</syntaxhighlight>
{{out}}
<pre>26</pre>
=={{header|BASIC256}}==
<
dim numbers(10)
for t = 0 to 9
Line 1,516 ⟶ 1,690:
print numbers[t] + "=" + words$[t]
next t
return</
=={{header|Batch File}}==
Arrays can be approximated, in a style similar to REXX
<
@echo off
setlocal ENABLEDELAYEDEXPANSION
Line 1,545 ⟶ 1,719:
echo %1 = %2
goto :eof
</syntaxhighlight>
{{out}}
Line 1,558 ⟶ 1,732:
=={{header|BBC BASIC}}==
<
DIM array(6), array%(6), array$(6)
Line 1,574 ⟶ 1,748:
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)</
=={{header|bc}}==
Line 1,581 ⟶ 1,755:
The following is a transcript of an interactive session:
<
g[3] = 42
/* Look at some other elements in g */
Line 1,598 ⟶ 1,772:
123
g[3]
42</
=={{header|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
Line 1,615 ⟶ 1,789:
% There is no automatic garbage collection
delete $arr
</syntaxhighlight>
=={{header|Boo}}==
<
myArray as (int) = (1, 2, 3) // Size based on initialization
fixedArray as (int) = array(int, 1) // Given size(1 in this case)
Line 1,627 ⟶ 1,801:
print myArray[0]
</syntaxhighlight>
=={{header|BQN}}==
Line 1,633 ⟶ 1,807:
All arrays are variable length, and can contain any types of values.
<
arr ← 1‿2‿'a'‿+‿5
# General List Syntax:
Line 1,645 ⟶ 1,819:
# Modifying the array(↩):
arr ↩ "hello"⌾(4⊸⊑) arr</
<
⟨ 1 2 'a' + 5 ⟩
⟨ 1 2 'a' + 5 ⟩
+
⟨ 1 2 'a' + "hello" ⟩</
[https://mlochbaum.github.io/BQN/try.html#code=IyBTdHJhbmRpbmc6CmFyciDihpAgMeKAvzLigL8nYSfigL8r4oC/NQojIEdlbmVyYWwgTGlzdCBTeW50YXg6CmFycjEg4oaQIOKfqDEsMiwnYScsKyw14p+pCuKAolNob3cgYXJyIOKJoSBhcnIxICMgYm90aCBhcnJheXMgYXJlIHRoZSBzYW1lLgrigKJTaG93IGFycgrigKJTaG93IGFycjEKCiMgVGFraW5nIG50aCBlbGVtZW50KOKKkSk6CuKAolNob3cgM+KKkWFycgoKIyBNb2RpZnlpbmcgdGhlIGFycmF5KOKGqSk6CmFyciDihqkgImhlbGxvIuKMvig04oq44oqRKSBhcnIK Try It Here!]
Line 1,665 ⟶ 1,839:
To delete and array (and therefore the variable with the array's name), call <code>tbl</code> with a size <code>0</code>.
<
& 5:?(30$mytable)
& 9:?(31$mytable)
Line 1,675 ⟶ 1,849:
| out$"mytable is gone"
)
);</
{{out}}
<pre>5
Line 1,685 ⟶ 1,859:
Note that Brainf*** does not natively support arrays, this example creates something that's pretty close, with access of elements at each index, altering elements, and changing size of list at runtime.
<syntaxhighlight lang="bf">
===========[
ARRAY DATA STRUCTURE
Line 1,771 ⟶ 1,945:
return back by finding leftmost null then decrementing pointer
twice then decrement our NEWVALUE cell
</syntaxhighlight>
=={{header|C}}==
Fixed size static array of integers with initialization:
<
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.
<
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.
<
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 <code>malloc()</code>, <code>calloc()</code> and <code>free()</code> functions require the header <code>stdlib.h</code>.
<
int *myArray = malloc(sizeof(int) * numElements); /* array of 10 integers */
if ( myArray != NULL ) /* check to ensure allocation succeeded. */
Line 1,800 ⟶ 1,974:
/* 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[1] = 3;</
And to retrieve it (e.g. for printing, provided that the <tt>stdio.h</tt> header was included for the printf function)
<
The <tt>array[index]</tt> syntax can be considered as a shortcut for <tt>*(index + array)</tt> and
thus the square brackets are a commutative binary operator:
<
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.
<
double *kernel = malloc(sizeof(double)*2*XSIZE+1);
if (kernel) {
Line 1,827 ⟶ 2,001:
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).
Line 1,833 ⟶ 2,007:
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:
<syntaxhighlight lang="c">
int *array = malloc (sizeof(int) * 20);
....
array = realloc(array, sizeof(int) * 40);
</syntaxhighlight>
A Linked List for chars may be implemented like this:
<syntaxhighlight lang="c">
#include <stdlib.h>
#include <stdio.h>
Line 1,899 ⟶ 2,073:
list->size = 0;
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
Line 1,905 ⟶ 2,079:
Example of array of 10 int types:
<
Example of array of 3 string types:
<
You can also declare the size of the array and initialize the values at the same time:
<
Line 1,919 ⟶ 2,093:
The following creates a 3x2 int matrix
<
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.
<
or
<
<
array[0] = 1;
array[1] = 3;
Console.WriteLine(array[0]);</
Dynamic
<
using System.Collections.Generic;
Line 1,948 ⟶ 2,122:
list[0] = 2;
Console.WriteLine(list[0]);</
=={{header|C++}}==
Line 1,962 ⟶ 2,136:
<code>std::vector<T></code> is a resizable array of <code>T</code> objects.
The memory for the array will be allocated from the heap (unless a custom allocator is used).
<
#include <vector>
Line 2,005 ⟶ 2,179:
demonstrate(fixed_size_array);
demonstrate(dynamic_array);
}</
=={{header|Ceylon}}==
{{works with|Ceylon|1.3.0}}
<
ArrayList
Line 2,028 ⟶ 2,202:
list.push("hello again");
print(list);
}</
=={{header|ChucK}}==
<syntaxhighlight lang="c">
int array[0]; // instantiate int array
array << 1; // append item
Line 2,041 ⟶ 2,215:
[1,2,3,4,5,6,7] @=> array;
array.popBack(); // Pop last element
</syntaxhighlight>
=={{header|Clean}}==
Line 2,047 ⟶ 2,221:
===Lazy array===
Create a lazy array of strings using an array denotation.
<
array = {"Hello", "World"}</
Create a lazy array of floating point values by sharing a single element.
<
array = createArray 10 3.1415</
Create a lazy array of integers using an array (and also a list) comprehension.
<
array = {x \\ x <- [1 .. 10]}</
===Strict array===
Create a strict array of integers.
<
array = {x \\ x <- [1 .. 10]}</
===Unboxed array===
Create an unboxed array of characters, also known as <tt>String</tt>.
<
array = {x \\ x <- ['a' .. 'z']}</
=={{header|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.
<
Local arr1 := { { "NITEM","N",10,0 }, { "CONTENT","C",60,0} }
// Create an empty array
Line 2,076 ⟶ 2,250:
// 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
<
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:
<
// The retrieved item can be nested array, in this case it isn't copied, the pointer to it is assigned
</syntaxhighlight>
There is a set of functions to manage arrays in Clipper, including the following:
<
AFill( arr4, 0, 5, 20 )
//Copy 10 items from arr4 to arr3[2], starting from the first position:
Line 2,095 ⟶ 2,269:
//Duplicate the whole or nested array:
arr5 := AClone( arr1 )
arr6 := AClone( arr1[3] )</
=={{header|Clojure}}==
<
;is, instead clojure creates a new array with an added value using (conj...)
;in the example below the my-list does not change.
Line 2,131 ⟶ 2,305:
user=> (conj my-vec 300) ;adding to a vector always adds to the end of the vector
[1 2 3 4 5 6 300]</
=={{header|COBOL}}==
In COBOL, arrays are called ''tables''. Also, indexes begin from 1.
<
PROGRAM-ID. arrays.
Line 2,173 ⟶ 2,347:
GOBACK
.</
=={{header|CoffeeScript}}==
<
array1[0] = "Dillenidae"
array1[1] = "animus"
Line 2,183 ⟶ 2,357:
array2 = ["Cepphus", "excreta", "Gansu"]
alert "Value of array2[1]: " + array2[1] # excreta</
=={{header|ColdFusion}}==
Creating a one-dimensional Array:
<
Creating a two-dimensional Array in CFScript:
<
arr2 = ArrayNew(2);
</cfscript></
''ColdFusion Arrays are '''NOT''' zero-based, they begin at index '''1'''''
=={{header|Common Lisp}}==
<
(setf (aref array 0) 1
(aref array 1) 3)
(print array))</
Dynamic
<
(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.
<syntaxhighlight lang
Creates a two-dimensional array with dimensions 10x20.
<
<tt>make-array</tt> may be called with a number of optional arguments.
<
(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)</
=={{header|Component Pascal}}==
Line 2,225 ⟶ 2,399:
<
MODULE TestArray;
(* Implemented in BlackBox Component Builder *)
Line 2,252 ⟶ 2,426:
END DoTwoDim;
END TestArray.</
=={{header|Computer/zero Assembly}}==
Line 2,261 ⟶ 2,435:
===Fixed-length array===
We have finished iterating through the array when the next load instruction would be <tt>LDA ary+length(ary)</tt>.
<
ADD sum
STA sum
Line 2,291 ⟶ 2,465:
8
9
10</
===Zero-terminated array===
<
BRZ done
Line 2,322 ⟶ 2,496:
9
10
0</
=={{header|Crystal}}==
<
# create an array with one object in it
a = ["foo"]
Line 2,346 ⟶ 2,520:
%w(one two three) # => ["one", "two", "three"]
%i(one two three) # => [:one, :two, :three]
</syntaxhighlight>
=={{header|D}}==
<
import std.stdio, core.stdc.stdlib;
Line 2,389 ⟶ 2,563:
writeln("D) Element 0: ", array4[0]);
writeln("D) Element 1: ", array4[1]);
}</
{{out}}
<pre>A) Element 0: 1
Line 2,400 ⟶ 2,574:
D) Element 1: 3</pre>
One more kind of built-in array:
<
void main() {
Line 2,410 ⟶ 2,584:
writeln("E) Element 0: ", vector5.array[0]);
writeln("E) Element 1: ", vector5.array[1]);
}</
{{out}}
<pre>E) Element 0: 1
Line 2,416 ⟶ 2,590:
=={{header|Dao}}==
<
a = [ 1, 2, 3 ] # a vector
b = [ 1, 2; 3, 4 ] # a 2X2 matrix
Line 2,425 ⟶ 2,599:
d = a[1]
e = b[0,1] # first row, second column
f = c[1]</
=={{header|Dart}}==
<
main(){
// Dart uses Lists which dynamically resize by default
Line 2,471 ⟶ 2,645:
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,481 ⟶ 2,655:
=={{header|DBL}}==
<syntaxhighlight lang="dbl">;
; Arrays for DBL version 4 by Dario B.
;
Line 2,532 ⟶ 2,706:
VNUM2(1:5*8)=
CLEAR VALP1(1:5*8),VALP2(1:5*10)
VALP3(1:5*2*10)=</
=={{header|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
Line 2,572 ⟶ 2,746:
// Displaying both arrays (#13#10 = Carriage Return/Line Feed)
ShowMessage(StaticArrayText + #13#10 + DynamicArrayText);
end;</
=={{header|Diego}}==
<syntaxhighlight lang="diego">set_ns(rosettacode);
set_base(0);
// Create a new dynamic array with length zero, variant and/or mixed datatypes
add_array(myEmptyArray);
// Create a new dynamic array with length zero, of integers with no mixed datatypes
add_array({int}, myIntegerArray);
// Create a new fixed-length array with length 5
add_array(myFiveArray)_len(5)_base(0); // The value base '_base(0)' is usually defaulted to zero, depends upon thing.
// Create an array with 2 members (length is 2)
add_ary(myStringArray)_value(Item1,Item2); // '_array' can be shortened to '_ary'
// Assign a value to member [2]
with_ary(myChangeArray)_at(2)_v(5); // '_value' can be shortened to '_v'
// Add a member to an array with the push function (defaulted at end), length increased by one
[myExpandedArray]_push()_v(9); // 'with_ary(...)' can be shortened to '[...]'
[myExpandedArray]_append()_v(9);
// Add a member to an array with the push function (at a location), length increased by one
[myExpandedArray]_pushat(3)_v(8);
// Remove a member to an array with the pop function (defaulted at end), length reduced by one
[myExpandedArray]_pop();
// Remove a member to an array with the pop function (at a location), length reduced by one
[myExpandedArray]_popat(3);
// Swap a member to an array with the swap function
[myExpandedArray]_swapfrom(2)_swapto(6);
[myExpandedArray]_swap(2, 6);
// Rectiline a member in an array
[MyCaterpillarArray]_rectilat(4)_rectilup(2);
[MyCaterpillarArray]_rectilup(4, 2);
[MyCaterpillarArray]_rectilat(5)_rectildown(3);
[MyCaterpillarArray]_rectildown(5, 3);
// Null a member to an array with the pluck function (defaulted at end)
[myExpandedArray]_pluck();
// Null a member to an array with the pluck function (at a location)
[myExpandedArray]_pluckat(3);
// Get size of array
[mySizableArray]_size(); // '_len()' can also be used
[myMultidimensialArray]_size()
// Retrieve an element of an array
[myArray]_at(3);
[myArray]_first(); // Retrieve first element in an array
[myArray]_last(); // Retrieve last element in an array
// More transformations of arrays (like append, union, intersection) are available
// For multi-dimensional array use the 'matrix' object
set_matrixorder(row-major); // set major order as row- or column-major order depends on the thing
set_handrule(right); // set hand-rule, most things will use right hand-rule
// Create a new dynamic two-dimensional array with length zero, variant and/or mixed datatypes
add_matrix(myMatrix)_dim(2);
// Create a new dynamic three-dimensional array with length zero, of integers with no mixed datatypes
add_matrix({int}, my3DEmptyMatrix)_dim(3);
// Convert an array to a matrix by adding a new dimension with length zero, variant and/or mixed datatypes
with_array(MyConvertedArray)_dim(); // Should now use '_matrix' object rather than '_array'
with_array(MyConvertedArray)_dim(3); // Add three dimensions to array, should now use '_matrix' object rather than '_array'
// Create a new fixed-length traditional (2D) matrix with 5 rows and 4 columns
add_matrix(myMatrix)_rows(5)_columns(4);
add_matirx(myMatrix)_subs(5, 4); // check or set major order first
// Create a new fixed-length mutil-dimensional matrix with 5 rows, 4 columns, 6 subscripts, and 8 subscripts
add_matrix(myMatrix)_rows(5)_columns(4)_subs(6)_subs(8);
add_mat(myMatrix)_subs(5, 4, 6, 8); // check or set major order first, '_matrix' can be shortened to 'mat'
// Create a 4 x 4 identiy matrix:
add_mat(myIdentityMatrix)_subs(4, 4)_identity; // ...or...
add_mat(myMorphedMatrix)_subs(4, 4)
with_mat(myMorphedMatrix)_trans(morph)_identity(); // More transformations available
// Assign a value to member [2,4]
with_mat(myMatrix)_row(2)_col(4)_value(5); // ...or...
with_mat(myMatrix)_at(2, 4)_v(5); // check or set major order first
// Add a member(s) to a matrix using push functions is available
// Remove a member(s) from a matrix with the pop functions is available
// Swap a member(s) in a matrix with the swap functions is available
// Rectiline a single member in a three-dimensional matrix
[MyWobbleMatrix]_rectilat()_row(3)_col(3)_sub(3)_rectilto()_row(-1)_col(1)_sub(0); // ...or...
[MyWobbleMatrix]_rectilat(3, 3, 3)_rectilto(-1, 1, 0); // check or set major order first, ...or...
[MyWobbleMatrix]_rectilat(3, 3, 3)_rectilleft(1)_rectilup(1); / check or set hand-rule, ...or...
// Also 'crab', 'elevate', 'slide' and 'pump' movements are available
// Also 'row', 'pitch', and 'yaw' movements are available
// Also, quaternions calculations are available
// Null a member in a matrix using pluck functions is available
// Get size of a matrix
mat(mySizableMatrix)_size(); // will return an array of the size()
[myMultidimensialArray]_len(); // '_len()' can also be used
// Retrieve an element of a matrix
[myMatrix]_at(3, 2);
[myArray]_first()_atsub(2); // Retrieve first element of a row/column/subscript of a matrix
[myArray]_last()_atsub(2); // Retrieve last element of a row/column/subscript of a matrix
[myArray]_origin(); // Retrieve first element in a matrix
[myArray]_end(); // Retrieve last element in a matrix
reset_ns[];</syntaxhighlight>
=={{header|Dragon}}==
<
array[0] = 42
showln array[2] </
=={{header|DWScript}}==
<
// dynamic array, extensible, this a reference type
var d : array of Integer;
Line 2,596 ⟶ 2,889:
// inline array constructor, works for both static and dynamic arrays
s := [1, 2, 3];
</syntaxhighlight>
=={{header|Dyalect}}==
<
var empty = []
var xs = [1, 2, 3]
Line 2,610 ⟶ 2,903:
//Access array elements
var x = xs[2]
xs[2] = x * x</
=={{header|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.
<
local :l []
Line 2,634 ⟶ 2,927:
#this prints Boo
!print pop-from l
</syntaxhighlight>
=={{header|E}}==
Line 2,642 ⟶ 2,935:
Literal lists are <code>ConstList</code>s.
<
# value: []
Line 2,652 ⟶ 2,945:
? 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:
<
# value: []
Line 2,663 ⟶ 2,956:
? 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''.
<
# value: [1, 2].diverge()
Line 2,678 ⟶ 2,971:
? flex.snapshot()
# value: [1, 2, -3]</
Creating a FlexList with a specific size, generic initial data, and a type restriction:
<
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]].
Line 2,690 ⟶ 2,983:
=={{header|EasyLang}}==
<syntaxhighlight lang="text">len f[]
for i
f[i] = i
.
f[] &=
for i
print f[i]
.</
=={{header|Ecstasy}}==
Arrays use the [] syntax from C, use zero-based indexing, have a literal syntax, and are implemented by the [https://github.com/xtclang/xvm/blob/master/lib_ecstasy/src/main/x/ecstasy/collections/Array.x Array] class.
There are four mutability modes for the Array class, defined by the Array.Mutability enumeration. Here are some examples of how to use these different modes, and to create and manipulate arrays:
<syntaxhighlight lang="java">
module test {
void show(Object o=Null) {
@Inject Console console;
console.print(o);
}
void run() {
// an array literal has Constant mutability; it is **not** mutable
immutable Int[] literalArray = [1,2,3];
show($"{literalArray=}, {&literalArray.actualType=}");
// obtaining the size or any element of an array is easy
show($"{literalArray.size=}, {literalArray[2]=}");
// modifications to a Constant array result in a new Constant array;
// in Computer Science, this is called a persistent data structure
immutable Int[] biggerArray = literalArray + 4;
show($"{biggerArray=}, {&biggerArray.actualType=}");
immutable Int[] biggestArray = biggerArray + biggerArray;
show($"{biggestArray=}, {&biggestArray.actualType=}");
// arrays can be accessed using the bracket operators
show($"element at {biggestArray[2]=}");
// attempts to modify an immutable array "in place" will result in an
// exception at runtime
try {
biggestArray[2] = 99;
} catch (ReadOnly e) {
show($"immutable array not modified: {biggestArray=}");
}
// fixed-size arrays are like C/Java/C# arrays; their elements are
// all set to the default value of the array Element type
Int[] fixedLengthArray = new Int[10];
show($"element at {fixedLengthArray[2]=}");
// you can also initialize all the elements to a specific value
Int[] negOnes = new Int[3](-1);
show($"{negOnes=}");
// ... or using a lambda
Int[] counting = new Int[5](i -> i);
show($"{counting=}");
// attempts to modify a fixed-size array "in place" will succeed
counting[1] = 99;
show($"replaced [1]=99: {counting=}");
// attempts to add or delete elements from a fixed-size array will
// raise an exception
try {
counting += 101;
} catch (ReadOnly e) {
show($"Fixed mutability array not appendable: {counting=}");
}
// you can ask an array for its mutability
show($"{literalArray.mutability=}, {fixedLengthArray.mutability=}");
// you can convert an array from one mutability to another; the
// Persistent mutability is just like the Constant mutability,
// except that the array doesn't have to be immutable, so the
// array can hold elements that are mutable, but no elements can
// be added, removed, or replaced
Int[] constantToMutable = biggestArray.toArray(Mutable);
show($|{constantToMutable=}, {&constantToMutable.actualType=},\
| {constantToMutable.mutability=}
);
Int[] constantToFixed = biggestArray.toArray(Fixed);
show($|{constantToFixed=}, {&constantToFixed.actualType=},\
| {constantToFixed.mutability=}
);
Int[] fixedToPersistent = counting.toArray(Persistent);
show($|{fixedToPersistent=}, {&fixedToPersistent.actualType=},\
| {fixedToPersistent.mutability=}
);
Int[] fixedToConstant = counting.toArray(Constant);
show($|{fixedToConstant=}, {&fixedToConstant.actualType=},\
| {fixedToConstant.mutability=}
);
// a slice of an array is an array; this is very handy
Int[] slice = constantToMutable[1..2];
show($"{slice=}");
// slices may rely on the array that they are sliced from; to ensure that
// changes to the original array don't appear in the slice, the slice
// must be reified
constantToMutable[1] = 17; // this will appear in the slice
slice = slice.reify();
constantToMutable[2] = 18; // this will NOT appear in the slice
show($"{constantToMutable=}, {slice=}");
// slices can be inclusive or exclusive
show($"{constantToMutable[1..2]=}");
show($"{constantToMutable[1..<2]=}");
show($"{constantToMutable[1>..2]=}");
show($"{constantToMutable[1>..<2]=}");
// creating a new Mutable array uses the simplest form of the constructor;
// a Mutable array
Int[] variableArray = new Int[];
show($"new {variableArray=}");
// you can specify an estimated capacity for a new Mutable array, but the
// capacity is just an optimization hint!
Int[] willBeGiantArray = new Int[](999);
show($"new {willBeGiantArray=}, {willBeGiantArray.capacity=}");
// you can easily add and remove data from a Mutable array
for (Int i : 10..1) {
variableArray.add(i);
}
show($"NASA count-down: {variableArray=}");
// remove unlucky numbers in Japanese
variableArray.remove(4);
show($"lucky count-down: {variableArray=}");
// delete by index works as well
variableArray.delete(variableArray.size-1);
show($"aborted count-down: {variableArray=}");
}
}
</syntaxhighlight>
{{out}}
<pre>
literalArray=[1, 2, 3], &literalArray.actualType=immutable Array<Int>
literalArray.size=3, literalArray[2]=3
biggerArray=[1, 2, 3, 4], &biggerArray.actualType=immutable Array<Int>
biggestArray=[1, 2, 3, 4, 1, 2, 3, 4], &biggestArray.actualType=immutable Array<Int>
element at biggestArray[2]=3
immutable array not modified: biggestArray=[1, 2, 3, 4, 1, 2, 3, 4]
element at fixedLengthArray[2]=0
negOnes=[-1, -1, -1]
counting=[0, 1, 2, 3, 4]
replaced [1]=99: counting=[0, 99, 2, 3, 4]
Fixed mutability array not appendable: counting=[0, 99, 2, 3, 4]
literalArray.mutability=Constant, fixedLengthArray.mutability=Fixed
constantToMutable=[1, 2, 3, 4, 1, 2, 3, 4], &constantToMutable.actualType=Array<Int>, constantToMutable.mutability=Mutable
constantToFixed=[1, 2, 3, 4, 1, 2, 3, 4], &constantToFixed.actualType=Array<Int>, constantToFixed.mutability=Fixed
fixedToPersistent=[0, 99, 2, 3, 4], &fixedToPersistent.actualType=Array<Int>, fixedToPersistent.mutability=Persistent
fixedToConstant=[0, 99, 2, 3, 4], &fixedToConstant.actualType=immutable Array<Int>, fixedToConstant.mutability=Constant
slice=[2, 3]
constantToMutable=[1, 17, 18, 4, 1, 2, 3, 4], slice=[17, 3]
constantToMutable[1..2]=[17, 18]
constantToMutable[1..<2]=[17]
constantToMutable[1>..2]=[18]
constantToMutable[1>..<2]=[]
new variableArray=[]
new willBeGiantArray=[], willBeGiantArray.capacity=0
NASA count-down: variableArray=[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
lucky count-down: variableArray=[10, 9, 8, 7, 6, 5, 3, 2, 1]
aborted count-down: variableArray=[10, 9, 8, 7, 6, 5, 3, 2]
</pre>
=={{header|EGL}}==
Line 2,703 ⟶ 3,161:
'''Fixed-length array'''
<syntaxhighlight lang="egl">
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]);
</syntaxhighlight>
{{out}}
<pre>
Line 2,728 ⟶ 3,186:
=={{header|Eiffel}}==
<
class
APPLICATION
Line 2,762 ⟶ 3,220:
my_static_array: ARRAY [STRING]
end
</syntaxhighlight>
=={{header|Elena}}==
ELENA
Static array
<
Generic array
<
array[0] := 1;
array[1] := 2;
array[2] := 3;</
Stack allocated array
<
stackAllocatedArray[0] := 1;
stackAllocatedArray[1] := 2;
stackAllocatedArray[2] := 3;</
Dynamic array
<
dynamicArray.append
dynamicArray.append
dynamicArray.append
dynamicArray[2] := 3;</
Printing an element
<
system'console.writeLine(stackAllocatedArray[1]);
system'console.writeLine(dynamicArray[2]);</
=={{header|Elixir}}==
The elixir language has array-like structures called ''tuples''. The values of tuples occur sequentially in memory, and can be of any type. Tuples are represented with curly braces:
<
Elements of tuples are indexed numerically, starting with zero.
<
elem(ret, 0) == :ok
put_elem(ret, 2, "pi") # => {:ok, "fun", "pi"}
ret == {:ok, "fun", 3.1415}</
Elements can be appended to tuples with <tt>Tuple.append/2</tt>, which returns a new tuple, without having modified the tuple given as an argument.
<
New tuple elements can be inserted with <tt>Tuple.insert/3</tt>, which returns a new tuple with the given value inserted at the indicated position in the tuple argument.
<
Elixir also has structures called ''lists'', which can contain values of any type, and are implemented as linked lists. Lists are represented with square brackets:
<
Lists can be indexed, appended, added, subtracted, and list elements can be replaced, updated, and deleted. In all cases, new lists are returned without affecting the list being operated on.
<
my_list ++ [4, :five] # => [1, :two, "three", 4, :five]
Line 2,824 ⟶ 3,282:
List.delete(my_list, :two) # => [1, "three"]
my_list -- ["three", 1] # => [:two]
my_list # => [1, :two, "three"]</
Lists have a ''head'', being the first element, and a ''tail'', which are all the elements of the list following the head.
<
[:apple, :banana, :cherry]
iex(2)> hd(fruit)
Line 2,837 ⟶ 3,295:
true
iex(5)> tl(fruit) == [:banana, :cherry]
true</
=={{header|EMal}}==
<syntaxhighlight lang="emal">
^|EMal has dynamic lists.
|Lists have differen API to change the value in-place or not.
|SQL like name: insert, append, delete, order alter the current list.
|There are methods that operate on indexes, other on values.
|^
List a = int[] # a:[]
a.append(8) # a:[8]
a.insert(1, 13) # a:[8,13]
a.delete(0) # a:[13]
a.clear() # a:[]
a.of(21, 33) # a:[21,33]
a[1] = 34 # a:[21,34]
List b = a.remove(21) # a:[21, 34], b:[34]
writeLine("a has " + a.length + " items, their values are " + a[0] + ", " + a[1])
writeLine("b has " + b.length + " item, its value is " + b[0])
</syntaxhighlight>
{{out}}
<pre>
a has 2 items, their values are 21, 34
b has 1 item, its value is 34
</pre>
=={{header|Erlang}}==
<
%% Create a fixed-size array with entries 0-9 set to 'undefined'
A0 = array:new(10).
Line 2,871 ⟶ 3,353:
{'EXIT',{badarg,_}} = (catch array:set(18, true, A3)).
{'EXIT',{badarg,_}} = (catch array:get(18, A3)).
</syntaxhighlight>
=={{header|ERRE}}==
Line 2,924 ⟶ 3,406:
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">
--Arrays task for Rosetta Code wiki
--User:Lnettnay
Line 2,954 ⟶ 3,436:
end for
? dynarray
</syntaxhighlight>
{{out}}
<pre>
Line 2,970 ⟶ 3,452:
=={{header|F Sharp|F#}}==
'''Fixed-length arrays:'''
<
val it : char [] = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]
> Array.init 8 (fun i -> i * 10) ;;
Line 2,981 ⟶ 3,463:
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 <code>System.Collections.Generic.List<'T></code> which is aliased as <code>Microsoft.FSharp.Collections.ResizeArray<'T></code>:
<
val arr : ResizeArray<int>
> arr.Add(42);;
Line 3,000 ⟶ 3,482:
Parameter name: index ...
> arr;;
val it : ResizeArray<int> = seq [13]</
=={{header|Factor}}==
Line 3,007 ⟶ 3,489:
Directly in the listener :
<
{
[ "The initial array: " write . ]
Line 3,013 ⟶ 3,495:
[ "Modified array: " write . ]
[ "The element we modified: " write [ 1 ] dip nth . ]
} cleave</
The initial array: { 1 2 3 }
Modified array: { 1 42 3 }
Line 3,023 ⟶ 3,505:
{ 1 "coucou" f [ ] }
Arrays of growable length are called Vectors.
<
{
[ "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 }
Line 3,093 ⟶ 3,575:
For example, a static array of 10 cells in the dictionary, 5 initialized and 5 uninitialized:
<
here constant MyArrayEnd
Line 3,099 ⟶ 3,581:
MyArray 7 cells + @ . \ 30
: .array MyArrayEnd MyArray do I @ . cell +loop ;</
<
: array ( n -- )
create
Line 3,122 ⟶ 3,604:
5fillMyArray
.MyArray \ 1 2 3 4 5 0 30 0 0 0
</syntaxhighlight>
<
: array create dup , dup cells here swap 0 fill cells allot ;
: [size] @ ;
Line 3,139 ⟶ 3,621:
5fillMyArray
.MyArray \ 1 2 3 4 5 0 30 0 0 0
</syntaxhighlight>
=={{header|Fortran}}==
Line 3,145 ⟶ 3,627:
Basic array declaration:
<syntaxhighlight lang
<syntaxhighlight lang
<
Arrays are one-based. These declarations are equivalent:
<
<
Other bases can be used:
<
Arrays can have any type (intrinsic or user-defined), e.g.:
<
<
Multidimensional array declaration:
<
<
Allocatable array declaration:
<
<
Array allocation:
<syntaxhighlight lang
<
Array deallocation:
<syntaxhighlight lang
Array initialisation:
<
<
integer, dimension (10) :: a = (/(i * i, i = 1, 10)/)</
<
<
integer, dimension (10, 10) :: a = reshape ((/(i * i, i = 1, 100)/), (/10, 10/))</
Constant array declaration:
<
integer, dimension (10), parameter :: a = (/(i * i, i = 1, 10)/)</
Element assignment:
<
<
Array assignment (note that since Fortran 2003 array assignment also allocates or reallocates if necessary):
<
<
<
<
Array section assignment:
<
<
<
<
<
<
<
<
Element retrieval:
<
Array section retrieval:
<
Size retrieval:
<
Size along a single dimension retrieval:
<
Bounds retrieval:
<
<
Bounds of a multidimensional array retrieval:
<
=={{header|FreeBASIC}}==
Line 3,239 ⟶ 3,721:
'''The default lower bound is always 0'''
<
' compile with: FBC -s console -exx to have boundary checks.
Line 3,320 ⟶ 3,802:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre> The first dimension has a lower bound of 1 and a upper bound of 2
Line 3,355 ⟶ 3,837:
=={{header|Frink}}==
In Frink, all arrays are dynamically resizable. Arrays can be created as literals or using <CODE>new array</CODE>
<
a = new array
a@0 = 10
Line 3,362 ⟶ 3,844:
b = [1, 2, 3]
</syntaxhighlight>
=={{header|Futhark}}==
Line 3,368 ⟶ 3,850:
Multidimensional regular arrays are a built-in datatype in Futhark. They can be written as array literals:
<syntaxhighlight lang="futhark">
[1, 2, 3]
</syntaxhighlight>
Or created by an assortment of built-in functions:
<syntaxhighlight lang="futhark">
replicate 5 3 == [3,3,3,3,3]
iota 5 = [0,1,2,3,4]
</syntaxhighlight>
Uniqueness types are used to permit in-place updates without violating referential transparency. For example, we can write a function that writes an element to a specific index of an array as such:
<syntaxhighlight lang="futhark">
fun update(as: *[]int, i: int, x: int): []int =
let as[i] = x
in x
</syntaxhighlight>
Semantically the <code>update</code> function returns a new array, but the compiler is at liberty to re-use the memory where array <code>as</code> is stored, rather than create a copy as is normally needed in pure languages. Whenever the compiler encounters a call <code>update(as,i,x)</code>, it checks that the <code>as</code> is not used again. This prevents the in-place update from being observable, except through the return value of <code>modify</code>.
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
window 1, @"FutureBasic Arrays", (0,0,480,450)
begin globals
dynamic gA1(10) as long
dynamic gA2(10) as Str255
end globals
void local fn CType
long i
text ,, fn ColorGray
print @"// C-type fixed-length"
text
long a1(4)
a1(0) = 10
a1(1) = 5
a1(2) = 12
a1(3) = 8
a1(4) = 7
for i = 0 to 4
print a1(i),
next
print
a1(0) = 24
a1(2) = 18
a1(4) = 76
for i = 0 to 4
print a1(i),
next
print
CFStringRef a2(4)
a2(0) = @"Alpha"
a2(1) = @"Bravo"
a2(2) = @"Tango"
a2(3) = @"Delta"
a2(4) = @"Echo"
for i = 0 to 4
print a2(i),
next
print
a2(2) = @"Charlie"
for i = 0 to 4
print a2(i),
next
print : print
end fn
void local fn CTypeDynamic
long i
text ,, fn ColorGray
print @"// C-type dynamic"
text
gA1(0) = 46
gA1(1) = 38
gA1(10) = 67
for i = 0 to fn DynamicNextElement( dynamic(gA1) ) - 1
print gA1(i),
next
print
gA1(5) = 19
gA1(10) = 22
for i = 0 to fn DynamicNextElement( dynamic(gA1) ) - 1
print gA1(i),
next
print
gA2(0) = "Kilo"
gA2(1) = "Lima"
gA2(5) = "Mike"
for i = 0 to fn DynamicNextElement( dynamic(gA2) ) - 1
print gA2(i),
next
print
gA2(1) = "November"
gA2(6) = "Oscar"
for i = 0 to fn DynamicNextElement( dynamic(gA2) ) - 1
print gA2(i),
next
print : print
end fn
void local fn CoreFoundationImmutable
long i
text ,, fn ColorGray
print @"// CoreFoundation (CF) immutable"
text
CFArrayRef a5 = @[@10,@5,@12,@8,@7]
for i = 0 to 4
print a5[i],
next
print
CFArrayRef a6 = @[@"Alpha",@"Bravo",@"Charlie",@"Delta",@"Echo"]
for i = 0 to 4
print a6[i],
next
print : print
end fn
void local fn CoreFoundationMutableFixedLength
long i
text ,, fn ColorGray
print @"// CoreFoundation (CF) mutable, fixed-length"
text
CFMutableArrayRef a1 = fn MutableArrayWithCapacity(3)
MutableArrayAddObject( a1, @79 )
MutableArrayAddObject( a1, @43 )
MutableArrayAddObject( a1, @101)
for i = 0 to len(a1) - 1
print a1[i],
next
print
MutableArrayReplaceObjectAtIndex( a1, @15, 2 )
for i = 0 to len(a1) - 1
print a1[i],
next
print
CFMutableArrayRef a2 = fn MutableArrayWithCapacity(4)
MutableArrayAddObject( a2, @"Whisky" )
MutableArrayAddObject( a2, @"Oscar" )
MutableArrayAddObject( a2, @"Yankee" )
MutableArrayAddObject( a2, @"Sierra" )
for i = 0 to len(a2) - 1
print a2[i],
next
print
MutableArrayReplaceObjectAtIndex( a2, @"Xray", 1 )
MutableArrayReplaceObjectAtIndex( a2, @"Zulu", 3 )
for i = 0 to len(a2) - 1
print a2[i],
next
print : print
end fn
void local fn CoreFoundationMutableDynamic
long i
text ,, fn ColorGray
print @"// CoreFoundation (CF) mutable, dynamic"
text
CFMutableArrayRef a1 = fn MutableArrayWithCapacity(0)
MutableArrayAddObject( a1, @"Juliet" )
MutableArrayAddObject( a1, @"Golf" )
MutableArrayAddObject( a1, @"India" )
for i = 0 to len(a1) - 1
print a1[i],
next
print
MutableArrayReplaceObjectAtIndex( a1, @"Foxtrot", 0 )
MutableArrayReplaceObjectAtIndex( a1, @"Hotel", 2 )
for i = 0 to len(a1) - 1
print a1[i],
next
print : print
end fn
void local fn FB_MDA
long i
text ,, fn ColorGray
print @"// FB MDA - mutable, dynamic, multi-dimensional"
text
mda_add = @"Alpha"
mda_add = @"Romeo"
mda_add = @"Mike"
for i = 0 to mda_count - 1
print mda(i),
next
print
mda_swap(0),(2)
mda(1) = @"Delta"
for i = 0 to mda_count - 1
print mda(i),
next
end fn
fn CType
fn CTypeDynamic
fn CoreFoundationImmutable
fn CoreFoundationMutableFixedLength
fn CoreFoundationMutableDynamic
fn FB_MDA
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
// C-type fixed-length
10 5 12 8 7
24 5 18 8 76
Alpha Bravo Tango Delta Echo
Alpha Bravo Charlie Delta Echo
// C-type dynamic
46 38 0 0 0 0 0 0 0 0 67
46 38 0 0 0 19 0 0 0 0 22
Kilo Lima Mike
Kilo November Mike Oscar
// CoreFoundation (CF) immutable
10 5 12 8 7
Alpha Bravo Charlie Delta Echo
// CoreFoundation (CF) mutable, fixed-length
79 43 101
79 43 15
Whisky Oscar Yankee Sierra
Whisky Xray Yankee Zulu
// CoreFoundation (CF) mutable, dynamic
Juliet Golf India
Foxtrot Golf Hotel
// FB MDA - mutable, dynamic, multi-dimensional
Alpha Romeo Mike
Mike Delta Alpha
</pre>
=={{header|Gambas}}==
Line 3,393 ⟶ 4,114:
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[]
Line 3,402 ⟶ 4,123:
myfruits[0] = "apple"
myfruits[1] = "banana"
</syntaxhighlight>
Line 3,408 ⟶ 4,129:
'''[https://gambas-playground.proko.eu/?gist=5061d7f882a4768d212080e416c25e27 Click this link to run this code]'''
<
Dim sFixedArray As String[] = ["Rosetta", "code", "is", "a", "programming", "chrestomathy", "site"]
Dim sFixedArray1 As New String[10]
Line 3,426 ⟶ 4,147:
Print sFixedArray1[5] & sFixedArray1[6]
End</
Output:
<pre>
Line 3,435 ⟶ 4,156:
=={{header|GAP}}==
<
v := [ 10, 7, "bob", true, [ "inner", 5 ] ];
# [ 10, 7, "bob", true, [ "inner", 5 ] ]
Line 3,479 ⟶ 4,200:
Add(v, "added");
v;
# [ 10, 7, "bob", true, [ "inner", 5 ], 100,,,, 1000, 8, 9, "added" ]</
=={{header|Genie}}==
<
/*
Arrays, in Genie
Line 3,516 ⟶ 4,237:
dyn.add(dyn[0]+dyn[1])
stdout.printf("dyn size: %d\n", dyn.size)
stdout.printf("dyn[2] : %d\n", dyn[2])</
{{out}}
Line 3,531 ⟶ 4,252:
====Example of Fixed Length Array====
Array containing a space (" "), "A", "B", and "C":
<
array[1] = 'A'
array[2] = 'B'
array[3] = 'C'</
====Example of Arbitrary Length Array====
Array containing the set of all natural numbers from 1 through k:
<
array[i] = i + 1</
===2-Dimensional Array Examples===
====Example of Fixed Length Array====
Array containing the multiplication table of 1 through 4 by 1 through 3:
<
array[1,2] = 2
array[1,3] = 3
Line 3,555 ⟶ 4,276:
array[3,2] = 6
array[3,3] = 9
array[3,4] = 12</
====Example of Arbitrary Length Array====
Array containing the multiplication table of 1 through k by 1 through h:
<
for(j = 1; j <= h; j += 1)
array[i,j] = i * j</
=={{header|Go}}==
<
import (
Line 3,626 ⟶ 4,347:
// the cap()=10 array is no longer referenced
// and would be garbage collected eventually.
}</
{{out}}
<pre>len(a) = 5
Line 3,647 ⟶ 4,368:
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.
<
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.
Line 3,657 ⟶ 4,378:
=={{header|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 a = [0] * 100 // list of 100 zeroes
def b = 1..9 // range notation
Line 3,676 ⟶ 4,397:
d.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }
println()
e.each { print "["; it.each { elt -> printf "%7.1f ", elt }; println "]" }</
{{out}}
Line 3,692 ⟶ 4,413:
Here is a more interesting example showing a function that creates and returns a square identity matrix of order N:
<
(1..n).collect { i -> (1..n).collect { j -> i==j ? 1.0 : 0.0 } }
}</
Test program:
<
def i15 = identity(15)
Line 3,703 ⟶ 4,424:
i2.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }
println()
i15.each { print "["; it.each { elt -> printf "%4.1f ", elt }; println "]" }</
{{out}}
Line 3,727 ⟶ 4,448:
Groovy, like every other C-derived language in the known universe, uses ZERO-based array/list indexing.
<
println strings
Line 3,737 ⟶ 4,458:
strings[10] = 'strawberries'
println strings</
{{out}}
Line 3,746 ⟶ 4,467:
Negative indices are valid. They indicate indexing from the end of the list towards the start.
<syntaxhighlight lang
{{out}}
Line 3,754 ⟶ 4,475:
Groovy lists can be resequenced and subsequenced by providing lists or ranges of indices in place of a single index.
<
println strings[0..4]
println strings[0..3, -5]</
{{out}}
Line 3,768 ⟶ 4,489:
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:
<
=={{header|GW-BASIC}}==
Line 3,775 ⟶ 4,496:
(GW-BASIC User's Guide)
<
20 DIM A(9) ' Array with size 10 (9 is maximum subscript), all elements are set to 0
30 FOR I = 0 TO 9
Line 3,783 ⟶ 4,504:
70 A(4) = 400 ' Set 4th element of array
80 PRINT A(4)
</syntaxhighlight>
=={{header|Halon}}==
<
$array[] = 1;
Line 3,794 ⟶ 4,515:
echo $array[0];
echo $array["key"];</
=={{header|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.
<
local arr1 := { { "NITEM", "N", 10, 0 }, { "CONTENT", "C", 60, 0 } }
// Create an empty array
Line 3,808 ⟶ 4,529:
// 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
<
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:
<
// The retrieved item can be nested array, in this case it isn't copied, the pointer to it is assigned
</syntaxhighlight>
There is a set of functions to manage arrays in Clipper, including the following:
<
AFill( arr4, 0, 5, 20 )
// Copy 10 items from arr4 to arr3[ 2 ], starting from the first position:
Line 3,827 ⟶ 4,548:
// Duplicate the whole or nested array:
arr5 := AClone( arr1 )
arr6 := AClone( arr1[ 3 ] )</
=={{header|Haskell}}==
You can read all about Haskell arrays [http://haskell.org/haskellwiki/Arrays here]. The following example is taken from that page:
<
main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)
Line 3,837 ⟶ 4,558:
writeArray arr 1 64
b <- readArray arr 1
print (a,b)</
=={{header|hexiscript}}==
<
let a[0] 123 # index starting at 0
let a[1] "test" # can hold different types
println a[1]</
=={{header|HicEst}}==
<
Astat(2) = 2.22222222
Line 3,857 ⟶ 4,578:
ALIAS(Astat, n-1, last2ofAstat, 2)
WRITE(ClipBoard) last2ofAstat ! 2.22222222 0 </
=={{header|HolyC}}==
<
U8 array[10] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10;
Line 3,867 ⟶ 4,588:
// Access an element
Print("%d\n", array[0]);</
==Icon and Unicon==
==={{header|Icon}}===
<
procedure main()
Line 3,968 ⟶ 4,689:
S := A[-8 -: -3] # S is [30, 40, 50]
S := A[-5 +: -3] # S is [30, 40, 50]
end</
==={{header|Unicon}}===
This Icon solution works in Unicon.
<
# insert and delete work on lists allowing changes in the middle
# possibly others
</syntaxhighlight>
{{improve|Unicon|Need code examples for these extensions}}
=={{header|i}}==
<
//Fixed-length arrays.
f $= array.integer[1]()
Line 3,989 ⟶ 4,710:
d[+] $= 2
print(d[1])
}</
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">> (var my-list [1 2 3 4 5]) ;syntactic sugar
[1 2 3 4 5]
> (var my-list (vec 1 2 3 4 5))
[1 2 3 4 5]
> my-list
[1 2 3 4 5]
> (3 my-list) ;fourth element
4
> (-1 my-list) ;last element
5
> (append my-list 100)
[1 2 3 4 5 100]
> my-list ;variables are immutable so my-list cannot be changed without being redefined
[1 2 3 4 5]</syntaxhighlight>
=={{header|Io}}==
<
foo at(1) println // bar
foo append("Foobarbaz")
foo println
foo atPut(2, "barbaz") // baz becomes barbaz</
<pre>Io> foo := list("foo", "bar", "baz")
Line 4,015 ⟶ 4,758:
=={{header|J}}==
In J, all data occurs in the form of rectangular (or generally [[wp:Hyperrectangle|orthotopic]]) arrays. This is true for both named and anonymous data.
<
1
NB. invoking any array produces that array as the result
Line 4,042 ⟶ 4,785:
Xbcde
fXhij
klXno</
Because arrays are so important in J, a large portion of the language applies to this topic.
Note also that J's arrays are (with some obscure exceptions) "constants". We can append to an existing array, creating a new array, but if we kept a reference to the original it would have remained unchanged.
<syntaxhighlight lang="j"> A=: 7 11
B=: A, 9 5
B
7 11 9 5
A
7 11</syntaxhighlight>
Thus, in recent versions of J, special syntax was introduced to refer to a value while discarding the reference: <syntaxhighlight lang="j"> A=: 2 4 6 8
B=: A_:, 1 3 9 5
B
2 4 6 8 1 3 9 5
A
|value error: A</syntaxhighlight>
=={{header|Java}}==
In Java you can create an immutable array of any ''Object'' or primitive data-type by appending the declaring type with square brackets, [ and ].
<syntaxhighlight lang="java">
String[] strings;
int[] values;
</syntaxhighlight>
Alternately, you could place the brackets after the declaring variable name, although this is discouraged as it aspects the name rather than the type.
<syntaxhighlight lang="java">
String strings[];
int values[];
</syntaxhighlight>
Initialization can appear during the declaration, or after.
<syntaxhighlight lang="java">
String[] strings = new String[] { "rosetta", "code" };
int[] values = new int[] { 1, 2, 3 };
</syntaxhighlight>
<syntaxhighlight lang="java">
String[] strings;
strings = new String[] { "rosetta", "code" };
int[] values;
values = new int[] { 1, 2, 3 };
</syntaxhighlight>
If your arrays contents are more dynamic, and known only at runtime, you can alternately specify the array size by adding it to the assigned type's square brackets.
<syntaxhighlight lang="java">
String[] strings = new String[2];
int[] values = new int[3];
</syntaxhighlight>
To access an array element you, again, use the square-bracket syntax, specifying the element's index within it.<br />
Java indices are 0-based, so, for example, element 1 is at index 0.
<syntaxhighlight lang="java">
String string = strings[0];
int value = values[2];
</syntaxhighlight>
Here is a basic demonstration of using an array.
<syntaxhighlight lang="java">
String[] strings = new String[2];
strings[0] = "rosetta";
strings[1] = "code";
String string = strings[0] + " " + strings[1];
</syntaxhighlight>
If you printed ''string'' to the standard-out, you would get the following.
<pre>
rosetta code
</pre>
Java offers the ''Arrays'' class, which provides numerous array-related operations.<br />
A useful option is the ''Arrays.fill'' method, which can be used to initialize each element to a specified value.
<syntaxhighlight lang="java">
int[] values = new int[10];
Arrays.fill(values, 100);
</syntaxhighlight>
Additionally, you can print the contents of an array using the ''Arrays.toString'' method.
<syntaxhighlight lang="java">
Arrays.toString(values);
</syntaxhighlight>
If you printed ''values'' to the standard-out, you'd get the following.
<syntaxhighlight lang="java">
[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
</syntaxhighlight>
<br />
Java also offers a dynamic, mutable array under the Java Collections Framework ''List'' and ''Deque'' interfaces.<br />
Both which provide a substantial amount of implementing classes, for various types of dynamic array related tasks.<br />
The most logical, for this demonstration, would be the ''ArrayList'' and ''ArrayDeque''.<br /><br />
The ''ArrayList'' declaration is slightly different than that of the array, as you are simply calling the constructor of a class.<br />
We'll use ''List'' as our declaring type, since, as with most interfaces, it's more logical to specify it as the declaring type during the instantiation of any implementing type.<br />
Immediately after the declaring type you'll use the 'diamond operators', < and >, with the data type of the array specified within.
<syntaxhighlight lang="java">
List<String> strings;
List<Integer> values;
</syntaxhighlight>
Similar to an array, the initialization can appear during the declaration or after.<br />
Note, the ''ArrayList'' 'diamond-operator' does not require the declared-type, as it's inferred by the declaring-type.
<syntaxhighlight lang="java">
List<String> strings = new ArrayList<>();
List<Integer> values = new ArrayList<>();
</syntaxhighlight>
Adding an element is done via the ''List.add'' method.
<syntaxhighlight lang="java">
strings.add("rosetta");
strings.add("code");
values.add(1);
values.add(2);
values.add(3);
</syntaxhighlight>
Additionally, you could specify an index at the ''List.add'' method, which will insert the element at the index, shifting the current element at that index, and all subsequent elements to the right by 1.
<syntaxhighlight lang="java">
strings.add("code");
strings.add(0, "rosetta");
</syntaxhighlight>
''List.set'' is used for mutating an already existing element.
<syntaxhighlight lang="java">
strings.set(0, "ROSETTA");
strings.set(1, "CODE");
</syntaxhighlight>
It's worth noting that Java also offers a ''Vector'' class, which is nearly similar to the ''ArrayList'' class except it should be used in multi-threaded situations, as ''ArrayList'' will produced concurrency issues.<br /><br />
The ''ArrayDeque'' is also another option for dynamic, mutable array situations, and provides a LIFO, "Last In First Out", operation for its elements.<br />
A LIFO pattern can be assimilated to a stack of plates at a buffet, as the most recent plate to be placed on the stack is the first to be taken.<br />
You declare and instantiate an ''ArrayDeque'' in the same manner as an ''ArrayList'', using the 'diamond-operators'.
<syntaxhighlight lang="java">
Deque<String> strings = new ArrayDeque<>();
</syntaxhighlight>
There are numerous methods within the ''Deque'' class for accessing and mutating the data.<br />
For this task, I'll use the most generic and logical to a LIFO pattern.<br />
To add an element you use the ''Deque.push'' method.
<syntaxhighlight lang="java">
strings.push("code");
strings.push("rosetta");
</syntaxhighlight>
To remove an item you use the ''Deque.pop'' method.<br />
Elements of a ''Deque'' are not index based.
<syntaxhighlight lang="java">
strings.pop();
</syntaxhighlight>
=={{header|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.
<
var myArray = new Array();
Line 4,082 ⟶ 4,942:
// Elisions are supported, but are buggy in some implementations
var y = [0,1,,]; // length 3, or 4 in buggy implementations
</syntaxhighlight>
=={{header|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. <tt>[][4] = null</tt> creates an array of length 5 as explained below.<
[]
Line 4,122 ⟶ 4,982:
a[1:] # => [1,2,3,4]
a[2:4] # => [2,3]
a[4:2] # null</
=={{header|Jsish}}==
From Javascript, with the differences that Jsi treats ''typeof [elements]'' as "array", not "object".
<
// Create a new array with length 0
var myArray = new Array();
Line 4,178 ⟶ 5,038:
myArray3.length ==> 4
=!EXPECTEND!=
*/</
{{out}}
Line 4,186 ⟶ 5,046:
=={{header|Julia}}==
Julia has both heterogeneous arrays and typed arrays.
<pre>julia> A =
3-element
#undef
#undef
Line 4,212 ⟶ 5,072:
in push! at array.jl:488
julia> ['a':'c'...] # type inference
3-element
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)</pre>
=={{header|KonsolScript}}==
<
Array:New array[3]:Number;
Line 4,229 ⟶ 5,089:
array[0] = 5; //assign value
Konsol:Log(array[0]) //retrieve value and display
}</
=={{header|Kotlin}}==
<
var a = arrayOf(1, 2, 3, 4)
println(a.asList())
Line 4,238 ⟶ 5,098:
println(a.asList())
println(a.reversedArray().asList())
}</
{{out}}
<pre>[1, 2, 3, 4]
Line 4,248 ⟶ 5,108:
=={{header|Lambdatalk}}==
<
// Create a new array with length 0
{def myArray1 {A.new}}
Line 4,273 ⟶ 5,133:
and so on...
</syntaxhighlight>
=={{header|lang5}}==
<
1 append
['foo 'bar] append
2 reshape
0 remove 2 swap 2 compress collapse .</
=={{header|langur}}==
Langur uses 1-based indexing.
<
val .a2 = series 4..10
val .a3 = .a1 ~ .a2
Line 4,308 ⟶ 5,168:
writeln ".a2[5; 0]: ", .a2[5; 0]
writeln ".a2[10; 0]: ", .a2[10; 0]
writeln()</
{{out}}
Line 4,332 ⟶ 5,192:
Lasso Array [http://lassoguide.com/operations/containers.html?#array] 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.
<
local(array1) = array
Line 4,364 ⟶ 5,224:
// Insert item at specific position
#array1->insert('0',1) // 0, a, c, c, z</
=== Static Arrays ===
Lasso also supports Static Arrays[http://lassoguide.com/operations/containers.html#staticarray]. 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.
<
local(mystaticArray) = staticarray('a','b','c','d','e')
Line 4,379 ⟶ 5,239:
// Create an empty static array with a length of 32
local(mystaticArray) = staticarray_join(32,void)</
=={{header|Latitude}}==
Like everything in Latitude, arrays are simply objects. In particular, arrays store their elements in numerical slots rather than traditional symbolic ones. The translation scheme used to store them enables constant-time push and pop operations on either side of the array.
<
foo := [1, 2, 3].
Line 4,409 ⟶ 5,269:
println: foo popBack. ;; 3
println: foo popFront. ;; "front"
println: foo. ;; [1, 99]</
=={{header|LDPL}}==
<syntaxhighlight lang="ldpl">data:
myArray is list of numbers
procedure:
# add elements
push 1 to myArray
push 2 to myArray
push 3 to myArray
# access elements
display myArray:0 lf
# store elements
store 99 in myArray:0
# remove elements
remove element at 1 from myArray
delete last element of myArray
# clear array
clear myArray
</syntaxhighlight>
=={{header|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))
Line 4,467 ⟶ 5,351:
in (array get 2)
</syntaxhighlight>
=={{header|Liberty BASIC}}==
Line 4,480 ⟶ 5,364:
DATA is READ into variables. It cannot be READ directly into arrays.
<br>To fill arrays with DATA items, first READ the item into a variable, then use that variable to fill an index of the array.
<syntaxhighlight lang="lb">
dim Array(10)
Line 4,495 ⟶ 5,379:
print Array( 0), Array( 10)
</syntaxhighlight>
=={{header|LIL}}==
Line 4,514 ⟶ 5,398:
For filter and foreach, the VARNAME fields are optional, LIL creates defaults inside the code block of '''x''' for filter and '''i''' for foreach if user names are not given.
<
set a [list abc def ghi]
set b [list 4 5 6]
Line 4,522 ⟶ 5,406:
append b [list 7 8 9]
print [count $b]
print $b</
{{out}}
Line 4,537 ⟶ 5,421:
=={{header|Lingo}}==
<
put a[2] -- or: put a.getAt(2)
-- 2
Line 4,551 ⟶ 5,435:
a.sort()
put a
-- [3, 5]</
In addition to the 'list' type shown above, for arrays of bytes (i.e. integers between 0 and 255) there is also the bytearray data type:
<
put ba
-- <ByteArrayObject length = 2 ByteArray = 0xff, 0xff >
Line 4,565 ⟶ 5,449:
ba[1] = 5
put ba
-- <ByteArrayObject length = 3 ByteArray = 0x5, 0x2, 0x3 ></
=={{header|Lisaac}}==
<
a := ARRAY(INTEGER).create 0 to 9;
a.put 1 to 0;
a.put 3 to 1;
a.item(1).print;</
=={{header|Little}}==
Arrays in Little are list of values of the same type and they grow dynamically.
<
They are zero-indexed. You can use END to get the last element of an array:
<syntaxhighlight lang="c">
puts(fruit[0]);
puts(fruit[1]);
puts(fruit[END]);
fruit[END+1] = "banana";</
=={{header|Logo}}==
<
(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</
=={{header|LOLCODE}}==
<
BTW declaring array
I HAS A array ITZ A BUKKIT
Line 4,610 ⟶ 5,494:
VISIBLE array'Z three
VISIBLE array'Z string
KTHXBYE</
=={{header|LSE64}}==
<
0 array 5 [] ! # store 0 at the sixth cell in the array
array 5 [] @ # contents of sixth cell in array</
=={{header|LSL}}==
LSL does not have Arrays, but it does have [http://wiki.secondlife.com/wiki/List lists] which can function similar to a one dimensional ArrayList in Java or C#.
<syntaxhighlight lang="lsl">
default {
state_entry() {
Line 4,647 ⟶ 5,531:
llSay(0, "Deserialize a string CSV List\n(note that all elements are now string datatype)\nList=["+llList2CSV(lst)+"]\n");
}
}</
{{out}}
<pre>
Line 4,679 ⟶ 5,563:
=={{header|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[1] = 1 -- Index starts with 1, not 0.
l[0] = 'zero' -- But you can use 0 if you want
Line 4,685 ⟶ 5,569:
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</
=={{header|M2000 Interpreter}}==
Line 4,691 ⟶ 5,575:
We can copy multiple items from an array to another array (ore the same) with statement Stock. We can copy from memory to strings and place them to other address.
<syntaxhighlight lang="m2000 interpreter">
Module CheckArray {
\\ Array with parenthesis in name
Line 4,779 ⟶ 5,663:
}
CheckArray
</syntaxhighlight>
===Passing Arrays By Reference===
By default arrays passed by value. Here in make() we read reference in a variable A, which interpreter put then pointer to array, so it is a kind of reference (like in C). Using & we have normal reference. A ++ operator in a pointer of array add one to each element.
<syntaxhighlight lang="m2000 interpreter">
Dim a(10)=1
Print a() ' 1 1 1 1 1 1 1 1 1 1
Line 4,796 ⟶ 5,680:
A++
End Sub
</syntaxhighlight>
=={{header|Maple}}==
<
a := Array (1..5);
a := [ 0 0 0 0 0 ]
Line 4,815 ⟶ 5,699:
a := [ 9 2 3 4 5 6 ]
a[7] := 7;
Error, Array index out of range</
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
a[[1]]
Delete[a, 2]</
{{out}}
<pre>{Sin[1],Sin[2],Sin[3],Sin[4],Sin[5],Sin[6],Sin[7],Sin[8],Sin[9],Sin[10]}
Line 4,829 ⟶ 5,713:
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 =
Line 4,889 ⟶ 5,773:
2 35 10
7 9 42</
=={{header|Maxima}}==
<
array(a, flonum, 20, 20, 3)$
Line 4,916 ⟶ 5,800:
listarray(b);
/* [1000, 3/4] */</
=={{header|Mercury}}==
Line 4,922 ⟶ 5,806:
Mercury's arrays are a mutable non-functional type, and therefore are slightly more troublesome than functional types to A) accept as parameters to predicates, and B) involve in higher-order code, and C) include as a member of a composite data type. All of this is still very possible, but it requires an understanding of Mercury's variable instantiation system, as you can't just have 'in' and 'out' modes for parameters that involve arrays. Mercury has a 'bt_array' module with performance characteristics very similar to that of arrays, but which is a functional type and therefore is easier to work with. Especially if you're just starting out with Mercury, going with bt_array can be a big win for 'whippitupitude'.
<
:- interface.
:- import_module io.
Line 4,977 ⟶ 5,861:
else
true
).</
=={{header|MiniScript}}==
Line 5,005 ⟶ 5,889:
Example:
<
print arr[0]
arr.push "x"
print arr.pop</
=={{header|MIPS Assembly}}==
<
.data
array: .word 1, 2, 3, 4, 5, 6, 7, 8, 9 # creates an array of 9 32 Bit words.
Line 5,020 ⟶ 5,904:
li $s1, 25
sw $s1, 4($s0) # writes $s1 (25) in the second array element
# the four counts
lw $s2, 20($s0) # $s2 now contains 6
Line 5,026 ⟶ 5,910:
li $v0, 10 # end program
syscall
</syntaxhighlight>
=={{header|Modula-2}}==
Line 5,032 ⟶ 5,916:
=={{header|Modula-3}}==
<
Defines a static array of 10 elements, indexed 1 through 10.
Static arrays can also be given initial values:
<
VAR staticArray2 := ARRAY [1..10] OF INTEGER {1, ..} (* Initialize all elements to 1. *)</
Open (dynamic) arrays can be be defined by creating a reference to an array of an unspecified size:
<
VAR openArray: TOpenIntArray;</
Defines an open array of a currently unknown size.
Open arrays must first be initialized via a call to the built-in function NEW, passing in the type and the size of the array.
The allocation is performed on the heap and all elements are initialized to 0:
<
Initializes the open array to hold 10 elements, indexed 0 through 9. Modula-3 uses garbage collection for heap allocated data by default, so once all references to the open array go out of scope, the memory it occupied is de-allocated automatically.
Retrieval or insertion of elements and determining array bounds is performed using the same built-in functions regardless of the array kind. Though open arrays must first be de-referenced when passing them to such functions. Assuming we have made the declarations above, we can do the following:
<
staticArraySize := NUMBER(staticArray);
staticArrayElement := staticArray[4];
openArraySize := NUMBER(openArray^); (* Note the dereference. *)
openArrayElement := openArray[9];</
<
openArray[1] := 200;</
=={{header|Monte}}==
<
To retrieve a value:
<syntaxhighlight lang
To change a value:
<
Now myArray is ['a','b','c','z'].
=={{header|Nanoquery}}==
<
arr = array(10)
Line 5,092 ⟶ 5,976:
// display the list
println l</
{{out}}
<pre>hello, world!
Line 5,098 ⟶ 5,982:
=={{header|Neko}}==
<
$print(myArray[0]);</
{{out}}
Line 5,106 ⟶ 5,990:
=={{header|Nemerle}}==
<
using System.Console;
using System.Collections;
Line 5,125 ⟶ 6,009:
foreach (i in dynamic) Write($"$i\t"); // Nemerle isn't great about displaying arrays, it's better with lists though
}
}</
=={{header|NetRexx}}==
'''Note:''' Dynamic arrays can be simulated via the [[Java]] [http://download.oracle.com/javase/6/docs/technotes/guides/collections/index.html Collections Framework] or by using [[NetRexx]] ''indexed strings'' (AKA: [[Creating an Associative Array|associative arrays]]).
<
options replace format comments java crossref symbols nobinary
Line 5,162 ⟶ 6,046:
loop x_ = 1 to cymru[0] by 1
say x_':' cymru[x_]
end x_</
{{out}}
Line 5,179 ⟶ 6,063:
=={{header|NewLISP}}==
This creates an array of 5 elements, initialized to <code>nil</code>:
<
→ (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.
<
→ ((1 2 3 4) (5 6 7 8) (9 10 11 12))</
=={{header|Nim}}==
<
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
Line 5,207 ⟶ 6,091:
a.add(200) # append another element
echo a.pop() # pop last item, removing and returning it
echo a</
=={{header|NS-HUBASIC}}==
<
20 A(1)=10
30 PRINT A(1)</
=={{header|NSIS}}==
Line 5,219 ⟶ 6,103:
NSIS does not have native support for arrays. Array support is provided by the [http://nsis.sourceforge.net/Arrays_in_NSIS NSISArray] plugin.
</div>
<
!include NSISArray.nsh
Function ArrayTest
Line 5,233 ⟶ 6,117:
Pop $0
FunctionEnd
</syntaxhighlight>
=={{header|Nu}}==
<syntaxhighlight lang="nu">
let x = [1 2 3]
print $x
# Both are equivalent
print $x.1 ($x | get 1)
# Shadowing the original x
let x = $x | append 4
print $x
# Using mut
mut y = [a b c]
print $y
$y = $y | append d
print $y
</syntaxhighlight>
{{out}}
<pre>
╭───┬───╮
│ 0 │ 1 │
│ 1 │ 2 │
│ 2 │ 3 │
╰───┴───╯
2
2
╭───┬───╮
│ 0 │ 1 │
│ 1 │ 2 │
│ 2 │ 3 │
│ 3 │ 4 │
╰───┴───╯
╭───┬───╮
│ 0 │ a │
│ 1 │ b │
│ 2 │ c │
╰───┴───╯
╭───┬───╮
│ 0 │ a │
│ 1 │ b │
│ 2 │ c │
╰───┴───╯
</pre>
=={{header|Oberon-2}}==
<
MODULE Arrays;
IMPORT
Line 5,273 ⟶ 6,206:
Dynamic
END Arrays.
</syntaxhighlight>
=={{header|Objeck}}==
<
bundle Default {
class Arithmetic {
Line 5,287 ⟶ 6,220:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
<
// Create an array of NSString objects.
Line 5,313 ⟶ 6,246:
// No nil termination is then needed.
NSArray *thirdArray = @[ @"Hewey", @"Louie", @"Dewey", @1, @2, @3 ];
</syntaxhighlight>
=={{header|OCaml}}==
in the toplevel:
<
- : char array = [|'A'; 'A'; 'A'; 'A'; 'A'; 'A'|]
Line 5,333 ⟶ 6,266:
# arr ;;
- : int array = [|0; 1; 2; 3; 65; 5; 6|]</
=={{header|Oforth}}==
Line 5,340 ⟶ 6,273:
To create a mutable array, #new is used.
<
Array new dup addAll( [1, 2, 3] ) dup put( 2, 8.1 ) .
</syntaxhighlight>
{{out}}
Line 5,363 ⟶ 6,296:
The last element in a vector is indexed by minus one, and the first element is indexed by minus length of the vector.
<
; making a vector
> #(1 2 3 4 5)
Line 5,472 ⟶ 6,405:
[7 8 3]])
#false
</syntaxhighlight>
=={{header|ooRexx}}==
ooRexx arrays hold object references. Arrays will automatically increase in size if needed.
<
b = .array~new(10) -- create an array with initial size of 10
c = .array~of(1, 2, 3) -- create 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</
ooRexx provides a built-in array class that provides one- and more dimensional arrays
Line 5,500 ⟶ 6,433:
to all compound variables with that stem.
<syntaxhighlight lang="oorexx">
XXX.='*'
Say 'xxx.1='xxx.1 -- shows xxx.1=*
Line 5,506 ⟶ 6,439:
xxx.u='Joe'
Say 'xxx.u='xxx.17 -- shows xxx.u=Joe
</syntaxhighlight>
ooRexx introduces a notation a.[x,y] where x and y can actually be expressions.
Line 5,525 ⟶ 6,458:
must not exceed 250 bytes no longer applies to ooRexx and Regina.
XXX.u.v...='something'
<syntaxhighlight lang="oorexx">u=17
v='John Doe'
XXX.u.v...='some value'
z='17.John Doe...'
Say xxx.z shows 'some value'</
When using a stem for storing structured data, as in
<
person.last='Pachl'</
it is advisable to use constant symbols such as 0first and 0last in the tail
since an accidental use of the variables first or last would render confusion.
=={{header|OxygenBasic}}==
<
'CREATING A STATIC ARRAY
float
'SETTING INDEX BASE
Line 5,547 ⟶ 6,480:
'FILLING PART OF AN ARRAY
'MAPPING AN ARRAY TO ANOTHER
float *g
@g=@
print g[6] 'result 12
'DYNAMIC (RESIZEABLE) ARRAYS
redim float
redim float
print
redim float
print
redim float
</syntaxhighlight>
=={{header|Oz}}==
<
Arr = {Array.new 1 %% lowest index
10 %% highest index
Line 5,573 ⟶ 6,506:
{Show Arr.1}
Arr.1 := 64
{Show Arr.1}</
=={{header|PARI/GP}}==
<
v=concat(v,7);
v[1]</
=={{header|Pascal}}==
A modification of the Delphi example:
<
Program ArrayDemo;
uses
Line 5,616 ⟶ 6,549:
writeln(DynamicArrayText);
end.
</syntaxhighlight>
=={{header|Perl}}==
Line 5,622 ⟶ 6,555:
In-line
<
my @empty_too = ();
Line 5,630 ⟶ 6,563:
my $aref = ['This', 'That', 'And', 'The', 'Other'];
print $aref->[2]; # And
</syntaxhighlight>
Dynamic
<
push @arr, 1;
Line 5,641 ⟶ 6,574:
$arr[0] = 2;
print $arr[0];</
Two-dimensional
<
[0, 1, 2, 3],
[qw(a b c d e f g)],
[qw(! $ % & *)],
);
</syntaxhighlight>
=={{header|Phix}}==
Line 5,660 ⟶ 6,593:
without any need to worry about memory management issues.
<!--<
<span style="color: #000080;font-style:italic;">-- simple one-dimensional arrays:</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s1</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4.7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">9</span><span style="color: #0000FF;">},</span> <span style="color: #000080;font-style:italic;">-- length(s1) is now 4</span>
Line 5,735 ⟶ 6,668:
<span style="color: #0000FF;">?</span><span style="color: #000000;">s1</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">s2</span>
<!--</
{{out}}
Line 5,749 ⟶ 6,682:
=={{header|Phixmonti}}==
<
0 tolist /# create an empty array/list. '( )' is equivalent #/
Line 5,763 ⟶ 6,696:
3 2 slice /# extract the subarray/sublist [ 2 "Hello" ] #/
pstack /# show the content of the stack #/ </
=={{header|PHP}}==
===Writing To An Array===
====Single Dimension====
<
$LetterArray = array("a", "b", "c", "d", "e", "f");
$simpleForm = ['apple', 'orange'];</
====Multi-Dimensional====
<
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)
);</
====Array push====
<
array_push($arr, 'pear');
print implode(',', $arr); // Returns apple,orange,pear</
===Reading From An Array===
====Single Dimension====
Read the 5th value in the array:
<
echo $LetterArray[5]; // Returns f</
====Multi-Dimensional====
Read the 2nd line, column 5
<
===Print a whole array===
This is useful while developing to view the contents of an array:
<syntaxhighlight lang
Which would give us:
<
0 => array(
0 => 0
Line 5,831 ⟶ 6,764:
5 => 3
)
)</
=== Set custom keys for values===
This example starts the indexing from 1 instead of 0
<
This example shows how you can apply any key you want
<
To read the 3rd value of the second array:
<
===Other Examples===
Create a blank array:
<
Set a value for the next key in the array:
<
Assign a value to a certain key:
<
=={{header|Picat}}==
Line 5,855 ⟶ 6,788:
Here are some examples how to use arrays.
<
go =>
Line 5,900 ⟶ 6,833:
nl.
</syntaxhighlight>
{{out}}
Line 5,922 ⟶ 6,855:
{{trans|Prolog}}
<
List = new_list(5), % create a list of length 5
nth(1,List,a), % put an a at position 1 , nth/3 uses indexing from 1
Line 5,935 ⟶ 6,868:
Value = List3[1], % get the value at position 1
println(value=Value). % will print out a
</syntaxhighlight>
{{out}}
Line 5,948 ⟶ 6,881:
=={{header|PicoLisp}}==
PicoLisp has no built-in array data type. Lists are used instead.
<
(mapc println A) # Show it</
{{out}}
<pre>(1 2 3)
Line 5,955 ⟶ 6,888:
((d e) NIL 777)</pre>
Replace 'b' with 'B' in middle row:
<
(mapc println A)</
{{out}}
<pre>(1 2 3)
Line 5,962 ⟶ 6,895:
((d e) NIL 777)</pre>
Insert '1' in front of the middle row:
<
(mapc println A)</
{{out}}
<pre>(1 2 3)
Line 5,969 ⟶ 6,902:
((d e) NIL 777)</pre>
Append '9' to the middle row:
<
(mapc println A)</
{{out}}
<pre>(1 2 3)
Line 5,977 ⟶ 6,910:
=={{header|Pike}}==
<
// Initial array, few random elements.
array arr = ({3,"hi",84.2});
Line 5,984 ⟶ 6,917:
write(arr[5] + "\n"); // And finally print element 5.
}</
=={{header|PL/I}}==
<
declare A(10) float initial (1, 9, 4, 6, 7, 2, 5, 8, 3, 10);
Line 6,007 ⟶ 6,940:
C = 0;
c(7) = 12;
put (C(9));</
=={{header|Plain English}}==
Arrays are a bit of a sticking point for Plain English, because its creators have not as yet devised a sufficiently elegant way to work with them within the constraints of the language. Only lists have high-level routine support. Nevertheless, the capability to build arrays ourselves exists within the language. Following is an example of how it could be done.
<
Start up.
Write "Creating an array of 100 numbers..." on the console.
Line 6,056 ⟶ 6,989:
Put the number array's first element pointer into a number pointer.
Add the offset to the number pointer.
Put the number into the number pointer's target.</
{{out}}
<pre>
Line 6,070 ⟶ 7,003:
Arrays are homogenous.
<
- - -
Line 6,086 ⟶ 7,019:
Fact(s == 3) // size of array 'other' is 3
other(1) = 40 // 'other' now is [10, 40, 30]
end</
=={{header|PostScript}}==
<syntaxhighlight lang="text">
%Declaring array
Line 6,106 ⟶ 7,039:
x 1 get
</syntaxhighlight>
=={{header|PowerShell}}==
Empty array:
<
Array initialized with only one member:
<
$a = @(2) # alternative</
Longer arrays can simply be created by separating the values with commas:
<
A value can be appended to an array using the <code>+=</code> operator:
<
Since arrays are immutable this simply creates a new array containing one more member.
Values can be retrieved using a fairly standard indexing syntax:
<syntaxhighlight lang
Similarly, those values can also be replaced:
<
The range operator <code>..</code> can be used to create contiguous ranges of integers as arrays:
<
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:
<
Indexing from the end of the array can be done with negative numbers:
<
=={{header|Prolog}}==
Line 6,138 ⟶ 7,071:
retrieve and set elements.
<
singleassignment:-
functor(Array,array,100), % create a term with 100 free Variables as arguments
Line 6,148 ⟶ 7,081:
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
</syntaxhighlight>
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
Line 6,162 ⟶ 7,095:
arg(1 ,Array,Value1), % get the value at position 1
print(Value1),nl. % will print Value1 and therefore c followed by a newline
</syntaxhighlight>
Lists can be used as arrays.
<
listvariant:-
length(List,100), % create a list of length 100
Line 6,176 ⟶ 7,109:
nth1(1 ,List3,Value), % get the value at position 1
print(Value),nl. % will print out a
</syntaxhighlight>
=={{header|PureBasic}}==
Line 6,182 ⟶ 7,115:
'''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.
<
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.
<
ReDim MyArray(55)
MyArray(22) = 7
MyArray(33) = 11
MyArray(44) = 23</
<
For i=0 To ArraySize(MyArray())
If MyArray(i)
PrintN(Str(i)+" differs from zero.")
EndIf
Next</
<
Dim MultiArray.i(800, 600)
MultiArray(100, 200) = 640
MultiArray(130, 40) = 120</
<
PrintN( Str(ArraySize(MultiArray2(), 2)) ; Will tell that second dimension size is '128'</
=={{header|Python}}==
Python lists are dynamically resizeable.
<
array.append(1)
Line 6,215 ⟶ 7,148:
array[0] = 2
print
A simple, single-dimensional array can also be initialized thus:
<
However, this will not work as intended if one tries to generalize from the syntax:
<
This creates a list of "height" number of references to one list object
To initialize a list of lists one could use a pair of nested list comprehensions like so:
<
That is equivalent to:
<
for x in range(height):
To retrieve an element in an array, use any of the following methods:
<
# Retrieve an element directly from the array.
item = array[index]
Line 6,245 ⟶ 7,178:
# 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.
</syntaxhighlight>
Python produces an IndexError when accessing elements out of range:
<
try:
# This will cause an exception, which will then be caught.
print
except IndexError as e:
# Print the exception.
print
</syntaxhighlight>
Slicing a list creates a new list.
<syntaxhighlight lang="python">
another_array = my_array[1:3]
</syntaxhighlight>
=={{header|QB64}}==
<syntaxhighlight lang="qb64">
'Task
'Show basic array syntax in your language.
Line 6,380 ⟶ 7,318:
</syntaxhighlight>
=={{header|Quackery}}==
Line 6,453 ⟶ 7,391:
Dynamic
<
arr <- append(arr,3)
Line 6,459 ⟶ 7,397:
arr[1] <- 2
print(arr[1])</
=={{header|Racket}}==
<
;; import dynamic arrays
Line 6,474 ⟶ 7,412:
(gvector-ref gv 0) ; 1
(gvector-add! gv 5) ; increase size
</syntaxhighlight>
=={{header|Raku}}==
Line 6,480 ⟶ 7,418:
At its most basic, an array in Raku is quite similar to an array in Perl 5.
<syntaxhighlight lang="raku"
push @arr, 1;
Line 6,487 ⟶ 7,425:
@arr[0] = 2;
say @arr[0];</
===Some further exposition:===
Line 6,543 ⟶ 7,481:
1..Inf # natural numbers
'a'..'z' # lowercase latin letters
'''Sequence''': Iterable list of objects with some method to determine the next (or previous) item in the list. Reified on demand. Will try to automatically deduce simple arithmetic or geometric sequences. Pass in a code object to calculate more complex sequences.
Line 6,558 ⟶ 7,495:
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">
a: [] ; Empty.
b: ["foo"] ; Pre-initialized.
</syntaxhighlight>
Inserting and appending.
<syntaxhighlight lang="rebol">
append a ["up" "down"] ; -> ["up" "down"]
insert a [left right] ; -> [left right "up" "down"]
</syntaxhighlight>
Getting specific values.
<syntaxhighlight lang="rebol">
first a ; -> left
third a ; -> "up"
last a ; -> "down"
a/2 ; -> right (Note: REBOL is 1-based.)
</syntaxhighlight>
Getting subsequences. REBOL allows relative motion through a block (list).
Line 6,583 ⟶ 7,520:
you can even assign to it without destroying the list.
<syntaxhighlight lang="rebol">
a ; -> [left right "up" "down"]
next a ; -> [right "up" "down"]
Line 6,594 ⟶ 7,531:
copy/part a 2 ; -> [left right]
copy/part skip a 2 2 ; -> ["up" "down"]
</syntaxhighlight>
=={{header|Red}}==
<
arr2: ["apple" "orange" 1 2 3] ;create an array with data
>> insert arr1 "blue"
Line 6,610 ⟶ 7,547:
== "black"
>> pick arr1 2
== "black"</
A vector! is a high-performance series! of items.
The items in a vector! must all have the same type.
The allowable item types are: integer! float! char! percent!
Vectors of string! are not allowed.
<
== make vector! [20 30 70]
>> vec1/2
Line 6,630 ⟶ 7,567:
*** Script Error: invalid argument: 3.0
*** Where: append
*** Stack:</
=={{header|ReScript}}==
<
let _ = Js.Array2.push(arr, 4)
Line 6,640 ⟶ 7,577:
arr[3] = 5
Js.log(Js.Int.toString(arr[3]))</
{{out}}
<pre>
Line 6,651 ⟶ 7,588:
Retro has a vocabulary for creating and working with arrays.
<syntaxhighlight lang="retro">
needs array'
Line 6,686 ⟶ 7,623:
( Create a quote from the values in an array )
d ^array'toQuote
</syntaxhighlight>
=={{header|REXX}}==
Line 6,693 ⟶ 7,630:
===simple arrays===
<
a.='not found' /*value for all a.xxx (so far).*/
do j=1 to 100 /*start at 1, define 100 elements*/
Line 6,701 ⟶ 7,638:
say 'element 50 is:' a.50
say 'element 3000 is:' a.3000
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 6,709 ⟶ 7,646:
===simple arrays, mimic other languages===
<
a. = 'not found' /*value for all a.xxx (so far). */
do j=1 to 100 /*start at 1, define 100 elements*/
Line 6,719 ⟶ 7,656:
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────A subroutine────────────────────────*/
a: _a_ = arg(1); return a._a_</
<pre>
element 50 is: -5000
Line 6,726 ⟶ 7,663:
===simple arrays, assigned default===
<
a. = 00 /*value for all a.xxx (so far). */
do j=1 to 100 /*start at 1, define 100 elements*/
Line 6,736 ⟶ 7,673:
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────A subroutine────────────────────────*/
a: _a_ = arg(1); return a._a_</
{{out}}
<pre>
Line 6,744 ⟶ 7,681:
===arrays with non-unity index start===
<
array. = 'out of range' /*define ALL elements to this. */
Line 6,753 ⟶ 7,690:
say g "squared is:" array.g
say 7000 "squared is:" array.7000
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 6,761 ⟶ 7,698:
===arrays, disjoint===
<
yr. = 'year not supported' /*value for all yr.xxx (so far).*/
Line 6,777 ⟶ 7,714:
year=1744
say 'DOB' year "is:" yr.year
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 6,785 ⟶ 7,722:
===sparse arrays and special indices===
<
yyy = -55 /*REXX must use this mechanism···*/
a.yyy = 1e9 /*··· when assigning neg indices.*/
Line 6,811 ⟶ 7,748:
│ identify stemmed arrays (the period). │
└────────────────────────────────────────────────────────────────────┘*/
/*stick a fork in it, we're done.*/</
=={{header|Ring}}==
Line 6,817 ⟶ 7,754:
Dynamic
<
a = ['foo']
Line 6,827 ⟶ 7,764:
# retrieve an element
see a[1]</
=={{header|RLaB}}==
<syntaxhighlight lang="rlab">
// 1-D (row- or column-vectors)
// Static:
Line 6,862 ⟶ 7,799:
</syntaxhighlight>
=={{header|Robotic}}==
Robotic does not natively support arrays of any kind.
However, using [https://www.digitalmzx.net/wiki/index.php?title=Counter_interpolation Counter Interpolation], we can create a simple (faux) array.
<
set "index" to 0
. "Assign random values to array"
Line 6,877 ⟶ 7,814:
* "Value of index 50 is ('array('50')')."
end
</syntaxhighlight>
You can even create multi-dimensional arrays using the Counter Interpolation method.
<
set "xx" to 0
set "yy" to 0
Line 6,894 ⟶ 7,831:
* "Value of 16,16 is ('array('16'),('16')')."
end
</syntaxhighlight>
Because arrays aren't built in, there are no functions that allow you to manipulate the data you create within an array. You would have to create your own function when, for example, you want to sort numbers from least to greatest.
Line 6,902 ⟶ 7,839:
{{works with|ILE RPG}}
<
//-Static array
//--def of 10 el array of integers, initialised to zeros
Line 6,930 ⟶ 7,867:
/end-free
</syntaxhighlight>
{{works with|ILE RPG v7.1+}}
<nowiki>**</nowiki>free
//-Static array
//--def of 10 el array of integers, initialised to zeros
dcl-s array int(10) dim(10) inz;
//--def an el
dcl-s el_1 int(10) inz(0);
//-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
=={{header|RPL}}==
Arrays have a predefined size and can only contain floating point numbers.
They can be created either by enumerating their elements one by one or by creating an array with the same value everywhere:
[ 1 2 3 4 5 ]
{ 5 } -1 CON <span style="color:grey">@ create the array [ -1 -1 -1 -1 -1 ]</span>
To assign a value, you can use either <code>PUT</code> or <code>PUTI</code>. <code>PUT</code> returns only the updated array - other input arguments are gone - whilst <code>PUTI</code> leaves in stack the index, incremented by one : you can then easily assign another value to the following position.
[ 1 2 3 4 5 ] 3 10 PUT
returns:
1: [ 1 2 10 4 5 ]
but
[ 1 2 3 4 5 ] 3 10 PUTI
returns:
2: [ 1 2 10 4 5 ]
1: 4
Similarly, you can use <code>GET</code> or <code>GETI</code> to retrieve an element.
[ 10 20 30 40 50 ] 3 GET
returns:
1: 30
but
[ 10 20 30 40 50 ] 3 GETI
returns:
3: [ 10 20 30 40 50 ]
2: 4
1: 30
Another useful data structure in RPL is the list, which is very similar in use to arrays: <code>PUT</code>, <code>PUTI</code>, <code>GET</code> and <code>GETI</code> give the same results. Lists can contain any kind of objects, including lists. Beside direct assignment through <code>PUT</code>, it is also possible to append an element at the beginning or the end of the list with the <code>+</code> operator.
In recent RPL versions, several functions such as <code>SORT</code> can be applied only to lists, which make this data structure very versatile. The only drawback is the necessity to create a list element by element
by direct enumeration:
{ 1 2 3 4 5 }
by concatenation:
{ 1 2 3 } { 4 5 } +
or through a loop:
{ } 1 5 '''FOR''' j j + '''NEXT'''
=={{header|Ruby}}==
Line 6,936 ⟶ 7,929:
Dynamic
<
a = ['foo']
Line 6,955 ⟶ 7,948:
# retrieve an element
puts a[0]</
=={{header|Run BASIC}}==
<
print "Enter array 2 greater than 0"; : input a2
Line 6,966 ⟶ 7,959:
chrArray$(1,1) = "Hello"
numArray(1,1) = 987.2
print chrArray$(1,1);" ";numArray(1,1)</
=={{header|Rust}}==
Line 6,974 ⟶ 7,967:
By default, arrays are immutable unless defined otherwise.
<
let mut m = [1, 2, 3]; // mutable array
let zeroes = [0; 200]; // creates an array of 200 zeroes</
To get the length and iterate,
<
a.len();
for e in a.iter() {
e;
}</
Accessing a particular element uses subscript notation, starting from 0.
<
names[1]; // second element</
Dynamic arrays in Rust are called vectors.
<
However, this defines an immutable vector. To add elements to a vector, we need to define v to be mutable.
<
v.push(4);
v.len(); // 4</
=={{header|Sather}}==
<
a :ARRAY{INT};
-- create an array of five "void" elements
Line 7,013 ⟶ 8,006:
b[1] := c; -- syntactic sugar for b.aset(1, c)
-- append another array
b := b.append(|5.5|);</
=={{header|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.
<
val a = new Array[Int](10)
Line 7,027 ⟶ 8,020:
// Retrieve item at element 2
val c = b(2)</
Dynamic arrays can be made using <code>ArrayBuffer</code>s:
<
a += 5 // Append value 5 to the end of the list
a(0) = 6 // Assign value 6 to element 0</
=={{header|Scheme}}==
Lists are more often used in Scheme than vectors.
<
(array2 (make-vector 5)) ; default is unspecified
(array3 (make-vector 5 0))) ; default 0
(vector-set! array 0 3)
(vector-ref array 0)) ; 3</
=={{header|Scratch}}==
Line 7,052 ⟶ 8,045:
Every type, which can be mapped to integer, can be used as index type.
<
const type: charArray is array [char] string; # Define an array type for arrays with char index.
Line 7,086 ⟶ 8,079:
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;</
=={{header|Self}}==
Line 7,094 ⟶ 8,087:
Creating simple vectors:
<syntaxhighlight lang
<
A polymorphic vector:
<
Using a vector:
<
"creates an vector that holds up to 20 elements"
v: vector copySize: 20.
Line 7,109 ⟶ 8,102:
(v at: 9) printLine.
"put 100 as second value"
vat: 1 Put: 100.</
Enumeration:
<
v copy mapBy: [:each | each squared].
v copy filterBy: [:each | each > 10].</
Using a squence:
<
"creates a new sequence"
s: sequence copyRemoveAll.
Line 7,127 ⟶ 8,120:
s removeFirst.
"Check size"
s size printLine.</
=={{header|SenseTalk}}==
<
set a to (1, 2, 3)
Line 7,158 ⟶ 8,151:
// Changing the values in the array
set the third item of a to "abc"
put a -- (2, 3, "abc", 6)</
=={{header|Sidef}}==
<
var arr = [];
Line 7,189 ⟶ 8,182:
# retrieve an element
say arr[-1]; #=> 'baz'</
=={{header|Simula}}==
<
PROCEDURE STATIC;
Line 7,227 ⟶ 8,220:
DYNAMIC(5)
END ARRAYS.
</syntaxhighlight>
{{out}}
<pre>
Line 7,234 ⟶ 8,227:
</pre>
One can write an ArrayList class like Java has in package java.util.
<
CLASS ITEM;;
Line 7,379 ⟶ 8,372:
END;
</syntaxhighlight>
{{out}}
<pre>EXPAND TO CAPACITY 20
Line 7,467 ⟶ 8,460:
=={{header|Slate}}==
<
{1. 2. 3}
slate[2]> x
Line 7,480 ⟶ 8,473:
1
slate[7]> x at: 0.
1</
=={{header|SmallBASIC}}==
<syntaxhighlight lang="SmallBASIC">
' One dimensional arrays
DIM A ' empty array
DIM B(3) ' empty array with 4 elements
DIM C(2 TO 4) ' empty array with elements 2,3 and 4
D = [1,2,3,4] ' assign array in one statement
E = ["one", "two", "three"] ' string array
F = [1, "two", [1,2,3]] ' arrays can contain mixed data types
B[0] = 1 ' use [] or () to assign value to
B(1) = 2 ' element or access elements
A << 2 ' append element to an array
print F ' print whole array -> Output: [1,two,[1,2,3]]
print F[0] ' print first element -> Output: 1
print F(1) ' print second element -> Output: two
' Multi dimensional arrays
DIM A(2,0) ' column array (vector) with 3 elements
DIM B(2,2) ' empty 2D array (matrix) with 3x3 elements
DIM C(2,2,2) ' empty 3D array with 3x3x3 elements
A[0,0] = 1
A[1,0] = 2
A[2,0] = 3
' Math with arrays
A = [1,2,3]
B = [4,5,6]
print A + B ' Output: [5,7,9]
print 3 * A ' Output: [3,6,9]
print A * B ' Output: [4,10,18]
C = [1;2;3] ' vector
D = [1,2,3;4,5,6;7,8,9] ' 2D matrix
print D * C ' matrix * vector -> Output [14;32;50]
print D * D ' matrix * matrix -> Output [30,36,42;66,81,96;102,126,150]
</syntaxhighlight>
=={{header|Smalltalk}}==
Line 7,491 ⟶ 8,529:
Literal Arrays (Array constants):
<
a polymorphic array containing integers, a string, a float, booleans, a nil, another array with integers and a character constant.
Programatic use:
<
"creates an array that holds up to 20 elements"
array := Array new: 20 .
Line 7,506 ⟶ 8,544:
array := Array withAll: #('an' 'apple' 'a' 'day' 'keeps' 'the' 'doctor' 'away').
"Replacing apple with orange"
array at: 2 put: 'orange'.</
<
"suppose array is bound to an array of 20 values"
array at: 5 put: 'substitute fifth element'.
Line 7,514 ⟶ 8,552:
[ array at: 21 put: 'error' ]
on: SystemExceptions.IndexOutOfRange
do: [ :sig | 'Out of range!' displayNl ].</
<
#($a $b $c) at: 2</
Enumeration:
<
array collect:[:each | each squared|
array select:[:each | each > 10]</
{{works with|Pharo}}
Line 7,528 ⟶ 8,566:
{{works with|Squeak}}
Constructing an Array from evaluated expressions:
<
this construct evaluates each expression and creates a 4-element array containing a time, int, date and string object.
OrderedCollection:
<
oc add:1. oc add:2. oc add:3.
foo := oc removeFirst.
Line 7,544 ⟶ 8,582:
oc findFirst:[:el | el isString]
"hundreds of other methods skipped here.."
</syntaxhighlight>
=={{header|SNOBOL4}}==
SNOBOL4 supports multi-dimensional arrays and array initialization.
<
fill i = LT(i, 3) i + 1 :F(display)
ar<i,1> = i
Line 7,557 ⟶ 8,595:
OUTPUT = "Row " ar<j,1> ": " ar<j,2>
+ :S(display)
END</
{{out}}
<pre>
Line 7,566 ⟶ 8,604:
=={{header|SPL}}==
<
a[2] = 3
a[3] = "Result is "
#.output(a[3],a[1]+a[2])</
{{out}}
<pre>
Line 7,605 ⟶ 8,643:
done: ; program continues</pre>
We are now in a position to translate this algorithm into SSEM instructions and run it. As always, the SSEM version is a bit fiddlier than the pseudocode because the SSEM has no <tt>load</tt> or <tt>add</tt> instructions; but it follows the pseudocode as closely as the instruction set allows, so it should be comparatively readable. As a test, we shall sum an array of the first four positive integers—a very significant operation for the Pythagoreans of old—and halt with the accumulator holding the result.
<
11101000000000010000000000000000 1. Sub. 23
00101000000001100000000000000000 2. c to 20
Line 7,631 ⟶ 8,669:
01000000000000000000000000000000 24. 2
11000000000000000000000000000000 25. 3
00100000000000000000000000000000 26. 4</
The program could easily be modified to work with arrays of unknown length, if required, along the lines of the second pseudocode example above.
=={{header|Standard ML}}==
<syntaxhighlight lang="standard ml">
(* create first array and assign elements *)
-val first = Array.tabulate (10,fn x=>x+10) ;
Line 7,647 ⟶ 8,685:
-Array.sub(second,4);
val it = 14: int
</syntaxhighlight>
=={{header|Stata}}==
In Stata, there are mainly two ways to work with arrays: the '''[http://www.stata.com/help.cgi?matrix matrix]''' command can create and manipulate arrays, either elementwise or using matrix functions. And there is Mata, a matrix programming language similar to MATLAB, R or SAS/IML.
Line 7,661 ⟶ 8,699:
=== Matrix command ===
<
display det(a)
matrix svd u d v = a
Line 7,668 ⟶ 8,706:
* store the u and v matrices in the current dataset
svmat u
svmat v</
=== Mata ===
<
a = 2,9,4\7,5,3\6,1,8
det(a)
Line 7,677 ⟶ 8,715:
// Notice that to reconstruct the matrix, v is not transposed here,
// while it is with -matrix svd- in Stata.
u*diag(s)*v</
=={{header|Suneido}}==
<
array.Add('three')
array.Add('five', at: 5)
array[4] = 'four'
Print(array[3]) --> 'three'</
=={{header|Swift}}==
<
var anyArray = [Any]()
anyArray.append("foo") // Adding to an Array
anyArray.append(1) // ["foo", 1]
anyArray.removeAtIndex(1) // Remove object
anyArray[0] = "bar" // ["bar"]</
=={{header|Tailspin}}==
<
// arrays are created as literals, by simply listing elements, or by a generator expression, or a combination.
def a: [1, 2, 3..7:2, 11];
Line 7,704 ⟶ 8,742:
// Natural indexes start at 1
$a(1) -> !OUT::write
'
' -> !OUT::write
// But you can have an array start at any index
def b: -5:['foo', 'bar', 'qux'];
$b(-3) -> !OUT::write
'
' -> !OUT::write
Line 7,720 ⟶ 8,764:
// A mutable array can be appended
5 -> \(@: [1,2]; $ -> ..|@: $; $@ ! \) -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
[1, 2, 3, 5, 7, 11]
1
qux
[3, 5, 7, 11]
[5, 1, 7]
Line 7,732 ⟶ 8,777:
=={{header|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.)
<
lappend ary 1
Line 7,739 ⟶ 8,784:
lset ary 0 2
puts [lindex $ary 0]</
Note also that serialization is automatic on treating as a string:
<
=={{header|Tern}}==
Arrays and lists are synonymous in Tern.
<
for(i in list) {
println(i);
}
</syntaxhighlight>
{{out}}
Line 7,764 ⟶ 8,809:
<br>'''List'''<br>
One dimensional arrays are lists, they can be set as a whole with the syntax:
<
using only numerical values separated by commas and enclosed by curly braces.<br>
Lists can be accessed as a whole using L1-L6 or a custom list name
Line 7,770 ⟶ 8,815:
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.
<
Disp L1(3)
0→L1(4)</
This would return 3 and set the fourth list element to 0.
<br>You can dynamically define or delete lists by:
<
DelVar L1
5→dim(∟MYLIST)
DelVar ∟MYLIST</
'''Matrix'''<br>
Two dimensional arrays are matrices. Similar, set them and retrieve numbers using the syntax:
<
Disp [A](1,3)
0→[A](4,2)</
This would return 13 and set the element (4,2) to 0.
<br>You can dynamically define or delete matrices by:
<
DelVar [A]</
=={{header|TorqueScript}}==
Arrays in TorqueScript:
<syntaxhighlight lang="torquescript">
$array[0] = "hi";
$array[1] = "hello";
for(%i=0;%i<2;%i++)
echo($array[%i]);</
=> hi
Line 7,803 ⟶ 8,848:
=> hello
<syntaxhighlight lang="torquescript">
$array["Greet",0] = "hi";
$array["Greet",1] = "hello";
for(%i=0;%i<2;%i++)
echo($array["Greet",%i]);</
=> hi
Line 7,821 ⟶ 8,866:
Vectors can be created as empty containers, or they can be initialized with some values at the time of creation.
<
v1: Vector<Int>(),
v2: Vector<String>(),
Line 7,829 ⟶ 8,874:
v5: [1.0, 2.5, 8.6], // Vector<Double>
v6: ["one","two","three"] // Vector<String>
}</
Individual elements in a vector can be read, appended, and deleted.
<
(textout (get v 1)) // <= 2
(erase v 1)
Line 7,839 ⟶ 8,884:
(append v 7)
(textout v) // <= [1, 3, 7]
)</
All standard container operations can be applied to vectors:
<
(textout (reverse v)) // <= [4, 2, 5, 1, 3]
(textout (sort v)) // <= [1, 2, 3, 4, 5]
(textout (shuffle v)) // <= [5, 3, 4, 1, 2]
)</
=={{header|TXR}}==
Line 7,914 ⟶ 8,959:
A complete program which turns comma-separated into tab-separated,
where the first and last field from each line are exchanged:
<
@line
@(bind f @(split-str line ","))
Line 7,920 ⟶ 8,965:
@{f[-1]}@\t@{f[1..-1] "\t"}@\t@{f[0]}
@(end)
@(end)</
====Other Kinds of Objects====
Line 7,930 ⟶ 8,975:
=={{header|uBasic/4tH}}==
uBasic/4tH has only one single, global array of 256 integers. Since it's fixed, it can't be declared.
<syntaxhighlight lang="text">Let @(0) = 5 : Print @(0)</
=={{header|Unicon}}==
Unicon's arrays are provided by the list type, which is a hybrid list/array type.
Lists of integers or reals, if not polluted by other types nor changed in size, may use a C-compatible internal representation (long and double).
<syntaxhighlight lang="text">L := list(100); L[12] := 7; a := array(100, 0.0); a[3] +:= a[1]+a[2]</
=={{header|UNIX Shell}}==
Line 7,945 ⟶ 8,990:
To create an array:
<
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:
<
echo "The number of items in alist is ${#alist[*]}"</
To iterate up over the items in the array:
<
while [[ $x < ${#alist[*]} ]]; do
echo "Item $x = ${alist[$x]}"
: $((x++))
done</
To iterate down over theitems in an 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:
<
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:
<
# push LIST VALUES ...
push() {
Line 7,978 ⟶ 9,023:
push alist "one thing to add"
push alist many words to add</
To delete a single array item, the first item:
<syntaxhighlight lang
To delete and return the last item in an array (e.g., "pop" function):
<
pop() {
Line 8,004 ⟶ 9,049:
c
pop alist
No items in alist</
To delete all the items in an array:
<syntaxhighlight lang
To delete the array itself (and all items in it, of course):
<syntaxhighlight lang
=={{header|உயிர்/Uyir}}==
<
இருபரிமாணணி வகை எண் அணி {3, 3};
இருபரிமாணணி2 வகை எண் அணி {3} அணி {3};
Line 8,021 ⟶ 9,066:
செவ்வகணி = அணி { அணி {10, 22, 43}, அணி {31, 58, 192}, அணி {46, 73, 65} };
முக்கோண்ணி = அணி { அணி {1}, அணி {2, 3}, அணி {4, 5, 6}, அணி {7, 8, 9, 1, 2} };
</syntaxhighlight>
=={{header|Vala}}==
Non-dynamic arrays:
<
int[] array = new int[10];
Line 8,032 ⟶ 9,077:
stdout.printf("%d\n", array[0]);
</syntaxhighlight>
{{libheader|Gee}}
Dynamic Arrays with Gee:
<
var array = new ArrayList<int> ();
Line 8,045 ⟶ 9,090:
stdout.printf("%d\n", array[0]);
</syntaxhighlight>
=={{header|VBA}}==
The Option Base statement is used at the module level to declare the default lower bound for array subscripts.
<syntaxhighlight lang
<
'create an array,
Dim a(3) As Integer
Line 8,078 ⟶ 9,123:
Debug.Print d(i)
Next i
End Sub</
{{out}}
<pre> 1 4 9 1 4 9 1 4 9 16 </pre>
=={{header|VBScript}}==
<
'create a static array
Line 8,127 ⟶ 9,172:
'Multi-Dimensional arrays
'The following creates a 5x4 matrix
Dim mat(4,3) </
{{out}}
<pre>
Line 8,138 ⟶ 9,183:
=={{header|VHDL}}==
<syntaxhighlight lang="vhdl">
entity Array_Test is
end entity Array_Test;
Line 8,196 ⟶ 9,241:
end architecture Example;
</syntaxhighlight>
=={{header|Vim Script}}==
Lists can be used for dynamic arrays. Indexing starts at 0.
<
let array = [3, 4]
Line 8,218 ⟶ 9,263:
call insert(array, 3, 2)
echo array</
{{Out}}
Line 8,224 ⟶ 9,269:
=={{header|Visual Basic .NET}}==
<
Dim numbers As Integer() = New Integer(9) {}
'Example of array of 4 string types:
Line 8,254 ⟶ 9,299:
list.Add(3)
list(0) = 2
Console.WriteLine(list(0))</
=={{header|V (Vlang)}}==
<
// Tectonics: v run arrays.v
module main
Line 8,310 ⟶ 9,355:
println("array4: $array4")
println("array5: $array5")
}</
{{out}}
Line 8,331 ⟶ 9,376:
=={{header|Wee Basic}}==
<
let array$(1)="Hello!"
let array$(2)="Goodbye!"
print 1 array$(1)</
=={{header|Wren}}==
<
arr.add(1)
arr.add(2)
Line 8,350 ⟶ 9,395:
arr[-1] = 0
arr.insert(-1, 0) // [0, 0, 1, 0, 0]
arr.removeAt(2) // [0, 0, 0, 0]</
=={{header|X86 Assembly}}==
<
section .text
global _start
Line 8,432 ⟶ 9,477:
resd 1
resd 1
</syntaxhighlight>
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".
Line 8,438 ⟶ 9,483:
=={{header|XBS}}==
Arrays in [[XBS]] are very similar to [[JavaScript]].
<
log(Array[0]);
Array.push("Test");
log(?Array);
log(Array[?Array-1]);</
=={{header|XLISP}}==
Like some other languages, XLISP refers to one-dimensional arrays as vectors. Examples of vector and array syntax, from a REPL (interactive session):
<
A
Line 8,469 ⟶ 9,514:
[8] (array-ref d 1 2 3) ; and get the value of d_1,2,3
10</
=={{header|XPL0}}==
<
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
Line 8,479 ⟶ 9,524:
B(7):= 28;
IntOut(0, A(3)+B(7)); \displays 42
]</
=={{header|Yabasic}}==
<
// Indexed at your preference (0 to 9 or 1 to 10)
print arraysize(a(), 1) // this function return the element's higher number of an array
Line 8,509 ⟶ 9,554:
print arraysize(a$(), 1)
print a$(5) // show the content of an element of the array. Now is empty</
=={{header|Z80 Assembly}}==
An array is nothing more than a contiguous section of memory. Whether an array is mutable or not is solely determined by whether its memory location is in ROM or RAM.
<
byte 0,0,0,0,0
byte 0,0,0,0,0
byte 0,0,0,0,0
byte 0,0,0,0,0</
<i>Side note: Some systems, such as the Game Boy or other ROM cartridge-based computers, cannot use the above declaration to initialize an array in RAM at assemble time; only in ROM. While the label "Array" can be given to an arbitrary RAM location on any system, you won't be able to define a data block in RAM the same way you would on an assembly program meant to run on the Amstrad CPC or ZX Spectrum for example. The examples below will still work on any system, you just won't be able to "see" the array before running the program, if that makes sense. Clearing the system ram will suffice to initialize the array to zero.</i>
Line 8,525 ⟶ 9,570:
This code will assign a value of decimal 20 to the 1st (zero-indexed) row and 2nd (zero-indexed) column. The resulting array will look like this:
<
byte 0,0,0,0,0
byte 0,0,20,0,0
byte 0,0,0,0,0
byte 0,0,0,0,0</
<
ld hl,Array ;hl points to the 0th element of row 0.
Line 8,543 ⟶ 9,588:
ld a,20 ;get the value 20 which we want to store here
ld (hl),a ;store 20 into the desired slot. (Retrieving a value is the same process except we skip the step above and
; execute "ld a,(hl)" at this point instead.)</
The main takeaway from all this is that arrays are handled the same as any other type of memory, and have no "special" syntax, apart from the boilerplate pointer arithmetic of <code>*array = *array + (desired_row_number*row_length*bytes_per_element) + (desired_column_number*bytes_per_element)</code>. This is the case for most assembly languages, even though the methods of offsetting a pointer may vary.
Line 8,552 ⟶ 9,597:
In the example below, we wish to load the 13th (zero-indexed) element from the array MyTable.
<
;>LABEL means "the high byte of the address represented by LABEL
LD L,13 ;this was a lot faster than doing LD HL,&0400 and adding the desired index later.
Line 8,564 ⟶ 9,609:
byte 3,6,9,12,15
byte 4,8,12,16,20
byte 5,10,15,20,25</
But what if you're working with 16-bit data? If you've got bytes to burn, you can separate your data into two "byteplanes" - a pair of tables, one of which contains the low bytes and the other containing the high bytes, both sharing a common index. Using alignment you can guarantee that they are a multiple of &0100 bytes apart, which simplifies the lookup process greatly. You can get away with loading just the high byte of the pointer to the "low table" and incrementing that half of the pointer to get to the high byte, while leaving the index (which is stored in the low half of your pointer register) intact.
That might have been a bit confusing, so let's visualize the concept. Here's a practical example of storing a sine wave pattern. Instead of storing 16-bit data together like you normally would:
<
word &8000,&8327,&864e,&8973,&8c98,&8fba,&92da,&95f7
word &9911,&9c27,&9f38,&a244,&a54c,&a84d,&ab48,&ae3c
word &b12a,&b40f,&b6ed,&b9c2,&bc8e,&bf50,&c209,&c4b7
word &c75b,&c9f4,&cc81,&cf02,&d177,&d3e0,&d63b,&d889</
You can instead store it like this:
<
byte <&8000,<&8327,<&864e,<&8973,<&8c98,<&8fba,<&92da,<&95f7
byte <&9911,<&9c27,<&9f38,<&a244,<&a54c,<&a84d,<&ab48,<&ae3c
Line 8,585 ⟶ 9,630:
byte >&9911,>&9c27,>&9f38,>&a244,>&a54c,>&a84d,>&ab48,>&ae3c
byte >&b12a,>&b40f,>&b6ed,>&b9c2,>&bc8e,>&bf50,>&c209,>&c4b7
byte >&c75b,>&c9f4,>&cc81,>&cf02,>&d177,>&d3e0,>&d63b,>&d889</
If your assembler is cool like mine is, this will be valid despite looking like I'm trying to declare what is obviously 16-bit data as 8-bit data. Many Z80 assemblers have some sort of "low byte" and "high byte" operator, it might not be the same symbol but most have it. If yours doesn't, I'd recommend using one that does, because it's really necessary for optimizations like these. In addition it makes the code more readable as it communicates to the reader how the data is intended to be interpreted.
So let's say we want to read the last entry in "the table".
<
LD L,&1F ;desired index
ld a,(hl)
Line 8,596 ⟶ 9,641:
inc h ;LD h,&05. We can keep L the same since the index is the same.
;Effectively we did all the necessary pointer arithmetic for indexing the second table, just with this one instruction!
ld a,(hl) ;now we have the low byte in C and the high byte in A.</
That would have taken a lot more instructions had this been a single table of words with more than 128 entries. You'd have to do some bit shifting to offset the pointer to the table by the desired index, and it would have just taken a lot more time. If you're trying to get something done quickly (such as a raster interrupt) you want to spend as little time doing lookups as possible.
Line 8,602 ⟶ 9,647:
=={{header|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.
<
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)</
=={{header|zonnon}}==
<
var
a: array 10 of integer;
da: array * of cardinal;
</syntaxhighlight>
=={{header|ZX Spectrum Basic}}==
<
20 LET a(2)=128
30 PRINT a(2)</
{{omit from|X86-64 Assembly|the same as X86, Just R based registers(eax,rax)}}
|