જાવાસ્ક્રિપ્ટ એરેમાં : કાર્ય ઘટાડવા સમજ

સિન્ટેક્સ

arr.reduce(callbackFunction, [initialValue])

શું ઘટાડવા નથી?

ઘટાડો કાર્ય છે કે જે એરે મારફતે આંટીઓ છે.

ઓપરેશન્સ કૉલબેક ફંક્શનથી મારફતે એરે પર કરી શકાય છે.

એરે પર કામગીરી અંતે, વળતર એક કિંમત ઘટાડવા

ઘટાડો વાપરી શકાય છે, દાખ્લા તરીકે, એક શોપિંગ કાર્ટ કુલ

ઉદાહરણ

  દો આગમન = [1,2,3,4,5];
  arr.reduce( (સંગ્રાહક, વર્તમાન કિંમત, currentIndex, એરે) => { 
      //કેટલાક ઓપરેશન્સની;
      પાછા કંઈક;
  });

 

કૉલબૅક કાર્ય

કૉલબૅક કાર્ય એરે દરેક તત્વ માટે લાગુ પાડી શકાય છે, માં પસાર 4 દલીલો જેમાં ઘટાડવા કાર્ય દ્વારા પસાર કરવામાં આવે.

આ 4 દલીલો પછી અમારી કૉલબૅક કાર્ય ઉપયોગ કરી શકાય છે.

ચાર દલીલો લે

  1. સંગ્રાહક – પ્રથમ લૂપ અથવા પ્રારંભિક મૂલ્ય પર એરે પ્રથમ તત્વ જો પૂરી પાડવામાં. અગાઉના લૂપની પછી પરત કિંમત.
  2. વર્તમાન કિંમત – એરે માં વર્તમાન તત્વ. અરે એટલે બીજા તત્વ શરૂ. આગમન[1], જ્યારે પ્રારંભિક મૂલ્ય એક દલીલ પસાર નથી. પ્રારંભિક મૂલ્ય એક દલીલ પસાર કરવામાં આવે છે, તો પછી વર્તમાન મૂલ્ય એરે આગમન માં 1 લી તત્વ શરૂ થાય[0].
  3. currentIndex – વર્તમાન તત્વ ની અનુક્રમણિકા.
  4. એરે – સમગ્ર એરે.

વર્કિંગ ઉદાહરણ

દો આગમન = [1,2,3,4,5];

arr.reduce(
  (સંગ્રાહક, વર્તમાન કિંમત, currentIndex, એરે) => {
    console.log(`સંગ્રાહક (1 લી લુપ પર, સંગ્રાહક આગમન છે[0], પછી તે અગાઉના લૂપની પરત કિંમત છે): ${સંગ્રાહક}`);
    console.log(`currentValue (એરે મારફતે આંટીઓ, આગમન પર શરૂ[1]): ${વર્તમાન કિંમત}`);
    console.log(`currentIndex: ${currentIndex}`);
    console.log(`એરે: ${એરે}`);
    console.log('---');
    વળતર સંગ્રાહક + વર્તમાન કિંમત;
  }
);

આઉટપુટ

સંગ્રાહક (1 લી લુપ પર, સંગ્રાહક આગમન છે[0], પછી તે અગાઉના લૂપની પરત કિંમત છે): 1
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[1]): 2
currentIndex: 1
એરે: 1,2,3,4,5
---
સંગ્રાહક (1 લી લુપ પર, સંગ્રાહક આગમન છે[0], પછી તે અગાઉના લૂપની પરત કિંમત છે): 3
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[1]): 3
currentIndex: 2
એરે: 1,2,3,4,5
---
સંગ્રાહક (1 લી લુપ પર, સંગ્રાહક આગમન છે[0], પછી તે અગાઉના લૂપની પરત કિંમત છે): 6
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[1]): 4
currentIndex: 3
એરે: 1,2,3,4,5
---
સંગ્રાહક (1 લી લુપ પર, સંગ્રાહક આગમન છે[0], પછી તે અગાઉના લૂપની પરત કિંમત છે): 10
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[1]): 5
currentIndex: 4
એરે: 1,2,3,4,5
---

 

પ્રારંભિક કિંમત પૂરો

બીજો પેરામીટર ઉલ્લેખ (initialValue) ઘટાડવા ફંક્શનમાં કારણ બનશે initialValue પ્રથમ લુપ પર સંગ્રાહક દલીલ તરીકે પસાર કરી.

નોંધ કરો કે 1 લી લુપ પર વર્તમાન મૂલ્ય હવે એરે પ્રથમ તત્વ અંતે શરૂ થાય છે

વર્કિંગ ઉદાહરણ

  દો આગમન = [1,2,3,4,5];

  arr.reduce(
  (સંગ્રાહક, વર્તમાન કિંમત, currentIndex, એરે) => {
    console.log(`સંગ્રાહક ( 1 લી લુપ પર, આ પ્રારંભિક મૂલ્ય છે, અગાઉના લૂપની પછી પરત કિંમત): ${સંગ્રાહક}`);
    console.log(`currentValue (એરે મારફતે આંટીઓ, આગમન પર શરૂ[0]): ${વર્તમાન કિંમત}`);
    console.log(`currentIndex: ${currentIndex}`);
    console.log(`એરે: ${એરે}`);
    console.log('---');
    વળતર સંગ્રાહક + વર્તમાન કિંમત;
  }, 0
);

આઉટપુટ

સંગ્રાહક ( 1 લી લુપ પર, આ પ્રારંભિક મૂલ્ય છે, અગાઉના લૂપની પછી પરત કિંમત): 0
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[0]): 1
currentIndex: 0
એરે: 1,2,3,4,5
---
સંગ્રાહક ( 1 લી લુપ પર, આ પ્રારંભિક મૂલ્ય છે, અગાઉના લૂપની પછી પરત કિંમત): 1
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[0]): 2
currentIndex: 1
એરે: 1,2,3,4,5
---
સંગ્રાહક ( 1 લી લુપ પર, આ પ્રારંભિક મૂલ્ય છે, અગાઉના લૂપની પછી પરત કિંમત): 3
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[0]): 3
currentIndex: 2
એરે: 1,2,3,4,5
---
સંગ્રાહક ( 1 લી લુપ પર, આ પ્રારંભિક મૂલ્ય છે, અગાઉના લૂપની પછી પરત કિંમત): 6
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[0]): 4
currentIndex: 3
એરે: 1,2,3,4,5
---
સંગ્રાહક ( 1 લી લુપ પર, આ પ્રારંભિક મૂલ્ય છે, અગાઉના લૂપની પછી પરત કિંમત): 10
વર્તમાન કિંમત (એરે મારફતે આંટીઓ, આગમન પર શરૂ[0]): 5
currentIndex: 4
એરે: 1,2,3,4,5
---