added notes on filter (more for my use cases article)

Author: JasonHarder

Arrraynoodling.js

@@ -2,9 +2,9 @@
 
 const cheese = [1,2,3,4,5,6,7,8]
 const wheel = [9,10,11,12,13,14]
+console.log(Array.of(cheese,wheel));
 
-console.log(Array.of(cheese,wheel));         // [1]
-Array.of(1, 2, 3);   // [1, 2, 3]
+console.log(Array.of(1, 2, 3));
 Array.of(undefined);
 
 const forest = 'There are deers , bears and foxes here'
@@ -14,3 +14,26 @@ console.log(forestArray)
 console.log(animals)
 
 
+// findSum(5) should return 8 (3 + 5)
+
+// findSum(10) should return 33 (3 + 5 + 6 + 9 + 10)
+
+
+
+function findSum(n) {
+  const divide3 = 3 % n
+  const divide5 = 5 % n
+  console.log(divide3)
+  console.log(divide5)
+}
+
+console.log(findSum(10))
+
+//You will be provided with an initial array (the first argument in the destroyer function), followed by one or more arguments. Remove all elements from the initial array that are of the same value as these arguments.
+
+function destroyer(arr) {
+  // Remove all the values
+  return arr;
+}
+
+destroyer([1, 2, 3, 1, 2, 3], 2, 3);

arraymethods.md

@@ -114,12 +114,20 @@ Filter is a method on an array that takes a callback and you can (in that callba
 
 IF YOU ARE SEARCHING THROUGH EXISTING DATA YOU SHOULD FILTER IT.
 
+You can filter by booleans , Datatypes (all sorts of stuff).
+
 #### filter() syntax
 
 ```Javascript
 
 const totalPurchases = transactions.filter(transaction => transaction.type === 'purchase').length
 
+
+const bouncer = (arr) => {
+  return arr.filter(Boolean)
+}
+
+// Filters for true values (FCC Challange ^^)
 ```
 
 ### .map()
@@ -312,8 +320,8 @@ var arr2 = [3, 4, 5];
 arr1 = arr1.concat(arr2);
 // With spread syntax this becomes:
 
-var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
+let arr1 = [0, 1, 2];
+let arr2 = [3, 4, 5];
 arr1 = [...arr1, ...arr2];
 ```
 

bigO.md

@@ -0,0 +1,11 @@
+# Big O notes
+
+With big O we express runtime in terms of how quickly it grows relative to the input as the input gets arbitrarily large.
+
+Broken down it looks like this:
+
+1. How quickly the runtime grows.
+
+2. Relative to the input.
+
+3. As the input gets arbitrarily large.

es6notes.md

@@ -0,0 +1,52 @@
+# Jason's Es6 Notes
+
+1. Let & Const vs var
+
+2. Arrow functions and defaulr arguements
+
+3. Template strings & string improvements
+
+4. Destructuring
+
+5. Interables & Loops
+
+6. Array Improvements
+
+7. Spread & Rest
+
+8. Promises
+
+9. JS modules & NPM
+
+10. Object Orientated JS
+
+## Let & Const vs Var
+
+
+### Scope
+
+```Javascript
+
+var dogYears = age * 7;
+
+```
+
+#### Scope w/Var
+
+Looking at the above var what do you see ?
+you see a variable you can call anywhwere which can cause problems when you want to just call something once or are using a temporary variable.
+
+It is best to put vars inside a function (since you are controlling it's scope)but they must be WITHIN the function for it to play well.
+
+### Scope w/ Let & Const
+
+```Javascript
+
+const dogYears1 = age * 7;
+
+```
+
+The const declaration creates a read-only variable - this does not mean the value is immutable (it isn't unless we use object.freeze) what it DOES mean is that the variable cannot be reassigned so its parameters can be altered but what it is itself cannot be changed (i.e we cannot change the variables name to catLives but we can change it to be 9)
+
+LET AND CONST ARE BLOCK SCOPED
+

jsvalueorreference.md

@@ -0,0 +1,14 @@
+## JS: Value or reference ?
+
+Short answer: Passing primitive types (strings numbers booleans) are passed by object. Objects are passed by reference.
+
+````Javascript
+
+var a;
+function foo(a) {
+
+}
+
+```
+
+The followup question would be:

usestrict.md

@@ -0,0 +1,98 @@
+# Use Strict in JavaScript
+
+What is use Strict ?
+
+Use Strict allows you to place a function or program in what is called a "Strict Operating Context" Code that would usually fail silently or been ignored would not generate errors / throw exceptions. This directs you to errors in your code quicker.
+
+You can enable this by typing it in (as a string) "use strict". These are not special keywords , it is a string. The reason why is because when it was implimented not all browsers supported it and if older browsers read it it would have failed.
+
+JS reads use strict 2 ways - as a string (as mentioned) or as a function (below)
+
+c
+
+If you run it as a function essentially you would just put the functions in strict mode within the scope of the strictCode() function (or whatever you name it)
+
+## Strict rules & Changes
+
+NTS: It seems like strict mode is similiar to using a linter.Except while a linter will call you out Strict will throw an error.
+
+
+### Defining Variables
+
+1. Using a variable before it is defined throws an error. (Like with ESlint Airbnb config) in  js there is always a global object where the global variables and functions go
+
+- In the browser this is the window.
+
+- In Node this is an object called 'global'.
+
+### syntax
+
+```Javascript
+
+// in browser
+asim =1;
+console.log(window.asim)
+// in node
+console.log(global.asim)
+```
+
+A problem with this is it can cause problems when calling variables, especially in larger files (i.e the kind you might use in production).
+
+###example:
+
+```Javascript
+
+const value = 0
+
+//pretend we have gone down 400 lines and attempt to call the value variable and reassign it like so:
+
+values = 1;
+
+if (value > 0 ) {
+  console.log('Hello')
+}
+
+// so as we might see here i might expect it to print hello and realized I meant to set VALUE not VALUES. if we were to use STRICT mode it would return an undefined error - in my personal case my ESlinter would cover this. But it is good to know when working in a professional setting.'use strict ' stops these syntax errors by calling them out for you
+```
+
+## Reserved Words
+
+2. As we know , let and const are words reserved for ES6 - lots of words are reserved for special use in JS , without strict mode this would not throw an error.
+
+```Javascript
+
+Const let = 1;
+
+// Uncaught SyntaxError: Unexpected strict mode reserved word.
+```
+
+## Cannot delete functions,variables or function arguements
+
+I.e - without strict mode you can delete functions variables or function arguements you would do it by doing this:
+
+``` Javascript
+
+const foo = 0;
+delete foo
+
+function moo(arguement) {
+  delete arg;
+};
+// these would work normally but in strict mode throws errors.
+```
+
+## Calling eval('')
+
+eval() lets you run any code as an arguement as long as you pass it as a string. This can cause security issues.
+
+```Javascript
+var eval = 1;
+// causes error in strict mode
+
+
+eval("var a = 1");
+console.log(a);
+// above code can cause an issue with the namespace and the console log would not normally work as it is messing with its own block
+```
+
+Anyway with use strict any variables you print within eval stays within it so when you console.log it in the same manner as the example above - you throw an error (a is not defined).