Array length: Difference between revisions

 

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

AEND DC 0C

PG DC CL25'Array length=' buffer

{{out}}

<pre>

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

byte "apple",0

byte "orange",0

 

=={{header|68000 Assembly}}==

 

 

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

RTS

DC.L Apple

DC.L Orange

 

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

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

{{out}}

<pre>

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program lenAreaString64.s */

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

.include "../includeARM64.inc"

 

=={{header|ABAP}}==

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.

 

 

write: internal_table[ 1 ] , internal_table[ 2 ] , lines( internal_table ).

 

{{out}}

=={{header|Ada}}==

 

 

procedure Array_Length is

 

Ada.Text_IO.Put_Line (" Array Size : " & Integer'Image (Fruits'Length));

 

{{out}}

 

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

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

 

=={{header|AntLang}}==

length[array]

 

=={{header|Apex}}==

 

=={{header|APL}}==

Output:

<pre>2</pre>

 

=={{header|AppleScript}}==

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

count theList

-- or

number of items in theList

''Strictly speaking, 'items in' can be omitted from the last example, since 'number of' does essentially the same as 'length of'. The additional stage of extracting theList's 'items' is inefficient.''

{{out}}

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

 

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

end repeat

end fold

 

{{Out}}

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program lenAreaString.s */

.Ls_magic_number_10: .word 0x66666667

 

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|ATS}}==

#include

"share/atspre_staload.hats"

 

implement main0((*void*)) = ((*void*))

 

=={{header|AutoHotkey}}==

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

 

=={{header|AutoIt}}==

 

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

ConsoleWrite("aArray[" & $i & "] = '" & $aArray[$i] & "'" & @CRLF)

Next

{{Out}}

<pre>Elements in array: 2

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

print "String length:", array[1], length(array[1])

 

{{out}}

=={{header|BaCon}}==

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

 

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

meat$("first") = "chicken"

meat$("second") = "pork"

 

=={{header|Bash}}==

 

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

 

=={{header|BASIC}}==

X$(1) = "apple"

X$(2) = "orange"

 

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

20 A$(1) = "ORANGE"

30 A$(2) = "APPLE"

170 L$ = L$ + STR$ ( FN P(I))

180 L$ = L$ + " ": NEXT I

 

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

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

print fruta$[1]

end

<pre>

3

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"

90 IF T=128 THEN N$=N$+"$": REM STRING

100 L=PEEK(AT+6): REM FIRST INDEX SIZE

 

{{Out}}

 

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

DIM fruta$(2)

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

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

END

 

{{out}}

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.

 

DIM fruit$(2)

MAT READ fruit$

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

END

 

 

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

 

set /a arraylength+=1

goto loop

{{in}}

<pre>

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

{{works with|BBC BASIC for Windows}}

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

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

PRINT "Number of bytes in all elements combined = "; SUMLEN(array$())

{{Out}}

 

 

=={{header|Brat}}==

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

 

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

 

return 0;

}

 

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

 

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

 

Note that these arrays become pointers when passed as a parameter to a function.

</p>

====Solution====

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

 

 

return EXIT_SUCCESS;

{{output}}

<pre>There are 2 elements in an array with a capacity of 10 elements:

 

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

 

 

return 0;

<p>

As we can see the ''sizeof(ArrayType)/sizeof(ElementType)'' approach mostly fail.

=={{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" };

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

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

 

A shorter variant could also have been used:

 

using static System.Console;

 

}

}

 

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

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

 

#include <iostream>

#include <string>

std::cout << fruit.size();

return 0;

 

Note that <code>char*</code> or <code>const char*</code> could have been used instead of <code>std::string</code>.

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

 

Of these, vector is probably the most widely used.

 

=={{header|Ceylon}}==

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

print(array.size);

 

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

 

* nizchka: March - 2016

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

? LEN(FRUIT)

RETURN

Outputs:<pre>2</pre>

[[User:nizchka|nizchka]] 23:27, 16 March 2016 (UTC)

=={{header|Clojure}}==

 

(count ["apple" "orange"])

 

; OR alength if using Java arrays:

 

=={{header|COBOL}}==

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.

 

.

 

{{out}}

<pre>$ cobc -xjd array-length.cob

=={{header|ColdFusion}}==

 

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

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

Outputs:<pre>Array Length = 2</pre>

[[User:grandnegus|Mike Knapp]] 15:57, 26 May 2016 (UTC)

 

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

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

===Alternate solution===

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

 

;; Project : Array length

 

(length my-array)

(terpri)

Output:

<pre>

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

{{works with|BlackBox Component Builder}}

MODULE AryLen;

IMPORT StdLog;

 

END AryLen.

Execute: ^Q AryLen.Do

{{out}}

=={{header|Crystal}}==

 

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

 

{{out}}

 

=={{header|D}}==

import std.stdio;

 

return 0;

}

 

Or a somewhat shorter...

import std.stdio;

 

["apple", "orange"].length.writeln;

}

 

=={{header|Dart}}==

arrLength(arr) {

return arr.length;

}

 

 

=={{header|DataWeave}}==

sizeOf(arr)

 

=={{header|Delphi}}==

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

 

=={{header|Diego}}==

 

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

{{out}}

 

=={{header|Dragon}}==

 

a = ["apple","orange"]

 

show b

 

=={{header|Dyalect}}==

 

 

=={{header|EasyLang}}==

<lang>fruit$[] = [ "apples" "oranges" ]

 

=={{header|EchoLisp}}==

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

→ 2

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

→ 2

 

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

|> Basics.toString

|> Html.text

 

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

 

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

 

=={{header|Erlang}}==

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

2

1> tuple_size({"apple", "orange"}). %using a tuple

2

 

 

=={{header|Euphoria}}==

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

 

1 -- 2.95 is an atomic value

 

 

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

Or:

 

=={{header|Factor}}==

{ "apple" "orange" } length

 

=={{header|Forth}}==

REPEAT

DROP

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

WRITE (6,*) "L. bound",LBOUND(ARRAY),", U. bound",UBOUND(ARRAY)

END

 

Output:

 

=={{header|FreeBASIC}}==

 

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

Print

Print "Press any key to quit the program"

 

{{out}}

 

=={{header|Frink}}==

a = ["apple", "orange"]

println[length[a]]

 

=={{header|FurryScript}}==

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

COUNT_STEP[ DR 1 SU ]

 

 

=={{header|Futhark}}==

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]

 

=={{header|FutureBasic}}==

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

window 1

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

HandleEvents

{{out}}

<pre>

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

 

Print siList.Count

 

Output:

<pre>

 

=={{header|Genie}}==

/* Array length, in Genie */

init

arr:array of string = {"apple", "orange"}

stdout.printf("%d ", arr.length)

 

{{out}}

=={{header|Go}}==

 

 

import "fmt"

 

fmt.Printf("Length of %v is %v.\n", arr, len(arr))

 

 

=={{header|Groovy}}==

 

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

println fruits.size()

 

=={{header|Harbour}}==

 

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

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

 

=={{header|Haskell}}==

 

 

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

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'

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

apple

orange

2 6

#>'apple';'orange'

And, here's an array with no dimensions:

<lang> 9001

1

$9001

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

#$9001

0

1

#$>'apple';'orange'

 

=={{header|Janet}}==

 

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

(length our-array)

 

{{out}}

 

=={{header|Java}}==

public static void main(String[] args) {

System.out.println(new String[]{"apple", "orange"}.length);

}

 

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

 

using length has the disadvantage that it leaves ''last'' simply undefined for an empty list.

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;

}, null);

 

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;

 

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;

 

=={{header|jq}}==

 

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

 

{{out}}

=={{header|Julia}}==

 

a = ["apple","orange"]

length(a)

 

=={{header|Klingphix}}==

 

( "apple" "orange" ) len print

 

{{out}}

<pre>2</pre>

=={{header|Klong}}==

 

#["apple" "orange"]

 

=={{header|Kotlin}}==

 

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

 

=={{header|Lambdatalk}}==

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

-> 3

 

=={{header|Latitude}}==

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"

print ")"

end sub

{{out}}

<pre>

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"

print [count $a]

 

{{out}}

 

=={{header|Limbo}}==

 

include "sys.m";

a := array[] of {"apple", "orange"};

sys->print("length of a: %d\n", len a);

 

=={{header|Lingo}}==

put fruits.count

 

=={{header|Little}}==

 

=={{header|LiveCode}}==

 

split fruit using comma

 

=={{header|Lua}}==

fruits = {"apple", "orange"}

print(#fruits)

end

 

{{out}}

<pre>

 

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

\\ A is a pointer to array

A=("Apple", "Orange")

Dim K(1,1,1,1,1,1) ' Maximum 10 dimensions

Print Len(K()=1 ' True

 

=={{header|Maple}}==

{{out}}

<pre>

 

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

BEGIN

IO.PutInt(NUMBER(Arr));

 

=={{header|Mercury}}==

:- interface.

 

main(!IO) :-

Array = array(["apples", "oranges"]),

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

 

=={{header|MiniScript}}==

fruits = ["apple", "orange"]

print fruits.len

=={{header|MiniZinc}}==

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

var int: size = length(arr);

 

output [show(size),"\n"];

 

=={{header|Nanoquery}}==

fruit[0] = "apple"

fruit[1] = "orange"

println len(fruit)

 

 

=={{header|Neko}}==

 

 

=={{header|NewLISP}}==

 

; Nehal-Singhal 2018-05-25

 

=={{header|NGS}}==

# same

 

=={{header|Nim}}==

 

{{out}}

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

{{works with|oo2c}}

MODULE ArrayLength;

IMPORT

Out.String("length: ");Out.Int(Length(a),0);Out.Ln

END ArrayLength.

{{out}}

<pre>

 

=={{header|Objeck}}==

class Test {

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

fruit->Size()->PrintLine();

}

 

=={{header|OCaml}}==

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

 

=={{header|Oforth}}==

 

=={{header|Ol}}==

All of these methods are equivalent.

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

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

 

(print (size #("apple" "orange")))

 

=={{header|Onyx}}==

 

 

=={{header|ooRexx}}==

/* REXX */

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

say e

End

{{out}}

<pre>2 elements

 

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

length(array) \\ == 2

 

The <code>#</code> syntax is a handy shorthand. It usually looks best just on variables but it works on expressions too, possibly with parens to control precedence.

{{works with|Free Pascal|2.6.2}}

 

#!/usr/bin/instantfpc

//program ArrayLength;

WriteLn('Length of Fruits by bounds : ', High(Fruits) - Low(Fruits) + 1);

END.

 

{{out}}

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

 

 

scalar @array; # 5

takes_a_scalar @array;

 

 

A common mistake is to use <code>length</code> which works on strings not arrays.

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

 

length @array; # 1

 

print 'the length of @array is on the order of ';

print 10 ** (length( @array )-1); # 100

 

=={{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;">)

{{out}}

<pre>

 

=={{header|Phixmonti}}==

With syntactic sugar

{{out}}

<pre>

=={{header|PHP}}==

 

 

=={{header|Picat}}==

println(length(L)),

println(L.len),

 

{{out}}

 

=={{header|PicoLisp}}==

-> 2

 

=={{header|Pike}}==

{

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

write("%d\n", sizeof(fruit));

 

{{out}}

 

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

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

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

(Skip,a,f(2),a);

Put Skip Data(a);

{{out}}

<pre>

 

=={{header|Plorth}}==

 

=={{header|Pony}}==

actor Main

new create(env:Env)=>

c.push("orange")

env.out.print("Array c is " + c.size().string() + " elements long!")

 

=={{header|Potion}}==

 

=={{header|PowerShell}}==

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

$Array.Count

{{out}}

<pre>

 

=={{header|Processing}}==

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

void setup(){

println(arr.length);

}

{{out}}

<pre>

 

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

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

 

def setup():

println(len(arr))

 

{{out}}

 

=={{header|Prolog}}==

 

X = 2

 

 

=={{header|PureBasic}}==

EnableExplicit

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

CloseConsole()

EndIf

{{out}}

<pre>

 

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"

fruit$(1) = "orange"

Debug ArraySize(fruit$()) + 1 ;the number of elements is equal to the size + 1. For example: Dim a(2) contains 3 elements from a(0) to a(2) for a size of 2.

{{out}}

<pre>

 

=={{header|Python}}==

2

 

=={{header|QB64}}==

 

Dim max As Integer, Index As Integer

Randomize Timer

Print UBound(Stringar)

End

=={{header|Quackery}}==

 

 

{{out}}

 

=={{header|R}}==

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

length(a)

{{out}}

<pre>

=={{header|Racket}}==

{{trans|EchoLisp}}

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

{{out}}

<pre>2

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

 

say + @array; # 2

say @array + 0; # 2

 

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

 

 

say @infinite[5000]; # 5001

say @infinite.elems; # Throws exception "Cannot .elems a lazy list"

 

=={{header|Rapira}}==

 

=={{header|Red}}==

 

=={{header|Relation}}==

relation fruit

insert "apples"

project fruit count

print

 

{| border=1

 

=={{header|ReScript}}==

 

 

<html>

<head>

 

</body>

{{out}}

<pre>// Generated by ReScript, PLEASE EDIT WITH CARE

 

=={{header|REXX}}==

* The compond variable a. implements an array

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

a.z=arg(1)

a.0=z

{{out}}

<pre>There are 2 elements in the array:

=={{header|Ring}}==

 

 

=={{header|Robotic}}==

 

Example 1:

set "index" to 0

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

set "$array&index&" to "orange"

* "Array length: ('index' + 1)"

 

Example 2:

set "index" to 0

set "local1" to random 1 to 99

if "local1" > 1 then "rand"

* "Array length: ('index')"

 

=={{header|Ruby}}==

 

 

=={{header|Rust}}==

By default arrays are immutable in rust.

 

fn main() {

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

println!("the array has {} elements", array.len());

}

 

=={{header|Scala}}==

 

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

 

=={{header|Scheme}}==

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

 

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

 

=={{header|Seed7}}==

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

begin

writeln(length(anArray));

 

=={{header|SenseTalk}}==

 

=={{header|Shen}}==

\\ Using a vector

\\ @v creates the vector

\\ As an list

(length [apple orange])

 

=={{header|Sidef}}==

say arr.len; #=> 2

 

=={{header|Simula}}==

BEGIN

 

OUTIMAGE;

END

{{out}}

<pre>

 

=={{header|Smalltalk}}==

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

 

=={{header|SNOBOL4}}==

ar<1,1> = 'apple'

ar<1,2> = 'first'

ar<2,2> = 'second'

OUTPUT = IDENT(DATATYPE(ar), 'ARRAY') PROTOTYPE(ar)

{{out}}<pre>2,2</pre>

 

=={{header|SPL}}==

{{out}}

<pre>

=={{header|SQL}}==

 

 

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

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

in

Array.length a

 

=={{header|Stata}}==

 

=== Dimensions of a dataset ===

input str10 fruit

apple

 

di _N

 

=== Length of a macro list ===

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'

 

=== Mata ===

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

 

a=st_sdata(.,"fruit")

rows(a)

cols(a)

length(a)

 

=={{header|Swift}}==

 

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

 

{{out}}<pre>2</pre>

 

=={{header|Symsyn}}==

| Symsyn does not support Array of Strings

| The following code for an Array of Integers

sz []

| shows 2

 

=={{header|Tailspin}}==

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

{{out}}

<pre>2</pre>

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

 

set mylistA {apple orange} ;# actually a string

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

set lenB [llength $mylistB]

puts "$mylistB : $lenB"

 

{{out}}

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

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

{{out}}

<pre>

 

=={{header|Transd}}==

 

MainModule : {

(lout (size ["apple", "orange"]))

)

<pre>

2

 

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

array=("orange" "apple")

{{out}}

<pre>

 

=={{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" };

string[] fruit = { "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

 

'call the function

 

{{Out}}

 

=={{header|VBScript}}==

 

{{Out}}

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

Debug.Print LengthOfArray(arr) ' prints 2 as result

 

 

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

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

 

Sub Main()

 

End Module

 

{{out}}

=={{header|Vlang}}==

A '''len''' property is maintained for all V arrays.

// Tectonics: v run array-length.v

module main

arr := ["apple", "orange"]

println(arr.len)

 

{{out}}<pre>prompt$ v run array-length.v

 

=={{header|WDTE}}==

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

 

=={{header|Wren}}==

 

{{out}}

 

=={{header|XLISP}}==

 

 

=={{header|Yabasic}}==

dim fruta$(3)

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

print fruta$(2)

end

<pre>

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

byte "Apple",0

Orange:

 

{{out}}

=={{header|zkl}}==

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

 

=={{header|Zig}}==

 

pub fn main() !void {

// slices and arrays have an len field

try stdout_wr.print("fruit.len = {d}\n", .{fruit.len});

 

=={{header|Zoea}}==

program: array_length

input: [a,b,c]

output: 3

 

=={{header|Zoea Visual}}==

 

=={{header|zonnon}}==

module AryLength;

type

writeln(len(b,1):4) (* second dimension *)

end AryLength.