Eloquent JavaScript

[Carmer]

In a comment on this issue, state what you found to be a valuable thing you read from Eloquent JavaScript.

Please use this github issue as a forum to ask and answer questions you came across in the from the reading.

[jesse-spevack]

Eloquent JavaScript Chapter 3: Functions

• Functions are adding vocabulary to our code.
• Variables in a function, are local to the function.
• Functions can be created inside other functions, producing several degrees of locality, which is known as lexical scoping.
• let keyword creates a variable scoped to its container block, as opposed to var, which is scoped to its container function.
• It is a bad idea to define a function in a conditional block because different platforms in different browsers do different things in that situation.
• If you pass too many arguments to a function, the extra ones are ignored. If you pass too few, the missing parameters simply get assigned the value undefined.
• Closure analogy: A good mental model is to think of the function keyword as "freezing" the code in its body and wrapping it into a package (the function value). So when you read return function (...) {...}, think of it as returning a handle to a piece of computation, frozen for later use.
• Running through a simple loop is a lot cheaper than calling a function multiple times.
• How difficult it is to find a good name for a function is a good indication of how clear a concept it is that you're trying to wrap.

  Eloquent JavaScript Chapter 5: Higher-Order Functions

• Abstractions hide details and give us the ability to talk about problems at a higher (or more abstract) level.
• Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher-order functions.
• Examples of higher order functions are reduce, map, filter, forEach;
• Abstractions add layers between the raw things the computer is doing and the concepts we are working with and thus cause the machine to perform more work.

  Eloquent JavaScript Chapter 6: The Secret Life of Objects

• Almost all objects have a prototype, which is used as a fallback source of properties.
• In JavaScript, calling a function with the new keyword in front of it causes it to be treated as a constructor. An object created with new is an instance of its constructor.
• Polymorphic code can work with values of different shapes, as long as they support the interface it expects.
• Inheritance is a fundamental part of the object-oriented tradition, alongside encapsulation and polymorphism.

  Speaking JavaScript Chapter 17: Objects and Inheritance

• Objects are maps / dictionaries from strings to values.
• If a property does not exist, setting it automatically creates it. If a property already exists, setting it changes its value.
• Prototypes are great for sharing data between objects.
• An own property of an object is stored directly in that object whereas an inherited property is stored in one of its prototypes.
• Properties have attributes: value, writeable, get, set, enumerable, and configurable.
• Protecting an object with seal or freeze is said to be shallow: it affects the own properties, but ot the values of those properties.
• A constructor function helps with producing objects that are similar in some way.
• Do not put data in prototype properties, but there are a few exceptions to this.

  JavaScript Garden

• Everything in JavaScript acts like an boject except null and undefined
• The only way to remove a property from an object is to use delete operator.
• Object properties can be both notated as plain characters and strings.
• Lookup time for properties that are high up on the prototype chain can have negative impact on performance.
• With closures, scopes always keep access to the outer scope in which they were defined.
• In order to create a new object, one should rather use a factory and construct a new object inside of that factory.
• The user of global variables is considered bad practice. Any use of them indicates badly written code that is prone to errors and hard to maintain.
• Literals are preferred to the Array constructore because they are shorter, have a clearer syntax, and increase code readability.
• It is recommended to only use the strict equality operator.
• In order to check the type of an object, it is recommended to use Object.prototype.toString. Avoid using Typeof.
• The instanceof operator should only be used when dealing with custom made objects that originate from the same JavaScript context.
• eval should never be used. setTimeout and setInterval can do the same thing without the security risks.
• It is recommended to never omit semicolons.
• It is recommended that braces be kept on the same line as their corresponding statements and never omit them for single line if / else statements.
• A string should never be used as the parameter of setTimeout or setInterval.

[susiirwin]

I think the biggest point of value is to be consistent with good practices. Each of the readings generally have the same principles on them and that really drives home the point in writing clean code. Keep things readable. Keep things to the SRP. IN EJ specifically, I was really interested in the chapter on Objects - specifically when talking about this and prototypes - since i had to use these in the exercisms. seeing that by using prototype affords us a few out of the box methods is extremely helpful.

[NateAnderson1780]

Eloquent Javascript, Chapter 3 - Functions

• Bread and butter of JS programming

• Defining new vocabulary

• Has parameters and body

• Return statement explicitly

• You can call a function before defining it

• Ignores other arguments if given more than parameters define, if less than they define, the argument will come back as undefined

• Closure = being able to wrap a specific instance of local variables in an enclosing function

• Speed vs Elegance

• Pure function is a specific kind of value producing function that not only has no side effects but also doesn't rely on side effects from other code.

Eloquent Javascript, Chapter 5 - Higher-Order Functions

• Abstractions hide details and give us the ability to talk about problems at a higher (or more abstract) level.

• Higher order functions are functions that operate on other functions, either by taking them as arguments or returning them. They allow us to abstract over actions, not just values.

• With apply method, you pass it an array of arguments, and it will call the function with those arguments.

• Filter function helps you to build up a new array with only the elements passing the test, rather than deleting elements from the existing array.

• Higher order functions really come in handy when you need to compose functions.

• Bind method creates a new function that will call the original function but with some of the arguments already fixed.

Eloquent Javascript, Chapter 6 - Secret Life of Objects

• Methods are simply properties that hold function values.

• "this" points to object it was called on.

• apply, bind, and call can be passed a specific "this" value.

• Almost all objects have a prototype, which is another object used as a fallback source of properties.

• An object created with new is said to be an instance of it's contructor

• Constructors (and all functions) get a property called prototype which by default holds a plain, empty object that derives from Object.prototype.

• Calling .toString on an array gives a similar effect to .join(",")

• You can pass null to create an object with no prototype which is useful.

Eloquent Javascript, Chapter 17 - Objects & Inheritance

• Several layers of OOP in Javascript: Layer 1 Object-orientation with single objects Layer 2 Prototype chains of objects Layer 3 Constructors as factories for instances Layer 4 Subclassing

• Accessors are getters and setters

• This chapter was a lot of information to get through and went into detail about the different OOP layers in Javascript. A lot of the information was a little hard to get through because I feel like I need to put some of these principles into practice. I feel like once I do so the ability to grasp some of the concepts will be easier but a lot is still unclear to me at this time.

Javascript Garden

• Everything in Javascript acts like an object, with the only two exceptions being null and undefined.

• Common misconception is that number literals cannot be used as objects.

• Can also be used as hashmaps.

• Properties of objects can be accessed in two ways: either by dot notation or by square bracket notation.

• Only way to remove a property from an object is by the delete operator

• Only widely used language that uses prototypical inheritance.

[bheim6]

Eloquent JS Ch. 3: Functions

• Lexical Scoping - all variables from blocks around a functions definitions are visible ~ those that are in the functions body that encloses it as well as those at the top level of the program.

• In JS, functions are the only thing that can create a new scope. Free-standing blocks can be used but they do not allow for re-naming variables that have already been defined. These free-standing blocks are really only useful to group the body of an if statement or a loop.

• JS doesn't care how many arguments are passed into a function, but if you pass too many, the extras get ignored, too few, and the missing parameters get re-assigned as undefined.

Eloquent JS Ch. 5: Higher-Order Functions

• Abstractions hide details and give us the ability to talk about problems at a higher (or more abstract) level, for example: using sum instead of a loop with a counter. This does however require the programmer to have some knowledge and experience with these abstractions in order to take advantage of them.

• Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher ­order functions. Higher order functions allow programmers to abstract over actions, as well as values. You can have functions that create new functions, change other functions, and provide types of flow control.

Eloquent JS Ch. 6: The secret life of objects

• Prototypes are another object that is used as a fallback source of properties. When an object gets a request for a property that it does not explicitly have, its prototype will be searched for that property, then the prototypes prototype, and so on. (ex: Object.prototype, Function.prototype, Array.prototype)

• Getter / Setter methods allow us to specify a function to be run when a certain property is read or written; often the purpose is to restrict certain properties to certain limits or parameters. These can also be added to existing objects.

• Some very useful concepts of objects

  • Encapsulation - specify an interface for an object and tell everybody that they are supposed to talk to your object only through that interface. The rest of the details that make up your object are now encapsulated, hidden behind the interface.
  • Polymorphism - having different objects expose the same interface and then writing code that works on any object with the interface is called polymorphism.
  • Inheritance / Prototypes - very useful as a hidden hierarchical library tree for object properties, but can cause problems by tying objects together, and thus "tangling" code. Encapsulation and polymorphism, however, serve to separate code.

Speaking JS Ch. 17: Objects and Inheritance

• I thought this was a great overview from chapter 1: "Roughly, all objects in JavaScript are maps (dictionaries) from strings to values. A (key, value) entry in an object is called a property. The key of a property is always a text string. The value of a property can be any JavaScript value, including a function. Methods are properties whose values are functions."

• proto ( proto ) is a special property for getting and setting the prototype of an object, granting direct access to [[Prototype]].

• There are three levels of protecting an object, listed from weakest to strongest they are: Preventing extensions, Sealing, and Freezing.

• To determine object properties, iterate over property keys and use a for - in loop with hasOwnProperty().

• Constructors are similar to Classes in other languages, and are used to create objects of similar type and property.

• Privileged methods - functions created in the constructor added as instance methods. Meaning that, on one hand, they can access private data; on the other hand, they are public and therefore seen by prototype methods. They serve as mediators between private data and the public (including prototype methods).

JavaScript Garden

• I found this to be an awesome little cliff notes version of the other readings. With a ton of code snippets and concise explanations, I have a feeling I will be referring to this alot more than the other readings, especially for things like quick syntax confirmation.

• I also like how it went over Array iteration, array properties, and the array constructor, as well as numerous other core JS properties, in a nice reference format.

[danbroadbent]

Chapter 3 (Eloquent): Functions

• How scope works in JS with, scope for local variables is specific to the function vs. global scope available everywhere
• What local variables are available when nesting functions, local variables above the function are available
• Recognizing functions that return a variable vs. functions that have side effects
• How arguments work in JS. Good to know you can have too many or too few and it won't tell you, it either ignores extras or assigns undefined

Chapter 5 (Eloquent): Higher Order Functions

• Passing functions to functions is an incredibly powerful tool in JS.
• It is called higher-order functions when one function takes another as an argument or returns a function
• This provides the building blocks to do more advanced things like transforming, filtering and reducing arrays. Be careful when abstracting things too much you can lose sight of what is happening and create inefficient code

Chapter 6: (Eloquent) The Secret Life of Objects

• JS has objects through the use of prototypes
• A prototype is another object that is used as a fallback source of properties
• A constructor is a more convenient way to create instances of a prototype
• Inheritance can be used to build slightly different data types based on existing ones without starting from scratch

Chapter 17: Objects and Inheritance (Speaking JavaScript)

• There are several layers of object oriented programing in JS so you can learn incrementally as each layer depends on prior ones
• The base layer is a object composed of properties (key value pairs)
• Object literals are objects you just create yourself, no class needed
• Delete operator lets you completely remove a property (key & value) from an object
• Every object can have another object as it's prototype via internal property [[Prototype]]
• When an object inherits a method, this refers to object it was called on
• If an object has it's own property of the same name as one it inherited, the inherited property will be overwritten
• Setting and deleting properties only affect object itself and ignores inheritance
• There are three levels of protecting properties: preventing extensions, sealing, and freezing
• Constructors act as classes
• When creating objects from a constructor, data is instance-specific and behavior is shared by all instances
• A function becomes a constructor when it is invoked with 'new'
• There can be inheritance between constructors

JavaScript Garden

• Functions are first class objects and can be passed around like any other value
• There are 5 different ways 'this' can be bound, but it can be explicitly set
• Closures keep access to the scope in which they were defined
• The arguments object is not an array
• Factories can be used instead of constructors and don't require the word 'new'
• Not using var will set the variable in the global scope, don't do it
• Var statements and function declarations get hoisted to the top of their enclosing scope
• Don't use 'for in' loops on arrays
• The == operator uses weak typing meaning they are coerced before they are compared e.g. 2 == '2' is true
• Use === for strict equality
• Javascript will automatically insert semicolons, but don't omit them because you don't want the parser to decide for you where they go

[rdavid1099]

Chapter 3 (Eloquent): Functions This chapter was extremely valuable to me. It wasn't until I understood the power and structure of functions that JavaScript actually began to click in my mind. Learning that I could save functions to variables and call those variables similarly to Ruby methods was awesome. Weird nuances with functions that I learned is the fact that functions must have () to take arguments, even if the function doesn't take any arguments. Also, the fact that functions MUST SPECIFICALLY return a value is pretty interesting. I caught myself often forgetting to "return" things while working through those exercises. The nice thing about JavaScript functions, they are a lot more easy-going than other languages, such as C#, which makes you declare the type of value the function is returning. That's great.

Chapter 5 (Eloquent): Higher Order Functions Right off the bat, this chapter really spoke to me, saying that complexity is the death of an efficient program. I think I have a tendency to write uglier and more complex programs when working with lower level languages. For some reason, the curly braces and semicolons make it naturally look ugly and make me think I have a pass on writing clean, clear code. This chapter proved why my tendencies are not correct. This chapter easily has some of the coolest things I've learned so far about JavaScript. Learning about using and creating higher-order functions and using functions as arguments for other functions is amazing. These concepts hit very close to what I learned while working through Lololodash. It was extremely confusing to see functions within the parameters at first, but after realizing the order of operations, it became clear how powerful higher-order functions can be when writing complex problems. It is important, however, to remember to keep things as simple as possible and not create complex functions for complex-sake. Complexity can make code difficult for others to work on and may hurt efficiency and run-time.

Chapter 6: (Eloquent) The Secret Life of Objects This chapter was a great read. I feel like one of the most difficult things to learn about JavaScript after learning Ruby is JS Objects. While we relate them to hashes, they are not exactly the same as the hashes we know and love. I noticed this while comparing my exercisms work with others. More advanced coders could use and manipulate JS objects to do a whole lot more than just store and recall values. This chapter showed several awesome concepts including using object keys to refer to functions. This use looks a lot like class methods... but under the hood, it's working completely different than Ruby. I still need to do a lot more research and messing around to fully grasp the concept of prototypes. Reading about it felt similar to when Jeff initially showed us the abstract depth of Ruby classes and prime classes. While in theory it makes a bit of sense, I am not fully understanding what is happening in the background. It's interesting, actually, considering that while working through Exercisms, I was manipulating the prototype and didn't even realize it. Overall, this chapter showed me just how much was happening in the background... and how important it is to understand the ins and outs of objects to write truly magnificent and efficient programs. I am definitely going to re-read this chapter.

Chapter 17: Objects and Inheritance (Speaking JavaScript) Diving deeper into the JavaScript pool... The depth and power of JS objects continues to baffle me. While I feel like I was holding on to what was happening in this chapter, it was easy to get tripped up and confused. The more I learn about dot operators and how objects can hold functions, the more I realize how you can manipulate JavaScript to do similar things as Ruby. At the same time, however, objects can be as simple as hashes, using functions such as keys, you can navigate the object in the same way a Ruby hash can be navigated. This chapter was very dense, with a lot of interesting information, but, to be honest, the whole time I was reading I just felt like I needed to apply the knowledge to fully understand it and learn it. It's definitely beneficial to at least be exposed to the concepts, and I will be saving a link to this chapter for future reference.

JavaScript Garden Another great resource for future reference. I really think this reading should have been the first thing we did for prework before jumping into the NodeSchool. It's a clear and well-written piece of all the weird nuances JavaScript has. There is little to no assumed back knowledge, and knowing what we know about Ruby and other programming languages, I thought it did a good job pointing out the major differences and how to avoid falling into the pitfalls. I honestly learned a whole lot more reading through this documentation and am excited to apply my new skills. The way JS Garden described prototypes really helped my understanding. I am learning the differences between Ruby and JS and inheritance. While Ruby directly inherits, JS uses prototypes to emulate the inheritance feeling. Learning how to chain prototypes together makes a lot of sense, and I really feel that concept starting to click. Learning more about function declarations was very helpful. I have been going back and forth with whether I should declare a function similar to Ruby or declare a variable which equals a function. I am still struggling to understand the full scope of 'this' and how it is different than 'self' in Ruby. I think the idea of the global scope is throwing me off. Arrays in JavaScript are real interesting. I don't know what it is, but I'm really kind of liking the lack of enumerables and the custom ways you can work your way through arrays. Overall, this was a great read, and I can't wait to refer back to it as I'm writing some awesome JavaScript programs.

[JeanJoeris]

chap 3 - functions I appreciated the clarification on how js handles scoping, especially that each function creates its own scope. I like the let {} block, as the ability to define mine own scope when needed is useful. I also didn't realize the difference between var foo = function()... and function foo() = .... I'm not sure how the function syntax moves the function to the top when javascript is interpreted. As I've been learning Elixir and functional programming over the break, it is nice that javascript has closures and first class functions. The very loose attitude about arrity of functions is frustrating however. I'm also reluctant to use closures in a language where the variables passed into the closure can be changed outside the closure (boo mutability!)

chap 5 - higher order functions I think it is very useful to see that patterns we are used to as enumerables in Ruby are relatively straight-forward to build. They are similar to an explicit for-loop, but designed with a general purpose (i.e. map applies a function to an array). I feel like I got more out of this because I had recently built these functions (map, reduce, etc.) with recursion in a functional programming language. As many problems as I have with javascript, the ability to easily pass functions (named and anonymous) as arguments is very useful

chap 6 - the secret life of objects The most useful thing about this article was learning about prototypes and the javascript inheritance model. Prototypes seem very similar to inheritance, the Object object in Ruby (and the idea of eigenclasses), but they are used in ways similar to a class definition. Constructors seem to be how javascript handles the idea of class, particular given the instanceOf syntax. The ideas of polymorphism and encapsulation seem the same as Ruby.

chap 17 - objects and inheritance There is a lot going on in this reading. While a lot of the material has been covered in the previous chapters, this describes the same ideas in a much denser way. It was nice to get explicit confirmation of my understanding of constructors as analogous to classes. The biggest take away for me wasn't a particular thing I learned but that (essentially) everything I already know has equivalents in javascript, even if they are much uglier. Also, spending time with a pure functional language over break (Elixir) I find it quite frustrating that even Object.freeze(obj) leaves values somewhat mutable.

javascript garden - This is awesome! A website that explicit acknowledges the weirdness of javascript and gives a frank discussion of workarounds and common frustrations. I really appreciated the clarification that prototype is a different model of inheritance. Prototyping felt similar to inheritance but I wasn't sure what was different about it. It was also super helpful that they explicitly layout 5 different cases for the meaning of this, which helped clear up my confusion regarding this. I also really appreciated the discussion of automatically inserting semicolons. I had heard 'javascript doesn't require semicolons' said somewhat jokingly, and now I understand

[rsbarbo]

Chapter # 3 - Functions

• Can be assigned as a value for a variable.
• it can be passed as an argument to another function.
• It can be returned as a value from another function.
• Inside of every function you have access to an object called argument which is an array-like object that contains all the arguments passed into the function.

Chapter # 5 - Higher-Order Functions

• The bind method, which all functions have, creates a new function that will call the original function but with some of the arguments already fixed.
• Arrays provide a number of useful higher-order methods—forEach to do something with each element in an array, filter to build a new array with some elements filtered out, map to build a new array where each element has been put through a function, and reduce to combine all an array’s elements into a single value.

Chapter # 6 - The Secret Life of Objects

• The biggest take away were prototypes and constructors and the approach to JavaScript to it.
• Prototypes are somehow similar to inheritance in Ruby and can be used in similarly to a class definition.
• Constructors are in some ways the way JS seemed to handle classes and its inheritance.

Chapter # 17 - objects and inheritance It seemed to me that this chapter was added to our read in order to further our knowledge in functions, objects, constructors, and so on. The biggest take away here is that I can pretty much apply all the knowledge learned in Ruby in JavaScript, the key is understanding how similar approaches are applied differently in JS.

JavaScript Garden

It is necessary to understand the prototypal inheritance model before being able to write complex code that makes use of it. Also, it is very important to be aware of the length of the prototype chains in the code and break them up when necessary to avoid possible slow down and performance issues. The hasOwnProperty is the most reliable method to check whether a property exists within an object or not. It's often recommended that hasOwnProperty is used in many cases when iterating over object properties. Although omitting the new keyword may result in some bugs, it's certainly not ideal to drop the use of prototypes altogether. In the end, we should be able to understand which solution is better suited for the needs of our application. In short, The JS Garden is an amazing resource that should be saved for future reference and understanding.

[j-sm-n]

Eloquent JavaScript Chapter 3: Functions

• Variables in a function are local to the function only.
• Functions add vocabulary to our programs.
• It is a bad idea to define a function in a conditional block because different platforms in different browsers do different things in that situation.
• Functions can be created inside other functions--producing several degrees of locality--which is known as lexical scoping.
• let keyword creates a variable scoped to its container block, as opposed to var, which is scoped to its container function.
• If you pass too many arguments to a function, the extra ones are ignored. If you pass too few, the missing parameters simply get assigned the value undefined.
• Looping is more efficient than calling a function multiple times.

Eloquent JavaScript Chapter 5: Higher-Order Functions

• Abstractions hide details and give us the ability to talk about problems at a higher level.
• Functions that operate on other functions are called higher-order functions.
  • Examples of higher order functions are reduce();, map();, filter();, forEach();

Eloquent JavaScript Chapter 6: The Secret Life of Objects

• Inheritance is a fundamental part of the object-oriented tradition, alongside encapsulation and polymorphism.
• Nearly all objects have a prototype, which is used as a fallback source of properties.
• In JS, calling a function with the new keyword in front of it causes it to be treated as a constructor. An object created with new is an instance of its constructor.
• Polymorphic code can work with values of different shapes, as long as they support the interface it expects.

Speaking JavaScript Chapter 17: Objects and Inheritance

• If a property does not exist, setting it automatically creates it. If a property already exists, setting it changes its value. (Which is more efficient?)
• Prototypes are great for sharing data between objects.
• An own property of an object is stored directly in that object whereas an inherited property is stored in one of its prototypes.
• Objects are maps/dictionaries from strings to values.
• Properties have attributes: value, writeable, get, set, enumerable, and configurable.
• A constructor function helps with producing objects that are similar in some way.

JavaScript Garden

• The only way to remove a property from an object is to use the delete operator.
• Object properties can be both characters and strings.
• Lookup time for properties that are high up on the prototype chain can have negative impact on performance.
• Everything in JavaScript acts like an object except null and undefined.
• With closures, scopes always keep access to the outer scope in which they were defined.
• The use of global variables is considered bad practice. Any use of them indicates badly written code that is prone to errors and hard to maintain.
• Literals are preferred to the Array constructor because they are shorter, have a clearer syntax, and increase code readability.
• It is recommended to only use the strict equality operator.
• The instanceOf operator should only be used when dealing with custom made objects that originate from the same JS context.
• Avoid using Typeof. In order to check the type of an object, it is recommended to use Object.prototype.toString.
• eval should never be used. setTimeout and setInterval can do the same thing without the security risks.
• It is recommended to never omit semicolons.
• It is recommended that braces be kept on the same line as their corresponding statements.
• A string should never be used as the parameter of setTimeout or setInterval.

[ghost]

Eloquent JavaScript Ch.3

• Using var makes an entirely new variable local to that function (unless it is global) while simply calling the variable name can allow you to reassign a new value to that previously declared variable. This allows you to reuse variable names.

• Functions are the only thing which create new scopes. Functions can be passed as arguments. Variables that hold functions are just regular variables that can have their values reassigned.

• Function declarations are an alternative to assigning the function to a variable. Function declarations aren't part of the regular top to bottom flow control in JS. You should only use function declarations in the outermost block.

• Functions can take optional arguments which seem to be like default arguments in Ruby.

• Closure allows you to reference a specific instance of a local variable inside an enclosing function.

Eloquent JavaScript Ch.5

• forEach is useful in place of manually iterating with a for loop.

• Functions can change other functions and define new types of control flow.

• You can pass arrays of arguments to functions using the apply method.

• You can pass a function as an argument of another function.

• The filter function creates a new array with only the items which fit the filter's requirements, and the filter itself is just implemented by building your own custom function.

• Binding creates a new function which fixes arguments when calling an already established function.

Eloquent JavaScript Ch.6

This chapter was very dense, and I will definitely need to re-read it. I'm still unclear about the nature of prototypes, although I'm inclined to analogize it to inheritance in Ruby (really not sure about that, though).

• Object.create allows you to create an object with a specific prototype.

• Using constructors allows you to create objects that derive from a shared prototype. You create this new instance using "new."

• Every instance of a constructor has an empty object which comes from Object.prototype, and this quality allows you to add methods to the constructor which can then be called upon instances of the constructor.

• Getters and setters allow you to include properties that are not methods (I think this is sort of like the attributes of an object in Ruby but am unsure). This will just run a function when a property is read (get) or written (set).

[kctrlv]

Functions

Defining a new vocabulary word to wrap a piece of a program in. Purpose is to reduce repetition and structure programs. Purpose is to reduce repetition and structure programs.

Definition

var addOne = function(x) {
  return x + 1;
};

console.log(addOne(2));
=> 3

• Expression function
• Can have 0 or more parameters
• Body must be wrapped in braces
• May return a value or not

Scoping

• Parameters and variables created inside function are local to the function.

Possible to change global vars inside function.

var x = 'one'
var f1 = function() {
  var x = 'two'
}
f1();
// console.log(x) => 1

var f2 = function() {
  x = 'two'
}
f2();
// console.log(x) => 2

• Scopes can be nested

• Functions can be values

Shorter Declaration

function addOne(x) {
  return x + 1;
}

Function Declaration can be below the code that uses it

Arguments

• Extra arguments are ignored
• Can use this to make functions have optional arguments

Recursive

• Functions can call themselves

A useful principle is not to add cleverness unless you are absolutely sure you’re going to need it. It can be tempting to write general “frameworks” for every little bit of functionality you come across. Resist that urge. You won’t get any real work done, and you’ll end up writing a lot of code that no one will ever use.

[alishersadikov]

Eloquent Javascript Chapter 3: Functions

1) In other programming languages, a block of code between the braces produces a new local environment. But in Javascript, functions are the only things that create a new scope.

2) Function variables usually simply act as names for a specific piece of the program.

3) Optional Arguments: JavaScript is extremely broad-minded about the number of arguments you pass to a function. If passed too many, the extra ones are ignored. If passed too few, the missing ones will become 'undefined'. In this case, we can set the optional argument to a default value if it is not passed in.

4) A good mental model is to think of the function keyword as 'freezing' the code in its body and wrapping it into a package (the function value).

5) Assuming number is an integer: var numberString = String(number); will convert it to a string, like to_s in Ruby.

6) I thought declaring functions in the following two ways was equivalent:

    var f = function(a) { 
      console.log(a + 2); 
    };

    function g(a, b) { 
      return a * b * 3.5; 
    }

But apparently the former creates a function value f, hence the semicolon at the end. And the latter declares g to be a function.

Chapter 5: Higher-Order Functions

1) Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher order functions. For example, you can have functions that create new functions, functions that change other functions, functions that provide new types of control flow.

2) JSON.stringify() - takes a JavaScript value and returns JSON-encoded string. JSON.parse() - vice versa.

3) The function is 'pure', if it does not modify/mutate the data(e.g.,array) it is given.

4) Some built-in methods for arrays in JavaScript: forEach, filter, map, reduce, every, some (need more exercises on these).

5) Although it is possible to write elegant code through abstractions, abstractions add layers between input and output which causes the computer to do more work.

6) Apply: functions have an 'apply' method that can be used to call them with an array specifying their arguments.

7) Binding: the bind method, which all functions have, creates a new function that will call the original function but with some of the arguments already fixed.

Chapter 6: The Secret Life of Objects

1) Methods are simply properties that hold function values.

2) 'this': object.method() { this }, 'this' is the object itself, like self.

3) Prototype: In addition to their set of properties, almost all objects also have a prototype. A prototype is another object that is used as a fallback source of properties. When an object gets a request for a for a property that it does not have, its prototype will be searched for the property, the the prototype's prototype, and so on. Object.prototype is the entity behind almost all objects, their great ancestral prototype.

4) Constructors: a more common way to create objects that derive from some shared prototype. In JavaScript, calling a function with the 'new' keyword in front of causes it to be treated as a constructor, so the object created with 'new' is an instance of the constructor. It is a convention to capitalize the names of constructors.

5) Enumberable vs. nonenumerable properties: all properties that we create by simply assigning to them are enumerable. The standard properties in Object.prototype are all nonenumerable and therefore do not show up in for/in loop, for instance.

6) Polymorphism: when a piece of code is written to work with objects that have a certain interface, any kind of object that happens to support this interface can be plugged into the code, and it will just work. Polymorphic code can work with values of different shapes, as long as they support the interface it expects.

7) Using a variable name starting with an '_' or consisting entirely entirely of a single underscore is a way to to indicate that this argument is not going to be used.

Speaking JavaScript Chapter 3: The Nature of JavaScript JavaScript is:

• dynamic;
• dynamically typed;
• both functional and object-oriented;
• a language that fails silently;
• deployed as source code;
• part of the web platform.

Chapter 17: Objects and Inheritance

Layers of OOP in JS:

1. Object-orientation with single objects;
2. Prototype chains of objects;
3. Constructors as factories for instances, similar to classes in other languages;

4. Subclassing - creating new constuctors by inheriting from existing ones.

   Layer 1: Single Objects

   • All objects in JS are maps from strings to values.
   • A key/value entry in an object is called property.
   • The key of a property is a text string.
   • The value of a property can be any JS value, including a function.
   • Methods are properties whose values are functions.

   Three kinds of properties:

   1. Properties (or named data properties): normal properties in an object - mappings from keys to values; methods; most common kind.
   2. Accessors (or named accessor properties): getter and setter properties; sort of virtual properties; allow to compute the values of properties.
   3. Internal properties: exist in ECMAScript lang specification; not directly accessible; accessible via Object.getPrototypeOf().

   Object Literals

   • allow you to directly create plain objects;

     var jane = {
     name: 'Jane',
     describe: function () {
       return 'Person named '+this.name; 
     },  
     };

   Based on the above example:

   • jane.name => 'Jane' // dot operator can only access properties whose keys are identifiers
   • jane.describe => [Function]
   • jane.descirbe() => 'Person named Jane' // calls that method
   • jane.name = 'John'; // sets property name
   • delete jane.name // deletes the property(the whole key-value pair)

   Delete only affects direct, noninherited properties, without touching the prototypes.

   Bracket operator coerces its interior to string:

   var obj = { '6': 'bar' };
   > obj[3+3]  // key: the string '6'
   'bar'

   An empty object literal is almost always a better choice than the constructor:

   var obj = new Object(); // avoid
   var obj = {}; // prefer

   Layer 2: The Prototype Relationship Between Objects

   • this relationship is about inheritance: every object can have another object as its prototype.

   The following code creates objects jane and tarzan that share the prototype PersonProto:

   var PersonProto = {
     describe: function () {
         return 'Person named '+this.name;
     }
   };
   var jane = {
     name: 'Jane'
   };
   var tarzan = {
     name: 'Tarzan'
   };

   • Sealing: prevents extensions and makes all properties 'unconfigurable';
   • Freezing: makes all properties non-writable and seals obj.

   Layer 3: Constructors - Factories for Instances

   • A constructor function or constructor helps with producing objects that are similar in some way.
   • 'use strict'; in the constructor allows you to get exception if something goes wrong, instead of failing silently.

   Layer 4: Inheritance Between Constructors

   • Yes, such inheritance is possible.

[bradgreen3]

Chapter 3 (Speaking): The Nature of JavaScript

• Both functional and object-oriented
• Doesn't throw very helpful errors
• Essential part of web platform, but also used in nonbrowser settings (e.g. Node.js)
• Quirks
  • Does not have block scope, therefore a variable within a block (e.g. for loop) IS available from outside
  • No built-in modules
  • JS engines have fixes for many quirks
• Elegant parts
  • First-class functions (have state, can be altered, etc)
  • Closures (variables within { } are available to each other regardless of when called)
  • Prototypes (e.g. make methods of one function inheritable by another)
  • Object literals {a: 'apple'}
  • Array literals [a,b,c,1,2,3]

Chapter 3 (Eloquent): Functions

• Variables created inside a function are local to the function, but you can access variables declared outside the function (global vars) from within the function
• Functions are the only things that create a new scope, you can have free-standing blocks
• function(future) {code} is a function declaration; it does not follow top-to-bottom flow of control
  • only use function declarations in the outer-most block; don't put one inside an if statement
• If you pass too many arguments to a function, the additional arguments are ignored. Too little, and they're assigned 'undefined'
• Closure = being able to reference a specific instance of local variables in an enclosing function
• Aim for functions with single responsibility

Chapter 5 (Eloquent): Higher Order Functions

• classic for loop is complex for (i=0, i<3, i++), a potentially better way is similar to Ruby's each: products.forEach(function(product, index)) {code would go here});
  • forEach == less code, fewer OBOEs
  • As in Ruby, map is destructive, forEach is not. map
• Higher-order functions are functions that operate on other functions (e.g. taking them as arguments)
  • allow us to abstract over actions, not just values
• JSON
  • all property names are wrapped in double quotes & only simple data types are allowed
  • JSON.stringify / JSON.parse
• filter builds a new array with some elements filtered out
• reduce combines all elements of an array into a single value

Chapter 6: (Eloquent) The Secret Life of Objects

• Methods of an object are function values
  • when a method is called on an object, this refers to the object called
  • call, apply, bind are ways to write common methods for multiple objects
  • addToThis.call(objectCalled, argumentOfFunction)
  • addToThis.apply(obj, arrayOfArguments)
  • bind is a way to combine an object and a function
• A prototype is another object that is used as a fallback source of properties for an object
• A constructor is a function that derives from some shared prototype. Distinguish with new
  • var blackRabbit = new Rabbit("black");
• Prototype-less objects var map = Object.create(null);
• Getters/setters run when a property is read or written
• Inheritance: there are no classes in JS, only objects. You can set an object's prototype to another object in order for it to inherit methods and attributes from the other object.

Chapter 17: Objects and Inheritance (Speaking JavaScript)

• key/value pair in an object == property
  • key always a string, value is any value, including a function
  • methods are properties whose values are functions
• Dot operator and method assignment are same as Ruby
  • .delete removes a property
• Bracket operator lets you compute the key of a property (e.g. obj['some' + 'Property'])
• In functions, this is always an implicit parameter whose value is always the global object (window for browsers)
  • In methods, this refers to the object on which the method has been invoked
• Functions are also objects, thus they have methods of their own
• Listing properties
  • Own property (stored directly on object) == Object.getOwnPropertyNames(obj)
  • All properties == use a loop
• Accessors
  • Getters are called when a property is read
  • Setters are called when a property is set to a value
• Enumerables
  • properties created by system == nonenumerable
  • properites create by user == enumerable
• 3 ways to protect an object
  • preventing extensions, sealing, freezing
• Constructors
  • similar to classes in Ruby
  • start with uppercase letters
  • create an instance with new
  • look up constructor of an object with: obj.constructor.name
  • var Car = function(maxSpeed, driver) { this.maxSpeed = maxSpeed this.driver = driver this.drive = function(speed,time){console.log(speed*time);}; }
  • to create an instance of ^ this constructor: var myCar = new Car(70, "Ninja Man");
  • to create a shared function amongst all objects, create a prototype on the original function (Car.prototype.nameofprotofunction)
• 3 ways to keep object data private
  • constructor environment
  • properties with marked keys (underscore dot)
  • properties with reified keys
• Descriptors
  • value, writable, enumerable, configurable

Javascript Garden

• square bracket accessor works for property names that'd otherwise lead to a syntax error
• monkey patching is a bad idea (modifying Object's prototypes or other built-in prototypes)
• use hasOwnProperty in for/in loop to avoid bringing in prototypes higher up the chain
• Occurences of this
  • global scope
  • test.foo(); (this == test)
  • new foo(); -- inside of constructor, this refers to the newly created object
  • In call or apply, the first argument == this
• arguments variable holds arguments passed to function (can pass arguments to another function)
• no good reason to use for in with an array (use classic for loop)
• JS will apply type coercion wherever possible, use strict equal operator to avoid issues
• parser will add semicolons if none exist, so make sure you put them where they need to be
• Never use a string as a parameter of setTimeout or setInterval

[bermannoah]

Chapter 3 (Speaking) The Nature of Javascript

• javascript is everywhere, it is sometimes gross, and sometimes isn't
• as per the spec there are no integers, but JS engines will often use them
• it fails silently! (especially bad when it comes to filetypes - it can expect a particular thing, get another, and run anyway)

Chapter 3 (Eloquent) Functions

• the function body must always be wrapped in braces (middle school is hell for JS functions)
• a function can have multiple parameters or none at all
• variables created inside of a function are local to that function. if you declare a variable outside of a function, it becomes a global. don't double-up on variable names.
• still: you can nest functions, and those can see variables defined within their parent function
• you can pass function values as an argument
• function declarations (declaring it outside of a variable) is possible - can also work outside of scope/order. DO NOT DO THIS IN AN IF BLOCK OR LOOP!
• JS will flat out ignore extra arguments. Can be used for optional args, but be careful
• a closure is when you can reference a particular local variable in an enclosing function
• don't worry about efficiency until you know for sure that the program is too slow. don't ignore it, but don't spend tons of time on it at first
• don't add cleverness until you're sure you need it

Chapter 5 (Eloquent) Higher-Order Functions

• abstraction has to become second nature
• forEach is a good thing
• functions that operate on other functions (taking or returning) are higher order functions
• you can do some crazy stuff with functions - change control flow, other functions, etc
• scoping scoping scoping
• filter is not a destructive method! makes a new array.
• ditto map
• for reduce, if your array contains at least one element, you don't need to pass a start arg
• function calls in JS are expensive compared to simple loop bodies
• keep track of how often a thing will run
• bind will create a new function that calls the original function but with some args fixed
• functions have apply method that can be used to call them with an array specifying their args

Chapter 6 (Eloquent) The Secret Life of Objects

• using the special variable this in a function's body will point to the object that it was called on
• call takes arguments normally, rather than as an array
• objects have prototypes -- fallback sources of properties
• you can create prototypes - containers for all the properties shared by the same type of objects
• calling a function with the new keyword in front of it causes it to be a constructor
• capitalize the names of constructors
• "When you add a property to an object, whether it is present in the prototype or not, the property is added to the object itself, which will henceforth have it as its own property"
• you can override those properties!
• you can set a function as a prototype's property
• "All properties that we create by simply assigning to them are enumerable"
• "It is possible to define our own nonenumerable properties by using the Object.defineProperty function"
• we can use Object.create to make things without prototypes
• "When a piece of code is written to work with objects that have a certain interface—in this case, a toString method—any kind of object that happens to support this interface can be plugged into the code, and it will just work." ---- Polymorphism!
• using a variable name starting with / consisting entirely of an underscore indicates that an arg is not used
• get or set for properties allows you to specify a function to run when the prop is read or written
• can also add it to, say, a prototype
• prototypes can have prototypes
• inheritance is slightly dodgy though
• instanceof does pretty much what you would expect

Chapter 17 (Speaking) Objects + Inheritance

• properties: named data properties, accessors, internal properties (indirectly accessed)
• object literals: plain objects, direct instances of Object. has name and describe.
• the dot operator lets you read a property's value, call methods
• assignment operator = does what you'd expect. if it doesn't exist, doing that creates it
• delete operator lets you delete a property. destroys key as well. returns false if it can't be deleted.
• you can use reserved words as property keys ???? also numbers and arbitrary strings obj['blahblah']
• bracket notation can be used to get properties because why the hell not, this is javascript, lets make everything a hash
• you can also, for some reason, do this: var obj = {'6': 'bar'}; obj[3+3], and it'll return 'bar'
• if you'd like you can convert arbitrary values to objects
• var obj = {}; is better than var obj = new Object();

• 
      func.call(jane, 'Tarzan');```
  - you need to call jane again or else it won't know how to pull sayHelloTo for func

[bfpepper]

We can't get away from Javascript. It's everywhere. You can declare a function by var <name>(){}; or function <name>(){}. Has similar scope as Ruby. Can accept any number of arguments. If there are more arguments they are simply ignored, if there are too few the remaining are "undefined." We can nest functions within each other. In this case the main function will "freeze" and get the return function(...){...} will then get its necessary info to execute and then the rest of the function will continue. JS loves SRP as much as Ruby. For arrays we still have access to functions like reduce, map, forEach, for, etc. this is analogous to self in Ruby. new <constructorName> == Class.new in Ruby.

[JStans12]

Chapter 3 (Speaking) The Nature of Javascript

• Javascript can be both functional and object oriented. Functions are first class. Objects have mutable state.
• In many cases, where you would learn features in another language, you use patterns and workaround in javascript.

Chapter 3 (Eloquent) Functions

• Some functions return a value and others create a side effect. Same thing in ruby, but I never thought about it in that way.
• Variables declared outside a function are global and are visible throughout the program. We have be told not to use global variables, but they can be useful for browser things in javascript (like to save the URL of a specific page in a chrome extension).
• Functions can be created inside of other functions.
• Each local scope can see all the local scopes that contain it.
• Javascript is broad-minded about the number of arguments you pass to a function. If you pass too many, the extras are ignored. If you pass to few, the missing become undefined.
• Being able to reference a specific instance of local variables is an enclosing function is called a closure.
• Recursion in javascript is about 10x slower than looping.

Chapter 5 (Eloquent) Higher-Order Functions

• Vocabulary of functions should correspond to the problem being solved. It's ok to have dependencies and more code, if it allows you to be more explicit.
• Abstraction hides details and allows us to talk about the problem on a higher level.
• forEach can take a predefined function as a parameter, or you can define your own.
• Functions that operate on other functions, either by taking them as arguments or returning them, are called higher order functions.
• Higher order functions allow us to abstract over actions, not just values.
• In javascript reduce is a way to compute a single value from a given array.
• Elegance often comes at the cost of efficiency. When processing an array, it can be expensive to break it down into each individual step for the purpose of readability.
• All functions have a bind method which will call the original function but with some of the arguments already fixed.

Chapter 6 (Eloquent) The Secret Life of Objects

• An object hides complexity and creates a simplified interface (methods) for the programmer. Interesting way to look at it.
• Special method .this refers to the object it was called on.
• A prototype is another object that is used as a fallback source for properties.
• Constructors provide a convenient way to create multiple objects from the same prototype.
• Prototype can be used to add more methods to objects.
• Object.create(null) creates a fresh new object with no properties.
• Getters and setters allow us to set and read the value of object properties.

Chapter 17 (Speaking) Objects + Inheritance

• There are 3 types of properties: properties, accessors and internal properties.
• Normal properties are storage locations for property values; accessors allow you to compute the values of properties.
• Internal properties are not directly accessible through javascript, but there might be a workaround.
• Can delete properties with delete obj.stuff
• The dot operator works to access fixed property keys, while the brackets allow you to access a property with an expression.
• .prototype is an example of an internal property of an object.
• Some engines use ```proto which allows for direct access.
• someKey in obj returns true if the object has someKey
• use for(var key in obj) to iterate over object keys.

[m-scherer]

Speaking Javascript

Chapter 3. The Nature of Javascript

• Javascript objects can be changed after they are created
• Object properties can hold different types
• Javascript is both functional and OO

Chapter 17. Objects and Inheritance

• Object properties are defined with key/value pairs
  • Key is always a string
  • Value is any JS value, including functions
• Kinds of properties
  • Normal
  • Accessors - getters/setters
  • Internal - not directly accessible via JS
• JS uses dot operators
  • return object properties Object.property
  • call methods Object.method()
  • set object properties Object.property = value will create if doesn't exist
• The delete operator completely removes the key/value pair delete Object.property
• Properties can be accessed, set, and deleted with bracket notation object['property']
• apply() doesn't know what object methods were called on so they need to be repeated ex: thing.apply(thing, ['stuff'])
• Prototyping inheritance pattern: data lives in the first object in the chain, while methods live in later objects
• Object.getOwnPropertyNames(obj) returns the keys of all own properties of obj
• Object.keys(obj) returns the keys of all enumerable own properties of obj
• Property Attributes
  • value
  • writable
  • get
  • set
  • enumerable
  • configurable
• Objects can be protected by preventing extensions, sealing, and freezing
• Functions become constructors only when the new operator is used

Eloquent Javascript

Chapter 3

• Functions can be created using regular variable definitions or through declaration

  var thing = function(){};
  function thing(){}

  • the first approach sets a variable value equal to the function
  • variables holding functions behave regular variables
  • variables holding functions can be assigned new values
• Like ruby, return statements ejects from the current function
• Unlike ruby, return is required to return a value from a function
• In the current version of Javascript, functions are the only thing that can create scope
  • Newer versions of Javascript will incorporate let to allow scoping inside blocks
• Function definitions are moved to the top of their scope, and accessible within that scope
• Javascript is flexible when defining arguments and passing parameters
  • Extra parameters will be ignored
  • Missing parameters will be considered "optional" and will be assigned undefined values
• Closures help reference specific instances of a function call
  • Closures have access to the variables held in the parent scope
  • The parent function's code is "frozen" in the variable value
  • Calling the variable executes the inner function with whatever parameters have been passed
• Recursive functions are more expensive than looping
  • Developers must make a decision between readability/elegance and speed
  • Don't worry about efficiency until the program is known to be too slow
• Functions can have return values or side effects
  • Pure functions return values and do not rely on side effects
  • Side effect are executed code without returning a value from the function ex: console.log()

Chapter 5

• Abstractions are useful when they are descriptive
  • Use a forEach instead of for when iterating over an array

    method.forEach(array, function(){...})

• apply passes an array as a parameter
• JSON is pronounced 'Jason'
  • Javascript Object Notation
  • Property names are surrounded by double quotes
  • Only simple expressions are allowed (no variables/functions/etc)
  • JSON.stringify = to JSON / JSON.parse = from JSON
• filter builds a new array (from an existing array) based on passing criteria
• map builds a new array (from an existing array) from an applied function's return values
• reduce operates the same as it does in ruby, reducing an array into a single values
• Efficiency is the tradeoff for composability
• Abstractions add layers between the code being run and the processes doing the work on the machine
• Think in terms of human scale - it most likely doesn't matter
• Inefficiencies
  • A loop within a loop will run N M times (Outer Inner)
• All functions have the bind method
  • creates a new function with this set to a value

Chapter 6

• Objects hide complexity, and provide an interface so that they can be used
• Methods are properties that hold function values
  • this refers to the object which called the method
• call operates like bind or apply and can be passed a this value
• Prototypes are ancestral objects that can be used as a source of properties
  • Prototypes inherit from one another
  • If a property does not exist on the object, JS will search up the ancestral prototype chain
• The keyword new creates a constructor from a function

  new thing()

  • Constructors have this variable bound to the fresh object
  • All functions get the prototype property - inherited from Object.prototype
  • Object.defineProperty()allows for the control of the property type
  • To bypass creating a prototype, pass null when using .create
• I got nothing out of polymorphism nor the table example in the book
  • Polymorphism allows child objects to change properties from their parent objects - this allows for shared behavior and gives subtypes the ability to build on from their parent
• Getter - method that gets the value of a property
• Setter - method that sets the value of a property
• instanceof() returns true/false -- can be used to show inheritance

[NZenitram]

Chapter 3. The Nature of JavaScript

• JS it object oriented

• JS is dynamically typed -- variables and objects can hold properties of any type

• It "fails silently" -- exception handling is an afterthought in JS

• It exists as part of the web platform

• JS inherits and was influenced by several programming languages

Chapter 3 (Eloquent): Functions

• A function defines new vocabulary for a program

• A function is an instruction that can used throughout the program or scoped to a specific part of the program

• You can nest the scope of a function within other functions

• Those functions can contain variables that are scoped with the specific function or globally

• Functions may also act as variables and store values

• A function may take optional arguments and will not throw an exception if it takes too many arguments

• A functions variables are recreated each time that function is called, allowing us to use the same data throughout the program

Chapter 5 (Eloquent): Higher Order Functions

• Name variables for their responsibility in the program

• Higher order functions allow the user to write functions that create functions

• Similar to ruby, the map method will transform the data set

• Reduce again allows us to compute a single value from a data set

• Nesting loops leads to inefficiency, loop n within m leads to a total run time of 'm' times 'n'

• Reduce and concat act as flatten in JS

• Efficiency over readability?

Chapter 6: (Eloquent) The Secret Life of Objects

• Methods are properties that hold function values

• A prototype is an object that is used as a fallback source for properties

• And object created with /new/ is an instance of its constructor

• Constructors carry the object prototype

• Prototype properties can interfere with explicit properties in some cases

• .toString is an example of polymorphism

• JS uses getters and setter to read and write specific properties

Chapter 17: Objects and Inheritance (Speaking JavaScript)

• JS has kinds of properties: properties, accessors, internal properties

• Dot (.) operator provides syntax for getting properties

• Assignment (=) operator provides syntax for setting properties

• delete lets you remove a property

• configurable true/false determines if a property can be deleted or edited

• In strict mode, this is always undefined

• You cannot delete/change inherited properties from the objects that inherited them

• A prefixed underscore can make data private

• Super call?

JavaScript Garden

• Properties can be accessed through the dot notation or square bracket notation

• 'This' exists in the global scope and 'this' inside of test.foo refers to test not 'foo'

• The only closure in JS is a function closure

• There is a difference between global and current scopes when defining and using variables

• Local variables only exist within function parameters

• Var and function declarations will be moved to the top of their enclosed scopes

• The use of global variables is considered bad practice

• A for in loop caches the value of the array with array.length

• Use [] to create arrays not 'new Array'

• Weak typing in JS coerces types to compare them

• === is the strict equality operator and will not coerce data types

• eval only executes in the local scope

• null and undefined are not the same expressions of 'nothing'

• JS parser will automatically insert semicolons to end expressions but 'guesses' where they should go -- never omit semicolons

[dshinzie-zz]

Chapter 3 (Eloquent): Functions JavaScript scopes variables depending on where they are created Prototypes are used to add methods and properties to objects Functions can be stored as values Being able to reference a specific instance of local variables in an enclosing function is called closure. Functions can be roughly divided into those that are called for their side effects and those that are called for their return value

Chapter 5 (Eloquent): Higher Order Functions Abstractions hide details and give us the ability to talk about problems at a higher (or more abstract) level. Functions that operate on other functions, either by taking them as arguments or by returning them, are called higher-order functions. The map method transforms an array by applying a function to all of its elements and building a new array from the returned values. Higher-order functions start to shine when you need to compose functions.

Chapter 6: (Eloquent) The Secret Life of Objects Methods are simply properties that hold function values. A prototype is another object that is used as a fallback source of properties. A more convenient way to create objects that derive from some shared prototype is to use a constructor. A prototype can be used at any time to add new properties and methods to all objects based on it. When a piece of code is written to work with objects that have a certain interface—in this case, a toString method—any kind of object that happens to support this interface can be plugged into the code, and it will just work. This technique is called polymorphism—though no actual shape-shifting is involved. Polymorphic code can work with values of different shapes, as long as they support the interface it expects.

Chapter 17: Objects and Inheritance (Speaking JavaScript) The value of a property can be any JavaScript value, including a function. Methods are properties whose values are functions. JavaScript’s object literals allow you to directly create plain objects (direct instances of Object)

[jbkimble]

Chapter 3: The Nature of Javascript

* Some quirks unique to javascript are: it has no integers, only floats. It has no built-in modules.
* Javascript is a dynamic, dynamically typed, functional and object-oriented programming language which fails silently and is an essential part of the web platform

Eloquent Javascript Chapter 3:

* Functions are like the words in your vocabulary, they allow you to do work.
* Variables defined inside of functions are only accessible with that function
* Variables initially declared outside of a function have a global scope
* Functions can be created inside of other functions.  These functions each have their own individual variable scope and access to the variables of the ‘parent’ functions which wrap them
* Control flow - the order the machine executes the code
* With ‘function declaration’ short hand you can define functions which are moved to the top of the control flow and thus can be called above where they are declared
* Call Stack - The order of the control flow and where in the code the computer should jump to next, the call stack takes memory which can be overloaded in which case you will get an error
* You can create functions with variable numbers of arguments, if you pass to many arguments to a function the get ignored, if you pass to few the unassigned arguments get set equal to ‘undefined’

Eloquent Javascript Chapter 5:

* Pure function - given the same attributes will always produce the same results
* Higher order functions - functions that operate on other functions either by taking them as arguments or by returning them
* Javascript has a map methods map(array, transformMethod(()) which returns an array with every element transformed
* It also has a reduce function which computes a single value from an array
* Nested loops can be a source of series slow down in your program
* ‘bind’ method - creates a new function that will call the original function but with some the arguments already fixed

Eloquent Javascript Chapter 6:

* Objects act as a simple interface for programmers to interact with
* prototype: another object that is used as a fallback source of properties.  You can create an object with a specific photo type which can contain function and state ubiquitous to all objects with that prototype.
* If you add a property to an object who's prototype has the same name the objects property will store the value but the prototype will remain unchanged.  Prototype property values could show up when enumerating through an object, to avoid that we should define our properties as ‘non-enumerable’
* Sometime prototypes get in the way, you can create objects without prototypes
* Constructors: Use new keyword to create a new object / ‘instance’ of its constructor.  Constructors are capitalized to distinguish them.
* polymorphism - methods with same names in different classes doing similar things
* you can use the ‘get’ and ‘set’ key words to specify a function to be run when the associated property is read or written
* you can use inheritance to allow one function to access the functions of another class

Chapter 17: Object and Inheritance

* object literals - plain direct instances of object (with state and behavior)
* .nameOfVar - . operator for reading properties
* numbers can be used as property values but they will be interpreted as strings
* You sometimes have to convert a value into an object
* ‘this’ is always a parameter that comes with a method, it represents the object on which the method has been called.  its value is ‘undefined’
* you can protect objects in three ways (preventing extensions: making it impossible to add properties to an object, sealing: making all the properties unchangeable, freezing: makes all properties permanently read only
* You can have constructors inherit one another prototype properties as well
* There are not that many generic methods in Javascript, most are around arrays and strings

Javascript Garden

* Everything but null and undefined acts like an object in javascript
* hasOwnProperty is the only reliable method to check for the existence of a property on an object
* loops can iterate over the prototype chain what iterating over the properties of an object, therefore you have to filter out unwanted properties side the loop body
* closures: functions insides of other functions have access to the scope of the ‘parent’ functions which wrap them.
* every function in javascript has a special variable called ‘arguments’ which is an object with a list of all arguments passed to that function, you can convert this object into an array

[meganft]

Speaking JS: Chapter 3

• I found it super interesting that JS is both functional and object oriented
• It’s clearly dynamic, so you can directly create objects without creating a class first
• Elegant parts let you presumably work around the quirks (“they allow you to implement block scoping, modules, and inheritance APIs—all within the language.”)
• JS influenced by 6 languages, which seems like a lot to me, but probably adds to whole theory of it being super dynamic

Eloquent JS Ch. 3: Functions

• It’s interesting that functions are the only thing that can create a new scope in Javascript
• Functions must specifically return a value in JS, which is a change from Ruby that I will have to remember
• Variables within a function are available only within that function, while those outside of it are “global” and available anywhere, which makes sense and is somewhat similar to Ruby
• Additionally, functions can be created within other functions, and this results in “lexical scoping”
• I appreciated the idea of the the let block, in which you could define your own scope
• I also was interested to hear that JS doesn't care how many arguments are passed into a function. But, if you pass too many arguments, the extras are ignored, and if you pass too few, the missing arguments become undefined.
• It was nice to hear the author say to not worry about efficiency until you know that the speed is a problem. Seems like a good rule of thumb!

Chapter 5 (Eloquent): Higher Order Functions

• The most important thing I learned in this chapter is that functions operating on other functions is a very powerful in JS.
• These functions that operate on other functions by taking them as arguments or by returning them are called higher-­order functions.
• They allow programmers to abstract over actions. These higher order functions can do tons of interesting stuff - create new functions, change other functions, and provide types of flow control
• A function is called ‘pure' in JS if it does not modify or change the data that is given, aka its not destructive
• JS has lots of pretty powerful built in methods for arrays, which I found super interesting - forEach does something on each element, filter builds a new array with some elements filtered out, map builds a new array in which each element has been through a function, and reduce combines all elements into one value.
• Additionally, functions in JS have the apply and bind methods. apply can be used to call them with an array specifying their arguments, while bind is used to create a partially applied version of the function. I still think I need to do some practice on these ones!

Chapter 6 (Eloquent): The Secret Life of Objects

• I found it very interesting that JS has some classic object-oriented techniques, but it also has an “eccentric” take on it, which is a bit confusing at first
• I didn’t know that almost all objects also have a ‘prototype’ in JS. A prototype is an object that is a fallback source of properties, so that when an object gets a request for a property that it doesn’t have, its prototype will be searched for that prototype. And if that prototype doesn't have it, the prototype’s prototype will be searched, and on and on
• Object.prototype, Function.prototype, and Array.prototype are all different prototypes
• Another option for creating objects is with a constructor. If you call a function with ‘new’, it will be treated as a constructor. An object created with ‘new’ is said to be an instance of its constructor.
• You can override the properties which exist on a prototype, which seems like it could be very useful
• Additionally, you are allowed to pass ‘null’ as the prototype to create a new object with no prototype. This also seems super useful and important to remember!
• Polymorphic code in JS does not shape-shift, but can work with values of different shapes
• I liked the idea of the get or set words - these are for properties and allow you to specify a function to be run

Chapter 17(Speaking): Objects and Inheritance

• A a lot of the material in this chapter had been covered in previous readings, but this describes the same concepts in a deeper way
• This chapter actually got overwhelming at times because it was so dense, and made me realize there is a lot to learn about JS
• It was interesting to note that there are several layers of OO programing in JS. The first layer is a object with single objects, the second is prototype chains of objects, the third is constructors as factories for instances, and the fourth is subclassing
• The delete operator lets you completely remove a property from an object (both the key and the value pair)
• Setting and deleting properties in this case ignores inheritance and only impacts the object itself
• There are three main ways to protect an object in JS - preventing extensions, sealing, freezing
• I again thought that Constructors were described as similar to classes in Ruby.

Javascript Garden

• This chapter was a nice summary of the rest of the readings, and it was very clear
• Everything in JS acts like an object except null and undefined.
• It is interesting that the use of global variables is considered bad practice and would indicate badly written code
• The authors recommended that you only use the strict equality operator
• This is definitely a resource that I will come back to for reference !

[annadolan]

Chapter 3 (Speaking)

• interesting that JS is both functional and object-oriented. I also found it interesting that an object can be created directly, without a class.
• The article mentions the use of prototypes, which I saw in the exercisms I did, but still don’t fully understand.

Chapter 3 (Eloquent)

• Scope matters within functions! The article discusses scope within nested functions as well, which I think will be useful. let vs var seems as though it may help a little with the confusion.
• Functions being assigned to variables seems to hold a lot of possibility. Not clear on the implications of this type of notation versus declaration notation.
• Don’t put functions inside if blocks or loops!
• The way JS uses optional arguments in functions is very explicit and makes a lot of sense to me.
• Break code out into functions (and smaller functions) the same way you would with methods in Ruby
• Side effects vs return value in JS is interesting, something I hadn’t thought about.

Chapter 5 (Eloquent)

• Expressing a concept simply, readably is more important than brevity
• Abstraction - looking at problems from a higher level
• The example of using forEach to clean up an iterating function is something I’ll refer back to.
• Functions operating on other functions - returning them or changing them
• Once again, scoping is very important!
• Using .apply to pass along multiple arguments within one argument - very clever
• Good explanation of JSON
• filter, map, reduce methods on arrays - lots of similarity to Ruby
• Abstractions can be expensive!

Chapter 6 (Eloquent)

• Function called as a method, using this to point to an object
• Objects have a prototype - another object used as a fallback source of properties
• All objects have the prototype Object.prototype - so much like Ruby! Array and function prototypes as well.
• Create an object based on a prototype
• Function with new in front of it makes it a constructor
• Object with new makes it an instance of its constructor
• I definitely should have done this reading before completing my exercisms
• Overriding properties from a prototype
• JS has actual get and set properties!
• Inheritance vs polymorphism is very, very confusing
• instanceOf returns a boolean, checks for constructor

Chapter 17 (Speaking)

• Three kinds of properties - normal properties, accessors, internal properties (like [[Prototype]])
• Object literals - directly create plain objects
• dot operator to access properties, call methods
• assignment operator = to set value of a property - creates property if it doesn’t exist, delete removes property
• .keys accesses keys, values can then be called with bracket operator
• bracket operator can also be used to call methods, delete properties
• slice converts args into an array
• that = this - another strange JS workaround - I prefer the forEach example.
• Checking object inheritance searches prototypes
• Cannot delete inherited properties
• Copying an object exactly is interesting, although I’m not clear on why you would want to do that.
• preventExtensions(obj), seal(obj), freeze(obj) to make objects less or nonwritable. Protects properties but not values.
• Article keeps referring to strict mode - I don’t know what this is, but it keeps JS from failing silently, which would be great.
• Don’t use nonpoymorphic properties (i.e. constants) in a prototype
• private values, privileged methods - taking advantage of scoping
• Different meanings of “prototype” - thanks JS
• Using methods from a prototype without inheriting from it - generic method
• Super helpful list of generic methods and cheat sheet for objects!

JavaScript Garden will probably be the most helpful of all of these - it clarifies a lot of the things I didn't understand in the chapters. This will be a really helpful reference.

[AliSchlereth]

Chapter 3(Speaking): Quirks: No int, arrays are not technically indexed, but map btwn # & element Elegances: First class functions, closures, prototypes, object literals, array literals

Chapter 3(Eloquent): Lexical Scoping: Sometimes referred to as Static Scoping. Access to variable in outer scope/function and own function. Let vs Var: Let creates a variable local to the block not the function Arguments: Won't throw an error, ignore too many, set as undefined for too few Closures: ... ?? Being able to reference a specific instance of local variables in an enclosing function ... ?? Looping vs Recursion: Looping is faster but recursion is more elegant, Worry about readability first though.

Chapter 5(Eloquent): Higher-Order Functions: Pass functions into other functions. Var declared inside inner isn't available in out function here. forEach, map, filter, reduce: All available, similar to Ruby enumerables. Looping is faster but less readable than these. forEach, map, and filter can take a second argument for index. apply: within body of a function, will apply function for each arg not just first bind: available on all functions, partially applied version of the function

Chapter 6(Eloquent): Objects!! Prototypes: another object that is used as a fallback source of properties. Look-up chain, inherits from parent generations properties Constructors: new => constructor, provides this = newObj, creates instances, the prototype of a constructor is Function.prototype no Object.prototype. A constructor's prototype property is the instances of the constructor, not is's prototype(Function.prototype). Can overwrite a property locally.
Array.prototype.toString !== Object.prototype.toString Properties we create are enumerable, but can set that to false with .defineProperty. hasOwnProperty checks if property is of the object not its prototype Polymorphism: code that works w/ different types of values i.e. toString instanceof: checks inheritance line

Chapter 17(Speaking): Methods vs Properties: properties are key:value methods are key: fuction delete obj.hello: returns t/f use sparingly use obj = {} vs obj = new Object Strict Mode and Callbacks: I'll need to learn more about this. .call: jane.prototype.call(jane, 'Tarzan') .apply: call w/ array of arguments .bind: sends along params to new function .construct: .bind.apply() for-in: avoid when iterating over own code protecting obj: .preventExtensions, .seal, .freeze

Garden: This is a good review of everything that has been covered.

[epintozzi]

Chapter 3. Speaking - The Nature of JavaScript • It's dynamic- can easily be changed and manipulated • It is both functional and object-oriented • It's error messages can be ambiguous, if they are event present • It is compiled by javascript engines after the source code is deployed • Though typically used directly in browser, it can be used without (ex: node.js) • It's creation takes influence from java, perl, awk, hypertalk, scheme, and self

Chapter 3. Eloquent JavaScript - Functions • Functions are just variables set to equal the function itself • Functions can take many parameters or no parameters • Functions can be created inside of functions, where, those results remain local to the nested function • Declaration notation can be used (rather than defining a function as a variable); when this is done, the function does not have to be at the top of the page/declared before it is used. Declaration notation should not be used with nested functions. • You can pass as many arguments as you want in JS, but if you pass too many, the extras will just be ignored.

Chapter 5. Eloquent JavaScript - Higher Order Functions • More lines doesn't mean a better program • Using abstractions can make code simpler and easier to understand as the program grows and changes hands • Higher order functions are just functions that create, change, or return other functions • The JSON format is a commonly used format for communicating and storing data but you can't use variables or functions within. • Filter, forEach, map, reduce, are standard methods for arrays • We can compose functions for greater clarity and abstraction • Using these built-in methods can significantly slow down programs however so we have to weigh the cost of abstraction against the cost of performance

Chapter 6. Eloquent JavaScript - The Secret Life of Objects • Prototypes sound a lot like Ruby classes to me, based on the description in this chapter • Constructors seem similar to initializing a object via a class in ruby by using new • Object properties can be overridden for specific derivatives of that object • Polymorphism adjusts an object or value to match a specified property without being destructive • Getters and setters are used to read and write properties on objects • Inheritances can be used to override properties of instances of prototypes but the use of them is controversial

Chapter 17. Speaking - Objects and Inheritance • There are 4 layers of objects in JS: single objects, prototype chains of objects, constructors, and subclassing • All objects are dictionaries (like a hash) where every key/value pair is a property. Keys are always strings and values can be anything. • Named properties are most common where the string key points to a value. Accessors (getters/setters) are a second type of property. Internal properties also exist but are generally only accessible via the getPrototypeOf method • Use the "dot" to call methods, access properties, and get/set or delete properties • Methods can also be called with the bracket operator • This chapter reviews a lot of what was covered in Chapters 5 and 6 of Eloquent JavaScript, though with a few more thorough examples. • Section 2 has a nice summary of best practices for iterating through properties and enumerating • Defining a property is creating a new property whereas assigning a property is changing an existing property • Properties can be protected with various methods which determine how or if they can be altered • The later half of this chapter will need to be reviewed and re-read several times as I better understand Javascript; This portion of the chapter will be great to reference as I work with constructors and inheritance

Javascript Garden • Right off the bat, this will be a great resource to keep around as it is a little clearer and more succinct than the chapters above. Especially while starting out, I think this is the most useful tool I've read through so far. • All objects in js are technically hash maps or dictionaries so I would access properties just as I would a hash in ruby. • Good recap of functions- what they are and how to use • Also good recap of this which often confuses me; Come back to this section! • Overall good quick lookup type resource

[antciccone]

Module 4 Intermission Assignments

Readings

1. The Nature of JavaScript Key Takeaways -no build in modules -Object Oriented and functional -JavaScript has been influenced by many languages like java, perl, python etc

Functions

• Functions to me seem similar to methods in ruby.
• Functions can take arguments
• You have to explicitly return values in JS
• Variables created inside of that function are local to that function
• Nested functions - function inside another functions
• Functions are the only things that create a new scope
• Functions can be written in two different ways. var square = function() or function square()
  • Declaration notation is written like function square() and gives the user more freedom as they are conceptually moved to the top of the scope
• Functions that are passed too many arguments ignoring the extra which can cause problems of passing around data that is not needed
• Functions can call themselves similar to ruby (recursion) as long as it does not overflow the stack

Minimum function min(num1, num2){ if (num1 > num2) return num1; } else { return num2; }

Recursion function isEven(num){ if (num === 0) return true; } else if { num < 0 return false; } else { num - 2; isEven(num); } console.log(isEven(50)); -> true console.log(isEven(75)); -> false console.log(isEven(-1)); -> false

Bean Counting function countBs(string){ var counter = 0; for (var i = 0, i < string.length, ++) counter ++ if ( i === “B”); return counter; } console.log(countBs("BBC")) -> 2

function countChar(string, letter) { var counter = 0 ; for (var i = 0, string.length, ++) counter ++ if ( i === letter); return counter; } console.log(countChar("kakkerlak", "k"))

Higher order Functions

-Abstractions hide details and give us the ability to talk about problems at a higher level. -Higher order functions operate on other functions either by taking them as arguments or returning them -Reminder - JSON = javascript object notation what -reduce :)

The Secret Life of Objects

-methods are simply properties that hold function values -almost all object have a prototype or another object that is used as a fallback source of properties -calling a function with the ‘new’ keyword in front of it causes it to be treated as a constructor

• an object created with new is said to be an instance of its contructor
• should capitalize the names of constructors

JavaScript Garden -great resource for common javascript problems. It also has easy to read samples.

[vidoseaver]

Eloquent Javacsript

Chapter 3: Data structures, object and arrays

• You can use [] notation in place of dot notation. Especially if dot notation isn't working.

• .delete removes things from objects by key like Object["cat_name"].delete who then render Object["cat_name"] void of that key

• objects will return thier contents when called

• Chinese boxes are phyically impossibly but work in programing

• range(start, end) takes two arguments. the first is optional

• Split(" ") breaks a string on " ".

• slice(from, too) copies from index to index not including the last one

• objects dont == themselves even if they have the same value. Cause they arent the same object.

• Date(year, month, day, hour, minute, seconds.....)

• Arguments is an object. You can .length it

• Math.

  • max
  • min
  • round
  • floor
  • ciel
  • pow
  • sin
  • cos
  • pi

• for(method in object) do this stuff

Chapter 5: Functional Programming

• Abstraction == refactoring
• forEach(array, function(arrayItem)
• appartentlly you can call foreach(array, randomFunction) and the random function takes the array item as an argument secretly... wtf?
• Section on modifying functions is unclear - its a hard coded shell designed to corrupt pre-existing functions?
• Apparently we have to our own reduce and maps now. Awesome.
• Html has two children
  • Head - information about the document
  • Body - actual document
• Build programs like clay. Solid yet maleable.
• typo line 7 page 82 - should be paragraphs?
• after the hermit story I can't help but wonder. was this written by josh cheek?
• indexOf(substring) returns -1 if it doesnt find it.
• concat adds things to an array?
• replace(thing, withThis)
• treat your document as a data structure
• function tag(name, attributes, content) - niiiiice meta programing
• you can put a bunch of operations into a has then hit the hash with the key for that functions operation
• Composition... Ehh What?

Chapter 6: Object Oriented Programming

• You can use dot notation to assign new keys to a object
• Constuctors start with caps and can be made with new
• Proptyping is kind of like inhertenance. provides default values that can be over written
• Make interfaces small and custom to each object( kind of like using hidden methods)

Javascript Garden

• null and undefined only non js objects
• 2..toString()
• delete is reserved keyword for javascript
• prottypes allow for multiple parents?
• hasOwnProperty - way to check if an object has a property in it

[rtravitz]

Chapter 3 (Speaking): The Nature of JavaScript

• JavaScript has several quirks and missing features (some of which are solved in ES6). But this also means that it has some useful parts, including prototypes, object literals, and array literals.
• JavaScript was influenced by several programming languages, including Java for syntax and partitioning values, AWK for functions, Self for its style of object-orientation, and Perl and Python for handling of strings, arrays, and regex.

Chapter 3 (Eloquent): Functions

• Functions allow defining new vocabulary.
• Function definitions in JS are just regular variable definitions where the value given to the variable happens to be a function.
• Functions contain locally scoped variables as in Ruby.
• Javascript uses lexical scoping, but blocks do not create a new local scope like they do in Ruby. ES6 provides a let keyword that scopes within a block.
• Functions are often passed as values to other functions.
• JS is very liberal about the number of arguments you can pass to a function and will not throw an error. You can take optionals.
• JS has closures, which can be used to access specific instances of local variables.

Chapter 5 (Eloquent): Higher Order Functions

• Often in JS, abstraction involves passing actions as function values.
• Higher-Order functions are those that operate on other functions, either by thaking them as arguments or by returning them. Functions can create other functions, change other functions, or write functions with new types of control flow.
• The apply method takes an array or array-like object and calls a function with those arguments.
• forEach is a good example of a higher-order function in JS. Similarly, filtering an array is done by passing a collection and then another function that contains the filtering logic. Map and Reduce both operate the same way.
• Elegant code can often be inefficient, but if you are not working at a massive scale, this often does not matter and optimizing for developer hours is more important.
• The bind method creates a new function that will call the original function with some arguments already fixed.

Chapter 6: (Eloquent) The Secret Life of Objects

• In JS methods are properties that hold function values. Along with that, this points to an object that a method is called on.
• Almost all objects in JS have a prototype, which is another object used as a fallback source of properties. If an object is asked for a property that it doesn't have, it will search its prototype and subsequent prototypes.
• Constructors are a convenient way to create objects that derive from a shared prototype. The keyword new is also treated as a constructor.
• Methods can be added to an object's prototype or within the constructor.
• Properties can be overidden within an object without changing the prototype.
• Prototypes can be used to add new properties and methods to all objects based on it.
• JS is a polymorphic language
• get and set within an object literal allow you to specificy a function to be run when the property is read or written.
• call is used in JS's inheritance pattern to build slightly different data types.
• instanceof allows you to see through inherited types to learn from where an object was derived.

Chapter 17: Objects and Inheritance (Speaking JavaScript)

• At a basic level, it helps to think about JS objects as maps from strings to values.
• Callbacks are common in JS, but somtimes bind() is needed to give a fixed value for this.
• proto gives direct access to [[Prototype]] and will be implemented in ES6.
• Objects can list out all of their properties, which can be used in enumerables.
• Property descriptors are used for getting a property and defining a property.
• Objects can be protected in several ways, including preventing extensions, sealing, and freezing.
• Setting strict mode is recommended for constructors.
• Much of the end of this chapter will be good to reference as I learn more about JavaScript. Right now, I am still working on fully comprehending constructor inheritance.

JavaScript Garden

• The only way to remove a property from an object is to use the delete operator. Setting it to undefined or null just removes the value associated with the property.
• It's interesting that when enumerating over properties of an object, every property in the prototype chain will be looked at, which can have a high performance cost high up on the chain.
• hasOwnProperty seems useful for staying out of the prototype chain while looking for properties.
• I learned the word hoisted to describe when a function can be defined after it is called and still work.
• Every function scope in JavaScript can access the special variable arguments. This variable holds a list of all the arguments that were passed to the function.
• Undefined in JS is used more like null or nil in other languages. null itself in JS is more or less just another data type.

[Cdunagan05]

• Javascript is functional and object-oriented. I think this is extremely cool, because whenever I’ve researched languages, it seems like I always have to pick one that is either functional OR object oriented, but I don’t have to worry about that with Javascript. It’s both.

• Function declarations in Javascript are not top-to-bottom read. This is important to know because we could then write code in a way that is clearer to us, as coders, but still functions correctly.

• Passing the correct number of arguments to a function in Javascript can be tricky, because the language is very permissible to having too many or too few arguments, and will mostly not tell you about it, if you put in the incorrect amount. Be careful here.

• You can pass actions as function values. function forEach(array, action) { for (var i = 0; i < array.length; i++) action(array[i]); }

• Higher order functions are extremely versatile. You can use functions to create new functions. You can use functions to change functions. You can even use functions to make new types of flow control. Very cool.

• Javascript has methods like Ruby, and It’s up to me to find them and make the best use of them.

• Constructors can be used to create objects for object oriented programming in javascript.
  example: function Rabbit(type) { this.type = type; }

  var killerRabbit = new Rabbit("killer"); var blackRabbit = new Rabbit("black"); console.log(blackRabbit.type); // → black

• Getters and Setters can be used to “specify a function to be run when the property is read or written”. This seems like it will come in handy in the future, and is something I need to remember. Mainly used in an object literal.

• When talking about single objects there are dot operators and bracket operators ( I think I prefer dot operators because it is closer to ruby, and seems very straight forward).

• Javascript as a whole can sometimes be a funky language, but it looks and seems very fun to write and play around with. I look forward to getting more in-depth with this language in the next weeks and months of my life!