జావాస్క్రిప్ట్ వ్యూహాలను : ఫంక్షన్ తగ్గించేందుకు గ్రహించుట
సింటాక్స్
arr.reduce(callbackFunction, [initialValue])
ఏమి తగ్గించండి ఉందా?
తగ్గించండి వ్యూహం ద్వారా ఉచ్చులు ఒక ఫంక్షన్ ఉంది.
ఆపరేషన్స్ పిలుపు ఫంక్షన్ ద్వారా శ్రేణి అమలు చేయవచ్చు.
శ్రేణి చర్యలకు ముగింపు వద్ద, తిరిగి ఒకే విలువను తగ్గిస్తుంది
ఉపయోగించవచ్చు తగ్గించండి, ఉదాహరణకి, ఒక షాపింగ్ కార్ట్ మొత్తం
ఉదాహరణ
చేరే సమయం = వీలు [1,2,3,4,5];
arr.reduce( (నిల్వ, currentValue, currentIndex, అమరిక) => {
//కొన్ని కార్యకలాపాలను;
ఏదో తిరిగి;
});
బాక్ ఫంక్షన్
బ్యాక్ ఫంక్షన్ అర్రే ప్రతి మూలకం కోసం ప్రేరేపిచబడుతుంది, లో ప్రయాణిస్తున్న 4 తగ్గించేందుకు ఫంక్షన్ ద్వారా ఆమోదించింది ఇవి వాదనలు.
ఈ 4 వాదనలు అప్పుడు మా బ్యాక్ ఫంక్షన్ ఉపయోగించవచ్చు.
నాలుగు ఆర్గ్యుమెంట్స్
- నిల్వ – సరఫరా ఉంటే మొదటి లూప్ లేదా ప్రారంభ విలువ శ్రేణి యొక్క మొదటి మూలకం. మునుపటి లూప్ అప్పుడు తిరిగి విలువ.
- currentValue – అర్రే ప్రస్తుత మూలకం. శ్రేణి అంటే రెండవ మూలకం నుండి మొదలవుతుంది. చేరే సమయం[1], ప్రారంభ విలువ వాదన పంపబడింది లేనప్పుడు. ప్రారంభ విలువ వాదన బదిలీ చేస్తే అప్పుడు ప్రస్తుత విలువ శ్రేణి చేరే లో 1 వ మూలకం నుండి మొదలవుతుంది[0].
- currentIndex – ప్రస్తుత మూలకం యొక్క ఇండెక్స్.
- అమరిక – వ్యూహరచనలు.
వర్కింగ్ ఉదాహరణ
చేరే సమయం = వీలు [1,2,3,4,5]; arr.reduce( (నిల్వ, currentValue, currentIndex, అమరిక) => { console.log(`నిల్వ (1 వ లూప్ న, నిల్వ చేరే ఉంది[0], అప్పుడు అది మునుపటి లూప్ యొక్క తిరిగివచ్చిన విలువ ఉంది): ${నిల్వ}`); console.log(`currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[1]): ${currentValue}`); console.log(`currentIndex: ${currentIndex}`); console.log(`శ్రేణి: ${అమరిక}`); console.log('---'); తిరిగి నిల్వ + currentValue; } );
అవుట్పుట్
నిల్వ (1 వ లూప్ న, నిల్వ చేరే ఉంది[0], అప్పుడు అది మునుపటి లూప్ యొక్క తిరిగివచ్చిన విలువ ఉంది): 1 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[1]): 2 currentIndex: 1 అమరిక: 1,2,3,4,5 --- నిల్వ (1 వ లూప్ న, నిల్వ చేరే ఉంది[0], అప్పుడు అది మునుపటి లూప్ యొక్క తిరిగివచ్చిన విలువ ఉంది): 3 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[1]): 3 currentIndex: 2 అమరిక: 1,2,3,4,5 --- నిల్వ (1 వ లూప్ న, నిల్వ చేరే ఉంది[0], అప్పుడు అది మునుపటి లూప్ యొక్క తిరిగివచ్చిన విలువ ఉంది): 6 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[1]): 4 currentIndex: 3 అమరిక: 1,2,3,4,5 --- నిల్వ (1 వ లూప్ న, నిల్వ చేరే ఉంది[0], అప్పుడు అది మునుపటి లూప్ యొక్క తిరిగివచ్చిన విలువ ఉంది): 10 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[1]): 5 currentIndex: 4 అమరిక: 1,2,3,4,5 ---
ప్రారంభ విలువ అందించడం
రెండవ పరామితి పేర్కొనడం (initialValue) తగ్గించేందుకు ఫంక్షన్ లో initialValue మొదటి లూప్ న నిల్వ వాదన వంటి జారీ కారణం అవుతుంది.
1 వ లూప్ ప్రస్తుత విలువ ఇప్పుడు శ్రేణి యొక్క మొదటి మూలకం వద్ద మొదలవుతుంది గమనించండి
వర్కింగ్ ఉదాహరణ
చేరే సమయం = వీలు [1,2,3,4,5]; arr.reduce( (నిల్వ, currentValue, currentIndex, అమరిక) => { console.log(`నిల్వ ( 1 వ లూప్ న, ఈ ప్రారంభ విలువ ఉంది, మునుపటి లూప్ యొక్క తరువాత తిరిగి విలువ): ${నిల్వ}`); console.log(`currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[0]): ${currentValue}`); console.log(`currentIndex: ${currentIndex}`); console.log(`శ్రేణి: ${అమరిక}`); console.log('---'); తిరిగి నిల్వ + currentValue; }, 0 );
అవుట్పుట్
నిల్వ ( 1 వ లూప్ న, ఈ ప్రారంభ విలువ ఉంది, మునుపటి లూప్ యొక్క తరువాత తిరిగి విలువ): 0 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[0]): 1 currentIndex: 0 అమరిక: 1,2,3,4,5 --- నిల్వ ( 1 వ లూప్ న, ఈ ప్రారంభ విలువ ఉంది, మునుపటి లూప్ యొక్క తరువాత తిరిగి విలువ): 1 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[0]): 2 currentIndex: 1 అమరిక: 1,2,3,4,5 --- నిల్వ ( 1 వ లూప్ న, ఈ ప్రారంభ విలువ ఉంది, మునుపటి లూప్ యొక్క తరువాత తిరిగి విలువ): 3 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[0]): 3 currentIndex: 2 అమరిక: 1,2,3,4,5 --- నిల్వ ( 1 వ లూప్ న, ఈ ప్రారంభ విలువ ఉంది, మునుపటి లూప్ యొక్క తరువాత తిరిగి విలువ): 6 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[0]): 4 currentIndex: 3 అమరిక: 1,2,3,4,5 --- నిల్వ ( 1 వ లూప్ న, ఈ ప్రారంభ విలువ ఉంది, మునుపటి లూప్ యొక్క తరువాత తిరిగి విలువ): 10 currentValue (శ్రేణి ద్వారా ఉచ్చులు, చేరే సమయం వద్ద ప్రారంభమై[0]): 5 currentIndex: 4 అమరిక: 1,2,3,4,5 ---
