You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: README.md
+8-3Lines changed: 8 additions & 3 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -15,7 +15,9 @@ yarn
15
15
yarn pull-en
16
16
17
17
# Optional: Verify your changes will correctly replace the english files
18
-
yarn validate-paths
18
+
yarn lint
19
+
# Alternative: Run the lint watcher
20
+
yarn lint --watch
19
21
```
20
22
21
23
That's it, you've got a copy of all the documentation and now can write documentation which follows the existing patterns.
@@ -46,7 +48,8 @@ For example if you wanted to translate a new handbook page you would:
46
48
- Pull in the English files `yarn pull-en` (these will be gitignored)
47
49
- Find your english file: `docs/documentation/en/handbook-v2/Basics.md`
48
50
- Recreate the same folder path in your language: `docs/documentation/it/handbook-v2/Basics.md`
49
-
- Translate the file!
51
+
- Translate the file!
52
+
- Validate your changes: `yarn lint` (or `yarn lint docs/documentation/it/handbook-v2/Basics.md`)
50
53
- Create a pull request to this repo
51
54
- Once merged, the translation will appear on the next website deploy
52
55
@@ -56,12 +59,14 @@ When a new language is created, we ask for a few people to become language owner
56
59
57
60
The TypeScript team generally only know English, and can answer clarifying questions if needed! For quick questions, you can use the `ts-website-translation` channel in the [TypeScript Discord](https://discord.gg/typescript).
58
61
59
-
#### Well tested
62
+
#### Secure
60
63
61
64
This repo has extensive CI to ensure that you can't accidentally break the TypeScript website.
62
65
63
66
There are local, fast checks that it won't break via `yarn test` and then the full TypeScript website test suite runs with the changes, and a website build is generated to ensure that nothing breaks.
64
67
68
+
The checks may not seem obvious to an outsider, because the website is complex, so there is a watch mode which you can run via `yarn link --watch` to get instant feedback.
69
+
65
70
# Contributing
66
71
67
72
This project welcomes contributions and suggestions. Most contributions require you to agree to a
oneline: "Emette Javascript compatibile e più dettagliato per oggetti iterativi"
4
+
---
5
+
6
+
Iterazione di livello inferiore, o Downleveling, è un termine di TypeScript utilizzato per migrare verso una versione precedente di JavaScript. Questa flag permette quindi di supportare una più accurata implementazione di come il JavaScript moderno itera i nuovi concetti in versioni precedenti di JavaScript in runtime.
7
+
8
+
ECMAScript 6 aggiunge una serie di nuove iterazioni primitive: il `for / of` loop (`for (el of arr)`), spread di Array (`[a, ...b]`), spread di argomenti (`fn (... args)`) e [`Symbol.iterator`](https://medium.com/trainingcenter/iterators-em-javascript-880adef14495).`--downlevelIteration` permette a queste iterazioni primitive di essere utilizzate in modo più accurrato in un ambiente ES5 se un'implementazione di [`Symbol.iterator`](https://medium.com/trainingcenter/iterators-em-javascript-880adef14495) è presente.
9
+
10
+
#### Esempio: Effetti su `for / of`
11
+
12
+
Con questo codice TypeScript:
13
+
14
+
```js
15
+
conststr="Ciao!";
16
+
for (constsof str) {
17
+
console.log(s);
18
+
}
19
+
```
20
+
21
+
Senza `downlevelIteration` attivo, un loop `for / of` su un qualsiasi oggetto viene convertito in un tradizionale `for` loop:
22
+
23
+
```ts twoslash
24
+
// @target: ES5
25
+
// @showEmit
26
+
const str ="Ciao!";
27
+
for (const s ofstr) {
28
+
console.log(s);
29
+
}
30
+
```
31
+
32
+
Generalmente tutti si aspettano questo, tuttavia non è compatibile al 100% con il protocollo di iterazione ECMAScript 6. Certe string, ad esempio un emoji (😜), hanno un `.length` di 2 (o anche di più!), ma dovrebbero iterare come 1 unità in un `for-of` loop. Guarda [questo blog post di Jonathan New](https://blog.jonnew.com/posts/poo-dot-length-equals-two) per una spiegazione più dettagliata.
33
+
34
+
Quando `downlevelIteration` è attivo, TypeScript utilizzerà una funzione ausiliaria che andrà a controllare la presenza di un `Symbol.iterator` (che può essere di tipo nativo o polyfill). Nel caso in cui questa implementazione non ci sia, ritornerai ad un'iterazione index-based.
35
+
36
+
```ts twoslash
37
+
// @target: ES5
38
+
// @downlevelIteration
39
+
// @showEmit
40
+
const str ="Ciao!";
41
+
for (const s ofstr) {
42
+
console.log(s);
43
+
}
44
+
```
45
+
46
+
Puoi utilizzare [tslib](https://www.npmjs.com/package/tslib) via [importHelpers](#importHelpers) in modo da ridurre il numero di righe inline Javascript:
47
+
48
+
```ts twoslash
49
+
// @target: ES5
50
+
// @downlevelIteration
51
+
// @importHelpers
52
+
// @showEmit
53
+
const str ="Ciao!";
54
+
for (const s ofstr) {
55
+
console.log(s);
56
+
}
57
+
```
58
+
59
+
> > **Nota:** attivare `downlevelIteration` non andrà a migliorare le prestazioni di compliazione se `Symbol.iterator` non è presente in runtime.
60
+
61
+
#### Esempio: Effetti sullo spray di Array
62
+
63
+
Questo è un spread di array:
64
+
65
+
```js
66
+
// Crea un nuovo array composto dall'elemento 1 seguito dagli elementi di arr2
67
+
constarr= [1, ...arr2];
68
+
```
69
+
70
+
Secondo la descrizione, sembra facile convertirlo in ES5:
71
+
72
+
```js
73
+
// Stessa cosa, no?
74
+
constarr= [1].concat(arr2);
75
+
```
76
+
77
+
Tuttavia, questo è visibilmente diverso in certi rari casi. Ad esempio, nel caso un array abbia un "buco", l'index mancante andrà a creare una proprietà *own* nel caso si decida di applicare uno spread, ma non se creato utilizzando `.concat`:
78
+
79
+
```js
80
+
// Crea un array dove manca l'elemento '1'
81
+
let mancante = [0, , 1];
82
+
let spread = [...mancante];
83
+
let concatenato = [].concat(mancante);
84
+
85
+
// true
86
+
"1"in spread;
87
+
// false
88
+
"1"in concatenato;
89
+
```
90
+
91
+
Proprio come un `for / of`, `downlevelIteration` andrà ad usare `Symbol.iterator` (se presente) in modo da emulare in modo più preciso il comportamento di ES 6.
oneline: "Permette di importare alcune funzioni ausiliari per il progetto"
4
+
5
+
---
6
+
7
+
TypeScript da alcuni suggerimenti per operazioni di livello inferiore come ad esempio estendere classi, spread di array o oggetti, e operazioni asincrone. In modo predefinito, questi suggerimenti vengono dati nei file che usano le operazioni elencate in precedenza. Tuttavia, nel caso in cui lo stesso suggerimento è usato in più moduli diversi, si possono verificare alcuni casi di duplicazione del codice.
8
+
9
+
Se l'opzione `importHelpers` è attiva, queste funzionalità ausiliari vengono importate dal modulo [tslib](https://www.npmjs.com/package/tslib). Dovrai assicurarti che il modulo `tslib` è in grado di essere importato in runtime. Questo riguarda solo i moduli; I file degli script globali non proveranno ad importare i moduli.
oneline: "Crea dei file .tsbuildinfo per permettere la compilazione incrementale del progetto"
4
+
---
5
+
6
+
Dice a TypeScript di salvare le informazioni riguardo il grafo del progetto dall'ultima compliazione nei file salvati nel disco.
7
+
Questo crea una serie di file `.tsbuildinfo` nella stessa cartella del risultato della compilazione. Essi non vengono usati dal tuo JavaScript durante l'esecuzione e possono essere tranquillamente eliminati. Puoi saperne di più riguardo questa flag nelle [3.4 note di rilascio](/docs/handbook/release-notes/typescript-3-4.html#faster-subsequent-builds-with-the---incremental-flag).
8
+
9
+
Per scegliere in che cartella vuoi i tuoi file compilati, usa l'opzione di configurazione [`tsBuildInfoFile`](#tsBuildInfoFile).
oneline: "Si assicura che ogni file possa essere compilato in sicurezza senza basarsi sulle altre importazioni"
4
+
---
5
+
6
+
Quando usi TypeScript per produrre codice JavaScript, è usanza comune usare altri transpilers come ad esempio [Babel](https://babeljs.io).
7
+
Tuttavia, gli altri transpilers possono operare solo su un singolo file alla volta, questo significa che non possono fare cambiamenti che dipendono dalla comprensione dell'intero progetto.
8
+
Questa regola si applica anche al `ts.transpileModule` API di TypeScript che è usata da alcuni strumenti di esecuzione.
9
+
10
+
Queste limitazioni possono causare problemi di esecuzione con alcune funzionalità di TypeScript come `const enum` e `namespace`.
11
+
Impostando la flag `isolatedModules` chiedi a TypeScript di avvisarti se stai scrivendo del codice che non può essere correttamente interpretato da un processo di transpilation su un singolo file.
12
+
13
+
Esso non cambia la forma del tuo codice e nemmeno la forma del controllo di TypeScript e il processo di emissione.
14
+
15
+
Alcuni esempi di codice che non funzionano quando `isolatedModules` è abilitato.
16
+
17
+
#### Esportazione di idententificatori senza valore
18
+
19
+
In TypeScript, puoi importare un _type_ e di conseguenza esportarlo:
20
+
21
+
```ts twoslash
22
+
// @noErrors
23
+
import { tipo, funzione } from"modulo";
24
+
25
+
funzione();
26
+
27
+
export { tipo, funzione };
28
+
```
29
+
30
+
Dato che non ci sono valori per `tipo`, l'emissione `export` non proverà ad esportarlo (questo perché ci sarebbe un errore di esecuzione in JavaScript):
31
+
32
+
```js
33
+
export { funzione };
34
+
```
35
+
36
+
I transpilers a singolo file non sanno se `tipo` produce un valore o meno, quindi c'è un errore nell'esportazione di un nome che si riferisce solo ad un tipo.
37
+
38
+
#### File Non-Moduli
39
+
40
+
Se `isolatedModules` è impostato, tutti file di implementazione devono essere _modules_ (ciò significa che esso ha alcune forme di `import` / `export`). Un errore appare se nessun file è un modulo:
41
+
42
+
```ts twoslash
43
+
// @errors: 1208
44
+
// @isolatedModules
45
+
function fn() {}
46
+
```
47
+
48
+
Questa regola non viene applicata ai file `.d.ts`
49
+
50
+
#### Riferimenti ai membri `const enum`
51
+
52
+
In TypeScript, quando ti riferisci ad un membro `const enum`, il riferimento viene rimpiazzato dal suo valore attuale nel JavaScript compilato. Cambiando questo TypeScript:
53
+
54
+
```ts twoslash
55
+
declareconstenumNumeri {
56
+
Zero=0,
57
+
Uno=1,
58
+
}
59
+
console.log(Numeri.Zero+Numeri.Uno);
60
+
```
61
+
62
+
Con questo JavaScript:
63
+
64
+
```ts twoslash
65
+
// @showEmit
66
+
// @removeComments
67
+
declareconstenumNumeri {
68
+
Zero=0,
69
+
Uno=1,
70
+
}
71
+
console.log(Numeri.Zero+Numeri.Uno);
72
+
```
73
+
74
+
Senza la conoscenza del valore di questi membri, gli altri transpilers non possono rimpiazzare il riferimento a `Numeri`, questo comporterebbe un errore di esecuzione se lasciato a se stesso (dal momento in cui non ci sono oggetti di tipo `Numeri` in esecuzione).
75
+
A causa di questo, quando `isolatedModules` è impostato, c'è un errore nel riferire un ambiente ad un membro `const enum`.
0 commit comments