feat: rewrite and add new sections

Author: Kikobeats

.travis.yml

@@ -16,22 +16,28 @@
 
 * Function
 	* [new agnostic](function/new.md)
-	* [bind is slower](function/bind.md)
+	* [.bind is slower](function/bind.md)
 
 * RegExp
 	* [Use the correct method](regexp/correct-methods.md)
 	* [Focus on failing faster](regexp/fail-faster.md)
-	* [Mandatory Fields](regexp/flags.md)
+	* [Dot all flag](regexp/dot-all-flag.md)
+	* [Global flag](regexp/global-flag.md)
+	* [Unicode flag](regexp/unicode-flag.md)
+
+* Object
+	* [Empty prototype](object/empty-prototype.md)
 
 * V8
-	* [Hidden Class](v8-tips/hidden-class.md)
-	* [Sparse Arrays](v8-tips/sparse-arrays.md)
-	* [Properties Names](v8-tips/properties-names.md)
 	* [Float Number](v8-tips/float-number.md)
+	* [Freeing memory](v8-tips/freeing-memory.md)
+	* [Hidden classes](v8-tips/hidden-classes.md)
 	* [Inline initialization](v8-tips/inline-initialization.md)
 	* [Monomorphic](v8-tips/monomorphic.md)
+	* [Properties Names](v8-tips/properties-names.md)
+	* [Sparse Arrays](v8-tips/sparse-arrays.md)
 	* [Use strict](v8-tips/use-strict.md)
-	* [Freeing memory](v8-tips/freeing-memory.md)
+  * [Spread Syntax](v8-tips/spread-syntax.md)
 
 * Workflow
 	* [Deferring by a tick](workflow/defer.md)
@@ -42,4 +48,4 @@
 	* [Scope](workflow/scope.md)
 	* [Variable access](workflow/variable-access.md)
 	* [How to clone](workflow/how-to-clone.md)
-	* [null and undefined](workflow/null-and-undefined.md)
+	* [null or undefined](workflow/null-or-undefined.md)

contributing.md renamed to CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# pop over shift
+# .pop over .shift
 
 The `.shift` method removes the first element from an array and returns it.
 

docs/_sidebar.md

@@ -1,6 +1,10 @@
 # Preallocation
 
-## Initialize value
+Preallocation is when you reserve memory space before using it.
+
+This is specially useful when you know much much space you need, or you want to avoid expanding repeatedly the size of a collection over time.
+
+## Initializing the values
 
 If you want to preallocate an array with a initial value, you can use [`Array.from()`](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/from):
 
@@ -11,7 +15,7 @@ const n = 5
 [...Array(n).keys()] // [ 0, 1, 2, 3, 4 ]
 
 // more powerful
-Array.from({length: n}, (value, index) => index) // [ 0, 1, 2, 3, 4 ]
+Array.from({ length: n }, (value, index) => index) // [ 0, 1, 2, 3, 4 ]
 ```
 
 ## Reusing instances

docs/array/pop-or-shift.md

@@ -48,7 +48,6 @@
 <script src="//unpkg.com/docsify@latest/lib/plugins/external-script.min.js"></script>
 <script src="//unpkg.com/docsify@latest/lib/plugins/ga.min.js"></script>
 <script src="//unpkg.com/docsify-pagination/dist/docsify-pagination.min.js"></script>
-<script async src="//cdn.headwayapp.co/widget.js"></script>
 <script src="//cdn.jsdelivr.net/npm/codecopy/umd/codecopy.min.js"></script>
 
 </html>

docs/array/preallocation.md

@@ -0,0 +1,19 @@
+# Empty prototype
+
+All objects in JavaSCript are instance of `Object` and they inherit properties and methods, such as `.toString`.
+
+There are situations in which you just want to use an `Object` instance as a container of values.
+
+For thoese cases, an `Object` maybe be deliberately created with an empty prototype, meaning it inherits nothing.
+
+```js
+const cache = Object.create(null)
+```
+
+In this way, the object has a smaller memory footprint.
+
+Since it doesn't inherit from other object, you can't typechecking using `instanceof`:
+
+```js
+Object.create(null) instanceof Object // false
+```

docs/index.html

@@ -1,34 +1,4 @@
-# Always use flags
-
-## Unicode flag
-
-The unicode (`u`) flag is mandatory when working with Unicode strings, in particular when you might need to handle characters in astral planes, the ones that are not included in the first 1600 Unicode characters.
-
-Like Emojis, for example, but not just those.
-
-If you don’t add that flag, this simple regex that should match one character will not work, because for JavaScript that emoji is represented internally by 2 characters (see [Unicode in JavaScript](https://flaviocopes.com/javascript-unicode/)):
-
-```js
-/^.$/.test('a')   // ✅
-/^.$/.test('🐶')  // ❌
-/^.$/u.test('🐶') // ✅
-```
-
-So, always use the `u` flag.
-
-Keep in mind that Unicode, just normal characters, handle ranges:
-
-```js
-/[a-z]/.test('a') // ✅
-/[1-9]/.test('1') // ✅
-
-/[🐶-🦊]/u.test('🐺') // ✅
-/[🐶-🦊]/u.test('🐛') // ❌
-```
-
-JavaScript checks the internal code representation, so `🐶 < 🐺 < 🦊` because `\u1F436 < \u1F43A < \u1F98A`. Check [emoji-regex](https://github.com/mathiasbynens/emoji-regex) for exploring more about that.
-
-## Dot all flag
+# Dot all flag (s)
 
 By default, `.` matches any character except for line terminators.
 
@@ -38,25 +8,25 @@ Line terminators are specially remarkable when you are working with [Templates S
 const input = `
 Lorem ipsum dolor sit amet, consectetur adispiscing hello
 world elit. Nam sit amet elit id risus aliquam porta.
-`
+`;
 
 /hello.world/u.test(input)
 // → false 🤔
 ```
 
 As you can see, it doesn't match because a line break is present between `hello` and `world` words.
 
-The problem, is that the dot, in fact, doest not math all characters. It only matches characters that JavaScript does not consider to be line terminators.
+The "dot" doesn't match all characters. It only matches characters that JavaScript doesn't consider to be line terminators.
 
 Sometimes you really do want to match any character, including new lines. This problem is so common that developers have started to use workarounds like this:
 
 ```js
 const input = `
 Lorem ipsum dolor sit amet, consectetur adispiscing hello
 world elit. Nam sit amet elit id risus aliquam porta.
-`
+`;
 
-/hello[\s\S]world/u.test(input);
+/hello[\s\S]world/u.test(input)
 // → true 😕
 ```
 
@@ -68,9 +38,9 @@ Another workaround is to use a negated empty character class:
 const input = `
 Lorem ipsum dolor sit amet, consectetur adispiscing hello
 world elit. Nam sit amet elit id risus aliquam porta.
-`
+`;
 
-/hello[^]world/u.test(input);
+/hello[^]world/u.test(input)
 // → true 🤷‍♂️
 ```
 
@@ -84,7 +54,7 @@ The new regular expression flag called dotAll mode (`s`) makes the dot truly mat
 const input = `
 Lorem ipsum dolor sit amet, consectetur adispiscing hello
 world elit. Nam sit amet elit id risus aliquam porta.
-`
+`;
 
 /hello.world/us.test(input)
 // → true 🎉

docs/main.min.js

@@ -0,0 +1,53 @@
+# Global flag (g)
+
+The global flag indicates the regular expression should be tested against all possible matches in a string.
+
+```js
+const regex = new RegExp('o', 'g')
+
+const greetings = 'Hello, how are you?'
+const results = greetings.match(regex)
+
+console.log(results.length) // => 3
+```
+
+If you just want to know if a string matches a regular expression, you use [RegExp.test()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test) for it.
+
+```js
+const regex = new RegExp('o', 'g')
+const greetings = 'Hello, how are you?'
+
+regex.test(greetings) // => true
+```
+
+When `.test` is invoked, the regex keeps internally the state of the search at [lastIndex](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex) property.
+
+This will be cause inconsistent results if you call test method several times:
+
+```js
+const regex = new RegExp('o', 'g')
+const greetings = 'Hello, how are you?'
+
+regex.lastIndex // => 0
+regex.test(greetings) // => true
+regex.lastIndex // => 5
+regex.test(greetings) // => true
+regex.lastIndex // => 9
+regex.test(greetings) // => true
+regex.lastIndex // => 17
+regex.test(greetings) // => false
+regex.lastIndex // => 0
+```
+
+As you can see, `lastIndex` will continue from the last matched result.
+
+That can be easily avoided just wrapping into a function that will be executed from the beginning every time:
+
+```js
+const regex = new RegExp('o', 'g')
+const greetings = 'Hello, how are you?'
+
+const test = (regex, str) => regex.test(str)
+
+test(regex, greetings) // => true
+```