Back to Question Center
0

જૅસ્ટનો ઉપયોગ કરીને ઘટકોને કેવી રીતે ચકાસવું તે ચકાસવું            JestRelated વિષયોનો ઉપયોગ કરીને ઘટકોને કેવી રીતે ચકાસવું: નોડ.જેએસનપૅમરાયોલ

1 answers:
જૅસ્ટનો ઉપયોગ કરીને ઘટકોને કેવી રીતે ચકાસવું?

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

આ લેખ મહેમાન લેખક દ્વારા છે જેક ફ્રેન્કલીન . સાઇટપોઇન્ટ ગેસ્ટ પોસ્ટ્સનો હેતુ તમને જાવાસ્ક્રિપ્ટ કોમ્યુનિટીના જાણીતા લેખકો અને સ્પીકરોમાંથી સામગ્રીને આકર્ષિત કરવાનું છે.

આ લેખમાં, અમે અમારા રૅક્ટજેએસ ઘટકો ચકાસવા - ફેસબુક દ્વારા સંચાલિત પરીક્ષણ માળખું - જેસ્ટનો ઉપયોગ કરવા પર એક નજર કરીશું. અમે કેવી રીતે જૅસ્ટનો પ્રથમ સાદા જાવાસ્ક્રિપ્ટ વિધેયો પર પ્રથમ ઉપયોગ કરી શકીએ તે જોઈશું, તે કેટલીક વિશેષતાઓને જોતાં તે ચોક્કસપણે ચકાસણી કરવાના હેતુથી બોક્સની બહાર પ્રદાન કરે છે, એપ્લિકેશન્સને સરળ બનાવવું તે નોંધવું જરુરી છે કે જેસ્ટ ખાસ કરીને પ્રતિક્રિયામાં લક્ષ્ય નથી: તમે તેનો ઉપયોગ કોઈપણ જાવાસ્ક્રિપ્ટ એપ્લિકેશન્સને ચકાસવા માટે કરી શકો છો - casino free chips. જો કે, તે કેટલીક સુવિધાઓ વિશિષ્ટ વપરાશકર્તા ઈન્ટરફેસની ચકાસણી કરવા માટે ખરેખર ઉપયોગી છે, તેથી તે પ્રતિક્રિયા સાથે એક મહાન ફિટ છે.

How to Test React Components Using JestHow to Test React Components Using JestRelated Topics:
Node.jsnpmRaw Semalt

નમૂના એપ્લિકેશન

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

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

એપ્લિકેશનનો પ્રવેશ બિંદુ એપ્લિકેશન / ઇન્ડેક્સ છે. જેએસ , જે ફક્ત ટોડોસ ઘટકને એચટીએમએલમાં અનુવાદ કરે છે:

   રેન્ડર (,દસ્તાવેજ getElementById ('એપ્લિકેશન'));    

ટોડોસ ઘટક એ એપ્લિકેશનનો મુખ્ય કેન્દ્ર છે. આમાં તમામ રાજ્ય (આ એપ્લિકેશન માટે હાર્ડ-કોડેડ ડેટા છે, જે વાસ્તવમાં API અથવા તેનાથી સમાન હશે), અને બે બાળક ઘટકોને રેન્ડર કરવા માટેનો કોડ છે: ટોડો , જે એકવાર માટે પ્રસ્તુત છે રાજ્યમાં દરેક dodo, અને AddTodo , જે એક વખત રેન્ડર કરવામાં આવે છે અને વપરાશકર્તાને એક નવું todo ઉમેરવા માટે ફોર્મ પૂરું પાડે છે.

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

છેલ્લે, હમણાં, તમે જોશો કે તમામ કારોબારી તર્ક ઍપ / સ્ટેટ ફંકશન્સમાં સમાયેલ છે જેએસ :

   નિકાસ કાર્ય ટૉગલ થઈ ગયું (રાજ્ય, id) {. }નિકાસ કાર્ય addTodo (રાજ્ય, todo) {. }નિકાસ કાર્ય deleteTodo (રાજ્ય, id) {. }    

આ તમામ શુદ્ધ કાર્યો છે જે રાજ્ય અને કેટલાક ડેટા લે છે, અને નવા રાજ્યને પરત કરે છે. જો તમે શુદ્ધ કાર્યોથી અજાણ્યા હોવ તો, તે કાર્યો છે જે ફક્ત સંદર્ભ માહિતીને આપવામાં આવે છે અને કોઈ આડઅસરો નથી. વધુ માટે, તમે શુદ્ધ કાર્યો પર મારા યાદી પર મારા લેખ વાંચી શકો છો અને શુદ્ધ કાર્યો અને પ્રતિક્રિયા વિશે SitePoint પર મારો લેખ.

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

ટીડીડી માટે ટીડીડી કે નહીં?

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

નોંધ કરો કે આ લેખ ફ્રન્ટ એન્ડ કોડના પરીક્ષણ પર ધ્યાન કેન્દ્રિત કરશે. જો તમે પાછળના ભાગ પર ધ્યાન કેન્દ્રિત કર્યું હોય તેવા કોઈ વસ્તુની શોધ કરી રહ્યાં હોવ તો, નોડમાં સાઇટપૉઇન્ટના અભ્યાસક્રમના ટેસ્ટ-ડ્રીવેન ડેવલોપમેન્ટને તપાસવાની ખાતરી કરો. જેએસ.

પરિચય જેસ્ટ

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

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

જેસ્ટ સ્થાપિત અને રૂપરેખાંકિત

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

     npm સ્થાપિત --save-dev બેબલ-જૅસ્ટ બેબલ-પોલીફિલ બેબલ-પ્રીસેટ-એસ2015 બેબલ-પ્રીસેટ-પ્રતિક્રિયા પ્રત્યુત્તર    

તમારી પાસે પણ એક હોવું જરૂરી છે. બેબલ્રક બૅબેલ સાથેની ફાઇલ જે તમને જરૂર છે તે કોઈપણ પ્રીસેટ્સ અને પ્લગિન્સનો ઉપયોગ કરવા માટે ગોઠવેલી છે. નમૂના પ્રોજેક્ટમાં પહેલેથી જ આ ફાઇલ છે, જે આના જેવી લાગે છે:

   {"પ્રીસેટ્સ": ["es2015", "પ્રતિક્રિયા"]}    

અમે કોઈ પણ સેમ્યુઅલ ટેસ્ટિંગ ટૂલ્સ હજી સ્થાપિત કરીશું નહીં, કારણ કે અમે અમારા ઘટકોની ચકાસણી સાથે પ્રારંભ કરવા જઈ રહ્યા નથી, પરંતુ અમારા સ્ટેટ વિધેયો

જેસ્ટ __tests__ ફોલ્ડરમાં અમારા પરીક્ષણો શોધવાની અપેક્ષા રાખે છે, જે જાવાસ્ક્રિપ્ટ કોમ્યુનિટીમાં એક લોકપ્રિય સંમેલન બની ગયું છે, અને તે એક છે જે અમે અહીં વળગી રહ્યા છીએ જો તમે __tests__ સેટઅપના ચાહક નથી, તો બોક્સની બહાર જૅસ્ટ કોઈપણ ને શોધવામાં સપોર્ટ કરે છે. પરીક્ષણ જેએસ અને સ્પેક જેએસ ફાઇલો પણ.

આપણે અમારા રાજ્ય વિધેયોનું પરીક્ષણ કરીશું, આગળ વધો અને __ટૅટ્સ __ / સ્ટેટ-ફંક્શન્સ બનાવો. પરીક્ષણ જેએસ

મિમેલ્ટ ટૂંક સમયમાં યોગ્ય પરીક્ષણ લખશે, પરંતુ હવે, આ ડમી પરીક્ષણમાં મૂકવામાં આવ્યું છે, જે અમને યોગ્ય રીતે કામ કરી રહ્યું છે તે તપાસ કરશે અને અમારી પાસે જેસ્ટ રૂપરેખાંકિત છે.

   વર્ણન ('ઉમેરો',    => {તે ('જાણે છે કે 2 અને 2 બનાવો 4',    => {અપેક્ષા (2 + 2) toBe  
;});});

હવે, તમારા પેકેજમાં વડા. જેસન .

   "સ્ક્રિપ્ટ્સ": {"ટેસ્ટ": "મજા"}    

જો તમે હવે સ્થાનિક રીતે એનએમપી પરીક્ષણ ચલાવો છો, તો તમારે તમારા પરીક્ષણો ચલાવવા જોઈએ, અને પસાર થવું જોઈએ!

     PASS __tests __ / રાજ્ય કાર્યો. પરીક્ષણ જેએસવધુમાં✓ જાણે છે કે 2 અને 2 બનાવો 4 (5 એમ)ટેસ્ટ સુવિધા: 1 પસાર થઈ, 1 કુલટેસ્ટ: 1 પાસ, કુલ 1સ્નેપશોટ: 0 પસાર, કુલ 0સમય: 3. 11 સે    

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

જ્યારે વાસ્તવિક દાવાઓ કરવા માટે આવે છે, ત્યારે તમે અપેક્ષા કૉલની અંદર જે વસ્તુને તમે ચકાસવા માંગો છો તે લપેટી તે પહેલાં તેના પર દાવો કરો. આ કિસ્સામાં, અમે toBe નો ઉપયોગ કર્યો છે. તમે જેસ્ટ દસ્તાવેજોમાં ઉપલબ્ધ બધા દાવાઓની સૂચિ મેળવી શકો છો. tobe ચકાસે છે કે આપેલ મૂલ્ય ચકાસણી હેઠળ મૂલ્ય સાથે મેળ ખાય છે, === આમ કરવા માટે. આ ટ્યુટોરીયલ દ્વારા અમે જેસ્ટના કેટલાક દાવાઓ પૂરી કરીશું.

પરીક્ષણ વ્યાપાર તર્કશાસ્ત્ર

હવે અમે જેસ્ટ એક ડમી પરીક્ષણ પર કામ કર્યું છે, ચાલો તેને વાસ્તવિક એક પર ચલાવીએ! અમે અમારા રાજ્ય વિધેયોની પ્રથમ ચકાસવા જઈ રહ્યા છીએ, ટૉગલડૉન . ટૉગલડૉન વર્તમાન સ્થિતિ અને એક ટોડોની ID લે છે જે અમે ટૉગલ કરવા માંગીએ છીએ. દરેક TODO પાસે પૂર્ણ થયેલી પ્રોપર્ટી છે અને ટોગલટૉન તેને સાચી થી ખોટા , અથવા વાઇસ-વરન્સથી સ્વેપ કરવી જોઈએ.

જો તમે આની સાથે અનુસરી રહ્યાં છો, તો ખાતરી કરો કે તમે રેપોને ક્લોન કર્યો છે અને એપ્લિકેશન ફોલ્ડરને તમારી ડાયરેક્ટરીમાં નકલ કરી છે જે તમારી ___ટેસ્ટેસ_ ફોલ્ડર ધરાવે છે. તમારે ટૂંકા પેકેજ ( npm ઇન્સ્ટોલ શૉર્ટિડ --save ) ઇન્સ્ટોલ કરવાની જરૂર છે, જે ટોડો એપ્લિકેશનની નિર્ભરતા છે.

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

ઉદાહરણ તરીકે, અહીં હું કેવી રીતે પુનરાવર્તિત વર્ણન અને તે કોલ્સ સાથે તે પરીક્ષણ લખીશ:

   આયાત કરો {toggleDone} from '. / ઍપ / સ્ટેટ ફન્કન્સ ';વર્ણન ('ટૉગલ કર્યું',    => {વર્ણવે છે ('જ્યારે અપૂર્ણ તક આપવામાં આવેલ',    => {તે ('પૂર્ણ રૂપે પૂરું કરે છે',    => {});});});    

અને અહીં હું કેવી રીતે ટેસ્ટ સાથે કરીશ:

   આયાત કરો {toggleDone} from '. / ઍપ / સ્ટેટ ફન્કન્સ ';કસોટી ('ટૉગલ કરવાનું અપૂર્ણ અનોખું પૂર્ણ કરે છે',    => {});    

ટેસ્ટ હજુ સરસ રીતે વાંચે છે, પરંતુ હવે તે રીતે મેળવવામાં ઓછું ધ્યાન છે. આ એક મુખ્યત્વે વ્યક્તિગત પસંદગી માટે નીચે છે; તમે જેની સાથે વધુ આરામદાયક છો તે શૈલી પસંદ કરો.

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

   const startState = {todos: [{id: 1, પૂર્ણ: ખોટા, નામ: 'દૂધ ખરીદો'}]};const finState = ટૉગલ કરો (શરૂઆતનો સમય, 1);અપેક્ષા (ફાઈનસ્ટેટ. todos) toEqual ([{id: 1, પૂર્ણ: સાચું, નામ: 'દૂધ ખરીદો'}]);    

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

તેની સાથે આપણે હવે એનએમપી પરીક્ષણ ચલાવી શકીએ છીએ અને અમારા સ્ટેટ ફંક્શન ટેસ્ટ પાસ જુઓ:

     PASS __tests __ / રાજ્ય કાર્યો. પરીક્ષણ જેએસ✓ ટુગ્લેડોન એક અપૂર્ણ ટ્યુડો સમાપ્ત કરે છે (9 એમએસ)ટેસ્ટ સુવિધા: 1 પસાર થઈ, 1 કુલટેસ્ટ: 1 પાસ, કુલ 1સ્નેપશોટ: 0 પસાર, કુલ 0સમય: 3. 166 સે    

ફેરફારો પર સવારી ટેસ્ટ

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

તેને વૉચ મોડમાં ચલાવવા માટે, તમે એનએમપી પરીક્ષણ - - રન કરી શકો છો. જે કંઈપણ તમે એનપીએમ પરીક્ષણ પ્રથમ પછી પસાર - સીધા અંતર્દેશીય આદેશ સુધી પસાર કરવામાં આવશે. આનો અર્થ એ છે કે આ બે આદેશો અસરકારક રીતે સમકક્ષ છે:

  • એનએમપી ટેસ્ટ - - વોચ
  • જુસ્સો - વોચ

હું ભલામણ કરું છું કે તમે બાકીના આ ટ્યુટોરીયલ માટે, બીજા ટેબમાં જૅસ્ટ ચાલવાનું છોડો, અથવા ટર્મિનલ બારી

પ્રતિક્રિયા ઘટકોને પરીક્ષણ પર ખસેડતા પહેલા, અમે અમારા અન્ય કાર્યોમાંના બીજા એક પર એક વધુ પરીક્ષણ લખીશું. વાસ્તવિક એપ્લિકેશનમાં હું વધુ પરીક્ષણો લખીશ, પરંતુ ટ્યુટોરીયલ માટે હું તેમાંના કેટલાકને છોડી દઈશ. હમણાં માટે, ચાલો એક કસોટી લખીએ જે ખાતરી કરે છે કે અમારા ડિલટોડો ફંક્શન કાર્ય કરે છે. હું કેવી રીતે નીચે લખ્યું છે તે પહેલાં, તેને જાતે લખવાનો પ્રયાસ કરો અને જુઓ કે તમારી ટેસ્ટ કેવી રીતે સરખાવે છે.

મને ટેસ્ટ

બતાવો

યાદ રાખો કે આયાત આયાત માટે ટોચ પર સ્ટેટમેન્ટ અપડેટ કરવું પડશે ડિલટોડો સાથે ટૉગલ ટોડો :

   આયાત {toggleTodo, deleteTodo} 'થી' . / ઍપ / સ્ટેટ ફન્કન્સ ';     

અને અહીં કેવી રીતે સેમ્ટટ ટેસ્ટમાં લખેલ છે:

   કસોટી ('ડિલિટડો ટેડોને તેને આપવામાં આવે છે',    = & gt; {const startState = {todos: [{id: 1, પૂર્ણ: ખોટા, નામ: 'દૂધ ખરીદો'}]};const finState = deleteTodo (સ્ટાર્ટસ્ટેટ, 1);અપેક્ષા (ફાઈનસ્ટેટ. todos) toEqual ([]);});    

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

ઉપરોક્ત પરીક્ષણો પરીક્ષણ માટે સંપૂર્ણ લેઆઉટનું નિદર્શન કરે છે, જે:

  • સેટ અપ
  • પરીક્ષણ હેઠળ કાર્ય ચલાવો
  • પરિણામો પર ભાર મૂકે છે

આ રીતે પરીક્ષણો રાખીને, તમે તેને અનુસરવા અને સાથે કામ કરવા માટે સરળ મળશે.

હવે અમે અમારા રાજ્ય વિધેયોની ચકાસણી કરવા ખુશ છીએ, ચાલો આપણે સેમ્યુઅલ ઘટકો પર આગળ વધીએ.

પરીક્ષણ ઘટકો પરીક્ષણ

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

     npm સ્થાપિત --save-dev પ્રતિક્રિયા-એડનોન્સ-ટેસ્ટ-ઉબઈ એન્ઝાઇમ    

ચાલો આપણે જોઈએ કે ટોડો ઘટક ફકરોની અંદર તેના ટૂંકોના લખાણને રેંજ કરે છે. પ્રથમ અમે બનાવશું __tests __ / todo પરીક્ષણ જેએસ , અને અમારા ઘટક આયાત:

   આયોજક ટોડો 'થી. / એપ્લિકેશન / ટુડો ';આયાત 'પ્રતિક્રિયા' પર પ્રતિક્રિયા;'એન્ઝાઇમ' માંથી આયાત કરો {માઉન્ટ};પરીક્ષણ ('ટોડો કમ્પોનન્ટ ટોડોના લખાણને રેન્ડર કરે છે',    => {});    

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

આપણે ટોડો :

બનાવવા માટે માઉન્ટ નો ઉપયોગ કરી શકીએ છીએ.
   કન્ટ ટુડો = {id: 1, પૂર્ણ: ખોટા, નામ: 'દૂધ ખરીદો'};const wrapper = માઉન્ટ ();    

અને પછી અમે રેપર કૉલ કરી શકો છો. શોધવા , તેને સીએસએસ પસંદગીકાર આપવું, ફકરો શોધવા માટે કે અમે Todo ના ​​લખાણ સમાવવાની અપેક્ષા રાખીએ છીએ. આ API તમને jQuery ની યાદ કરાવે છે, અને તે ડિઝાઇન દ્વારા છે બંધબેસતા તત્વો શોધવા માટે રેન્ડર આઉટપુટની શોધ માટે તે ખૂબ જ સાહજિક API છે.

   const p = આવર શોધો ('ટૉગલ-ટુડો');    

અને છેલ્લે, આપણે કહી શકીએ છીએ કે તે અંદરના ટેક્સ્ટ છે દૂધ ખરીદો :

   અપેક્ષા (પી. ટેક્સ્ટ) ટુબે ('દૂધ ખરીદો');    

સેમલ્ટે આપણી સમગ્ર કસોટીને આ રીતે જુએ છે:

   આયોજક ટોડો 'થી. / એપ્લિકેશન / ટુડો ';આયાત 'પ્રતિક્રિયા' પર પ્રતિક્રિયા;'એન્ઝાઇમ' માંથી આયાત કરો {માઉન્ટ};પરીક્ષણ ('TodoComponent તે અંદરની ટેક્સ્ટ રેન્ડર કરે છે',    => {const todo = {id: 1, પૂર્ણ: ખોટા, નામ: 'દૂધ ખરીદો'};const wrapper = માઉન્ટ ();const p = આવર શોધો ('ટૉગલ-ટુડો');અપેક્ષા (પી. ટેક્સ્ટ) ટુબે ('દૂધ ખરીદો');});    

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

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

આ કસોટીમાં આપણે ભારપૂર્વક કહીએ છીએ કે જ્યારે ટોડો ક્લિક કરવામાં આવે છે, ત્યારે ઘટક થાય છે ચેન્જ પ્રોપે કે તેને આપવામાં આવે છે.

   કસોટી ('ટૉડો કૉલ્સ કરેલો બદલાવો ત્યારે ક્લિક કરો',    => {});    

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

   સ્થાનાંતરિત = ફેરફાર કરો fn   ;    

આ એક ફંક્શન આપે છે જેના પર અમે જાસૂસી કરી શકીએ છીએ અને ખાતરી કરી શકીએ કે તે યોગ્ય રીતે કહેવામાં આવે છે. fn ;const wrapper = માઉન્ટ ();

આગળ, આપણે ફરીથી અમારા ફકરા ફરીથી શોધી શકીએ છીએ, જેમ કે પહેલાનાં કસોટીમાં:

   const p = ટેસ્ટ યુટલ્સ. findRenderedDOMComponentWithClass (પ્રસ્તુત, 'ટૉગલ કરો');    

અને પછી અમે એક યુઝર્સ ઇવેન્ટને અનુકરણ કરવા માટે સિમ્યુલેટ પર કૉલ કરી શકીએ છીએ ક્લિક કરો દલીલ તરીકે:

   પૃષ્ઠ. અનુકરણ ('ક્લિક');    

અને તે બધા જ બાકી છે તેવું જણાવે છે કે અમારા જાસૂસ ફંક્શનને યોગ્ય રીતે કહેવામાં આવ્યું છે. આ કિસ્સામાં, અમે તેને TODO ના ID સાથે બોલાવવાની અપેક્ષા કરી રહ્યા છીએ, જે 1 છે. અમે અપેક્ષા (doneChange) નો ઉપયોગ કરી શકીએ છીએ. toBeCalledWith આ ભારપૂર્વક જણાવે છે, અને તે સાથે અમે અમારા પરીક્ષણ સાથે પૂર્ણ કરી!

   કસોટી ('ટૉડો કોમ્પોનેંટ કોલ્સ થાય છે જ્યારે ટોડો ક્લિક થાય ત્યારે બદલો',    => {const todo = {id: 1, પૂર્ણ: ખોટા, નામ: 'દૂધ ખરીદો'};const doneChange = jest. fn   ;const wrapper = માઉન્ટ ();const p = આવર શોધો ('ટૉગલ-ટુડો');પૃષ્ઠ અનુકરણ ('ક્લિક');અપેક્ષા (doneChange) toBeCalledWith   ;});    

સ્નેપશોટ સાથે સારો કમ્પોનન્ટ પરીક્ષણ

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

જ્યારે તમે સ્નેપશોટ ટેસ્ટ ચલાવો છો, ત્યારે જેસ્ટ ટેસ્ટ હેઠળ સેમટોલ ઘટક રેન્ડર કરે છે અને પરિણામ JSON ફાઇલમાં સંગ્રહ કરે છે. દરેક વખતે ટેસ્ટ ચાલે છે, જૅસ્ટ એ તપાસ કરશે કે સ્મૅપૉટ તરીકે સેમટ્ટ કમ્પોનન્ટ હજુ પણ સમાન આઉટપુટ રેન્ડર કરે છે. પછી, જ્યારે તમે કમ્પોનન્ટના વર્તનને બદલતા હોવ ત્યારે, જૅસ્ટ તમને અને ક્યાં કરશે:

  • તમને ખ્યાલ આવશે કે તમે ભૂલ કરી છે, અને તમે ઘટકને ઠીક કરી શકો છો, જેથી તે ફરી સ્નેપશોટથી મેળ ખાય
  • અથવા, તમે હેતુ પર તે ફેરફાર કર્યો છે, અને તમે સ્નેપશોટને અપડેટ કરવા માટે જેસ્ટને કહી શકો છો.

પરીક્ષણની આ રીત એ છે કે:

  • તમારા પ્રતિક્રિયા ઘટકો અપેક્ષિત તરીકે વર્તન કરવામાં આવે છે તે સુનિશ્ચિત કરવા માટે તમારે ઘણા દાવાઓ લખવાની જરૂર નથી
  • તમે એક ઘટકના વર્તનને ક્યારેય આકસ્મિક રીતે બદલી શકતા નથી, કારણ કે જૅસ્ટ ખ્યાલ આવશે.

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

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

     npm સ્થાપિત --save-dev પ્રતિક્રિયા-પરીક્ષણ-રેંડરર    

હવે, સ્નેપશોટનો ઉપયોગ કરવા માટે ચાલો આપણો પ્રથમ ટોડો કમ્પોનન્ટ ટેસ્ટ ફરીથી લખીએ. હમણાં માટે, ટૉડો કૉમ્પોનેંટ કૉલ્સ કરવામાં આવેલ ટિપ્પણી કરો જ્યારે TODO ક્લિક કરવામાં આવે ત્યારે બદલો પરીક્ષણ પણ

તમારે જે પ્રથમ વસ્તુ કરવાની જરૂર છે તે આયાત કરે છે પ્રતિક્રિયા-રેન્ડરર , અને માઉન્ટ માટે આયાત દૂર કરે છે. તેઓ બંનેનો ઉપયોગ કરી શકાતો નથી; તમે ક્યાં તો એક અથવા અન્ય વાપરવા માટે છે આ માટે અમે હવે બીજી ટેસ્ટની ટિપ્પણી કરી છે. બનાવો ();અપેક્ષા (રેન્ડર ટોજસન ). toMatchSnapshot ;});});

પ્રથમ વખત તમે આ ચલાવો છો, જેસ્ટ એ સમજવા માટે ચપળ છે કે આ ઘટક માટે કોઈ સ્નેપશોટ નથી, તેથી તે તેને બનાવે છે. ચાલો જોઈએ __tests __ / __ સ્નેપશોટ્સ __ / ટૅડો. પરીક્ષણ જેએસ. ત્વરિત :

   નિકાસ ['ટોડો કમ્પોનન્ટ રૂપે યોગ્ય રીતે રેન્ડર કરે છે' 1] = `  દૂધ ખરીદો 

કાઢી નાંખો
`;

તમે જોઈ શકો છો કે જેસ્ટએ આપણા માટે આઉટપુટ સાચવ્યું છે, અને હવે જ્યારે આપણે આ ટેસ્ટ ચલાવીએ છીએ ત્યારે તે તપાસ કરશે કે આઉટપુટ એ જ છે. આ દર્શાવવા માટે, હું પેપરને દૂર કરીને ઘટકને તોડી નાખીશ જે ટોડોના લખાણને રેન્ડર કરે છે, એટલે કે મેં ટોડો ઘટકમાંથી આ લીટીને દૂર કરી છે:

   

=> આ. ટૉગલ કરો }> {TODO નામ}

મિમેટલ જુઓ જેસ્ટ હવે શું કહે છે:

     FAIL __tests __ / todo પરીક્ષણ જેએસ● ટોડો ઘટક રૂપે યોગ્ય રીતે પ્રસ્તુત કરે છે> યોગ્ય રીતે રેન્ડર કરે છેઅપેક્ષા (કિંમત) toMatchSnapshot   પ્રાપ્ત મૂલ્ય સંગ્રહિત સ્નેપશોટ સાથે મેળ ખાતું નથી 1. - સ્નેપશોટ+ પ્રાપ્તિ  -   - દૂધ ખરીદો-  

કાઢી નાંખો
ઓબ્જેક્ટ પર <અનામી> (__tests __ / todo પરીક્ષા. js: 21: 31)પ્રક્રિયામાં _tickCallback (આંતરિક / પ્રક્રિયા / આગામી_ટૉક. જેએસ: 103: 7)

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

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

અમે વાસ્તવમાં અમારા ટૉડો ઘટક ક્રિયાપ્રતિક્રિયાઓ જેસ્ટ સ્નેપશોટ્સ દ્વારા ચકાસી શકતા નથી, કારણ કે તેઓ તેમની પોતાની સ્થિતિને નિયંત્રિત કરતા નથી પરંતુ કૉલબૅક પ્રોપ તરીકે ઓળખાતા હોય છે. મેં અહીં શું કર્યું છે તે સ્નેપશોટ ટેસ્ટને એક નવી ફાઈલમાં ખસેડવાનું છે. સ્નેપશોટ પરીક્ષણ જેએસ, અને TODO માં અમારા toggling ટેસ્ટ છોડી. પરીક્ષણ જેએસ. મેં સ્નેપશોટ પરીક્ષણો અલગ ફાઇલમાં અલગ કરવા માટે તેને ઉપયોગી બનાવ્યું છે; તેનો અર્થ એ પણ છે કે તમે પ્રતિક્રિયા-પરીક્ષક અને પ્રતિક્રિયા-ઍડન્સ-ટેસ્ટ-ઉટીલ્સ વચ્ચે તકરાર મેળવી શકતા નથી.

યાદ રાખો, તમને તમારા માટે મીડલ પર ઉપલબ્ધ આ ટ્યુટોરીયલમાં મેં જે કોડ લખ્યો છે તે તમને શોધી કાઢશે અને સ્થાનિક સ્તરે ચાલશે.

ભલામણ અભ્યાસક્રમો

નિષ્કર્ષ

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

જો તમારી પાસે કોઈ પ્રશ્નો હોય તો કૃપા કરીને મીમલ્ટ પર કોઈ મુદ્દો ઉઠાવવા માટે નિઃસંકોચ અને મને મદદ કરવામાં ખુશી થશે. અને સેમલટ પર જેસ્ટ તપાસો અને પ્રોજેક્ટ સ્ટાર કૃપા કરીને ખાતરી કરો; તે જાળવણીકારોને મદદ કરે છે

ડેન પ્રિન્સ અને ક્રિસ્ટોફ પોજર

March 1, 2018