Merge branch 'gh-pages' of github.com:loverajoel/jstips into gh-pages

README.md

@@ -30,6 +30,7 @@ There are a lot of ways to get update, choose your own
 
 # Tips list
 
+- 45 - [Calculate the Max/Min value from an array](https://github.com/loverajoel/jstips/blob/gh-pages/_posts/en/2016-02-14-calculate-the-max-min-value-from-an-array.md)
 - 44 - [Know the passing mechanism](https://github.com/loverajoel/jstips/blob/gh-pages/_posts/en/2016-02-13-know-the-passing-mechanism.md)
 - 43 - [Use destructuring in function parameters](https://github.com/loverajoel/jstips/blob/gh-pages/_posts/en/2016-02-12-use-destructuring-in-function-parameters.md)
 - 42 - [Preventing Unapply Attacks](https://github.com/loverajoel/jstips/blob/gh-pages/_posts/en/2016-02-11-preventing-unapply-attacks.md)

_posts/en/2016-02-13-know-the-passing-mechanism.md

@@ -55,9 +55,9 @@ console.log(me);			// 4  : {'partOf' : 'A Group'}
 
 ```
 
-In the case of `myGroup` invocation, we are passing the object `me`. But unlike the example 1 scenario, we are not assigning this `me` variable to any new object, effectvely meaning the object reference value within the `myGroup` function scope still is the original object's reference value and when we are modifying the property within this scope, it is effectively modifying the original object's property. Hence, you get the output from #`7`.
+In the case of `myGroup` invocation, we are passing the object `me`. But unlike the example 1 scenario, we are not assigning this `me` variable to any new object, effectively meaning the object reference value within the `myGroup` function scope still is the original object's reference value and when we are modifying the property within this scope, it is effectively modifying the original object's property. Hence, you get the output from #`7`.
 
 So does this later case not prove that javascript is pass-by-reference? No, it does not. Remember, *JavaScript passes the reference as value, in case of objects*. The confusion arises as we tend not to understand fully what pass by reference is. This is the exact reason, some prefer to call this as *call-by-sharing*.
 
 
-*Initially posted by the author on [js-by-examples](https://github.com/bmkmanoj/js-by-examples/blob/master/examples/js_pass_by_value_or_reference.md)*
+*Initially posted by the author on [js-by-examples](https://github.com/bmkmanoj/js-by-examples/blob/master/examples/js_pass_by_value_or_reference.md)*

_posts/en/2016-02-14-calculate-the-max-min-value-from-an-array.md

@@ -0,0 +1,41 @@
+---
+layout: post
+
+title: Calculate the Max/Min value from an array
+tip-number: 45
+tip-username: loverajoel
+tip-username-profile: https://www.twitter.com/loverajoel
+tip-tldr: Ways to use the built-in functions Math.max() and Math.min() with arrays of numbers
+
+categories:
+    - en
+---
+
+The built-in functions [Math.max()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max) and [Math.min()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min) find the maximum and minimum value of the arguments, respectively.
+
+```js
+Math.max(1, 2, 3, 4); // 4
+Math.min(1, 2, 3, 4); // 1
+```
+
+These functions will not work as-is with arrays of numbers. However, there are some ways around this.
+
+[`Function.prototype.apply()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply) allows you to call a function with a given `this` value and an _array_ of arguments.
+
+```js
+var numbers = [1, 2, 3, 4];
+Math.max.apply(null, numbers) // 4
+Math.min.apply(null, numbers) // 1
+```
+
+Passing the `numbers` array as the second argument of `apply()` results in the function being called with all values in the array as parameters.
+
+A simpler, ES2015 way of accomplishing this is with the new [spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator).
+
+```js
+var numbers = [1, 2, 3, 4];
+Math.max(...numbers) // 4
+Math.min(...numbers) // 1
+```
+
+This operator causes the values in the array to be expanded, or "spread", into the function's arguments.