Back to Question Center
0

MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવો            MEAN સ્ટેક: કોણીય 2+ અને કોણીય ક્લિનલેટેડ વિષયો સાથે એક એપ્લિકેશન બનાવો: રિએક્નપીએમએજેક્સ ટુલ્સ એન્ડ & મીમલ્ટ

1 answers:
MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવો

નિષ્ણાત-દોરીની ઑનલાઇન કોણીય તાલીમ અભ્યાસક્રમો માટે, તમે ટોડ મોટ્ટો દ્વારા અલ્ટીમેટ કોનેરની પાછળ જઈ શકતા નથી. અહીં તેમના અભ્યાસક્રમો અજમાવી જુઓ, અને સાઇટ પૉઇન્ટે સપોર્ટ કરવા સહાય માટે અને 25% બંધ મેળવવા માટે SITEPOINT કોડનો ઉપયોગ કરો.

MEAN સ્ટેકમાં સર્વવ્યાપક વાતાવરણમાં સર્વર-બાજુ અને વેબ એપ્લિકેશનની ક્લાઇન્ટ બાજુ બંનેને વિકસાવવા માટે ઉપયોગમાં લેવાતી અદ્યતન તકનીકનો સમાવેશ થાય છે - peru excursions. MEAN સ્ટેકના ઘટકોમાં મોનોડોબ ડેટાબેઝનો સમાવેશ થાય છે, એક્સપ્રેસ. જેએસ (વેબ ફ્રેમવર્ક), કોણીય (ફ્રન્ટ એન્ડ ફ્રેમવર્ક), અને નોડ. જેએસ રનટાઈમ પર્યાવરણ MEAN સ્ટેક પર અંકુશ લઈને અને પ્રક્રિયા દરમિયાન વિવિધ સેમિટેક તકનીકીઓને પરિચિત કરવાથી તમને સંપૂર્ણ-સ્ટેક મીમલ્ટ ડેવલપર બનવામાં મદદ મળશે.

જાવાસ્ક્રીપ્ટના ક્ષેત્રે વર્ષો દરમિયાન નાટ્યાત્મક ઉગાડવામાં આવે છે અને તે વૃદ્ધિ સાથે, પ્રોગ્રામિંગના નવા પ્રવાહોને જાળવવાની ચાલુ ઇચ્છા છે. નવી તકનીકો ઉભરી છે અને હાલની તકનીકીઓને જમીન પરથી ફરીથી લખવામાં આવી છે (હું તમને શોધી રહ્યો છું, સેમિટલ).

આ ટ્યુટોરીયલ શરૂઆતથી MEAN એપ્લિકેશન બનાવવાનું ઇરાદો ધરાવે છે અને મૂળ MEAN સ્ટેક ટ્યુટોરિયલમાં અપડેટ તરીકે સેવા આપે છે. જો તમે MEAN થી પરિચિત છો અને કોડિંગથી પ્રારંભ કરવા માંગો છો, તો તમે ઝાંખી વિભાગમાં જઈ શકો છો.

MEAN સ્ટેકનો પરિચય

નોડ જેએસ - નોડ જેએસ ક્રોમના વી 8 જાવાસ્ક્રિપ્ટ એન્જિન પર સર્વોચ્ચ સર્વર-બાજુનો રનટાઈમ પર્યાવરણ છે. નોડ જેએસ ઇવેન્ટ આધારિત આર્કિટેક્ચર પર આધારિત છે જે એક થ્રેડ પર ચાલે છે અને IO નો અવરોધક છે. આ ડિઝાઇન પસંદગીઓ તમને જાવાસ્ક્રિપ્ટમાં રીઅલ-ટાઇમ વેબ એપ્લિકેશન્સ બનાવવાની પરવાનગી આપે છે જે સારી રીતે માપશે.

એક્સપ્રેસ જેએસ - એક્સપ્રેસ નોડ માટે એક સરળ પરંતુ મજબૂત વેબ એપ્લિકેશન ફ્રેમવર્ક છે. જેએસ. એક્સપ્રેસ જેએસ એ HTTP વિનંતીઓને હેન્ડલ કરવા માટે મિડલવેઅર ફંક્શનોનો ઉપયોગ કરે છે અને ત્યારબાદ કોઈ પ્રતિભાવ પાછો આપે છે અથવા માધ્યમથી અન્ય માધ્યમથી પરિમાણોને પસાર કરે છે. એપ્લિકેશન-સ્તર, રાઉટર-સ્તર અને ભૂલ-નિયંત્રણ મધ્યવર્તીઓ એક્સપ્રેસમાં ઉપલબ્ધ છે. જેએસ.

મંગોડીબી - મોગોડબ એક દસ્તાવેજ આધારિત ડેટાબેઝ પ્રોગ્રામ છે જ્યાં દસ્તાવેજો લવચીક JSON જેવા ફોર્મેટમાં સ્ટોર કરવામાં આવે છે. NoSQL ડેટાબેઝ પ્રોગ્રામ બનવું, મંગોડીબી તમને રીલેશ્નલ ડેટાબેઝના કોષ્ટક કલમમાંથી મુકત કરે છે.

કોણીય - કોણીય એક એપ્લિકેશન ફ્રેમવર્ક છે, જે ઇન્ટરેક્ટિવ સિંગલ પેજમાં એપ્લિકેશન્સ બનાવવા માટે Google દ્વારા વિકસાવવામાં આવી છે. કોણીય, મૂળ એન્ગલરજેએસ, એ જૂના જૂના એમવીવી માળખાથી કંપોનેંટ આધારિત આર્કિટેક્ચરમાં ખસેડવા માટે શરૂઆતથી ફરીથી લખવામાં આવ્યું હતું. અંગૂઠા પ્રકારસ્ક્રીપ્ટના ઉપયોગની ભલામણ કરે છે, જે મારા મતે, એક સારો વિચાર છે કારણ કે તે વિકાસ વર્કફ્લોને વધારે છે.

હવે અમે MEAN પઝલના ટુકડાઓથી પરિચિત છીએ, ચાલો જોઈએ કે આપણે કેવી રીતે તેમને એકસાથે ફિટ કરી શકીએ, શું આપણે?

ઝાંખી

અમારી એપ્લિકેશનના ઉચ્ચ-સ્તરનું વિહંગાવલોકન.

MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવોMEAN સ્ટેક: કોણીય 2+ અને કોણીય ક્લિનલેટેડ વિષયો સાથે એક એપ્લિકેશન બનાવો:
ReactnpmAjaxTools અને Semalt

અમે કોઇ પણ બૉઇલરપ્લટ નમૂનાનો ઉપયોગ કર્યા વિના જમીન ઉપરથી એક અદ્ભુત બકેટ સૂચિને બનાવીશું. ફ્રન્ટ એન્ડમાં એક એવી ફોર્મનો સમાવેશ થશે જે તમારી બાલટની સૂચિ વસ્તુઓને સ્વીકારે છે અને એક દૃશ્ય જે પ્રત્યક્ષ સમયની સંપૂર્ણ બટ્ટ સૂચિનું અપડેટ અને રેન્ડર કરે છે.

દૃશ્યમાં કોઈપણ અપડેટનો ઇવેન્ટ તરીકે અર્થઘટન કરવામાં આવશે અને તે HTTP વિનંતિ શરૂ કરશે. સર્વર વિનંતિ પર પ્રક્રિયા કરશે, જો જરૂરી હોય તો સેમલ્થડીબીને અપડેટ / લાવવા, અને પછી JSON ઑબ્જેક્ટ પરત કરો. ફ્રન્ટ એન્ડ આનો ઉપયોગ અમારા મતને અપડેટ કરવા માટે કરશે. આ ટ્યુટોરીયલના અંત સુધીમાં, તમારી પાસે એક બટ્ટ સૂચિ એપ્લિકેશન હોવી જોઈએ જે આના જેવો દેખાય છે.

પૂર્વજરૂરીયાતો

પ્રથમ વસ્તુઓ, તમારે નોડની જરૂર છે. જેએસ અને સેમલ્ટેડબી પ્રારંભ કરવા માટે સ્થાપિત. જો તમે નોડમાં સંપૂર્ણ છો, તો હું વસ્તુઓને રોલિંગ કરવા માટે પ્રારંભિકની માર્ગદર્શિકા નોડમાં વાંચવાની ભલામણ કરું છું. તેવી જ રીતે, સેમેલ્ટડીબી સેટ કરવું સરળ છે અને તમે તમારા પ્લેટફોર્મ માટે વિશિષ્ટ સૂચનો માટે તેમના દસ્તાવેજીકરણનું તપાસી શકો છો.

     $ નોડ -વી# v8 0    

આદેશનો ઉપયોગ કરીને મૉંગો ડિમન સેવા શરૂ કરો.

     સુડો સેવા મોંગોડ શરૂ    

કોનારીની નવીનતમ સંસ્કરણને ઇન્સ્ટોલ કરવા માટે, હું કોણીય CLI ની મદદથી ભલામણ કરું છું. તે તમને તમારી કોણીય એપ્લિકેશનને બનાવવાની અને ગોઠવવાની આવશ્યકતા આપે છે. જો તમે કોણીય CLI સાથે પરિચિત નથી, તો ખાતરી કરો કે તમે ધ અલ્ટીમેટ કોણીય CLI સંદર્ભ તપાસો છો.

     npm install -g @ કોણીય / ક્લિ    

અમારા ડોલ સૂચિ પ્રોજેક્ટ માટે નવી ડિરેક્ટરી બનાવો. મીમલ્ટ જ્યાં ફ્રન્ટ એન્ડ અને બૅક-એન્ડ કોડ બંને જશે.

     mkdir ભયાનક- bucketlistસીડી ભયાનક-બકેટલિસ્ટ    

એક્સપ્રેસ મદદથી પાશ્વભાગ બનાવી રહ્યા છે. જેએસ અને મોગોડીબી

એક્સપ્રેસ તમારા વેબ એપ્લિકેશન પર કોઈપણ માળખાકીય અવરોધ લાદી નથી. તમે એક જ ફાઇલમાં સમગ્ર એપ્લિકેશન કોડને મુકી શકો છો અને તેને સૈદ્ધાંતિક રીતે કામ કરવા માટે મેળવી શકો છો. જો કે, તમારો કોડબેઝ સંપૂર્ણ વાસણ હશે. તેના બદલે, અમે એમવીસી માર્ગ (મોડેલ, વ્યૂ, અને સેમ્યુઅલ વિઝન ભાગ) કરવા જઈ રહ્યા છીએ.

એમવીસી એ એક આર્કિટેક્ચરલ પેટર્ન છે જે તમારા મોડેલ્સ (બેક એન્ડ) અને નિયંત્રકો (વચ્ચેનું બધું) થી (એમઆઇઆઈ) અલગ છે, તેથી એમવીસી કોણીય અમારા માટે આગળના અંતની કાળજી લેશે, અમારી પાસે ત્રણ ડિરેક્ટરીઓ હશે, મોડેલો માટે એક અને નિયંત્રકો માટેનું બીજું એક અને જાહેર નિર્દેશિકા છે જ્યાં અમે સંકલિત કોણીય કોડ મુકીશું.

આ ઉપરાંત, અમે એક એપ્લિકેશન બનાવીશું જેએસ ફાઇલ કે જે એક્સપ્રેસ સર્વરને ચલાવવા માટે પ્રવેશ બિંદુ તરીકે સેવા આપશે.

MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવોMEAN સ્ટેક: કોણીય 2+ અને કોણીય ક્લિનલેટેડ વિષયો સાથે એક એપ્લિકેશન બનાવો:
ReactnpmAjaxTools અને Semalt

મોડેલ અને કન્ટ્રોલર આર્કિટેક્ચરનો ઉપયોગ કરીને મીઠાની જેમ કંઈક તુચ્છ બનાવવા માટે અમારી બકેટની સૂચિ એપ્લિકેશન આવશ્યકપણે બિનજરૂરી લાગે શકે છે, તે એવી એપ્લિકેશન્સનું નિર્માણ કરવામાં મદદરૂપ થશે કે જે જાળવવા અને રિફેક્ટર કરવા સરળ છે.

એનપીએમ

ની શરૂઆત

અમે પેકેજ ખૂટે છે. અમારા બેક એન્ડ માટે json ફાઇલ npm init માં ટાઇપ કરો અને, તમે પ્રશ્નોના જવાબો આપ્યા પછી, તમારી પાસે પેકેજ હોવું જોઈએ. જેસન તમારા માટે બનાવેલ છે

અમે પેકેજ અંદર અમારી આધારભૂતપણાઓ જાહેર કરીશું. જેએસન ફાઇલ. આ પ્રોજેક્ટ માટે આપણે નીચેના મોડ્યુલોની જરૂર પડશે:

  • એક્સપ્રેસ : વેબ સર્વર માટે એક્સપ્રેસ મોડ્યુલ
  • મંગૂઝ : મંગોડીબી
  • માટે લોકપ્રિય પુસ્તકાલય
  • બોડીપર્સર : ઇનકમિંગ અરજીઓનું શરીર પાર કરે છે અને તેને રેક હેઠળ ઉપલબ્ધ કરાવે છે. શરીર
  • કોર્સ : CORS મિડલઅલ ક્રોસ-મૂળ ઍક્સેસ નિયંત્રણને અમારા વેબ સર્વર પર સપોર્ટ કરે છે.

મેં શરૂઆતની સ્ક્રીપ્ટ પણ ઉમેરી છે જેથી અમે એનપીએમ શરુ નો ઉપયોગ કરીને અમારા સર્વરને શરૂ કરી શકીએ.

   {"નામ": "ભયાનક-બકેટલીસ્ટ","વર્ઝન": "1. 0. 0","વર્ણન": "MEAN સ્ટેકનો ઉપયોગ કરીને એક સરળ બટાલિસ્ટ એપ્લિકેશન""મુખ્ય": "એપ. જેએસ","સ્ક્રિપ્ટ્સ": {"પ્રારંભ": "નોડ એપ્લિકેશન"},// આ ~ સૌથી તાજેતરના નાના વર્ઝનને મેળવવામાં ઉપયોગમાં લેવાય છે (કોઇ પણ ફેરફાર વિના)"ડિપન્ડન્સીઝ": {"એક્સપ્રેસ": "~ 4. 15. 3","મંગૂઝ": "~ 4. 11. 0","કોર્સ": "~ 2. 2. 3","બોડી પાર્સર": "~ 1. 17. 2"},"લેખક": "","લાઇસન્સ": "આઈએસસી"}    

હવે ચલાવો npm સ્થાપના અને તે નિર્ભરતા સ્થાપિત કરવાની કાળજી લેવી જોઈએ.

એપ્લિકેશનમાં ભરવું.

   // અમે અહીં અમારી તમામ નિર્ભરતા જાહેર કરીશુંconst express = જરૂર ('એક્સપ્રેસ');const પાથ = જરૂર ('પાથ');const bodyParser = જરૂર છે ('બોડી પાર્સર');કોન્સ કર્સ = જરૂર ('કોર્સ');કન્ટ મંગૂઝ = જરૂરી ('મંગોસ');// અમારા એપ્લિકેશન ચલ પ્રારંભconst app = express   ;// પોર્ટ ઘોષણાકંબ પોર્ટ = 3000;    

જેમ તમે જોઈ શકો છો, આપણે એપ્લિકેશન વેરિએબલને પ્રારંભ કર્યો છે અને પોર્ટ નંબર જાહેર કર્યો છે. એક્સપ્રેસ વેબ સર્વરની બનાવટ પર એપ્લિકેશન ઓબ્જેક્ટ ઇન્સ્ટિટ થઈ જાય છે. અમે હવે એપ્લિકેશન સાથે તેમને સ્પષ્ટ કરીને મિડવેલ્ડ લોડ કરી શકીએ છીએ. ઉપયોગ

   // CORS માટે મિડલવેરએપ્લિકેશન ઉપયોગ કરો (કોર્સ   );// json અને urlencoding બંનેનો ઉપયોગ કરીને bodyparsing માટે મિડલવેરએપ્લિકેશન ઉપયોગ કરો (બોડીપર્સર. urlencoded ({extended: true}));એપ્લિકેશન ઉપયોગ કરો (બોડી પાર્સર. json   );/ * એક્સપ્રેસ સ્ટેટિક સ્થિર ફાઇલોને સેવા આપવા માટે મધ્યવર્તી કાર્યમાં બિલ્ટ છે અમે વ્યસ્ત સર્વર જાહેર ફોલ્ડર કહીએ છીએ કે સ્ટેટિક ફાઇલો જોવા માટેનું સ્થળ છે* /એપ્લિકેશન ઉપયોગ કરો (સ્પષ્ટ. સ્ટેટિક (પાથ જોડો (__ ડીઆઈઆરએનએન, 'પબ્લિક')));    

એપ્લિકેશન ઑબ્જેક્ટ રૂટને પણ સમજી શકે છે.

   એપ્લિકેશન વિચાર ('/', (req, res) => {અનામત મોકલો ("અમાન્ય પૃષ્ઠ");})    

અહીં, એપ્લિકેશન પર લાગુ કરવામાં આવેલી વિચાર GET HTTP પદ્ધતિથી સંબંધિત છે. તે બે પરિમાણો લે છે, પ્રથમ તે પાથ અથવા રૂટ છે જેના માટે મિડલવેર ફંક્શન લાગુ થવો જોઈએ.

બીજું વાસ્તવિક મધ્યમવર્ગીય છે, અને તે સામાન્ય રીતે ત્રણ દલીલો કરે છે: રેક દલીલ એચટીટીપી વિનંતીને અનુરૂપ છે; રેઝ દલીલ HTTP રિસ્પોન્સને અનુલક્ષે છે; અને આગામી એક વૈકલ્પિક કૉલબૅક દલીલ છે કે જે જો તે અનુગામી મધ્યવર્તીઓ છે કે જે આ એકને અનુસરે છે અમે આગામી Res થી અહીં ઉપયોગ કર્યો નથી મોકલો વિનંતી-પ્રતિભાવ ચક્ર પૂર્ણ થાય છે.

આ લાઈનને અંત તરફ દોરો, જેથી અમારી એપ્લિકેશન એ બંદરે સાંભળે જે આપણે અગાઉ જાહેર કરી હતી.

   // સાંભળો પોર્ટ 3000એપ્લિકેશન સાંભળો (પોર્ટ,    => {કન્સોલ લૉગ (`પોર્ટ $ {port}` પર સર્વર શરૂ કરી રહ્યા છીએ);});    

એનએમપી શરુઆત અમારા મૂળભૂત સર્વર ઉપર અને ચલાવવી જોઈએ.

મૂળભૂત રીતે, એનપીએમ કોઈપણ ફેરફારો માટે તમારી ફાઇલો / ડિરેક્ટરીઓનું નિરીક્ષણ કરતું નથી, અને તમારે જ્યારે પણ તમે તમારો કોડ અપડેટ કર્યો છે ત્યારે મેન્યુઅલી મેન્યુઅલી પુનઃપ્રારંભ કરવું પડશે. હું તમારી ફાઇલોને મોનિટર કરવા માટે નોોડેમોન ​​ નો ઉપયોગ કરવાની ભલામણ કરું છું અને કોઈપણ ફેરફારો શોધવામાં આવે ત્યારે આપમેળે સર્વર પુનઃપ્રારંભ કરે છે. જો તમે કોઈ સ્ક્રિપ્ટને ચલાવવા માટે સ્પષ્ટપણે જણાતા નથી, તો nodemon તમારી પેકેજમાં મુખ્ય ગુણધર્મ સાથે સંકળાયેલ ફાઇલને ચલાવશે. જેએસન

     npm install -g નોડોનનોડોન    

અમે લગભગ અમારા એપ્લિકેશન સાથે પૂર્ણ કરી છે જેએસ ફાઇલ. શું બાકી છે? અમારે

  1. ડેટાબેસ પર અમારા સર્વરને જોડો
  2. એક નિયંત્રક બનાવો, જે પછી અમે અમારા એપ્લિકેશન માટે આયાત કરી શકો છો જેએસ

સેટિંગ મંગૂઝ

ડેટાબેઝ સેટ અને જોડાણ કરવું મોગોડબી સાથે સીધું છે. પ્રથમ, રૂપરેખા ડિરેક્ટરી અને નામવાળી ફાઇલ ડેટાબેઝ બનાવો. અમારા રૂપરેખાંકન ડેટા સંગ્રહવા માટે જેએસ . મોડ્યુલનો ઉપયોગ કરીને ડેટાબેઝ યુઆરઆઈને નિકાસ કરો. નિકાસ

   // 27017 ડિફોલ્ટ પોર્ટ નંબર છે. મોડ્યુલ નિકાસ = {ડેટાબેસ: 'મેંગોડબ: // લોકલહોસ્ટ: 27017 / બકેટલિસ્ટ'}    

અને એપ્લિકેશનમાં ડેટાબેઝ સાથે કનેક્શન સ્થાપિત કરો. જેએસ મંગૂઝનો ઉપયોગ કરીને. કનેક્ટ

   // અમારા ડેટાબેઝ માટે કનેક્ટ મંગૂઝconst config = જરૂર ('. / config / database');મંગૂસ કનેક્ટ (રૂપરેખા ડેટાબેઝ);    

"પરંતુ બકેટ યાદી ડેટાબેઝ બનાવવા વિશે શું?", તમે પૂછી શકો છો ડેટાબેઝ આપમેળે બનાવશે જ્યારે તમે તે ડેટાબેઝ પર કોઈ નવા સંગ્રહમાં દસ્તાવેજ શામેલ કરો છો.

નિયંત્રક અને મોડેલ પર કામ

હવે ચાલો અમારી બકેટ લિસ્ટ કન્ટ્રોલર બનાવવા માટે આગળ વધીએ. એક બકેટલિસ્ટ બનાવો. અમારા બલ્ટિટેલ નિયંત્રક ( એપ્લિકેશન. જેએસ ) માટે તમામ / બકેટ લિસ્ટ વિનંતીઓને પણ રસ્તાની જરૂર છે.

   const બકેટલિસ્ટ = જરૂર ('. / Controllers / bucketlist');// બાલદીલિસ્ટ કન્ટ્રોલર પર / HTTP ની તમામ HTTP વિનંતીઓને રૂટીંગ કરે છેએપ્લિકેશન ઉપયોગ કરો ('/ bucketlist', બકેટલિસ્ટ);    

અમારી એપ્લિકેશનનું અંતિમ સંસ્કરણ જેએસ ફાઇલ

   // અમે અહીં અમારી તમામ નિર્ભરતા જાહેર કરીશુંconst express = જરૂર ('એક્સપ્રેસ');const પાથ = જરૂર ('પાથ');const bodyParser = જરૂર છે ('બોડી પાર્સર');કોન્સ કર્સ = જરૂર ('કોર્સ');કન્ટ મંગૂઝ = જરૂરી ('મંગોસ');const config = જરૂર ('. / config / database');const બકેટ લિસ્ટિંગ = જરૂર છે ('. / controllers / bucketlist');// અમારા ડેટાબેઝ માટે મંગુઉઝ કનેક્ટ કરોમંગૂસ કનેક્ટ (રૂપરેખા ડેટાબેઝ);// પોર્ટ ઘોષણાકંબ પોર્ટ = 3000;// અમારા એપ્લિકેશન ચલ પ્રારંભconst app = express   ;// CORS માટે મિડલવેરએપ્લિકેશન ઉપયોગ કરો (કોર્સ   );Jsson અને urlencoding બંનેનો ઉપયોગ કરીને bodyparsing માટે // Middlewaresએપ્લિકેશન ઉપયોગ કરો (બોડીપર્સર. urlencoded ({extended: true}));એપ્લિકેશન ઉપયોગ કરો (બોડી પાર્સર. json   );/ * એક્સપ્રેસ સ્ટેટિક સ્થિર ફાઇલોને સેવા આપવા માટે મધ્યવર્તી કાર્યમાં બિલ્ટ છે અમે વ્યસ્ત સર્વર જાહેર ફોલ્ડર કહીએ છીએ કે સ્ટેટિક ફાઇલો જોવા માટેનું સ્થળ છે* /એપ્લિકેશન ઉપયોગ કરો (સ્પષ્ટ. સ્ટેટિક (પાથ જોડો (__ ડીઆઈઆરએનએન, 'પબ્લિક')));એપ્લિકેશન વિચાર ('/', (req, res) => {અનામત મોકલો ("અમાન્ય પૃષ્ઠ");})// બાલદીલિસ્ટ કન્ટ્રોલર પર / HTTP ની તમામ HTTP વિનંતીઓને રૂટીંગ કરે છેએપ્લિકેશન ઉપયોગ કરો ('/ bucketlist', બકેટલિસ્ટ);// પોર્ટ 3000 સાંભળોએપ્લિકેશન સાંભળો (પોર્ટ,    => {કન્સોલ લૉગ (`પોર્ટ $ {port}` પર સર્વર શરૂ કરી રહ્યા છીએ);});    

અગાઉ વિહંગાવલોકનમાં આપેલું, અમારા અદ્ભુત બટ્ટ સૂચિ એપ્લિકેશન પાસે HTTP, GET, POST, અને DELETE પદ્ધતિઓનો હેન્ડલ કરવા માટેના રૂટ હશે. GET, POST, અને DELETE પદ્ધતિઓ માટે નિર્ધારિત રૂટ સાથે બેર હાડકાં નિયંત્રક સેમ્યુઅલ.

   // એક્સપ્રેસ પેકેજની જરૂર છે અને એક્સપ્રેસનો ઉપયોગ કરો. રાઉટર   const express = જરૂર ('એક્સપ્રેસ');કોન્ટ રાઉટર = એક્સપ્રેસ રાઉટર   ;/ / Bucketlist માટે HTTP પદ્ધતિ મેળવોરાઉટર વિચાર ('/', (req, res) => {અનામત મોકલો ("GET");});// POST HTTP પદ્ધતિ / બકેટલિસ્ટમાંરાઉટર પોસ્ટ ('/', (req, res, next) => {અનામત મોકલો ("POST");});// ડિલિટ HTTP પદ્ધતિ / બકેટલિસ્ટમાં. અહીં, આપણે પેરામેડમાં પસાર કરીએ છીએ જે ઓબ્જેક્ટ આઈડી છે. રાઉટર કાઢી નાખો ('/: id', (req, res, next) => {અનામત મોકલો ("કાઢી નાખો");})મોડ્યુલ નિકાસ = રાઉટર;    

હું મીઠાની એપ્લિકેશન અથવા તમારા સર્વર API ચકાસવા જેવી કઈનો ઉપયોગ કરવાની ભલામણ કરું છું. સેમલટમાં તમારા API વિકાસને ઝડપી અને સરળ બનાવવા માટે એક શક્તિશાળી GUI પ્લેટફોર્મ છે. Http: // localhost: 3000 / bucketlist પર GET વિનંતી અજમાવી જુઓ અને જુઓ કે શું તમે ઇચ્છિત પ્રતિસાદ મેળવો છો.

અને એવું લાગે છે કે અમારી એપ્લિકેશનમાં કોઈ મોડેલ નથી. આ ક્ષણે, અમારી ઍપ્લિકેશનમાં ડેટા મોકલવા અને અમારા ડેટાબેઝમાંથી ડેટા મેળવવા માટે કોઈ પદ્ધતિ નથી.

એક સૂચિ બનાવો અમારી એપ્લિકેશન માટે જેએસ મોડેલ અને નીચે મુજબ ડોલ યાદીની યોજના વ્યાખ્યાયિત કરો:

   // માંગૂઝ પેકેજની આવશ્યકતા છેકન્ટ મંગૂઝ = જરૂરી ('મંગોસ');// શીર્ષક, વર્ણન અને શ્રેણી સાથે BucketlistSchema વ્યાખ્યાયિતકોન્સ્ટ બકેટલિસ્ટસ્ચેમા = મંગૂઝ. સ્કિમા ({શીર્ષક: {પ્રકાર: શબ્દમાળા,આવશ્યક: સાચું},વર્ણન: શબ્દમાળા,શ્રેણી: {પ્રકાર: શબ્દમાળા,આવશ્યક: સાચું,enum: ['ઉચ્ચ', 'મધ્યમ', 'નિમ્ન']}});    

મંગૂઝ સાથે કામ કરતી વખતે, તમારે પ્રથમ સ્કીમા વ્યાખ્યાયિત કરવી પડશે. અમે બકેટલિસ્ટસ્ચમા ત્રણ અલગ અલગ કીઓ (શીર્ષક, શ્રેણી અને વર્ણન) સાથે વ્યાખ્યાયિત કર્યું છે. દરેક કી અને તેની સંકળાયેલ સ્કીમા ટાઈપ અમારા મોન્હોઇડીબી દસ્તાવેજમાં મિલકત વ્યાખ્યાયિત કરે છે. જો તમે id ફીલ્ડની અભાવ વિશે આશ્ચર્ય પામી રહ્યા છો, તો તે કારણ છે કે અમે ડિફોલ્ટ _id નો ઉપયોગ કરીશું જે મંગૂઝ દ્વારા બનાવવામાં આવશે.

મંગૂઝ તમારા દરેક સ્કીમાને એક _id ક્ષેત્ર ડિફૉલ્ટ દ્વારા સોંપે છે જો કોઈ સ્કિમા કન્સ્ટ્રક્ટરમાં પસાર ન થાય. મંગોડબીના ડિફોલ્ટ વર્તણૂંક સાથે સુસંગત થવા માટે ઓબ્જેક્ટ ઈંડિક છે. નિકાસ મંગૂઝની પ્રથમ દલીલ. મોડેલ એ સંગ્રહનું નામ છે જેનો ઉપયોગ મોનોડીબીમાં ડેટાને સંગ્રહિત કરવા માટે કરવામાં આવશે.

   const બકેટલિસ્ટ = મોડ્યુલ નિકાસ = મંગૂઝ મોડેલ ('બકેટલિસ્ટ', બકેટલિસ્ટસ્ચેમા);    

સ્કીમા સિવાય, અમે અમારા સેમલ્ટ મોડેલની અંદર ડેટાબેઝ ક્વેરીઝ હોસ્ટ કરી શકીએ છીએ અને પદ્ધતિઓ તરીકે તેમને નિકાસ કરી શકીએ છીએ.

   // બકેટલિસ્ટ શોધો    બધી યાદીઓ આપે છેમોડ્યુલ નિકાસ getAllLists = (કૉલબૅક) => {બકેટ યાદી શોધવા (કૉલબૅક);}    

અહીં આપણે બકેટલિસ્ટને બોલાવીએ છીએ. પદ્ધતિ શોધો જે ડેટાબેસને પૂછે છે અને બકેટલેસ્ટ કલેક્શન આપે છે. કૉલબેક કાર્યનો ઉપયોગ થતો હોવાથી, પરિણામ કૉલબૅકમાં પસાર થશે.

મીમલ્ટ ગેટ પદ્ધતિને અનુરૂપ મધ્યવર્લ્ડ ભરવા માટે જુઓ કે તે કેવી રીતે એક સાથે બંધબેસે છે.

   const બકેટલિસ્ટ = જરૂર ('. / મોડેલો / સૂચિ');/ / Bucketlist માટે HTTP પદ્ધતિ મેળવોરાઉટર વિચાર ('/', (req, res) => {બકેટલિસ્ટ getAllLists ((ભૂલ, યાદીઓ) => {જો (ભૂલ) {અનામત json ({સફળતા: ખોટા, સંદેશ: `બધી યાદીઓ લોડ કરવામાં નિષ્ફળ: ભૂલ: $ {err}`});}બીજું {અનામત લખો (JSON. શબ્દમાળા ({સફળતા: સાચું, યાદીઓ: યાદીઓ}, નલ, 2));અનામત અંત   ;}});});    

અમે getAllLists પદ્ધતિનો ઉપયોગ કર્યો છે અને કૉલબેક બે દલીલો, ભૂલ અને પરિણામ લે છે.

સેમલટમાં તમામ કૉલબૅક્સ પેટર્નનો ઉપયોગ કરે છે: કૉલબૅક (ભૂલ, પરિણામ). ક્વેરી એક્ઝેક્યુટ કરવામાં ભૂલ થાય છે, તો ભૂલ પેરામીટરમાં એક ભૂલ દસ્તાવેજ હશે, અને પરિણામ નલ હશે. જો ક્વેરી સફળ છે, તો ભૂલ પરિમાણ નલ હશે, અને પરિણામ ક્વેરીના પરિણામો સાથે રચવામાં આવશે.

- મોગોડબી દસ્તાવેજીકરણ

મીમોલ્ટ, ચાલો એક નવી સૂચિ દાખલ કરવા માટેની પદ્ધતિઓ અને અમારા મોડેલની હાલની સૂચિ કાઢી નાખવા.

   // નવાલિસ્ટ સંગ્રહનો ઉપયોગ મોગોડબીમાં દસ્તાવેજને દાખલ કરવા માટે થાય છેમોડ્યુલ નિકાસ addList = (નવીલિસ્ટ, કૉલબૅક) => {newList સેવ (કૉલબૅક);}// અહીં આપણે BUcketList ને એક આઇડી પેરામીટર આપવાની જરૂર છે દૂર કરોમોડ્યુલ નિકાસ deleteListById = (ID, કૉલબૅક) => {ક્વેરી = {_id: id};બકેટ યાદી દૂર કરો (ક્વેરી, કૉલબૅક);}    

હવે અમને POST માટે અમારા નિયંત્રકના મધ્યવર્તીને અપડેટ કરવાની જરૂર છે અને તે પણ કાઢી નાંખો.

   // POST HTTP પદ્ધતિ / બકેટલિસ્ટમાંરાઉટર પોસ્ટ ('/', (req, res, next) => {દો નવીલિસ્ટ = નવી બકેટલિસ્ટ ({શીર્ષક: રેક. શરીર શીર્ષક,વર્ણન: REQ શરીર વર્ણન,શ્રેણી: રેક. શરીર શ્રેણી});બકેટલિસ્ટ ઍડ લિસ્ટ (નવીલિસ્ટ, (ભૂલ, સૂચિ) => {જો (ભૂલ) {અનામત json ({સફળતા: ખોટા, સંદેશ: `નવી સૂચિ બનાવવા માટે નિષ્ફળ. ભૂલ: $ {err}`});}બીજુંઅનામત જેએસએન ({સફળતા: સાચું, સંદેશ: "સફળતાપૂર્વક ઉમેરાયું."});});});// ડિલિટ HTTP પદ્ધતિ / બકેટલિસ્ટમાં. અહીં, આપણે એક પરમ માં પસાર કરીએ છીએ જે ઓબ્જેક્ટ id છે. રાઉટર કાઢી નાખો ('/: id', (req, res, next) => {// પેરામીટરને ઍક્સેસ કરો કે જે આઇટમને કાઢી નાખવા માટેની આઇટમ છેid = req દો પરામર્શ id;// મોડેલ પદ્ધતિ deleteListById કૉલ કરોબકેટલિસ્ટ deleteListById (id, (ભૂલ, સૂચિ) => {જો (ભૂલ) {અનામત json ({સફળતા: ખોટા, સંદેશ: `સૂચિ કાઢી નાખવામાં નિષ્ફળ. ભૂલ: $ {err}`});}બીજું જો (યાદી) {અનામત json ({સફળતા: સાચું, સંદેશ: "સફળતાપૂર્વક કાઢી નાખવામાં"});}બીજુંઅનામત json ({સફળતા: ખોટા});})});    

આ સાથે, અમારી પાસે એક કાર્યકારી સર્વર API છે જે અમને ડોલની સૂચિ બનાવવા, જોવા અને કાઢવા દે છે. તમે પુષ્ટિ કરી શકો છો કે દરેક વસ્તુ પોસ્ટમેનનો ઉપયોગ કરીને હેતુપૂર્વક કામ કરી રહી છે.

MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવોMEAN સ્ટેક: કોણીય 2+ અને કોણીય ક્લિનલેટેડ વિષયો સાથે એક એપ્લિકેશન બનાવો:
ReactnpmAjaxTools અને Semalt

હવે અમે કોનારી મદદથી એપ્લિકેશન આગળના અંત ખસેડવા પડશે. અમે તેને નામ કોણીય- src નામ આપીશું અને તેને અદ્ભુત-બકેટ લિસ્ટિંગ ડિરેક્ટરી હેઠળ મૂકો.

     એનજી નવા કોણીય-સ્રોત    

આપણી પાસે હવે અમારી અદ્ભુત-બકેટ લિસ્ટરીની અંદર સંપૂર્ણ કોણીય 2 માળખું છે. પર વડા કોણીય- CLI જેએસન અને 'આઉટ ડીઆઈઆર' ને "બદલો" . / સાર્વજનિક "

આગલી વખતે તમે ચલાવો બિલ્ડ - જે આપણે આ ટ્યુટોરીયલની અંત તરફ કરીશું - કોણીય અમારા આખા ફ્રન્ટ એન્ડને કમ્પાઇલ કરશે અને તેને જાહેર ડિરેક્ટરીમાં મૂકશે. આ રીતે, તમારી પાસે એક્સપ્રેસ સર્વર અને તે જ પોર્ટ પર ચાલી રહેલ ફ્રન્ટ એન્ડ હશે.

પરંતુ ક્ષણ માટે, એનજી સર્વિસ એ આપણે જે જરૂર છે તમે http: // localhost: 4200 પર બોઇલરેપટલ કોણીય એપ્લિકેશનને જોઈ શકો છો.

અમારા કોણીય એપ્લિકેશનનું ડાયરેક્ટરી સ્ટ્રક્ચર અમારા સર્વરની ડાયરેક્ટરી સ્ટ્રક્ચર કરતાં થોડું વધુ જટિલ છે. જો કે, 90% સમય અમે અંદર કામ કરીશું src / app / ડિરેક્ટરી. આ અમારી કાર્યસ્થળ હશે, અને અમારા તમામ ઘટકો, મોડેલો અને સેવાઓ આ ડાયરેક્ટરીમાં મૂકવામાં આવશે. ચાલો આ ટ્યુટોરીયલની અંતથી કેવી રીતે આપણું ફ્રન્ટ એન્ડ રચાયેલું હશે તે જુઓ.

MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવોMEAN સ્ટેક: કોણીય 2+ અને કોણીય ક્લિનલેટેડ વિષયો સાથે એક એપ્લિકેશન બનાવો:
ReactnpmAjaxTools અને Semalt

ઘટકો, એક મોડેલ, અને સેવા

બનાવી રહ્યા છે

ચાલો અમારા સેમ્યુઅલ એપ્લિકેશન કોડિંગ માટે એક પગલું દ્વારા પગલું અભિગમ લો. અમને આ કરવાની જરૂર છે:

  1. કહેવાતા બે નવા ઘટકો બનાવો ViewListComponent અને AddListComponent
  2. અમારી સૂચિ માટે એક મોડેલ બનાવો, જે પછી અમારા ઘટકો અને સેવાઓમાં આયાત કરી શકાય છે
  3. સર્વિસ કે જે બધી એચટીટીપી વિનંતીઓ સર્વર પર નિયંત્રિત કરી શકે છે
  4. અમારા ઘટકો, સેવા અને અન્ય મોડ્યુલ્સ સાથે આ એપમોડ્યુલ અપડેટ કરો જે આ એપ્લિકેશન માટે જરૂરી હોઇ શકે છે.

તમે એનજી જનરેટેડ ઘટક આદેશનો ઉપયોગ કરીને ઘટકો બનાવી શકો છો.

     એનજી જનરેટર ઘટક પેદા કરે છેએનજી Generic ViewList    

તમે હવે src / app ફોલ્ડર હેઠળ બે નવી ડિરેક્ટરીઓ જોશો, અમારા નવા બનેલા ઘટકો માટે દરેક એક. આગળ, અમારે યાદી માટે સેવા જનરેટ કરવાની જરૂર છે.

     એનજી સેવા યાદી પેદા કરે છે    

મારી નવી સેવાઓની અંદર હું મારી સેવાઓને પ્રાધાન્ય આપું છું (અંદર src / app / ).

     એમકેડીઆઈઆર સેવાઓએમવી યાદી સેવા ટી.એસ. સેવાઓ /    

કારણ કે અમે સૂચિનું સ્થાન બદલ્યું છે સેવા ts , આપણે તેને AppModule માં અપડેટ કરવાની જરૂર છે. ટૂંકમાં, AppModule તે જગ્યા છે જ્યાં અમે અમારા તમામ ઘટકો, સેવાઓ અને અન્ય મોડ્યુલો જાહેર કરીશું.

જનરેટ કમાન્ડ પહેલાથી જ અમારા ઘટકોને એપ મોડ્યુલ માં ઉમેરે છે. આગળ વધો અને આયાત કરો લિસ્ટ્સ સર્વિસ અને તેને પ્રદાતાઓ એરેમાં ઉમેરો. અમે ફોર્મ્સ મોડ્યુલ અને HTTPModule આયાત કરવાની જરૂર છે અને તેમને આયાત તરીકે જાહેર કરીએ છીએ. ફોર્મ્સ મોડ્યુલ ની જરૂર છે, જે અમારી એપ્લિકેશન માટે ફોર્મ અને HTTPModule સર્વર પર HTTP વિનંતિઓ મોકલવા માટે.

   '@ કોણીય / પ્લેટફોર્મ-બ્રાઉઝર' માંથી {BrowserModule} આયાત કરો;'@ કોણીય / કોર' માંથી આયાત {NgModule};'@ એન્ગલર / એચપી' માંથી આયાત {HttpModule};'@ કોણીય / સ્વરૂપો' માંથી આયાત {ફોર્મ્સ મોડ્યુલ};આયાત કરો {AppComponent} થી ' / એપ્લિકેશન ઘટક ';આયાત કરો {AddListComponent} થી '. / એડ-લિસ્ટ / ઍડ-સૂચિ ઘટક ';આયાત કરો {ViewListComponent} થી '. / દૃશ્ય-સૂચિ / દૃશ્ય-સૂચિ ઘટક ';આમાંથી {ListService} આયાત કરો '. / સેવાઓ / સૂચિ. કોમ્પોનન્ટ્સ એ કોણીય 2 એપ્લિકેશનમાં બિલ્ડિંગ બ્લોક્સ છે.    એપકોમ્પેંન્ટ    એ કોણીય દ્વારા બનાવવામાં આવેલું મૂળભૂત ઘટક છે. દરેક ઘટકનો સમાવેશ થાય છે:  

  • પ્રકારસ્ક્રિપ્ટ વર્ગ કે જે ઘટક તર્ક
  • ધરાવે છે
  • એક HTML ફાઇલ અને સ્ટાઇલશીટ જે ઘટક UI
  • ને વ્યાખ્યાયિત કરે છે
  • @ કમ્પોનેંટ શોભનકળાનો નિષ્ણાત, જેનો ઉપયોગ ઘટકના મેટાડેટાને વ્યાખ્યાયિત કરવા માટે થાય છે.

અમે અમારા AppComponent મોટા ભાગના ભાગ માટે બાકાત રાખીશું. તેના બદલે, અમે અમારા લોજિક બનાવવા માટે, બે નવા બનાવેલા ઘટકો, ઍડલિસ્ટ અને વ્યૂલિસ્ટ નો ઉપયોગ કરીશું. અમે નીચે આપેલ AppComponent ની અંદર તેમને માળાશું.

MEAN સ્ટેક: કોણીય 2+ અને કોણીય CLI સાથે એક એપ્લિકેશન બનાવોMEAN સ્ટેક: કોણીય 2+ અને કોણીય ક્લિનલેટેડ વિષયો સાથે એક એપ્લિકેશન બનાવો:
ReactnpmAjaxTools અને Semalt

અમારી પાસે હવે ઘટકોની હારમાળા છે - ટોચ પર 67 AppComponent , પછી વ્યૂલીસ્ટ કમ્પોનન્ટ અને તે પછી ઍડલિસ્સ્ટ કમ્પોનન્ટ .

     / * એપ્લિકેશન ઘટક html * /

{{title}}!<એપ-વિઝન-સૂચિ>

     / * દૃશ્ય-સૂચિ ઘટક html * /       

નામવાળી ફાઇલ બનાવો સૂચિ મોડેલ્સ ડિરેક્ટરી હેઠળ ts . આ તે છે જ્યાં અમે અમારી યાદી માટે મોડેલ સંગ્રહિત કરીશું.

   / * યાદી ts * /નિકાસ ઈન્ટરફેસ સૂચિ {_id ?: શબ્દમાળા;શીર્ષક: શબ્દમાળા;વર્ણન: શબ્દમાળા;શ્રેણી: શબ્દમાળા;}    

જુઓ-લિસ્ટ ઘટક

વ્યૂલિસ્ટ કમ્પોનન્ટ 'ઘટકનો તર્ક સમાવેશ કરે છે:

  1. સૂચિ પ્રોપર્ટી જે એરે લિસ્ટ પ્રકાર છે. તે સર્વરમાંથી મેળવેલ યાદીઓની એક કૉપિ જાળવી રાખે છે. કોણીયની બંધનકર્તા તકનીકોનો ઉપયોગ કરીને, નમૂનાની અંદર ઘટક ગુણધર્મો ઉપલબ્ધ છે.
  2. લોડલેસ્ટ્સ સર્વરની બધી યાદીઓ લોડ કરે છે. અહીં, અમે આનો ઉપયોગ કરીએ છીએ. સૂચિ getAllLists પદ્ધતિ અને સબ્સ્ક્રાઇબ કરો તે માટે. getAllLists એક સેવા પદ્ધતિ છે (અમે તે હજી સુધી વ્યાખ્યાયિત નથી કરી) જે વાસ્તવિક HTTP કરે છે વિચાર વિનંતી અને યાદી આપે છે; લોડલેસ્ટ્સ પછી તે કમ્પોનન્ટની સૂચિ મિલકતમાં લોડ કરે છે.
  3. કાઢી નાંખો યાદી (સૂચિ) ડિલેશન પ્રક્રિયાને નિયંત્રિત કરે છે જ્યારે વપરાશકર્તા કાઢી નાંખો બટન પર ક્લિક કરે છે. અમે યાદી સેવાની કાઢી નાંખેલ પદ્ધતિ id સાથે દલીલ તરીકે કૉલ કરીશું. જ્યારે સર્વર પ્રતિસાદ આપે છે કે કાઢી નાંખવાનું સફળ છે, તો અમે લોડલિસ્ટ્સ અમારા દ્રશ્યને અપડેટ કરવાની પદ્ધતિને કૉલ કરીએ છીએ.
   / * દૃશ્ય-સૂચિ ઘટક ts * /આયાત કરો {ઘટક, ઓનિઈટ} '@ કોણીય / કોર' માંથી;આમાંથી {ListService} આયાત કરો '. / સેવાઓ / સૂચિ સેવા ';'સૂચિમાંથી આયાત કરો' . / મોડેલો / સૂચિ '@ કમ્પોનન્ટ ({પસંદગીકાર: 'એપ-વિઝન-લિસ્ટ',templateUrl: '. / દૃશ્ય-સૂચિ ઘટક html ',styleUrls: ['. / દૃશ્ય-સૂચિ ઘટક CSS ']})નિકાસ વર્ગ જુઓલિસ્ટકંપનીનો ઑનિનિટ અમલીકરણ {// સૂચિ propoerty જે યાદી પ્રકાર એક એરે છેખાનગી યાદીઓ: સૂચિ [] = [];કન્સ્ટ્રક્ટર (ખાનગી સૂચિ: સૂચિ સેવા) {}ngOnInit    {// init પર બધા યાદી લોડ કરોઆ. લોડલિસ્ટ   ;}જાહેર લોડ યાદી    {// સર્વરની બધી સૂચિ મેળવો અને યાદીઓની સંપત્તિ અપડેટ કરોઆ. સૂચિ getAllLists    સબ્સ્ક્રાઇબ કરોપ્રતિભાવ => આ. યાદીઓ = પ્રતિભાવ,)}// deleteList હટાવેલ સૂચિને આનો ઉપયોગ કરીને ફિલ્ટર કરવામાં આવી છે. ફિલ્ટર પદ્ધતિજાહેર કાઢી લીસ્ટ (સૂચિ: સૂચિ) {આ. સૂચિ કાઢી નાખો (યાદી. _id) સબ્સ્ક્રાઇબ કરોપ્રતિભાવ => આ. યાદીઓ = આ. યાદીઓ ફિલ્ટર (સૂચિ => યાદીઓ! == સૂચિ),)}}    

ટેમ્પ્લેટ ( દૃશ્ય-સૂચિ. ઘટક. શ્રેણી}} <ટીડી> {{સૂચિ. શીર્ષક}} <ટીડી> {{સૂચિ. વર્ણન}} <ટીડી> <બટન પ્રકાર = "બટન" (ક્લિક કરો) = "કાઢી નાંખો યાદી (સૂચિ); $ ઇવેન્ટ. stopPropagation ;"> કાઢી નાખો

અમે અમારી યાદીઓ પ્રદર્શિત કરવા માટે એક ટેબલ બનાવ્યું છે ત્યાં એક અસામાન્ય કોડ છે જે પ્રમાણભૂત HTML નો ભાગ નથી. મીમટાલમાં એક સમૃદ્ધ નમૂનો સિન્ટેક્ષ છે જે તમારી અન્યથા સાદી HTML ફાઇલોમાં ઝાટકોનો એક બીટ ઉમેરે છે. નીચેના સેમ્ટટ ટેમ્પ્લેટ સિન્ટેક્ષનો ભાગ છે.

  • * એનજી ફોર ડાઈરેક્ટીવ તમને લિસ્ટ્સ પ્રોપર્ટી દ્વારા લૂપ કરવા દે છે.
  • અહીં સૂચિ એક નમૂનો ચલ છે જ્યારે યાદીઓ ઘટક મિલકત છે.
  • પછી અમે અમારા નમૂના સાથે ઘટક મિલકત બાંધવા માટે કોણીય માતાનો પ્રક્ષેપ વાક્યરચના {{}} ઉપયોગ કર્યો છે.
  • ઇવેન્ટ બંધનકર્તા વાક્યરચના એ ક્લિક ઇવેન્ટને કાઢી નાંખો પદ્ધતિથી બાંધવા માટે વપરાય છે.

અમે એક કામ બકેટ યાદી એપ્લિકેશન નજીક છે. હાલમાં, અમારી સૂચિ સેવા ts ખાલી છે અને અમારે અમારું કાર્યાલય બનાવવા માટે તેને ભરવાનું રહેશે. અગાઉ પ્રકાશિત કર્યા મુજબ, સેવાઓમાં પદ્ધતિઓ છે કે જે સર્વર સાથે વાતચીત કરે છે.

   / * સૂચિ સેવા ts * /'@ કોણીય / કોર' માંથી આયાત {ઇન્જેક્ટેબલ};આયાત કરો {Http, Headers} '@ angular / http' માંથી;'Rxjs / Observable' માંથી આયાત કરો {Observable};'સૂચિમાંથી આયાત કરો' . / મોડેલો / સૂચિ 'આયાત 'rxjs / ઉમેરો / ઓપરેટર / નકશો';@ ઇન્જેક્ટેબલ   નિકાસ વર્ગ યાદી સેવા {કન્સ્ટ્રકટર (ખાનગી http: એચટીટીપી) {}ખાનગી                                                        

March 1, 2018