que - AngularJS: Cuándo usar el servicio en lugar de fábrica
que es un service en angularjs (8)
Explicación
Tienes cosas diferentes aquí:
Primero:
- Si utiliza un servicio, obtendrá la instancia de una función ("
this" palabra clave). - Si utiliza una fábrica, obtendrá el valor que se devuelve al invocar la referencia de función (la declaración de devolución en fábrica).
ref: angular.service vs angular.factory
Segundo:
¡Tenga en cuenta que todos los proveedores en AngularJS (valor, constante, servicios, fábricas) son únicos!
Tercero:
Usar uno u otro (servicio o fábrica) es sobre el estilo del código. Pero, la forma común en AngularJS es usar la fábrica .
Por qué ?
Porque "el método de fábrica es la forma más común de obtener objetos en el sistema de inyección de dependencia AngularJS. Es muy flexible y puede contener una lógica de creación sofisticada. Dado que las fábricas son funciones normales, también podemos aprovechar un nuevo alcance léxico para simular "variables. Esto es muy útil ya que podemos ocultar los detalles de implementación de un servicio dado".
( ref : http://www.amazon.com/Mastering-Web-Application-Development-AngularJS/dp/1782161821 ).
Uso
Servicio: podría ser útil para compartir funciones de utilidad que son útiles para invocar simplemente añadiendo () a la referencia de función inyectada. También podría ejecutarse con injectedArg.call(this) o similar.
Fábrica: podría ser útil para devolver una función de ''clase'' que luego puede ser nueva para crear instancias.
Por lo tanto, use una fábrica cuando tenga lógica compleja en su servicio y no quiera exponer esta complejidad .
En otros casos, si desea devolver una instancia de un servicio, simplemente use el servicio .
Pero verá con el tiempo que usará la fábrica en el 80% de los casos, creo.
Para más detalles: http://blog.manishchhabra.com/2013/09/angularjs-service-vs-factory-with-example/
ACTUALIZACIÓN:
Excelente publicación aquí: http://iffycan.blogspot.com.ar/2013/05/angular-service-or-factory.html
"Si desea que su función se llame como una función normal , use factory . Si desea que su función se ejemplifique con el nuevo operador, use el servicio. Si no conoce la diferencia, use factory".
ACTUALIZACIÓN:
El equipo de AngularJS hace su trabajo y da una explicación: http://docs.angularjs.org/guide/providers
Y desde esta página:
"Factory y Service son las recetas más utilizadas. La única diferencia entre ellas es que las recetas de Service funcionan mejor para objetos de tipo personalizado, mientras que Factory puede producir funciones y primitivas de JavaScript".
Por favor ten paciencia conmigo aquí. Sé que hay otras respuestas como: AngularJS: Servicio vs proveedor vs fábrica
Sin embargo, todavía no puedo entender cuándo usarías el servicio sobre la fábrica.
Por lo que puedo decir, la fábrica se usa comúnmente para crear funciones "comunes" que pueden ser llamadas por varios Controladores: Crear funciones de controlador comunes
Los documentos angulares parecen preferir la fábrica al servicio. Incluso se refieren al "servicio" cuando usan la fábrica, lo que es aún más confuso. http://docs.angularjs.org/guide/dev_guide.services.creating_services
Entonces, ¿cuándo uno usaría el servicio?
¿Hay algo que solo es posible o mucho más fácil hacer con el servicio?
¿Hay algo diferente que pasa detrás de las escenas? ¿Diferencias de rendimiento / memoria?
Aquí hay un ejemplo. Aparte del método de declaración, parecen idénticos y no puedo entender por qué haría uno frente al otro. http://jsfiddle.net/uEpkE/
Actualización: de la respuesta de Thomas, parece implicar que el servicio es para una lógica más simple y una lógica más compleja con métodos privados, así que actualicé el siguiente código de violín y parece que ambos son capaces de admitir funciones privadas.
myApp.factory(''fooFactory'', function() {
var fooVar;
var addHi = function(foo){ fooVar = ''Hi ''+foo; }
return {
setFoobar: function(foo){
addHi(foo);
},
getFoobar:function(){
return fooVar;
}
};
});
myApp.service(''fooService'', function() {
var fooVar;
var addHi = function(foo){ fooVar = ''Hi ''+foo;}
this.setFoobar = function(foo){
addHi(foo);
}
this.getFoobar = function(){
return fooVar;
}
});
function MyCtrl($scope, fooService, fooFactory) {
fooFactory.setFoobar("fooFactory");
fooService.setFoobar("fooService");
//foobars = "Hi fooFactory, Hi fooService"
$scope.foobars = [
fooFactory.getFoobar(),
fooService.getFoobar()
];
}
El concepto para todos estos proveedores es mucho más simple de lo que parece inicialmente. Si diseccionas un proveedor y sacas las diferentes partes, se vuelve muy claro.
En pocas palabras, cada uno de estos proveedores es una versión especializada del otro, en este orden: provider > factory > value / constant / service .
Mientras el proveedor haga lo que pueda, puede utilizar al proveedor más abajo en la cadena, lo que resultaría en escribir menos código. Si no logra lo que desea, puede subir la cadena y tendrá que escribir más código.
Esta imagen ilustra lo que quiero decir, en esta imagen verá el código de un proveedor, con las partes resaltadas que le muestran qué partes del proveedor podrían usarse para crear una fábrica, un valor, etc.
Para obtener más detalles y ejemplos de la publicación del blog del que obtuve la imagen, vaya a: http://www.simplygoodcode.com/2015/11/the-difference-between-service-provider-and-factory-in-angularjs/
Incluso cuando dicen que todos los servicios y fábricas son únicos, no estoy de acuerdo al 100 por ciento con eso. Yo diría que las fábricas no son singletes y este es el punto de mi respuesta. Realmente pensaría en el nombre que define cada componente (Servicio / Fábrica), quiero decir:
Una fábrica porque no es un singleton, puede crear tantas como desee cuando inyecte, por lo que funciona como una fábrica de objetos. Puede crear una fábrica de una entidad de su dominio y trabajar más cómodamente con estos objetos que podrían ser como un objeto de su modelo. Cuando recuperas varios objetos, puedes mapearlos en estos objetos y puede actuar como una capa más entre el DDBB y el modelo de AngularJs. Puedes agregar métodos a los objetos para que orientes los objetos un poco más a tu aplicación de AngularJs.
Mientras tanto, un servicio es un singleton, por lo que solo podemos crear 1 de un tipo, tal vez no crear, pero solo tenemos 1 instancia cuando inyectamos un controlador, por lo que un servicio se parece más a un servicio común (llamadas de resto, funcionalidad ...) a los controladores.
Conceptualmente, puede pensar que los servicios proporcionan un servicio, las fábricas pueden crear múltiples instancias (objetos) de una clase
No hay nada que una Fábrica no pueda hacer o haga mejor en comparación con un Servicio. Y viceversa. La fábrica parece ser más popular. La razón de ello es su conveniencia en el manejo de miembros privados / públicos. El servicio sería más torpe en este sentido. Al codificar un Servicio, tiende a hacer públicos sus miembros objeto a través de la palabra clave "this" y puede descubrir repentinamente que esos miembros públicos no son visibles a los métodos privados (es decir, funciones internas).
var Service = function(){
//public
this.age = 13;
//private
function getAge(){
return this.age; //private does not see public
}
console.log("age: " + getAge());
};
var s = new Service(); //prints ''age: undefined''
Angular usa la palabra clave "nueva" para crear un servicio para usted, por lo que la instancia de Angular pasa al controlador tendrá el mismo inconveniente. Por supuesto, puedes superar el problema usando este / eso:
var Service = function(){
var that = this;
//public
this.age = 13;
//private
function getAge(){
return that.age;
}
console.log("age: " + getAge());
};
var s = new Service();// prints ''age: 13''
Pero con una constante de servicio grande, esto haría que el código fuera poco legible. Además, los prototipos del Servicio no verán miembros privados, solo el público estará disponible para ellos:
var Service = function(){
var name = "George";
};
Service.prototype.getName = function(){
return this.name; //will not see a private member
};
var s = new Service();
console.log("name: " + s.getName());//prints ''name: undefined''
Resumiendo, usar Factory es más conveniente. Como fábrica no tiene estos inconvenientes. Recomendaría usarlo por defecto.
Puede usar la forma que desee : ya sea crear objeto o j ust para acceder a funciones desde ambos
Puedes crear un nuevo objeto desde el servicio
app.service(''carservice'', function() {
this.model = function(){
this.name = Math.random(22222);
this.price = 1000;
this.colour = ''green'';
this.manufacturer = ''bmw'';
}
});
.controller(''carcontroller'', function ($scope,carservice) {
$scope = new carservice.model();
})
Nota :
- Servicio por defecto devuelve objeto y no función constructora.
- Así que esa es la razón por la cual la función de constructor se establece en esta propiedad de modelo
- Debido a este servicio, se devolverá el objeto, pero pero dentro de ese objeto habrá una función constructora que se usará para crear un nuevo objeto;
Puedes crear nuevos objetos de fábrica
app.factory(''carfactory'', function() {
var model = function(){
this.name = Math.random(22222);
this.price = 1000;
this.colour = ''green'';
this.manufacturer = ''bmw'';
}
return model;
});
.controller(''carcontroller'', function ($scope,carfactory) {
$scope = new carfactory();
})
Nota :
- La fábrica por defecto devuelve la función constructora y no el objeto.
- Por eso es que se puede crear un nuevo objeto con la función de constructor.
Crear servicio para solo acceder a funciones simples.
app.service(''carservice'', function () {
this.createCar = function () {
console.log(''createCar'');
};
this.deleteCar = function () {
console.log(''deleteCar'');
};
});
.controller(''MyService'', function ($scope,carservice) {
carservice.createCar()
})
Crear fábrica para acceder a funciones simples.
app.factory(''carfactory'', function () {
var obj = {}
obj.createCar = function () {
console.log(''createCar'');
};
obj.deleteCar = function () {
console.log(''deleteCar'');
};
});
.controller(''MyService'', function ($scope,carfactory) {
carfactory.createCar()
})
Conclusión:
- puede utilizar la forma que desee para crear un nuevo objeto o simplemente para acceder a funciones simples
- No habrá ningún impacto de rendimiento, utilizando uno sobre el otro.
- Ambos son objetos singleton y solo se crea una instancia por aplicación.
- Siendo solo una instancia cada donde se pasa su referencia.
- En la documentación angular la fábrica se llama servicio y también el servicio se llama servicio .
Tanto la fábrica como el servicio dan como resultado objetos singleton que pueden ser configurados por los proveedores e inyectados en los controladores y bloques de ejecución. Desde el punto de vista de la persona inyectada, no hay absolutamente ninguna diferencia si el objeto proviene de una fábrica o un servicio.
Entonces, ¿cuándo usar una fábrica y cuándo usar un servicio? Se reduce a su preferencia de codificación, y nada más. Si te gusta el patrón modular de JS, ve a la fábrica. Si te gusta el estilo de la función de constructor ("clase"), ve al servicio. Tenga en cuenta que ambos estilos admiten miembros privados.
La ventaja del servicio podría ser que es más intuitivo desde el punto de vista de la POO: cree una "clase" y, junto con un proveedor, reutilice el mismo código en todos los módulos y varíe el comportamiento de los objetos instanciados simplemente suministrando Diferentes parámetros para el constructor en un bloque de configuración.
Servicios
Sintaxis : module.service (''serviceName'', function); Resultado : Al declarar serviceName como un argumento inyectable, se le proporcionará la referencia de la función real pasada a module.service.
Uso : podría ser útil para compartir funciones de utilidad que son útiles para invocar simplemente añadiendo () a la referencia de función inyectada. También podría ejecutarse con injectedArg.call (this) o similar.
Suerte
Sintaxis : module.factory (''factoryName'', function);
Resultado : Al declarar factoryName como un argumento inyectable, se le proporcionará el valor que se devuelve al invocar la referencia de función pasada a module.factory.
Uso : podría ser útil para devolver una función de ''clase'' que luego puede ser nueva para crear instancias.
Proveedores
Sintaxis : module.provider (''providerName'', function);
Resultado : Al declarar providerName como un argumento inyectable, se le proporcionará el valor que se devuelve al invocar el método $ get de la referencia de función pasada a module.provider.
Uso : podría ser útil para devolver una función de ''clase'' que luego puede ser nueva para crear instancias pero que requiere algún tipo de configuración antes de ser inyectada. ¿Quizás útil para las clases que son reutilizables en todos los proyectos? Todavía un poco confuso en este caso.
allernhwkim originalmente publicó una respuesta a esta pregunta relacionada con su blog , sin embargo, un moderador la eliminó. Es la única publicación que encontré que no solo le dice cómo hacer lo mismo con el servicio, el proveedor y la fábrica, sino que también le dice qué puede hacer con un proveedor que no puede con una fábrica y con Una fábrica que no puedes con un servicio.
Directamente desde su blog:
app.service(''CarService'', function() {
this.dealer="Bad";
this.numCylinder = 4;
});
app.factory(''CarFactory'', function() {
return function(numCylinder) {
this.dealer="Bad";
this.numCylinder = numCylinder
};
});
app.provider(''CarProvider'', function() {
this.dealerName = ''Bad'';
this.$get = function() {
return function(numCylinder) {
this.numCylinder = numCylinder;
this.dealer = this.dealerName;
}
};
this.setDealerName = function(str) {
this.dealerName = str;
}
});
Esto muestra cómo CarService siempre producirá un automóvil con 4 cilindros, no puede cambiarlo por autos individuales. Mientras que CarFactory devuelve una función para que pueda hacer una new CarFactory en su controlador, pasando una serie de cilindros específicos para ese automóvil. No puede hacer un new CarService porque CarService es un objeto y no una función.
La razón por la cual las fábricas no funcionan así:
app.factory(''CarFactory'', function(numCylinder) {
this.dealer="Bad";
this.numCylinder = numCylinder
});
Y devolver automáticamente una función para que usted pueda crear una instancia, es porque entonces no puede hacer esto (agregar cosas al prototipo / etc):
app.factory(''CarFactory'', function() {
function Car(numCylinder) {
this.dealer="Bad";
this.numCylinder = numCylinder
};
Car.prototype.breakCylinder = function() {
this.numCylinder -= 1;
};
return Car;
});
Vea cómo es literalmente una fábrica que produce un automóvil.
La conclusión de su blog es bastante buena:
En conclusión,
--------------------------------------------------- | Provider| Singleton| Instantiable | Configurable| --------------------------------------------------- | Factory | Yes | Yes | No | --------------------------------------------------- | Service | Yes | No | No | --------------------------------------------------- | Provider| Yes | Yes | Yes | ---------------------------------------------------
Use el Servicio cuando solo necesite un objeto simple como un Hash, por ejemplo {foo; 1, bar: 2} Es fácil de codificar, pero no puede crear una instancia.
Utilice Factory cuando necesite crear una instancia de un objeto, es decir, nuevo Cliente (), nuevo Comentario (), etc.
Utilice Provider cuando necesite configurarlo. es decir, url de prueba, url de control de calidad, url de producción.
Si descubre que está devolviendo un objeto en fábrica, probablemente debería usar el servicio.
No hagas esto
app.factory(''CarFactory'', function() {
return {
numCylinder: 4
};
});
Use servicio en su lugar:
app.service(''CarService'', function() {
this.numCylinder = 4;
});