Presentation improved for all files in Javascript_Basics

Author: Swap76

docs/JavaScript_Basics/number_methods.md

@@ -1,8 +1,6 @@
 # Number Methods
 
-## Number methods allow you to easily work with numbers
-
-**isFinite()**
+## isFinite()
 Checks whether a value is a finite number.
 Finite is a number that isn't infinite and can be measured or given a value.
 
@@ -16,48 +14,48 @@ Numbers that pass as finite:
 - decimals
 - equations
 
-**.isInteger()**
+## .isInteger()
 Checks whether the value passed is an integer.
 It's return value will be a boolean (true / false)
 
-**.isNaN()**
+## .isNaN()## 
 Checks whether the value passed is NaN (Not a number) or if the value is a number
 
 true = NaN
 
-**.isSafeInteger()**
+## .isSafeInteger()
 Checks whether the method passed is a safe integer. The returned value will provide a boolean.
 
 A safe integer is represented as an IEEE-754 double precision number. This is simply any number between -9007199254740991 and 9007199254740991.
 
 Note that the value isn't changed to a number if a string is passed in.
 
-**.toExponential()**
+## .toExponential()
 Converts a number to its exponential form. The returned value is a string that represents the Number object in exponential notation
 
-**.toFixed()**
+## .toFixed()
 Formats a number using the fixed-point notation. It allows you to format a number with a specific number of digits to the right of the decimal. Numbers will be rounded if necessary.
 
 Its return value is a string with the given number using fixed-point notation. If the number given is negative, the return value will be a number and won't be converted into a string.
 
-**.toLocaleString()**
+## .toLocaleString()
 Converts a number into a language-sensitive representation of said number.
 It can take in two optional parameters:
 - locales: A string with a language tag (bali, latn)
 - options: A set of options for the given locale (currency, style)
 
 The return value is a string.
 
-**.toPrecision()**
+## .toPrecision()
 Converts a number to the specified precision.
 
 The returned value is in the form of a string. The value will be rounded and padded with 0's if there are not enough digits.
 
-**.toString()**
+## .toString()
 Converts a given number to a string with the specified base number (an integer between 2 and 36)
 
 The return value is given in the form of a string if no radix is given.
 
-**.valueOf()**
+## .valueOf()
 Returns the number value in primitive form of a Number object.
 This is rarely something done on your own, as JavaScript invokes this automatically.

docs/JavaScript_Basics/regex.md

@@ -17,9 +17,7 @@ var re = new RegExp('pattern', 'flags');
 
 In each of these cases, the variable `re` is a regex, and 'pattern' and 'flags' are placeholders that we will learn about next.
 
-## Anatomy of a Regex
-
-### Simple Character Patterns
+## Simple Character Patterns
 A Regex can be constructed from simple characters, like 'a', 'b', and 'c', or special characters such as '()', '*', and '$'. A Regex using simple characters simply searches for an exact match of that combination of characters within the searched string. The most basic example of a regex would be:
 
 ```js
@@ -36,7 +34,7 @@ console.log(result);
 // expected output: 0 since 'abc' is found at index 0 of exampleString
 ```
 
-### Special Character Patterns
+## Special Character Patterns
 Once you are ready to perform more complex searches on strings, you will want to start using special characters. There are a lot of special characters that can be used, so only a select few will be covered below, and a reference with explanations for the exhausive list of characters can be found at the bottom of the document.
 
 - `/[abc]/` specifies a character set which matches any one of the characters within the brackets. Unlike `/abc/`, `/[abc]/` matches on indices 0, 1, and 2 of the example string used in the Simple Character Patterns example. An alternative syntax for `/[abc]/` is `/[a-c]/`.
@@ -60,7 +58,7 @@ console.log(result2);
 - `/^abc/` uses the '^' special character outside of the context of square brackets. In this case, the '^' special character refers to the beginning of the search string. A search using this regex would succeed for the test string 'abcdefg' since the simple character pattern 'abc' does occur at the beginning of the test string.
 - `/efg$/` uses the '$' special character, which refers to the end of the search string. A search using this regex would also succeed for the test string 'abcdefg' since this test string ends in the simple character pattern 'efg'.
 
-### Flags
+## Flags
 Flags are placed at the end of Regex, and allow for an even more robust set of search possibilities. They can be used together or independently regardless of order. Two of the most commonly used flags are:
 
 - `g`: Global search. This allows the regex to be applied to the entire test string, regardless of whether a match has already been found.

docs/JavaScript_Basics/splice_slice.md

@@ -26,7 +26,7 @@ languages.splice(2, 1, "Python", "Pearl");
  This will add Python and Perl starting at index 2 and delete one element which was at index 2 originally.
  As of result we get an output of `["C++", "Java", "Python", "Pearl", "R"]`
 
- #### Example 3: Deleting an element at a specific index
+#### Example 3: Deleting an element at a specific index
 
 ```javascript
 let languages = ["C++", "Java", "Javascript", "R"];

docs/JavaScript_Basics/string-concat.md

@@ -9,21 +9,57 @@ const variableName = "Hello JavaScript";
 const variableName = 'Hello JavaScript';
 ```
 
-### Concatenation
-First way of doing string concatenation is using **+** operator
-```javascript
-const name = "Richard";
+## Concatenation
 
-const text = "Hello " + name; 
+String concatenation is joining 2 or more strings together in one string
 
-console.log(text);  // Hello Richard
-``` 
-Or using **template literals**. More convenient way for manipulating strings contains many variables.
-```javascript
-const name = "Richard";
+There are several method to achieve this in javascript and here we will mention some:
 
-// Use backticks ( ` ) inside quotes and put variables inside ${}
-const text = `Hello ${Richard}`;
+1. Using .concat() method ( same as Array.concat() method )
+    ```javascript
 
-console.log(text);  // Hello Richard
-```
+    let str = 'hello '.concat('world!')
+    console.log(str) // hello world!
+
+    let user = 'jack'
+    console.log('welcome '.concat(user)) // welcome jack
+
+    ```
+
+2. Using plus operator
+    ```javascript
+
+    let str = 'hello ' + 'world!'
+    console.log(str) // hello world!
+
+    let user = 'jack'
+    console.log('welcome '+ user) // welcome jack
+
+    ```
+2. Using Template literals (Template strings):
+   -  using back-ticks
+   -  new feature from ES6
+   -  you can add multiple lines in one string without the need to add \<br\> tags or \n special character
+    ```javascript
+
+    let str = `hello world!`
+    console.log(str) // hello world!
+
+    let user = 'jack'
+    console.log(`welcome ${jack}`) // welcome jack
+
+    console.log(`this is
+    a multiline string
+    created by Template literals`)
+    // output :
+    //this is
+    //a multiline string
+    //created by Template literals
+
+    // ES5 version
+    console.log('this i\na multiline string\ncreated by Template literals')
+    // output :
+    //this is
+    //a multiline string
+    //created by Template literals
+    ```

docs/JavaScript_Basics/string_operation.md

@@ -18,7 +18,7 @@ Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, parent: Window, …}
 
 ```
 
-  ## 'this'  in a function
+## 'this'  in a function
 
 In JavaScript, by default the owner of the function is `this`. The value of this in a function refers to the object it belongs to. In below example, `this` refers to window object, so instead of printing '5' it refers to global value '10'.
 
@@ -58,7 +58,7 @@ printX();
  */
 ```
 
-  ## 'this' in a method
+## 'this' in a method
 
 In JavaScript, `this` in a method refers to the object of which the method belongs to.  In below example, the `printX` method belongs to person object. so `this` refers to person object.