From 95aca4b4d8fa62815d4bd412fff1a364f842814a Mon Sep 17 00:00:00 2001 From: Ryan Johnson Date: Thu, 29 Apr 2021 16:16:42 -0700 Subject: remove retired locales (#699) --- .../reference/statements/break/index.html | 130 --------- .../reference/statements/empty/index.html | 102 ------- .../reference/statements/export/index.html | 259 ----------------- .../reference/statements/for...of/index.html | 264 ----------------- .../reference/statements/function_star_/index.html | 280 ------------------ .../reference/statements/import/index.html | 167 ----------- .../web/javascript/reference/statements/index.html | 131 --------- .../javascript/reference/statements/let/index.html | 208 -------------- .../reference/statements/switch/index.html | 320 --------------------- .../reference/statements/throw/index.html | 195 ------------- .../javascript/reference/statements/var/index.html | 221 -------------- 11 files changed, 2277 deletions(-) delete mode 100644 files/it/web/javascript/reference/statements/break/index.html delete mode 100644 files/it/web/javascript/reference/statements/empty/index.html delete mode 100644 files/it/web/javascript/reference/statements/export/index.html delete mode 100644 files/it/web/javascript/reference/statements/for...of/index.html delete mode 100644 files/it/web/javascript/reference/statements/function_star_/index.html delete mode 100644 files/it/web/javascript/reference/statements/import/index.html delete mode 100644 files/it/web/javascript/reference/statements/index.html delete mode 100644 files/it/web/javascript/reference/statements/let/index.html delete mode 100644 files/it/web/javascript/reference/statements/switch/index.html delete mode 100644 files/it/web/javascript/reference/statements/throw/index.html delete mode 100644 files/it/web/javascript/reference/statements/var/index.html (limited to 'files/it/web/javascript/reference/statements') diff --git a/files/it/web/javascript/reference/statements/break/index.html b/files/it/web/javascript/reference/statements/break/index.html deleted file mode 100644 index 8799911ff9..0000000000 --- a/files/it/web/javascript/reference/statements/break/index.html +++ /dev/null @@ -1,130 +0,0 @@ ---- -title: break -slug: Web/JavaScript/Reference/Statements/break -translation_of: Web/JavaScript/Reference/Statements/break ---- -
{{jsSidebar("Statements")}}
- -

Lo statement break interrompe il loop corrente, termina uno statement {{jsxref("Statements/switch", "switch")}}, o trasferisce l'esecuzione verso un {{jsxref("Statements/label", "label")}} .

- -
{{EmbedInteractiveExample("pages/js/statement-break.html")}}
- - - -

Sinstassi

- -
break [label];
- -
-
label {{optional_inline}}
-
Identificatore che può essere anche associato ad una {{jsxref("Statements/label", "label")}}. Se lo statement non è un loop o uno {{jsxref("Statements/switch", "switch")}}, il label è necessario.
-
- -

Descrizione

- -

Lo statement break può contenere un parametro opzionale ({{jsxref("Statements/label", "label")}}) che impone al programma di interrompere l'esecuzione e saltare ad un determinato punto nel programma, indicato dalla label stessa. La label può anche essere uno degli statement jsxref("Statements/block", "block")}}; e non dovrà essere preceduto da uno statement loop.
- Uno statement break, con o senza label opzionale, non può essere usato nel corpo di una funzione innestata in un loop o uno switch, poichè quando verrà eseguito break il programma verrà terminato insieme al loop o allo switch.

- -

Esempi

- -

break in un while loop

- -

La seguente funzione contiene uno statement  break che interromperà il {{jsxref("Statements/while", "while")}} loop quando la variabile i avrà valore 3, quindi restituirà il valore di 3 * x.

- -
function testBreak(x) {
-  var i = 0;
-
-  while (i < 6) {
-    if (i == 3) {
-      break;
-    }
-    i += 1;
-  }
-
-  return i * x;
-}
- -

break in labeled blocks

- -

Il seguente codice usa lo statement break con un blocco definito da una {{jsxref("Statements/label", "label")}}. Lo stetement break deve essere innestato all'interno di qualsiasi label a cui fa riferimento. Nota che inner_block è innestato dentro outer_block.

- -
outer_block: {
-  inner_block: {
-    console.log('1');
-    break outer_block; // esce sia da inner_block che da outer_block
-    console.log(':-('); // non viene eseguito
-  }
-  console.log('2'); // non viene eseguito
-}
-
- -

break in labeled blocks che genera un errore

- -

Il codice seguente usa lo statement break nei labeled block, ma genera un SyntaxError poichè il break è all'interno del block_1 ma fa riferimento a block_2. Uno statement break deve sempre essere innestato all'interno dei blocchi a cui si riferiscono i {{jsxref("Statements/label", "label")}}.

- -
block_1: {
-  console.log('1');
-  break block_2; // SyntaxError: label not found
-}
-
-block_2: {
-  console.log('2');
-}
-
- -

break all'interno di funzioni

- -

Verranno generati SyntaxError anche nei seguenti esempi di codice dove viene usato lo stetement break all'interno di funzioni che sono innestate nei cicli loop, oppure all'interno di funzioni innestate in labeled block, per cui lo stetemen break si intende come stop all'esecuzione e uscita.

- -
function testBreak(x) {
-  var i = 0;
-
-  while (i < 6) {
-    if (i == 3) {
-      (function() {
-        break;
-      })();
-    }
-    i += 1;
-  }
-
-return i * x;
-}
-
-testBreak(1); // SyntaxError: Illegal break statement
-
- -
block_1: {
-  console.log('1');
-  ( function() {
-    break block_1; // SyntaxError: Undefined label 'block_1'
-  })();
-}
-
- -

Specifiche

- - - - - - - - - - -
Specifiche
{{SpecName('ESDraft', '#sec-break-statement', 'Break statement')}}
- -

Compatibilità dei Browser

- - - -

{{Compat("javascript.statements.break")}}

- -

Vedi anche

- - diff --git a/files/it/web/javascript/reference/statements/empty/index.html b/files/it/web/javascript/reference/statements/empty/index.html deleted file mode 100644 index bb10fd7165..0000000000 --- a/files/it/web/javascript/reference/statements/empty/index.html +++ /dev/null @@ -1,102 +0,0 @@ ---- -title: empty -slug: Web/JavaScript/Reference/Statements/Empty -translation_of: Web/JavaScript/Reference/Statements/Empty ---- -
{{jsSidebar("Statements")}}
- -

Un empty statement (istruzione vuota) è utilizzato per evitare di inserire uno statement nel caso in cui la sintassi JavaScript ne richieda uno.

- -
{{EmbedInteractiveExample("pages/js/statement-empty.html")}}
- - - -

Sintassi

- -
;
-
- -

Descrizione

- -

L'empty statement è un punto e virgola (;) che indica che nessuno statement sarà eseguito, nonostante la sintassi JavaScript ne richieda uno. Il comportamento opposto, quando vuoi eseguire più statement ma JavaScript ne consente uno solo, è reso possibile dall'utilizzo di un block statement; esso ne combina diversi in un singolo statement .

- -

Esempi

- -

L'empty statement è utilizzato talvolta con i loop statements. Guarda l'esempio seguente con un copro del loop vuoto:

- -
var arr = [1, 2, 3];
-
-// Assegna il valore 0 a tutti gli elementi dell'array
-for (i = 0; i < arr.length; arr[i++] = 0) /* empty statement */ ;
-
-console.log(arr)
-// [0, 0, 0]
-
- -

Nota: E' una buona pratica commentare l'utilizzo intenzionale di empty statement, poichè non è immediatamente ovvia la differenza con un normale punto e virgola. Nell'esempio seguente l'uso è probabilmente non intenzionale:

- -
if (condition);       // Attenzione, questo "if" non produce nessun effetto!
-   killTheUniverse()  // E quindi questo sarà eseguito sempre!!!
-
- -

Un altro Esempio: Un if...else statement senza parentesi graffe ({}). Se three è true, non accadrà nulla, four non viene valutato, e neanche la funzione launchRocket()nel ramo else sarà eseguita.

- -
if (one)
-  doOne();
-else if (two)
-  doTwo();
-else if (three)
-  ; // nothing here
-else if (four)
-  doFour();
-else
-  launchRocket();
- -

Specifiche

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}}{{Spec2('ESDraft')}}
{{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}}{{Spec2('ES6')}}
{{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES3', '#sec-12.3', 'Empty statement')}}{{Spec2('ES3')}}
{{SpecName('ES1', '#sec-12.3', 'Empty statement')}}{{Spec2('ES1')}}Initial definition.
- -

Compatibilità con i Browser

- - - -

{{Compat("javascript.statements.empty")}}

- -

See also

- - diff --git a/files/it/web/javascript/reference/statements/export/index.html b/files/it/web/javascript/reference/statements/export/index.html deleted file mode 100644 index 47d67a6eb2..0000000000 --- a/files/it/web/javascript/reference/statements/export/index.html +++ /dev/null @@ -1,259 +0,0 @@ ---- -title: export -slug: Web/JavaScript/Reference/Statements/export -tags: - - ECMAScript 2015 - - JavaScript - - Moduli - - export -translation_of: Web/JavaScript/Reference/Statements/export ---- -
{{jsSidebar("Statements")}}
- -
Il comando export è utilizzato per esportare funzioni, oggetti o tipi primitivi da un dato file (o modulo) in modo tale da poter essere riutilizzati in altri file con il comando {{jsxref("Statements/import", "import")}}
- -
- -
I moduli sono esportati sempre in {{jsxref("Strict_mode","strict mode", "", 1)}}  nonostante non sia dichiarato. Il comando export non può essere usato in embedded scripts.
- -

Sintassi

- -

Ci sono due tipi di exports:

- -
    -
  1. Named exports (uno o più exports per modulo)
    2. -
  2. Default exports (uno per modulo)
    3. -
- -
// Export di variabili, funzioni e oggetti singolarmente
-export let name1, name2, …, nameN; // also var, const
-export let name1 = …, name2 = …, …, nameN; // also var, const
-export function functionName(){...}
-export class ClassName {...}
-
-// Export di una lista
-export { name1, name2, …, nameN };
-
-// Rinominare gli exports
-export { variable1 as name1, variable2 as name2, …, nameN };
-
-// Exporting destructured assignments with renaming
-// Export di assegnazioni destrutturate rinominando l'export
-export const { name1, name2: bar } = o;
-
-// DEfault export
-export default expression;
-export default function (…) { … } // also class, function*
-export default function name1(…) { … } // also class, function*
-export { name1 as default, … };
-
-// Aggregazione di moduli
-export * from …; // does not set the default export
-export * as name1 from …; // Draft ECMAScript® 2O21
-export { name1, name2, …, nameN } from …;
-export { import1 as name1, import2 as name2, …, nameN } from …;
-export { default } from …;
- -
-
nameN
-
Nome che deve essere esportato (così da poter essere importato via import in un altro script).
-
- -

Descrizione

- -

Ci sono due tipi diversi di export, named and default. Puoi avere più named exports per modulo ma solamente un default export.

- -

Named exports:

- -
// Export di variabili, funzioni, oggetti dichiarati precedentemente
-export { myFunction, myVariable };
-
-// export individual features (can export var, let,
-// const, function, class)
-export let myVariable = Math.sqrt(2);
-export function myFunction() { ... };
- -

Default exports:

- -
// Export di funzioni dichiarati precedentemente come default
-export { myFunction as default };
-
-// Export di singole funzioni, oggetti come default
-export default function () { ... }
-export default class { .. }
-
-// ogni export sovrascrive il precedente
- -

I named exports sono utili per esportare più valori. Durante l'import, è obbligatorio usare lo stesso nome dell'oggetto corrispondente.

- -

I defalt export invece possono essere importati con qualsiasi nome. Ad esempio:

- -
// file test.js
-let k; export default k = 12;
-
- -
// some other file
-import m from './test'; //notare che abbiamo la libertà di importare m invece di importate k, perché  k era il default export
-console.log(m);        // stamperà 12
-
- -

Puoi anche rinominare i named exports per evitare conflitti:

- -
export { myFunction as function1,
-         myVariable as variable };
- -

Ri-esportare / Aggregare

- -

È anche possibile importare ed esportare da più moduli nel modulo padre in modo tale da rendere rendere disponibili gli import da quel modulo. In altre parole è possibile creare un modulo che aggreghi i vari export da vari moduli.

- -

È possibile farlo con la sintassi "export from":

- -
export { default as function1,
-         function2 } from 'bar.js';
-
- -

che è paragonabile ad una combinazione di import e export:

- -
import { default as function1,
-         function2 } from 'bar.js';
-export { function1, function2 };
- -

dove function1 e function2 non sono disponibili nel modulo corrente.

- -
-

Note: I seguenti esempi sono sintatticamente invalidi nonostante siano equivalenti dal punto divista del comando import

-
- -
import DefaultExport from 'bar.js'; // Valid
- -
export DefaultExport from 'bar.js'; // Invalid
- -

Il modo corretto di farlo è di rinominare gli export:

- -
export { default as DefaultExport } from 'bar.js';
- -

Esempi

- -

Usare gli export espliciti

- -

In un modulo my-module.js, potremmo includere il seguente codice:

- -
// modulo "my-module.js"
-function cube(x) {
-  return x * x * x;
-}
-
-const foo = Math.PI + Math.SQRT2;
-
-var graph = {
-  options: {
-      color:'white',
-      thickness:'2px'
-  },
-  draw: function() {
-      console.log('From graph draw function');
-  }
-}
-
-export { cube, foo, graph };
- -

E nel modulo principale incluso nella pagina HTML potremmo avere

- -
import { cube, foo, graph } from './my-module.js';
-
-graph.options = {
-    color:'blue',
-    thickness:'3px'
-};
-
-graph.draw();
-console.log(cube(3)); // 27
-console.log(foo);    // 4.555806215962888
- -

Notare che:

- - - -

Usare i default export

- -

Se vogliamo esportare un singolo valore o avere un valore di default per il tuo modulo, allora possiamo usare il default export:

- -
// modulo "my-module.js"
-export default function cube(x) {
-  return x * x * x;
-}
-
- -

Quindi, in un altro script, puoi importare il modulo direttamente:

- -
import cube from 'my-module';
-console.log(cube(3)); // 27
-
- -

Usare export from

- -

Facciamo l'esempio dove abbiamo i seguenti moduli:

- - - -

Questo è come sarebbe con il codice:

- -
// Nel modulo childModule1.js
-let myFunction = ...; // assegna una funzione myFunction
-let myVariable = ...; // assegna un valore alla variabile myVariable
-export {myFunction, myVariable};
-
- -
// Nel modulo childModule2.js
-let myClass = ...; // assegna qualcosa di utile a myClass
-export myClass;
-
- -
// Nel modulo parentModule.js
-// Aggreghiamo solamente gli export dai moduli childModule1 e childModule2
-// per poi riesportarli
-export { myFunction, myVariable } from 'childModule1.js';
-export { myClass } from 'childModule2.js';
-
- -
// Nel modulo principale
-// Possiamo usare gli export importandoli da un singolo modulo
-// che li colleziona/include in un singolo modulo
-import { myFunction, myVariable, myClass } from 'parentModule.js'
- -

Specifiche

- - - - - - - - - - - - -
Specifiche
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}
- -

Compatibilità Browser

- -

{{Compat("javascript.statements.export")}}

- -

Vedi anche

- - diff --git a/files/it/web/javascript/reference/statements/for...of/index.html b/files/it/web/javascript/reference/statements/for...of/index.html deleted file mode 100644 index ffc6f472c0..0000000000 --- a/files/it/web/javascript/reference/statements/for...of/index.html +++ /dev/null @@ -1,264 +0,0 @@ ---- -title: for...of -slug: Web/JavaScript/Reference/Statements/for...of -translation_of: Web/JavaScript/Reference/Statements/for...of ---- -

{{jsSidebar("Statements")}}

- -

Il costrutto for...of crea un ciclo con gli oggetti iterabili (inclusi {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, {{jsxref("String")}}, {{jsxref("TypedArray")}}, argomenti di oggetti e così via), iterando le istruzioni per ogni valore di ogni proprietà.

- -

Sintassi

- -
for (variabile of oggettoIterabile) {
-  istruzioni
-}
-
- -
-
variabile
-

- Questa variabile assume il valore di una proprietà in ogni ciclo.
-
oggettoIterabile
-
Oggetto le cui proprietà sono iterate.
-
- -

Esempi

- -

Iterare un {{jsxref("Array")}}:

- -
let array = [10, 20, 30];
-
-for (let valore of array) {
-  console.log(valore);
-}
-// Output:
-// 10
-// 20
-// 30
-
- -

Si può utilizzare const anzichè let se 'value' non cambia valore durante il ciclo.

- -
let iterable = [10, 20, 30];
-
-for (const value of iterable) {
-  console.log(value); // il valore di value di questo ciclo rimarrà costante
-  value++; // operazione non consentita.
-}
-// 10
-// 20
-// 30
-
- -

Iterare un oggetto {{jsxref("String")}}:

- -
let iterable = "boo";
-
-for (let value of iterable) {
-  console.log(value);
-}
-// output:
-// "b"
-// "o"
-// "o"
-
- -

Iterare un oggetto {{jsxref("TypedArray")}}:

- -
let iterable = new Uint8Array([0x00, 0xff]);
-
-for (let value of iterable) {
-  console.log(value);
-}
-// 0
-// 255
-
- -

Iterare un oggetto {{jsxref("Map")}}:

- -
let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]);
-
-for (let entry of iterable) {
-  console.log(entry);
-}
-// [a, 1]
-// [b, 2]
-// [c, 3]
-
-for (let [key, value] of iterable) {
-  console.log(value);
-}
-// 1
-// 2
-// 3
-
- -

Iterare un oggetto {{jsxref("Set")}}:

- -
let iterable = new Set([1, 1, 2, 2, 3, 3]);
-
-for (let value of iterable) {
-  console.log(value);
-}
-// 1
-// 2
-// 3
-
- -

Iterare un DOM collection

- -
-

Iterare un DOM collection come {{domxref("NodeList")}}: il seguente esempio aggiunge una classe 'read' ai paragrafi che sono discendenti diretti di un elemento article:

-
- -
-

Nota: Questo costrutto funziona soltanto con le piattaforme che implementano NodeList.prototype[Symbol.iterator]

-
- -
-
let articleParagraphs = document.querySelectorAll("article > p");
-
-for (let paragraph of articleParagraphs) {
-  paragraph.classList.add("read");
-}
-
-
- -

Iterare generatori

- -

Si possono iterare i generatori:

- -
function* fibonacci() { // generatore di funzione
-  let [prev, curr] = [0, 1];
-  while (true) {
-    [prev, curr] = [curr, prev + curr];
-    yield curr;
-  }
-}
-
-for (let n of fibonacci()) {
-  console.log(n);
-  // tronca la sequenza a 1000
-  if (n >= 1000) {
-    break;
-  }
-}
-
- -

Differerenze tra for...of e for...in

- -

Il for...in itera tutte le proprietà enumerabili di un oggetto.

- -

Il for...of è specifico per le collezioni, piuttosto che tutti gli oggetti. Itera tutti gli oggetti di qualsiasi collection che abbia la proprietà [Symbol.iterator].

- -

Il seguente esempio mostra le differenze tra for...of e for...in.

- -
Object.prototype.objCustom = function () {};
-Array.prototype.arrCustom = function () {};
-
-let iterable = [3, 5, 7];
-iterable.foo = "hello";
-
-for (let i in iterable) {
-  console.log(i); // logs 0, 1, 2, "foo", "arrCustom", "objCustom"
-}
-
-for (let i of iterable) {
-  console.log(i); // logs 3, 5, 7
-}
-
- -

Specifiche

- - - - - - - - - - - - - - - - - - - -
SpecificaStatoCommenti
{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...of statement')}}{{Spec2('ES6')}}Definizione iniziale.
{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...of statement')}}{{Spec2('ESDraft')}} 
- -

Compatibilità con i browser

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)EdgeOperaSafari
Basic support{{CompatChrome(38)}} [1]
- {{CompatChrome(51)}} [3]		{{CompatGeckoDesktop("13")}} [2]12257.1
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatUnknown}}{{CompatChrome(38)}} [1]{{CompatGeckoMobile("13")}} [2]{{CompatUnknown}}{{CompatUnknown}}8
-
- -

[1] Da Chrome 29 a Chrome 37 questa caratteristica era disponibile nel menu preferenze. In chrome://flags/#enable-javascript-harmony, bisognava attivare “Enable Experimental JavaScript”.

- -

[2] Da Gecko 17 (Firefox 17 / Thunderbird 17 / SeaMonkey 2.14) a Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) la proprietà iterator era usata (bug 907077), e da Gecko 27 a Gecko 35 era utilizzato "@@iterator" placeholder. In Gecko 36 (Firefox 36 / Thunderbird 36 / SeaMonkey 2.33), il simbolo symbolo @@iterator fu implementato (bug 918828).

- -

[3] Il supporto dell'iteration of objects è stato aggiunto in Chrome 51.

- -

Note

- -

Se alcuni collegamenti su questa pagina fossero segnati in rosso e si volesse visualizzarli, essi sono dispoiìnibili solo in lingua inglese. In tal caso basta cambiare la lingua di questo stesso articolo.

- -

See also

- - - -

 

diff --git a/files/it/web/javascript/reference/statements/function_star_/index.html b/files/it/web/javascript/reference/statements/function_star_/index.html deleted file mode 100644 index a71ccfc55e..0000000000 --- a/files/it/web/javascript/reference/statements/function_star_/index.html +++ /dev/null @@ -1,280 +0,0 @@ ---- -title: function* -slug: Web/JavaScript/Reference/Statements/function* -translation_of: Web/JavaScript/Reference/Statements/function* ---- -
{{jsSidebar("Statements")}}
- -

La dichiarazione function* (la parola chiave function seguita da un asterisco) definisce una funzione generatrice, la quale restituisce un oggetto di tipo {{jsxref("Global_Objects/Generator","Generator")}}.

- -

{{EmbedInteractiveExample("pages/js/statement-functionasterisk.html")}}

- -
-

È anche possibile definire una funzione generatrice usando il costrutto {{jsxref("GeneratorFunction")}} e una {{jsxref("Operators/function*", "espressione function*")}}.

-
- -

Sintassi

- -
function* nome([param[, param[, ... param]]]) {
-   istruzioni
-}
-
- -
-
nome
-
Il nome della funzione.
-
- -
-
param
-
Gli argomenti passati alla funzione. Una funzione può avere fino a 255 argomenti.
-
- -
-
istruzioni
-
Le istruzioni che compongono il corpo della funzione.
-
- -

Descrizione

- -

I generatori sono funzioni  dalle quali è possibile uscire e poi rientrarvi in un secondo momento. Il loro contesto (binding delle variabili) verrà salvato all'uscita per quando vi entrerà successivamente.

- -

La chiamata ad un generatore non viene eseguita immediatamente; la funzione ritornerà invece un oggetto iterator. Quando il metodo next() dell'iteratore viene chiamato, il corpo del generatore viene eseguito fino alla prima espressione {{jsxref("Operators/yield", "yield")}}, la quale specifica quale espressione ritornare dall'iteratore oppure, con l'espressione {{jsxref("Operators/yield*", "yield*")}}, delegare questo valore ad un'altra funzione generatrice. Il metodo next() restituisce un oggetto con proprietà value contenente il valore da restituito all'iteratore ed una proprietà done che contiene un valore di tipo boolean per indicare se il generatore ha restituito l'ultimo valore. Chiamando il metodo next() con un argomento farà riprendere l'esecuzione della funzione generatrice, sostituendo l'istruzione yield in cui l'esecuzione era stata fermata con l'argomento della funzione next(). 

- -

Esempi

- -

Esempio semplice

- -
function* idMaker(){
-  var index = 0;
-  while(index < 3)
-    yield index++;
-}
-
-var gen = idMaker();
-
-console.log(gen.next().value); // 0
-console.log(gen.next().value); // 1
-console.log(gen.next().value); // 2
-console.log(gen.next().value); // undefined
-// ...
- -

Esempio con yield*

- -
function* anotherGenerator(i) {
-  yield i + 1;
-  yield i + 2;
-  yield i + 3;
-}
-
-function* generator(i){
-  yield i;
-  yield* anotherGenerator(i);
-  yield i + 10;
-}
-
-var gen = generator(10);
-
-console.log(gen.next().value); // 10
-console.log(gen.next().value); // 11
-console.log(gen.next().value); // 12
-console.log(gen.next().value); // 13
-console.log(gen.next().value); // 20
-
- -

Passare argomenti ai Generatori

- -
function* logGenerator() {
-  console.log(yield);
-  console.log(yield);
-  console.log(yield);
-}
-
-var gen = logGenerator();
-
-// the first call of next executes from the start of the function
-// until the first yield statement
-gen.next();
-gen.next('pretzel'); // pretzel
-gen.next('california'); // california
-gen.next('mayonnaise'); // mayonnaise
-
- -

I generatori non sono costruttori

- -
function* f() {}
-var obj = new f; // solleva "TypeError: f is not a constructor"
- -

Specifiche

- - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificaStatoCommenti
{{SpecName('ES6', '#', 'function*')}}{{Spec2('ES6')}}Definizione iniziale
{{SpecName('ES7', '#', 'function*')}}{{Spec2('ES7')}}I generatori non devono avere essere usati come costruttori e deveo lanciare un eccezione quando vengono usati con la parola chiave new.
{{SpecName('ESDraft', '#', 'function*')}}{{Spec2('ESDraft')}} 
- -

Compatibilità per i browser

- -
{{CompatibilityTable}}
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet Explorer EdgeOperaSafari (WebKit)
Supporto base{{CompatChrome(39.0)}}{{CompatGeckoDesktop("26.0")}}{{CompatNo}}1326{{CompatNo}}
yield*{{CompatVersionUnknown}}{{CompatGeckoDesktop("27.0")}}{{CompatNo}}1326{{CompatNo}}
IteratorResult invece delle eccezioni{{CompatVersionUnknown}}{{CompatGeckoDesktop("29.0")}}{{CompatNo}}13{{CompatVersionUnknown}}{{CompatNo}}
Non istanziabile con new {ES2016){{CompatVersionUnknown}}{{CompatGeckoDesktop("43.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Supporto base{{CompatNo}}{{CompatVersionUnknown}}{{CompatGeckoMobile("26.0")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatChrome(39.0)}}
yield*{{CompatNo}}{{CompatVersionUnknown}}{{CompatGeckoMobile("27.0")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}
IteratorResult invece delle eccezioni{{CompatNo}}{{CompatUnknown}}{{CompatGeckoMobile("29.0")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatVersionUnknown}}
Non istanziabile con new (ES2016){{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile("43.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
-
- -

Note specifiche per Firefox

- -

Generatori e iteratori in Firefox nelle versioni precedenti alla 26

- -

Versioni di FIrefox precedenti implementano una versione più vecchia della proposta di standard per i generatori. Tra le varie differenze, in queste versioni i generatori erano definiti usando la parola chiave function (senza asterisco) per le funzioni semplici. Per maggiori informazioni fare riferimento a {{jsxref("Statements/Legacy_generator_function", "funzioni generatrici (legacy)")}}.

- -

IteratorResult al posto delle eccezioni

- -

A partire da Gecko 29 {{geckoRelease(29)}}, la funzione generatrice completata non solleva più eccezioni {{jsxref("TypeError")}} "generator has already finished". Restituisce invece oggetti di tipo IteratorResult come il seguente { value: undefined, done: true } ({{bug(958951)}}).

- -

Vedi anche

- - diff --git a/files/it/web/javascript/reference/statements/import/index.html b/files/it/web/javascript/reference/statements/import/index.html deleted file mode 100644 index 9a6ac79920..0000000000 --- a/files/it/web/javascript/reference/statements/import/index.html +++ /dev/null @@ -1,167 +0,0 @@ ---- -title: import -slug: Web/JavaScript/Reference/Statements/import -translation_of: Web/JavaScript/Reference/Statements/import ---- -
{{jsSidebar("Statements")}}
- -

Il comando import si usa per importare bindings esportati da un altro modulo. I moduli importati sono in {{jsxref("Strict_mode","strict mode")}} indipendentemente dal fatto che venga dichiarato in modo esplicito. Il comando import non puo' essere usato negli script embedded.

- -

Sintassi

- -
import defaultExport from "module-name";
-import * as name from "module-name";
-import { export } from "module-name";
-import { export as alias } from "module-name";
-import { export1 , export2 } from "module-name";
-import { export1 , export2 as alias2 , [...] } from "module-name";
-import defaultExport, { export [ , [...] ] } from "module-name";
-import defaultExport, * as name from "module-name";
-import "module-name";
- -
-
defaultExport
-
Nome riferito all'export di default nel modulo.
-
module-name
-
Il modulo da cui importare. E' spesso il path relativo o assoluto del file .js che contiene il modulo. Alcuni bundlers possono permettere o imporre l'uso dell'estensione; verifica nel tuo environment. Sono ammesse solo stringhe a singole o doppie virgolette.
-
name
-
Nome dell' oggetto-modulo che verra' usato come namespace quando si fa riferimento nelle importazioni.
-
export, exportN
-
Nome degli export da importare.
-
alias, aliasN
-
Nomi fittizi (alias) riferiti ai nomi importati.
-
- -

Descrizione

- -

Il parametro name e' il nome dell' "oggetto-modulo" che verra' usato come namespace per riferirsi agli export al suo interno. I parametri export indicano i nomi dei singoli export, mentre import * li importa tutti insieme. Seguiranno degli esempi per chiarire questa sintassi.

- -

Importare l'intero contenuto di un modulo

- -

L'esempio inserisce myModule nello scope corrente, che conterra' tutti gli export del modulo, il cui file si trova in /modules/my-module.js.

- -
import * as myModule from '/modules/my-module.js';
-
- -

Qui invece, si accede agli export usando il nome del modulo ("myModule" in this case) come namespace. Per esempio, se il modulo importato contiene l'export doAllTheAmazingThings(), lo indicherai in questo modo:

- -
myModule.doAllTheAmazingThings();
- -

Importare un singolo export da un modulo

- -

Dato un oggetto o valore di nome myExport che sia esportato dal modulo my-module, sia implicitamente (perche' viene esportato l'intero modulo) che esplicitamente (usando il comando {{jsxref("Statements/export", "export")}}), l'esempio che segue inserira' myExport nello scope corrente.

- -
import {myExport} from '/modules/my-module.js';
- -

Importare export multipli da un modulo

- -

In questo esempio, sia foo che bar verranno inseriti nello scope corrente.

- -
import {foo, bar} from '/modules/my-module.js';
- -

Importare un export usando un alias

- -

E' possibile rinominare un export in fase di importazione, ad esempio, shortName verra' inserito in questo modo nello scope corrente:

- -
import {reallyReallyLongModuleExportName as shortName}
-  from '/modules/my-module.js';
- -

Rinominare export multipli in un importazione

- -

Importazione multipla di export da un modulo, usando per comodita' degli alias:

- -
import {
-  reallyReallyLongModuleExportName as shortName,
-  anotherLongModuleName as short
-} from '/modules/my-module.js';
- -

Importare solo gli 'effetti collaterali' di un modulo

- -

Importazione dei soli 'effetti collaterali' di un modulo, senza importare tutto il resto. Cio' che segue eseguira' soltanto il codice nello scope globale ma senza importare alcun valore.

- -
import '/modules/my-module.js';
-
- -

Importare defaults

- -

E' possibile che in un modulo ci sia un esportazione di default {{jsxref("Statements/export", "export")}} (che sia un oggetto, una funzione, una classe, ecc...) e il comando import potra' servire per importarlo.

- -

La versione piu' semplice che importa direttamente il default e' questa:

- -
import myDefault from '/modules/my-module.js';
- -

E' possibile usare questa sintassi all'interno delle altre che abbiamo gia' visto (importazioni con namespace o nomi specifici) ma, in questo caso, l'importazione di default dovra' essere indicata per prima:

- -
import myDefault, * as myModule from '/modules/my-module.js';
-// myModule used as a namespace
- -

oppure

- -
import myDefault, {foo, bar} from '/modules/my-module.js';
-// specific, named imports
-
- -

Esempi

- -

Importazione di una funzione helper da un modulo secondario che processa una richiesta AJAX JSON.

- -

Modulo: file.js

- -
function getJSON(url, callback) {
-  let xhr = new XMLHttpRequest();
-  xhr.onload = function () {
-    callback(this.responseText)
-  };
-  xhr.open('GET', url, true);
-  xhr.send();
-}
-
-export function getUsefulContents(url, callback) {
-  getJSON(url, data => callback(JSON.parse(data)));
-}
- -

Main program: main.js

- -
import { getUsefulContents } from '/modules/file.js';
-
-getUsefulContents('http://www.example.com',
-    data => { doSomethingUseful(data); });
- -

Specifiche

- - - - - - - - - - - - - - - - - - - -
SpecificaStatusCommento
{{SpecName('ES2015', '#sec-imports', 'Imports')}}{{Spec2('ES2015')}}Definizione iniziale.
{{SpecName('ESDraft', '#sec-imports', 'Imports')}}{{Spec2('ESDraft')}} 
- -

Compatibilitá

- - - -

{{Compat("javascript.statements.import")}}

- -

Vedi anche

- - diff --git a/files/it/web/javascript/reference/statements/index.html b/files/it/web/javascript/reference/statements/index.html deleted file mode 100644 index e997b9799f..0000000000 --- a/files/it/web/javascript/reference/statements/index.html +++ /dev/null @@ -1,131 +0,0 @@ ---- -title: Statements -slug: Web/JavaScript/Reference/Statements -tags: - - JavaScript - - NeedsTranslation - - Reference - - TopicStub - - statements -translation_of: Web/JavaScript/Reference/Statements ---- -
{{jsSidebar("Statements")}}
- -

JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.

- -

Statements and declarations by category

- -

For an alphabetical listing see the sidebar on the left.

- -

Control flow

- -
-
{{jsxref("Statements/block", "Block")}}
-
A block statement is used to group zero or more statements. The block is delimited by a pair of curly brackets.
-
{{jsxref("Statements/break", "break")}}
-
Terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.
-
{{jsxref("Statements/continue", "continue")}}
-
Terminates execution of the statements in the current iteration of the current or labeled loop, and continues execution of the loop with the next iteration.
-
{{jsxref("Statements/Empty", "Empty")}}
-
An empty statement is used to provide no statement, although the JavaScript syntax would expect one.
-
{{jsxref("Statements/if...else", "if...else")}}
-
Executes a statement if a specified condition is true. If the condition is false, another statement can be executed.
-
{{jsxref("Statements/switch", "switch")}}
-
Evaluates an expression, matching the expression's value to a case clause, and executes statements associated with that case.
-
{{jsxref("Statements/throw", "throw")}}
-
Throws a user-defined exception.
-
{{jsxref("Statements/try...catch", "try...catch")}}
-
Marks a block of statements to try, and specifies a response, should an exception be thrown.
-
- -

Declarations

- -
-
{{jsxref("Statements/var", "var")}}
-
Declares a variable, optionally initializing it to a value.
-
{{experimental_inline}} {{jsxref("Statements/let", "let")}}
-
Declares a block scope local variable, optionally initializing it to a value.
-
{{experimental_inline}} {{jsxref("Statements/const", "const")}}
-
Declares a read-only named constant.
-
- -

Functions and classes

- -
-
{{jsxref("Statements/function", "function")}}
-
Declares a function with the specified parameters.
-
{{experimental_inline}} {{jsxref("Statements/function*", "function*")}}
-
Generators functions enable writing iterators more easily.
-
{{jsxref("Statements/return", "return")}}
-
Specifies the value to be returned by a function.
-
{{experimental_inline}} {{jsxref("Statements/class", "class")}}
-
Declares a class.
-
- -

Iterations

- -
-
{{jsxref("Statements/do...while", "do...while")}}
-
Creates a loop that executes a specified statement until the test condition evaluates to false. The condition is evaluated after executing the statement, resulting in the specified statement executing at least once.
-
{{jsxref("Statements/for", "for")}}
-
Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.
-
{{deprecated_inline}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for each...in")}}
-
Iterates a specified variable over all values of object's properties. For each distinct property, a specified statement is executed.
-
{{jsxref("Statements/for...in", "for...in")}}
-
Iterates over the enumerable properties of an object, in arbitrary order. For each distinct property, statements can be executed.
-
{{experimental_inline}} {{jsxref("Statements/for...of", "for...of")}}
-
Iterates over iterable objects (including arrays, array-like objects, iterators and generators), invoking a custom iteration hook with statements to be executed for the value of each distinct property.
-
{{jsxref("Statements/while", "while")}}
-
Creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.
-
- -

Others

- -
-
{{jsxref("Statements/debugger", "debugger")}}
-
Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.
-
{{experimental_inline}} {{jsxref("Statements/export", "export")}}
-
Used to export functions to make them available for imports in external modules, another scripts.
-
{{experimental_inline}} {{jsxref("Statements/import", "import")}}
-
Used to import functions exported from an external module, another script.
-
{{jsxref("Statements/label", "label")}}
-
Provides a statement with an identifier that you can refer to using a break or continue statement.
-
- -
-
{{deprecated_inline}} {{jsxref("Statements/with", "with")}}
-
Extends the scope chain for a statement.
-
- -

Specifications

- - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
ECMAScript 1st Edition.StandardInitial definition.
{{SpecName('ES5.1', '#sec-12', 'Statements')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ES6')}}New: function*, let, for...of, yield, class
- -

See also

- - diff --git a/files/it/web/javascript/reference/statements/let/index.html b/files/it/web/javascript/reference/statements/let/index.html deleted file mode 100644 index 7900b7673a..0000000000 --- a/files/it/web/javascript/reference/statements/let/index.html +++ /dev/null @@ -1,208 +0,0 @@ ---- -title: let -slug: Web/JavaScript/Reference/Statements/let -translation_of: Web/JavaScript/Reference/Statements/let ---- -
{{jsSidebar("Statements")}}
- -

L'istruzione let dichiara una variabile locale nel blocco di codice e, facoltativamente, la inizializza ad un valore.

- -
{{EmbedInteractiveExample("pages/js/statement-let.html")}}
- - - -

Sintassi

- -
let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];
-
- -

Parametri

- -
-
var1, var2, …, varN
-
Il nome della variabile o delle variabili da dichiarare. Devono essere identificatori JavaScript validi.
-
value1, value2, …, valueN {{optional_inline}}
-
Per ogni variabile definita, è possibile specificare il valore iniziale usando qualunque espressione JavaScript valida.
-
- -

Descrizione

- -

let permette di dichiarare variabili limitandone la visibilità ad un {{jsxref("statements/block", "blocco di codice", "", 1)}}, o ad un'espressione in cui è usata, contrariamente alla parola chiave var, che invece definisce una variabile globalmente in uno script o localmente in una funzione a prescindere dal blocco di codice. L'altra differenza tra {{jsxref("statements/var", "var")}} e let è che la seconda è inizializzata ad un valore solo quando un parser la evaluta (vedi sotto).

- -

Esempi

- -

Regole di visibilità

- -

Le variabili inizializzate da let sono legate al blocco dell'espressione in cui sono dichiarate. Il suo funzionamento è del tutto simile a quello di var, ma le variabili definite da quest'ultima istruzione sono sempre variabili globali a livello di programma o di funzione, hanno quindi una visibilità più ampia.

- -
function varTest() {
-  var x = 1;
-  {
-    var x = 2;  // same variable!
-    console.log(x);  // 2
-  }
-  console.log(x);  // 2
-}
-
-function letTest() {
-  let x = 1;
-  {
-    let x = 2;  // different variable
-    console.log(x);  // 2
-  }
-  console.log(x);  // 1
-}
- -

Dichiarare nuovamente la stessa variabile con let restituisce l'errore TypeError.

- -

-if (x) {
-  let foo;
-  let foo; // lancia un errore TypeError.
-}
- -

Se usata al livello più alto di programma, let, a differenza di var, non crea una proprietà seuul'oggetto globale. Per esempio:

- -
var x = 'global';
-let y = 'global';
-console.log(this.x); // "global"
-console.log(this.y); // undefined
- -

Potresti imbatterti in errori in un blocco switch perché i casi non vengono separati ma fanno parte tutti dello stesso blocco.

- -

-switch (x) {
-  case 0:
-    let foo;
-    break;
-
-  case 1:
-    let foo; // TypeError for redeclaration.
-    break;
-}
- -

Esempi

- -

Una let expression può essere usata per limitare la visibilità della variabile dichiarata alla sola espressione chiamata.

- -

-var a = 5;
-let(a = 6) alert(a); // 6
-alert(a); // 5
- -

Usando let in un blocco di codice ne limitiamo la visibilità al solo blocco racchiuso. Nel codice di esempio nota come le due assegnazioni nel blocco if diano due risultati diversi.

- -

-var a = 5;
-var b = 10;
-
-if (a === 5) {
-  let a = 4; // La visibilità è dentro il blocco if
-  var b = 1; // La visibilità è dentro la funzione
-
-  console.log(a);  // 4
-  console.log(b);  // 1
-}
-
-console.log(a); // 5
-console.log(b); // 1
- -

Puoi usare let come iteratore in un ciclo for invece di usare una nuova variabile globale.

- -

-for (let i = 0; i<10; i++) {
-  alert(i); // 1, 2, 3, 4 ... 9
-}
-
-alert(i); // i non è definita
- -

Quando lavori con i costruttori puoi usare let per creare in'interfaccia privata senza chiusure.

- -

-/*\
-|*|
-|*|  :: Una API pubblica e riutilizzabile per i costruttori ... ::
-|*|
-\*/
-
-let (
-  switchScope = function (oOwner, fConstructor) {
-    return oOwner && oOwner.constructor === fConstructor ? oOwner : this;
-  }
-) {
-  function buildIndoors (fConstructor) {
-    const oPrivate = new fConstructor(this);
-    this.getScope = oPrivate.getScope = switchScope.bind(this, oPrivate);
-    return oPrivate;
-  }
-}
-
-/*\
-|*|
-|*|  :: Use of the *let* statement in order to create a private interface without closures... ::
-|*|
-\*/
-
-let (
-
-  /* "Secrets" is the constructor of the private interface */
-
-  Secrets = function Secrets (oPublic /* (the public interface) */) {
-    /* setting a private property... */
-    this.password = Math.floor(Math.random() * 1e16).toString(36);
-    /* you can also store the public interface into a private property... */
-    /* this.publicInterface = oPublic; */
-    alert("I\'m getting a public property from a private constructor...: somePublicProperty: " + oPublic.somePublicProperty);
-  }
-
-) {
-
-  /* "User" is the constructor of the public interface */
-
-  function User (sNick) {
-    /* setting a public property... */
-    this.somePublicProperty = "Hello World!";
-    const oPrivate = this.createScope(Secrets); /* (the private interface) */
-    /* setting a public property... */
-    this.user = sNick;
-    alert("I\'m getting a private property from a public constructor...: password: " + oPrivate.password);
-  }
-
-  User.prototype.somePublicMethod = function () {
-    const oPrivate = this.getScope(Secrets); /* (the private interface) */
-    alert("I\'m getting a public property from a public method...: user: " + this.user);
-    alert("I\'m getting a private property from a public method...: password: " + oPrivate.password);
-    oPrivate.somePrivateMethod();
-  };
-
-  Secrets.prototype.somePrivateMethod = function () {
-    const oPublic = this.getScope(); /* (the public interface) */
-    alert("I\'m getting a public property from a private method...: user: " + oPublic.user);
-    alert("I\'m getting a private property from a private method...: password: " + this.password);
-  };
-
-  /* ...creating a mutual access... */
-
-  User.prototype.createScope = buildIndoors;
-}
-
-/* out of the *let* statement you have not access to the private interface! */
-
-const johnSmith = new User("John Smith");
-johnSmith.somePublicMethod();
- -

Browser compatibility

- - - -

{{Compat("javascript.statements.let")}}

- -

- -

See also

- - diff --git a/files/it/web/javascript/reference/statements/switch/index.html b/files/it/web/javascript/reference/statements/switch/index.html deleted file mode 100644 index aef4d668ce..0000000000 --- a/files/it/web/javascript/reference/statements/switch/index.html +++ /dev/null @@ -1,320 +0,0 @@ ---- -title: switch -slug: Web/JavaScript/Reference/Statements/switch -tags: - - JavaScript - - Reference - - Statement - - Web -translation_of: Web/JavaScript/Reference/Statements/switch ---- -
{{jsSidebar("Statements")}}
- -

Il comandoswitch valuta un espressione, confronta il valore dell'espressione con ciascuna delle clausole case ed esegue i comandi (statements) associati alla clausola (case) che verifica il confronto.

- -

Sintassi

- -
switch (espressione) {
-  case valore1:
-    //Comandi eseguiti quando il valore dell'espressione coincide con valore1
-    [break;]
-  case valore2:
-    //Comandi eseguiti quando il valore dell'espressione coincide con valore2
-    [break;]
-  ...
-  case valoreN:
-    //Comandi eseguiti quando il valore dell'espressione coincide con valoreN
-    [break;]
-  default:
-    //Comandi eseguiti quando nessuno dei valori coincide col valore dell'epressione
-    [break;]
-}
- -
-
espressione
-
Un'espressione il cui risultato è confrontato con ogni clausola case.
-
case valoreN
-
Clausola case usata nel confronto con l' espressione.
-
default
-
Una clausola default è facoltativa e, se specificata, la clausola viene eseguita se il valore dell'espressione non corrisponde a nessuna clausola case.
-
- -

Descrizione

- -

Un comando switch per prima cosa valuta espressione; poi cerca la prima clausola case la cui essa ha lo stesso valore del risultato dell'espressione di switch (utilizzando la strict comparison, ===); quindi il comando switch trasferisce il controllo alla clausola case, eseguendone i comandi. Se più clausole case sono verificate dal confronto con l'espressione di switch,  viene scelta la prima che verifica il confronto, anche se le clausole non sono uguali. Se nessuna clausola case risulta verificata dal confronto, il programma cerca la clausola facoltativa default, e se la trova, trasferisce il controllo a questa, eseguendone i comandi. Se non viene trovata alcuna clausola default, il programma continua eseguendo il comando successivo alla fine del comando switch. Convenzionalmente, ma non necessariamente, la clausola default è l'ultima clausola.

- -

Il comando facoltativo break associato a ciascuna etichetta case assicura che, una volta eseguiti i comandi della clausola che verifica l'espressione di switch, il programma interrompa il comando switch e che continui eseguendo il comando successivo. Se il comando break viene omesso, il programma continua l'esecuzione dal comando successivo all'interno del comando di switch, quindi dal primo della successiva clausola case.

- -

Esempi

- -

Utilizzo di switch

- -

Nell'esempio seguente, se expr vale "Banane", il programma confronta il valore con la clausola "Banane" ed esegue i comandi associati. Quando incontra break, il programma interrompe il comando switch ed esegue il comando successivo a switch. Se break fosse omesso, sarebbero eseguiti anche i comandi della clausola "Ciliegie".

- -
switch (expr) {
-  case "Arance":
-    console.log("Le arance costano €1,0 al chilo.");
-    break;
-  case "Mele":
-    console.log("Le mele costano €0.64 al chilo.");
-    break;
-  case "Banane":
-    console.log("Le banane costano €0.92 al chilo.");
-    break;
-  case "Ciliege":
-    console.log("Le ciliegie costano €2.59 al chilo.");
-    break;
-  case "Manghi":
-  case "Papaye":
-    console.log("I manghi e le papaye costano €1.79 al chilo.");
-    break;
-  default:
-    console.log("Spiacenti, non abbiamo " + expr + ".");
-}
-
-console.log("Desidera qualcos'altro ?");
-
- -

Cosa accade se dimentico un break?

- -

Se vi dimenticate un break, lo script partirà dalla clausola il cui criterio è verificato, e proseguirà con la clausola successiva anche se il criterio non era verifcato. Ecco alcuni esempi:

- -
var foo = 0;
-switch (foo) {
-  case -1:
-    console.log('1 negativo');
-    break;
-  case 0: // foo è 0 quindi il criterio è verificato; questo blocco verrà eseguito
-    console.log(0);
-    // NOTA: il break dimenticato sarebbe dovuto essere qui
-  case 1: // manca il comando break in 'case 0:' quindi anche questo blocco sarà eseguito
-    console.log(1);
-    break; // incontra questo break così con proseguirà in 'case 2:'
-  case 2:
-    console.log(2);
-    break;
-  default:
-    console.log('default');
-}
- -

Posso mettere un default in mezzo?

- -

Certo che puoi! JavaScript passerà al default se non troverà nessun criterio corrispondente:

- -
var foo = 5;
-switch (foo) {
-  case 2:
-    console.log(2);
-    break; // incontra un break, quindi non procederà automaticamente su "default:"
-  default:
-    console.log('default')
-    // non c'è un break, quindi verrà eseguito anche il contenuto di "case 1:"!
-  case 1:
-    console.log('1');
-}
- -

Funziona anche se metti default prima di ogni altra clausola.

- -

Riscrivere molteplici istruzioni If con Switch

- -

Di seguito viene fornito un esempio:

- -
var a = 100;
-var b = NaN;
-switch (true) {
-  case isNaN(a) || isNaN(b):
-    console.log('NaNNaN');
-    break;
-  case a === b:
-    console.log(0);
-    break;
-  case a < b:
-    console.log(-1);
-    break;
-  default:
-    console.log(1);
-}
- - - -

Metodi per i case con più criteri

- -

I sorgenti per questa tecnica possono essere scaricati qui:

- -

Switch statement multiple cases in JavaScript (Stack Overflow)

- -

Multi-case - operazione singola

- -

Questo metodo si avvale del fatto che se non c'è un break break prima di un comando di case continuerà eseguento il successivo comando di case ingnorando se verifica il criterio di esecuzione. Vedi la sezione  "Cosa accade se dimentico un break?"

- -

Questo è un esempio di un comando di switch a singola operazione sequenziale, dove quattro valori diversi realizzano la stessa cosa.

- -
var Animale = 'Giraffa';
-switch (Animale) {
-  case 'Mucca':
-  case 'Giraffa':
-  case 'Cane':
-  case 'Maiale':
-    console.log('Queso animale anndrà sull'Arca di Noè.');
-    break;
-  case 'Dinosauro':
-  default:
-    console.log('Questo animale non andrà.');
-}
- -

Multi-case - operazioni concatenate

- -

Questo è un esempio di un comando di switch ad operazione multipla sequenziale, dove, a seconda del numero intero fornito, si ricevono diversi output. Mostra come sia possibile sfruttare l'ordine in cui sono scritte le clausole, e come non debbano essere numericamente in sequenza. In JavaScript, si possono anche inserire definizioni di stringhe nei comandi case.

- -
var foo = 1;
-var output = 'Output: ';
-switch (foo) {
-  case 10:
-    output += 'quindi ';
-  case 1:
-    output += 'quale ';
-    output += 'è ';
-  case 2:
-    output += ' il tuo ';
-  case 3:
-    output += 'nome';
-  case 4:
-    output += '?';
-    console.log(output);
-    break;
-  case 5:
-    output += '!';
-    console.log(output);
-    break;
-  default:
-    console.log('Per favore prendere un numero da 1 a 5 o 10!');
-}
- -

Output per questo esempio:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ValoreTesto di log
foo è diverso da 1, 2, 3, 4, 5 or 10Per favore prendere un numero da 1 a 5 o 10!
10Output: quindi quale è il tuo nome?
1Output: quale è il tuo nome?
2Output: il tuo nome?
3Output: nome?
4Output: ?
5Output: !
- -

Specifiche

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificheStatusCommento
{{SpecName('ES3')}}{{Spec2('ES3')}}Definizione iniziale. Relaizzata in JavaScript 1.2
{{SpecName('ES5.1', '#sec-12.11', 'switch statement')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}}
- -

Compatibilità dei browser

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Vedi anche

- - diff --git a/files/it/web/javascript/reference/statements/throw/index.html b/files/it/web/javascript/reference/statements/throw/index.html deleted file mode 100644 index 1aecd9ca9a..0000000000 --- a/files/it/web/javascript/reference/statements/throw/index.html +++ /dev/null @@ -1,195 +0,0 @@ ---- -title: throw -slug: Web/JavaScript/Reference/Statements/throw -tags: - - JavaScript - - Statement -translation_of: Web/JavaScript/Reference/Statements/throw ---- -
{{jsSidebar("Statements")}}
- -

L'istruzione throw chiama un'eccezione definita dall'utente. L'esecuzione della funzione corrente si interrompe (ovvero i comandi successivi a throw non verranno eseguiti), e il controllo verrà passato al primo blocco catch nella pila delle chiamate. Se non è previsto nessun blocco catch esiste nella funzione chiamante, il programma verrà terminato.

- -
{{EmbedInteractiveExample("pages/js/statement-throw.html")}}
- - - -

Sintassi

- -
throw espressione;
- -
-
espressione
-
L'espressione da chiamare.
-
- -

Descrizione

- -

Usa l'istruzione throw per chiamare un'eccezione. Quando chiami un'eccezione, l'espressione specifica il valore dell'eccezione. Ognuna delle seguenti righe chiama un'eccezione.

- -
throw 'Error2'; // genera un'eccezione con una stringa con valore Error2
-throw 42;       // genera un'eccezione con valore 42
-throw true;     // genera un'eccezione con valore true
- -

Nota bene che l'istruzione throw viene gestita dall'automatic semicolon insertion (ASI) e quindi non puoi andare a capo fra throw e l'espressione.

- -

Esempi

- -

Chiama un oggetto

- -

Puoi specificare un oggetto quando chiami un eccezione. In seguito puoi riportare le proprietà dell'oggetto nel blocco catch. L'esempio seguente crea un oggetto di tipo UserException e poi lo usa nell'istruzione throw.

- -
function UserException(message) {
-   this.message = message;
-   this.name = 'UserException';
-}
-function getMonthName(mo) {
-   mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec)
-   var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
-      'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-   if (months[mo] !== undefined) {
-      return months[mo];
-   } else {
-      throw new UserException('InvalidMonthNo');
-   }
-}
-
-try {
-   // statements to try
-   var myMonth = 15; // 15 is out of bound to raise the exception
-   var monthName = getMonthName(myMonth);
-} catch (e) {
-   monthName = 'unknown';
-   console.log(e.message, e.name); // pass exception object to err handler
-}
-
- -

Un altro esempio di chiamata ad un oggetto

- -

L'esempio seguente testa una stringa in input per un codice postale di avviamento postale (CAP) americano. Se il CAP fornito è in un formato non valido, l'istruzione throw chiama un'eccezione creando un oggetto di tipo ZipCodeFormatException.

- -
/*
- * Creates a ZipCode object.
- *
- * Accepted formats for a zip code are:
- *    12345
- *    12345-6789
- *    123456789
- *    12345 6789
- *
- * If the argument passed to the ZipCode constructor does not
- * conform to one of these patterns, an exception is thrown.
- */
-
-function ZipCode(zip) {
-   zip = new String(zip);
-   pattern = /[0-9]{5}([- ]?[0-9]{4})?/;
-   if (pattern.test(zip)) {
-      // zip code value will be the first match in the string
-      this.value = zip.match(pattern)[0];
-      this.valueOf = function() {
-         return this.value
-      };
-      this.toString = function() {
-         return String(this.value)
-      };
-   } else {
-      throw new ZipCodeFormatException(zip);
-   }
-}
-
-function ZipCodeFormatException(value) {
-   this.value = value;
-   this.message = 'does not conform to the expected format for a zip code';
-   this.toString = function() {
-      return this.value + this.message;
-   };
-}
-
-/*
- * This could be in a script that validates address data
- * for US addresses.
- */
-
-const ZIPCODE_INVALID = -1;
-const ZIPCODE_UNKNOWN_ERROR = -2;
-
-function verifyZipCode(z) {
-   try {
-      z = new ZipCode(z);
-   } catch (e) {
-      if (e instanceof ZipCodeFormatException) {
-         return ZIPCODE_INVALID;
-      } else {
-         return ZIPCODE_UNKNOWN_ERROR;
-      }
-   }
-   return z;
-}
-
-a = verifyZipCode(95060);         // returns 95060
-b = verifyZipCode(9560);          // returns -1
-c = verifyZipCode('a');           // returns -1
-d = verifyZipCode('95060');       // returns 95060
-e = verifyZipCode('95060 1234');  // returns 95060 1234
-
- -

Richiamare un'eccezione

- -

Puoi usare throw per richiamare un'eccezione dopo averla già gestita. L'esempio seguente gestisce un'eccezione con un valore numerico e la richiama se tale valore supera 50. Un'eccezione richiamata si propaga fino alla funzione che la racchiude oppure fino al livello più alto in modo che l'utente la veda.

- -
try {
-   throw n; // throws an exception with a numeric value
-} catch (e) {
-   if (e <= 50) {
-      // statements to handle exceptions 1-50
-   } else {
-      // cannot handle this exception, so rethrow
-      throw e;
-   }
-}
-
- -

Specifiche

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Definizione iniziale. Implementata in JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}{{Spec2('ESDraft')}} 
- -

Compatibilità dei browser

- - - -

{{Compat("javascript.statements.throw")}}

- -

Vedi anche

- - diff --git a/files/it/web/javascript/reference/statements/var/index.html b/files/it/web/javascript/reference/statements/var/index.html deleted file mode 100644 index 41ee508d3c..0000000000 --- a/files/it/web/javascript/reference/statements/var/index.html +++ /dev/null @@ -1,221 +0,0 @@ ---- -title: var -slug: Web/JavaScript/Reference/Statements/var -tags: - - Dichiarazioni - - Globali - - JavaScript - - Locali - - Valore - - Variabili - - funzione -translation_of: Web/JavaScript/Reference/Statements/var ---- -
{{jsSidebar("Statements")}}
- -

La dichiarazione variabile  dichiara una variabile, opzionalmente inizializzabile ad un valore.

- -
{{EmbedInteractiveExample("pages/js/statement-var.html")}}
- - - -

Sintassi

- -
var nomevariabile1 [= valore1] [, nomevariabile2 [= valore2] ... [, nomevariabileN [= valoreN]]];
- -
-
nomevariabileN
-
Il nome della variabile. Può essere qualunque identificatore legale.
-
- -
-
valoreN
-
Valore iniziale della variabile. Può essere qualunque espressione legale. Il valore di default è undefined (non definito).
-
- -

 Descrizione

- -

Le dichiarazioni di variabile, ovunque appaiano, sono processate prima dell'esecuzione di qualsiasi codice. L'ambiente di una variabile dichiarata con var è il suo attuale contesto di esecuzione, che è la funzione di chiusura o, per le variabili dichiarate al di fuori di qualsiasi funzione, globale. Se si dichiara nuovamente una variabile JavaScript, il suo valore non sarà perso.

- -

Assegnando un valore a una variabile non dichirata la rende implicitamente globale (diventa una proprietà dell'oggetto) quando viene eseguita. Le differenze fra variabili dichiarate e non dichiarate sono:

- -

1. Le variabili dichiarate sono legate al contesto in cui sono dichiarate. Quelle non dichiarate sono sempre globali.

- -
function x() {
-  y = 1;   // Genera un ReferenceError in strict mode
-  var z = 2;
-}
-
-x();
-
-console.log(y); // scrive "1" in console
-console.log(z); // Genera un ReferenceError: z non è definita fuori dalla funzione x
-
- -

2. Variabili dichiarate sono create prima dell'esecuzione del codice. Variabili non dichiarate non esistono finchè il codice assegnato loro non viene eseguito.

- -
console.log(a);                // Genera un ReferenceError.
-console.log('still going...'); // Non verrà eseguito.
- -
var a;
-console.log(a);                // scrive in console "undefined" o "" a seconda del browser usato.
-console.log('still going...'); // scrive in console "still going...".
- -

3. Variabili dichiarate diventano una proprietà non configurabile del loro contesto di esecuzione (funzione o globale). Quelle non dichiarate sono configurabili (per esempio, possono essere cancellate).

- -
var a = 1;
-b = 2;
-
-delete this.a; // Genera un TypeError in strict mode. Altrimenti fallisce senza generare messaggi.
-delete this.b;
-
-console.log(a, b); // Genera un ReferenceError.
-// La proprietà 'b' è stata cancellata e non esiste più.
- -

A causa di queste tre differenze, il fallimento della dichiarazione di variabile porta molto probabilmente a risultati inaspettati. Pertanto è raccomandato di dichiarare sempre le variabili, indipendentemente dal loro contesto di appartenenza (funzione o globale). In ECMAScript 5 strict mode, assegnare una variabile non dichiarata genera un errore.

- -

Hoisting di var

- -

Poichè le dichiarazioni di variabile (come le dichiarazioni in generale) sono processate prima dell'esecuzione del codice, dichiararne una in qualsiasi punto del codice è equivalente al dichiararle in cima. Questo significa anche che quella variabile può essere usata prima della dichiarazione. Questo comportamento è chiamato "hoisting" (sollevamento, innalzamento), poichè sembra che la dichiarazione di variabile sia portata in cima alla funzione o al codice globale.

- -
bla = 2;
-var bla;
-// ...
-
-// è implicitamente interpretato come:
-
-var bla;
-bla = 2;
-
- -

Per questa ragione, è consigliato sempre dichiarare le variabili in cima al loro ambiente (in cima al codice globale o della funzione in cui appaiono) al fine di rendere chiaro quali variabili appartengono alle funzioni (locali) e quali no.

- -

È importante precisare che l'hoisting è applicato alla dichiarazione della variabile, ma non all'inizializzazione del suo valore. Il valore verrà infatti assegnato al raggiungimento della dichiarazione :

- -
function fai_qualcosa() {
-  console.log(bar); // non definito
-  var bar = 111;
-  console.log(bar); // 111
-}
-
-// è implicitamente interpretato come:
-function fai_qualcosa() {
-  var bar;
-  console.log(bar); // non definito
-  bar = 111;
-  console.log(bar); // 111
-}
-
- -

 

- -

Esempi

- -

Dichiarare e inizializzare due variabili

- -
var a = 0, b = 0;
-
- -

Assegnare un singolo valore stinga a due variabili

- -
var a = 'A';
-var b = a;
-
-// è come dire:
-
-var a, b = a = 'A';
-
- -

Prestare attenzione all'ordine:

- -
var x = y, y = 'A';
-console.log(x + y); // non definito
-
- -

Qui, x e y sono dichiarate prima dell'esecuzione del codice, gli assegnamenti verranno eseguiti in seguito. Nel momento in cui "x = y" viene valutato, y esiste quindi nessun ReferenceError viene generato e il suo valore risulta essere 'undefined' (non definit). Quindi, x è assegnata ad un valore non definito. Ora, ad y è assegnato il valore 'A'. Di conseguenza, dopo la prima riga, x === undefined && y === 'A'. Da qui il risultato.

- -

Inizializzazione di più variabili

- -
var x = 0;
-
-function f() {
-  var x = y = 1; // x è dichiarata localmente. y invece no!
-}
-f();
-
-console.log(x, y); // Genera un ReferenceError in strict mode (y non è definita). 0, 1 altrimenti.
-// In modalità non-strict mode:
-// x è la globale come si ci aspettava
-// però, y è uscita fuori dalla funzione!
- -

Globali implicite e ambienti esterni alle funzioni

- -

Le variabili che sembrano essere globali implicite possono essere riferimenti a variabili nell'ambito di una funzione esterna:

- -
var x = 0;  // x è dichiarata dentro l'ambiente file, poi le è assegnato valore 0
-
-console.log(typeof z); // undefined, poichè z ancora non esiste
-
-function a() { // quando a è chiamata,
-  var y = 2;   // y è dichiarata dentro l'ambiente della funzione a, e le è assegnato valore 2
-
-  console.log(x, y);   // 0 2
-
-  function b() {       // quando b è chiamata
-    x = 3;  // assegna 3 all'esistente ambiente x, non crea una nuova variabile globale
-    y = 4;  // assegna 4 all'esistente esterna y, non crea una nuova variabile globale
-    z = 5;  // crea una nuova variabile globale z e le assegna valore 5.
-  }         // (Throws a ReferenceError in strict mode.)
-
-  b();     // chiamare b crea z come variabile globale
-  console.log(x, y, z);  // 3 4 5
-}
-
-a();                   // chiamando a si richiama b
-console.log(x, z);     // 3 5
-console.log(typeof y); // non definito, perchè y è locale alla funzione a
- -

Specifiche

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificaStatoCommento
{{SpecName('ES1')}}{{Spec2('ES1')}}Definizione iniziale, implementata in JavaScript 1.0
{{SpecName('ES5.1', '#sec-12.2', 'var statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-variable-statement', 'variable statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-variable-statement', 'variable statement')}}{{Spec2('ESDraft')}} 
- -

Compatibilità Browser

- - - -

{{Compat("javascript.statements.var")}}

- -

Guarda anche

- - -- cgit v1.2.3-54-g00ecf