Array length: Difference between revisions

[[Category:Simple]]

 

;Task:

 

=={{header|11l}}==

{{out}}

<pre>

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

Array length is computed at compilation time with the formula : (AEND-A)/L'A

ARRAYLEN START

USING ARRAYLEN,12

{{trans|360 Assembly}}

Array length is computed at compilation time with the formula: (Array_End-Array). Even though the labels Array and Array_End are both 16-bit values, if their difference fits into 8 bits the assembler will allow you to load it into a register.

LDA #(Array_End-Array) ;evaluates to 13

RTS

 

 

MOVE.B #(MyArray_End-MyArray)/4 ;evaluates to 2

RTS

 

=={{header|8th}}==

["apples", "oranges"] a:len . cr

</syntaxhighlight>

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program lenAreaString64.s */

The concept of arrays does not exist in ABAP, instead internal tables are used. Since ABAP Version 7.40 they can be accessed with the common index notation. Note that the index starts at 1 and out of bound access raises an exception. The built-in function "lines" returns the number of records.

 

report z_array_length.

 

=={{header|Ada}}==

 

 

procedure Array_Length is

Fruits : constant array (Positive range <>) of access constant String

:= (new String'("orange"),

new String'("apple"));

 

 

end Array_Length;</syntaxhighlight>

 

{{out}}

 

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

[]STRING fruits = ( "apple", "orange" );

print( ( ( UPB fruits - LWB fruits ) + 1, newline ) ) # prints 2 #</syntaxhighlight>

 

=={{header|AntLang}}==

length[array]

/Works as a one liner: length[seq["apple"; "orange"]]</syntaxhighlight>

 

=={{header|Apex}}==

 

=={{header|APL}}==

Output:

<pre>2</pre>

 

=={{header|AppleScript}}==

set theList to {"apple", "orange"}

count theList

<pre>fold (λx n -> 1 + n) 0</pre>

 

set xs to ["alpha", "beta", "gamma", "delta", "epsilon", ¬

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program lenAreaString.s */

=={{header|Arturo}}==

 

 

print ["array length =" size fruit]</syntaxhighlight>

 

=={{header|ATS}}==

#include

"share/atspre_staload.hats"

 

=={{header|AutoHotkey}}==

{{Out}}<pre>2</pre>

 

=={{header|AutoIt}}==

 

Local $aArray[2] = ["Apple", "Orange"]

Using Avail's tuples and the `|_|` method:

 

 

=={{header|AWK}}==

Another method to count the elements of the array is by using a variant of for().

 

#

function countElements(array) {

=={{header|BaCon}}==

BaCon knows three types of arrays, the UBOUND function can query all.

 

DECLARE fruit$[] = { "apple", "orange" }

=={{header|Bash}}==

 

fruit=("apple" "orange" "lemon")

echo "${#fruit[@]}"</syntaxhighlight>

 

=={{header|BASIC}}==

X$(1) = "apple"

X$(2) = "orange"

 

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

20 A$(1) = "ORANGE"

30 A$(2) = "APPLE"

 

==={{header|BASIC256}}===

fruta$ = {"apple", "orange", "pear"}

orange

</pre>

 

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

Commodore BASIC has no way within the language to query an array for its length, but you can dive into the implementation to get that information. On a C-64 in particular, this works:

{{works with|Commodore BASIC|2.0 on C-64}}

20 A$(0) = "ORANGE"

30 A$(1) = "APPLE"

{{Out}}

<pre>A$ HAS 2 ELEMENTS.</pre>

 

==={{header|True BASIC}}===

READ fruta$(1), fruta$(2)

DATA "apple", "orange"

 

PRINT "La longitud del array fruta$ es" ; tamano

{{out}}

<pre> La longitud del array fruta$ es 2 </pre>

True BASIC's arrays are not fixed in length and, although True BASIC is a compiled-language, the number of elements can be changed during runtime using such functions as the MAT REDIM (matrix re-dimension) function. Although the starting index of 1 is in implicit, it can be changed by setting the lower and upper bounds (eg. fruit(0 to 3)) when declaring the array. Also, the example below uses the MAT READ function to read in the data elements into the array without having to explicitly list each variable-array index. The example also uses the SIZE function vs the bounds method to determine the length of the array. Finally, in this example the SIZE function was not assigned to a separate variable and instead is used within the PRINT function itself.

 

MAT READ fruit$

DATA "apple", "orange"

 

PRINT "The length of the array 'fruit$' is "; SIZE(fruit$)

 

 

{{out}}

 

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

While batch files don't support arrays in the traditional sense, sets of variables forming somewhat of a pseudo-array are extremely useful. They are usually in the form of <code>%name{number}%</code>. The below code gives an example of how to create an array from a list stored in a variable, and how to acquire the amount of entries in the array.

 

@echo off

 

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

{{works with|BBC BASIC for Windows}}

array$() = "apple", "orange"

PRINT "Number of elements in array = "; DIM(array$(), 1) + 1

<pre>Number of elements in array = 2

Number of bytes in all elements combined = 11</pre>

 

=={{header|Brat}}==

p ["apple", "orange"].length

</syntaxhighlight>

 

=={{header|BQN}}==

 

<code>≠</code> gives the length of an array in BQN.

[https://mlochbaum.github.io/BQN/try.html#code=4omgIDHigL8iYSLigL8r Try It!]

 

For static arrays:

 

#include <stdio.h>

 

A C pre-processor macro may be created for ease of use:

 

#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0]))

</syntaxhighlight>

</p>

====Solution====

#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS

 

 

====An example why sizeof(A)/sizeof(E) may be a bad idea in C====

#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS

 

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

 

using System;

 

Note that any of the following array declarations could be used:

 

var fruit = new[] { "apple", "orange" };

var fruit = new string[] { "apple", "orange" };

A shorter variant could also have been used:

 

using static System.Console;

 

However, C++ has an additional <code>std::array</code> type (amongst other collections) in its standard library:

 

#include <iostream>

#include <string>

In addition to the <code>std::array</code> type, the C++ standard library also provides dynamically-sized containers to hold arbitrary objects.

These all support similar interfaces, though their implementations have different performance characteristics.

std::list<std::string> fruitL({ "apples", "oranges" });

std::deque<std::string> fruitD({ "apples", "oranges" });

 

=={{header|Ceylon}}==

value array = ["apple", "orange"];

print(array.size);

=={{header|Clipper/XBase++}}==

 

* nizchka: March - 2016

* This is a Clipper/XBase++ of RosettaCode Array_Length

=={{header|Clojure}}==

 

(count ["apple" "orange"])

 

Arrays in COBOL are usually referred to as tables. Tables can have fixed or variable (with known maximum) allocations, using a syntax of OCCURS DEPENDING ON. The value of the ODO identifier is the number of active elements in the table.

 

program-id. array-length.

 

=={{header|ColdFusion}}==

 

<cfset testArray = ["apple","orange"]>

<cfoutput>Array Length = #ArrayLen(testArray)#</cfoutput>

 

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

(print (length #("apple" "orange")))

</syntaxhighlight>

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

;; Project : Array length

 

=={{header|Component Pascal}}==

{{works with|BlackBox Component Builder}}

MODULE AryLen;

IMPORT StdLog;

=={{header|Crystal}}==

 

puts ["apple", "orange"].size

</syntaxhighlight>

 

=={{header|D}}==

import std.stdio;

 

 

Or a somewhat shorter...

import std.stdio;

 

 

=={{header|Dart}}==

arrLength(arr) {

return arr.length;

 

=={{header|DataWeave}}==

sizeOf(arr)

</syntaxhighlight>

 

=={{header|Delphi}}==

showmessage( length(['a','b','c']).ToString );

</syntaxhighlight>

 

=={{header|Diego}}==

 

me_msg()_array()_values(apple,orange)_length();

 

=={{header|Dragon}}==

 

a = ["apple","orange"]

</syntaxhighlight>

 

 

print(xs.Length())</syntaxhighlight>

 

=={{header|EasyLang}}==

print len fruit$[]</syntaxhighlight>

 

=={{header|EchoLisp}}==

(length '("apple" "orange")) ;; list

→ 2

→ 2

</syntaxhighlight>

 

=={{header|Ela}}==

 

=={{header|Elena}}==

ELENA 5.0 :

var array := new string[]{"apple", "orange"};

var length := array.Length;

 

=={{header|Elixir}}==

2

iex(2)> tuple_size( {"apple", "orange"} ) # Tuple

 

=={{header|Elm}}==

import Array

import Html

|> Array.fromList

|> Array.length

|> Html.text

</syntaxhighlight>

 

=={{header|Emacs Lisp}}==

=> 2</syntaxhighlight>

 

<code>length</code> also accepts a list or a string.

 

=={{header|Erlang}}==

1> length(["apple", "orange"]). %using a list

2

 

=={{header|Euphoria}}==

sequence s = {"apple","orange",2.95} -- Euphoria doesn't care what you put in a sequence

 

 

=={{header|F_Sharp|F#}}==

Or:

 

=={{header|Factor}}==

{ "apple" "orange" } length

</syntaxhighlight>

 

=={{header|Forth}}==

The code is commented to explain what is going on for those unfamiliar with Forth.

 

HERE OVER CHAR+ ALLOT PLACE ;

 

R> ; \ return counter to data stack </syntaxhighlight>

Test code at Forth console

 

=={{header|Fortran}}==

For a simple example, the WRITE(6,*) suffices: write to standard output (the 6), in free-format (the *).

 

MODULE EXAMPLE

CONTAINS

 

=={{header|FreeBASIC}}==

 

Dim fruit(1) As String = {"apple", "orange"}

 

=={{header|Frink}}==

a = ["apple", "orange"]

println[length[a]]

 

=={{header|FurryScript}}==

COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ]

COUNT_STEP[ DR 1 SU ]

The <code>shape</code> builtin returns the shape of an array as an array of integers. The length is element 0 of the shape:

 

fun length(as: []int): int = (shape as)[0]

</syntaxhighlight>

=={{header|FutureBasic}}==

NSUInteger count = fn ArrayCount( ''array'' ). Example:

window 1

print fn ArrayCount( @[@"apple",@"orange",@"cherry",@"grape",@"lemon"] )

HandleEvents

</syntaxhighlight>

{{out}}

<pre>

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=2a452c807c7030eb64a2f1d60d31a830 Click this link to run this code]'''

Dim siList As Short[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

 

 

=={{header|Genie}}==

/* Array length, in Genie */

init

=={{header|Go}}==

 

 

import "fmt"

=={{header|Groovy}}==

 

def fruits = ['apple','orange']

println fruits.size()

=={{header|Harbour}}==

 

LOCAL aFruits := {"apple", "orange"}

Qout( Len( aFruits ) ) // --> 2

=={{header|Haskell}}==

 

length ["apple", "orange"]</syntaxhighlight>

 

=={{header|hexiscript}}==

let a[0] "apple"

let a[1] "orange"

 

=={{header|Hoon}}==

 

=={{header|i}}==

 

=={{header|Icon}} and {{header|Unicon}}==

Icon, and therefore Unicon, includes a prefix size operator, star <code>*</code>. This operator can be applied to just about any data type or data structure.

 

 

=={{header|Idris}}==

 

=={{header|J}}==

Tally (<code>#</code>) returns the length of the leading dimension of an array (or 1 if the array has no dimensions). Shape Of (<code>$</code>) returns the length of each dimension of an array.

2

$ 'apple';'orange'

2</syntaxhighlight>

For the list array example given, the result appears to be the same. The difference is that the result of Tally is a scalar (array of 0 dimensions) whereas the result of Shape Of is a list (1 dimensional array), of length 1 in this case.

 

$$'apple';'orange'

1</syntaxhighlight>

This might be a clearer concept with a few more examples. Here's an array with two dimensions:

apple

orange

2</syntaxhighlight>

And, here's an array with no dimensions:

9001

#9001

</syntaxhighlight>

You can count the number of dimensions of an array (the length of the list of lengths) using <code>#$array</code>:

#$9001

0

=={{header|Janet}}==

 

(def our-array @["apple" "orange"])

(length our-array)

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

 

 

However, determining the length of a list, array, or collection may simply be the wrong thing to do.

If, for example, the actual task (undefined here, unfortunately) requires retrieving the final item, while it is perfectly possible to write '''last''' in terms of '''length'''

 

return lst[lst.length - 1];

}</syntaxhighlight>

We might do better to drop the narrow focus on length, and instead use a fold (''reduce'', in JS terms) which can return a default value of some kind.

 

return lst.reduce(function (a, x) {

return x;

Alternatively, rather than scanning the entire list to simply get the final value, it might sometimes be better to test the length:

 

return list.length ?list[list.length-1] :defaultValue;

}</syntaxhighlight>

Or use other built-in functions – this, for example, seems fairly clear, and is already 100+ times faster than unoptimised tail recursion in ES5 (testing with a list of 1000 elements):

 

return list.slice(-1)[0] || defaultValue;

}</syntaxhighlight>

 

 

Output:

 

Note that the ''length'' filter is polymorphic, so for example the empty string (""), the empty list ([]), and ''null'' all have ''length'' 0.

 

=={{header|Jsish}}==

var arr = new Array('apple', 'orange');

puts(arr.length);

=={{header|Julia}}==

 

a = ["apple","orange"]

length(a)

</syntaxhighlight>

 

=={{header|Klingphix}}==

 

( "apple" "orange" ) len print

=={{header|Klong}}==

 

#["apple" "orange"]

</syntaxhighlight>

=={{header|Kotlin}}==

 

println(arrayOf("apple", "orange").size)

}</syntaxhighlight>

 

=={{header|Lambdatalk}}==

{A.length {A.new 1 2 3}}

-> 3

</syntaxhighlight>

 

In Latitude, <code>length</code> and <code>size</code> are synonymous and will both retrieve the size of a collection.

 

 

=={{header|Liberty BASIC}}==

NOTE -- This program runs only under LB Booster version 3.05 or higher because of arrays with more than two dimensions, passed array names to functions and subroutines as a parameter, and structured error trapping syntax. Get the LBB compiler here: http://lbbooster.com/

{{works with|LB Booster}}

FruitList$(0)="apple" 'assign 2 cells of a list array

FruitList$(1)="orange"

LIL does not use arrays, but indexed lists. The builtin '''count''' command returns the item count in a list. The '''length''' command returns the length of the list after string conversion.

 

set a [list "apple"]

append a "orange"

 

=={{header|Limbo}}==

 

include "sys.m";

 

=={{header|Lingo}}==

put fruits.count

-- 2</syntaxhighlight>

 

=={{header|Little}}==

puts(length(fruit));</syntaxhighlight>

 

=={{header|LiveCode}}==

 

split fruit using comma

answer the number of elements of fruit</syntaxhighlight>

 

=={{header|Lua}}==

fruits = {"apple", "orange"}

print(#fruits)

 

=={{header|M2000 Interpreter}}==

\\ A is a pointer to array

A=("Apple", "Orange")

 

=={{header|Maple}}==

numelems(a);</syntaxhighlight>

{{out}}

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

For arrays with more than one dimension, length reports the length of the larges dimension. The number of elements in a multi-dimensional array can be obtained with numel.

 

=={{header|Modula-3}}==

 

IMPORT IO;

 

=={{header|Mercury}}==

:- interface.

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

 

=={{header|MiniScript}}==

fruits = ["apple", "orange"]

print fruits.len

</syntaxhighlight>

=={{header|MiniZinc}}==

array[int] of int: arr = [1,2,3];

var int: size = length(arr);

 

=={{header|Nanoquery}}==

fruit[0] = "apple"

fruit[1] = "orange"

 

=={{header|Neko}}==

 

$print($asize(fruit));</syntaxhighlight>

 

=={{header|NewLISP}}==

 

; Nehal-Singhal 2018-05-25

 

=={{header|NGS}}==

# same

echo(['apple', 'orange'].len())</syntaxhighlight>

 

=={{header|Nim}}==

echo "The length of the fruit array is ", len(fruit)</syntaxhighlight>

 

The length of the fruit array is 2

</pre>

 

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE ArrayLength;

IMPORT

 

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

 

=={{header|OCaml}}==

Array.length [|"apple"; "orange"|];;

</syntaxhighlight>

 

=={{header|Oforth}}==

 

=={{header|Ol}}==

All of these methods are equivalent.

(print (vector-length (vector "apple" "orange")))

(print (vector-length #("apple" "orange")))

=={{header|Onyx}}==

 

 

=={{header|ooRexx}}==

/* REXX */

a = .array~of('apple','orange')

 

=={{header|PARI/GP}}==

length(array) \\ == 2

#array \\ == 2</syntaxhighlight>

{{works with|Free Pascal|2.6.2}}

 

#!/usr/bin/instantfpc

//program ArrayLength;

</pre>

 

=={{header|Perl}}==

 

The way to get the number of elements of an array in Perl is to put the array in scalar context.

 

 

scalar @array; # 5

So using it on an array, as a side-effect, actually gives you a number which represents the order of magnitude.

 

length @array; # 1

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">constant</span> <span style="color: #000000;">fruits</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #008000;">"apple"<span style="color: #0000FF;">,<span style="color: #008000;">"orange"<span style="color: #0000FF;">}</span>

<span style="color: #0000FF;">?<span style="color: #7060A8;">length<span style="color: #0000FF;">(<span style="color: #000000;">fruits<span style="color: #0000FF;">)

 

=={{header|Phixmonti}}==

With syntactic sugar

( "apple" "orange" ) len print</syntaxhighlight>

{{out}}

=={{header|PHP}}==

 

 

=={{header|Picat}}==

L = ["apple", "orange"],

println(len(L))),

 

=={{header|PicoLisp}}==

-> 2

:</syntaxhighlight>

 

=={{header|Pike}}==

{

array fruit = ({ "apple", "orange" });

 

=={{header|PL/I}}==

Dcl a(2) Char(6) Varying Init('apple','orange');

Put Edit('Array a has',(hbound(a)-lbound(a)+1),' elements.')

 

=={{header|Plorth}}==

 

=={{header|Pony}}==

actor Main

new create(env:Env)=>

 

=={{header|Potion}}==

 

=={{header|PowerShell}}==

$Array = @( "Apple", "Orange" )

$Array.Count

 

=={{header|Processing}}==

String[] arr = {"apple", "orange"};

void setup(){

 

==={{header|Processing Python mode}}===

arr = ['apple', 'orange'] # a list for an array

 

 

=={{header|Prolog}}==

 

X = 2

 

=={{header|PureBasic}}==

EnableExplicit

Define Dim fruit$(1); defines array with 2 elements at indices 0 and 1

 

An abbreviated form of the above, not printing to console/terminal

Dim fruit$(1); defines array with 2 elements at indices 0 and 1

fruit$(0) = "apple"

 

=={{header|Python}}==

2

>>> </syntaxhighlight>

=={{header|QB64}}==

 

Dim max As Integer, Index As Integer

Randomize Timer

=={{header|Quackery}}==

 

 

{{out}}

 

=={{header|R}}==

a <- c('apple','orange') # create a vector containing "apple" and "orange"

length(a)

=={{header|Racket}}==

{{trans|EchoLisp}}

(length '("apple" "orange")) ;; list

(vector-length #("apple" "orange")) ;; vector</syntaxhighlight>

To get the number of elements of an array in Raku you put the array in a coercing Numeric context, or call <code>elems</code> on it.

 

my @array = <apple orange>;

 

Watch out for infinite/lazy arrays though. You can't get the length of those.

 

 

say @infinite[5000]; # 5001

 

=={{header|Rapira}}==

output: #arr</syntaxhighlight>

 

=={{header|Red}}==

== 2</syntaxhighlight>

 

=={{header|Relation}}==

relation fruit

insert "apples"

 

=={{header|ReScript}}==

 

Js.log(Js.Array.length(fruits))</syntaxhighlight>

 

<html>

<head>

 

=={{header|REXX}}==

* The compond variable a. implements an array

* By convention, a.0 contains the number of elements

=={{header|Ring}}==

 

 

=={{header|Robotic}}==

 

Example 1:

set "index" to 0

set "$array&index&" to "apple"

 

Example 2:

set "index" to 0

set "local1" to random 1 to 99

* "Array length: ('index')"

</syntaxhighlight>

 

=={{header|Ruby}}==

 

 

=={{header|Rust}}==

By default arrays are immutable in rust.

 

fn main() {

let array = ["foo", "bar", "baz", "biff"];

}

</syntaxhighlight>

 

=={{header|Scala}}==

 

println(Array("apple", "orange").length)

</syntaxhighlight>

Using Scheme's vector type as an equivalent to an array:

 

(display (vector-length #("apple" "orange")))

</syntaxhighlight>

The function [http://seed7.sourceforge.net/libraries/array.htm#length(in_arrayType) length]

determines the length of an array.

 

const array string: anArray is [] ("apple", "orange");

 

=={{header|SenseTalk}}==

put the number of items in fruits</syntaxhighlight>

 

=={{header|Shen}}==

\\ Using a vector

\\ @v creates the vector

 

=={{header|Sidef}}==

say arr.len; #=> 2

say arr.end; #=> 1 (zero based)</syntaxhighlight>

 

=={{header|Simula}}==

BEGIN

 

2

</pre>

 

=={{header|Smalltalk}}==

a := #('apple' 'orange').

a size</syntaxhighlight>

 

=={{header|SNOBOL4}}==

ar<1,1> = 'apple'

ar<1,2> = 'first'

 

=={{header|SPL}}==

#.output("Number of elements in array: ",#.size(a,1))</syntaxhighlight>

{{out}}

=={{header|SQL}}==

 

 

=={{header|Standard ML}}==

val a = Array.fromList ["apple", "orange"]

in

 

=== Dimensions of a dataset ===

input str10 fruit

apple

Use either the '''[https://www.stata.com/help.cgi?macrolists sizeof]''' macro list function or the '''[https://www.stata.com/help.cgi?extended_fcn word count]''' extended macro function. Notice that the argument of the former is the macro ''name'', while the argument of the latter is the macro ''contents''.

 

di `: list sizeof fruits'

di `: word count `fruits''</syntaxhighlight>

For a Mata array, use '''[https://www.stata.com/help.cgi?mf_rows rows]''' and similar functions:

 

a=st_sdata(.,"fruit")

rows(a)

=={{header|Swift}}==

 

let fruitsCount = fruits.count // Declare constant array length (count)

 

 

=={{header|Symsyn}}==

| Symsyn does not support Array of Strings

| The following code for an Array of Integers

 

=={{header|Tailspin}}==

['apple', 'orange'] -> $::length -> !OUT::write

</syntaxhighlight>

<!-- http://ideone.com/uotEvm -->

 

set mylistA {apple orange} ;# actually a string

set mylistA "Apple Orange" ;# same - this works only for simple cases

{{works with|TI-83 2.55MP}}

Use function <code>dim()</code>.

dim(L1)</syntaxhighlight>

{{out}}

 

=={{header|Transd}}==

 

MainModule : {

 

=={{header|UNIX Shell}}==

array=("orange" "apple")

echo "${#array[@]}"</syntaxhighlight>

 

=={{header|Vala}}==

string[] fruit = {"apple", "orange"};

stdout.printf("%d\n", fruit.length);

Note that any of the following array declarations could be used:

 

var fruit = new string[] { "apple", "orange" };

string[] fruit = new string[] { "apple", "orange" };

A shorter variant could also have been used:

 

void main() {

stdout.printf("%d\n", new string[] {"apples", "orange"}.length);

=={{header|VBA}}==

One-liner. Assumes array lower bound, which is not always safe.

 

Works regardless of lower bound:

 

Public Function SizeOfArray(ar As Variant) As Long

 

=={{header|VBScript}}==

WScript.StdOut.WriteLine UBound(arr) - LBound(arr) + 1 </syntaxhighlight>

 

The amount of elements in an array in Visual Basic is computed via the upper bound and lower bound indices. In Visual Basic the indices of arrays have to be numeric, but it is even possible to have negative values for them. Of course the element numbering is continuous.

 

' declared in a module

Public Function LengthOfArray(ByRef arr As Variant) As Long

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

 

Sub Main()

</pre>

 

// Tectonics: v run array-length.v

module main

 

=={{header|WDTE}}==

let a => ['apple'; 'orange'];

len a -- io.writeln io.stdout;</syntaxhighlight>

 

=={{header|Wren}}==

System.print(arr.count)</syntaxhighlight>

 

 

=={{header|XLISP}}==

 

 

=={{header|Yabasic}}==

dim fruta$(3)

read fruta$(1), fruta$(2), fruta$(3)

The simplest way to implement an array of variable-length strings is to have the array contain pointers to said strings rather than the strings themselves. That way, the elements of the array are of equal length, which makes any array <b>much</b> easier to work with.

 

ld hl,TestArray

call GetArrayLength_WordData_NullTerminated

=={{header|zkl}}==

zkl doesn't support arrays natively, use lists instead.

T("apple", "orange").len().println() //-->2, read only list (ROList) </syntaxhighlight>

 

=={{header|Zig}}==

 

pub fn main() !void {

 

=={{header|Zoea}}==

program: array_length

input: [a,b,c]

 

=={{header|zonnon}}==

module AryLength;

type