Merge pull request #104 from javascript-tutorial/sync-1edb0a38

Sync with upstream @ 1edb0a3

Author: ipapoutsidis

1-js/01-getting-started/1-intro/article.md

@@ -33,16 +33,17 @@
 
 Τα engines είναι περίπλοκοι. Αλλά τα βασικά είναι εύκολα.
 
+
 1. Το engine (ενσωματωμένος αν είναι πρόγραμμα περιήγησης) διαβάζει ("αναλύει") τα script.
 2. Στη συνέχεια μετατρέπει ("μεταγλώττιση") το script στη γλώσσα του μηχανήματος.
 3. Ύστερα ο κώδικας του μηχανήματος τρέχει, αρκετά γρήγορα.
 Το engine εφαρμόζει βελτιστοποιήσει σε κάθε βήμα της διαδικασίας. Παρακολουθεί ακόμη και το μεταγλωττισμένο script καθώς εκτελείται, αναλύει τα δεδομένα που ρέουν μέσα από αυτό και εφαρμόζει βελτιστοποιήσεις στον κώδικα του μηχανήματος βάσει αυτής της γνώσης. Όταν ολοκληρωθεί, τα script εκτελούνται αρκετά γρήγορα.
-'''
 
 ## Τι μπορεί να κάνει η JavaScript στο πρόγραμμα περιήγησης?
 
 Η σύγχρονη JavaScript είναι μια "ασφαλής" γλώσσα προγραμματισμού. Δεν παρέχει low-level πρόσβαση στη μνήμη ή στη CPU, επειδή δημιουργήθηκε αρχικά για προγράμματα περιήγησης που δεν το χρειάζονται.
 
+
 Οι δυνατότητες της JavaScript εξαρτώνται σε μεγάλο βαθμό από το περιβάλλον στο οποίο εκτελείται. Για παράδειγμα, το [Node.js] (https://wikipedia.org/wiki/Node.js) υποστηρίζει λειτουργίες που επιτρέπουν στην JavaScript να διαβάζει/γράφει αυθαίρετα αρχεία, να εκτελεί αιτήματα δικτύου, και τα λοιπά.
 
 Η JavaScript στο πρόγραμμα περιήγησης μπορεί να κάνει ό, τι σχετίζεται με τη διαχείριση ιστοσελίδων, την αλληλεπίδραση με τον χρήστη και τον διακομιστή ιστού.
@@ -103,21 +104,11 @@
 
 Παραδείγματα τέτοιων γλωσσών:
 
-<<<<<<< HEAD
 - [CoffeeScript](http://coffeescript.org/) είναι "syntactic sugar" για την JavaScript. Εισάγει συντομότερη σύνταξη, επιτρέποντάς μας να γράψουμε σαφέστερο και ακριβέστερο κώδικα.
 Συνήθως, στούς Ruby devs αρέσει.
 - [TypeScript](http://www.typescriptlang.org/) επικεντρώνεται στην προσθήκη "αυστηρής πληκτρολόγησης δεδομένων" για απλοποίηση της ανάπτυξης και υποστήριξης σύνθετων συστημάτων. Αναπτύσσεται από τη Microsoft.
 - [Flow](http://flow.org/)  προσθέτει επίσης πληκτρολόγηση δεδομένων, αλλά με διαφορετικό τρόπο. Αναπτύχθηκε από το Facebook.
 - [Dart](https://www.dartlang.org/) είναι μια αυτόνομη γλώσσα που έχει τη δική της μηχανή που λειτουργεί σε περιβάλλοντα εκτός προγράμματος περιήγησης (όπως εφαρμογές για κινητά), αλλά μπορεί επίσης να μεταφερθεί σε JavaScript. Αναπτύχθηκε από την Google.
-- [Brython](https://brython.info/) είναι ένας Python transpiler σε JavaScript που επιτρέπει την εγγραφή εφαρμογής σε πλήρη Python χωρίς JavaScript.
-=======
-- [CoffeeScript](https://coffeescript.org/) is a "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
-- [TypeScript](https://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
-- [Flow](https://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
-- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps), but also can be transpiled to JavaScript. Developed by Google.
-- [Brython](https://brython.info/) is a Python transpiler to JavaScript that enables the writing of applications in pure Python without JavaScript.
-- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) is a modern, concise and safe programming language that can target the browser or Node.
->>>>>>> 30a5d5e2a7c3504c9afd5028f83f4a696e60aede
 
 Υπάρχουν περισσότερα. Φυσικά, ακόμη και αν χρησιμοποιούμε μία από τις μεταγλωττισμένες γλώσσες, πρέπει επίσης να γνωρίζουμε τη JavaScript για να κατανοήσουμε πραγματικά τι κάνουμε.
 

1-js/02-first-steps/07-type-conversions/article.md

@@ -66,6 +66,7 @@ alert(age); // NaN, η μετατροπή απέτυχε
 
 Κανόνες αριθμητικών μετατροπών:
 
+
 | Τιμή                                  | Γίνεται...                                                                                                                                                                                                                               |
 | ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `undefined`                           | `NaN`                                                                                                                                                                                                                                    |
@@ -133,7 +134,7 @@ alert(Boolean("")); // false
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
-|<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
+
 | `string` | Η συμβολοσειρά διαβάζεται "όπως είναι", τα κενά και από τις δύο πλευρές αγνοούνται. Μια άδεια συμβολοσειρά γίνεται `0`. Ένα σφάλμα δίνει `NaN`. |
 
 

1-js/02-first-steps/08-operators/article.md

@@ -187,13 +187,13 @@ alert( +apples + +oranges ); // 5
 | Precedence | Name | Sign |
 |------------|------|------|
 | ... | ... | ... |
-| 15 | unary plus | `+` |
-| 15 | unary negation | `-` |
-| 14 | exponentiation | `**` |
-| 13 | multiplication | `*` |
-| 13 | division | `/` |
-| 12 | addition | `+` |
-| 12 | subtraction | `-` |
+| 14 | unary plus | `+` |
+| 14 | unary negation | `-` |
+| 13 | exponentiation | `**` |
+| 12 | multiplication | `*` |
+| 12 | division | `/` |
+| 11 | addition | `+` |
+| 11 | subtraction | `-` |
 | ... | ... | ... |
 | 2 | assignment | `=` |
 | ... | ... | ... |
@@ -202,7 +202,6 @@ alert( +apples + +oranges ); // 5
 
 ## Ανάθεση
 
-
 Ας σημειώσουμε ότι μια ανάθεση `=` είναι επίσης τελεστής. Παρατίθεται στον πίνακα προτεραιότητας με την πολύ χαμηλή προτεραιότητα του `3`.
 
 Γι 'αυτό, όταν εκχωρούμε μια μεταβλητή, όπως `x = 2 * 2 + 1`, οι υπολογισμοί γίνονται πρώτα και στη συνέχεια αξιολογείται το `=`, αποθηκεύοντας το αποτέλεσμα στο `x`.
@@ -297,10 +296,9 @@ alert( n ); // 14
 ```js run
 let n = 2;
 
-n *= 3 + 5;
+n *= 3 + 5; // right part evaluated first, same as n *= 8
 
 alert( n ); // 16  (το σωστό μέρος αξιολογήθηκε πρώτα, το ίδια και για το n *= 8)
-```
 
 ## Αύξηση/μείωση
 
@@ -368,7 +366,7 @@ alert(a); // *!*1*/!*
     ++counter;
     alert( counter ); // 2, οι παραπάνω γραμμές έκαναν το ίδιο
     ```
-- Εάν θέλουμε να αυξήσουμε μια τιμή *και* να χρησιμοποιήσουμε αμέσως το αποτέλεσμα του τελεστή, χρειαζόμαστε τη φόρμα prefix:
+- Εάν θέλουμε να αυξήσουμε μια τιμή *και* να χρησιμοποιήσουμε αμέσως το αποτέλεσμα του τελεστή, χρειαζόμαστε τη φόρμα prefix:
 
     ```js run
     let counter = 0;

1-js/02-first-steps/15-function-basics/article.md

@@ -24,7 +24,7 @@ function showMessage() {
 
 ```js
 function name(parameter1, parameter2, ... parameterN) {
-  ...body...
+ // body
 }
 ```
 
@@ -193,6 +193,10 @@ showMessage("Ann"); // Ann: δεν έχει δοθεί κείμενο
 
 Τώρα, εάν η παράμετρος `text` δεν δοθεί, θα λάβει την τιμή `"no text given"`.
 
+```js
+showMessage("Ann", undefined); // Ann: no text given
+```
+
 Εδώ `"no text given"` είναι μια συμβολοσειρά, αλλά μπορεί να είναι μια πιο περίπλοκη έκφραση, η οποία αξιολογείται και αναθέτετε μόνο εάν λείπει η παράμετρος. Αυτό είναι επίσης δυνατό:
 
 ```js run
@@ -470,11 +474,7 @@ function name(parameters, delimited, by, comma) {
 
 Για να κάνετε τον κώδικα καθαρό και κατανοητό, συνίσταται η χρήση κυρίως τοπικών μεταβλητών και παραμέτρων στη συνάρτηση, όχι εξωτερικών μεταβλητών.
 
-<<<<<<< HEAD
 Είναι πάντα πιο εύκολο να κατανοήσουμε μια συνάρτηση που παίρνει παραμέτρους, δουλεύει μαζί τους και επιστρέφει ένα αποτέλεσμα, παρά μια συνάρτηση που δεν έχει παραμέτρους, αλλά τροποποιεί τις εξωτερικές μεταβλητές ως side-effect.
-=======
-It is always easier to understand a function which gets parameters, works with them and returns a result than a function which gets no parameters, but modifies outer variables as a side effect.
->>>>>>> 206485fc3a5465f961608b6e7303fae2e1a0e0b5
 
 Ονομασία συναρτήσεων:
 

1-js/03-code-quality/05-testing-mocha/article.md

@@ -79,7 +79,7 @@ So, the development is *iterative*. We write the spec, implement it, make sure t
 
 Let's see this development flow in our practical case.
 
-The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
+The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use a few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
 
 ## The spec in action
 

1-js/04-object-basics/09-object-toprimitive/article.md

@@ -136,8 +136,8 @@ As we can see from the code, `user` becomes a self-descriptive string or a money
 
 If there's no `Symbol.toPrimitive` then JavaScript tries to find methods `toString` and `valueOf`:
 
-- For the `"string"` hint: call `toString` method, and if it doesn't exist, then `valueOf` (so `toString` has the priority for string conversions).
-- For other hints: `valueOf`, and if it doesn't exist, then `toString` (so `valueOf` has the priority for maths).
+- For the `"string"` hint: call `toString` method, and if it doesn't exist or if it returns an object instead of a primitive value, then call `valueOf` (so `toString` has the priority for string conversions).
+- For other hints: call `valueOf`, and if it doesn't exist or if it returns an object instead of a primitive value, then call `toString` (so `valueOf` has the priority for maths).
 
 Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
 

1-js/05-data-types/02-number/article.md

@@ -334,15 +334,44 @@ alert( isFinite(num) );
 
 Please note that an empty or a space-only string is treated as `0` in all numeric functions including `isFinite`.
 
-```smart header="Compare with `Object.is`"
+````smart header="`Number.isNaN` and `Number.isFinite`"
+[Number.isNaN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) and [Number.isFinite](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite) methods are the more "strict" versions of `isNaN` and `isFinite` functions. They do not autoconvert their argument into a number, but check if it belongs to the `number` type instead.
+
+- `Number.isNaN(value)` returns `true` if the argument belongs to the `number` type and it is `NaN`. In any other case it returns `false`.
+
+    ```js run
+    alert( Number.isNaN(NaN) ); // true
+    alert( Number.isNaN("str" / 2) ); // true
+
+    // Note the difference:
+    alert( Number.isNaN("str") ); // false, because "str" belongs to the string type, not the number type
+    alert( isNaN("str") ); // true, because isNaN converts string "str" into a number and gets NaN as a result of this conversion
+    ```
+
+- `Number.isFinite(value)` returns `true` if the argument belongs to the `number` type and it is not `NaN/Infinity/-Infinity`. In any other case it returns `false`.
+
+    ```js run
+    alert( Number.isFinite(123) ); // true
+    alert( Number.isFinite(Infinity) ); //false
+    alert( Number.isFinite(2 / 0) ); // false
+
+    // Note the difference:
+    alert( Number.isFinite("123") ); // false, because "123" belongs to the string type, not the number type
+    alert( isFinite("123") ); // true, because isFinite converts string "123" into a number 123
+    ```
+
+In a way, `Number.isNaN` and `Number.isFinite` are simpler and more straightforward than `isNaN` and `isFinite` functions. In practice though, `isNaN` and `isFinite` are mostly used, as they're shorter to write.
+````
+
+```smart header="Comparison with `Object.is`"
 There is a special built-in method `Object.is` that compares values like `===`, but is more reliable for two edge cases:
 
 1. It works with `NaN`: `Object.is(NaN, NaN) === true`, that's a good thing.
 2. Values `0` and `-0` are different: `Object.is(0, -0) === false`, technically that's true, because internally the number has a sign bit that may be different even if all other bits are zeroes.
 
 In all other cases, `Object.is(a, b)` is the same as `a === b`.
 
-This way of comparison is often used in JavaScript specification. When an internal algorithm needs to compare two values for being exactly the same, it uses `Object.is` (internally called [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)).
+We mention `Object.is` here, because it's often used in JavaScript specification. When an internal algorithm needs to compare two values for being exactly the same, it uses `Object.is` (internally called [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)).
 ```
 
 
@@ -435,7 +464,9 @@ For different numeral systems:
 For regular number tests:
 
 - `isNaN(value)` converts its argument to a number and then tests it for being `NaN`
-- `isFinite(value)` converts its argument to a number and returns `true` if it's a regular number, not `NaN/Infinity/-Infinity`
+- `Number.isNaN(value)` checks whether its argument belongs to the `number` type, and if so, tests it for being `NaN`
+- `isFinite(value)` converts its argument to a number and then tests it for not being `NaN/Infinity/-Infinity`
+- `Number.isFinite(value)` checks whether its argument belongs to the `number` type, and if so, tests it for not being `NaN/Infinity/-Infinity`
 
 For converting values like `12pt` and `100px` to a number:
 

1-js/05-data-types/03-string/article.md

@@ -445,6 +445,8 @@ There are 3 methods in JavaScript to get a substring: `substring`, `substr` and
     alert( str.substr(-4, 2) ); // 'gi', from the 4th position get 2 characters
     ```
 
+    This method resides in the [Annex B](https://tc39.es/ecma262/#sec-string.prototype.substr) of the language specification. It means that only browser-hosted Javascript engines should support it, and it's not recommended to use it. In practice, it's supported everywhere.
+
 Let's recap these methods to avoid any confusion:
 
 | method | selects... | negatives |

1-js/05-data-types/05-array-methods/article.md

@@ -262,8 +262,8 @@ The method [arr.lastIndexOf](mdn:js/Array/lastIndexOf) is the same as `indexOf`,
 ```js run
 let fruits = ['Apple', 'Orange', 'Apple']
 
-alert( arr.indexOf('Apple') ); // 0 (first Apple)
-alert( arr.lastIndexOf('Apple') ); // 2 (last Apple)
+alert( fruits.indexOf('Apple') ); // 0 (first Apple)
+alert( fruits.lastIndexOf('Apple') ); // 2 (last Apple)
 ```
 
 ````smart header="The `includes` method handles `NaN` correctly"

1-js/05-data-types/06-iterable/article.md

@@ -218,7 +218,7 @@ alert(arr.pop()); // World (method works)
 
 The same happens for an iterable:
 
-```js
+```js run
 // assuming that range is taken from the example above
 let arr = Array.from(range);
 alert(arr); // 1,2,3,4,5 (array toString conversion works)
@@ -233,7 +233,7 @@ The optional second argument `mapFn` can be a function that will be applied to e
 
 For instance:
 
-```js
+```js run
 // assuming that range is taken from the example above
 
 // square each number