constructor functions

provider(provider) - registers a service provider with the $injector constant(obj) - registers a value/object that can be accessed by providers and services. value(obj) - registers a value/object that can only be accessed by services, not providers. factory(fn) - registers a service factory function, fn, that will be wrapped in a service provider object, whose $get property will contain the given factory function. service(class) - registers a constructor function, class that will be wrapped in a service provider object, whose $get property will instantiate a new object using the given constructor function

When you request a service, the $injector is responsible for finding the correct service provider, instantiating it and then calling its $get service factory function to get the instance of the service.

An Angular service is a singleton object created by a service factory. These service factories are functions which, in turn, are created by a service provider. The service providers are constructor functions. When instantiated they must contain a property called $get, which holds the service factory function.

This method returns a new promise which is resolved or rejected via the return value of the

we created a new toastr object and then we created 3 spies (more on this shortly). After that we just needed to create a new value service that will create/override the toastr one.

What about those createSpy? They do more or less the same as spyOn. What’s the difference? spyOn is used to spy an existing function and createSpy will create a dummy spied function. Since our new toastr service has none, we can create spied functions from scratch, handy.

If we have a service (of any kind) with a certain name and we after that create another service (of any kind) with that same name, it will be overriden. That is whycreating a simple value service will override the previous one.

We replaced the toastr service with one we made right here, in other words, a complete mock.

We also run a manual $digest to resolve all the promises we have on the mocked service.

Testing angular controllers is not hard but a bad controller usage can make our tests a nightmare. We need to keep our controllers as lean as possible.

Additionally, NaN compared to anything – even itself! – is false:

variables and functions declared inside of an eval() statement are not created in the containing scope

When setting an object property, JavaScript will implicitly stringify the parameter value. In this case, b and c will both be converted to Object.

A closure is an inner function that has access to the variables in the outer (enclosing) function’s scope chain.

The above behavior is what occurs if you are using use strict. Without use strict both a and b will be defined in the above example (which is yet another reason you should use use strict as a matter of course in your code!).

(toString.call(bar) !== "[object Array]"

The stack overflow is eliminated because the event loop handles the recursion, not the call stack. When nextListItem runs, if item is not null, the timeout function (nextListItem) is pushed to the event queue and the function exits, thereby leaving the call stack clear. When the event queue runs its timed-out event, the next item is processed and a timer is set to again invoke nextListItem. Accordingly, the method is processed from start to finish without a direct recursive call, so the call stack remains clear, regardless of the number of iterations.

Passing an array to the push() method of another array pushes that entire array as a single element onto the end of the array.

The reverse() method returns a reference to the array itself (i.e., in this case, arr1). As a result, arr2 is simply a reference to (rather than a copy of) arr1.

Calling an array object’s reverse() method doesn’t only return the array in reverse order, it also reverses the order of the array itself (i.e., in this case, arr1).

But any operator applied to NaN with any other numeric operand will still yield NaN.

it performs automatic type conversion on values to accommodate the operation being performed.

function isPalindrome(str) { return str.split('').reverse().join('') === str; }

function foo2() { return { bar: "hello" }; }

Throws error on invalid usage of delete. The delete operator (used to remove properties from objects) cannot be used on non-configurable properties of the object. Non-strict code will fail silently when an attempt is made to delete a non-configurable property, whereas strict mode will throw an error in such a case.

Disallows duplicate property names or parameter values.

Eliminates this coercion. Without strict mode, a reference to a this value of null or undefined is automatically coerced to the global. This can cause many headfakes and pull-out-your-hair kind of bugs. In strict mode, referencing a a this value of null or undefined throws an error.

Prevents accidental globals. Without strict mode, assigning a value to an undeclared variable automatically creates a global variable with that name. This is one of the most common errors in JavaScript. In strict mode, attempting to do so throws an error.

Prior to ECMA 5, this in the inner function would refer to the global window object; whereas, as of ECMA 5, this in the inner function would be undefined

When working with methods, the value of this is important. By using the apply, call, and bind methods of Function, we can: Change this inside a function, enabling flexible APIs to be created as demonstrated by popular projects like jQuery, Backbone.js, and Express Reduce syntactical overhead when using functions inside methods, and passing methods to other functions Chain calls to constructors

JavaScript allows us to pass functions around, then execute them in different contexts by taking advantage of call and apply.

In Angular spies are heavily used on any kind of unit test. When we are testing something, we don’t care about the injected dependencies, we just need to make sure that they were used properly.

Having our spy in place, all what we need to do is to call post.retrieve and then assert that getAll was called and that also post.posts contain our fake posts that were returned by getAll

We create our directive element, we compile it and we test it. To test it, some times we need to check its scope status and also the resulting DOM to check that everything is in place as we expect.

led on false positives.

To inject we need to use the inject function (from angular-mocks) which will receive a function with all the stuff we need to inject

To load it and since we need it before each test, we use the module function (from angular-mocks) to load that app module for us. If we have more dependencies like ngRoute, we also need to load it (before app).

Are you starting to see what we are getting here so far? API design. By using our object before we coded it, we are using the API as we would like to use it. That is a much much better way to define our API.

Compile function: It is used for template DOM Manipulation and collect all of the directives.

An injector is a service locator. It is used to retrieve object instances as defined by provider, instantiate types, invoke methods and load modules. There is a single injector per Angular application, it helps to look up an object instance by its name.

Link combines the directives with a scope and produce a live view. For registering DOM listeners as well as updating the DOM, link function is responsible. After the template is cloned it is executed.

Context : In Angular, the expressions are evaluated against a scope object, while the Javascript expressions are evaluated against the global window

Attach a controller to each view (using ng-view and routing, or ng-controller). Have the controller find/get only whatever model data the view needs to do its job. Make controllers as thin as possible.

In AngularJS, you want to think about views rather than DOM elements. Views are (declarative) HTML that contain AngularJS directives. Directives set up the event handlers behind the scenes for us and give us dynamic databinding. Selectors are rarely used, so the need for IDs (and some types of classes) is greatly diminished. Views are tied to models (via scopes). Views are a projection of the model. Events change models (that is, data, scope properties), and the views that project those models update "automatically."

don't design, and then mark up. You must architect, and then design.

In the various applications I’ve written in Angular so far, by far the majority of the application’s complexity is in the directives. They are a powerful tool for working with and modifying the DOM,

Controllers should be used purely to wire up services, dependencies and other objects, and assign them to the view via scope.

One-time binding syntax: In newer versions of Angular (v1.3.0-beta.10+), use the one-time binding syntax {{ ::value }} where it makes sense

Directives and Filters are the only providers that have the first letter as lowercase; this is due to strict naming conventions in Directives.

DOM manipulation

function someDirective () { return { template: [ '<div class="some-directive">', '<h1>My directive</h1>', '</div>' ].join('') }; }

Controllers should fetch Model data from Services, avoiding any Business logic. Controllers should act as a ViewModel and control the data flowing between the Model and the View presentational layer. Business logic in Controllers makes testing Services impossible.

When your code is minified and bundled into a single file for deployment to a production server, you could have collisions of variables and many global variables.

The following create new scopes, and inherit prototypically: ng-repeat, ng-include, ng-switch, ng-view, ng-controller,

Where you give ng-class an object, whose keys are CSS class names and whose values are conditional expressions using $scope variables.

In particular, don't use it for code, only data. If you're tempted to put a function on $rootScope, it's almost always better to put it in a service that can be injected where it's needed, and more easily tested.

ng-repeat is extremely useful, one of the most powerful directives in Angular. However the transformation it applies to the DOM is substantial. Therefore applying other directives (such as ng-show, ng-controller and others) to the same element as ng-repeat generally leads to problems.

In this same New Bedford

Upon waking next morning about dayligh