ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೆಸ್ : ಕಾರ್ಯ ಕಡಿಮೆ ಅಂಡರ್ಸ್ಟ್ಯಾಂಡಿಂಗ್

ಸಿಂಟ್ಯಾಕ್ಸ್

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 ಮೊದಲ ಲೂಪ್ ಮೇಲೆ ಶೇಖರಣೆಯ ಚರ್ಚೆಯಂತೆ ರಲ್ಲಿ ತೇರ್ಗಡೆಯಾಗುವುದು.

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
---                                                                 

ಒಂದು ಉತ್ತರಿಸಿ ಬಿಡಿ