From 0c4f90c9d1f452cf0b6d2c1ded5649ac4af5b141 Mon Sep 17 00:00:00 2001 From: Andrea Longo Date: Sat, 6 Mar 2021 11:21:02 +0100 Subject: [PATCH 1/3] translate article and tasks --- .../1-strange-instanceof/solution.md | 8 +- .../1-strange-instanceof/task.md | 4 +- 1-js/09-classes/06-instanceof/article.md | 126 +++++++++--------- 3 files changed, 69 insertions(+), 69 deletions(-) diff --git a/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md b/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md index d41d90edf..839e79141 100644 --- a/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md +++ b/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md @@ -1,7 +1,7 @@ -Yeah, looks strange indeed. +Si, sembra strano. -But `instanceof` does not care about the function, but rather about its `prototype`, that it matches against the prototype chain. +Ma `instanceof` non prende in considerazione la funzione, ma piuttosto il suo `prototype`, che trova riscontro nella catena dei prototye. -And here `a.__proto__ == B.prototype`, so `instanceof` returns `true`. +In questo caso `a.__proto__ == B.prototype`, quindi `instanceof` ritorna `true`. -So, by the logic of `instanceof`, the `prototype` actually defines the type, not the constructor function. +Quindi, secondo la logica di `instanceof`, è il `prototype` a definire il tipo, non il costruttore. diff --git a/1-js/09-classes/06-instanceof/1-strange-instanceof/task.md b/1-js/09-classes/06-instanceof/1-strange-instanceof/task.md index 5b8dc7de3..fc29895a8 100644 --- a/1-js/09-classes/06-instanceof/1-strange-instanceof/task.md +++ b/1-js/09-classes/06-instanceof/1-strange-instanceof/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Strange instanceof +# Uno strano instanceof -In the code below, why does `instanceof` return `true`? We can easily see that `a` is not created by `B()`. +Nel codice sottostante, perché `instanceof` ritorna `true`? Possiamo facilmente vedere che `a` non è creato da `B()`. ```js run function A() {} diff --git a/1-js/09-classes/06-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md index 630818188..09692fb99 100644 --- a/1-js/09-classes/06-instanceof/article.md +++ b/1-js/09-classes/06-instanceof/article.md @@ -1,42 +1,42 @@ -# Class checking: "instanceof" +# Verifica delel classi: "instanceof" -The `instanceof` operator allows to check whether an object belongs to a certain class. It also takes inheritance into account. +L'operatore `instanceof` ci consente di verificare se un oggetto appartiene ad una specifica classe. Anche l'ereditarietà viene presa in considerazione. -Such a check may be necessary in many cases. For example, it can be used for building a *polymorphic* function, the one that treats arguments differently depending on their type. +Questo tipo di verifiche potrebbero essere necessarie in diversi casi. Ad esempio, può essere utilizzato per costruire una funzione *polimorfa*, una funzione che tratta gli argomenti differentemente in base al loro tipo. -## The instanceof operator [#ref-instanceof] +## L'operatore instanceof [#ref-instanceof] -The syntax is: +La sintassi è: ```js obj instanceof Class ``` -It returns `true` if `obj` belongs to the `Class` or a class inheriting from it. +Ritorna `true` se `obj` è di tipo `Class` o è una sua sotto-classe. -For instance: +Ad esempio: ```js run class Rabbit {} let rabbit = new Rabbit(); -// is it an object of Rabbit class? +// è un oggetto di tipo Rabbit? *!* alert( rabbit instanceof Rabbit ); // true */!* ``` -It also works with constructor functions: +Funziona anche con i costruttori: ```js run *!* -// instead of class +// invece di usare class function Rabbit() {} */!* alert( new Rabbit() instanceof Rabbit ); // true ``` -...And with built-in classes like `Array`: +...E con le classi integrate come `Array`: ```js run let arr = [1, 2, 3]; @@ -44,19 +44,19 @@ alert( arr instanceof Array ); // true alert( arr instanceof Object ); // true ``` -Please note that `arr` also belongs to the `Object` class. That's because `Array` prototypically inherits from `Object`. +Da notare che `arr` appartiene anche alla classe `Object`. Questo accade perché `Array` eredita da `Object`. -Normally, `instanceof` examines the prototype chain for the check. We can also set a custom logic in the static method `Symbol.hasInstance`. +Normalmente `instanceof` esamina la catena dei prototype per effettuare questa verifica. Possiamo anche definire una logica personalizzata nel metodo statico `Symbol.hasInstance`. -The algorithm of `obj instanceof Class` works roughly as follows: +L'algoritmo di `obj instanceof Class` funzione, a grandi linee, in questo modo: -1. If there's a static method `Symbol.hasInstance`, then just call it: `Class[Symbol.hasInstance](obj)`. It should return either `true` or `false`, and we're done. That's how we can customize the behavior of `instanceof`. +1. Se è stato definito un metodo statico `Symbol.hasInstance`, allora questo verrà invocato: `Class[Symbol.hasInstance](obj)`. Dovrebbe ritornare `true` o `false`, questo è tutto. Cosi è come possiamo personalizzare il comportamento di `instanceof`. For example: ```js run - // setup instanceOf check that assumes that - // anything with canEat property is an animal + // impostiamo il controllo instanceOf in modo che assuma che + // qualsiasi cosa con la proprietà canEat sia un animale class Animal { static [Symbol.hasInstance](obj) { if (obj.canEat) return true; @@ -65,24 +65,24 @@ The algorithm of `obj instanceof Class` works roughly as follows: let obj = { canEat: true }; - alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) is called + alert(obj instanceof Animal); // true: Animal[Symbol.hasInstance](obj) è stato invocato ``` -2. Most classes do not have `Symbol.hasInstance`. In that case, the standard logic is used: `obj instanceOf Class` checks whether `Class.prototype` is equal to one of the prototypes in the `obj` prototype chain. +2. Molte classi non hanno `Symbol.hasInstance`. In questo caso, viene utilizzata la logica standard: `obj instanceOf Class` che controlla se `Class.prototype` equivale ad uno dei prototype nella catena dei prototype di `obj`. - In other words, compare one after another: + In altre parole, li confronta tutti uno alla volta: ```js obj.__proto__ === Class.prototype? obj.__proto__.__proto__ === Class.prototype? obj.__proto__.__proto__.__proto__ === Class.prototype? ... - // if any answer is true, return true - // otherwise, if we reached the end of the chain, return false + // se una di questa vale true, allora viene ritornato true + // altrimenti, se siamo arrivati al termine della catena, ritorna false ``` - In the example above `rabbit.__proto__ === Rabbit.prototype`, so that gives the answer immediately. + Nell'esempio sopra `rabbit.__proto__ === Rabbit.prototype`, questo ci ritorna una risposta immediata. - In the case of an inheritance, the match will be at the second step: + In caso di ereditarietà, il riscontro avverrà al secondo passo: ```js run class Animal {} @@ -99,70 +99,70 @@ The algorithm of `obj instanceof Class` works roughly as follows: */!* ``` -Here's the illustration of what `rabbit instanceof Animal` compares with `Animal.prototype`: +Qui vediamo raffigurato cosa `rabbit instanceof Animal` confronta con `Animal.prototype`: ![](instanceof.svg) -By the way, there's also a method [objA.isPrototypeOf(objB)](mdn:js/object/isPrototypeOf), that returns `true` if `objA` is somewhere in the chain of prototypes for `objB`. So the test of `obj instanceof Class` can be rephrased as `Class.prototype.isPrototypeOf(obj)`. +Comunque, abbiamo a disposizione anche il metodo [objA.isPrototypeOf(objB)](mdn:js/object/isPrototypeOf), che ritorna `true` se `objA` si trova nella catena dei prototype di `objB`. Quindi la verifica `obj instanceof Class` può essere riformulata come `Class.prototype.isPrototypeOf(obj)`. -It's funny, but the `Class` constructor itself does not participate in the check! Only the chain of prototypes and `Class.prototype` matters. +Un fatto divertente, è che il costruttore della `Class` stessa, non viene coinvolto nella verifica! Solamente la catena dei prototype e `Class.prototype` vengono valutati. -That can lead to interesting consequences when a `prototype` property is changed after the object is created. +Questo può portare a diverse conseguenze quando la proprietà `prototype` viene modificata dopo la creazione dell'oggetto. -Like here: +Come nell'esempio: ```js run function Rabbit() {} let rabbit = new Rabbit(); -// changed the prototype +// modifichiamo il prototype Rabbit.prototype = {}; -// ...not a rabbit any more! +// ...non è pù un rabbit! *!* alert( rabbit instanceof Rabbit ); // false */!* ``` -## Bonus: Object.prototype.toString for the type +## Bonus: Object.prototype.toString per il tipo -We already know that plain objects are converted to string as `[object Object]`: +Sappiamo già che gli oggetti semplici vengono convertiti a stringa come `[object Object]`: ```js run let obj = {}; alert(obj); // [object Object] -alert(obj.toString()); // the same +alert(obj.toString()); // lo stesso ``` -That's their implementation of `toString`. But there's a hidden feature that makes `toString` actually much more powerful than that. We can use it as an extended `typeof` and an alternative for `instanceof`. +Questa è la loro implementazione del metodo `toString`. Ma esiste una funzionalità nascosta che rende `toString` molto più potente di cosi. Possiamo utilizzarlo come un'estensione di `typeof` e come alternativa di `instanceof`. -Sounds strange? Indeed. Let's demystify. +Sembra strano? Lo è! Capiamo perché. -By [specification](https://tc39.github.io/ecma262/#sec-object.prototype.tostring), the built-in `toString` can be extracted from the object and executed in the context of any other value. And its result depends on that value. +Secondo le [specifiche](https://tc39.github.io/ecma262/#sec-object.prototype.tostring), il metodo integrato `toString` può essere estratto dall'oggetto ed eseguito nel contesto di un qualsiasi altro valore. Ed il suo risultato dipende da quel valore. -- For a number, it will be `[object Number]` -- For a boolean, it will be `[object Boolean]` -- For `null`: `[object Null]` -- For `undefined`: `[object Undefined]` -- For arrays: `[object Array]` -- ...etc (customizable). +- Per un numero, sarà `[object Number]` +- Per un boolean, sarà `[object Boolean]` +- Per `null`: `[object Null]` +- Per `undefined`: `[object Undefined]` +- Per gli array: `[object Array]` +- ...etc (personalizzabile). -Let's demonstrate: +Dimostriamolo: ```js run -// copy toString method into a variable for convenience +// copiamo il metodo toString in una variabile per comodità let objectToString = Object.prototype.toString; -// what type is this? +// di che tipo è questo? let arr = []; alert( objectToString.call(arr) ); // [object *!*Array*/!*] ``` -Here we used [call](mdn:js/function/call) as described in the chapter [](info:call-apply-decorators) to execute the function `objectToString` in the context `this=arr`. +Qui abbiamo utilizzato [call](mdn:js/function/call) come descritto nel capitolo [](info:call-apply-decorators) per eseguire la funzione `objectToString` nel contesto `this=arr`. -Internally, the `toString` algorithm examines `this` and returns the corresponding result. More examples: +Internamente, l'algoritmo `toString` esamina `this` e ritorna il risultato corrispondente. Più esempi: ```js run let s = Object.prototype.toString; @@ -174,9 +174,9 @@ alert( s.call(alert) ); // [object Function] ### Symbol.toStringTag -The behavior of Object `toString` can be customized using a special object property `Symbol.toStringTag`. +Il comportamento di Object `toString` può essere personalizzato utilizzando una proprietà speciale dell'oggetto `Symbol.toStringTag`. -For instance: +Ad esempio: ```js run let user = { @@ -186,10 +186,10 @@ let user = { alert( {}.toString.call(user) ); // [object User] ``` -For most environment-specific objects, there is such a property. Here are some browser specific examples: +Per molti oggetti specifici di un ambiente, esiste questa proprietà. Qui vediamo alcuni esempi specifici per il browser: ```js run -// toStringTag for the environment-specific object and class: +// toStringTag per l'oggetto specifico d'ambiente: alert( window[Symbol.toStringTag]); // Window alert( XMLHttpRequest.prototype[Symbol.toStringTag] ); // XMLHttpRequest @@ -197,22 +197,22 @@ alert( {}.toString.call(window) ); // [object Window] alert( {}.toString.call(new XMLHttpRequest()) ); // [object XMLHttpRequest] ``` -As you can see, the result is exactly `Symbol.toStringTag` (if exists), wrapped into `[object ...]`. +Come potete vedere, il risultato è esattamente `Symbol.toStringTag` (se esiste), racchiuso in `[object ...]`. -At the end we have "typeof on steroids" that not only works for primitive data types, but also for built-in objects and even can be customized. +Al termine avremo "typeof on steroids" che non funziona solamente con i tipi di dato primitivo, ma anche con gli oggetti integrati e può anche essere personalizzato. -We can use `{}.toString.call` instead of `instanceof` for built-in objects when we want to get the type as a string rather than just to check. +Possiamo utilizzare `{}.toString.call` piuttosto di `instanceof` per gli oggetti integrati quando vogliamo ottenerne il tipo come stringa piuttosto che effettuare una semplice verifica. -## Summary +## Riepilogo -Let's summarize the type-checking methods that we know: +Ricapitoliamo i metodi di verifica del tipi: -| | works for | returns | +| | funzionano con | ritorna | |---------------|-------------|---------------| -| `typeof` | primitives | string | -| `{}.toString` | primitives, built-in objects, objects with `Symbol.toStringTag` | string | -| `instanceof` | objects | true/false | +| `typeof` | primitivi | stringa | +| `{}.toString` | primitivi, oggetti integrati, oggetti con `Symbol.toStringTag` | stringa | +| `instanceof` | oggetti | true/false | -As we can see, `{}.toString` is technically a "more advanced" `typeof`. +Come possiamo vedere, `{}.toString` è tecnicamente più avanzato di `typeof`. -And `instanceof` operator really shines when we are working with a class hierarchy and want to check for the class taking into account inheritance. +Invece l'operatore `instanceof` funziona veramente bene quando stiamo lavorando con una gerarchia di classi e vogliamo verificare il tipo, tenendo conto dell'ereditarietà. From e3450011dd17cd2cb82b310f32c4c687353262c3 Mon Sep 17 00:00:00 2001 From: Andrea <45577511+longo-andrea@users.noreply.github.com> Date: Sun, 7 Mar 2021 09:45:14 +0100 Subject: [PATCH 2/3] Apply suggestions from code review Co-authored-by: Dorin David <70648503+Dorin-David@users.noreply.github.com> --- .../06-instanceof/1-strange-instanceof/solution.md | 2 +- 1-js/09-classes/06-instanceof/article.md | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md b/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md index 839e79141..3909de2ca 100644 --- a/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md +++ b/1-js/09-classes/06-instanceof/1-strange-instanceof/solution.md @@ -1,4 +1,4 @@ -Si, sembra strano. +Sì, sembra strano. Ma `instanceof` non prende in considerazione la funzione, ma piuttosto il suo `prototype`, che trova riscontro nella catena dei prototye. diff --git a/1-js/09-classes/06-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md index 09692fb99..2cee78763 100644 --- a/1-js/09-classes/06-instanceof/article.md +++ b/1-js/09-classes/06-instanceof/article.md @@ -1,4 +1,4 @@ -# Verifica delel classi: "instanceof" +# Verifica delle classi: "instanceof" L'operatore `instanceof` ci consente di verificare se un oggetto appartiene ad una specifica classe. Anche l'ereditarietà viene presa in considerazione. @@ -50,12 +50,12 @@ Normalmente `instanceof` esamina la catena dei prototype per effettuare questa v L'algoritmo di `obj instanceof Class` funzione, a grandi linee, in questo modo: -1. Se è stato definito un metodo statico `Symbol.hasInstance`, allora questo verrà invocato: `Class[Symbol.hasInstance](obj)`. Dovrebbe ritornare `true` o `false`, questo è tutto. Cosi è come possiamo personalizzare il comportamento di `instanceof`. +1. Se è stato definito un metodo statico `Symbol.hasInstance`, allora questo verrà invocato: `Class[Symbol.hasInstance](obj)`. Dovrebbe ritornare `true` o `false`, questo è tutto. Così possiamo personalizzare il comportamento di `instanceof`. For example: ```js run - // impostiamo il controllo instanceOf in modo che assuma che + // impostiamo il controllo instanceOf in modo che supponga che // qualsiasi cosa con la proprietà canEat sia un animale class Animal { static [Symbol.hasInstance](obj) { @@ -76,11 +76,11 @@ L'algoritmo di `obj instanceof Class` funzione, a grandi linee, in questo modo: obj.__proto__.__proto__ === Class.prototype? obj.__proto__.__proto__.__proto__ === Class.prototype? ... - // se una di questa vale true, allora viene ritornato true + // se una di questa è true, allora viene ritornato true // altrimenti, se siamo arrivati al termine della catena, ritorna false ``` - Nell'esempio sopra `rabbit.__proto__ === Rabbit.prototype`, questo ci ritorna una risposta immediata. + Nell'esempio sopra `rabbit.__proto__ === Rabbit.prototype`, che ci ritorna una risposta immediata. In caso di ereditarietà, il riscontro avverrà al secondo passo: @@ -201,7 +201,7 @@ Come potete vedere, il risultato è esattamente `Symbol.toStringTag` (se esiste) Al termine avremo "typeof on steroids" che non funziona solamente con i tipi di dato primitivo, ma anche con gli oggetti integrati e può anche essere personalizzato. -Possiamo utilizzare `{}.toString.call` piuttosto di `instanceof` per gli oggetti integrati quando vogliamo ottenerne il tipo come stringa piuttosto che effettuare una semplice verifica. +Possiamo utilizzare `{}.toString.call` piuttosto di `instanceof` per gli oggetti integrati quando vogliamo ottenerne il tipo come stringa invece di effettuare una semplice verifica. ## Riepilogo From 09cac43ce15fb0a624b055360329582d7f1d927f Mon Sep 17 00:00:00 2001 From: Andrea <45577511+longo-andrea@users.noreply.github.com> Date: Sun, 7 Mar 2021 20:50:18 +0100 Subject: [PATCH 3/3] Apply suggestions from code review Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com> --- 1-js/09-classes/06-instanceof/article.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/1-js/09-classes/06-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md index 2cee78763..2576404d0 100644 --- a/1-js/09-classes/06-instanceof/article.md +++ b/1-js/09-classes/06-instanceof/article.md @@ -2,7 +2,7 @@ L'operatore `instanceof` ci consente di verificare se un oggetto appartiene ad una specifica classe. Anche l'ereditarietà viene presa in considerazione. -Questo tipo di verifiche potrebbero essere necessarie in diversi casi. Ad esempio, può essere utilizzato per costruire una funzione *polimorfa*, una funzione che tratta gli argomenti differentemente in base al loro tipo. +Questo tipo di controllo potrebbe essere necessario in diversi casi. Ad esempio, può essere utilizzato per costruire una funzione *polimorfa*, ossia una funzione che tratta gli argomenti differentemente in base al loro tipo. ## L'operatore instanceof [#ref-instanceof] @@ -48,14 +48,14 @@ Da notare che `arr` appartiene anche alla classe `Object`. Questo accade perché Normalmente `instanceof` esamina la catena dei prototype per effettuare questa verifica. Possiamo anche definire una logica personalizzata nel metodo statico `Symbol.hasInstance`. -L'algoritmo di `obj instanceof Class` funzione, a grandi linee, in questo modo: +L'algoritmo di `obj instanceof Class` funziona, a grandi linee, in questo modo: -1. Se è stato definito un metodo statico `Symbol.hasInstance`, allora questo verrà invocato: `Class[Symbol.hasInstance](obj)`. Dovrebbe ritornare `true` o `false`, questo è tutto. Così possiamo personalizzare il comportamento di `instanceof`. +1. Se è stato definito un metodo statico `Symbol.hasInstance`, allora questo verrà invocato: `Class[Symbol.hasInstance](obj)`. Dovrebbe ritornare `true` o `false`, questo è tutto. In questo modo possiamo personalizzare il comportamento di `instanceof`. For example: ```js run - // impostiamo il controllo instanceOf in modo che supponga che + // impostiamo il controllo instanceOf in modo che assuma che // qualsiasi cosa con la proprietà canEat sia un animale class Animal { static [Symbol.hasInstance](obj) { @@ -77,10 +77,10 @@ L'algoritmo di `obj instanceof Class` funzione, a grandi linee, in questo modo: obj.__proto__.__proto__.__proto__ === Class.prototype? ... // se una di questa è true, allora viene ritornato true - // altrimenti, se siamo arrivati al termine della catena, ritorna false + // altrimenti, una volta arrivati al termine della catena, ritorna false ``` - Nell'esempio sopra `rabbit.__proto__ === Rabbit.prototype`, che ci ritorna una risposta immediata. + Nell'esempio sopra `rabbit.__proto__ === Rabbit.prototype`, quindi riceviamo immediatamente una risposta. In caso di ereditarietà, il riscontro avverrà al secondo passo: @@ -105,7 +105,7 @@ Qui vediamo raffigurato cosa `rabbit instanceof Animal` confronta con `Animal.pr Comunque, abbiamo a disposizione anche il metodo [objA.isPrototypeOf(objB)](mdn:js/object/isPrototypeOf), che ritorna `true` se `objA` si trova nella catena dei prototype di `objB`. Quindi la verifica `obj instanceof Class` può essere riformulata come `Class.prototype.isPrototypeOf(obj)`. -Un fatto divertente, è che il costruttore della `Class` stessa, non viene coinvolto nella verifica! Solamente la catena dei prototype e `Class.prototype` vengono valutati. +Un fatto divertente, è che il costruttore stesso della `Class`, non viene coinvolto nella verifica! Solamente la catena dei prototype e `Class.prototype` vengono valutati. Questo può portare a diverse conseguenze quando la proprietà `prototype` viene modificata dopo la creazione dell'oggetto. @@ -162,7 +162,7 @@ alert( objectToString.call(arr) ); // [object *!*Array*/!*] Qui abbiamo utilizzato [call](mdn:js/function/call) come descritto nel capitolo [](info:call-apply-decorators) per eseguire la funzione `objectToString` nel contesto `this=arr`. -Internamente, l'algoritmo `toString` esamina `this` e ritorna il risultato corrispondente. Più esempi: +Internamente, l'algoritmo `toString` esamina `this` e ritorna il risultato corrispondente. Altri esempi: ```js run let s = Object.prototype.toString; @@ -199,7 +199,7 @@ alert( {}.toString.call(new XMLHttpRequest()) ); // [object XMLHttpRequest] Come potete vedere, il risultato è esattamente `Symbol.toStringTag` (se esiste), racchiuso in `[object ...]`. -Al termine avremo "typeof on steroids" che non funziona solamente con i tipi di dato primitivo, ma anche con gli oggetti integrati e può anche essere personalizzato. +Al termine avremo "typeof on steroids" che non funziona solamente con i tipi di dato primitivo, ma anche con gli oggetti integrati, inoltre può essere personalizzato. Possiamo utilizzare `{}.toString.call` piuttosto di `instanceof` per gli oggetti integrati quando vogliamo ottenerne il tipo come stringa invece di effettuare una semplice verifica. @@ -215,4 +215,4 @@ Ricapitoliamo i metodi di verifica del tipi: Come possiamo vedere, `{}.toString` è tecnicamente più avanzato di `typeof`. -Invece l'operatore `instanceof` funziona veramente bene quando stiamo lavorando con una gerarchia di classi e vogliamo verificare il tipo, tenendo conto dell'ereditarietà. +Invece l'operatore `instanceof` funziona veramente bene quando lavoriamo con una classe e vogliamo controllarne l'ereditarietà.