---
title: Array
slug: Web/JavaScript/Reference/Global_Objects/Array
tags:
- Array
- JavaScript
- NeedsTranslation
- TopicStub
translation_of: Web/JavaScript/Reference/Global_Objects/Array
---
<div>{{JSRef}}</div>
<h2 id="Summary" name="Summary">Sommario</h2>
<p>L'oggetto <strong><code>Array </code></strong>di JavaScript è un oggetto globale che è utilizzato nella costruzione di array; che sono oggetti di alto-livello del tipo lista.</p>
<p><strong>Creare un Array</strong></p>
<pre class="brush: js">var fruits = ["Apple", "Banana"];
console.log(fruits.length);
// 2
</pre>
<p><strong>Accedere (index into) ad un Array item</strong></p>
<pre class="brush: js">var first = fruits[0];
// Apple
var last = fruits[fruits.length - 1];
// Banana
</pre>
<p><strong>Loop in un Array</strong></p>
<pre class="brush: js">fruits.forEach(function (item, index, array) {
console.log(item, index);
});
// Apple 0
// Banana 1
</pre>
<p><strong>Aggiungere alla fine di un Array</strong></p>
<pre class="brush: js">var newLength = fruits.push("Orange");
// ["Apple", "Banana", "Orange"]
</pre>
<p><strong>Rimuovere dalla fine di un Array</strong></p>
<pre class="brush: js">var last = fruits.pop(); // remove Orange (from the end)
// ["Apple", "Banana"];
</pre>
<p><strong>Rimuovere dall'inizio di un Array</strong></p>
<pre class="brush: js">var first = fruits.shift(); // remove Apple from the front
// ["Banana"];
</pre>
<p><strong>Aggiungere al'inizio di un Array</strong></p>
<pre class="brush: js">var newLength = fruits.unshift("Strawberry") // add to the front
// ["Strawberry", "Banana"];
</pre>
<p><strong>Trovare l'indice di un elemento nell'Array</strong></p>
<pre class="brush: js">fruits.push("Mango");
// ["Strawberry", "Banana", "Mango"]
var pos = fruits.indexOf("Banana");
// 1
</pre>
<p><strong>Rimuovere un elemento tramite la Posizione dell'Indice</strong></p>
<pre class="brush: js">var removedItem = fruits.splice(pos, 1); // this is how to remove an item
// ["Strawberry", "Mango"]
</pre>
<p><strong>Copiare un Array</strong></p>
<pre class="brush: js">var shallowCopy = fruits.slice(); // this is how to make a copy
// ["Strawberry", "Mango"]
</pre>
<h2 id="Sintassi">Sintassi</h2>
<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]])
new Array(<var>arrayLength</var>)</code></pre>
<dl>
<dt><code>element<em>N</em></code></dt>
<dd>Un array JavaScript è inizializzato con gli elementi dati, eccetto nel caso in cui un argomento singolo è passato al costruttore dell'<code>Array</code> e l'argomento è un numero. (Vedere sotto.) Notare che questo caso speciale si applica solo agli array JavaScript creati con il costruttore <code>Array</code>, non array literals creati con la sintassi a parentesi.</dd>
<dt><code>arrayLength</code></dt>
<dd>Se l'unico argomento passato al costruttore <code>Array</code> è un integer tra 0 e 2<sup>32</sup>-1 (inclusivo), questo restituisce un nuovo array JavaScript con la lunghezza settata su quel numero. Se l'argomento è un qualsiasi altro numero, un eccezione {{jsxref("Global_Objects/RangeError", "RangeError")}} è lanciata.</dd>
</dl>
<h2 id="Descrizione">Descrizione</h2>
<p>Gli Array sono come oggetti di tipo lista il cui prototipo ha metodi per performare operazioni trasversali e di mutazione. Nè la lunghezza di un array JavaScript o i tipi dei suoi elementi sono fissati. Poichè la grandezza della lunghezza di un array cresce o diminuisce in qualsiasi momento, gli array JavaScript non danno garanzia di essere compatti; questo dipende da come il programmatore sceglie di usarli. In generale, queste sono caratteristiche convenienti; ma se tali caratteristiche non fossero desiderabili per un utilizzo particolare, si potrebbe considerare di utilizzare i typed arrays.</p>
<p>Alcuni pensano che<a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/"> non si dovrebbe un utilizzare un array come un associative array</a>. In ogni caso, si può utilizzare un semplice {{jsxref("Global_Objects/Object", "objects")}} invece, con i suoi avvertimenti. Vedere il post <a class="external" href="http://www.less-broken.com/blog/2010/12/lightweight-javascript-dictionaries.html">Lightweight JavaScript dictionaries with arbitrary keys</a> come esempio.</p>
<h3 id="Accedere_ad_elementi_di_array">Accedere ad elementi di array </h3>
<p>Gli array JavaScript sono indicizzati a zero: il primo elemento di un array è all'indice <code>0</code>, e l'ultimo elemento è all'indice uguale al valore della proprietà dell'array {{jsxref("Array.length", "length")}} meno 1. Usare un numero di indice invalido restituisce <code>undefined</code>.</p>
<pre class="brush: js">var arr = ['this is the first element', 'this is the second element'];
console.log(arr[0]); // logs 'this is the first element'
console.log(arr[1]); // logs 'this is the second element'
console.log(arr[arr.length - 1]); // logs 'this is the second element'
</pre>
<p>Gli elementi dell'Array sono proprietà dell'oggetto allo stesso modo che <code>toString</code> è una proprietà, ma provare ad accedere ad un elemento di un array come segue, lancia un errore di sintassi, poichè la proprietà del nome non è valida:</p>
<pre class="brush: js">console.log(arr.0); // a syntax error
</pre>
<p>Non c'è niente di speciale riguardo gli array JavaScript e la proprietà che causa questo. Le proprietà JavaScript che iniziano con un numero non possono essere referenziate con la notazione punto: e vi si deve accedere usando la notazione parentesi quadre. Per esempio, se si avesse un oggetto con una proprietà chiamata <code>'3d'</code>, la si potrebbe referenziare solamente utilizzando la notazione parentesi quadre. E.g.:</p>
<pre class="brush: js">var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(years.0); // a syntax error
console.log(years[0]); // works properly
</pre>
<pre class="brush: js">renderer.3d.setTexture(model, 'character.png'); // a syntax error
renderer['3d'].setTexture(model, 'character.png'); // works properly
</pre>
<p>Notare che nell'esempio <code>3d</code>, <code>'3d'</code> doveva essere messo tra virgolette. E' possibile mettere tra virgolette anche gli indici dell'array JavaScript (e.g., <code>years['2']</code> invece di <code>years[2]</code>), anche se non necessario. Il 2 in <code>years[2]</code> è costretto in una stringa dal motore di JavaScript attraverso una implicita conversione <code>toString</code>. E' per questa ragione che <code>'2'</code> e <code>'02'</code> riferirebbero a due differenti slot nell'oggetto <code>years</code> ed il seguente esempio potrebbe essere <code>true</code>:</p>
<pre class="brush: js">console.log(years['2'] != years['02']);
</pre>
<p>Ugualmente, alle proprietà di oggetti che sono parole riservate(!) vi si può accedere come string literals in notazione parentesi quadrate (ma anche in notazione punto a partire dalla versione 40.0a2 di firefox):</p>
<pre><code>var promise = {
'var' : 'text',
'array': [1, 2, 3, 4]
};
console.log(promise['var']);</code></pre>
<h3 id="Relzione_tra_length_e_proprietà_numeriche">Relzione tra <code>length</code> e proprietà numeriche</h3>
<p>Una proprietà di un array JavaScript {{jsxref("Array.length", "length")}} e proprietà numeriche sono connesse. Molti dei metodi integrati di array(e.g., {{jsxref("Array.join", "join")}}, {{jsxref("Array.slice", "slice")}}, {{jsxref("Array.indexOf", "indexOf")}}, etc.) tengono in conto del valore della proprietà dell'array {{jsxref("Array.length", "length")}} quando sono chiamati. Altri metodi(e.g., {{jsxref("Array.push", "push")}}, {{jsxref("Array.splice", "splice")}}, etc.) risultano nell'aggiornamento della proprietà{{jsxref("Array.length", "length")}} dell'array.</p>
<pre class="brush: js">var fruits = [];
fruits.push('banana', 'apple', 'peach');
console.log(fruits.length); // 3
</pre>
<p>Quando si setta una proprietà su un array JavaScript, quando la proprietà è un valido indice di array e quell'iindice è al di fuori dei limiti dell'array, il motore aggiornerà la proprietà {{jsxref("Array.length", "length")}} in accordo:</p>
<pre class="brush: js">fruits[5] = 'mango';
console.log(fruits[5]); // 'mango'
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 6
</pre>
<p>Aumentando{{jsxref("Array.length", "length")}}.</p>
<pre class="brush: js">fruits.length = 10;
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10
</pre>
<p>Diminuendo la proprietà {{jsxref("Array.length", "length")}}, comunque cancella gli elementi.</p>
<pre class="brush: js">fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2
</pre>
<p>La spiegazione è ampliata nella pagina{{jsxref("Array.length")}}.</p>
<h3 id="Creare_un_array_utilizzando_il_risultato_di_un_match">Creare un array utilizzando il risultato di un match</h3>
<p>Il risultato di una corrispondenza tra una espressione regolare e una stringa può creare un array JavaScript. Tale array ha proprietà ed elementi che provvedono informazioni riguardo il match. Questo tipo di array è restituito da {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, e {{jsxref("String.replace")}}. Per aiutare a spiegare queste proprietà ed elementi, vedere l'esempio seguente e fare riferimento alla tavola sottostante:</p>
<pre class="brush: js">// Match one d followed by one or more b's followed by one d
// Remember matched b's and the following d
// Ignore case
var myRe = /d(b+)(d)/i;
var myArray = myRe.exec('cdbBdbsbz');
</pre>
<p>Le proprietà ed elementi restituiti da questo match sono le seguenti:</p>
<table class="fullwidth-table">
<tbody>
<tr>
<td class="header">Property/Element</td>
<td class="header">Description</td>
<td class="header">Example</td>
</tr>
<tr>
<td><code>input</code></td>
<td>Una proprietà read-only che riflette la stinga originale verso la quale l'espressione irregolare era stata abbinata.</td>
<td>cdbBdbsbz</td>
</tr>
<tr>
<td><code>index</code></td>
<td>Una proprietà read-only su indice base-zeroindex dell'abbinamento nella stringa.</td>
<td>1</td>
</tr>
<tr>
<td><code>[0]</code></td>
<td>Un elemento read-only che specifica gli ultimi caratteri abbinati.</td>
<td>dbBd</td>
</tr>
<tr>
<td><code>[1], ...[n]</code></td>
<td>Elementi read-only che specificano gli abbinamenti di sottostringa in parentesi, se inclusi nella espressione regolare. Il numero di possibili sottostringhe in parentesi è illimitato.</td>
<td>[1]: bB<br>
[2]: d</td>
</tr>
</tbody>
</table>
<h2 id="Proprietà">Proprietà</h2>
<dl>
<dt><code>Array.length</code></dt>
<dd>Il costruttore della proprietà lunghezza <code>Array</code> il cui valore è 1.</dd>
<dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt>
<dd>La funzione del costruttore che è usata per creare oggetti derivati.</dd>
<dt>{{jsxref("Array.prototype")}}</dt>
<dd>Permette l'addizione di proprietà a tutti gli oggetti array.</dd>
</dl>
<h2 id="Metodi">Metodi</h2>
<dl>
<dt>{{jsxref("Array.from()")}} {{experimental_inline}}</dt>
<dd>Crea una nuova istanza <code>Array</code> da un oggetto del tipo array o iterabile.</dd>
<dt>{{jsxref("Array.isArray()")}}</dt>
<dd>Restituisce true se una variabile è un array, altrimenti false.</dd>
<dt>{{jsxref("Array.observe()")}} {{experimental_inline}}</dt>
<dd>In modo asincrono osserva i cambiamenti agli Arrays, come{{jsxref("Object.observe()")}} per gli oggetti. Provvede un flusso di cambiamenti in ordine di occorrenza.</dd>
<dt>{{jsxref("Array.of()")}} {{experimental_inline}}</dt>
<dd>Crea una nuova istanza <code>Array</code> con un variabile numero di argomenti, nonostante il numero o i tipi di argomenti.</dd>
</dl>
<h2 id="Istanze_di_Array">Istanze di<code> Array</code> </h2>
<p>Tutte le istanze di <code>Array</code> ereditano da {{jsxref("Array.prototype")}}. L'oggetto prototype del costruttore <code>Array</code> può essere modificato per influenzare tutte le istanze di <code>Array</code>.</p>
<h3 id="Proprietà_2">Proprietà</h3>
<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties')}}</div>
<h3 id="Metodi_2">Metodi</h3>
<h4 id="Metodi_mutatori">Metodi mutatori</h4>
<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods')}}</div>
<h4 id="Metodi_per_accedere">Metodi per accedere</h4>
<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods')}}</div>
<h4 id="Metodi_di_iterazione">Metodi di iterazione</h4>
<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods')}} </div>
<h2 id="Metodi_generici_Array"><code><font face="x-locale-heading-primary, zillaslab, Palatino, Palatino Linotype, x-locale-heading-secondary, serif"><span style="background-color: #ffffff;">Metodi generici </span></font>Array</code> </h2>
<div class="warning">
<p><strong>Array generics are non-standard, deprecated and will get removed near future</strong>. Note that you can not rely on them cross-browser. However, there is a <a href="https://github.com/plusdude/array-generics">shim available on GitHub</a>.</p>
</div>
<p>A volte si vorrebbe applicare metodi di array alle stringhe o altri oggetti del tipo array (come {{jsxref("Functions/arguments", "arguments", "", 1)}}). Facendo ciò, si tratta una stringa come un array di caratteri(o altrimenti trattare un non array come array). Per esempio, per controllare che ogni carattere nella variabile <var>str</var> sia una lettera, si scriverebbe:</p>
<pre class="brush: js">function isLetter(character) {
return character >= 'a' && character <= 'z';
}
if (Array.prototype.every.call(str, isLetter)) {
console.log("The string '" + str + "' contains only letters!");
}
</pre>
<p>Tale notazione è dispersiva e JavaScript 1.6 ha introdotto un generico shorthand:</p>
<pre class="brush: js">if (Array.every(str, isLetter)) {
console.log("The string '" + str + "' contains only letters!");
}
</pre>
<p>{{jsxref("Global_Objects/String", "Generics", "#String_generic_methods", 1)}} are also available on {{jsxref("Global_Objects/String", "String")}}.</p>
<p>Queste no fanno parte dello standard ECMAScript (anche se ES2015 {{jsxref("Array.from()")}} può essere utilizzato per raggingere tale scopo). Ciò che segue è un aiuto per permetterene l'utilizzo in tutti i browser:</p>
<pre class="brush: js">// Assumes Array extras already present (one may use polyfills for these as well)
(function() {
'use strict';
var i,
// We could also build the array of methods with the following, but the
// getOwnPropertyNames() method is non-shimable:
// Object.getOwnPropertyNames(Array).filter(function(methodName) {
// return typeof Array[methodName] === 'function'
// });
methods = [
'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
'forEach', 'map', 'reduce', 'reduceRight', 'filter',
'some', 'every', 'find', 'findIndex', 'entries', 'keys',
'values', 'copyWithin', 'includes'
],
methodCount = methods.length,
assignArrayGeneric = function(methodName) {
if (!Array[methodName]) {
var method = Array.prototype[methodName];
if (typeof method === 'function') {
Array[methodName] = function() {
return method.call.apply(method, arguments);
};
}
}
};
for (i = 0; i < methodCount; i++) {
assignArrayGeneric(methods[i]);
}
}());
</pre>
<h2 id="Esempi">Esempi</h2>
<h3 id="Creare_un_array">Creare un array</h3>
<p>Il seguente esempio crea un array, <code>msgArray</code>, con una lunghezza di 0, poi assegna valori a <code>msgArray[0]</code> e <code>msgArray[99]</code>, cambiando la lunghezza dell'array a 100.</p>
<pre class="brush: js">var msgArray = [];
msgArray[0] = 'Hello';
msgArray[99] = 'world';
if (msgArray.length === 100) {
console.log('The length is 100.');
}
</pre>
<h3 id="Creare_un_array_bidimensionale">Creare un array bidimensionale</h3>
<p>Ciò che segue crea una scacchiera come un array bidiensionale di stringhe. La prima mossa è fatta copiando la 'p' in (6,4) in (4,4). La vecchia posizione (6,4) è resa bianca.</p>
<pre class="brush: js">var board = [
['R','N','B','Q','K','B','N','R'],
['P','P','P','P','P','P','P','P'],
[' ',' ',' ',' ',' ',' ',' ',' '],
[' ',' ',' ',' ',' ',' ',' ',' '],
[' ',' ',' ',' ',' ',' ',' ',' '],
[' ',' ',' ',' ',' ',' ',' ',' '],
['p','p','p','p','p','p','p','p'],
['r','n','b','q','k','b','n','r'] ];
console.log(board.join('\n') + '\n\n');
// Move King's Pawn forward 2
board[4][4] = board[6][4];
board[6][4] = ' ';
console.log(board.join('\n'));
</pre>
<p>Ecco l'output:</p>
<pre class="eval">R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
, , , , , , ,
, , , , , , ,
, , , , , , ,
, , , , , , ,
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r
R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
, , , , , , ,
, , , , , , ,
, , , ,p, , ,
, , , , , , ,
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r
</pre>
<h2 id="Specificazioni">Specificazioni</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Specification</th>
<th scope="col">Status</th>
<th scope="col">Comment</th>
</tr>
<tr>
<td>{{SpecName('ES1')}}</td>
<td>{{Spec2('ES1')}}</td>
<td>Definizione iniziale.</td>
</tr>
<tr>
<td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td>
<td>{{Spec2('ES5.1')}}</td>
<td>Nuovi metodi aggiunti: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td>
</tr>
<tr>
<td>{{SpecName('ES2015', '#sec-array-objects', 'Array')}}</td>
<td>{{Spec2('ES2015')}}</td>
<td>Nuovi metodi aggiunti: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td>
</tr>
</tbody>
</table>
<h2 id="Compatibilità_Browser">Compatibilità Browser </h2>
<div>{{CompatibilityTable}}</div>
<div id="compat-desktop">
<table class="compat-table">
<tbody>
<tr>
<th>Feature</th>
<th>Chrome</th>
<th>Firefox (Gecko)</th>
<th>Internet Explorer</th>
<th>Opera</th>
<th>Safari</th>
</tr>
<tr>
<td>Basic support</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
</tr>
</tbody>
</table>
</div>
<div id="compat-mobile">
<table class="compat-table">
<tbody>
<tr>
<th>Feature</th>
<th>Android</th>
<th>Chrome for Android</th>
<th>Firefox Mobile (Gecko)</th>
<th>IE Mobile</th>
<th>Opera Mobile</th>
<th>Safari Mobile</th>
</tr>
<tr>
<td>Basic support</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
<td>{{CompatVersionUnknown}}</td>
</tr>
</tbody>
</table>
</div>
<h2 id="Vedere_anche">Vedere anche:</h2>
<ul>
<li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Indexing_object_properties">JavaScript Guide: “Indexing object properties”</a></li>
<li><a href="/en-US/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Array_Object">JavaScript Guide: “Predefined Core Objects: <code>Array</code> Object”</a></li>
<li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a></li>
<li><a href="https://github.com/plusdude/array-generics">Polyfill for JavaScript 1.8.5 Array Generics and ECMAScript 5 Array Extras</a></li>
<li><a href="/en-US/docs/JavaScript_typed_arrays">Typed Arrays</a></li>
</ul>