Add 1-js/06-advanced-functions/04-var/article.md

Author: longo-andrea

1-js/06-advanced-functions/05-global-object/article.md

@@ -1,57 +1,57 @@
 
-# Global object
+# Oggetto globale
 
-The global object provides variables and functions that are available anywhere. Mostly, the ones that are built into the language or the host environment.
+L'oggetto globale fornisce variabili e funzioni che sono accessibili in qualsiasi punto. Principalmente quelle integrate dal linguaggio o fornite dall'ambiente.
 
-In a browser it is named "window", for Node.js it is "global", for other environments it may have another name.
+In un browser l'ambiente si chiama "window", per Node.js viene detto "global", negli altri ambienti si usano diversi termini.
 
-For instance, we can call `alert` as a method of `window`:
+Ad esempio, potremmo invocare `alert` come metodo di `window`:
 
 ```js run
 alert("Hello");
 
-// the same as
+// la stessa cosa
 window.alert("Hello");
 ```
 
-We can reference other built-in functions like `Array` as `window.Array` and create our own properties on it.
+LO stesso vale per tutte le altre funzioni integrate, ad esempio possiamo invocare `Array` come `window.Array` e creare le nostre personali proprietà.
 
-## Browser: the "window" object
+## Browser: l'oggetto "window" 
 
-For historical reasons, in-browser `window` object is a bit messed up.
+Per ragioni storiche, l'oggetto `window` è leggermente incasinato.
 
-1. It provides the "browser window" functionality, besides playing the role of a global object.
+1. Fornisce la funzionalità di "finestra del browser", oltre a svolgere il ruolo di oggetto globale.
 
-    We can use `window` to access properties and methods, specific to the browser window:
+    Possiamo utilizzare `window` per accedere a proprietà e metodi, specifici di una finestra del browser:
 
     ```js run
-    alert(window.innerHeight); // shows the browser window height
+    alert(window.innerHeight); // mostra l'altezza della window 
 
-    window.open('http://google.com'); // opens a new browser window
+    window.open('http://google.com'); // apre una nuova browser window
     ```
 
-2. Top-level `var` variables and function declarations automatically become properties of `window`.
+2. Le variabili `var` e le dichiarazioni di funzioni diventano automaticamente delle proprietà di `window`.
 
-    For instance:
+    Ad esempio:
     ```js untrusted run no-strict refresh
     var x = 5;
 
-    alert(window.x); // 5 (var x becomes a property of window)
+    alert(window.x); // 5 (var x diventa una proprietà di window)
 
     window.x = 0;
 
-    alert(x); // 0, variable modified
+    alert(x); // 0, variabile modificata
     ```
 
-    Please note, that doesn't happen with more modern `let/const` declarations:
+    Da notare che tutto ciò non vale per le dichiarazioni `let/const`:
 
     ```js untrusted run no-strict refresh
     let x = 5;
 
-    alert(window.x); // undefined ("let" doesn't create a window property)
+    alert(window.x); // undefined ("let" non crea proprietà sull'oggetto window)
     ```
 
-3. Also, all scripts share the same global scope, so variables declared in one `<script>` become visible in  another ones:
+3. Inoltre, tutti gli script condividono lo stesso scope globale, quindi le variabili dichiarate all'interno di uno `<script>` diventano visibili anche negli altri:
 
     ```html run
     <script>
@@ -65,25 +65,25 @@ For historical reasons, in-browser `window` object is a bit messed up.
     </script>
     ```
 
-4. And, a minor thing, but still: the value of `this` in the global scope is `window`.
+4. Un ultima cosa, il valore di `this` nello scope globale è `window`.
 
     ```js untrusted run no-strict refresh
     alert(this); // window
     ```
 
-Why was it made like this? At the time of the language creation, the idea to merge multiple aspects into a single `window` object was to "make things simple". But since then many things changed. Tiny scripts became big applications that require proper architecture.
+Perché è stato fatto cosi? Nel momento in cui è stato creato il linguaggio, l'idea era quella di fondere diversi aspetti in un unico oggetto `window` per "rendere le cose più semplici". Ma da quel momento sono cambiate molte cose. Da piccoli script si è passati a grandi applicazioni le quali richiedono una propria architettura.
 
-Is it good that different scripts (possibly from different sources) see variables of each other?
+E' una cosa buona che diversi script (eventualmente anche provenienti da altri sviluppatori) si vedano le variabili a vicenda?
 
-No, it's not, because it may lead to naming conflicts: the same variable name can be used in two scripts for different purposes, so they will conflict with each other.
+Ovviamente no, questa caratteristica potrebbe portare ad errori dovuti a conflitti tra nomi: due variabili (di script diversi) con uno stesso nome potrebbero aver scopi differenti nei diversi script in cui vengono utilizzate.
 
-As of now, the multi-purpose `window` is considered a design mistake in the language.
+Ad oggi, questa caratteristica di `window` viene considerata un errore nel design del linguaggio.
 
-Luckily, there's a "road out of hell", called "JavaScript modules".
+Fortunatamente esiste una soluzione per "aggirare" questo problema, ed è chiamata "JavaScript module".
 
-If we set `type="module"` attribute on a `<script>` tag, then such script is considered a separate "module" with its own top-level scope (lexical environment), not interfering with `window`.
+Se impostiamo `type="module"` come attributo su un tag `<script>`, allora questo script verrà considerato un "modulo" separato con il suo suo personale scope globale (lexical environment), e non interferirà con `window`.
 
-- In a module, `var x` does not become a property of `window`:
+- In un modulo, `var x` non diventerà una proprietà di `window`:
 
     ```html run
     <script type="module">
@@ -93,7 +93,7 @@ If we set `type="module"` attribute on a `<script>` tag, then such script is con
     </script>
     ```
 
-- Two modules that do not see variables of each other:
+- Due moduli diversi non condividono le variabili:
 
     ```html run
     <script type="module">
@@ -102,54 +102,54 @@ If we set `type="module"` attribute on a `<script>` tag, then such script is con
 
     <script type="module">
       alert(window.x); // undefined
-      alert(x); // Error: undeclared variable
+      alert(x); // Error: variabile non dichiarata
     </script>
     ```
 
-- And, the last minor thing, the top-level value of `this` in a module is `undefined` (why should it be `window` anyway?):
+- E come ultima cosa, il valore di `this` (al livello globale) in un modulo sarà `undefined` (non avrebbe alcun senso se contenesse `window`?):
 
     ```html run
     <script type="module">
       alert(this); // undefined
     </script>
     ```
 
-**Using `<script type="module">` fixes the design flaw of the language by separating top-level scope from `window`.**
+**L'utilizzo di `<script type="module">` risolve i difetti di design del linguaggio, separando il livello massimo (top-level) da `window`.**
 
-We'll cover more features of modules later, in the chapter [](info:modules).
+Più avanti tratteremo più in dettaglio questo argomento, nel capitolo [](info:modules).
 
-## Valid uses of the global object
+## Utilizzi sensati dell'oggetto globale
 
-1. Using global variables is generally discouraged. There should be as few global variables as possible, but if we need to make something globally visible, we may want to put it into `window` (or `global` in Node.js).
+1. L'utilizzo delle variabili globali, solitamente è sconsigliato. Dovrebbero esserci il minor numero di variabili globali possibili, ma se proprio ne avessimo bisogno possiamo comunque sfruttare l'oggetto globale `window` (o `global` in Node.js).
 
-    Here we put the information about the current user into a global object, to be accessible from all other scripts:
+    Qui inseriamo delle informazioni riguardo l'utente nell'oggetto globale, in modo tale da renderle accessibili anche agli altri script:
 
     ```js run
-    // explicitly assign it to `window`
+    // assegnazione esplicita a `window`
     window.currentUser = {
       name: "John",
       age: 30
     };
 
-    // then, elsewhere, in another script
+    // poi, in un qualsiasi punto di un altro script
     alert(window.currentUser.name); // John
     ```
 
-2. We can test the global object for support of modern language features.
+2. Possiamo testare l'oggetto globale per verificare la presenza di caratteristiche moderne.
 
-    For instance, test if a build-in `Promise` object exists (it doesn't in really old browsers):
+    Ad esempio, testiamo se esiste l'oggetto `Promise` (nei vecchi browser non era presente):
     ```js run
     if (!window.Promise) {
       alert("Your browser is really old!");
     }
     ```
 
-3. We can create "polyfills": add functions that are not supported by the environment (say, an old browser), but exist in the modern standard.
+3. Possiamo creare "polyfills": aggiungere funzioni che non sono supportate dall'ambiente, ma che sono supportate dagli standard moderni.
 
     ```js run
     if (!window.Promise) {
-      window.Promise = ... // custom implementation of the modern language feature
+      window.Promise = ... // implementazione di una caratteristica moderna
     }
     ```
 
-...And of course, if we're in a browser, using `window` to access browser window features (not as a global object) is completely fine.
+...E ovviamente, se ci troviamo in ambiente browser, possiamo utilizzare `window` per accedere alle caratteristiche della finestra (senza utilizzarlo come oggetto globale).