Is there a less verbose way of accessing dependencies (i.e. constructor parameters) in prototype functions? Particularly for AngularJS Services.
I only know of
function SomeSrvc($http, ...other deps...) {
var srvc = this;
// Verbose way of storing dependencies
srvc.$http = $http;
srvc.dep2 = dep2;
srvc.dep3 = dep3;
srvc.dep4 = dep4;
}
SomeSrvc.prototype.doSomething = function() {
var srvc = this;
// Do stuff with srvc.$http and other srvc.deps...
};
The shortest I know would be avoiding using prototype in an outer scope and simply use closures:
function SomeSrvc($http, ...other deps...) {
var srvc = this;
srvc.doSomething = function() {
// just use $http without this / srvc
};
}
Short and nice. If you really like prototype-like syntax, just adjust the indentation (but in my opinion this would be uglier):
function SomeSrvc($http, ...other deps...) {
var srvc = this;
srvc.doSomething = function() {
// Do stuff with srvc.$http and other srvc.deps...
};
}
This gives you the same effect - the object created with a new operator will have this function and angular services are created this way.
Additionally, this way has a really good side-effect. It does not create the variables on the service object, so they can be considered private, when assigning all your variables to the service makes them public and could be accessed from another angular module. Currently by just injecting your service you are able to use all injected modules by just calling e.g.
SomeSrvc.$http
which is totally against the whole idea of dependency injection.
new operator. You cannot reuse constructor function elsewhere, so prototype is just obsolete. In my opinion at least...new SomeSrvc() and taking it's prototype. Just one step moreThis is actually an official way described in documentation
function SomeClass(greeter) {
this.greeter = greeter;
}
SomeClass.prototype.doSomething = function(name) {
this.greeter.greet(name);
}
But I would consider to use ES2015 classes syntax instead.
export default class SomeClass {
constructor(greeter) {
this._greeter = greeter;
}
doSomething() {
this._greeter.greet(name);
}
}
You can read about it more here
$scope-variables-way instead of this way on the most pages of their documentation, but it does not mean it is a right way to go...
for services, not controllers, I've been doing something a little different
module.factory('myService', function(dep1, dep2){
var createInternal=function(){
var internal = Object.create(proto);
internal.init( ... );
return internal;
};
var service = function(){
var internal = createInternal();
return {
doSomething: function(a, b, c){ return internal.doSomething(a,b,c); },
...
};
};
var proto = {
init: function( ... ){
dep1.greet();
dep2.doSomethingElse();
...
},
doSomething: function(a, b, c){
dep1.grito(b);
dep2.haceOtraCosa();
},
...
};
return service();
});
It's a little bit different, but it breaks it up into a header and a list of prototype functions, which I like.
prototypeall that frequently ... But I've always liked it even if it is slightly more verbose.$injector.$injector? Does it change the verbose way of passing to prototype functions?function SomeSrvc($injector)thensrvc.$http = $injector.get('$http'), so you still have to assign it