//- Destructure an object to reference specific values
   - if you want to use variable names that don't match the keys, you can use aliasing
      - `let { oldkeyname: newkeyname } = object`- rule of thumb—only destructure values from objects that are two levels deep
```js
//let obj = {name: "Wilfred",appearance: ["short", "mustache"],favorites: {color: "mauve",food: "spaghetti squash",number: 3}}// with variable names that match keyslet { name, appearance } = obj;
console.log(name); // "Wilfred"
console.log(appearance); // ["short", "mustache"]// with new variable names (aliasing)let {name: myName, appearance: myAppearance} = obj;

console.log(myName); // "Wilfred"
console.log(myAppearance); // ["short", "mustache"]// in a function calllet sayHello = function({name}) {
console.log("Hello, " + name); // "Hello Wilfred"}// nested objects + aliasinglet { favorites: {color, food: vegetable} } = obj;
console.log(color, vegetable); //=> mauve spaghetti squash

//let greaterCB = function (val, callback1, callback2) {if (callback1(val) > callback2(val)) {return callback1(val);}return callback2(val);};let greaterCB = function (val, callback1, callback2) {if (callback1(val) > callback2(val)) {return callback1(val);}return callback2(val);};

//- Write a function, myMap, that takes in an array and a callback as arguments. The function should mimic the behavior of `Array#map`.```js
//let myMap = function(array, callback) {let newArr = [];for (let i = 0; i < array.length; i ++) {
      mapped = callback(array[i], i, array);
      newArr.push(mapped);}return newArr;}
console.log( myMap([16,25,36], Math.sqrt)); // => [4, 5, 6];let myMapArrow = (array, callback) => {let newArr = [];
   array.forEach( (ele, ind, array) => {
      newArr.push(callback(ele, ind, array));})return newArr;}
console.log(myMapArrow([16,25,36], Math.sqrt)); // => [4, 5, 6];

//makeFuncBoundToObj: function () {return () => {return this.name;}// this function will return a function that will be bound// to the object where we call the outer method// because the arrow syntax is nested inside one of this// function's methods, it cannot be rebound},makeUnboundFunc: function () {return function () {return this.name;}//this function will return a function that will still be unbound},immediatelyInvokedFunc: function () {return this.name;}(), // this property will be set to the return value of this anonymous function,// which is invoked during the object definition;// basically, it's a way to check the context inside of an object, at this momentinnerObj: {name: "inner object",innerArrowFunc: () =>  {return this.name;} // the context inside a nested object is not the parent, it's still// the global object. entering an object definition doesn't change the context},let otherObj = { name: "my other object" }// call unboundFunc on obj, we get "my object" console.log("unboundFunc: ", obj.unboundFunc()); // => "my object" // assign unboundFunc to a variable and call it let newFunc = obj.unboundFunc; // this newFunc will default to being called on global object console.log("newFunc: ",newFunc()); // => undefined // but you could bind it directly to a different object if you wanted console.log("newFunc: ", newFunc.bind(otherObj)()); // "my other object"// meanwhile, obj.boundToGlobal will only ever be called on global object console.log("boundToGlobal: ", obj.boundToGlobal()); //=> undefined let newBoundFunc = obj.boundToGlobal; console.log("newBoundFunc: ", newBoundFunc()); // => undefined // even if you try to directly bind to another object, it won't work! console.log("newBoundFunc: ", newBoundFunc.bind(otherObj)()); // => undefined// let's make a new function that will always be bound to the context // where we call our function maker let boundFunc = obj.makeFuncBoundToObj();// note that we're invoking, not just assigning console.log("boundFunc: ", boundFunc()); // => "my object" // we can't rebind this function console.log("boundFunc: ", boundFunc.bind(otherObj)()) // =>"my object"// but if I call makeFuncBoundToObj on another context // the new bound function is stuck with that other context let boundToOther = obj.makeFuncBoundToObj.bind(otherObj)(); console.log("boundToOther: ", boundToOther()); // => "my other object" console.log("boundToOther: ", boundToOther.bind(obj)()) // "my other object"// the return value of my immediately invoked function // shows that the context inside of the object is the // global object, not the object itself // context only changes inside a function that is called // on an object console.log("immediatelyInvokedFunc: ", obj.immediatelyInvokedFunc); // => undefined// even though we're inside a nested object, the context is // still the same as it was outside the outer object // in this case, the global object console.log("innerArrowFunc: ", obj.innerObj.innerArrowFunc()); // => undefined

//- Implement a closure and explain how the closure effects scope
   - a closure is "the combination of a function and the lexical environment within which that function was declared"- alternatively, "when an inner function uses or changes variables in an outer function"- closures have access to any variables within their own scope + scope of outer functions + global scope — the set of all these available variables is "lexical environemnt"- closure keeps reference to all variables **even if the outer function has returned**- each function has a private mutable state that cannot be accessed externally
      - the inner function will maintain a reference to the scope in which it was declared. so it has access to variables that were initialized in any outer scope—even if that scope
      - if a variable exists in the scope of what could have been accessed by a function (e.g. global scope, outer function, etc), does that variable wind up in the closure even if it never got accessed?- if you change the value of a variable (e.g. i++) you will change the value of that variable in the scope that it was declared in---```js
//function createCounter() {// this function starts a counter at 0, then returns a// new function that can access and change that counter//// each new counter you create will have a single internal// state, that can be changed only by calling the function.// you can't access that state from outside of the function,// even though the count variable in question is initialized// by the outer function, and it remains accessible to the// inner function after the outer function returns.let count = 0;return function() {
      count ++;return count;}}let counter = createCounter();
console.log(counter()); //=> 1
console.log(counter()); //=> 2// so the closure here comes into play because// an inner function is accessing and changing// a variable from an outer function// the closure is the combination of the counter// function and the all the variables that existed// in the scope that it was declared in. because// inner blocks/functions have access to outer// scopes, that includes the scope of the outer// function.// so counter variable is a closure, in that// it contains the inner count value that was// initialized by the outer createCounter() function// count has been captured or closed over// this state is private, so if i run createCounter again// i get a totally separate count that doesn't interact// with the previous one and each of the new functions// will have their own internal state based on the// initial declaration in the now-closed outer functionlet counter2 = createCounter();
console.log(counter2()); // => 1// if i set a new function equal to my existing counter// the internal state is shared with the new functionlet counter3 = counter2;
console.log(counter3());

//- `bind` can also work with arguments, so you can have a version of a function with particular arguments and a particular context. the first arg will be the context aka the `this` you want it to use. the next arguments will be the functions arguments that you are binding
      - if you just want to bind it to those arguments in particular, you can use `null` as the first argument, so the context won't be bound, just the arguments
- Given a code snippet, identify what `this` refers to
   - important to recognize the difference between scope and context
      - scope works like a dictionary that has all the variables that are available within a given block, plus a pointer back the next outer scope (which itself has pointers to new scopes until you reach the global scope. so you can think about a whole given block's scope as a kind of linked list of dictionaries) (also, this is not to say that scope is actually implemented in this way, that is just the schema that i can use to understand it)- context refers to the value of the `this` keyword
   - the keyword `this` exists in every function and it evaluates to the object that is currently invoking that function- so the context is fairly straightforward when we talk about methods being called on specific objects
   - you could, however, call an object's method on something other than that object, and then this would refer to the context where/how it was called, e.g.```js
//let dog = {name: "Bowser",changeName: function () {this.name = "Layla";},};// note this is **not invoked** - we are assigning the function itselflet change = dog.changeName;
console.log(change()); // undefined// our dog still has the same name
console.log(dog); // { name: 'Bowser', changeName: [Function: changeName] }// instead of changing the dog we changed the global name!!!
console.log(this); // Object [global] {etc, etc, etc,  name: 'Layla'}

   - `bind` can also work with arguments, so you can have a version of a function with particular arguments and a particular context. the first arg will be the context aka the `this` you want it to use. the next arguments will be the functions arguments that you are binding
      - if you just want to bind it to those arguments in particular, you can use `null` as the first argument, so the context won't be bound, just the arguments
- Given a code snippet, identify what `this` refers to
   - important to recognize the difference between scope and context
      - scope works like a dictionary that has all the variables that are available within a given block, plus a pointer back the next outer scope (which itself has pointers to new scopes until you reach the global scope. so you can think about a whole given block's scope as a kind of linked list of dictionaries) (also, this is not to say that scope is actually implemented in this way, that is just the schema that i can use to understand it)
      - context refers to the value of the `this` keyword
   - the keyword `this` exists in every function and it evaluates to the object that is currently invoking that function
   - so the context is fairly straightforward when we talk about methods being called on specific objects
   - you could, however, call an object's method on something other than that object, and then this would refer to the context where/how it was called, e.g.
```js
//
let dog = {
   name: "Bowser",
   changeName: function () {
      this.name = "Layla";
  },
};

// note this is **not invoked** - we are assigning the function itself
let change = dog.changeName;
console.log(change()); // undefined

// our dog still has the same name
console.log(dog); // { name: 'Bowser', changeName: [Function: changeName] }

// instead of changing the dog we changed the global name!!!
console.log(this); // Object [global] {etc, etc, etc,  name: 'Layla'}

//let obj = { one: 1, two: 2 };// Choose the square brackets property accessor when the property name is determined at// runtime, or if the property name is not a valid identifierlet myKey = 'one';
console.log(obj[myKey]);// Choose the dot property accessor when the property name is known ahead of time.
console.log(obj.two);

//let keyName = 'two';// If the key is not known, you can use an alternative `[]` syntax for// object initialization onlylet obj2 = { [keyName]: 2 };
console.log(obj2);

//function doesKeyExist(obj, key) {// obj[key] !== undefined// or:return key in obj;}let course = { bootcamp: 'Lambda', course: 'Bootcamp Prep' };
console.log(doesKeyExist(course, 'course')); // => true
console.log(doesKeyExist(course, 'name')); // => false

//function printKeys(object) {return Object.keys(object);}function printValues(object) {return Object.values(object);}

console.log(printKeys({ dog: 'Strelka', dog2: 'Belka' }));
console.log(printValues({ dog: 'Strelka', dog2: 'Belka' }));

//let player = { name: 'Sergey', skill: 'hockey' };for (let key in player) {
    console.log(key, player[key]);}

console.log(Object.entries(player));

//function restSum(...otherNums) {let sum = 0;
    console.log(otherNums);
    otherNums.forEach(function (num) {
        sum += num;});return sum;}

console.log(restSum(3, 5, 6)); // => 14
console.log(restSum(1, 2, 3, 4, 5, 6, 7, 8, 9)); // => 45
console.log(restSum(0)); // => 0

//let numArray = [1, 2, 3];let moreNums = [...numArray, 4, 5, 6];

console.log(moreNums);let shoe = { color: 'red', size: 10 };let newShoe = { ...shoe, brand: 'Nike', size: 12 };
console.log(newShoe);
newShoe.color = 'black';
console.log(newShoe);

console.log(shoe);

//let arr = ['one', 'two', 'three'];let [first] = arr;
console.log(first);

//let me = {name: 'Ian',instruments: ['bass', 'synth', 'guitar'],siblings: {brothers: ['Alistair'],sisters: ['Meghan']}};let {
    name,instruments: musical_instruments,siblings: { sisters }} = me;

console.log(name);
console.log(musical_instruments);
console.log(sisters);

//function charCount(inputString) {let res = inputString.split('').reduce(function (accum, el) {if (el in accum) {
            accum[el] = accum[el] + 1;} else {
            accum[el] = 1;}return accum;}, {});return res;}

console.log(charCount('aaabbbeebbcdkjfalksdfjlkasdfasdfiiidkkdingds'));

//var a = 'a';

//let b = 'b';

//const c = 'c';

//// function and block scope in this examplefunction run() {var foo = 'Foo';let bar = 'Bar';

    console.log(foo, bar);{
        console.log(foo);let baz = 'Bazz';
        console.log(baz);}

    console.log(baz); // ReferenceError}run();

//function run() {
    console.log(foo); // undefinedvar foo = 'Foo';
    console.log(foo); // Foo}run();

//// global scopefunction func1(arg1) {// func1 scopereturn function func2(arg2) {// func2 scopereturn function func3(arg3) {// func3 scope

            console.log(arg1, arg2, arg3);};};}

//const adder = (arg1) => {return (arg2) => {return arg1 + arg2;};};const func2 = adder(2);const result = func2(2);
console.log(result); // => 4;

//const returnValue = (val) => val;

//const returnValue = (val) => {return val;};

//function fDAdder(arr) {
    console.log(this);return arr.reduce((acc, ele) => {return acc + ele;});}fDAdder([1, 2, 4, 6]);

//const adder = (arr) => {
    console.log(this);
    arr.reduce((acc, ele) => (sum += ele));};adder([1, 2, 4, 6]);

//const pokemon = {firstname: 'Pika',lastname: 'Chu',getPokeName: function () {const fullname = `${this.firstname} ${this.lastname}`;return fullname;}};

console.log(pokemon.getPokeName());

//const pokemon = {firstname: 'Pika',lastname: 'Chu',getPokeName: function () {const fullname = `${this.firstname} ${this.lastname}`;return fullname;}};const logPokemon = pokemon.getPokename.bind(pokemon);logPokemon('sushi', 'algorithms'); // Pika Chu loves sushi and algorithms

//function Person(name) {// this.name = name;// let that = this;setTimeout(function () {// console.log(this); // => Window// console.log(that); // => [Function] => Person// this.sayName(); // => no method error
        that.sayName();}, 1000);}Person.prototype.sayName = function () {
    console.log(this.name);};const jane = new Person('Jane');