tweak to chapter 3 wrong section + tweak to code blocks

Author: AlbertoMontalesi

ebook/02_arrow_functions.md

@@ -47,7 +47,7 @@ const greeting = name => `hello ${name}`;
 
 Look at a side by side comparison with an old ES5 Function:
 
-```js
+```javascript
 const oldFunction = function(name){
   return `hello ${name}`
 }
@@ -58,7 +58,7 @@ const arrowFunction = name => `hello ${name}`;
 Both functions achieve the same result, but the new syntax allows you to be more concise.
 Beware! Readability is more important than conciseness so you might want to write your function like this if you are working in a team and not everybody is totally up-to-date with ES6.
 
-```js
+```javascript
 const arrowFunction = (name) => {
   return `hello ${name}`;
 }
@@ -175,7 +175,7 @@ The `arguments object` is an array-like object that we can access from inside fu
 
 A quick example:
 
-```js
+```javascript
 function example(){
   console.log(arguments[0])
 }
@@ -222,7 +222,7 @@ showWinner("Usain Bolt", "Justin Gatlin", "Asafa Powell" )
 
 Example with **function**:
 
-```js
+```javascript
 const showWinner = function() {
   const winner = arguments[0];
   return `${winner} was the winner`

ebook/03_default_function_arguments.md

@@ -2,7 +2,7 @@
 
 Prior to ES6, setting default values to function arguments was not so easy. Let's look at an example:
 
-``` js
+```javascript
 function getLocation(city,country,continent){
   if(typeof country === 'undefined'){
     country = 'Italy'
@@ -26,7 +26,7 @@ When calling `getLocation('Milan')` the second and third parameter (country and
 
 But what if we want our default value to be at the beginning and not at the end of our list of arguments?
 
-``` js
+```javascript
 function getLocation(continent,country,city){
   if(typeof country === 'undefined'){
     country = 'Italy'
@@ -52,7 +52,7 @@ If we want to replace any of the first arguments with our default we need to pas
 
 ES6 makes it very easy to set default function arguments. Let's look at an example:
 
-``` js
+```javascript
 function calculatePrice(total, tax = 0.1, tip = 0.05){
 // When no value is given for tax or tip, the default 0.1 and 0.05 will be used
 return total + (total * tax) + (total * tip);
@@ -61,14 +61,14 @@ return total + (total * tax) + (total * tip);
 
 What if we don't want to pass the parameter at all, like this:
 
-``` js
+```javascript
 // The 0.15 will be bound to the second argument, tax even if in our intention it was to set 0.15 as the tip
 calculatePrice(100, 0.15)
 ```
 
 We can solve by doing this:
 
-``` js
+```javascript
 // In this case 0.15 will be bound to the tip
 calculatePrice(100, undefined, 0.15)
 ```
@@ -77,7 +77,7 @@ It works, but it's not very nice, how to improve it?
 
 With **destructuring** we can write this:
 
-``` js
+```javascript
 function calculatePrice({
   total = 0,
   tax = 0.1,
@@ -94,7 +94,7 @@ In the example above the default value for *tip* was 0.05 and we overwrote it wi
 
 Notice this detail:
 
-``` js
+```javascript
 {
   total = 0,
   tax = 0.1,
@@ -110,7 +110,7 @@ Cannot destructure property `total` of 'undefined' or 'null'.
 
 By writing `= {}` we default our argument to an `Object` and no matter what argument we pass in the function, it will be an `Object`:
 
-```js
+```javascript
 calculatePrice({});
 // 0
 calculatePrice();
@@ -122,25 +122,3 @@ calculatePrice(undefined)
 No matter what we passed, the argument was defaulted to an `Object` which had three default properties of total, tax and tip.
 
 Don't worry about destructuring, we will talk about it in Chapter 10.
-
-Note: We now don't need to construct object and equate to an empty object. Alternative to above we can construct a function as below
-
-``` js
-function calculatePrice({
-  total = 0,
-  tax = 0.1,
-  tip = 0.05}){
-  return total + (total * tax) + (total * tip);
-}
-```
-
-and the below code would work normal
-
-``` js
-calculatePrice({});
-// 0
-calculatePrice();
-// 0
-calculatePrice(undefined)
-// 0
-```

ebook/04_template_literals.md

@@ -76,7 +76,7 @@ how are you?`;
 
 It's very easy to nest a template inside another one, like this:
 
-``` js
+```javascript
 const markup = `
 <ul>
   ${people.map(person => `<li>  ${person.name}</li>`)}
@@ -92,7 +92,7 @@ We can easily add some logic inside our template string by using a ternary opera
 
 The syntax for a ternary operator looks like this:
 
-```js
+```javascript
 const isDiscounted = false
 
 return isDiscounted ? "$10" : "$20"
@@ -101,7 +101,7 @@ return isDiscounted ? "$10" : "$20"
 
 If the condition before the `?` can be converted to `true` then the first value is returned, else it's the value after the `:` that gets returned.
 
-``` js
+```javascript
 // create an artist with name and age
 const artist = {
   name: "Bon Jovi",
@@ -136,7 +136,7 @@ const artist = {
 
 Similarly to the example above, if we want to, we can pass a function inside a template literal.
 
-``` js
+```javascript
 const groceries = {
   meat: "pork chop",
   veggie: "salad",
@@ -184,7 +184,7 @@ By tagging a function to a template literal we can run the template literal thro
 
 The way it works is very simple: you just take the name of your function and put it in front of the template that you want to run it against.
 
-```js
+```javascript
 let person = "Alberto";
 let age = 25;
 
@@ -208,7 +208,7 @@ We captured the value of the variable age and used a ternary operator to decide
 In our example our string is divided in 3 pieces: `${person}`, `is a` and `${age}`.
 We use array notation to access the string in the middle like this:
 
-```js
+```javascript
 let str = strings[1];
 ```
 

ebook/05_additional_string_methods.md

@@ -6,7 +6,7 @@ There are many methods that we can use against strings. Here's a list of a few o
 
 Gets the position of the first occurrence of the specified value in a string.
 
-```js
+```javascript
 const str = "this is a short sentence";
 str.indexOf("short");
 // Output: 10
@@ -16,7 +16,7 @@ str.indexOf("short");
 
 Pulls a specified part of a string as a new string.
 
-```js
+```javascript
 const str = "pizza, orange, cereals"
 str.slice(0, 5);
 // Output: "pizza"
@@ -26,7 +26,7 @@ str.slice(0, 5);
 
 Turns all characters of a string to uppercase.
 
-```js
+```javascript
 const str = "i ate an apple"
 str.toUpperCase()
 // Output: "I ATE AN APPLE"
@@ -36,7 +36,7 @@ str.toUpperCase()
 
 Turns all characters of a string to lowercase.
 
-```JS
+```javascript
 const str = "I ATE AN APPLE"
 str.toLowerCase()
 // Output: "i ate an apple"
@@ -61,7 +61,7 @@ ES6 introduced 4 new string methods:
 
 This new method will check if the string starts with the value we pass in:
 
-```js
+```javascript
 const code = "ABCDEFG";
 
 code.startsWith("ABB");
@@ -74,7 +74,7 @@ code.startsWith("ABC");
 
 We can pass an additional parameter, which is the starting point where the method will begin checking.
 
-``` js
+```javascript
 const code = "ABCDEFGHI"
 
 code.startsWith("DEF",3);
@@ -87,7 +87,7 @@ code.startsWith("DEF",3);
 
 Similarly to `startsWith()` this new method will check if the string ends with the value we pass in:
 
-```js
+```javascript
 const code = "ABCDEF";
 
 code.endsWith("DDD");
@@ -101,7 +101,7 @@ code.endsWith("DEF");
 
 We can pass an additional parameter, which is the number of digits we want to consider when checking the ending.
 
-``` js
+```javascript
 const code = "ABCDEFGHI"
 
 code.endsWith("EF", 6);
@@ -114,7 +114,7 @@ code.endsWith("EF", 6);
 
 This method will check if our string includes the value we pass in.
 
-```js
+```javascript
 const code = "ABCDEF"
 
 code.includes("ABB");
@@ -131,7 +131,7 @@ code.includes("CDE");
 
 As the name suggests, this new method will repeat what we pass in.
 
-``` js
+```javascript
 let hello = "Hi";
 console.log(hello.repeat(10));
 // "HiHiHiHiHiHiHiHiHiHi"

ebook/06_destructuring.md

@@ -12,7 +12,7 @@ Let's start with **destructuring objects** first.
 
 To create variables from an object we used to do this:
 
-```js
+```javascript
 var person  = {
   first: "Alberto",
   last: "Montalesi"
@@ -24,7 +24,7 @@ var last = person.last;
 
 In ES6 we can now write this:
 
-```js
+```javascript
 const person = {
   first: "Alberto",
   last: "Montalesi"
@@ -37,7 +37,7 @@ Since our `const` have the same name as the properties we want to grab, we don't
 
 The same applies even when we have nested data, such as what we could get from an API.
 
-```js
+```javascript
 const person = {
   name: "Alberto",
   last: "Montalesi",
@@ -54,14 +54,14 @@ const { facebook } = person.links.social;
 
 We are not limited to name our variable the same as the property of the object, we can also rename it like this:
 
-```js
+```javascript
 const { facebook:fb } = person.links.social;
 // it will look for the property person.links.social.facebook and name the variable fb
 ```
 
 We can also pass in **default values** like this:
 
-```js
+```javascript
 const { facebook:fb = "https://www.facebook.com"} = person.links.social;
 // we renamed the variable to *fb* and we also set a default value to it
 ```
@@ -72,14 +72,14 @@ const { facebook:fb = "https://www.facebook.com"} = person.links.social;
 
 The first difference we notice when **destructuring arrays** is that we are going to use `[]` and not `{}`.
 
-```js
+```javascript
 const person = ["Alberto","Montalesi",25];
 const [name,surname,age] = person;
 ```
 
 What if the number of variables that we create is less than the elements in the array?
 
-```js
+```javascript
 const person = ["Alberto","Montalesi",25];
 // we leave out age, we don't want it
 const [name,surname] = person;
@@ -90,7 +90,7 @@ console.log(name,surname);
 
 Let's say we want to grab all the other values remaining, we can use the **rest operator**:
 
-```js
+```javascript
 const person = ["Alberto", "Montalesi", "pizza", "ice cream", "cheese cake"];
 // we use the **rest operator** to grab all the remaining values
 const [name,surname,...food] = person ;
@@ -108,7 +108,7 @@ The `...` is the syntax for the `rest operator`
 
 The destructuring assignment makes it **extremely easy** to swap variables, just look at this example:
 
-```js
+```javascript
 let hungry = "yes";
 let full = "no";
 // after we eat we don't feel hungry anymore, we feel full, let's swap the values
@@ -124,7 +124,7 @@ It can't get easier than this to swap values.
 
 ## Destructuring functions
 
-```js
+```javascript
 function totalBill({ total, tax = 0.1 }) {
   return total + (total * tax);
 }