Arrays: Difference between revisions

{{trans|Python}}

array.append(1)

array.append(3)

V width = 3

V height = 4

{{out}}

=={{header|360 Assembly}}==

ARRAYS PROLOG

* we use TA array with 1 as origin. So TA(1) to TA(20)

J DC F'4'

YREGS

=={{header|6502 Assembly}}==

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.

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:

{

char array[5] = {3,6,9,12,15};

return array[2];

would (theoretically) compile to the following in 6502 Assembly:

foo:

LDX #2 ;load the desired index

array: ;this is the array we're reading from.

===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:

LDA $80,x ;evaluates to LDA $00

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:

The 6502 is little-endian, so the above would be exactly the same as the following:

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

LDA wordArray,X ;evaluates to LDA #$EF

STA $00 ;store in a zero page temporary variable

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,

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.

db $CD,$EF,$FE,$DA

wordArray_Hi:

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:

LDA wordArray_Lo,x ;evaluates to LDA #$EF

STA $00

LDA wordArray_Hi,x ;evaluates to LDA #$BE

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.

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:

In the eyes of the CPU, this is the same as ANY of the following:

db 5

db 10

db 40

db 45

db 5,10

db 15,20

db 25,30

db 35,40

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:

db 5,10

db 15,20

db 25,30

db 35,40

For this example, we want row 3 and column 1 (zero-indexed for both) which means we want to load 40.

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)

TAX ;move A to X so we can use it as the index

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.

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.

Defining an array in ROM (or RAM if you're making a program that is loaded from disk) is very simple:

MyArray:

DC.B 1,2,3,4,5

DC.L 6,7,8,9,10

DC.L 11,12,13,14,15

Strings are also arrays and most assemblers accept single or double quotes. The following are equivalent:

DC.B "Hello World",0

even

MyString2:

DC.B 'H','e','l','l','o',' ','W','o','r','l','d',0

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

LSL.W #2,D0 ;this array is intended for 32-bit values.

MOVE.L #23,D1 ;load decimal 23 into D1

This is the equivalent of the [[C]] code:

Loading an element is very similar to storing it.

;load element 4

MOVE.W #4,D0 ;load the desired offset into D0

LSL.W #2,D0 ;this array is intended for 32-bit values.

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.

MOVE.L (A0,D0),(4,A0,D0)

ADDA.L #4,A0

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.

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

pop dph

=={{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

\ arrays don't have to be homogenous:

[1,"one", 2, "two"]

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program areaString64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|ABAP}}==

There are no real arrays in ABAP but a construct called internal tables.

TYPES: tty_int TYPE STANDARD TABLE OF i

WITH NON-UNIQUE DEFAULT KEY.

cl_demo_output=>display( itab ).

cl_demo_output=>display( itab[ 2 ] ).

{{out}}

=={{header|ACL2}}==

(assign array-example

(compress1 'array-example

;; Get a[5]

=={{header|Action!}}==

BYTE i

PrintF("c(%B)=%B ",i,c(i))

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Arrays.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

var array1:Array = new Array(10);

//creates an array with the values 1, 2

array2.push(4);

//get and remove the last element of an array

=={{header|Ada}}==

A, B : array (1..20) of Integer;

Fingers_Extended'Last := False; -- Set last element of array

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)

var arr7 = arr1 & arr2 // intersection

# retrieve an element

=={{header|Aime}}==

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

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

l_append(l, "arrays");

The insertion position can be specified:

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

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

or is type specific fashion:

=={{header|ALGOL 60}}==

{{trans|Simula}}

comment arrays - Algol 60;

dynamic(5)

{{out}}

<pre>

=={{header|ALGOL 68}}==

(

[1:20]INT a;

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 );

% as parameters to procedures %

% multi-dimension arrays are supported %

=={{header|AmigaE}}==

da: PTR TO CHAR,

la: PTR TO CHAR

-> "deallocating" the array

IF la <> NIL THEN END la[100]

=={{header|AntLang}}==

arr: <1;2;3>

/ Get the nth element (index origin = 0)

=={{header|Apex}}==

array[0] = 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

=={{header|APL}}==

Arrays in APL are one dimensional matrices, defined by seperating variables with spaces. For example:

=={{header|App Inventor}}==

=={{header|AppleScript}}==

AppleScript arrays are called lists:

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

Or a new list containing the items can be created through concatenation:

set any to false & any & 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!

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}

If required, items can be specified by class instead of the generic 'item' …

… and some fairly complex range specifiers are possible:

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.

The number of items of a specific class can also be obtained:

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

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.

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.

=={{header|Arendelle}}==

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

(:::::::::::::::::

DynArray[5] = 243

prints DynArray[0] DynArray[5]

{{works with|Argile|1.1.0}}

let x = @["foo" "bar" "123"]

print x[2]

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program areaString.s */

.Ls_magic_number_10: .word 0x66666667

=={{header|Arturo}}==

arrA: []

; retrieve an element at some index

{{out}}

{{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"

; Push a value onto the array

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

StringSplit arrayX, source, %A_Space%

Loop, %arrayX0%

=={{header|AutoIt}}==

Create an userdefined array.

#include <Array.au3> ;Include extended Array functions (_ArrayDisplay)

_ArrayDisplay($aInputs) ;Display the Array

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

Tuples are immutable, however one can quickly create a new tuple with a specified element replaced.

=={{header|AWK}}==

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"

print " " i ": " array[i]

}

{{out}}

=={{header|Axe}}==

2→{L₁+1}

3→{L₁+2}

Disp {L₁+1}►Dec,i

Disp {L₁+2}►Dec,i

=={{header|Babel}}==

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:

===Get a single array element===

{{Out}}

Changing a value-array element:

{{Out}}

Changing a pointer-array element:

{{Out}}

===Select a range of an array===

{{Out}}

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.

Convert a value-array to a list of values:

{{Out}}

Convert a list of values to a value-array:

{{Out}}

Convert a pointer-array to a list of pointers:

{{Out}}

Convert a list of pointers to a pointer-array:

{{Out}}

Note: We need to use quotes in DATA

DATA "January", "February", "March", "April", "May", "June", "July"

DATA "August", "September", "October", "November", "December"

PRINT dat$[i]

NEXT

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

INCR i

WEND

name this '''split.bac'''

SPLIT ARGUMENT$ BY " " TO TOK$ SIZE len_array

PRINT TOK$[i]

NEXT i

in the terminal

./split January February March April May June July August September October November December

Notes: if you want to take a string from the command line

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.

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"

'''Array Initialization'''

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)

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

50 LET A%(11) = 1

60 PRINT A%(1), A%(11)

{{works with|qbasic}}

===Static===

staticArray(0) = -1

staticArray(10) = 1

===Dynamic===

Note that BASIC dynamic arrays are not stack-based; instead, their size must be changed in the same manner as their initial declaration -- the only difference between static and dynamic arrays is the keyword used to declare them (<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

dynamicArray(20) = 1

==={{header|Applesoft BASIC}}===

20 LET A%(0) = -1

30 LET A%(11) = 1

==={{header|Commodore BASIC}}===

=={{header|BASIC256}}==

dim numbers(10)

for t = 0 to 9

print numbers[t] + "=" + words$[t]

next t

=={{header|Batch File}}==

Arrays can be approximated, in a style similar to REXX

@echo off

setlocal ENABLEDELAYEDEXPANSION

echo %1 = %2

goto :eof

{{out}}

=={{header|BBC BASIC}}==

DIM array(6), array%(6), array$(6)

PRINT array(2) TAB(16) array(3) TAB(32) array(4)

PRINT array%(2) TAB(16) array%(3) TAB(32) array%(4)

=={{header|bc}}==

The following is a transcript of an interactive session:

g[3] = 42

/* Look at some other elements in g */

123

g[3]

=={{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

% There is no automatic garbage collection

delete $arr

=={{header|Boo}}==

myArray as (int) = (1, 2, 3) // Size based on initialization

fixedArray as (int) = array(int, 1) // Given size(1 in this case)

print myArray[0]

=={{header|BQN}}==

All arrays are variable length, and can contain any types of values.

arr ← 1‿2‿'a'‿+‿5

# General List Syntax:

# Modifying the array(↩):

⟨ 1 2 'a' + 5 ⟩

⟨ 1 2 'a' + 5 ⟩

+

[https://mlochbaum.github.io/BQN/try.html#code=IyBTdHJhbmRpbmc6CmFyciDihpAgMeKAvzLigL8nYSfigL8r4oC/NQojIEdlbmVyYWwgTGlzdCBTeW50YXg6CmFycjEg4oaQIOKfqDEsMiwnYScsKyw14p+pCuKAolNob3cgYXJyIOKJoSBhcnIxICMgYm90aCBhcnJheXMgYXJlIHRoZSBzYW1lLgrigKJTaG93IGFycgrigKJTaG93IGFycjEKCiMgVGFraW5nIG50aCBlbGVtZW50KOKKkSk6CuKAolNob3cgM+KKkWFycgoKIyBNb2RpZnlpbmcgdGhlIGFycmF5KOKGqSk6CmFyciDihqkgImhlbGxvIuKMvig04oq44oqRKSBhcnIK Try It Here!]

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)

| out$"mytable is gone"

)

{{out}}

<pre>5

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.

===========[

ARRAY DATA STRUCTURE

return back by finding leftmost null then decrementing pointer

twice then decrement our NEWVALUE cell

=={{header|C}}==

Fixed size static array of integers with initialization:

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 };

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

/* calloc() additionally pre-initializes to all zeros */

short *myShorts = calloc( numElements, sizeof(short)); /* array of 10 */

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:

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));

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) {

free(kernel-XSIZE);

}

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

Typically dynamic allocation is used and the allocated array is sized to the maximum that might be needed. A additional variable is

declared and used to maintain the current number of elements used. In C, arrays may be dynamically resized if they were allocated:

int *array = malloc (sizeof(int) * 20);

....

array = realloc(array, sizeof(int) * 40);

A Linked List for chars may be implemented like this:

#include <stdlib.h>

#include <stdio.h>

list->size = 0;

}

=={{header|C sharp|C#}}==

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:

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;

Dynamic

using System.Collections.Generic;

list[0] = 2;

=={{header|C++}}==

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

demonstrate(fixed_size_array);

demonstrate(dynamic_array);

=={{header|Ceylon}}==

{{works with|Ceylon|1.3.0}}

ArrayList

list.push("hello again");

print(list);

=={{header|ChucK}}==

int array[0]; // instantiate int array

array << 1; // append item

[1,2,3,4,5,6,7] @=> array;

array.popBack(); // Pop last element

=={{header|Clean}}==

===Lazy array===

Create a lazy array of strings using an array denotation.

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

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

===Strict array===

Create a strict array of integers.

===Unboxed array===

Create an unboxed array of characters, also known as <tt>String</tt>.

=={{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

// Array can be dynamically resized:

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

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

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:

//Duplicate the whole or nested array:

arr5 := AClone( arr1 )

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

user=> (conj my-vec 300) ;adding to a vector always adds to the end of the vector

=={{header|COBOL}}==

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

PROGRAM-ID. arrays.

GOBACK

=={{header|CoffeeScript}}==

array1[0] = "Dillenidae"

array1[1] = "animus"

array2 = ["Cepphus", "excreta", "Gansu"]

=={{header|ColdFusion}}==

Creating a one-dimensional Array:

Creating a two-dimensional Array in CFScript:

arr2 = ArrayNew(2);

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

=={{header|Common Lisp}}==

(setf (aref array 0) 1

(aref array 1) 3)

Dynamic

(vector-push-extend 1 array)

(vector-push-extend 3 array)

(setf (aref array 0) 2)

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

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