Creating an Array: Difference between revisions

{{task|Basic language learning}}

This task is about numerically-indexed arrays. For '''hashes''' or '''associative arrays''', please see [[Creating an Associative Array]].

In addition, demonstrate how to initialize an array variable with data.

<lang actionscript>

// ActionScript arrays are zero-based

</lang>

'''Compiler:''' [[GCC]] 4.1.2

</lang>

Example of array of 10 integer types:

</lang>

<lang amigae>DEF ai[100] : ARRAY OF CHAR, -> static

da: PTR TO CHAR,

ENDPROC</lang>

AppleScript arrays are called lists:

<lang applescript> set empty to {}

<lang applescript> set any to {1, "foo", 2.57, missing value, ints}</lang>

AutoHotkey does not have arrays yet.

However, variables can be set to arbitrary size and pointer operations can be used, simulating arrays. Just without the syntactic sugar of '[]'.

</lang>

"Numeric" arrays coincide with hashes in awk. Indices begin at 1. The <tt>split</tt> function can be used to initialize an array from a string with elements separated by a field separator (space by default)

<lang awk>BEGIN {

capital["Italy"]="Rome"</lang>

{{works with|QuickBasic|4.5}}

<lang freebasic> Dim myArray(1 To 2, 1 To 5) As Integer => {{1, 2, 3, 4, 5}, {1, 2, 3, 4, 5}} </lang>

Dynamic

<lang c> #include <stdlib.h> /* for malloc */

<lang c> int myArray2[10] = { 1, 2, 0}; /* 3..9 := 0 */</lang>

Using dynamically-allocated (i.e. [[Heap]]) memory:

<lang cpp> const int n = 10;

myArray5.Add(2);</lang>

Example of array of 10 int types:

<lang csharp> string[,] funny_matrix = new string[2,2]{ {"clowns", "are"} , {"not", "funny"} };</lang>

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

===Lazy array===

array = {x \\ x <- ['a' .. 'z']}</lang>

Creates a one-dimensional Array

<lang coldfusion><cfset arr1 = ArrayNew(1)></lang>

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

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

<lang lisp>(make-array 10)</lang>

(make-array 4 :element-type 'integer :initial-contents '(1 2 3 4) :adjustable t)</lang>

{{works with|DMD}}

int[5] = [0,1,2,3,4];</lang>

'''Defining a variable-length array'''

<lang delphi>var

Delphi dynamic arrays have base 0 index.

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

If you want an array of some mutable objects, see [[N distinct objects#E]].

Forth has a variety of ways to allocate arrays of data, though it has no built-in array handling words, favoring pointer manipulation.

0 to MyArray</lang>

In ANSI FORTRAN 77 or later, this is a default-indexing array declaration:

13, 14, 15, 16 /), (/ 4, 4 /) ) )</lang>

In Groovy "arrays" are synonymous with "lists", and are thus not of a fixed size. Ranges are also a type of list.

<lang groovy>

</lang>

Arrays are initialized either by a list of index-value-pairs or by a list of values:

There are several flavours of arrays in Haskell, but creation looks very similar for the others.

IDL doesn't really distinguish between scalars and arrays - the same operations that can create the one can ''usually'' create the other as well.

print,a^2

9 25 64 49</lang>

"Creating an array" is topic seldom discussed in J as ''every'' verb takes array argument(s) and returns an array result (that is, ''everything'' creates an array). For example:

Both the <tt>a+b</tt>and the <tt>|."1 c</tt> expressions create arrays.

For example for an array of 10 int values:

<lang java>int[] intArray = new int[10];</lang>

<lang java>Object[] obs = new Object[size];</lang>

<lang javascript> var myArray = new Array();

var myArray1 = new Array(5); // gotcha: preallocated array with five empty elements, not [ 5 ].

var myArray3 = ["Item1", "Item2"];</lang>

<lang logo>array 5 ; default origin is 1

(array 5 0) ; custom origin

{1 2 3 4 5} ; array literal</lang>

<lang lse64>10 myArray :array</lang>

Creating an array is simply done with Set (=). An array can contain anything, and can have different Heads. A formule like 2+3x+x^2 is an array: Plus[2,Times[3,x],Times[2,Power[x,2]]]. Each list has different heads (Plus,Times, Power). Arrays are made as follows:

<lang Mathematica>

Note that arrays can have any dimensions, and don't have to be rectangular (every (sub)element can have different length).

{{works with|3D Studio Max|8}}

for i in 1 to 100 do arr[i] = 0</pre>

{{works with|mIRC Script Editor}}

<lang mirc>alias creatmearray { .echo -a $array_create(MyArray, 5, 10) }</lang>

Modula-3 arrays include their range in the declaration.

<lang modula3>VAR a: ARRAY [1..10] OF INTEGER;</lang>

Which creates a 2 dimensional array of 10 integers each.

To create an array of 5 elements with values from 1 to 5

<lang nial>| count 5

<lang nial>| newarr := [2 4 6]</lang>

Create an array of 10 integers. Initial values are undefined. All arrays are zero-indexed.

<lang oberon2>VAR a: ARRAY 10 OF INTEGER;</lang>

creates a 3 dimensional array of 10 integers each.

Using an array literal:

let array = Array.init 5 callback</lang>

'''Using a fixed length array as global or stack variable'''

<lang pascal>var

Note that also the lower index may be given as dynamic argument.

{{works with|Perl|5}}

<lang perl> my @empty;

</lang>

For a single dimension array with 10 elements:

?></lang>

For a single dimension int array:

<lang pike> array(int) x = ({ 1, 2, 3 });</lang>

Note that inner arrays can be of different sizes, as are simply values of the outer array.

Pop11 distinguishes between vectors and arrays. Vectors are one dimensional and the lowest index is 1. There is special shorthand syntax to create vectors:

vars a1 = newarray([2 5 -1 1], 0);</lang>

List are mutable arrays. You can put anything into a list, including other lists.

The [http://docs.python.org/library/ctypes.html#arrays ctypes module] can construct specialised arrays for interfacing with external C functions. The [http://docs.python.org/library/struct.html struct module] allows a string of characters to be interpreted as an array of values of C types such as 32 bit ints, float, etc.

<lang R>a <- vector("numeric", 10) # a is a vector (array) of 10 numbers

b <- vector("logical", 10) # b is an array of logical (boolean) values

<lang raven>[ 1 2 3.14 'a' 'b' 'c' ] as a_list

a_list print</lang>

5 => "c"

This is the most basic way to create an empty one-dimensional array in Ruby:

<lang ruby> my_array = Array.new

array = Array.new(4) {|i| Array.new(6,i)}</lang>

<lang scala> val array = new Array[int](10) // a 10 element array

val stringArray = new Array[String](20) // a 20 element string array

(1 :: 2 :: 3 :: 4 :: 5 :: Nil).toArray</lang>

Lists are more often used in Scheme than vectors.

<lang scheme> (make-vector 5 0)</lang>

Script3D has dynamic arrays allowing to store any datatype and a special type for storing vectors of floating point values, typically used in 3D applications.

var myVector = Vector(2000); // 2000 elements vector of floats</lang>

<lang slate>

define: #array -> (Array newSize: 20).

</lang>

<lang smalltalk>|array|

"creates an array that holds up to 20 elements"

array at: 2 put: 'orange'.</lang>

Converting from a list:

<lang sml> val vector = #[1,2,3,4,5]</lang>

Tcl uses the <tt>list</tt> for what many other languages call "array". A list is an ordered, numerically indexable (zero based) collection of values in a single variable. Each list entry itself can be a list.

this creates an array with the name <tt>b</tt> with two elements. The keys of the elements are "foo" and "bar" and the values are <tt>b(foo) == 12</tt> and <tt>b(bar) == hello</tt>.

Toka allows creation of an array using is-array. Access to the elements is done using get-element, put-element, get-char-element, and put-char-element functions. You can not initialize the values automatically using the core array functions.

100 chars is-array bar</lang>

Implicit Size

<lang vbnet>Dim words() AS String = 'perl style'.split(" "c) ' You must tell VB that the space is a character by denoting c after the " "</lang>

<lang vbscript>Dim myArray(2)