कोणीय जेएस फोर्क को तोड़ते हैं

Question

मेरे पास कोणीय फॉरेक्स लूप है और अगर मैं किसी मूल्य से मेल खाता हूं तो मैं लूप से ब्रेक लेना चाहता हूं। निम्नलिखित कोड काम नहीं करता है।

angular.forEach([0,1,2], function(count){
  if(count == 1){
    break;
  }
});

मैं यह कैसे प्राप्त कर सकता हूं?

Comments

मुझे समझ में नहीं आता है कि आप लूप में जाने के बजाय सिर्फ वैल्यू क्यों नहीं ढूंढते। हो सकता है कि आपने जो उदाहरण दिया है वह पूरी कहानी नहीं कह रहा हो, लेकिन मैं वही करूंगा जो @Aman ने नीचे कहा था। नीचे बताए अनुसार लूप में क्यों जाएं और हर बार जब कुछ () वास्तव में अधिक सुरुचिपूर्ण तरीके से करता है तो एक चेक चलाएं। याद रखें कि यदि आप जावास्क्रिप्ट को एक कार्यात्मक भाषा के रूप में मानते हैं, तो नियंत्रण संरचनाओं के प्रकार / तोड़ने / तोड़ने के लिए इनका उपयोग करने का कोई मतलब नहीं होना चाहिए। यही कारण है कि foreach, find, some, etc मौजूद हैं

— एड्रियन रोड्रिगेज 23

Answer 1

ऐसा करने का कोई तरीका नहीं है। Https://github.com/angular/angular.js/issues/263 देखें । आप जो कर रहे हैं उसके आधार पर आप बूलियन का उपयोग सिर्फ लूप के शरीर में नहीं जा सकते हैं। कुछ इस तरह:

var keepGoing = true;
angular.forEach([0,1,2], function(count){
  if(keepGoing) {
    if(count == 1){
      keepGoing = false;
    }
  }
});

Comments

मैं केवल !keepGoing && return;फ़ंक्शन के शीर्ष, कम कोड में जोड़ना चाहूंगा ।

— एंड्रयू जोसलिन

यह सबसे अच्छा अभ्यास नहीं है, यहाँ कोणीय पूर्वाभास पाश कभी नहीं टूटता है, और कोणीय को तोड़ने के लिए कुछ भी नहीं है। लूप के लिए मूल निवासी कोणीय से लगभग 90% तेज है। इसलिए लूप के लिए देशी का उपयोग करना बेहतर होता है जब आप कंडीशन मैच पर ब्रेक लगाना चाहते हैं। धन्यवाद

— Nishchit Dhanani

xcatly जहाँ मैं फंस गया ... और इसने एक टन की मदद की ... किसी भी तरह से मैं लूप को अटूट बनाने का कारण जानना चाहूंगा। यदि कोई है

— सौरभ तिवारी

यह स्वीकार किए जाने वाले उत्तर नहीं होना चाहिए क्योंकि यह forEach लूप को नहीं तोड़ता है। यह लूप के अंदर सभी लॉजिक को निष्पादित नहीं करने का एक तरीका है।

— नेबुलसर

Answer 2

angular.forEachपाश एक शर्त मैच पर नहीं तोड़ सकते हैं।

मेरी व्यक्तिगत सलाह है कि इसके बजाय NATIVE लूप का उपयोग करें angular.forEach।

लूप के लिए नैटिव फॉर लूप लगभग 90% तेज है।

ANGULAR में लूप के लिए उपयोग करें:

var numbers = [0, 1, 2, 3, 4, 5];

for (var i = 0, len = numbers.length; i < len; i++) {
  if (numbers[i] === 1) {
    console.log('Loop is going to break.'); 
    break;
  }
  console.log('Loop will continue.');
}

Comments

यह मेरे लिए काम नहीं करता है। यह सब करता है लूप के इस विशेष पुनरावृत्ति को समाप्त करता है। लेकिन फिर यह अगले पुनरावृत्ति की ओर बढ़ता है।

— बेन

@ बेन, सॉरी बेन, यह मेरी गलती थी लेकिन अब मैं लंबे शोध के बाद अपना जवाब अपडेट करता हूं। उम्मीद है इससे आपको मदद मिलेगी । धन्यवाद

— Nishchit Dhanani

@ लामा: - आपका मामला क्या है ??

— निशचित धनानी

jsperf.com/angular-foreach-performance यह तय करने के लिए अपने ब्राउज़र पर परीक्षण करें कि आपको कौन सा फ़ंक्शन चुनना चाहिए। मैंने IE11 पर परीक्षण किया है और यह स्क्रीनशॉट में भी उतना ही तेज़ है। इसके अलावा Array.some () का परीक्षण किया है, लेकिन यह IE11 पर Array.forEach () धीमा है, लेकिन फिर तेज हो सकता है। या इसका परीक्षण यहाँ करें jsperf.com/angular-foreach-vs-native (सभी क्रेडिट मूल में जाते हैं, मुझसे नहीं ;-))

— सेबस्टियन

Jsperf के साथ भी आप यह नहीं कह सकते हैं कि "मूल निवासी लगभग 90% तेज है"। आपके परिदृश्य में यह अत्यधिक इस बात पर निर्भर करता है कि आंतरिक फ़ंक्शन का निष्पादन कितना महंगा है और कितने निष्पादन को लूप से बाहर निकलने (ब्रेक) से बचाया जा सकता है।

— होजेबेल

Answer 3

कृपया ForEach के कुछ या हर उदाहरण का उपयोग करें,

Array.prototype.some:
some is much the same as forEach but it break when the callback returns true

Array.prototype.every:
every is almost identical to some except it's expecting false to break the loop.

कुछ के लिए उदाहरण:

var ary = ["JavaScript", "Java", "CoffeeScript", "TypeScript"];

ary.some(function (value, index, _ary) {
    console.log(index + ": " + value);
    return value === "JavaScript";
});

हर के लिए उदाहरण:

var ary = ["JavaScript", "Java", "CoffeeScript", "TypeScript"];

ary.every(function(value, index, _ary) {
    console.log(index + ": " + value);
    return value.indexOf("Script") > -1;
});

अधिक जानकारी प्राप्त करें
http://www.jsnoob.com/2013/11/26/how-to-break-the-foreach/

Comments

कोई @ AngelS.Moreno, हर कोई एक विधि हाथ में मामले के लिए विशेष रूप से डिजाइन के बजाय एक स्थानीय चर का उपयोग करना पसंद

— Oded एनआईवी

Answer 4

कुछ विधि का उपयोग करें

 var exists = [0,1,2].some(function(count){
      return count == 1
 });

मौजूद सत्य वापस आ जाएगा, और आप इसे अपने फ़ंक्शन में एक चर के रूप में उपयोग कर सकते हैं

if(exists){
    console.log('this is true!')
}

ऐरे कुछ विधि - जावास्क्रिप्ट

Comments

मेरे लिए, उपयोग करने का एकमात्र कारण यह angular.forEach()है कि मुझे IE8 का समर्थन करना है, जिसमें Array.forEach()... या नहीं है Array.some()।

— बेनेट McElwee

आप आसानी से Array.forEach को पॉलीफ़िल कर सकते हैं। पृष्ठ के नीचे देखें: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— zumalifeguard

Answer 5

जहाँ तक मुझे पता है, कोणीय इस तरह के एक समारोह प्रदान नहीं करता है। आप इसके लिए अंडरस्कोर find()फ़ंक्शन का उपयोग करना चाह सकते हैं (यह मूल रूप से एक फ़ोरच है जो फ़ंक्शन के सही होने पर लूप से बाहर निकलता है)।

http://underscorejs.org/#find

Comments

यह बाद में समस्या को हल कर सकता है, लेकिन यह विलेख में लूप को नहीं तोड़ता है।

— ऐलिस

या लूप के लिए देशी

— शांति

Answer 6

यदि आप AngularJS के साथ संयोजन के रूप में jQuery (इसलिए jqLite नहीं) का उपयोग करते हैं तो आप $ .each के साथ पुनरावृत्ति कर सकते हैं - जो बूलियन रिटर्न वैल्यू अभिव्यक्ति के आधार पर ब्रेकिंग और जारी रखने की अनुमति देता है।

JSFiddle:

http://jsfiddle.net/JEcD2/1/

जावास्क्रिप्ट:

var array = ['foo', 'bar', 'yay'];
$.each(array, function(index, element){
    if (element === 'foo') {
        return true; // continue
    }
    console.log(this);
    if (element === 'bar') {
        return false; // break
    }
});

ध्यान दें:

यद्यपि jQuery का उपयोग करना बुरा नहीं है, लेकिन दोनों मूल Array.some या Array.every फ़ंक्शंस MDN द्वारा अनुशंसित हैं, जैसा कि आप मूल विदेशी दस्तावेज़ में पढ़ सकते हैं :

"फॉरच लूप को रोकने या तोड़ने का कोई तरीका नहीं है। समाधान Array.every या Array.some का उपयोग करना है"

MDN द्वारा निम्नलिखित उदाहरण दिए गए हैं:

Array.some:

function isBigEnough(element, index, array){
    return (element >= 10);
}
var passed = [2, 5, 8, 1, 4].some(isBigEnough);
// passed is false
passed = [12, 5, 8, 1, 4].some(isBigEnough);
// passed is true

Array.every:

function isBigEnough(element, index, array){
    return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

Answer 7

लगातार, आप एक forEachपाश से बाहर निकल सकते हैं , और किसी भी स्थान पर, एक अपवाद फेंक सकते हैं।

try {
   angular.forEach([1,2,3], function(num) {
      if (num === 2) throw Error();
   });
} catch(e) {
    // anything
}

हालांकि, यह बेहतर है कि आप अन्य पुस्तकालय का उपयोग करें या अपने स्वयं के फ़ंक्शन को लागू करें, findइस मामले में एक फ़ंक्शन है, इसलिए आपका कोड सबसे उच्च-स्तरीय है।

Comments

खैर, आपने सवाल का जवाब दिया! मुझे आशा है कि कोई भी ऐसा नहीं करता है :)

— जेसन कॉक्स

अनावश्यक रूप से एक अपवाद को फेंकना स्थिति को संभालने का अच्छा तरीका नहीं है। बल्कि @ dnc253 stackoverflow.com/a/13844508/698127

— Aamol

Answer 8

इसे तोड़ने की कोशिश करो;

angular.forEach([0,1,2], function(count){
  if(count == 1){
    return true;
  }
});

Answer 9

अन्य उत्तर के रूप में, कोणीय इस कार्यक्षमता प्रदान नहीं करता है। jQuery हालांकि करता है, और यदि आपने jQuery के साथ-साथ कोणीय भी लोड किया है, तो आप उपयोग कर सकते हैं

jQuery.each ( array, function ( index, value) {
    if(condition) return false; // this will cause a break in the iteration
})

Http://api.jquery.com/jquery.each/ देखें

Comments

ओपी ने एक AngularJS सॉल्यूशन मांगा, इसका सही जवाब है NO :)

— शैनन होच्किन्स

Answer 10

सामान्य रूप से जावास्क्रिप्ट में "प्रत्येक" लूप को तोड़ने का कोई तरीका नहीं है। आमतौर पर "शॉर्ट सर्किट" विधि का उपयोग करने के लिए क्या किया जा सकता है।

    array.forEach(function(item) {
      // if the condition is not met, move on to the next round of iteration.
      if (!condition) return;

      // if the condition is met, do your logic here
      console.log('do stuff.')
    }

Answer 11

break कोणीय forEach में प्राप्त करना संभव नहीं है, हमें ऐसा करने के लिए forEach को संशोधित करना होगा।

$scope.myuser = [{name: "Ravi"}, {name: "Bhushan"}, {name: "Thakur"}];  
                angular.forEach($scope.myuser, function(name){
                  if(name == "Bhushan") {
                    alert(name);
                    return forEach.break(); 
                    //break() is a function that returns an immutable object,e.g. an empty string
                  }
                });

Comments

यह उत्तर पूर्ण प्रतीत नहीं होता है। कृपया बताएं कि क्या break()परिभाषित करने की आवश्यकता है या इसे पहले से ही कोणीय का हिस्सा है। कृपया परिभाषित करें यदि नहीं।

— भूगर्भिक

Answer 12

आप इसका उपयोग कर सकते हैं:

var count = 0;
var arr = [0,1,2];
for(var i in arr){
   if(count == 1) break;
   //console.log(arr[i]);
}

Answer 13

var ary = ["JavaScript", "Java", "CoffeeScript", "TypeScript"];
var keepGoing = true;
ary.forEach(function(value, index, _ary) {
    console.log(index)
    keepGoing = true;
    ary.forEach(function(value, index, _ary) {
        if(keepGoing){ 
            if(index==2){
                keepGoing=false;
            }
            else{
                console.log(value)
            }

        }      
    });
});

Answer 14

$scope.arr = [0, 1, 2];  
$scope.dict = {}
for ( var i=0; i < $scope.arr.length; i++ ) {
    if ( $scope.arr[i] == 1 ) {
        $scope.exists = 'yes, 1 exists';
        break;
    }
 }
 if ( $scope.exists ) {
     angular.forEach ( $scope.arr, function ( value, index ) {
                      $scope.dict[index] = value;
     });
 }

Answer 15

मैं वापसी से ऐसा करना पसंद करूंगा। लूपिंग भाग को निजी फ़ंक्शन में रखें और जब आप लूप को तोड़ना चाहते हैं तब वापस लौटें।

Answer 16

मुझे लगता है कि यह पुराना है, लेकिन एक सरणी फ़िल्टर वह कर सकता है जिसकी आपको आवश्यकता है:

var arr = [0, 1, 2].filter(function (count) {
    return count < 1;
});

फिर आप चला सकते हैं arr.forEachऔर अन्य सरणी फ़ंक्शंस कर सकते हैं ।

मुझे एहसास है कि यदि आप पूरी तरह से लूप के संचालन में कटौती करने का इरादा रखते हैं, तो यह संभवतः वह नहीं करेगा जो आप चाहते हैं। उसके लिए आप सबसे अच्छा उपयोग करें while।

Answer 17

यह उदाहरण काम करता है। कोशिश करो।

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

Comments

मुझे लगता है कि वह एक forलूप नहीं चाहता है , उसके उपयोग के मामले को शायद foreachनहींfor

— हसन चौ।

Answer 18

लूप को तोड़ने के लिए रिटर्न का उपयोग करें।

angular.forEach([0,1,2], function(count){
  if(count == 1) {
    return;
  }
});

Answer 19

onSelectionChanged(event) {
    let selectdata = event['api']['immutableService']['gridOptionsWrapper']['gridOptions']['rowData'];
    let selected_flag = 0;

    selectdata.forEach(data => {
      if (data.selected == true) {
        selected_flag = 1;
      }
    });

    if (selected_flag == 1) {
      this.showForms = true;
    } else {
      this.showForms = false;
    }
}

Answer 20

के returnबदले मैं उपयोग करूंगा break।

angular.forEach([0,1,2], function(count){
  if(count == 1){
    return;
  }
});

एक जादू की तरह काम करता है।

Comments

यह एक वैध समाधान नहीं है। लुक: फंक्शन टेस्ट () {angular.forEach ([1,2,3,4,5,6,7,8,9], फंक्शन (वैल्यू, इंडेक्स) {अगर (वैल्यू == 2) रिटर्न; कंसोल; (मान);})} आउटपुट:> teste (); 1 3 4 5 6 7 8 9

— otaviodecampos

Answer 21

बस $ इंडेक्स जोड़ें और निम्न कार्य करें:

angular.forEach([0,1,2], function(count, $index) {
     if($index !== 1) {
          // do stuff
     }
}

Comments

ओपी लूप से बाहर निकलना चाहता है।

— एंजेल एस। मोरेनो