Mis vahe on AngularJSis tehase ja teenuse vahel ning millal tuleks neid kõiki kasutada?


Vastus 1:
angular.service ('apiService', apiServiceFunction);
nurgeline.factory ('apiFactory', apiFactoryFunction);

Ma arvan, et see küsimus on olnud umbes alates tehase ja teenuse loomisest AngularJS-is. See on võib-olla kõige rohkem küsitud ja vaieldav küsimus. Lühidalt, mõlemad on üksikud ja peaaegu üks ja sama hoiatus:

Tehas: kutsutakse meie loodud tehasefunktsioon (konstruktor).

apiFactoryInjected <--- apiFactoryFunction ()

Teenus: teenuse funktsioon, millest me kirjutame, realiseerub (uus)

  apiServiceInjected <---- uus apiFactoryFunction ()

Segadus? Noh, vaadake järgmist artiklit: AngularJS teenus vs tehas - näiteks


Vastus 2:

Tehase ja teenuse erinevus on täpselt nagu funktsiooni ja objekti erinevus

Tehase pakkuja

  • Annab meile funktsiooni tagastamisväärtuse st. Te lihtsalt loote objekti, lisate sellele atribuudid ja tagastate sama objekti. Kui teenus oma kontrollerile üle antakse, on need objekti atribuudid selles kontrolleris teie tehase kaudu nüüd saadaval. (Hüpoteetiline stsenaarium) Kasutada võib ka muid sõltuvusi, mida tavaliselt kasutatakse juhul, kui teenuse esinemisjuhis nõuab keerulist loomise loogikatKasutatav mittekonfigureeritavate teenuste jaoksKui kasutate mõnda objekti, võiksite kasutada tehase pakkujat.Süntaks: moodul.factory ('tehaseNimi', funktsioon);

Teenusepakkuja

  • Annab meile funktsiooni (objekti) eksemplari - te lihtsalt kohendasite märksõnaga „uus” ja lisate atribuudid sellele ja teenus tagastab selle „.” Kui edastate teenuse oma kontrollerile, siis need omadused sisse lülitatud „see” on nüüd teie teeninduse kaudu sellel kontrolleril saadaval. (Hüpoteetiline stsenaarium) Selle märksõna abil saate teenuseobjektile atribuute ja funktsioone lisada .Sõltuvusi sisestatakse ehitajaargumentidenaKasutatakse lihtsa loomise loogika jaoksKui kasutate klassi, võiksite kasutada teenusepakkujatSyntax: module.service ('serviceName', function );

Ühised jooned

  • Singleton ja see luuakse ainult üks kordKasutatavat komponentiKasutatakse kontrollerite vaheliseks suhtluseks andmete jagamiseks. Funktsiooni .config () ei tohi sisestada.

allikas (ilus selgitus) - AngularJS: tehas ja teenindus?

Lisateave - Teenus vs tehas - ükskord ja kõik

loodan, et see aitab !!


Vastus 3:

Vean kihla, et paremat seletust ei saa olla kui see!

Oota mida? Järjekordne postitus / artikkel, mis vastab suurele küsimusele: Teenus vs tehas, mida ma peaksin kasutama? Jah, tundub, et seda pole enam vaja, kuna Internetis on palju ressursse, mis seda teemat arutavad. Selgub, et see küsimus ilmub endiselt igal nädalal või erinevatel kanalitel ja isegi pärast StackOverflow kümne parima vastuse lugemist pole see ikkagi päris selge. Vaatamata sellele näib ka, et praegused veebiressursid ei edenda tegelikult parimat tava, eriti kui arvestada veebiplatvormi hiljutisi liikumisi. ES6 Ma vaatan sind!

See artikkel selgitab lõplikult teenuste ja tehaste erinevust ning seda, miks me tahame eelistada teenuseid tehastele.

SISUKORD

  • Erinevus teenuste ja vabrikute vahelKeski kasutada? Teenused võimaldavad meil kasutada ES6 klasse

Erinevus teenuste ja tehaste vahel

Olgu, mis vahe on AngularJS-is teenuse ja tehase vahel? Nagu me kõik teame, võime teenuse määratleda järgmiselt:

app.service ('MyService', funktsioon () {
  this.sayHello = funktsioon () {
    console.log ('tere');
  };
});

.service () on meetod meie moodulil, mis võtab teenuse määratlemiseks nime ja funktsiooni. Päris otse edasi. Kui see on määratletud, saame seda konkreetset teenust süstida ja kasutada ka muudesse komponentidesse, näiteks kontrolleritesse, direktiividesse ja filtritesse:

app.controller ('AppController', funktsioon (MyService) {
  MyService.sayHello (); // logib 'tere'
});

Olgu, selge. Nüüd sama mis tehases:

app.factory ('MyService', funktsioon () {
  tagastama {
    sayHello: function () {
      console.log ('tere');
    }
  }
});

Jällegi .factory () on meetod meie moodulis ja see võtab ka nime ja funktsiooni, mis määratlevad tehase. Saame seda asja süstida ja kasutada täpselt samamoodi nagu teenusega. Mis siin vahet on?

Noh, võite näha, et selle asemel, et teha seda tööd tehases, tagastame objekti sõnasõnaliselt. Miks nii? Selgub, et teenus on ehitaja funktsioon, tehas aga mitte. Kuskil selle nurkmaailma sees on see kood, mis kutsub teenuse Object.create () teenuskonstruktori funktsiooniga esile, kui see kiirendatakse. Kuid tehasefunktsioon on tegelikult lihtsalt funktsioon, mida kutsutakse, mistõttu peame objekti selgesõnaliselt tagastama.

Selle natuke selgemaks tegemiseks võime lihtsalt heita pilgu nurga lähtekoodile. Funktsioon factory () näeb välja järgmine:

funktsioon tehas (nimi, tehaseFn, jõustamine) {
  tagastamise pakkuja (nimi, {
    $ saada: jõustada! == vale? ForceceReturnValue (nimi, factoryFn): factoryFn
  });
}

See võtab nime ja tehasfunktsiooni, mis on üle antud, ja tagastab põhimõtteliselt samanimelise pakkuja, kellel on $ get meetod, mis on meie tehase funktsioon. Mis siis selle pakkuja asjaga on? Noh, alati, kui küsite injektorilt konkreetset sõltuvust, küsib ta põhimõtteliselt vastavalt pakkujalt selle teenuse esinemist, helistades meetodile $ get (). Seetõttu on teenusepakkujate loomisel vajalik $ get ().

Teisisõnu, kui süstime MyService'i kuhugi, siis kulisside taga juhtub järgmine:

MyServiceProvider. $ Get (); // tagastab teenuse eksemplari

Olgu, tehasefunktsioonidele helistatakse lihtsalt, aga kuidas on hoolduskoodiga? Siin on veel üks katkend:

funktsiooniteenus (nimi, ehitaja) {
  tagasta tehas (nimi, ['$ injector', funktsioon ($ injector) {
    return $ injector.instantiate (konstruktor);
  }]);
}

Vaata, selgub, et kui helistame teenindusele (), siis helistab see tegelikult tehasele (). Kuid see ei tähenda lihtsalt meie teenuse ehitaja funktsiooni tehasesse üleandmist, nagu see on. See läbib funktsiooni, mis palub injektoril antud konstrukatori poolt silmapilgutada ja objekte esitada. Teisisõnu: teenus kutsub etteantud tehase, mis lõppeb vastaval teenusepakkujal meetodiga $ get (). $ injector.instantiate () on meetod, mis kutsub kokku konstruktori funktsiooniga Object.create (). Seetõttu kasutame seda teenustes.

Olgu, nii selgub, et hoolimata sellest, mida me kasutame, teenust () või tehast (), loob see alati tehase, mida nimetatakse, mis loob meie teenuse pakkuja. Mis viib meid nurgaajaloo kõige sagedamini küsitud küsimuseni: millist peaksin kasutama?

Kumba kasutada?

Selle küsimuse Internetis küsimine viib meid paari artikli juurde ja StackOverflow vastab. Esimene on see vastus. See ütleb:

"Põhimõtteliselt on teenuse ja tehase erinevus järgmine:"

app.service ('myService', funktsioon () {

  // teenus on vaid konstruktori funktsioon
  // mida hakatakse kasutama koos uuega

  this.sayHello = funktsioon (nimi) {
     tagasta "Tere" + nimi + "!";
  };
});

app.factory ('myFactory', funktsioon () {

  // tehas tagastab objekti
  // võite mõnda koodi enne käivitada

  tagastama {
    sayHello: funktsioon (nimi) {
      tagasta "Tere" + nimi + "!";
    }
  }
});

Nüüd teame juba, mis kulisside taga toimub, kuid see vastus lisab veel ühe kommentaari. Selles öeldakse, et enne koodi sõnasõnalise tagastamise saab koodi käivitada. Põhimõtteliselt võimaldab see meil teha mõnda konfiguratsioonitoimingut või tinglikult luua objekti või mitte, mis teenuse teenuse loomisel ei tundu olevat võimalik, mistõttu soovitab enamik ressursse kasutada tehased teenuste asemel, kuid arutluskäik on mõistmatu.

Mis siis, kui ma teile ütleksin, saame sama teha ka teenustega?

Jah, õige. Teenus on siiski konstruktorifunktsioon, mis ei takista meid täiendavat tööd tegemast ja objektide tähtkuju tagastamast. Tegelikult võivad JavaScripti konstruktorifunktsioonid tagastada kõik, mida nad tahavad. Seega võime võtta meie teenuse koodi ja kirjutada nii, et see teeks põhimõtteliselt täpselt sama tööd nagu meie tehas:

app.service ('MyService', funktsioon () {

  // saaksime siin ka lisatööd teha
  tagastama {
    sayHello: function () {
      console.log ('tere');
    };
  }
});

Hoppla, mis nüüd saab? Mõistsime lihtsalt, et sõltuvalt sellest, kuidas me oma teenuseid kirjutame, pole nende kahe vahel enam vahet. Suur küsimus jääb: millist peaksime kasutama?

Teenused võimaldavad meil kasutada ES6 klasse

Muidugi on sellisel viisil kirjutamisteenused omamoodi kontraproduktiivsed, kuna neid nimetatakse konstruktorifunktsiooniks, seega tuleks neid ka ühe moodi kasutada. Kas on siis üldse mingit eelist teise ees? Jah seal on. Selgub, et ES6-le migreerumisel on tegelikult parem teenuseid kasutada kui vähegi võimalik. Selle põhjuseks on lihtsalt see, et teenus on ehitaja funktsioon ja tehas mitte. ES5 konstruktorifunktsioonidega töötamine võimaldab meil ES6-le üleminekul hõlpsalt kasutada ES6-klasse.

Näiteks võime võtta meie koodi ja selle ES6-s ümber kirjutada järgmiselt:

klassi MyService {
  ütle Tere() {
    console.log ('tere');
  }
}

app.service ('MyService', MyService);

ES6-klass on ES5-s tõesti vaid konstruktorifunktsioon. Kirjutasime sellest teemas ES6 kasutamisel koos Angulariga, kui te pole seda artiklit veel lugenud, soovitaksin seda kontrollida.

Tehastes pole see võimalik, kuna neid nimetatakse lihtsalt funktsioonideks. Loodetavasti tegi see artikkel kõik selgeks ja julgustab inimesi mitte kasutama tehaseid teenuste asemel, kui nad ei tea, mida kasutada.


Vastus 4:

Tehase Vs teenus?

Okei, alustame põhitõdedest

Nurga all on sisseehitatud teenused, sealhulgas "teenused" ja "tehased"

Tehases loote objekti, lisate sellele atribuudid ja tagastate sama objekti.

Teeninduses ei loo te objekti selgesõnaliselt, Angularjs piltide abil ta kulisside taha "uue" märksõnaga konstrueerib objekti põhimõtteliselt koos konstruktorifunktsiooniga.

Segadus? Võimaldab seda selle näitega lihtsustada.

app.service ('myService', serviceFunction)

app.factory ('myFactory', tehasefunktsioon)

var serviceFunction = function () {

// siin saate sellele funktsioonile väärtused määrata kasutades seda märksõna

// kulisside taga, nurk kuulutab var seda = {}

this.name = ”abc teenusest”,

// tagastage see

}

var factoryFunction = function () {

var someObject = {}

someObject.name = ”abc tehasest”;

return someObject.name;

}

rakendusekontroller ('myCtrl', funktsioon (myService, myFactory) {

console.log (“Data from Service”, myService) // o / p serviceFunction: {“nimi”: "abc teenusest"}

console.log (“Andmed tehasest”, myFactory) // o / p “tehas abc

})

nii et põhimõtteliselt teeninduses tagastab see kaudselt kogu funktsiooni eksemplari ... kuid tehases saate tagastada mis iganes soovite ... nii et teil on tehases rohkem kontrolli kui teenusel.

Loodetavasti annab see teile väikese ettekujutuse, kuidas teenused ja tehas erinevad.

soovi korral võite küsida täiendavaid selgitusi.


Vastus 5:

Täname A2A eest. Erinevusi pole tegelikult palju. Võite teha sama asja mõlemas. Siiski soovitaksin teil kinni pidada teenustest. Kuna JavaScript liigub "klassitaoliste" struktuuride poole, on teenused parim tava. Näiteks kui teil oli teenus ja funktsioon ületatud, on see funktsioon tegelikult klass. Niisiis, kui eemaldaksite nurga oma projektist, saaksite ikkagi teenusest kõike kasutada.


Vastus 6:

Erinevus teenuste ja tehaste vahel

Olgu, mis vahe on AngularJS-is teenuse ja tehase vahel? Nagu me kõik teame, võime teenuse määratleda järgmiselt:

app.service ('MyService', funktsioon () {
  this.sayHello = funktsioon () {
    console.log ('tere');
  };
});

.service () on meetod meie moodulil, mis võtab teenuse määratlemiseks nime ja funktsiooni. Päris otse edasi. Kui see on määratletud, saame seda konkreetset teenust süstida ja kasutada ka muudesse komponentidesse, näiteks kontrolleritesse, direktiividesse ja filtritesse:

app.controller ('AppController', funktsioon (MyService) {
  MyService.sayHello (); // logib 'tere'
});

Olgu, selge. Nüüd sama mis tehases:

app.factory ('MyService', funktsioon () {
  tagastama {
    sayHello: function () {
      console.log ('tere');
    }
  }
});

Jällegi .factory () on meetod meie moodulis ja see võtab ka nime ja funktsiooni, mis määratlevad tehase. Saame seda asja süstida ja kasutada täpselt samamoodi nagu teenusega. Mis siin vahet on?

Noh, võite näha, et selle asemel, et teha seda tööd tehases, tagastame objekti sõnasõnaliselt. Miks nii? Selgub, et teenus on ehitaja funktsioon, tehas aga mitte. Kuskil selle nurkmaailma sees on see kood, mis kutsub teenuse Object.create () teenuskonstruktori funktsiooniga esile, kui see kiirendatakse. Kuid tehasefunktsioon on tegelikult lihtsalt funktsioon, mida kutsutakse, mistõttu peame objekti selgesõnaliselt tagastama.

Selle natuke selgemaks tegemiseks võime lihtsalt heita pilgu nurga lähtekoodile. Funktsioon factory () näeb välja järgmine:

funktsioon tehas (nimi, tehaseFn, jõustamine) {
  tagastamise pakkuja (nimi, {
    $ saada: jõustada! == vale? ForceceReturnValue (nimi, factoryFn): factoryFn
  });
}

See võtab nime ja tehasfunktsiooni, mis on üle antud, ja tagastab põhimõtteliselt samanimelise pakkuja, kellel on $ get meetod, mis on meie tehase funktsioon. Mis siis selle pakkuja asjaga on? Noh, alati, kui küsite injektorilt konkreetset sõltuvust, küsib ta põhimõtteliselt vastavalt pakkujalt selle teenuse esinemist, helistades meetodile $ get (). Seetõttu on teenusepakkujate loomisel vajalik $ get ().

Teisisõnu, kui sisestame teenuse MyServicesomewhere, toimub kulisside taga järgmine:

MyServiceProvider. $ Get (); // tagastab teenuse eksemplari

Olgu, tehasefunktsioonidele helistatakse lihtsalt, aga kuidas on hoolduskoodiga? Siin on veel üks katkend:

funktsiooniteenus (nimi, ehitaja) {
  tagasta tehas (nimi, ['$ injector', funktsioon ($ injector) {
    return $ injector.instantiate (konstruktor);
  }]);
}

Vaata, selgub, et kui helistame teenindusele (), siis helistab see tegelikult tehasele (). Kuid see ei tähenda lihtsalt meie teenuse ehitaja funktsiooni tehasesse üleandmist, nagu see on. See läbib funktsiooni, mis palub injektoril antud konstrukatori poolt silmapilgutada ja objekte esitada. Teisisõnu: teenus kutsub etteantud tehase, mis lõppeb vastaval teenusepakkujal meetodiga $ get (). $ injector.instantiate () on meetod, mis kutsub kokku konstruktori funktsiooniga Object.create (). Seetõttu kasutame seda teenustes.


Vastus 7:

Nurga JS tegeleb probleemide eraldamisega. Selleks toetub ta teenuse arhitektuurile. Selles on toodud mõned sisseehitatud funktsioonid, näiteks $ location, $ http jne. Igale funktsioonile on määratud ainsus. Need on sisseehitatud teenused, mille eesliideks on $ märk. Kuid kui soovime luua oma teenuse, siis kasutame teenuse meetodit. Nii et teenuse meetod on API, mida kasutatakse funktsioonide loomiseks. Neid kutsutakse käitustõmmisse. Teisest küljest pole tehases kasutatav meetod teenusarhitektuuri kasutamiseks veel üks võimalus, see võib teha tööd, mis tehakse teenusmeetodi abil, kuid see pole sarnane teenusmeetodiga. fcatory meetod loob objekte erinevalt teenusest, mis on meetodite loomise API. Mõistagem seda näitega.

funktsioon getClass ($ http) {
  this.getClass = funktsiooni toomine () {
    tagasta $ http.get ('class.htm');
  };
}

nurgeline
  .module ('rakendus')
  .teenus ('getClass', getClass);
funktsioon getClass ($ http) {
  return {// tagastab objekti
    fetch: function () {// selles objektis määratletud fuction
      tagasta $ http.get ('class.htm');
    }
  };
}
nurgeline
  .module ('rakendus')
  .factory ('getClass', getClass);

Vastus 8:

Nurga JS tegeleb probleemide eraldamisega. Selleks toetub ta teenuse arhitektuurile. Selles on toodud mõned sisseehitatud funktsioonid, näiteks $ location, $ http jne. Igale funktsioonile on määratud ainsus. Need on sisseehitatud teenused, mille eesliideks on $ märk. Kuid kui soovime luua oma teenuse, siis kasutame teenuse meetodit. Nii et teenuse meetod on API, mida kasutatakse funktsioonide loomiseks. Neid kutsutakse käitustõmmisse. Teisest küljest pole tehases kasutatav meetod teenusarhitektuuri kasutamiseks veel üks võimalus, see võib teha tööd, mis tehakse teenusmeetodi abil, kuid see pole sarnane teenusmeetodiga. fcatory meetod loob objekte erinevalt teenusest, mis on meetodite loomise API. Mõistagem seda näitega.

funktsioon getClass ($ http) {
  this.getClass = funktsiooni toomine () {
    tagasta $ http.get ('class.htm');
  };
}

nurgeline
  .module ('rakendus')
  .teenus ('getClass', getClass);
funktsioon getClass ($ http) {
  return {// tagastab objekti
    fetch: function () {// selles objektis määratletud fuction
      tagasta $ http.get ('class.htm');
    }
  };
}
nurgeline
  .module ('rakendus')
  .factory ('getClass', getClass);

Vastus 9:

Nurga JS tegeleb probleemide eraldamisega. Selleks toetub ta teenuse arhitektuurile. Selles on toodud mõned sisseehitatud funktsioonid, näiteks $ location, $ http jne. Igale funktsioonile on määratud ainsus. Need on sisseehitatud teenused, mille eesliideks on $ märk. Kuid kui soovime luua oma teenuse, siis kasutame teenuse meetodit. Nii et teenuse meetod on API, mida kasutatakse funktsioonide loomiseks. Neid kutsutakse käitustõmmisse. Teisest küljest pole tehases kasutatav meetod teenusarhitektuuri kasutamiseks veel üks võimalus, see võib teha tööd, mis tehakse teenusmeetodi abil, kuid see pole sarnane teenusmeetodiga. fcatory meetod loob objekte erinevalt teenusest, mis on meetodite loomise API. Mõistagem seda näitega.

funktsioon getClass ($ http) {
  this.getClass = funktsiooni toomine () {
    tagasta $ http.get ('class.htm');
  };
}

nurgeline
  .module ('rakendus')
  .teenus ('getClass', getClass);
funktsioon getClass ($ http) {
  return {// tagastab objekti
    fetch: function () {// selles objektis määratletud fuction
      tagasta $ http.get ('class.htm');
    }
  };
}
nurgeline
  .module ('rakendus')
  .factory ('getClass', getClass);

Vastus 10:

Nurga JS tegeleb probleemide eraldamisega. Selleks toetub ta teenuse arhitektuurile. Selles on toodud mõned sisseehitatud funktsioonid, näiteks $ location, $ http jne. Igale funktsioonile on määratud ainsus. Need on sisseehitatud teenused, mille eesliideks on $ märk. Kuid kui soovime luua oma teenuse, siis kasutame teenuse meetodit. Nii et teenuse meetod on API, mida kasutatakse funktsioonide loomiseks. Neid kutsutakse käitustõmmisse. Teisest küljest pole tehases kasutatav meetod teenusarhitektuuri kasutamiseks veel üks võimalus, see võib teha tööd, mis tehakse teenusmeetodi abil, kuid see pole sarnane teenusmeetodiga. fcatory meetod loob objekte erinevalt teenusest, mis on meetodite loomise API. Mõistagem seda näitega.

funktsioon getClass ($ http) {
  this.getClass = funktsiooni toomine () {
    tagasta $ http.get ('class.htm');
  };
}

nurgeline
  .module ('rakendus')
  .teenus ('getClass', getClass);
funktsioon getClass ($ http) {
  return {// tagastab objekti
    fetch: function () {// selles objektis määratletud fuction
      tagasta $ http.get ('class.htm');
    }
  };
}
nurgeline
  .module ('rakendus')
  .factory ('getClass', getClass);