Array length: Difference between revisions
Content deleted Content added
Deadmarshal (talk | contribs) Added Modula-3 |
Added OmniMark solution |
||
(45 intermediate revisions by 31 users not shown) | |||
Line 1:
[[Category:Simple]]
{{task}}
;Task:
Line 13:
=={{header|11l}}==
<
{{out}}
<pre>
Line 21:
=={{header|360 Assembly}}==
Array length is computed at compilation time with the formula : (AEND-A)/L'A
<
ARRAYLEN START
USING ARRAYLEN,12
Line 32:
AEND DC 0C
PG DC CL25'Array length=' buffer
END ARRAYLEN</
{{out}}
<pre>
Line 40:
{{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
Line 47:
byte "apple",0
byte "orange",0
Array_End:</
=={{header|68000 Assembly}}==
Array length is computed at compilation time with the formula: (Array_End-Array). The "bit width" of this value is the bit width of the result, not the bit width of the inputs. In other words, even though code labels are 32-bit memory addresses, if their difference is 8 or 16-bit you can use a <code>.B</code> or <code>.W</code> instruction or directive on them without a compile-time error.
The biggest limitation to the (Array_End-Array) method is that it always measures in total bytes. So if your array elements are of a different type you'll have to adjust accordingly. For an array strings, you should instead construct an array of pointers to strings and divide the result of the difference by 4 to get the total number of "strings" in the array.
<syntaxhighlight lang="68000devpac">start:
MOVE.B #(MyArray_End-MyArray)/4 ;evaluates to 2
RTS
Apple:
DC.B "apple",0
even
Orange:
DC.B "orange",0
even
MyArray:
DC.L Apple
DC.L Orange
MyArray_End:</syntaxhighlight>
=={{header|8th}}==
<
["apples", "oranges"] a:len . cr
</syntaxhighlight>
{{out}}
<pre>
Line 74 ⟶ 82:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program lenAreaString64.s */
Line 139 ⟶ 147:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{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.
<syntaxhighlight lang="abap">
report z_array_length.
Line 150 ⟶ 158:
write: internal_table[ 1 ] , internal_table[ 2 ] , lines( internal_table ).
</syntaxhighlight>
{{out}}
Line 159 ⟶ 167:
=={{header|Ada}}==
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
with System;
procedure Array_Length is
Fruits : constant array (Positive range <>) of access constant String
:= (new String'("orange"),
new String'("apple"));
Memory_Size : constant Integer := Fruits'Size / System.Storage_Unit;
begin
Put_Line ("Number of elements : " & Fruits'Length'Image);
Put_Line ("Array memory Size : " & Memory_Size'Image & " bytes" );
Put_Line (" " & Integer'Image (Memory_Size * System.Storage_Unit / System.Word_Size) & " words" );
end Array_Length;</syntaxhighlight>
{{out}}
<pre>
Number of elements : 2
Array memory Size : 32 bytes
4 words
</pre>
=={{header|ALGOL 68}}==
<
[]STRING fruits = ( "apple", "orange" );
print( ( ( UPB fruits - LWB fruits ) + 1, newline ) ) # prints 2 #</
=={{header|AntLang}}==
<
length[array]
/Works as a one liner: length[seq["apple"; "orange"]]</
=={{header|Apex}}==
<
=={{header|APL}}==
<syntaxhighlight lang
Output:
<pre>2</pre>
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">
set theList to {"apple", "orange"}
count theList
Line 203 ⟶ 218:
-- or
number of items in theList
</syntaxhighlight>
''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}}
Line 214 ⟶ 229:
<pre>fold (λx n -> 1 + n) 0</pre>
<
set xs to ["alpha", "beta", "gamma", "delta", "epsilon", ¬
Line 255 ⟶ 270:
end repeat
end fold
</syntaxhighlight>
{{Out}}
Line 263 ⟶ 278:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program lenAreaString.s */
Line 399 ⟶ 414:
.Ls_magic_number_10: .word 0x66666667
</syntaxhighlight>
=={{header|Arturo}}==
<
print ["array length =" size fruit]</
{{out}}
Line 412 ⟶ 427:
=={{header|ATS}}==
<syntaxhighlight lang="ats">
#include
"share/atspre_staload.hats"
Line 425 ⟶ 440:
implement main0((*void*)) = ((*void*))
</syntaxhighlight>
=={{header|AutoHotkey}}==
<
{{Out}}<pre>2</pre>
=={{header|AutoIt}}==
<
Local $aArray[2] = ["Apple", "Orange"]
Line 441 ⟶ 456:
ConsoleWrite("aArray[" & $i & "] = '" & $aArray[$i] & "'" & @CRLF)
Next
</syntaxhighlight>
{{Out}}
<pre>Elements in array: 2
Line 451 ⟶ 466:
Using Avail's tuples and the `|_|` method:
<
=={{header|AWK}}==
Line 460 ⟶ 475:
Another method to count the elements of the array is by using a variant of for().
<
#
function countElements(array) {
Line 474 ⟶ 489:
print "String length:", array[1], length(array[1])
}</
{{out}}
Line 484 ⟶ 499:
=={{header|BaCon}}==
BaCon knows three types of arrays, the UBOUND function can query all.
<
DECLARE fruit$[] = { "apple", "orange" }
Line 501 ⟶ 516:
meat$("first") = "chicken"
meat$("second") = "pork"
PRINT UBOUND(meat$)</
=={{header|Bash}}==
<
fruit=("apple" "orange" "lemon")
echo "${#fruit[@]}"</
=={{header|BASIC}}==
<
X$(1) = "apple"
X$(2) = "orange"
PRINT UBOUND(X$) - LBOUND(X$) + 1</
==={{header|Applesoft BASIC}}===
<
20 A$(1) = "ORANGE"
30 A$(2) = "APPLE"
Line 549 ⟶ 564:
170 L$ = L$ + STR$ ( FN P(I))
180 L$ = L$ + " ": NEXT I
190 RETURN</
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
fruta$ = {"apple", "orange", "pear"}
Line 559 ⟶ 574:
print fruta$[1]
end
</syntaxhighlight>
<pre>
3
Line 565 ⟶ 580:
orange
</pre>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
Unless modified with OPTION BASE 1 or MAT ORIGIN 1, the lower limit of an array is 1.
<syntaxhighlight lang="qbasic">10 dim fruta$(2)
20 read fruta$(0),fruta$(1),fruta$(2)
30 data "apple","orange","lemon"
40 print "The length of the array 'fruit$' is ";ubound(fruta$)+1
50 end</syntaxhighlight>
==={{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"
Line 579 ⟶ 603:
90 IF T=128 THEN N$=N$+"$": REM STRING
100 L=PEEK(AT+6): REM FIRST INDEX SIZE
110 PRINT N$" HAS"L"ELEMENTS."</
{{Out}}
<pre>A$ HAS 2 ELEMENTS.</pre>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 STRING X$(1 TO 2)
110 LET X$(1)="apple":LET X$(2)="orange"
120 PRINT "The length of the array 'X$' is";SIZE(X$)</syntaxhighlight>
==={{header|True BASIC}}===
<
READ fruta$(1), fruta$(2)
DATA "apple", "orange"
Line 593 ⟶ 621:
PRINT "La longitud del array fruta$ es" ; tamano
END</syntaxhighlight>
{{out}}
<pre> La longitud del array fruta$ es 2 </pre>
Line 602 ⟶ 628:
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.
<syntaxhighlight lang="qbasic">DIM fruit$(2)
MAT READ fruit$
DATA "apple", "orange"
PRINT "The length of the array 'fruit$' is "; SIZE(fruit$)
END</syntaxhighlight>
{{out}}
<pre> The length of the array 'fruit$' is 2 </pre>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Array length"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
DIM F$[2]
F$[0] = "apple"
F$[1] = "orange"
F$[2] = "pear"
PRINT "The length of the fruit array is "; UBOUND(F$[])
PRINT F$[1]
END FUNCTION
END PROGRAM</syntaxhighlight>
{{out}}
<pre>
orange</pre>
=={{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
Line 647 ⟶ 690:
set /a arraylength+=1
goto loop
</syntaxhighlight>
{{in}}
<pre>
Line 659 ⟶ 702:
=={{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$())
END</
{{Out}}
<pre>Number of elements in array = 2
Number of bytes in all elements combined = 11</pre>
=={{header|Beef}}==
<syntaxhighlight lang="csharp">using System;
namespace ArrayLength
{
class Program
{
public static void Main()
{
var array = new String[]("apple", "orange");
Console.WriteLine(array.Count);
delete(array);
}
}
}
</syntaxhighlight>
=={{header|Brat}}==
<
p ["apple", "orange"].length
</syntaxhighlight>
=={{header|Binary Lambda Calculus}}==
BLC has no arrays, so here's a function to compute the length of a given list (as a church numeral) instead, corresponding to https://github.com/tromp/AIT/blob/master/lists/length.lam :
<pre>010001101000000101100000000000011100101010111111110111111101111011010000010</pre>
=={{header|BQN}}==
<code>≠</code> gives the length of an array in BQN.
<
<syntaxhighlight lang
[https://mlochbaum.github.io/BQN/try.html#code=4omgIDHigL8iYSLigL8r Try It!]
Line 689 ⟶ 755:
For static arrays:
<syntaxhighlight lang="c">
#include <stdio.h>
Line 711 ⟶ 777:
return 0;
}
</syntaxhighlight>
A C pre-processor macro may be created for ease of use:
<syntaxhighlight lang="c">
#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0]))
</syntaxhighlight>
Note that these arrays become pointers when passed as a parameter to a function.
Line 736 ⟶ 802:
</p>
====Solution====
<
#define _CRT_NONSTDC_NO_WARNINGS // enable old-gold POSIX names in MSVS
Line 811 ⟶ 877:
return EXIT_SUCCESS;
}</
{{output}}
<pre>There are 2 elements in an array with a capacity of 10 elements:
Line 819 ⟶ 885:
====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
Line 930 ⟶ 996:
return 0;
}</
<p>
As we can see the ''sizeof(ArrayType)/sizeof(ElementType)'' approach mostly fail.
Line 997 ⟶ 1,063:
=={{header|C sharp|C#}}==
<
using System;
Line 1,008 ⟶ 1,074:
}
}
</syntaxhighlight>
Note that any of the following array declarations could be used:
<
var fruit = new[] { "apple", "orange" };
var fruit = new string[] { "apple", "orange" };
Line 1,018 ⟶ 1,084:
string[] fruit = new string[] { "apple", "orange" };
string[] fruit = { "apple", "orange" };
</syntaxhighlight>
A shorter variant could also have been used:
<
using static System.Console;
Line 1,032 ⟶ 1,098:
}
}
</syntaxhighlight>
=={{header|C++}}==
Line 1,040 ⟶ 1,106:
However, C++ has an additional <code>std::array</code> type (amongst other collections) in its standard library:
<
#include <iostream>
#include <string>
Line 1,049 ⟶ 1,115:
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>.
Line 1,055 ⟶ 1,121:
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" });
std::cout << fruitV.size() << fruitL.size() << fruitD.size() << std::endl;</
Of these, vector is probably the most widely used.
=={{header|Ceylon}}==
<
value array = ["apple", "orange"];
print(array.size);
}</
=={{header|Clipper/XBase++}}==
<syntaxhighlight lang="clipper/xbase++">/*
* nizchka: March - 2016
* This is a Clipper/XBase++ of RosettaCode Array_Length
Line 1,080 ⟶ 1,146:
? LEN(FRUIT)
RETURN
</syntaxhighlight>
Outputs:<pre>2</pre>
[[User:nizchka|nizchka]] 23:27, 16 March 2016 (UTC)
Line 1,086 ⟶ 1,152:
=={{header|Clojure}}==
<
(count ["apple" "orange"])
; OR alength if using Java arrays:
(alength (into-array ["apple" "orange"]))</
=={{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.
Line 1,134 ⟶ 1,200:
.
end program array-length.</
{{out}}
<pre>$ cobc -xjd array-length.cob
Line 1,143 ⟶ 1,209:
=={{header|ColdFusion}}==
<
<cfset testArray = ["apple","orange"]>
<cfoutput>Array Length = #ArrayLen(testArray)#</cfoutput>
</syntaxhighlight>
Outputs:<pre>Array Length = 2</pre>
[[User:grandnegus|Mike Knapp]] 15:57, 26 May 2016 (UTC)
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(print (length #("apple" "orange")))
</syntaxhighlight>
===Alternate solution===
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]
<
;; Project : Array length
Line 1,166 ⟶ 1,232:
(length my-array)
(terpri)
</syntaxhighlight>
Output:
<pre>
Line 1,174 ⟶ 1,240:
=={{header|Component Pascal}}==
{{works with|BlackBox Component Builder}}
<
MODULE AryLen;
IMPORT StdLog;
Line 1,207 ⟶ 1,273:
END AryLen.
</syntaxhighlight>
Execute: ^Q AryLen.Do
{{out}}
Line 1,216 ⟶ 1,282:
=={{header|Crystal}}==
<
puts ["apple", "orange"].size
</syntaxhighlight>
{{out}}
Line 1,226 ⟶ 1,292:
=={{header|D}}==
<syntaxhighlight lang="d">
import std.stdio;
Line 1,235 ⟶ 1,301:
return 0;
}
</syntaxhighlight>
Or a somewhat shorter...
<syntaxhighlight lang="d">
import std.stdio;
Line 1,245 ⟶ 1,311:
["apple", "orange"].length.writeln;
}
</syntaxhighlight>
=={{header|Dart}}==
<
arrLength(arr) {
return arr.length;
Line 1,258 ⟶ 1,324:
}
</syntaxhighlight>
=={{header|DataWeave}}==
<
sizeOf(arr)
</syntaxhighlight>
=={{header|Delphi}}==
<
showmessage( length(['a','b','c']).ToString );
</syntaxhighlight>
=={{header|Diego}}==
<
me_msg()_array()_values(apple,orange)_length();
reset_namespace[];</
{{out}}
Line 1,282 ⟶ 1,348:
=={{header|Dragon}}==
<
a = ["apple","orange"]
Line 1,288 ⟶ 1,354:
show b
</syntaxhighlight>
=={{header|
<syntaxhighlight lang="dt">[ "apple" "orange" ] len</syntaxhighlight>
=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">var xs = ["apple", "orange"]
print(xs.Length())</syntaxhighlight>
=={{header|EasyLang}}==
<syntaxhighlight lang="text">fruit$[] = [ "apples" "oranges" ]
print len fruit$[]</
=={{header|EchoLisp}}==
<
(length '("apple" "orange")) ;; list
→ 2
(vector-length #("apple" "orange")) ;; vector
→ 2
</syntaxhighlight>
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">String[] array = ["apple", "orange"];
Int length = array.size;</syntaxhighlight>
=={{header|Ela}}==
<syntaxhighlight lang
=={{header|Elena}}==
ELENA 5.0 :
<
var array := new string[]{"apple", "orange"};
var length := array.Length;
</syntaxhighlight>
=={{header|Elixir}}==
<
2
iex(2)> tuple_size( {"apple", "orange"} ) # Tuple
2</
=={{header|Elm}}==
<
import Array
import Html
Line 1,333 ⟶ 1,405:
|> Array.fromList
|> Array.length
|>
|> Html.text
</syntaxhighlight>
=={{header|Emacs Lisp}}==
<
=> 2</
<code>length</code> also accepts a list or a string.
=={{header|EMal}}==
<syntaxhighlight lang="emal">
writeLine(text["apple", "orange"].length)
</syntaxhighlight>
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
1> length(["apple", "orange"]). %using a list
2
1> tuple_size({"apple", "orange"}). %using a tuple
2
</syntaxhighlight>
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">
sequence s = {"apple","orange",2.95} -- Euphoria doesn't care what you put in a sequence
Line 1,373 ⟶ 1,450:
1 -- 2.95 is an atomic value
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<
Or:
<
=={{header|Factor}}==
<
{ "apple" "orange" } length
</syntaxhighlight>
=={{header|Fennel}}==
<syntaxhighlight lang="fennel">(length [:apple :orange])</syntaxhighlight>
=={{header|Forth}}==
Line 1,391 ⟶ 1,471:
The code is commented to explain what is going on for those unfamiliar with Forth.
<syntaxhighlight lang="forth">: STRING, ( caddr len -- ) \ Allocate space & compile string into memory
HERE OVER CHAR+ ALLOT PLACE ;
Line 1,417 ⟶ 1,497:
REPEAT
DROP
R> ; \ return counter to data stack </
Test code at Forth console
<
=={{header|Fortran}}==
Line 1,432 ⟶ 1,512:
For a simple example, the WRITE(6,*) suffices: write to standard output (the 6), in free-format (the *).
<syntaxhighlight lang="fortran">
MODULE EXAMPLE
CONTAINS
Line 1,453 ⟶ 1,533:
WRITE (6,*) "L. bound",LBOUND(ARRAY),", U. bound",UBOUND(ARRAY)
END
</syntaxhighlight>
Output:
Line 1,467 ⟶ 1,547:
=={{header|FreeBASIC}}==
<
Dim fruit(1) As String = {"apple", "orange"}
Line 1,474 ⟶ 1,554:
Print
Print "Press any key to quit the program"
Sleep</
{{out}}
Line 1,482 ⟶ 1,562:
=={{header|Frink}}==
<
a = ["apple", "orange"]
println[length[a]]
</syntaxhighlight>
=={{header|FurryScript}}==
<
COUNT[ 0 SW ~| COUNT_STEP# 0 SW SU ]
COUNT_STEP[ DR 1 SU ]
`THE_LIST COUNT# +<></
=={{header|Futhark}}==
Line 1,498 ⟶ 1,578:
The <code>shape</code> builtin returns the shape of an array as an array of integers. The length is element 0 of the shape:
<syntaxhighlight lang="futhark">
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>
We can also use FB's len() function to get the length of an array.
<syntaxhighlight lang="futurebasic">
void local fn DoIt
CFArrayRef array = @[@"apple",@"orange",@"cherry",@"grape",@"lemon"]
print len(array)
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
Line 1,516 ⟶ 1,609:
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Array_length}}
'''Solution'''
The cardinality expression reduces to the number of subexpressions the given expression has, including if the expressions is a list:
[[File:Fōrmulæ - Array length 01.png]]
[[File:Fōrmulæ - Array length 02.png]]
=={{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
End</
Output:
<pre>
Line 1,536 ⟶ 1,633:
=={{header|Genie}}==
<
/* Array length, in Genie */
init
arr:array of string = {"apple", "orange"}
stdout.printf("%d ", arr.length)
print arr[1]</
{{out}}
Line 1,550 ⟶ 1,647:
=={{header|Go}}==
<
import "fmt"
Line 1,558 ⟶ 1,655:
fmt.Printf("Length of %v is %v.\n", arr, len(arr))
}</
Line 1,568 ⟶ 1,665:
=={{header|Groovy}}==
<syntaxhighlight lang="groovy">
def fruits = ['apple','orange']
println fruits.size()
</syntaxhighlight>
=={{header|Harbour}}==
<
LOCAL aFruits := {"apple", "orange"}
Qout( Len( aFruits ) ) // --> 2
</syntaxhighlight>
=={{header|Haskell}}==
<
length ["apple", "orange"]</
=={{header|hexiscript}}==
<
let a[0] "apple"
let a[1] "orange"
println len a</
=={{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|Insitux}}==
<syntaxhighlight lang="insitux">(len ['apple' 'orange'])</syntaxhighlight>
=={{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</
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</
This might be a clearer concept with a few more examples. Here's an array with two dimensions:
<
apple
orange
Line 1,623 ⟶ 1,723:
2 6
#>'apple';'orange'
2</
And, here's an array with no dimensions:
<syntaxhighlight lang="text"> 9001
9001
#9001
1
$9001
</syntaxhighlight>
You can count the number of dimensions of an array (the length of the list of lengths) using <code>#$array</code>:
<syntaxhighlight lang="j">
#$9001
0
Line 1,638 ⟶ 1,738:
1
#$>'apple';'orange'
2</
=={{header|Janet}}==
<
(def our-array @["apple" "orange"])
(length our-array)
</syntaxhighlight>
{{out}}
Line 1,653 ⟶ 1,753:
=={{header|Java}}==
The resulting ''array'' object will have a ''length'' field.
<syntaxhighlight lang="java">
String[] strings = {
int length = strings.length;
</syntaxhighlight>
Additionally, you can do this in one line, if need be.
<syntaxhighlight lang="java">
int length = new String[] { "apple", "orange" }.length;
</syntaxhighlight>
=={{header|JavaScript}}==
<
However, determining the length of a list, array, or collection may simply be the wrong thing to do.
Line 1,667 ⟶ 1,771:
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.
Line 1,675 ⟶ 1,779:
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|
<syntaxhighlight lang="joy">["apple" "orange"] size.</syntaxhighlight>
{{out}}
<pre>2</pre>
=={{header|jq}}==
<syntaxhighlight lang="jq">["apple","orange"] | length</syntaxhighlight>
Output:
<syntaxhighlight lang
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);
puts(arr[1]);</
{{out}}
Line 1,714 ⟶ 1,822:
=={{header|Julia}}==
<syntaxhighlight lang="julia">
a = ["apple","orange"]
length(a)
</syntaxhighlight>
=={{header|K}}==
<syntaxhighlight lang="k">#("apple";"orange")</syntaxhighlight>
{{out}}
<pre>2</pre>
=={{header|Klingphix}}==
<
( "apple" "orange" ) len print
" " input</
{{out}}
<pre>2</pre>
Line 1,730 ⟶ 1,843:
=={{header|Klong}}==
<syntaxhighlight lang="k">
#["apple" "orange"]
</syntaxhighlight>
=={{header|Kotlin}}==
<
println(arrayOf("apple", "orange").size)
}</
=={{header|Lambdatalk}}==
<
{A.length {A.new 1 2 3}}
-> 3
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
&arr $= [apple, orange]
# Array length function
fn.println(fn.arrayLength(&arr))
# Length operator function
fn.println(fn.len(&arr))
# Length operator
fn.println(parser.op(@&arr))
</syntaxhighlight>
=={{header|Latitude}}==
Line 1,750 ⟶ 1,877:
In Latitude, <code>length</code> and <code>size</code> are synonymous and will both retrieve the size of a collection.
<
=={{header|LDPL}}==
<syntaxhighlight lang="ldpl">data:
fruits is text list
len is number
procedure:
push "apple" to fruits
push "orange" to fruits
get length of fruits in len
display len lf
</syntaxhighlight>
{{out}}
<pre>
2
</pre>
=={{header|Liberty BASIC}}==
Line 1,762 ⟶ 1,905:
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}}
<syntaxhighlight lang="lb">
FruitList$(0)="apple" 'assign 2 cells of a list array
FruitList$(1)="orange"
Line 1,874 ⟶ 2,017:
print ")"
end sub
</syntaxhighlight>
{{out}}
<pre>
Line 1,885 ⟶ 2,028:
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]
print [index $a 1]</
{{out}}
Line 1,897 ⟶ 2,040:
=={{header|Limbo}}==
<
include "sys.m";
Line 1,912 ⟶ 2,055:
a := array[] of {"apple", "orange"};
sys->print("length of a: %d\n", len a);
}</
=={{header|Lingo}}==
<
put fruits.count
-- 2</
=={{header|Little}}==
<
puts(length(fruit));</
=={{header|LiveCode}}==
<
split fruit using comma
answer the number of elements of fruit</
=={{header|Lua}}==
<
fruits = {"apple", "orange"}
print(#fruits)
Line 1,947 ⟶ 2,090:
end
print(size(fruits))</
{{out}}
<pre>
Line 1,956 ⟶ 2,099:
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
\\ A is a pointer to array
A=("Apple", "Orange")
Line 1,995 ⟶ 2,138:
Dim K(1,1,1,1,1,1) ' Maximum 10 dimensions
Print Len(K()=1 ' True
</syntaxhighlight>
=={{header|Maple}}==
<
numelems(a);</
{{out}}
<pre>
Line 2,007 ⟶ 2,150:
=={{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;
Line 2,024 ⟶ 2,167:
BEGIN
IO.PutInt(NUMBER(Arr));
END ArrayLength.</
=={{header|Mercury}}==
<
:- interface.
Line 2,039 ⟶ 2,182:
main(!IO) :-
Array = array(["apples", "oranges"]),
io.write_int(size(Array), !IO).</
=={{header|min}}==
{{works with|min|0.19.3}}
<
{{out}}
<pre>
Line 2,050 ⟶ 2,193:
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">
fruits = ["apple", "orange"]
print fruits.len
</syntaxhighlight>
=={{header|MiniZinc}}==
<syntaxhighlight lang="minizinc">
array[int] of int: arr = [1,2,3];
var int: size = length(arr);
Line 2,062 ⟶ 2,205:
output [show(size),"\n"];
</syntaxhighlight>
=={{header|Nanoquery}}==
<
fruit[0] = "apple"
fruit[1] = "orange"
println len(fruit)
// outputs 2</
=={{header|Neko}}==
<
$print($asize(fruit));</
=={{header|NewLISP}}==
<
; Nehal-Singhal 2018-05-25
(length '(apple orange))</
=={{header|NGS}}==
<
# same
echo(['apple', 'orange'].len())</
=={{header|Nim}}==
<
echo "The length of the fruit array is ", len(fruit)</
{{out}}
Line 2,096 ⟶ 2,239:
The length of the fruit array is 2
</pre>
=={{header|Nu}}==
<syntaxhighlight lang="nu">
[apple orange] | length
</syntaxhighlight>
{{out}}
<pre>
2
</pre>
=={{header|Nutt}}==
<syntaxhighlight lang="Nutt">
module main
imports native.io.output.say
say(#{"apple","orange"})
end
</syntaxhighlight>
=={{header|Oberon-2}}==
{{works with|oo2c}}
<
MODULE ArrayLength;
IMPORT
Line 2,131 ⟶ 2,293:
Out.String("length: ");Out.Int(Length(a),0);Out.Ln
END ArrayLength.
</syntaxhighlight>
{{out}}
<pre>
Line 2,138 ⟶ 2,300:
=={{header|Objeck}}==
<
class Test {
function : Main(args : String[]) ~ Nil {
Line 2,144 ⟶ 2,306:
fruit->Size()->PrintLine();
}
}</
=={{header|OCaml}}==
<syntaxhighlight lang="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")))
Line 2,162 ⟶ 2,324:
(print (size #("apple" "orange")))
</syntaxhighlight>
=={{header|OmniMark}}==
In OmniMark, From [https://developers.stilo.com/docs/html/concept/629.html OmniMark v12 documentation]:<br>
<big>"</big> <small>Most programming languages allow programmers to store and manipulate values in arrays, associative arrays, queues, and stacks. Instead, OmniMark provides a data container called a shelf: a shelf can be used to accomplish all of the tasks normally carried out by these various structures in other programming languages. Like arrays, shelves can be indexed by numeric values that reflect the position of the elements they contain or, like associative arrays, these elements can be given names (keys) and then indexed by those keys.</small> <big>"</big>
<syntaxhighlight lang="omnimark">
process
local stream s variable initial {"apple", "orange"}
local integer i initial {number of s}
put #main-output 'The number of fruit elements is %d(i).'
</syntaxhighlight>
'''Output:'''
<pre>
The number of fruit elements is 2.
</pre>
=={{header|Onyx}}==
<
=={{header|ooRexx}}==
<
/* REXX */
a = .array~of('apple','orange')
Line 2,176 ⟶ 2,354:
say e
End
Say "a[2]="a[2]</
{{out}}
<pre>2 elements
Line 2,184 ⟶ 2,362:
=={{header|PARI/GP}}==
<
length(array) \\ == 2
#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.
Line 2,196 ⟶ 2,374:
{{works with|Free Pascal|2.6.2}}
<syntaxhighlight lang="pascal">
#!/usr/bin/instantfpc
//program ArrayLength;
Line 2,211 ⟶ 2,389:
WriteLn('Length of Fruits by bounds : ', High(Fruits) - Low(Fruits) + 1);
END.
</syntaxhighlight>
{{out}}
Line 2,219 ⟶ 2,397:
Length of Fruits by bounds : 2
</pre>
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="pascal">
// Array length. Nigel Galloway: September 2nd., 2022
var n:array of string:=('apple','orange');
begin
writeln(Length(n));
end.
</syntaxhighlight>
{{out}}
<pre>
2
</pre>
Modern way:
<syntaxhighlight lang="pascal">
// Array length. Mikhalkovich Stanislav: May 16, 2024
##
var a := |'apple','orange'|;
a.Length.Print;
</syntaxhighlight>
{{out}}
<pre>
2
</pre>
Line 2,225 ⟶ 2,428:
The way to get the number of elements of an array in Perl is to put the array in scalar context.
<
scalar @array; # 5
Line 2,244 ⟶ 2,447:
takes_a_scalar @array;
# the built-ins can also act like they have prototypes</
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
Line 2,259 ⟶ 2,462:
print 'the length of @array is on the order of ';
print 10 ** (length( @array )-1); # 100
print " elements long\n";</
=={{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>
Line 2,273 ⟶ 2,476:
=={{header|Phixmonti}}==
<
With syntactic sugar
<
( "apple" "orange" ) len print</
{{out}}
<pre>
Line 2,284 ⟶ 2,487:
=={{header|PHP}}==
<
=={{header|Picat}}==
<syntaxhighlight lang="text">main =>
L = ["apple", "orange"],
println(len(L))),
println(length(L)),
println(L.len),
println(L.length).</
{{out}}
Line 2,302 ⟶ 2,505:
=={{header|PicoLisp}}==
<
-> 2
:</
=={{header|Pike}}==
<
{
array fruit = ({ "apple", "orange" });
write("%d\n", sizeof(fruit));
}</
{{out}}
Line 2,317 ⟶ 2,520:
=={{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);
End;</
{{out}}
<pre>
Line 2,329 ⟶ 2,532:
=={{header|Plorth}}==
<
=={{header|Pony}}==
<
actor Main
new create(env:Env)=>
Line 2,339 ⟶ 2,542:
c.push("orange")
env.out.print("Array c is " + c.size().string() + " elements long!")
</syntaxhighlight>
=={{header|Potion}}==
<
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
$Array = @( "Apple", "Orange" )
$Array.Count
$Array.Length</
{{out}}
<pre>
Line 2,355 ⟶ 2,558:
=={{header|Processing}}==
<syntaxhighlight lang="processing">
String[] arr = {"apple", "orange"};
void setup(){
println(arr.length);
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,367 ⟶ 2,570:
==={{header|Processing Python mode}}===
<
arr = ['apple', 'orange'] # a list for an array
def setup():
println(len(arr))
</syntaxhighlight>
{{out}}
Line 2,380 ⟶ 2,583:
=={{header|Prolog}}==
<
X = 2
yes</
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
EnableExplicit
Define Dim fruit$(1); defines array with 2 elements at indices 0 and 1
Line 2,400 ⟶ 2,603:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
<pre>
Line 2,407 ⟶ 2,610:
An abbreviated form of the above, not printing to console/terminal
<syntaxhighlight lang="purebasic">
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.
</syntaxhighlight>
{{out}}
<pre>
Line 2,419 ⟶ 2,622:
=={{header|Python}}==
<
2
>>> </
=={{header|QB64}}==
<syntaxhighlight lang="qb64">
Dim max As Integer, Index As Integer
Randomize Timer
Line 2,436 ⟶ 2,639:
Print UBound(Stringar)
End
</syntaxhighlight>
=={{header|Quackery}}==
<
{{out}}
Line 2,446 ⟶ 2,649:
=={{header|R}}==
<syntaxhighlight lang="r">
a <- c('apple','orange') # create a vector containing "apple" and "orange"
length(a)
</syntaxhighlight>
{{out}}
<pre>
Line 2,457 ⟶ 2,660:
=={{header|Racket}}==
{{trans|EchoLisp}}
<
(length '("apple" "orange")) ;; list
(vector-length #("apple" "orange")) ;; vector</
{{out}}
<pre>2
Line 2,470 ⟶ 2,673:
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.
<syntaxhighlight lang="raku" line>
my @array = <apple orange>;
Line 2,477 ⟶ 2,680:
say + @array; # 2
say @array + 0; # 2
</syntaxhighlight>
Watch out for infinite/lazy arrays though. You can't get the length of those.
<syntaxhighlight lang="raku"
say @infinite[5000]; # 5001
say @infinite.elems; # Throws exception "Cannot .elems a lazy list"
</syntaxhighlight>
=={{header|Rapira}}==
<syntaxhighlight lang="rapira">arr := <* "apple", "orange" *>
output: #arr</syntaxhighlight>
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">
>> length? ["apples" "oranges"]
== 2
</syntaxhighlight>
=={{header|Red}}==
<
== 2</
=={{header|Relation}}==
<syntaxhighlight lang="relation">
relation fruit
insert "apples"
Line 2,498 ⟶ 2,711:
project fruit count
print
</syntaxhighlight>
{| border=1
Line 2,508 ⟶ 2,721:
=={{header|ReScript}}==
<
Js.log(Js.Array.length(fruits))</
<
<html>
<head>
Line 2,525 ⟶ 2,738:
</body>
</html></
{{out}}
<pre>// Generated by ReScript, PLEASE EDIT WITH CARE
Line 2,542 ⟶ 2,755:
=={{header|REXX}}==
<
* The compond variable a. implements an array
* By convention, a.0 contains the number of elements
Line 2,558 ⟶ 2,771:
a.z=arg(1)
a.0=z
Return</
{{out}}
<pre>There are 2 elements in the array:
Line 2,566 ⟶ 2,779:
=={{header|Ring}}==
<
=={{header|Robotic}}==
Line 2,572 ⟶ 2,785:
Example 1:
<
set "index" to 0
set "$array&index&" to "apple"
Line 2,578 ⟶ 2,791:
set "$array&index&" to "orange"
* "Array length: ('index' + 1)"
</syntaxhighlight>
Example 2:
<
set "index" to 0
set "local1" to random 1 to 99
Line 2,590 ⟶ 2,803:
if "local1" > 1 then "rand"
* "Array length: ('index')"
</syntaxhighlight>
=={{header|RPL}}==
The <code>SIZE</code> instruction can be used for arrays (e.g. vectors) and lists. RPL arrays can only contain real or complex numbers, so we will use a list here.
{ "apple" "orange" } SIZE
{{out}}
<pre>
1: 2
</pre>
=={{header|Ruby}}==
<
=={{header|Rust}}==
Line 2,600 ⟶ 2,821:
By default arrays are immutable in rust.
<
fn main() {
let array = ["foo", "bar", "baz", "biff"];
println!("the array has {} elements", array.len());
}
</syntaxhighlight>
=={{header|S-BASIC}}==
Finding the size of an S-BASIC array at run-time is convoluted, to say the least, but it can be done. (It would also generally be pointless, since the size of an array is fixed - and thus presumably known - at compile time.) Each array has an associated data structure (referred to in the documentation as "SPEC") containing information such as the number of dimensions, the size of an array element, the size of each dimension, and so on. The address of the SPEC for an array can be obtained using the LOCATION statement. For a single-dimension array, the number of elements will be found five bytes into the structure, at a point described in the documentation as the "dope vector".
<syntaxhighlight lang = "BASIC">
dim string animals(2) rem here is our array
var array_struct_address = integer
based array_size = integer
animals(1) = "ardvark"
animals(2) = "bison"
location spec array_struct_address = animals
base array_size at array_struct_address + 5
print "Size of array ="; array_size
end
</syntaxhighlight>
{{out}}
<pre>
Size of array = 2
</pre>
=={{header|Scala}}==
<
println(Array("apple", "orange").length)
</syntaxhighlight>
=={{header|Scheme}}==
Line 2,617 ⟶ 2,860:
Using Scheme's vector type as an equivalent to an array:
<
(display (vector-length #("apple" "orange")))
</syntaxhighlight>
=={{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");
Line 2,631 ⟶ 2,874:
begin
writeln(length(anArray));
end func;</
=={{header|SenseTalk}}==
<
put the number of items in fruits</
=={{header|Shen}}==
<
\\ Using a vector
\\ @v creates the vector
Line 2,649 ⟶ 2,892:
\\ As an list
(length [apple orange])
</syntaxhighlight>
=={{header|Sidef}}==
<
say arr.len; #=> 2
say arr.end; #=> 1 (zero based)</
=={{header|Simula}}==
<
BEGIN
Line 2,673 ⟶ 2,916:
OUTIMAGE;
END
</syntaxhighlight>
{{out}}
<pre>
2
</pre>
=={{heaer|Slope}}==
<syntaxhighlight lang="slope">(length ["apple" "orange"])</syntaxhighlight>
=={{header|SmallBASIC}}==
<syntaxhighlight lang="SmallBASIC">
A = ["apple", "orange"]
print len(A)
</syntaxhighlight>
=={{header|Smalltalk}}==
<
a := #('apple' 'orange').
a size</
=={{header|SNOBOL4}}==
<
ar<1,1> = 'apple'
ar<1,2> = 'first'
Line 2,691 ⟶ 2,943:
ar<2,2> = 'second'
OUTPUT = IDENT(DATATYPE(ar), 'ARRAY') PROTOTYPE(ar)
end</
{{out}}<pre>2,2</pre>
=={{header|SPL}}==
<
#.output("Number of elements in array: ",#.size(a,1))</
{{out}}
<pre>
Line 2,704 ⟶ 2,956:
=={{header|SQL}}==
<
=={{header|Standard ML}}==
<
val a = Array.fromList ["apple", "orange"]
in
Array.length a
end;</
=={{header|Stata}}==
Line 2,717 ⟶ 2,969:
=== Dimensions of a dataset ===
<
input str10 fruit
apple
Line 2,724 ⟶ 2,976:
di _N
di c(N) " " c(k)</
=== Length of a macro list ===
Line 2,730 ⟶ 2,982:
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''</
=== 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)
end</
=={{header|Swift}}==
<
let fruitsCount = fruits.count // Declare constant array length (count)
print(fruitsCount) // Print array length to output window</
{{out}}<pre>2</pre>
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
| Symsyn does not support Array of Strings
| The following code for an Array of Integers
Line 2,767 ⟶ 3,019:
sz []
| shows 2
</syntaxhighlight>
=={{header|Tailspin}}==
<
['apple', 'orange'] -> $::length -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>2</pre>
Line 2,779 ⟶ 3,031:
<!-- http://ideone.com/uotEvm -->
<
set mylistA {apple orange} ;# actually a string
set mylistA "Apple Orange" ;# same - this works only for simple cases
Line 2,792 ⟶ 3,044:
set lenB [llength $mylistB]
puts "$mylistB : $lenB"
</syntaxhighlight>
{{out}}
Line 2,801 ⟶ 3,053:
{{works with|TI-83 2.55MP}}
Use function <code>dim()</code>.
<
dim(L1)</
{{out}}
<pre>
Line 2,809 ⟶ 3,061:
=={{header|Transd}}==
<
MainModule : {
Line 2,818 ⟶ 3,070:
(lout (size ["apple", "orange"]))
)
}</
<pre>
2
2
</pre>
=={{header|Uiua}}==
{{works with|Uiua|0.11.1}}
It would be more accurate to say this is the number of ''rows'' in an array.
<syntaxhighlight lang="uiua">
⧻{"apple" "orange"}
</syntaxhighlight>
{{out}}
<pre>
2
</pre>
=={{header|UNIX Shell}}==
<
array=("orange" "apple")
echo "${#array[@]}"</
{{out}}
<pre>
Line 2,843 ⟶ 3,106:
=={{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" };
</syntaxhighlight>
A shorter variant could also have been used:
<
void main() {
stdout.printf("%d\n", new string[] {"apples", "orange"}.length);
}
</syntaxhighlight>
=={{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
Line 2,876 ⟶ 3,139:
'call the function
Debug.Print "Array Length: " & SizeOfArray(funkyArray)</
{{Out}}
Line 2,883 ⟶ 3,146:
=={{header|VBScript}}==
<
WScript.StdOut.WriteLine UBound(arr) - LBound(arr) + 1 </
{{Out}}
Line 2,892 ⟶ 3,155:
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.
<syntaxhighlight lang="vb">
' declared in a module
Public Function LengthOfArray(ByRef arr As Variant) As Long
Line 2,919 ⟶ 3,182:
Debug.Print LengthOfArray(arr) ' prints 2 as result
</syntaxhighlight>
=={{header|Visual Basic .NET}}==
{{works with|Visual Basic .NET|9.0+}}
<
Sub Main()
Line 2,931 ⟶ 3,194:
End Module
</syntaxhighlight>
{{out}}
Line 2,938 ⟶ 3,201:
</pre>
=={{header|V (Vlang)}}==
A '''len''' property is maintained for all V (Vlang) arrays.
<
// Tectonics: v run array-length.v
module main
Line 2,948 ⟶ 3,211:
arr := ["apple", "orange"]
println(arr.len)
}</
{{out}}<pre>prompt$ v run array-length.v
Line 2,954 ⟶ 3,217:
=={{header|WDTE}}==
<
let a => ['apple'; 'orange'];
len a -- io.writeln io.stdout;</
=={{header|Wren}}==
<
System.print(arr.count)</
{{out}}
Line 2,968 ⟶ 3,231:
=={{header|XLISP}}==
<
=={{header|Yabasic}}==
<
dim fruta$(3)
read fruta$(1), fruta$(2), fruta$(3)
Line 2,980 ⟶ 3,243:
print fruta$(2)
end
</syntaxhighlight>
<pre>
3
Line 2,992 ⟶ 3,255:
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
Line 3,036 ⟶ 3,299:
byte "Apple",0
Orange:
byte "Orange",0</
{{out}}
Line 3,045 ⟶ 3,308:
=={{header|zkl}}==
zkl doesn't support arrays natively, use lists instead.
<
T("apple", "orange").len().println() //-->2, read only list (ROList) </
=={{header|Zig}}==
<
pub fn main() !void {
Line 3,057 ⟶ 3,320:
// slices and arrays have an len field
try stdout_wr.print("fruit.len = {d}\n", .{fruit.len});
}</
=={{header|Zoea}}==
<syntaxhighlight lang="zoea">
program: array_length
input: [a,b,c]
output: 3
</syntaxhighlight>
=={{header|Zoea Visual}}==
Line 3,070 ⟶ 3,333:
=={{header|zonnon}}==
<
module AryLength;
type
Line 3,085 ⟶ 3,348:
writeln(len(b,1):4) (* second dimension *)
end AryLength.
</syntaxhighlight>
|