කෙටි පරිපථ Array.for සෑම ඇමතුම් විවේකයක්ම වගේ

[1,2,3].forEach(function(el) {
    if(el === 1) break;
});

forEachජාවාස්ක්‍රිප්ට් හි නව ක්‍රමය භාවිතා කර මෙය කරන්නේ කෙසේද? මම උත්සාහ කළා return;, return false;සහ break. breakබිඳවැටීම සහ නැවත නැවත returnකිරීම හැර වෙන කිසිවක් නොකරයි.

කිසිදු බිල්ට් හැකියාව තියෙනවා breakදී forEach. ක්‍රියාත්මක කිරීමට බාධා කිරීම සඳහා ඔබට යම් ආකාරයක ව්‍යතිරේකයක් විසි කිරීමට සිදුවේ. උදා.

var BreakException = {};

try {
  [1, 2, 3].forEach(function(el) {
    console.log(el);
    if (el === 2) throw BreakException;
  });
} catch (e) {
  if (e !== BreakException) throw e;
}

ජාවාස්ක්‍රිප්ට් ව්‍යතිරේකයන් ඉතා ලස්සන නැත. සාම්ප්‍රදායික forපුඩුවක් ඔබට සැබවින්ම අවශ්‍ය නම් එය වඩාත් සුදුසු breakවේ.

භාවිත Array#some

ඒ වෙනුවට, භාවිතා කරන්න Array#some:

[1, 2, 3].some(function(el) {
  console.log(el);
  return el === 2;
});

මෙම නිසා ය someප්රතිලාභ trueරැසක් සඳහා, නැවත දී ඝාතනය කරන ලද callbacks ඕනෑම ඉක්මනින්, true, ඉතිරි ඝාතනය කෙටි සර්කිට්.

some, එහි ප්‍රතිලෝම every(එය a මත නතර වනු ඇත return false), සහ forEachඒවා සියල්ලම ECMAScript පස්වන සංස්කරණ ක්‍රම වන Array.prototypeඅතර ඒවා අතුරුදහන් වූ බ්‍රව්සර් මත එකතු කළ යුතුය .

ECMAScript2015 (aka ES6) හි නව for for loop භාවිතා කරමින් මෙය කිරීමට ඊටත් වඩා හොඳ ක්‍රමයක් දැන් තිබේ . උදාහරණයක් ලෙස, මෙම කේතය අංක 5 ට පසුව අරාව මූලද්‍රව්‍ය මුද්‍රණය නොකරයි:

let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
for (let el of arr) {
  console.log(el);
  if (el === 5) {
    break;
  }
}

ලියකියවිලි වලින්:

දෙකම සඳහා ... දී සහ සඳහා ... ක දේවල් ගැන ප්රකාශ අවංකව. ඔවුන් අතර ඇති ප්‍රධාන වෙනස වන්නේ ඔවුන් නැවත කියන දෙයයි. මෙම සඳහා ... දී ප්රකාශයක් මුල් ඇතුලත් කිරීම් සඳහා, කට වස්තුවක ගණ්ය ගුණ දයානන්ද්. මෙම සඳහා ... ක ප්රකාශය iterable වස්තුව නිර්වචනය කට ශාඛාවයි කිරීමට දත්ත කට දයානන්ද්.

පුනරාවර්තනයේ දර්ශකය අවශ්‍යද? ඔබට භාවිතා කළ හැකිය Array.entries():

for (const [index, el] of arr.entries()) {
  if ( index === 5 ) break;
}

ඔබට සෑම ක්රමයක්ම භාවිතා කළ හැකිය :

[1,2,3].every(function(el) {
    return !(el === 1);
});

ES6

[1,2,3].every( el => el !== 1 )

පැරණි බ්‍රව්සර් ආධාරක භාවිතය සඳහා:

if (!Array.prototype.every)
{
  Array.prototype.every = function(fun /*, thisp*/)
  {
    var len = this.length;
    if (typeof fun != "function")
      throw new TypeError();

    var thisp = arguments[1];
    for (var i = 0; i < len; i++)
    {
      if (i in this &&
          !fun.call(thisp, this[i], i, this))
        return false;
    }

    return true;
  };
}

වැඩි විස්තර මෙතැනින් .

එම්ඩීඑන් ප්‍රලේඛනයෙන්Array.prototype.forEach() උපුටා ගැනීම :

නැත නතර කිරීමට හෝ බිඳ දැමීම සඳහා කිසිදු ක්රමයක් වන forEach()ව්යතිරේකයක් වීසි හැර වෙනත් පුඩුවක්. ඔබට එවැනි හැසිරීමක් අවශ්‍ය නම්, .forEach()ක්‍රමය වැරදි මෙවලමකි , ඒ වෙනුවට සරල පුඩුවක් භාවිතා කරන්න. ඔබ සංජානන සඳහා අරාව අංග පරීක්ෂා හා වීජ ආපසු ලැබෙන අගය අවශ්ය නම්, ඔබ භාවිතා කළ හැකිය every()හෝ some()ඒ වෙනුවට.

ඔබේ කේතය සඳහා (ප්‍රශ්නයේ), @ බොබින්ස් යෝජනා කළ පරිදි, Array.prototype.some()ඒ වෙනුවට භාවිතා කරන්න. එය ඔබගේ භාවිතයට හොඳින් ගැලපේ.

Array.prototype.some()අරාවෙහි ඇති සෑම මූලද්‍රව්‍යයක් සඳහාම නැවත වරක් ඇමතුම් ලබා ගැනීමේ ශ්‍රිතය ක්‍රියාත්මක කරයි Boolean. එවැනි මූලද්රව්යයක් සොයාගතහොත්, some()වහාම සත්‍ය වේ. එසේ නොමැතිනම්, some()වැරදි ලෙස ආපසු එවීම. ඇමතුම් ලබා ගැනීම ඉල්ලා සිටින්නේ අගයන් පවරා ඇති අරාවේ දර්ශක සඳහා පමණි; මකාදැමූ හෝ කිසි විටෙකත් අගයන් පවරා නැති දර්ශක සඳහා එය ආයාචනා නොකෙරේ.

අවාසනාවට මෙම අවස්ථාවේදී ඔබ භාවිතා නොකරන්නේ නම් එය වඩා හොඳ වනු ඇත forEach. ඒ වෙනුවට සාමාන්‍ය forලූපයක් භාවිතා කරන්න , එය දැන් ඔබ අපේක්ෂා කළ ආකාරයටම ක්‍රියාත්මක වේ.

var array = [1, 2, 3];
for (var i = 0; i < array.length; i++) {
  if (array[i] === 1){
    break;
  }
}

භාවිතා කිරීමට සලකා බලන්න jqueryගේ eachබොරු ඇතුළත callback කාර්යය නැවත කිරීමට ඉඩ නිසා, ක්රමය:

$.each(function(e, i) { 
   if (i % 2) return false;
   console.log(e)
})

ලොඩාෂ් පුස්තකාල takeWhileසිතියම සමඟ දම්වැල් දැමිය හැකි / අඩු කළ හැකි / නැමිය හැකි ක්‍රමයක් ද සපයයි :

var users = [
  { 'user': 'barney',  'active': false },
  { 'user': 'fred',    'active': false },
  { 'user': 'pebbles', 'active': true }
];

_.takeWhile(users, function(o) { return !o.active; });
// => objects for ['barney', 'fred']

// The `_.matches` iteratee shorthand.
_.takeWhile(users, { 'user': 'barney', 'active': false });
// => objects for ['barney']

// The `_.matchesProperty` iteratee shorthand.
_.takeWhile(users, ['active', false]);
// => objects for ['barney', 'fred']

// The `_.property` iteratee shorthand.
_.takeWhile(users, 'active');
// => []

ඔබගේ කේත උදාහරණයෙන්, Array.prototype.findඔබ සොයන දේ පෙනේ : Array.prototype.find () සහ Array.prototype.findIndex ()

[1, 2, 3].find(function(el) {
    return el === 2;
}); // returns 2

ඔබ ඩීන් එඩ්වඩ්ගේ යෝජනාව භාවිතා කිරීමට කැමති නම් සහ දෝෂය හසු නොවී පුඩුවෙන් පිටතට යාම සඳහා StopIteration දෝෂය විසි කරන්න, ඔබට පහත ශ්‍රිතය භාවිතා කළ හැකිය ( මුලින් මෙතැනින් ):

// Use a closure to prevent the global namespace from be polluted.
(function() {
  // Define StopIteration as part of the global scope if it
  // isn't already defined.
  if(typeof StopIteration == "undefined") {
    StopIteration = new Error("StopIteration");
  }

  // The original version of Array.prototype.forEach.
  var oldForEach = Array.prototype.forEach;

  // If forEach actually exists, define forEach so you can
  // break out of it by throwing StopIteration.  Allow
  // other errors will be thrown as normal.
  if(oldForEach) {
    Array.prototype.forEach = function() {
      try {
        oldForEach.apply(this, [].slice.call(arguments, 0));
      }
      catch(e) {
        if(e !== StopIteration) {
          throw e;
        }
      }
    };
  }
})();

ඉහත කේතය මඟින් ඔබේම උත්සාහ කිරීමේ වගන්ති නොකර පහත සඳහන් කේත වැනි කේත ධාවනය කිරීමේ හැකියාව ලබා දෙනු ඇත:

// Show the contents until you get to "2".
[0,1,2,3,4].forEach(function(val) {
  if(val == 2)
    throw StopIteration;
  alert(val);
});

මතක තබා ගත යුතු එක් වැදගත් කරුණක් නම්, මෙය යාවත්කාලීන වන්නේ Array.prototype.forEach ශ්‍රිතය දැනටමත් පවතී නම් පමණි. එය දැනටමත් නොපවතී නම්, එය එය වෙනස් නොකරනු ඇත.

කෙටි පිළිතුර: for...breakමේ සඳහා භාවිතා කරන්න හෝ ඔබේ කේතය වෙනස් නොකිරීමට භාවිතා කරන්න forEach. භාවිතා නොකරන්න .some()හෝ .every()සෑදීමේදී අනුගමනය කිරීමට for...break. for...breakලූපය වළක්වා ගැනීමට ඔබේ කේතය නැවත ලියන්න , නැතහොත් භාවිතා කරන්න for...break. for...breakවිකල්පයක් ලෙස ඔබ මෙම ක්‍රම භාවිතා කරන සෑම අවස්ථාවකම දෙවියන් වහන්සේ පූස් පැටවා මරා දමයි.

දිගු පිළිතුර:

.some()හා .every()නැවත යන booleanවටිනාකම, .some()ප්රතිලාභ trueශ්රිතයේ සම්මත වූ කිසිදු අංගයක් එහි නම් trueසෑම ප්රතිලාභ, falseශ්රිතයේ සම්මත වූ කිසිදු අංගයක් එහි නම් false. එම කාර්යයන් අදහස් කරන්නේ මෙයයි. ඔවුන් අදහස් නොකරන දේ සඳහා කාර්යයන් භාවිතා කිරීම වඩා නරක ය, පසුව CSS වෙනුවට පිරිසැලසුම සඳහා වගු භාවිතා කිරීම ඔබගේ කේතය කියවන සෑම කෙනෙකුම කලකිරීමට පත් කරයි.

එසේම, මෙම ක්‍රම for...breakවිකල්පයක් ලෙස භාවිතා කළ හැකි එකම ක්‍රමය වන්නේ අතුරු ආබාධ ඇති කිරීමයි ( .some()ඇමතුම් ආපසු ගැනීමේ ක්‍රියාවලියෙන් පිටත සමහර විචල්‍යයන් වෙනස් කිරීම ), මෙය මීට වඩා වෙනස් නොවේ for...break.

ඒ නිසා, භාවිතා .some()හෝ .every()ලෙස for...breakපුඩුවක් විකල්ප අතුරු ආබාධ රහිත නොවේ, එසේ නම් එහි පිරිසිදු නොවේ for...break, මේ අමිහිරි වේ, ඒ නිසා මෙම වඩා හොඳ නොවේ.

ඔබට සෑම විටම ඔබේ කේතය නැවත ලිවිය හැකි වන අතර එමඟින් අවශ්‍යතාවයක් නොමැත for...break. ඔබට අරාව භාවිතයෙන් පෙරහන් කළ හැකිය .filter(), ඔබට අරාව භාවිතා කර බෙදිය හැකිය .slice(), පසුව භාවිතා කරන්න .forEach()හෝ .map()අරාවෙහි එම කොටස සඳහා.

var array = [1,2,3,4];

for(var item of array){
    console.log(item);
    if(item == 2){
       break;
    }
}

මෙය ගැටලුව විසඳීම සඳහා මා ඉදිරිපත් කළ දෙයක් පමණයි ... මුල් අසන්නාට තිබූ ගැටලුව එය විසඳන බව මට හොඳටම විශ්වාසයි:

Array.prototype.each = function(callback){
    if(!callback) return false;
    for(var i=0; i<this.length; i++){
        if(callback(this[i], i) == false) break;
    }
};

ඉන්පසු ඔබ එය අමතන්නේ:

var myarray = [1,2,3];
myarray.each(function(item, index){
    // do something with the item
    // if(item != somecondition) return false; 
});

ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතය තුළ සාවද්‍ය ලෙස නැවත පැමිණීම විවේකයක් ඇති කරයි. එය ඇත්ත වශයෙන්ම ක්‍රියාත්මක නොවන්නේ නම් මට දන්වන්න.

මා ඉදිරිපත් කළ තවත් සංකල්පයක්:

function forEach(array, cb) {
  var shouldBreak;
  function _break() { shouldBreak = true; }
  for (var i = 0, bound = array.length; i < bound; ++i) {
    if (shouldBreak) { break; }
    cb(array[i], i, array, _break);
  }
}

// Usage

forEach(['a','b','c','d','e','f'], function (char, i, array, _break) {
  console.log(i, char);
  if (i === 2) { _break(); }
});

මෙම විසඳුම වෙනත් වෙබ් අඩවියකින් හමු විය. ඔබට උත්සාහය / අල්ලා ගැනීමේ අවස්ථාවකදී සෑම එකක්ම ඔතා තැබිය හැකිය.

if(typeof StopIteration == "undefined") {
 StopIteration = new Error("StopIteration");
}

try {
  [1,2,3].forEach(function(el){
    alert(el);
    if(el === 1) throw StopIteration;
  });
} catch(error) { if(error != StopIteration) throw error; }

වැඩි විස්තර මෙතැනින්: http://dean.edwards.name/weblog/2006/07/enum/

කලින් සඳහන් කළ පරිදි, ඔබට බිඳ දැමිය නොහැක .forEach().

මෙන්න ඊඑස් 6 ඉටරේටර්ස් සමඟ පුරෝකථනයක් කිරීමේ තරමක් නවීන ක්‍රමයක්. නැවත ක්‍රියාත්මක වන විට index/ වෙත access ජු ප්‍රවේශයක් ලබා ගැනීමට ඔබට ඉඩ දෙයි value.

const array = ['one', 'two', 'three'];

for (const [index, val] of array.entries()) {
  console.log('item:', { index, val });
  if (index === 1) {
    console.log('break!');
    break;
  }
}

ප්‍රතිදානය:

item: { index: 0, val: 'one' }
item: { index: 1, val: 'two' }
break!

සබැඳි

• Array.prototype.entries()
• අනුකාරක සහ ජනක යන්ත්‍ර
• පැවරුම් විනාශ කිරීම

නැවත සැකසීමෙන් පසු ඔබට ඔබේ අරාවට ප්‍රවේශ වීමට අවශ්‍ය නොවන්නේ නම්, අරාවෙහි දිග 0 ලෙස සැකසීමෙන් ඔබට ඇප ලබා ගත හැකිය.

[1,3,4,5,6,7,8,244,3,5,2].forEach(function (item, index, arr) {
  if (index === 3) arr.length = 0;
});

හෝ ක්ලෝනයක් සමඟ:

var x = [1,3,4,5,6,7,8,244,3,5,2];

x.slice().forEach(function (item, index, arr) {
  if (index === 3) arr.length = 0;
});

එය වඩා හොඳ විසඳුමක් වන අතර පසුව ඔබේ කේතයේ අහඹු දෝෂ විසි කරන්න.

මෙය for for loop, නමුත් forEach () මෙන් ලූපයේ වස්තු යොමු කිරීම පවත්වා ගෙන යන නමුත් ඔබට කැඩී යා හැක.

var arr = [1,2,3];
for (var i = 0, el; el = arr[i]; i++) {
    if(el === 1) break;
}

තවත් ප්රවේශයක්

        var wageType = types.filter(function(element){
            if(e.params.data.text == element.name){ 
                return element;
            }
        });
        console.dir(wageType);

මම ඒ සඳහා nullhack භාවිතා කරමි , එය දේපල වෙත ප්‍රවේශ වීමට උත්සාහ කරයි, එය nullදෝෂයකි:

try {
  [1,2,3,4,5]
  .forEach(
    function ( val, idx, arr ) {
      if ( val == 3 ) null.NULLBREAK;
    }
  );
} catch (e) {
  // e <=> TypeError: null has no properties
}
//

ඔබේ forEachවාක්‍ය ඛණ්ඩය තබා ගැනීමට ඔබට අවශ්‍ය නම් , මෙය කාර්යක්ෂමව තබා ගත හැකි ක්‍රමයකි (සාමාන්‍ය ලූපයක් තරම් හොඳ නොවුනත්). ඔබට ලූපයෙන් පිටතට යාමට අවශ්‍ය දැයි දන්නා විචල්‍යයක් සඳහා වහාම පරීක්ෂා කරන්න.

මෙම උදාහරණය නිර්මානය සඳහා නිර්නාමික කාර්යය භාවිතා කාර්යය විෂය පථය වටා forEachඔබ ගබඩා කිරීම සඳහා අවශ්ය කරන සිදු තොරතුරු.

(function(){
    var element = document.getElementById('printed-result');
    var done = false;
    [1,2,3,4].forEach(function(item){
        if(done){ return; }
        var text = document.createTextNode(item);
        element.appendChild(text);
        if (item === 2){
          done = true;
          return;
        }
    });
})();

<div id="printed-result"></div>

මගේ ශත දෙක.

මම දන්නවා එය නිවැරදි මාර්ගයක් නොවන බව. එය ලූපය බිඳ දැමීම නොවේ. එය ජුගාඩ් ය

let result = true;
[1, 2, 3].forEach(function(el) {
    if(result){
      console.log(el);
      if (el === 2){
        result = false;
      }
    }
});

array.prototype.everyශ්‍රිතය භාවිතා කරන්න , එමඟින් ඔබට ලූපය බිඳ දැමීමට උපයෝගීතාව ලබා දේ. උදාහරණය මෙතැනින් බලන්න මොසිල්ලා සංවර්ධක ජාලයේ ජාවාස්ක්‍රිප්ට් ප්‍රලේඛනය

ඉහළට ඔසවා ඇති බොබින්ස් සමඟ එකඟ වන්න.

එසේම, FYI:

Prototype.js සඳහා මේ සඳහා යමක් තිබේ:

<script type="text/javascript">
  $$('a').each(function(el, idx) {
    if ( /* break condition */ ) throw $break;
    // do something
  });
</script>

$break අභ්‍යන්තරව Prototype.js විසින් හසුරුවනු ලබන අතර එය "එක් එක්" චක්‍රය බිඳ දමමින් බාහිර දෝෂ ජනනය නොකරයි.

වැඩි විස්තර සඳහා Prototype.JS API බලන්න.

jQuery ට ද ක්‍රමයක් ඇත, කලින් ලූපය බිඳ දැමීම සඳහා හසුරුවන්නාගේ අසත්‍යය නැවත ලබා දෙන්න:

<script type="text/javascript">
  jQuery('a').each( function(idx) {
    if ( /* break condition */ ) return false;
    // do something

  });
</script>

විස්තර සඳහා jQuery API බලන්න.

මෙය වඩාත් කාර්යක්ෂම නොවේ, මන්ද ඔබ තවමත් සියලු අංග චක්‍රීය කර ඇති නමුත් එය ඉතා සරල ලෙස සලකා බැලීම වටී යැයි මම සිතුවෙමි:

let keepGoing = true;
things.forEach( (thing) => {
  if (noMore) keepGoing = false;
  if (keepGoing) {
     // do things with thing
  }
});

මට වැඩ කරන පහත කේතය ඔබට අනුගමනය කළ හැකිය:

 var     loopStop = false;
YOUR_ARRAY.forEach(function loop(){
    if(loopStop){ return; }
    if(condition){ loopStop = true; }
});

මම භාවිතා කිරීමට කැමතියි for in

var words = ['a', 'b', 'c'];
var text = '';
for (x in words) {
    if (words[x] == 'b') continue;
    text += words[x];
}
console.log(text);

for inබොහෝ දුරට ක්‍රියා කරන අතර forEach, ඔබට පිටවීමේ ශ්‍රිතයට නැවත එක් කළ හැකිය. වඩා හොඳ කාර්ය සාධනය ද ඇත.

ඔබගේ නඩුවේදී මෙන් දැනටමත් ඔබේ අරාවෙහි ඇති මූලද්‍රව්‍යවල වටිනාකම මත පදනම්ව ඔබට බිඳීමට අවශ්‍ය නම් (එනම්, බිඳීමේ තත්වය ධාවන කාල විචල්‍යය මත රඳා නොපවතින්නේ නම්, අරාව එහි මූලද්‍රව්‍ය අගයන් ලබා දීමෙන් පසුව වෙනස් විය හැක) ඔබට සංයෝජනය භාවිතා කළ හැකිය ක පෙත්තක් () හා indexOf () පහත සඳහන් පරිදි.

සෑම එකක්ම 'ඇපල්' වෙත ළඟා වූ විට ඔබට බිඳීමට අවශ්‍ය නම් ඔබට භාවිතා කළ හැකිය

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var fruitsToLoop = fruits.slice(0, fruits.indexOf("Apple"));
// fruitsToLoop = Banana,Orange,Lemon

fruitsToLoop.forEach(function(el) {
    // no need to break
});

W3Schools.com හි සඳහන් කර ඇති පරිදි, පෙත්ත () ක්‍රමය මඟින් අරාවෙහි තෝරාගත් අංග නව අරා වස්තුවක් ලෙස ලබා දෙයි. මුල් අරාව වෙනස් නොවේ.

එය JSFiddle හි බලන්න

එය යමෙකුට උපකාරී වේ යැයි සිතමි.

"සොයන්න" සමඟ උත්සාහ කරන්න:

var myCategories = [
 {category: "start", name: "Start", color: "#AC193D"},
 {category: "action", name: "Action", color: "#8C0095"},
 {category: "exit", name: "Exit", color: "#008A00"}
];

function findCategory(category) {
  return myCategories.find(function(element) {
    return element.category === category;
  });
}

console.log(findCategory("start"));
// output: { category: "start", name: "Start", color: "#AC193D" }

ඔබ ක ප්රභේද්යයක් නිර්මාණය කළ හැකිය forEachඒ සඳහා ඉඩ break, continue, return, සහ async/ await: (TypeScript ලියා උදාහරණයක් ලෙස)

export type LoopControlOp = "break" | "continue" | ["return", any];
export type LoopFunc<T> = (value: T, index: number, array: T[])=>LoopControlOp;

Array.prototype.ForEach = function ForEach<T>(this: T[], func: LoopFunc<T>) {
    for (let i = 0; i < this.length; i++) {
        const controlOp = func(this[i], i, this);
        if (controlOp == "break") break;
        if (controlOp == "continue") continue;
        if (controlOp instanceof Array) return controlOp[1];
    }
};

// this variant lets you use async/await in the loop-func, with the loop "awaiting" for each entry
Array.prototype.ForEachAsync = async function ForEachAsync<T>(this: T[], func: LoopFunc<T>) {
    for (let i = 0; i < this.length; i++) {
        const controlOp = await func(this[i], i, this);
        if (controlOp == "break") break;
        if (controlOp == "continue") continue;
        if (controlOp instanceof Array) return controlOp[1];
    }
};

භාවිතය:

function GetCoffee() {
    const cancelReason = peopleOnStreet.ForEach((person, index)=> {
        if (index == 0) return "continue";
        if (person.type == "friend") return "break";
        if (person.type == "boss") return ["return", "nevermind"];
    });
    if (cancelReason) console.log("Coffee canceled because: " + cancelReason);
}

ඔව්, සෑම පුඩුවක්ම ඉදිරියට ගෙනයාමට සහ පිටවීමට හැකිය.

ඉදිරියට යාමට, ඔබට නැවත භාවිතා කළ හැකිය, ලූපය දිගටම පවතිනු ඇති නමුත් වත්මන් ශ්‍රිතය අවසන් වනු ඇත.

ලූපයෙන් පිටවීම සඳහා, ඔබට තෙවන පරාමිතිය දිග 0 ක් ලෙස සැකසිය හැකිය, හිස් අරාවකට සකසන්න. ලූපය දිගටම පවතින්නේ නැත, වත්මන් ශ්‍රිතය එසේ වේ, එබැවින් ඔබට නිමාව සඳහා "ආපසු" භාවිතා කළ හැකිය, සාමාන්‍යයෙන් ලූපයක් සඳහා පිටවීම වැනි ...

මෙය:

[1,2,3,4,5,6,7,8,9,10].forEach((a,b,c) => {
    console.log(a);
    if(b == 2){return;}
    if(b == 4){c.length = 0;return;}
    console.log("next...",b);
});

මෙය මුද්‍රණය කරයි:

1
next... 0
2
next... 1
3
4
next... 3
5

පෙර, මගේ කේතය පහතින්

 this.state.itemsDataSource.forEach((item: any) => {
                if (!item.isByPass && (item.invoiceDate == null || item.invoiceNumber == 0)) {

                    return false;
                }
            });

මම පහලට වෙනස් කර ඇත, එය සවි කර ඇත.

 for (var i = 0; i < this.state.itemsDataSource.length; i++) {
                var item = this.state.itemsDataSource[i];
                if (!item.isByPass && (item.invoiceDate == null || item.invoiceNumber == 0)) {

                    return false;
                }
            }