Confronto tra linguaggi di programmazione (array) - Comparison of programming languages (array)
Questo confronto tra linguaggi di programmazione (array) mette a confronto le caratteristiche delle strutture di dati di array o l' elaborazione di matrici per oltre 48 diversi linguaggi di programmazione per computer .
Sintassi
Dimensioni dell'array
L'elenco seguente contiene esempi di sintassi su come determinare le dimensioni (indice del primo elemento, dell'ultimo elemento o dimensione in elementi).
Si noti in particolare che alcune lingue indicizzano da zero mentre altre indicizzano da uno. Almeno dal famoso saggio di Dijkstra , l'indicizzazione a base zero è stata considerata superiore e i nuovi linguaggi tendono a usarla.
| Le lingue | Taglia | Primo | Scorso |
|---|---|---|---|
| Ada | nome 'Lunghezza | nome 'Primo | nome 'Ultimo |
| ALGOL 68 |
UPB nome - LWB nome +1 2 UPB nome - 2 LWB nome +1 etc. |
Nome LWB 2 Nome LWB ecc. |
Nome UPB 2 Nome UPB |
| APL | ⍴ Nome (⍴ nome ) [ index ] |
IO |
(⍴ nome )-~⎕IO (⍴ nome )[ indice ]-~⎕IO |
| AWK | lunghezza | 1 | assortiti |
| C# , Visual Basic .NET , Windows PowerShell , F# | nome .Lunghezza | nome .GetLowerBound( dimensione ) | nome .GetUpperBound( dimensione ) |
| CFML |
arrayLen( nome ) nome .len() |
1 | nome .len() |
| Ch | max (forma ( nome )) | 0 | max (forma ( nome )) -1 |
| Lispa comune | ( nome lunghezza ) | 0 | (1- ( nome lunghezza )) |
| D | nome .lunghezza | 0 |
nome .lunghezza-1 $-1 |
| Fortran | TAGLIA ( nome ) | LBOUND ( nome ) | UBOUND ( nome ) |
| andare | len ( nome ) | 0 | len( nome ) - 1 |
| Haskell | rangeSize (limita il nome ) | fst ( nome dei limiti ) | snd ( nome dei limiti ) |
| ISLISP | ( nome lunghezza ) | 0 | (1- ( nome lunghezza )) |
| Cobra , D , Haxe , Java , JavaScript , Scala | nome .lunghezza | 0 | nome .lunghezza - 1 |
| J | # nome | 0 | <:@# nome |
| Giulia | lunghezza ( nome ) taglia ( nome ) |
1 prima. (assi ( nome )) |
fine ultimo.(assi( nome )) |
| Gergo | contare ( nome ) | 1 | getCognome( nome ) |
| Codice live | lunghezza ( nome ) |
1 prima |
-1 ultimo |
| Lua | # nome | 1 per convenzione; qualsiasi numero intero | # nome |
| matematica | Lunghezza[ nome ] |
1 Nome[ nome ] |
-1 Cognome[ nome ] |
| MATLAB , GNU Octave | lunghezza ( nome ) | 1 | fine |
| Nim | nome .len | nome .basso | nome .alto |
| Oberon | LEN( nome ) | 0 | LEN( nome ) - 1 |
| Oggetto Pascal | Lunghezza ( nome ) |
0 basso ( nome ) |
Lunghezza ( nome )-1 alta ( nome ) |
Obiettivo-C ( NSArray *solo)
|
[ conta nomi ] | 0 | [ conta nomi ] - 1 |
| OCaml | Nome array.lunghezza | 0 | Nome della lunghezza dell'array - 1 |
| Perla | scalare(@ nome ) | $[ | $# nome |
| PHP | contare ( nome ) | 0 | conteggio ( nome ) - 1 |
| Pitone | len ( nome ) | 0 |
-1 lunghezza ( nome ) - 1 |
| R | lunghezza ( nome ) | 1 | lunghezza ( nome ) |
| Raku | @ nome .elems | 0 | @ Nome .end |
| rosso | lunghezza? nome |
Nome / 1 primo nome |
ultimo nome |
| Rubino | nome .dimensione |
0 nome .first |
-1 nome .dimensione - 1 nome .cognome |
| Ruggine | nome .len() | 0 | nome .len() - 1 |
| Gergo | lunghezza ( nome ) | 0 |
-1 lunghezza ( nome ) -1 |
| schema | (vettore di lunghezza del vettore ) | 0 | (- (vettore di lunghezza del vettore ) 1) |
| chiacchiere | dimensione del nome |
1 nome prima |
nome dimensione nome cognome |
| Swift | nome. contare | 0 | nome. contare - 1 |
| Visual Basic | UBound( nome )-LBound( nome )+1 | LBound( nome ) | UBound( nome ) |
| Lingua di Wolfram | Lunghezza[ nome ] |
1 Nome[ nome ] |
-1 Cognome[ nome ] |
| Xojo | UBound( nome ) | 0 | UBound( nome ) |
| XPath / XQuery | conteggio($ nome ) | 1 |
count($ nome ) last() array:size( nome ) |
Indicizzazione
L'elenco seguente contiene esempi di sintassi su come accedere a un singolo elemento di un array.
| Formato | Le lingue |
|---|---|
| nome [ indice ] o nome [ indice 1 , indice 2 ] ecc. | ALGOL 58 , ALGOL 60 , ALGOL 68 , AWK , Modula , Pascal , Object Pascal , C# , S-Lang |
|
nome [ indice ] o nome [ indice 1 ; indice 2 ] ecc. o indice ⌷ nome o indice 1 indice 2 ⌷ nome ecc. |
APL |
| nome [ indice ] |
ActionScript , C , CFML , Ch , Cobra , C++ , D , Go , Haxe , Java , JavaScript , Julia , Lingo , Lua , Nim , Objective-C ( NSArray *), Perl , PHP , Python , R , Ruby , Rust , Swift
|
| $ nome [ indice ] | Perl , Windows PowerShell , XPath / XQuery |
| @ nome [ indice ] | Raku |
| nome ( indice ) o nome ( indice 1 , indice 2 ) ecc. | Ada , ALGOL W , BASIC , COBOL , Fortran , RPG , GNU Octave , MATLAB , PL/I , Scala , Visual Basic , Visual Basic .NET , Xojo |
| $ nome ( indice ) | XPath / XQuery |
| nome .( indice ) | OCaml |
| nome .[ indice ] | Fa# , OCaml |
| nome/indice | rosso |
| nome ! indice | Haskell |
| $ nome ? indice | XPath / XQuery |
| ( indice dei nomi di riferimento del vettore ) | schema |
| (ref indice dei nomi ) | Lispa comune |
| ( indice dei nomi elt ) | ISLISP |
| nome [[ indice ]] | Mathematica , Wolfram Language |
| nome su: index | chiacchiere |
| [ nome objectAtIndex: indice ] |
Obiettivo-C ( NSArray *solo)
|
| indice { nome | J |
| nome.oggetto(indice) o nome @ indice | Eiffel |
Affettare
L'elenco seguente contiene esempi di sintassi di come è possibile accedere a un intervallo di elementi di un array.
Nella tabella seguente:
- first - l'indice del primo elemento nella fetta
- last - l'indice dell'ultimo elemento nella fetta
- end - uno in più rispetto all'indice dell'ultimo elemento nella fetta
- len - la lunghezza della fetta (= fine - prima)
- step - il numero di elementi dell'array in ciascuno (predefinito 1)
| Formato | Le lingue |
|---|---|
| Nome [ prima : ultima ] | ALGOL 68 , Giulia |
| nome [ primo +(⍳ len )-⎕IO] | APL |
| nome [ first : end : step ] | Pitone |
| nome [ primo : fine ] | andare |
| Nome [ prima .. scorso ] | Pascal , Object Pascal , Delphi , Nim |
| $ nome [ primo .. ultimo ] | Windows PowerShell |
| @ Nome [ prima .. scorso ] | Perla |
|
Nome [ prima .. scorso ] nome [ prima ... fine ] nome [ primo , len ] |
Rubino |
| copia/salta parte nome prima lente | rosso |
| Nome ( prima .. scorso ) | Ada |
| Nome ( prima : ultima ) | Fortran , GNU Octave , MATLAB |
| nome [[ prima ;; ultimo ;; passo ]] | Mathematica , Wolfram Language |
| nome [[ prima : ultima ]] | Gergo |
| nome .[ primo .. passaggio .. ultimo ] | F# |
| nome .fetta ( prima , fine ) | Haxe , JavaScript , Scala |
| nome .slice( first , len ) | CFML |
| array_slice( nome , primo , len ) | PHP |
| ( nome secondario prima fine ) | Lispa comune |
| ( nome secondario prima fine ) | ISLISP |
| Array.sub nome prima lente | OCaml |
| [ nome sottoarrayWithRange:NSMakeRange( first , len )] |
Obiettivo-C ( NSArray *solo)
|
| ( primo ([+i.@(-~) fine ){ nome | J |
|
Nome [ prima .. < fine ] nome [ prima ... ultima ] |
Swift |
|
Nome CopyFrom: prima per: ultimo nome CopyFrom: primo conteggio: len |
chiacchiere |
| nome [ primo .. fine ] | RE , DO# |
|
nome [ primo .. fine ] nome [ primo ..= cognome ] |
Ruggine |
| nome [ primo : fine ] | Cobra |
Elenco di riferimenti incrociati del sistema di array
| Lingua |
Indice di base predefinito |
Specifiable tipo di indice |
Indice di base specificabile |
Assegno vincolato | Multidimensionale | Dimensioni dinamiche | Operazioni vettorizzate |
|---|---|---|---|---|---|---|---|
| Ada | tipo di indice | sì | sì | controllato | sì | dentro | alcuni, altri definibili |
| ALGOL 68 | 1 | no | sì | varia | sì | sì | definibile dall'utente |
| APL | 1 | ? | 0 o 1 | controllato | sì | sì | sì |
| AWK | 1 | si, implicitamente | no | deselezionato | si, come stringa delimitata | si, ripassato | no |
| DI BASE | 0 | ? | no | controllato | no | dentro | ? |
| C | 0 | no | no | deselezionato | parzialmente | init, mucchio | no |
| Ch | 0 | no | no | controllato | sì, anche array di array | init, mucchio | sì |
| C++ | 0 | no | no | deselezionato | sì, anche array di array | mucchio | no |
| C# | 0 | no | parziale | controllato | sì | mucchio | sì ( selezione LINQ ) |
| CFML | 1 | no | no | controllato | sì, anche array di array | sì | no |
| COBOL | 1 | no | no | controllato | array di array | no | alcuni intrinseci |
| Cobra | 0 | no | no | controllato | array di array | mucchio | ? |
| Lispa comune | 0 | ? | no | controllato | sì | sì | sì (mappa o mappa-in) |
| D | 0 | sì | no | varia | sì | sì | ? |
| F# | 0 | no | parziale | controllato | sì | mucchio | si (mappa) |
| BASIC | 0 | no | sì | controllato | sì | init, init | ? |
| Fortran | 1 | sì | sì | varia | sì | sì | sì |
| FoxPro | 1 | ? | no | controllato | sì | sì | ? |
| andare | 0 | no | no | controllato | array di array | no | no |
| Hack | 0 | sì | sì | controllato | sì | sì | sì |
| Haskell | 0 | sì | sì | controllato | sì, anche array di array | dentro | ? |
| IDL | 0 | ? | no | controllato | sì | sì | sì |
| ISLISP | 0 | ? | no | controllato | sì | dentro | sì (mappa o mappa-in) |
| J | 0 | ? | no | controllato | sì | sì | sì |
| Giava | 0 | no | no | controllato | array di array | dentro | ? |
| JavaScript | 0 | no | no | controllato | array di array | sì | sì |
| Giulia | 1 | sì | sì | controllato | sì | sì | sì |
| Gergo | 1 | ? | ? | deselezionato | sì | sì | sì |
| Lua | 1 | ? | parziale | controllato | array di array | sì | ? |
| matematica | 1 | no | no | controllato | sì | sì | sì |
| MATLAB | 1 | ? | no | controllato | sì | sì | sì |
| Nim | 0 | sì | sì | opzionale | array di array | sì | sì |
| Oberon | 0 | ? | no | controllato | sì | no | ? |
| Oberon-2 | 0 | ? | no | controllato | sì | sì | ? |
| Obiettivo-C | 0 | no | no | controllato | array di array | sì | no |
| OCaml | 0 | no | no | selezionato per impostazione predefinita | array di array | dentro | ? |
| Pascal , Oggetto Pascal | tipo di indice | sì | sì | varia | sì | varia | alcuni |
| Perla | 0 | no | si ( $[)
|
controllato | array di array | sì | no |
| Raku | 0 | no | no | controllato | sì | sì | sì |
| PHP | 0 | sì | sì | controllato | sì | sì | sì |
| PL/I | 1 | ? | sì | controllato | sì | no | ? |
| Pitone | 0 | no | no | controllato | array di array | sì | no |
| gioco di ruolo | 1 | no | no | ? | no | no | ? |
| R | 1 | ? | no | deselezionato | sì, anche array di array | sì | sì |
| Squillo | 1 | ? | parziale | controllato | array di array | sì | ? |
| Rubino | 0 | no | no | controllato | array di array | sì | ? |
| Ruggine | 0 | no | no | controllato | sì | ? | ? |
| Sass | 1 | no | no | controllato | array di array | dentro | ? |
| Gergo | 0 | ? | no | controllato | sì | sì | sì |
| Scala | 0 | no | no | controllato | array di array | dentro | si (mappa) |
| schema | 0 | ? | no | controllato | array di array | dentro | si (mappa) |
| chiacchiere | 1 | ? | no | controllato | array di array | sì | ? |
| Swift | 0 | no | no | controllato | array di array | sì | ? |
| Visual Basic | 0 | no | sì | controllato | sì | sì | ? |
| Visual Basic .NET | 0 | no | parziale | controllato | sì | sì | sì ( selezione LINQ ) |
| Lingua di Wolfram | 1 | no | no | controllato | sì | sì | sì |
| Windows PowerShell | 0 | no | no | controllato | sì | mucchio | ? |
| Xojo | 0 | no | no | controllato | sì | sì | no |
| XPath / XQuery | 1 | no | no | controllato | array di array | sì | sì |
Operazioni su array vettorizzati
Alcuni linguaggi compilati come Ada e Fortran e alcuni linguaggi di scripting come IDL , MATLAB e S-Lang hanno il supporto nativo per le operazioni vettorizzate sugli array. Ad esempio, per eseguire una somma elemento per elemento di due array, a e b per produrre un terzo c , è sufficiente scrivere
c = a + b
Oltre al supporto per operazioni aritmetiche e relazionali vettorizzate, questi linguaggi vettorializzano anche funzioni matematiche comuni come il seno. Ad esempio, se x è un array, allora
y = sin (x)
risulterà in un array y i cui elementi sono seno degli elementi corrispondenti dell'array x .
Sono supportate anche le operazioni sugli indici vettorizzati. Come esempio,
even = x(2::2);
odd = x(::2);
è come si userebbe Fortran per creare array dalle voci pari e dispari di un array. Un altro uso comune degli indici vettorizzati è un'operazione di filtraggio. Si consideri un'operazione di ritaglio di un'onda sinusoidale in cui le ampiezze maggiori di 0,5 devono essere impostate su 0,5. Usando S-Lang , questo può essere fatto da
y = sin(x); y[where(abs(y)>0.5)] = 0.5;
Operazioni con matrici matematiche
| Lingua/ Libreria |
Creare | determinante | Trasporre | Elemento | Colonna | Riga | autovalori |
|---|---|---|---|---|---|---|---|
| APL | m←dims⍴x11 x12 ... | -.×m | m | m[i;j] o ij⌷m | m[;j] o j⌷[2]m o j⌷⍤1⊢m o j⌷⍉m | m[i;] o i⌷m | 1⊢m |
| Fortran | m = RIFORMA([x11, x12, ...], FORMA(m)) |
TRASPOSIZIONE |
m(i,j) | m(:,j) | mi,:) | ||
| Ch | m = {... } |
determinante |
trasporre |
m[i-1][j-1] |
forma |
forma |
eigen |
|
Mathematica / Wolfram Language |
m = {{x11, x12, ...}, ... } | det[m] |
Trasposizione |
m[[i,j]] | m[[;;,j]] | mi]] |
Autovalori |
|
MATLAB / GNU Octave |
m = [...] | det(m) | m.' | m(i,j) | m(:,j) | mi,:) | eig(m) |
| NumPy | m = mat(...) | linalg.det(m) | mT | m[i-1,j-1] | m[:,j-1] | m[i-1,:] | linalg.eigvals(m) |
| Gergo |
m = rimodellare |
m = trasporre |
m[i,j] |
m[*,j] | m[j,*] | ||
| SymPy | m = matrice(...) | mT | m[i-1,j-1] |