फ़ोरैच लूप: Difference between revisions

Revision as of 10:54, 20 July 2023

foreach लूप्स का उपयोग लगभग हमेशा तत्वों के अनुक्रम में आइटमों को पुनरावृत्त करने के लिए किया जाता है।

कंप्यूटर प्रोग्रामिंग में, फ़ोरैच लूप (या प्रत्येक लूप के लिए) एक संग्रह वर्ग में आइटमों को पार करने के लिए एक नियंत्रण प्रवाह विवरण है। फॉरएच(foreach) का प्रयोग आमतौर पर मानक के स्थान पर किया जाता है for लूप स्टेटमेंट (कंप्यूटर विज्ञान)। दूसरे के विपरीत for लूप निर्माण, तथापि, foreach लूप्स^[1] आम तौर पर कोई स्पष्ट काउंटर नहीं रखते: वे अनिवार्य रूप से कहते हैं कि ऐसा करने के बजाय इस सेट में हर चीज के साथ ऐसा करें x बार . यह संभावित ऑफ-बाय-वन त्रुटियों से बचाता है और कोड को पढ़ने में आसान बनाता है। वस्तु के उन्मुख भाषाओं में, एक पुनरावर्तक, भले ही अंतर्निहित हो, अक्सर ट्रैवर्सल के साधन के रूप में उपयोग किया जाता है। वह foreach कुछ भाषाओं में कथन में कुछ परिभाषित क्रम होता है, जो संग्रह में प्रत्येक आइटम को पहले से आखिरी तक संसाधित करता है। वह foreachकई अन्य भाषाओं में, विशेष रूप से सरणी प्रोग्रामिंग भाषाओं में, कथन का कोई विशेष क्रम नहीं होता है। यह सामान्य रूप से लूप अनुकूलन को सरल बनाता है और विशेष रूप से संग्रह में वस्तुओं के वेक्टर प्रसंस्करण को समवर्ती रूप से अनुमति देता है।

सिंटेक्स

भाषाओं के बीच वाक्य-विन्यास भिन्न-भिन्न होता है। अधिकांश सरल शब्द का प्रयोग करते हैं for, मोटे तौर पर इस प्रकार है:

for each item in collection:
  do something to item

भाषा समर्थन

एक्शनस्क्रिप्ट 3.0

एक्शनस्क्रिप्ट ईCएमएस्क्रिप्ट 4.0 मानक का समर्थन करता है^[5] के लिए for each .. in^[6] जो प्रत्येक सूचकांक पर मूल्य खींचता है।

var foo:Object = {
	"apple":1,
	"orange":2
};

for each (var value:int in foo) { 
	trace(value); 
}

// returns "1" then "2"

यह भी सपोर्ट करता है for .. in^[7] जो प्रत्येक सूचकांक पर कुंजी खींचता है।

for (var key:String in foo) { 
	trace(key); 
}

// returns "apple" then "orange"

===वहाँ === है

Ada (प्रोग्रामिंग भाषा) सामान्य for लूप के भाग के रूप में foreach लूप का समर्थन करता है। कहें कि X एक ऐरे डेटा संरचना है:

for I in X'Range loop
   X (I) := Get_Next_Element;
end loop;

इस सिंटैक्स का उपयोग ज्यादातर सरणियों पर किया जाता है, लेकिन पूर्ण पुनरावृत्ति की आवश्यकता होने पर यह अन्य प्रकारों के साथ भी काम करेगा।

एडीए 2012 ने किC भी प्रकार के कंटेनर (सरणी, सूचियां, मानचित्र ...) पर फ़ोरैच लूप के लिए लूप को सामान्यीकृत किया है:

for Obj of X loop
   -- Work on Obj
end loop;

C

C (प्रोग्रामिंग भाषा) भाषा में संग्रह या फ़ोरैच निर्माण नहीं है। हालाँकि, इसमें कई मानक डेटा संरचनाएँ हैं जिनका उपयोग संग्रह के रूप में किया जा सकता है, और फ़ोरैच को C मैक्रो के साथ आसानी से बनाया जा सकता है।

हालाँकि, दो स्पष्ट समस्याएँ उत्पन्न होती हैं:

मैक्रो अस्वच्छ है: यह मौजूदा दायरे में एक नया वैरिएबल घोषित करता है जो लूप के बाद भी बना रहता है।
एक फ़ोरैच मैक्रो को परिभाषित नहीं किया जा सकता है जो विभिन्न संग्रह प्रकारों (उदाहरण के लिए, सरणी और लिंक की गई सूची) के साथ काम करता है या जो उपयोगकर्ता प्रकारों के लिए विस्तार योग्य है।

चार के संग्रह के रूप में C स्ट्रिंग

#include <stdio.h>

/* foreach macro viewing a string as a collection of char values */
#define foreach(ptrvar, strvar) \
char* ptrvar; \
for (ptrvar = strvar; (*ptrvar) != '\0'; *ptrvar++)

int main(int argc, char** argv) {
 char* s1 = "abcdefg";
 char* s2 = "123456789";
 foreach (p1, s1) {
  printf("loop 1: %c\n", *p1);
 }
 foreach (p2, s2) {
  printf("loop 2: %c\n", *p2);
 }
 return 0;
}

C int सारणी int के संग्रह के रूप में (सरणी का आकार संकलन-समय पर ज्ञात होता है)

#include <stdio.h>

/* foreach macro viewing an array of int values as a collection of int values */
#define foreach(intpvar, intarr) \
int* intpvar; \
for (intpvar = intarr; intpvar < (intarr + (sizeof(intarr)/sizeof(intarr[0]))); ++intpvar)

int main(int argc, char** argv) {
 int a1[] = {1, 1, 2, 3, 5, 8};
 int a2[] = {3, 1, 4, 1, 5, 9};
 foreach (p1, a1) {
  printf("loop 1: %d\n", *p1);
 }
 foreach (p2, a2) {
  printf("loop 2: %d\n", *p2);
 }
 return 0;
}

सबसे सामान्य: संग्रह के रूप में स्ट्रिंग या सरणी (रन-टाइम पर ज्ञात संग्रह आकार)

टिप्पणी: idxtype को हटाया जा सकता है और typeof(col[0]) इसके स्थान पर जीएनयू कंपाइलर संग्रह के साथ प्रयोग किया गया

#include <stdio.h>
#include <string.h>

/* foreach macro viewing an array of given type as a collection of values of given type */
#define arraylen(arr) (sizeof(arr)/sizeof(arr[0]))
#define foreach(idxtype, idxpvar, col, colsiz) \
idxtype* idxpvar; \
for (idxpvar = col; idxpvar < (col + colsiz); ++idxpvar)

int main(int argc, char** argv) {
 char* c1 = "collection";
 int c2[] = {3, 1, 4, 1, 5, 9};
 double* c3;
 int c3len = 4;
 c3 = (double*)calloc(c3len, sizeof(double)); 
 c3[0] = 1.2; c3[1] = 3.4; c3[2] = 5.6; c3[3] = 7.8;

 foreach (char, p1, c1, strlen(c1)) {
  printf("loop 1: %c\n", *p1);
 }
 foreach (int, p2, c2, arraylen(c2)) {
  printf("loop 2: %d\n", *p2);
 }
 foreach (double, p3, c3, c3len) {
  printf("loop 3: %.1lf\n", *p3);
 }
 return 0;
}

C#

C# में, यह मानते हुए कि myArray पूर्णांकों की एक सरणी है:

foreach (int x in myArray) { Console.WriteLine(x); }

लैंग्वेज इंटीग्रेटेड क्वेरी (LINQ) एक प्रतिनिधि (CLI) या लैम्ब्डा (प्रोग्रामिंग) को स्वीकार करते हुए निम्नलिखित सिंटैक्स प्रदान करती है:

myArray.ToList().ForEach(x => Console.WriteLine(x));

C++

C++11 एक फ़ोरैच लूप प्रदान करता है। सिंटैक्स फ़ोरैच लूप#जावा के समान है:

#include <iostream>

int main()
{
  int myint[] = {1, 2, 3, 4, 5};

  for (int i : myint)
  {
    std::cout << i << '\n';
  }
}

कथनों के लिए C++11 रेंज-आधारित को GNU कंपाइलर कलेक्शन (GCC) (संस्करण 4.6 से), बजना (संस्करण 3.0 से) और विज़ुअल C++ 2012 (संस्करण 11) में लागू किया गया है। ^[8])

रेंज आधारित for वाक्यात्मक शर्करा इसके समतुल्य है:

  for (auto __anon = begin(myint); __anon != end(myint); ++__anon)
  {
    auto i = *__anon;
    std::cout << i << '\n';
  }

संकलक इसे हल करने के लिए तर्क-निर्भर लुकअप का उपयोग करता है begin और end कार्य.^[9] C++ मानक लाइब्रेरी भी समर्थन करती है for_each,^[10] यह प्रत्येक तत्व को एक फ़ंक्शन पर लागू करता है, जो कोई भी पूर्वनिर्धारित फ़ंक्शन या लैम्ब्डा अभिव्यक्ति हो सकता है। जबकि रेंज-आधारित केवल शुरुआत से अंत तक है, रेंज और दिशा आप पहले दो मापदंडों को बदलकर दिशा या रेंज बदल सकते हैं।

#include <iostream>
#include <algorithm> // contains std::for_each
#include <vector>

int main()
{
  std::vector<int> v {1, 2, 3, 4, 5};

  std::for_each(v.begin(), v.end(), [](int i)
  {
    std::cout << i << '\n';
  });

  std::cout << "reversed but skip 2 elements:\n";

  std::for_each(v.rbegin()+2, v.rend(), [](int i)
  {
    std::cout << i << '\n';
  });
}

Qt (सॉफ़्टवेयर), एक C++ फ़्रेमवर्क, फ़ोरैच लूप प्रदान करने वाला एक मैक्रो प्रदान करता है^[11] एसटीएल इटरेटर इंटरफ़ेस का उपयोग करना:

#include <QList>
#include <QDebug>

int main()
{
  QList<int> list;

  list << 1 << 2 << 3 << 4 << 5;

  foreach (int i, list)
  {
    qDebug() << i;
  }
}

बूस्ट (C++ लाइब्रेरीज़), मुफ़्त पीयर-रिव्यू पोर्टेबल C++ लाइब्रेरीज़ का एक सेट फ़ोरैच लूप भी प्रदान करता है:^[12]

#include <boost/foreach.hpp>
#include <iostream>
 
int main()
{
  int myint[] = {1, 2, 3, 4, 5};
 
  BOOST_FOREACH(int &i, myint)
  {
    std::cout << i << '\n';
  }
}

C++/Cएलआई

C++/CLI भाषा C# के समान एक निर्माण का प्रस्ताव करती है।

यह मानते हुए कि myArray पूर्णांकों की एक सरणी है: <सिंटैक्सहाइलाइट लैंग = C# > प्रत्येक के लिए (myArray में int x) {

   कंसोल::राइटलाइन(x);

} </सिंटैक्सहाइलाइट>

कोल्डफ्यूजन मार्कअप लैंग्वेज (Cएफएमएल)

स्क्रिप्ट सिंटैक्स

// arrays
arrayeach([1,2,3,4,5], function(v){
    writeOutput(v);
});

// or

for (v in [1,2,3,4,5]){
    writeOutput(v);
}

// or

// (Railo only; not supported in ColdFusion)
letters = ["a","b","c","d","e"];
letters.each(function(v){
    writeOutput(v); // abcde
});

// structs
for (k in collection){
    writeOutput(collection[k]);
}

// or

structEach(collection, function(k,v){
    writeOutput("key: #k#, value: #v#;");
});

// or
// (Railo only; not supported in ColdFusion)
collection.each(function(k,v){
    writeOutput("key: #k#, value: #v#;");
});

टैग सिंटैक्स

<!--- arrays --->
<cfloop index="v" array="#['a','b','c','d','e']#">
  <cfoutput>#v#</cfoutput><!--- a b c d e  --->
</cfloop>

Cएफएमएल इस निर्माण में सूचकांक के रूप में मूल्य की गलत पहचान करता है; index वेरिएबल को सरणी तत्व का वास्तविक मान प्राप्त होता है, न कि उसका सूचकांक।

<!--- structs --->
<cfloop item="k" collection="#collection#">
    <cfoutput>#collection[k]#</cfoutput>
</cfloop>

सामान्य लिस्प

कॉमन लिस्प डोलिस्ट मैक्रो के साथ फ़ोरैच क्षमता प्रदान करता है:

(dolist (i '(1 3 5 6 8 10 14 17))
  (print i))

या अधिक डेटा प्रकारों पर पुनरावृति करने के लिए शक्तिशाली लूप मैक्रो

(loop for i in '(1 3 5 6 8 10 14 17)
      do (print i))

और यहां तक कि मैपकार फ़ंक्शन के साथ भी:

(mapcar #'print '(1 3 5 6 8 10 14 17))

डी

foreach(item; set) {
  // do something to item
}

या

foreach(argument) {
  // pass value
}

डार्ट

for (final element in someCollection) {
  // do something with element
}

ऑब्जेक्ट पास्कल, डेल्फ़ी

फ़ोरैच समर्थन डेल्फ़ी (प्रोग्रामिंग भाषा) 2005 में जोड़ा गया था, और एक एन्यूमरेटर वैरिएबल का उपयोग करता है जिसे var अनुभाग में घोषित किया जाना चाहिए।

for enumerator in collection do
begin
  //do something here
end;

एफिल

एफिल (प्रोग्रामिंग भाषा) लूप निर्माण का पुनरावृत्ति (foreach) रूप कीवर्ड across द्वारा प्रस्तुत किया गया है।

इस उदाहरण में, संरचना का प्रत्येक तत्व my_list मुद्रित है:

            across my_list as ic loop print (ic.item) end

स्थानीय इकाई ic लाइब्रेरी क्लास का एक उदाहरण है ITERATION_CURSOR. कर्सर की विशेषता item प्रत्येक संरचना तत्व तक पहुंच प्रदान करता है। वर्ग के वंशज ITERATION_CURSOR विशेष पुनरावृत्ति एल्गोरिदम को संभालने के लिए बनाया जा सकता है। वस्तुओं के प्रकार जिन्हें पुनरावृत्त किया जा सकता है (my_list उदाहरण में) उन कक्षाओं पर आधारित हैं जो लाइब्रेरी कक्षा से प्राप्त होती हैं ITERABLE.

एफिल लूप के पुनरावृत्ति रूप का उपयोग कीवर्ड के समय बूलियन अभिव्यक्ति के रूप में भी किया जा सकता है loop या तो द्वारा प्रतिस्थापित किया जाता है all (सार्वभौमिक परिमाणीकरण को प्रभावित करना) या some (अस्तित्व संबंधी परिमाणीकरण को प्रभावित करना)।

यह पुनरावृत्ति एक बूलियन अभिव्यक्ति है जो सभी आइटमों के लिए सत्य है my_list जिनकी संख्या तीन से अधिक है:

            across my_list as ic all ic.item.count > 3 end

यदि कम से कम एक आइटम की संख्या तीन से अधिक है तो निम्नलिखित सत्य है:

            across my_list as ic some ic.item.count > 3 end

जाओ

गो (प्रोग्रामिंग भाषा) के फ़ोरैच लूप का उपयोग किC सरणी, स्लाइस, स्ट्रिंग, मैप या चैनल पर लूप करने के लिए किया जा सकता है।

दो-मूल्य वाले फॉर्म का उपयोग करके, हमें सूचकांक/कुंजी (पहला तत्व) और मान (दूसरा तत्व) मिलता है:

for index, value := range someCollection {
	// Do something to index and value
}

एक-मान प्रपत्र का उपयोग करके, हमें सूचकांक/कुंजी (पहला तत्व) मिलता है:

for index := range someCollection {
	// Do something to index
}

^[13]

ग्रूवी

ग्रूवी (प्रोग्रामिंग भाषा) सरणियों, सूचियों और श्रेणियों जैसे संग्रहों पर लूप का समर्थन करती है:

def x = [1,2,3,4]
for (v in x)           // loop over the 4-element array x
{
    println v
}

for (v in [1,2,3,4])   // loop over 4-element literal list 
{
    println v
}

for (v in 1..4)        // loop over the range 1..4
{
    println v
}

ग्रूवी एक ऐरे इंडेक्स के साथ लूप के लिए C-स्टाइल का भी समर्थन करता है:

for (i = 0; i < x.size(); i++)
{
    println x[i]
}

ग्रूवी में संग्रहों को प्रत्येक कीवर्ड का उपयोग करके भी दोहराया जा सकता है और एक समापन. डिफ़ॉल्ट रूप से, लूप डमी को इसका नाम दिया गया है

x.each{ println it }     // print every element of the x array
x.each{i-> println i}    // equivalent to line above, only loop dummy explicitly named "i"

हास्केल

हास्केल (प्रोग्रामिंग भाषा) मोनाड (कार्यात्मक प्रोग्रामिंग) क्रियाओं का उपयोग करके सूचियों पर लूपिंग की अनुमति देता है mapM_ और forM_ (mapM_ इसके तर्क फ़्लिप के साथ) Control.Monad से:

code	prints
mapM_ print [1..4]	1 2 3 4
forM_ "test" $ \char -> do putChar char putChar char	tteesstt

उन कार्यों को मोनैड और किC भी डेटा संरचना के बजाय एप्लिकेटिव फ़ैक्टर्स पर काम करने के लिए सामान्यीकृत करना भी संभव है, जिसका उपयोग करके ट्रैवर्स किया जा सकता है। traverse (for इसके तर्क फ़्लिप किए गए) और mapM (forM इसके तर्क फ़्लिप के साथ) Data.Traversable से।

मिश्रित

for (value in iterable) {
    trace(value);
}

Lambda.iter(iterable, function(value) trace(value));

जावा

जावा (प्रोग्रामिंग भाषा) में, जावा डेवलपमेंट किट (जेडीके) 1.5.0 में एक फ़ोरैच-कंस्ट्रक्ट पेश किया गया था।^[14] आधिकारिक स्रोत निर्माण के लिए कई नामों का उपयोग करते हैं। इसे एन्हांस्ड फॉर लूप के रूप में जाना जाता है,^[14]प्रत्येक लूप के लिए,^[15] और फ़ोरैच कथन।^[16]^[17]^: 264

for (Type item : iterableCollection) {
    // Do something to item
}

जावा 8 के बाद से जावा स्ट्रीम एपीआई भी प्रदान करता है:^[17]^{: 294–203}

   List<Integer> intList = List.of(1, 2, 3, 4);
   intList.stream().forEach(i -> System.out.println(i));

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

ईCएमएस्क्रिप्ट 6 मानक है for..of जनरेटर, सरणियों और अधिक पर सूचकांक-रहित पुनरावृत्ति के लिए:

for (var item of array){
    // Do stuff
}

वैकल्पिक रूप से, फ़ंक्शन-आधारित शैली: ^[18]

array.forEach(item => {
    // Do stuff
})

किC ऑब्जेक्ट में कुंजियों पर अव्यवस्थित पुनरावृत्ति के लिए, जावास्क्रिप्ट की सुविधा है for...in कुंडली:

for (var key in object) {
    // Do stuff with object[key]
}

ऑब्जेक्ट के स्वयं के गुणों की पुनरावृत्ति को Cमित करने के लिए, प्रोटोटाइप श्रृंखला के माध्यम से विरासत में मिले गुणों को छोड़कर, कभी-कभी hasOwnProperty() परीक्षण जोड़ना उपयोगी होता है, यदि जावास्क्रिप्ट इंजन द्वारा समर्थित है (WebKit/Safari के लिए, इसका मतलब संस्करण 3 या बाद में है) .

for (var key in object) {
    if (object.hasOwnProperty(key)) {
        // Do stuff with object[key]
    }
}

ईCएमएस्क्रिप्ट 5 ने किC ऑब्जेक्ट की स्वयं की कुंजियों को सरणी में स्थानांतरित करने के लिए ऑब्जेक्ट.कीज़ विधि प्रदान की।^[19]

var book = { name: "A Christmas Carol", author: "Charles Dickens" }; 
for(var key of Object.keys(book)){
    alert("PropertyName = " key + " Property Value = " + book[key]);
}

दूसरा^[20]

केवल संख्यात्मक सूचकांक मानों के माध्यम से पुनरावृति करें:

for index, value in ipairs(array) do
	-- do something
end

सभी सूचकांक मानों के माध्यम से पुनरावृति करें:

for index, value in pairs(array) do
	-- do something
end

गणित

गणित में, Do किC भी मूल्य को लौटाए बिना, सूची के प्रत्येक तत्व के लिए बस एक अभिव्यक्ति का मूल्यांकन करेगा।

In[]:= Do[doSomethingWithItem, {item, list}]

इसका प्रयोग अधिक सामान्य है Table, जो प्रत्येक मूल्यांकन का परिणाम एक नई सूची में लौटाता है।

In[]:= list = {3, 4, 5};

In[]:= Table[item^2, {item, list}]
Out[]= {9, 16, 25}

मतलब

for item = array
%do something
end

पुदीना

प्रत्येक लूप के लिए मिंट में निम्नलिखित सिंटैक्स का समर्थन किया जाता है:

for each element of list
    /* 'Do something.' */
end

for (;;) ई>या while (true) अनंत लूप

मिंट में प्रत्येक लूप के लिए और एक अनंत सेट का उपयोग करके लिखा जा सकता है।^[21]

import type
/* 'This function is mapped to'
 * 'each index number i of the'
 * 'infinitely long list.'
 */
sub identity(x)
    return x
end
/* 'The following creates the list'
 * '[0, 1, 2, 3, 4, 5, ..., infinity]'
 */
infiniteList = list(identity)
for each element of infiniteList
    /* 'Do something forever.' */
end

उद्देश्य-C

फ़ोरैच लूप्स, जिन्हें ऑब्जेक्टिव-C#फ़ास्ट एन्यूमरेशन कहा जाता है, ऑब्जेक्टिव-C 2.0 में शुरू होने पर समर्थित हैं। उनका उपयोग किC भी ऑब्जेक्ट पर पुनरावृति करने के लिए किया जा सकता है जो NSFastEnumeration प्रोटोकॉल को लागू करता है, जिसमें NSArray, NSDictionary (कुंजी पर पुनरावृत्त), NSSet, आदि शामिल हैं।

NSArray *a = [NSArray new];       // Any container class can be substituted

for(id obj in a) {                // Note the dynamic typing (we do not need to know the
                                  // Type of object stored in 'a'.  In fact, there can be
                                  // many different types of object in the array.

    printf("%s\n", [[obj description] UTF8String]);  // Must use UTF8String with %s
    NSLog(@"%@", obj);                               // Leave as an object
}

NSArrays अपने सदस्यों को एक संदेश भी प्रसारित कर सकता है:

NSArray *a = [NSArray new];

[a makeObjectsPerformSelector:@selector(printDescription)];

जहां ब्लॉक (C भाषा एक्सटेंशन) उपलब्ध हैं, एक एनएसएआरएआरई स्वचालित रूप से प्रत्येक निहित आइटम पर एक ब्लॉक निष्पादित कर सकता है:

[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop)
	{
		NSLog(@"obj %@", obj);
		if ([obj shouldStopIterationNow])
			*stop = YES;
	}];

पुनरावृत्त किए जा रहे संग्रह का प्रकार प्रत्येक पुनरावृत्ति के साथ लौटाए गए आइटम को निर्धारित करेगा। उदाहरण के लिए:

NSDictionary *d = [NSDictionary new];

for(id key in d) {
    NSObject *obj = [d objectForKey:key];      // We use the (unique) key to access the (possibly nonunique) object.
    NSLog(@"%@", obj);
}

ओकैमल

OCaml एक कार्यात्मक भाषा है। इस प्रकार, फ़ोरैच लूप के समतुल्य को सूचियों और सरणियों पर लाइब्रेरी फ़ंक्शन के रूप में प्राप्त किया जा सकता है।

सूचियों के लिए:

List.iter (fun x -> print_int x) [1;2;3;4];;

या संक्षेप में:

List.iter print_int [1;2;3;4];;

सरणियों के लिए:

Array.iter (fun x -> print_int x) [|1;2;3;4|];;

या संक्षेप में:

Array.iter print_int [|1;2;3;4|];;

पैरासेल

पैरासेल (प्रोग्रामिंग भाषा) समानांतर प्रोग्रामिंग भाषा कई प्रकार के पुनरावर्तकों का समर्थन करती है, जिसमें एक कंटेनर पर प्रत्येक पुनरावर्तक के लिए एक सामान्य शामिल है:

var Con : Container<Element_Type> := ...
// ...
for each Elem of Con concurrent loop  // loop may also be "forward" or "reverse" or unordered (the default)
  // ... do something with Elem
end loop

पैरासेल इटरेटर्स पर फ़िल्टर और मानचित्र की कुंजी और मान दोनों को संदर्भित करने की क्षमता का भी समर्थन करता है। यहां My_Map के तत्वों पर आगे की पुनरावृत्ति दी गई है, केवल उन तत्वों का चयन करें जहां कुंजी My_Set में हैं:

var My_Map : Map<Key_Type => Univ_String, Value_Type => Tree<Integer>> := ...
const My_Set : Set<Univ_String> := ["abc", "def", "ghi"];

for each [Str => Tr] of My_Map {Str in My_Set} forward loop
   // ... do something with Str or Tr
end loop

पास्कल

पास्कल (प्रोग्रामिंग भाषा) में, आईएसओ मानक 10206:1990 ने पास्कल (प्रोग्रामिंग भाषा)#सेट प्रकारों पर पुनरावृत्ति की शुरुआत की, इस प्रकार:

var
  elt: ElementType;
  eltset: set of ElementType;

{...}

for elt in eltset do
  { ... do something with elt }

पर्ल

पर्ल में, किC सूची के तत्वों को पार करने के लिए foreach (जो छोटे for के बराबर है) का उपयोग किया जा सकता है। अभिव्यक्ति जो संग्रह को लूप करने के लिए दर्शाती है, उसका मूल्यांकन सूची-संदर्भ में किया जाता है और परिणामी सूची के प्रत्येक आइटम को, बदले में, लूप वैरिएबल के रूप में उपनाम दिया जाता है।

शाब्दिक उदाहरण सूचीबद्ध करें:

foreach (1, 2, 3, 4) {
    print $_;
}

सरणी उदाहरण:

foreach (@arr) {
    print $_;
}

foreach $x (@arr) { #$x is the element in @arr
    print $x;
}

हैश उदाहरण:

foreach $x (keys %hash) {
    print $x . " = " . $hash{$x}; # $x is a key in %hash and $hash{$x} is its value
}

संग्रह सदस्यों का प्रत्यक्ष संशोधन:

@arr = ( 'remove-foo', 'remove-bar' );
foreach $x (@arr){
    $x =~ s/remove-//;
}
# Now @arr = ('foo', 'bar');

पीएचपी

foreach ($set as $value) {
    // Do something to $value;
}

वैकल्पिक सिंटैक्स का उपयोग करके कुंजी और मान दोनों को निकालना भी संभव है:

foreach ($set as $key => $value) {
    echo "{$key} has a value of {$value}";
}

संग्रह सदस्यों का प्रत्यक्ष संशोधन:

$arr = array(1, 2, 3);
foreach ($arr as &$value) { // Note the &, $value is a reference to the original value inside $arr
    $value++;
}
// Now $arr = array(2, 3, 4);

// also works with the full syntax
foreach ($arr as $key => &$value) {
    $value++;
}

अधिक जानकारी

पायथन

for item in iterable_collection:
    # Do something with item

पायथन का टपल असाइनमेंट, जो इसके फ़ोरैच लूप में पूरी तरह से उपलब्ध है, सहयोगी सरणियों में (कुंजी, मान) जोड़े पर पुनरावृति करना भी आसान बनाता है:

for key, value in some_dict.items():  # Direct iteration on a dict iterates on its keys
    # Do stuff

जैसा for ... in पायथन में फॉर लूप का एकमात्र प्रकार है, अन्य भाषाओं में पाए जाने वाले काउंटर लूप के बराबर है...

for i in range(len(seq)):
    # Do something to seq[i]

...हालांकि का उपयोग कर रहे हैं enumerate फ़ंक्शन को अधिक पाइथोनिक माना जाता है:

for i, item in enumerate(seq):
    # Do stuff with item
    # Possibly assign it back to seq[i]

आर

for (item in object) {
    # Do something with item
}

जैसा for ... in का एकमात्र प्रकार है for आर में लूप, अन्य भाषाओं में पाए जाने वाले काउंटर लूप के बराबर है...

for (i in seq_along(object)) {
    # Do something with object[[i]]
}

रैकेट

(for ([item set])
  (do-something-with item))

या पारंपरिक योजना का उपयोग कर रहे हैं for-each समारोह:

(for-each do-something-with a-list)

do-something-with एक एक-तर्क वाला कार्य है।

राकु

राकू (प्रोग्रामिंग भाषा) में, पर्ल की एक सहयोगी भाषा, का उपयोग किC सूची के तत्वों को पार करने के लिए किया जाना चाहिए (foreach की अनुमति नहीं है)। वह अभिव्यक्ति जो संग्रह को लूप करने के लिए दर्शाती है, उसका मूल्यांकन सूची-संदर्भ में किया जाता है, लेकिन डिफ़ॉल्ट रूप से फ़्लैट नहीं किया जाता है, और परिणामी सूची के प्रत्येक आइटम को, बदले में, लूप वेरिएबल के उपनाम दिया जाता है।

शाब्दिक उदाहरण सूचीबद्ध करें:

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > 1..4 के लिए {

   ।कहना;

} </सिंटैक्सहाइलाइट>

सरणी उदाहरण:

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > @arr के लिए {

   ।कहना;

} </सिंटैक्सहाइलाइट>

इसके कथन संशोधक रूप में लूप के लिए:

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > .@arr के लिए कहें; </सिंटैक्सहाइलाइट>

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > @arr के लिए -> $x {

   $x कहो;

} </सिंटैक्सहाइलाइट>

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > @arr के लिए -> $x, $y { # एक समय में एक से अधिक आइटम

   $x, $y कहें;

} </सिंटैक्सहाइलाइट>

हैश उदाहरण:

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > कुंजियों के लिए %हैश -> $कुंजी {

   $key कहें: $hash{$key} ;

} </सिंटैक्सहाइलाइट>

या

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > %hash.kv के लिए -> $कुंजी, $मूल्य {

   $key कहें: $value ;

} </सिंटैक्सहाइलाइट>

या

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > %हैश के लिए -> $x {

   $x.key() कहें: $x.value() ; # कोष्ठक को दोहरे उद्धृत स्ट्रिंग में इनलाइन करने की आवश्यकता है

} </सिंटैक्सहाइलाइट>

दोहरे नुकीले ब्लॉक के साथ संग्रह सदस्यों का प्रत्यक्ष संशोधन, <->:

<सिंटैक्सहाइलाइट लैंग= पर्ल6 > मेरा @arr = 1,2,3; @arr के लिए <-> $x {

   $x *=2;

}

अब @arr = 2,4,6;

</सिंटैक्सहाइलाइट>

रूबी

set.each do |item|
  # do something to item
end

या

for item in set
  # do something to item
end

इसका उपयोग हैश के साथ भी किया जा सकता है.

set.each do |item,value|
  # do something to item
  # do something to value
end

जंग

for ई> लूप की संरचना है for <pattern> in <expression> { /* optional statements */ }. यह स्पष्ट रूप से को कॉल करता है IntoIterator::into_iter अभिव्यक्ति पर विधि, और परिणामी मूल्य का उपयोग करता है, जिसे लागू करना होगा Iterator प्रवृत्ति। यदि अभिव्यक्ति स्वयं एक पुनरावर्तक है, तो इसका उपयोग Cधे द्वारा किया जाता है for कार्यान्वयन के माध्यम से लूप करें IntoIterator सभी के लिए Iterators जो पुनरावर्तक को अपरिवर्तित लौटाता है। लूप कॉल करता है Iterator::next लूप बॉडी को निष्पादित करने से पहले इटरेटर पर विधि। अगर Iterator::next रिटर्न Some(_), अंदर का मान पैटर्न मिलान को सौंपा गया है और लूप बॉडी निष्पादित की गई है; अगर यह वापस आता है None, लूप समाप्त हो गया है।

let mut numbers = vec![1, 2, 3];

// Immutable reference:
for number in &numbers { // calls IntoIterator::into_iter(&numbers)
    println!("{}", number);
}

for square in numbers.iter().map(|x| x * x) { // numbers.iter().map(|x| x * x) implements Iterator
    println!("{}", square);
}

// Mutable reference:
for number in &mut numbers { // calls IntoIterator::into_iter(&mut numbers)
    *number *= 2;
}

// prints "[2, 4, 6]":
println!("{:?}", numbers);

// Consumes the Vec and creates an Iterator:
for number in numbers { // calls IntoIterator::into_iter(numbers)
    // ...
}

// Errors with "borrow of moved value":
// println!("{:?}", numbers);

स्काला

// return list of modified elements
items map { x => doSomething(x) }
items map multiplyByTwo

for {x <- items} yield doSomething(x)
for {x <- items} yield multiplyByTwo(x)

// return nothing, just perform action
items foreach { x => doSomething(x) }
items foreach println

for {x <- items} doSomething(x)
for {x <- items} println(x)

// pattern matching example in for-comprehension
for ((key, value) <- someMap) println(s"$key -> $value")

योजना

(for-each do-something-with a-list)

do-something-with एक एक-तर्क वाला कार्य है।

छोटी बात

collection do: [:item| "do something to item" ]

स्विफ्ट

स्विफ्ट (प्रोग्रामिंग भाषा) का उपयोग करता है for…in एक संग्रह के सदस्यों पर पुनरावृति करने के लिए निर्माण करें।^[22]

for thing in someCollection {
    // do something with thing
}

forसे>…in लूप का उपयोग अक्सर लूप बॉडी पर एक निश्चित संख्या में पुनरावृत्ति करने के लिए बंद और आधे-खुले रेंज निर्माणों के साथ किया जाता है।

for i in 0..<10 {
    // 0..<10 constructs a half-open range, so the loop body
    // is repeated for i = 0, i = 1, …, i = 9.
}

for i in 0...10 {
    // 0...10 constructs a closed range, so the loop body
    // is repeated for i = 0, i = 1, …, i = 9, i = 10.
}

SystemVerilog

SystemVerilog किC भी आयामीता के किC भी वेक्टर या सरणी प्रकार पर पुनरावृत्ति का समर्थन करता है foreach कीवर्ड.

एक तुच्छ उदाहरण पूर्णांकों की एक सरणी पर पुनरावृत्त होता है:

code	prints
int array_1d[] = '{ 3, 2, 1, 0 }; foreach array_1d[index] $display("array_1d[%0d]: %0d", index, array_1d[index]);	array_1d[0]: 3 array_1d[1]: 2 array_1d[2]: 1 array_1d[3]: 0

एक अधिक जटिल उदाहरण पूर्णांकों की सरणियों की एक साहचर्य सरणी पर पुनरावृत्त होता है:

code

prints

int  array_2d[string][] = '{ "tens": '{ 10, 11 },
                             "twenties": '{ 20, 21 } };

foreach array_2d[key,index]
  $display("array_2d[%s,%0d]: %0d", key, index, array_2d[key,index]);

array_2d[tens,0]: 10
array_2d[tens,1]: 11
array_2d[twenties,0]: 20
array_2d[twenties,1]: 21

टीCएल

Tcl सूचियों को पुनरावृत्त करने के लिए foreach का उपयोग करता है। एक से अधिक पुनरावर्तक चर निर्दिष्ट करना संभव है, जिस स्थिति में उन्हें सूची से अनुक्रमिक मान निर्दिष्ट किए जाते हैं।

code	prints
foreach {i j} {1 2 3 4 5 6} { puts "$i $j" }	1 2 3 4 5 6

एक से अधिक सूचियों को एक साथ दोहराना भी संभव है। निम्नांकित में i पहली सूची के अनुक्रमिक मूल्यों को मानता है, j दूसरी सूची के अनुक्रमिक मान:

code	prints
foreach i {1 2 3} j {a b c} { puts "$i $j" }	1 a 2 b 3 c

विजुअल बेसिक .NET

For Each item In enumerable
    ' Do something with item.
Next

या बिना प्रकार के अनुमान के

For Each item As type In enumerable
    ' Do something with item.
Next

खिड़कियाँ

पारंपरिक कमांड प्रोसेसर

एक काल्पनिक आह्वान करें frob तीन बार आदेश दें, हर बार इसे एक रंग का नाम दें।

C:\>FOR %%a IN ( red green blue ) DO frob %%a

विंडोज पॉवरशेल

foreach ($item in $set) {
    # Do something to $item
}

एक पाइपलाइन से

$list | ForEach-Object {Write-Host $_}

# or using the aliases
$list | foreach {write $_}
$list | % {write $_}

एक्सएसएलटी

 <xsl:for-each select="set">
   <!-- do something for the elements in <set> -->
 </xsl:for-each>

^[23]

यह भी देखें

संदर्भ

↑ "D Programming Language foreach Statement Documentation". Digital Mars. Retrieved 2008-08-04.
↑ "SWI-Prolog -- foreach/2". www.swi-prolog.org. Retrieved 2020-02-10.
↑ http://www.rebol.com. {{cite web}}: Missing or empty |title= (help)
↑ http://www.red-lang.org. {{cite web}}: Missing or empty |title= (help)
↑ "Proposed ECMAScript 4th Edition – Language Overview" (PDF). Retrieved 2020-02-21.
↑ "प्रत्येक के लिए..इन". Retrieved 2020-02-21.
↑ लिए "में लिए". Retrieved 2020-02-21. {{cite web}}: Check |url= value (help)
↑ "विजुअल सी++ 11 में सी++11 विशेषताएं - विजुअल सी++ टीम ब्लॉग - साइट होम - एमएसडीएन ब्लॉग". Blogs.msdn.com. 2011-09-12. Retrieved 2013-08-04.
↑ "लूप के लिए रेंज-आधारित (C++11 के बाद से)". en.cppreference.com. Retrieved 2018-12-03.
↑ "std::for_each - cppreference". en.cppreference.com. Retrieved 2017-09-30.
↑ "Qt 4.2: Generic Containers". Doc.qt.digia.com. Archived from the original on 2015-11-23. Retrieved 2013-08-04.
↑ Eric Niebler (2013-01-31). "Chapter 9. Boost.Foreach - 1.53.0". Boost.org. Retrieved 2013-08-04.
↑ "रेंज क्लॉज". The Go Programming Language Specification. The Go Programming Language. Retrieved October 20, 2013.
↑ ^14.0 ^14.1 "Enhanced for Loop - This new language construct[...]" "Java Programming Language, Section: Enhancements in JDK 5". Sun Microsystems, Inc. 2004. Retrieved 2009-05-26.
↑ "The For-Each Loop" "The For-Each Loop". Sun Microsystems, Inc. 2008. Retrieved 2009-05-10.
↑ "Implementing this interface allows an object to be the target of the "foreach" statement." "Iterable (Java Platform SE 6)". Sun Microsystems, Inc. 2004. Retrieved 2009-05-12.
↑ ^17.0 ^17.1 Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991.
↑ "Array.prototype.forEach() - JavaScript | MDN".
↑ "वस्तु.कुंजियाँ". Mozilla Developer Network. Retrieved May 7, 2014.
↑ "Lua Programming/Tables - Wikibooks, open books for an open world". en.wikibooks.org (in English). Retrieved 2017-12-06.
↑ Chu, Oliver. "मिंट ट्यूटोरियल". Retrieved 20 October 2013.
↑ "Control Flow — the Swift Programming Language (Swift 5.5)".
↑ "XSLT <xsl:for-each> Element". W3Schools.com.

[1] "D Programming Language foreach Statement Documentation". Digital Mars. Retrieved 2008-08-04.

[2] "SWI-Prolog -- foreach/2". www.swi-prolog.org. Retrieved 2020-02-10.

[3] ttp://www.rebol.com. {{cite web}}: Missing or empty |title= (help)

[4] ttp://www.red-lang.org. {{cite web}}: Missing or empty |title= (help)

[5] "Proposed ECMAScript 4th Edition – Language Overview" (PDF). Retrieved 2020-02-21.

[6] "प्रत्येक के लिए..इन". Retrieved 2020-02-21.

[7] लिए "में लिए". Retrieved 2020-02-21. {{cite web}}: Check |url= value (help)

[8] "विजुअल सी++ 11 में सी++11 विशेषताएं - विजुअल सी++ टीम ब्लॉग - साइट होम - एमएसडीएन ब्लॉग". Blogs.msdn.com. 2011-09-12. Retrieved 2013-08-04.

[9] "लूप के लिए रेंज-आधारित (C++11 के बाद से)". en.cppreference.com. Retrieved 2018-12-03.

[10] "std::for_each - cppreference". en.cppreference.com. Retrieved 2017-09-30.

[11] "Qt 4.2: Generic Containers". Doc.qt.digia.com. Archived from the original on 2015-11-23. Retrieved 2013-08-04.

[12] Eric Niebler (2013-01-31). "Chapter 9. Boost.Foreach - 1.53.0". Boost.org. Retrieved 2013-08-04.

[13] "रेंज क्लॉज". The Go Programming Language Specification. The Go Programming Language. Retrieved October 20, 2013.

[jdk5release-14] 14.0 ^14.1 "Enhanced for Loop - This new language construct[...]" "Java Programming Language, Section: Enhancements in JDK 5". Sun Microsystems, Inc. 2004. Retrieved 2009-05-26.

[15] "The For-Each Loop" "The For-Each Loop". Sun Microsystems, Inc. 2008. Retrieved 2009-05-10.

[16] "Implementing this interface allows an object to be the target of the "foreach" statement." "Iterable (Java Platform SE 6)". Sun Microsystems, Inc. 2004. Retrieved 2009-05-12.

[Bloch-17] 17.0 ^17.1 Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991.

[18] "Array.prototype.forEach() - JavaScript | MDN".

[19] "वस्तु.कुंजियाँ". Mozilla Developer Network. Retrieved May 7, 2014.

[20] "Lua Programming/Tables - Wikibooks, open books for an open world". en.wikibooks.org (in English). Retrieved 2017-12-06.

[21] Chu, Oliver. "मिंट ट्यूटोरियल". Retrieved 20 October 2013.

[22] "Control Flow — the Swift Programming Language (Swift 5.5)".

[xslforeach-23] "XSLT <xsl:for-each> Element". W3Schools.com.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

@@ Line 3: / Line 3: @@
 [[File:For-Loop-Mint-Programming-Language-Type-2.gif|thumb|{{mono|foreach}} लूप्स का उपयोग लगभग हमेशा तत्वों के अनुक्रम में आइटमों को पुनरावृत्त करने के लिए किया जाता है।]]
 {{Loop constructs}}<!-- NOTE: Please don't remove. Discuss navigation concept at [[Talk:Do_while_loop#Helpbox_experiment] -->
-[[कंप्यूटर प्रोग्रामिंग]] में, फ़ोरैच लूप (या प्रत्येक लूप के लिए) एक [[संग्रह वर्ग]] में आइटमों को पार करने के लिए एक नियंत्रण प्रवाह विवरण है। {{mono|foreach}} का प्रयोग आमतौर पर मानक के स्थान पर किया जाता है {{mono|[[For loop|for]]}} लूप स्टेटमेंट (कंप्यूटर विज्ञान)। दूसरे के विपरीत {{mono|for}} लूप निर्माण, तथापि, {{mono|foreach}} लूप्स<ref>{{cite web
+[[कंप्यूटर प्रोग्रामिंग]] में, फ़ोरैच लूप (या प्रत्येक लूप के लिए) एक [[संग्रह वर्ग]] में आइटमों को पार करने के लिए एक नियंत्रण प्रवाह विवरण है। {{mono|फॉरएच(foreach)}} का प्रयोग आमतौर पर मानक के स्थान पर किया जाता है {{mono|[[For loop|for]]}} लूप स्टेटमेंट (कंप्यूटर विज्ञान)। दूसरे के विपरीत {{mono|for}} लूप निर्माण, तथापि, {{mono|foreach}} लूप्स<ref>{{cite web
 | url=http://www.digitalmars.com/d/statement.html#ForeachStatement
 | title=D Programming Language <code>foreach</code> Statement Documentation

Anonymous

Search

फ़ोरैच लूप: Difference between revisions

Revision as of 10:54, 20 July 2023

सिंटेक्स

भाषा समर्थन

एक्शनस्क्रिप्ट 3.0

C

C#

C++

C++/Cएलआई

कोल्डफ्यूजन मार्कअप लैंग्वेज (Cएफएमएल)

स्क्रिप्ट सिंटैक्स

टैग सिंटैक्स

सामान्य लिस्प

डी

डार्ट

ऑब्जेक्ट पास्कल, डेल्फ़ी

एफिल

जाओ

ग्रूवी

हास्केल

मिश्रित

जावा

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

दूसरा[20]

गणित

मतलब

पुदीना

उद्देश्य-C

ओकैमल

पैरासेल

पास्कल

पर्ल

पीएचपी

पायथन

आर

रैकेट

राकु

रूबी

जंग

स्काला

योजना

छोटी बात

स्विफ्ट

SystemVerilog

टीCएल

विजुअल बेसिक .NET

खिड़कियाँ

पारंपरिक कमांड प्रोसेसर

विंडोज पॉवरशेल

एक्सएसएलटी

यह भी देखें

संदर्भ

Navigation

Wiki tools

Page tools

Other projects

Categories

दूसरा^[20]