Porovnání programovacích jazyků (pole) - Comparison of programming languages (array)
![]() | tento článek používá Značky HTML.Února 2019) ( |
Tento srovnání programovacích jazyků (pole) porovnává vlastnosti datové struktury pole nebo matice zpracování pro více než 48 různých počítačů programovací jazyky.
Syntax
Rozměry pole
Následující seznam obsahuje syntax příklady, jak určit rozměry (index prvního prvku, posledního prvku nebo velikosti v prvcích).
Zvláště si všimněte, že některé jazyky indexují od nuly, zatímco jiné indexují od jednoho. Alespoň od slavné eseje Dijkstra,[1] indexování založené na nule bylo považováno za lepší a nové jazyky jej obvykle používají.
Jazyky | Velikost | za prvé | Poslední |
---|---|---|---|
Ada | název'Délka | název'Za prvé | název'Poslední |
ALGOL 68 | UPB název - LWB název+1 2 UPB název - 2 LWB název+1 atd. | LWB název 2 LWB název atd. | UPB název 2 UPB název |
APL | ⍴ název (⍴ název)[index] | ⎕IO | (⍴ název) - ~ ⎕IO (⍴ název)[index] - ~ ⎕IO |
AWK | délka | 1 | asorti |
C#, Visual Basic .NET, Windows PowerShell, F# | název.Délka | název.GetLowerBound (dimenze) | název.GetUpperBound (dimenze) |
CFML | arrayLen (název) název.len () | 1 | název.len () |
Ch | max (tvar (název)) | 0 | max (tvar (název))-1 |
Společný Lisp | (délka název) | 0 | (1- (délka název)) |
D | název.délka | 0 | název.délka-1 $-1 |
Fortran | VELIKOST(název) | LBOUND (název) | UBOUND (název) |
Jít | len (název) | 0 | len (název) - 1 |
Haskell | rangeSize (hranice název) | fst (hranice název) | snd (hranice název) |
ISLISP | (délka název) | 0 | (1- (délka název)) |
Kobra, D, Haxe, Jáva, JavaScript, Scala | název.délka | 0 | název.délka - 1 |
J | #název | 0 | <:@#název |
Julie | délka(název) velikost(název) | 1 první. (osy (název)) | konec poslední. (osy (název)) |
Žargon | počet(název) | 1 | getLast (název) |
LiveCode | délka(název) | 1 za prvé | -1 poslední |
Lua | #název | 1 podle konvence; jakékoli celé číslo[2] | #název |
Mathematica | Délka[název] | 1 Za prvé[název] | -1 Poslední[název] |
MATLAB, GNU oktáva | délka(název) | 1 | konec |
Nim | název.len | název.nízký[3] | název.vysoký |
Oberon | LEN (název) | 0 | LEN (název) - 1 |
Objekt Pascal | Délka(název) | 0 nízký(název) | Délka(název)-1 vysoký(název) |
Cíl-C (NSArray * pouze) | [název počet] | 0 | [název počet] - 1 |
OCaml | Délka pole název | 0 | Délka pole název - 1 |
Perl | skalární(@název) | $[ | $#název |
PHP | počet($název) | 0 | počet($název) - 1 |
Krajta | len (název) | 0 | -1 len (název) - 1 |
R | délka(název) | 1 | délka(název) |
Raku | @název.elems | 0 | @název.konec |
Červené | délka? název | název/1 za prvé název | poslední název |
Rubín | název.velikost | 0 název.za prvé | -1 název. velikost - 1 název.poslední |
Rez | název.len () | 0 | název.len () - 1 |
Slang | délka(název) | 0 | -1 délka(název)-1 |
Systém | (délka vektoru vektor) | 0 | (- (délka vektoru vektor) 1) |
Pokec | název velikost | 1 název za prvé | název velikost název poslední |
Rychlý | název.počet | 0 | název.počet - 1 |
Visual Basic | UBound (název) -LBound (název)+1 | LBound (název) | UBound (název) |
Wolfram jazyk | Délka[název] | 1 Za prvé[název] | -1 Poslední[název] |
Xojo | UBound (název) | 0 | UBound (název) |
XPath /XQuery | počet ($název) | 1 | počet ($název) poslední() pole: velikost (název)[4] |
Indexování
Následující seznam obsahuje příklady syntaxe, jak získat přístup k jednomu prvku pole.
Formát | Jazyky |
---|---|
název[index] nebo jméno[index1, index2] atd. | ALGOL 58, ALGOL 60, ALGOL 68, AWK, Modula, Pascal, Objekt Pascal, C#, Slang[5] |
název[index] nebo jméno[index1; index2] atd. nebo index⌷název nebo index1 index2⌷jméno atd. | APL |
název[index] | ActionScript, C, CFML, Ch, Kobra, C ++, D, Jít, Haxe, Jáva, JavaScript, Julie, Žargon, Lua, Nim, Cíl-C (NSArray * ), Perl,[5] Krajta,[5] R, Rubín,[5] Rez, Rychlý |
$název[index] | Perl,[5] PHP, Windows PowerShell,[5] XPath /XQuery[4] |
@název[index] | Raku |
název(index) nebo jméno(index1, index2) atd. | Ada, ALGOL W, ZÁKLADNÍ, COBOL, Fortran, RPG, GNU oktáva, MATLAB, PL / I., Scala, Visual Basic, Visual Basic .NET, Xojo |
$název(index) | XPath /XQuery[4] |
název.(index) | OCaml |
název.[index] | F# |
jméno / index | Červené |
název ! index | Haskell |
$název ? index | XPath /XQuery[4] |
(ref. vektoru) index jmen) | Systém |
(aref index jmen) | Společný Lisp |
(elt index jmen) | ISLISP |
název[[index]] | Mathematica,[5] Wolfram jazyk |
název na:index | Pokec |
[název objectAtIndex:index] | Cíl-C (NSArray * pouze) |
index{název | J |
name.item (index) nebo name @ index[6] | Eiffelova |
Krájení
Následující seznam obsahuje příklady syntaxe toho, jak lze přistupovat k rozsahu prvku pole.
V následující tabulce:
- za prvé - index prvního prvku v řezu
- poslední - index posledního prvku ve výřezu
- konec - o jeden více než index posledního prvku v řezu
- len - délka řezu (= konec - první)
- krok - počet prvků pole v každém (výchozí 1)
Formát | Jazyky |
---|---|
název[za prvé:poslední] | ALGOL 68,[7] Julie |
název[za prvé+(⍳len) -⎕IO] | APL |
název[za prvé:konec:krok] | Krajta[8][9] |
název[za prvé:konec] | Jít |
název[za prvé..poslední] | Pascal, Objekt Pascal, Delphi, Nim |
$název[za prvé..poslední] | Windows PowerShell |
@název[za prvé..poslední] | Perl[10] |
název[za prvé..poslední] název[za prvé...konec] název[za prvé, len] | Rubín[9] |
kopírovat / přeskočit jméno první jméno | Červené |
název(za prvé..poslední) | Ada[7] |
název(za prvé:poslední) | Fortran,[7][8] GNU oktáva, MATLAB[7][10] |
název[[za prvé;;poslední;;krok]] | Mathematica,[7][8][9] Wolfram jazyk |
název[[za prvé:poslední]] | Slang[7][8][10] |
název.[za prvé..poslední] | F# |
název.plátek(za prvé, konec) | Haxe, JavaScript, Scala |
název.plátek(za prvé, len) | CFML |
array_slice (název, za prvé, len) | PHP[9] |
(podsekv jméno první konec) | Společný Lisp |
(podsekv jméno první konec) | ISLISP |
Array.sub jméno první len | OCaml |
[název subarrayWithRange: NSMakeRange (za prvé, len)] | Cíl-C (NSArray * pouze) |
(za prvé([+ i. @ (- ~)konec){název | J |
název[za prvé..<konec] název[za prvé...poslední] | Rychlý |
název copyFrom: za prvé na:poslední název copyFrom: za prvé počet:len | Pokec |
název[za prvé..konec] | D, C#[11][12] |
název[za prvé..konec] název[za prvé..=poslední] | Rez |
název[za prvé:konec] | Kobra |
Seznam křížových odkazů systému Array
Programovací jazyk | Výchozí základní index | Specifikovaný typ indexu[13] | Specifikovatelný základní index | Vázaná kontrola | Vícerozměrný | Dynamicky velké | Vektorizované operace |
---|---|---|---|---|---|---|---|
Ada | typ indexu[14] | Ano | Ano | kontrolovány | Ano | inic[15] | některé, jiné definovatelné[16] |
ALGOL 68 | 1 | Ne[17] | Ano | liší se | Ano | Ano | uživatelsky definovatelný |
APL | 1 | ? | 0 nebo 1[18] | kontrolovány | Ano | Ano | Ano |
AWK | 1 | ano, implicitně | Ne | nezaškrtnuto | ano, jako oddělený řetězec | ano, proměněno | Ne |
ZÁKLADNÍ | 0 | ? | Ne | kontrolovány | Ne | inic[15] | ? |
C | 0 | Ne | Ne[19] | nezaškrtnuto | částečně | init,[15][20] halda[21] | Ne |
Ch | 0 | Ne | Ne | kontrolovány | ano, také pole pole[22] | init,[15][20] halda[21] | Ano |
C ++[16] | 0 | Ne | Ne[19] | nezaškrtnuto | ano, také pole pole[22] | halda[21] | Ne |
C# | 0 | Ne | částečný[23] | kontrolovány | Ano | halda[21][24] | Ano (LINQ vybrat) |
CFML | 1 | Ne | Ne | kontrolovány | ano, také pole pole[22] | Ano | Ne |
COBOL | 1 | Ne[25] | Ne | kontrolovány | pole pole[22][26] | Ne[27] | některé vnitřní |
Kobra | 0 | Ne | Ne | kontrolovány | pole pole[22] | halda | ? |
Společný Lisp | 0 | ? | Ne | kontrolovány[28] | Ano | Ano | ano (mapovat nebo mapovat do) |
D | 0 | Ano[29] | Ne | liší se[30] | Ano | Ano | ? |
F# | 0 | Ne | částečný[23] | kontrolovány | Ano | halda[21][24] | ano (mapa) |
FreeBASIC | 0 | Ne | Ano | kontrolovány | Ano | init,[15] inic[31] | ? |
Fortran | 1 | Ano | Ano | liší se[32] | Ano | Ano | Ano |
FoxPro | 1 | ? | Ne | kontrolovány | Ano | Ano | ? |
Jít | 0 | Ne | Ne | kontrolovány | pole pole[22] | Ne[33] | Ne |
Zaseknout | 0 | Ano | Ano | kontrolovány | Ano | Ano | Ano |
Haskell | 0 | Ano[34] | Ano | kontrolovány | ano, také pole pole[22] | inic[15] | ? |
IDL | 0 | ? | Ne | kontrolovány | Ano | Ano | Ano |
ISLISP | 0 | ? | Ne | kontrolovány | Ano | inic[15] | ano (mapa nebo mapa do) |
J | 0 | ? | Ne | kontrolovány | Ano | Ano | Ano |
Jáva[16] | 0 | Ne | Ne | kontrolovány | pole pole[22] | inic[15] | ? |
JavaScript | 0 | Ne | Ne | kontrolovány[35] | pole pole[22] | Ano | Ano |
Julie | 1 | Ano | Ano | kontrolovány | Ano | Ano | Ano |
Žargon | 1 | ? | ? | nezaškrtnuto | Ano | Ano | Ano |
Lua | 1 | ? | částečný[36] | kontrolovány | pole pole[22] | Ano | ? |
Mathematica | 1 | Ne | Ne | kontrolovány | Ano | Ano | Ano |
MATLAB | 1 | ? | Ne | kontrolovány | Ano[37] | Ano | Ano |
Nim | 0 | Ano[38] | Ano | volitelný[39] | pole pole[22] | Ano | Ano[40] |
Oberon | 0 | ? | Ne | kontrolovány | Ano | Ne | ? |
Oberon-2 | 0 | ? | Ne | kontrolovány | Ano | Ano | ? |
Cíl-C[16] | 0 | Ne | Ne | kontrolovány | pole pole[22] | Ano | Ne |
OCaml | 0 | Ne | Ne | ve výchozím nastavení zaškrtnuto | pole pole[22] | inic[15] | ? |
Pascal, Objekt Pascal | typ indexu[14] | Ano | Ano | liší se[41] | Ano | liší se[42] | nějaký |
Perl | 0 | Ne | Ano ($[ ) | kontrolovány[35] | pole pole[22] | Ano | Ne[43] |
Raku | 0 | Ne | Ne | kontrolovány[35] | Ano | Ano | Ano |
PHP | 0 | Ano[44] | Ano[44] | kontrolovány[44] | Ano | Ano | Ano |
PL / I. | 1 | ? | Ano | kontrolovány | Ano | Ne | ? |
Krajta | 0 | Ne | Ne | kontrolovány | pole pole[22] | Ano | Ne[45] |
RPG | 1 | Ne | Ne | ? | Ne | Ne | ? |
R | 1 | ? | ? | ? | ? | ? | ? |
Prsten | 1 | ? | částečný[36] | kontrolovány | pole pole[22] | Ano | ? |
Rubín | 0 | Ne | Ne | kontrolovány[35] | pole pole[22] | Ano | ? |
Rez | 0 | Ne | Ne | kontrolovány | Ano | ? | ? |
Sass | 1 | Ne | Ne | kontrolovány | pole pole[22] | inic[30] | ? |
Slang | 0 | ? | Ne | kontrolovány | Ano | Ano | Ano |
Scala | 0 | Ne | Ne | kontrolovány | pole pole[22] | inic[15] | ano (mapa) |
Systém | 0 | ? | Ne | kontrolovány | pole pole[22] | inic[15] | ano (mapa) |
Pokec[16] | 1 | ? | Ne | kontrolovány | pole pole[22] | Ano[46] | ? |
Rychlý | 0 | Ne | Ne | kontrolovány | pole pole[22] | Ano | ? |
Visual Basic | 0 | Ne | Ano | kontrolovány | Ano | Ano | ? |
Visual Basic .NET | 0 | Ne | částečný[23] | kontrolovány | Ano | Ano | Ano (LINQ vybrat) |
Wolfram jazyk | 1 | Ne | Ne | kontrolovány | Ano | Ano | Ano |
Windows PowerShell | 0 | Ne | Ne | kontrolovány | Ano | halda | ? |
Xojo | 0 | Ne | Ne | kontrolovány | Ano | Ano | Ne |
XPath /XQuery | 1 | Ne | Ne | kontrolovány | pole pole[4][22] | Ano | Ano |
Programovací jazyk | Výchozí základní index | Specifikovaný typ indexu[13] | Specifikovatelný základní index | Vázaná kontrola | Vícerozměrný | Dynamicky velké | Vektorizované operace |
Vektorizované operace s poli
Některé kompilované jazyky jako např Ada a Fortran a některé skriptovací jazyky, například IDL, MATLAB, a Slang, mají nativní podporu pro vektorizované operace na polích. Chcete-li například provést prvek po prvku součet dvou polí, A a b produkovat třetinu C, je třeba pouze psát
c = a + b
Kromě podpory vektorizovaných aritmetických a relačních operací tyto jazyky také vektorizují běžné matematické funkce, jako je sinus. Například pokud X je tedy pole
y = hřích (x)
bude mít za následek pole y jejichž prvky jsou sinusem odpovídajících prvků pole X.
Podporovány jsou také vektorizované operace indexu. Jako příklad,
dokonce = X(2::2); zvláštní = X(::2);
jak by se dalo použít Fortran k vytvoření polí z sudých a lichých záznamů pole. Dalším běžným použitím vektorizovaných indexů je operace filtrování. Zvažte ořezovou operaci sinusové vlny, kde mají být amplitudy větší než 0,5 nastaveny na 0,5. Použitím Slang, to lze provést pomocí
y = sin (x); y [kde (abs (y)> 0,5)] = 0,5;
Operace matematické matice
Jazyk/ Knihovna | Vytvořit | Rozhodující | Přemístit | Živel | Sloupec | Řádek | Vlastní čísla |
---|---|---|---|---|---|---|---|
APL | m ← dims⍴x11 x12 ... | -. × m | .M | m [i; j] nebo já j⌷m | m [; j] nebo j⌷ [2] m nebo j⌷⍉m | m [i;] nebo já | ⌹⍠1⊢m |
Fortran | m = RESHAPE ([x11, x12, ...], SHAPE (m)) | PŘEMÍSTIT | m (i, j) | m (:, j) | m (i, :) | ||
Ch [47] | m = {...} | určující | přemístit | m [i-1] [j-1] | tvar | tvar | vlastní |
Mathematica | m = {{x11, x12, ...}, ...} | Det [m] | Přemístit | m [[i, j]] | m [[;;, j]] | m [[i]] | Vlastní čísla |
MATLAB / GNU oktáva | m = [...] | det (m) | m. ' | m (i, j) | m (:, j) | m (i, :) | vlastní (m) |
NumPy | m = mat (...) | linalg.det (m) | m.T | m [i-1, j-1] | m [:, j-1] | m [i-1 ,:] | linalg.eigvals (m) |
Slang | m = přetvoření | m = transponovat | m [i, j] | m [*, j] | m [j, *] | ||
SymPy | m = Matice (...) | m.T | m [i-1, j-1] | ||||
Wolfram jazyk | m = {{x11, x12, ...}, ...} | Det [m] | Přemístit | m [[i, j]] | m [[;;, j]] | m [[i]] | Vlastní čísla |
Reference
- ^ https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html
- ^ https://www.lua.org/pil/11.1.html
- ^ https://nim-lang.org/docs/tut1.html#advanced-types-arrays
- ^ A b C d E XPath / XQuery má dva druhy polí. Sekvence (1,2,3) které nemohou vnořit a ve verzi XPath / XQuery 3.1 pole pole {1,2,3 } nebo [1,2,3] které mohou.
- ^ A b C d E F G Index může být záporné číslo označující odpovídající počet míst před koncem pole.
- ^ http://smarteiffel.loria.fr/libraries/api/lib.d/storage.d/loadpath.se.d/collection.d/ARRAY/ANY.html
- ^ A b C d E F Řezy pro vícerozměrná pole jsou také podporovány a definovány podobně.
- ^ A b C d Plátky typu
za prvé:poslední:krok
jsou také podporovány. - ^ A b C d poslední nebo konec může být záporné číslo, což znamená, že se zastaví na odpovídajícím počtu míst před koncem pole.
- ^ A b C Obecněji pro 1-d pole Perl a Slang povolit řezy formuláře
pole[indexy]
, kdeindexy
může to být rozsah uvedený v poznámce pod čarou 2 nebo explicitní seznam indexů, např. '[0,9,3,4]
'nebo směs obou, např.A [[[[0: 3]], 7,9, [11: 2: -3]]]]
. - ^ Funkce navržená v C # 8.0 (k 29. srpnu 2019[Aktualizace])
- ^ „Rozsahy - jazykové návrhy C # 8.0“. Dokumenty Microsoftu. Microsoft. Citováno 29. srpna 2019.
- ^ A b Typ indexu lze libovolně zvolit celočíselný typ, vyjmenovaný typ nebo typ postavy. Pro pole s nekompaktní typy indexů viz: Asociativní pole
- ^ A b Výchozí základní index je nejnižší hodnota použitého typu indexu
- ^ A b C d E F G h i j k Velikost lze vybrat pouze při inicializaci, po které je opravena
- ^ A b C d E Tento seznam striktně porovnává jazykové funkce. V každém jazyce (dokonce i v assembleru) je možné zajistit vylepšenou manipulaci s poli přidáním knihoven. Tento jazyk vylepšil práci s poli jako součást své standardní knihovny
- ^ Pole ALGOL 68 musí být indexována (a rozdělena) podle typu INT. K převodu jiných typů na však lze použít hashovací funkci INT. např. název[hash ("řetězec")]
- ^ Základna indexování může být 0 nebo 1 podle systémové proměnné ⎕IO. Tato hodnota může platit pro celý "pracovní prostor", nebo může být lokalizována do uživatelem definované funkce nebo jedné primitivní funkce pomocí operátoru Variant (⍠)
- ^ A b Protože C neomezuje indexy kontroly, lze definovat ukazatel na vnitřek libovolného pole, které bude symbolicky fungovat jako pseudo-pole, které pojme negativní indexy nebo jakýkoli počátek celočíselného indexu
- ^ A b C99 umožňuje pole proměnné velikosti; nicméně není k dispozici téměř žádný kompilátor pro podporu této nové funkce
- ^ A b C d E Velikost lze zvolit pouze při inicializaci, když je paměť přidělena na haldě, na rozdíl od okamžiku, kdy je přidělena na zásobníku. Tuto poznámku není třeba dělat pro jazyk, který vždy přiděluje pole na haldě
- ^ A b C d E F G h i j k l m n Ó p q r s t u proti w Umožňuje pole polí, která lze použít k emulaci většiny - ale ne všech - aspektů vícerozměrných polí
- ^ A b C Při inicializaci pomocí lze základnu změnit System.Array.CreateInstance (který se vrací System.Array), ale ne při použití jazykové syntaxe. Pole s nenulovými základními indexy nejsou stejného typu jako pole s nulovými základními indexy a nelze s nimi manipulovat pomocí syntaxe jazyka ( GetValue a SetValue místo toho musí být použity metody) nebo sklopeny na konkrétní typ (T [] v C #, nebo T () ve VB.NET), prevence rozbití kódu za předpokladu, že základní indexy budou nulové.
- ^ A b Umožňuje vytváření polí pevné velikosti v „nebezpečném“ kódu, což umožňuje vylepšené interoperabilita s jiným jazykem
- ^ Pole COBOL mohou být indexována s typy „INDEX“, odlišnými od celočíselných typů
- ^ Zatímco COBOL má pouze pole v poli, k prvkům pole lze přistupovat pomocí syntaxe podobné vícerozměrnému poli, kde jazyk automaticky spojuje indexy s poli uzavírající odkazovanou položku
- ^ COBOL poskytuje způsob, jak určit, že použitelná velikost pole je proměnná, ale nikdy to nemůže být větší než deklarovaná maximální velikost, což je také přidělená velikost
- ^ Většina běžných implementací Lisp umožňuje selektivně deaktivovat kontrolu
- ^ Asociativní pole - programovací jazyk D.
- ^ A b Chování lze vyladit pomocí přepínačů kompilátoru. Stejně jako v DMD jsou hranice 1,0 zkontrolovány v režimu ladění a nezaškrtnuty v režimu vydání kvůli efektivitě
- ^ FreeBASIC podporuje jak délky proměnných polí, tak pole pevné délky. Pole deklarovaná bez rozsahu indexu jsou vytvořena jako pole s proměnnou délkou, zatímco pole s deklarovaným rozsahem jsou vytvořena jako pole s pevnou délkou
- ^ Téměř všechny implementace Fortranu nabízejí možnosti kontroly hranic pomocí přepínačů kompilátoru. Ve výchozím nastavení je však kontrola hranice z důvodu efektivity obvykle vypnutá
- ^ Zatímco Golangův typ pole nemá dynamickou velikost, datový typ Plátek má dynamickou velikost a používá se mnohem častěji než pole.
- ^ Pole Haskell (Data.Array) umožňují použít jakýkoli typ, který je instancí Ix jako typ indexu. Takže vlastní typ lze definovat a použít jako typ indexu, pokud instancí Ix. Také n-tice typů Ix jsou také typy Ix; toto se běžně používá k implementaci vícerozměrných polí
- ^ A b C d V těchto jazycích lze přistupovat nebo zapisovat do indexu pole většího nebo rovného délce pole a pole implicitně naroste na tuto velikost. To se může na první pohled zdát, jako by hranice nebyly zaškrtnuty; hranice jsou však zkontrolovány, aby se rozhodlo zvětšit pole, a nemáte nebezpečný přístup do paměti jako v C
- ^ A b Zadáním základního indexu lze vytvořit pole na libovolném základě. Ve výchozím nastavení však Luaův operátor délky při výpočtu délky nezohledňuje základní index pole. Toto chování lze změnit pomocí metametod
- ^ Alespoň 2 rozměry (skalární čísla jsou 1 × 1 pole, vektory jsou 1 × n nebo n × 1 pole)
- ^ https://nim-lang.org/docs/tut1.html#advanced-types-arrays
- ^ https://nim-lang.org/docs/nimc.html
- ^ https://stackoverflow.com/questions/53084192/r-style-logical-vector-operation-in-nim
- ^ Mnoho implementací (Turbo Pascal, Object Pascal (Delphi), FreePascal) umožňuje změnu chování pomocí přepínačů kompilátoru a přímých směrnic
- ^ Liší se podle implementace. Novější implementace (FreePascal, Object Pascal (Delphi)) umožňují hromadná dynamická pole
- ^ Standard Perl datové typy pole nepodporují vektorizované operace, jak jsou zde definovány. Nicméně Datový jazyk Perl rozšíření přidává objekty pole s touto schopností
- ^ A b C „Pole“ PHP jsou asociativní pole. Jako klíče (indexy) můžete použít celá čísla a řetězce; plováky lze také použít jako klíč, ale jsou zkráceny na celá čísla. Ve skutečnosti neexistuje žádný „základní index“ nebo „hranice“
- ^ Standardní Krajta typ pole,
seznam
, nepodporuje vektorizované operace, jak jsou zde definovány. Nicméně numpy rozšíření přidává objekty pole s touto schopností - ^ Třída Array má pevnou velikost, ale OrderedCollection je dynamická
- ^ Ch numerické vlastnosti