java प्रत्येक 'लूप के लिए जावा' कैसे काम करता है?




foreach syntactic-sugar (19)

विचार करें:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
    System.out.println(item);
}

प्रत्येक वाक्यविन्यास के उपयोग के बिना लूप के बराबर क्या दिखता है?


for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}

अपने "प्रत्येक के लिए" से बचने के लिए प्रत्येक के लिए एक विकल्प:

List<String> someList = new ArrayList<String>();

संस्करण 1 (सादा):

someList.stream().forEach(listItem -> {
    System.out.println(listItem);
});

संस्करण 2 (समानांतर निष्पादन (तेज़)):

someList.parallelStream().forEach(listItem -> {
    System.out.println(listItem);
});

प्रत्येक के लिए निर्माण सरणी के लिए भी मान्य है। जैसे

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
    // fruit is an element of the `fruits` array.
}

जो अनिवार्य रूप से बराबर है

for (int i = 0; i < fruits.length; i++) {
    String fruit = fruits[i];
    // fruit is an element of the `fruits` array.
}

तो, कुल सारांश:
[nsayer] क्या हो रहा है का लंबा रूप निम्नलिखित है:

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}

ध्यान दें कि यदि आपको i.remove () का उपयोग करने की आवश्यकता है; अपने लूप में, या वास्तविक इटरेटर को किसी भी तरह से एक्सेस करें, आप (:) idiom का उपयोग नहीं कर सकते हैं, क्योंकि वास्तविक इटरेटर केवल अनुमानित है।

[डेनिस Bueno]

यह nsayer के उत्तर से निहित है, लेकिन यह ध्यान देने योग्य है कि ओपी का (..) वाक्यविन्यास काम करेगा जब "कुछ सूची" कुछ भी है जो java.lang लागू करता है। अक्षम - इसे एक सूची, या कुछ संग्रह नहीं होना चाहिए java.util। इसलिए, अपने स्वयं के प्रकार भी इस वाक्यविन्यास के साथ उपयोग किया जा सकता है।


public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}

जावा में प्रत्येक लूप अंतर्निहित इटरेटर तंत्र का उपयोग करता है। तो यह निम्नलिखित के समान है:

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}

यह पागल दिखता है लेकिन हे यह काम करता है

List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);

यह काम। जादू


यहां एक समकक्ष अभिव्यक्ति है।

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}

यह भी ध्यान रखें कि मूल प्रश्न में "foreach" विधि का उपयोग करने से कुछ सीमाएं होती हैं, जैसे कि पुनरावृत्ति के दौरान सूची से आइटम को निकालने में सक्षम नहीं है।

नया फॉर-लूप एक अलग इटरेटर की आवश्यकता को पढ़ने और हटाने के लिए आसान है, लेकिन केवल पढ़ने-योग्य पुनरावृत्ति पास में ही वास्तव में प्रयोग योग्य है।


यहां एक ऐसा उत्तर है जो जावा इटरेटर्स के ज्ञान को नहीं मानता है। यह कम सटीक है, लेकिन यह शिक्षा के लिए उपयोगी है।

प्रोग्रामिंग करते समय हम अक्सर कोड लिखते हैं जो निम्न जैसा दिखता है:

char[] grades = ....
for(int i = 0; i < grades.length; i++) {   // for i goes from 0 to grades.length
    System.out.print(grades[i]);           // Print grades[i]
}

Foreach वाक्यविन्यास इस आम पैटर्न को एक और अधिक प्राकृतिक और कम वाक्य रचनात्मक शोर में लिखा जा सकता है।

for(char grade : grades) {   // foreach grade in grades
    System.out.print(grade); // print that grade
}

इसके अतिरिक्त यह वाक्यविन्यास लिस्ट या सेट जैसी ऑब्जेक्ट्स के लिए मान्य है जो सर इंडेक्सिंग का समर्थन नहीं करते हैं, लेकिन जावा इटेरेबल इंटरफेस को कार्यान्वित करते हैं।


जावा "फॉर-प्रत्येक" लूप निर्माण दो प्रकार की वस्तुओं पर पुनरावृत्ति की अनुमति देगा:

  • T[] (किसी भी प्रकार के सरणी)
  • java.lang.Iterable<T>

Iterable<T> इंटरफ़ेस में केवल एक विधि है: Iterator<T> iterator() । यह Collection<T> की वस्तुओं पर काम करता है क्योंकि Collection<T> इंटरफ़ेस Iterable<T> बढ़ाता है।


एक foreach पाश वाक्यविन्यास है:

for (type obj:array) {...}

उदाहरण:

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

आउटपुट:

Java
Coffe
Is
Cool

चेतावनी: आप फोरैच लूप के साथ सरणी तत्वों तक पहुंच सकते हैं, लेकिन आप उन्हें प्रारंभ नहीं कर सकते हैं। उस के for लूप के लिए मूल का प्रयोग करें।

चेतावनी: आपको अन्य ऑब्जेक्ट के साथ सरणी के प्रकार से मेल खाना चाहिए।

for (double b:s) // Invalid-double is not String

यदि आप तत्वों को संपादित करना चाहते हैं, तो इस तरह for लूप के for मूल का उपयोग करें:

for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
    if (i==1) //1 because once again I say the 0 index
        s[i]="2 is cool";
    else
        s[i] = "hello";
}

अब अगर हम कंसोल पर डंप करते हैं, तो हमें मिलता है:

hello
2 is cool
hello
hello

यह ऐसा कुछ दिखता है। बहुत क्रूर

for (Iterator<String> i = someList.iterator(); i.hasNext(); )
        System.out.println(i.next());

सूर्य प्रलेखन में प्रत्येक के लिए एक अच्छा लेखन है।


चूंकि बहुत से अच्छे उत्तरों ने कहा, एक ऑब्जेक्ट को Iterable interface को कार्यान्वित करना चाहिए यदि वह for-each लूप के for-each उपयोग करना चाहता है।

मैं एक साधारण उदाहरण पोस्ट करूंगा और एक अलग तरीके से व्याख्या करने की कोशिश करूंगा कि for-each लूप कैसे काम करता है।

for-each लूप उदाहरण के लिए:

public class ForEachTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");

        for (String str : list) {
            System.out.println(str);
        }
    }
}

फिर, अगर हम इस कक्षा को javap लिए javap का उपयोग करते हैं, तो हम इस बाइटकोड नमूना प्राप्त करेंगे:

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #16                 // class java/util/ArrayList
         3: dup
         4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
         7: astore_1
         8: aload_1
         9: ldc           #19                 // String 111
        11: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        16: pop
        17: aload_1
        18: ldc           #27                 // String 222
        20: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        25: pop
        26: aload_1
        27: invokeinterface #29,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

जैसा कि हम नमूना की आखिरी पंक्ति से देख सकते हैं, संकलक स्वचालित रूप for-each कीवर्ड के उपयोग को संकलन समय पर एक Iterator के उपयोग में परिवर्तित कर देगा। यह समझा सकता है कि ऑब्जेक्ट, जो Iterable interface कार्यान्वित नहीं करता Iterable interface , एक Exception फेंक देगा जब यह for-each लूप के for-each उपयोग करने का प्रयास करता है।


विकिपीडिया में उल्लिखित एक foreach पाश की अवधारणा नीचे हाइलाइट किया गया है:

लूप संरचनाओं के लिए अन्य के विपरीत, हालांकि, फोरच लूप आमतौर पर कोई स्पष्ट काउंटर नहीं बनाए रखते हैं: वे अनिवार्य रूप से "इस एक्स बार में" करने के बजाय "इस सेट में सब कुछ करने के लिए" कहें। यह संभावित ऑफ-बाय-वन त्रुटियों से बचाता है और कोड को पढ़ने के लिए सरल बनाता है।

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

// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){

}

लेकिन मान लीजिए कि सूची इंडेक्स 1 के साथ शुरू होती है तो यह लूप अपवाद फेंकने जा रहा है क्योंकि इसे इंडेक्स 0 पर कोई तत्व नहीं मिलेगा और इस त्रुटि को एक-एक-एक त्रुटि कहा जाता है। इसलिए इस त्रुटि से बचने के लिए एक फ़ोरैच लूप की अवधारणा का उपयोग किया जाता है। अन्य फायदे भी हो सकते हैं, लेकिन मुझे लगता है कि एक फोरैच लूप का उपयोग करने की मुख्य अवधारणा और लाभ है।


जावा 5 में जोड़ा गया docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html (जिसे "लूप के लिए बढ़ाया गया" भी कहा जाता है), एक ही चीज़ के लिए java.util.Iterator --it की वाक्य रचनात्मक चीनी का उपयोग करने के बराबर है। इसलिए, प्रत्येक तत्व को पढ़ते समय, एक-एक करके और क्रम में, एक foreach हमेशा एक पुनरावर्तक पर चुना जाना चाहिए, क्योंकि यह अधिक सुविधाजनक और संक्षिप्त है।

प्रत्येक के लिए

for(int i : intList) {
   System.out.println("An element in the list: " + i);
}

इटरेटर

Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
   System.out.println("An element in the list: " + intItr.next());
}

ऐसी परिस्थितियां हैं जहां आपको सीधे Iterator उपयोग करना चाहिए। उदाहरण के लिए, फोरैच का उपयोग करते समय तत्व को हटाने का प्रयास कर सकते हैं (होगा?) परिणामस्वरूप एक ConcurrentModificationException में परिणाम हो सकता है।

foreach बनाम: मूल अंतर

foreach और foreach बीच एकमात्र व्यावहारिक अंतर यह है कि, सूचकांक वस्तुओं के मामले में, आपके पास इंडेक्स तक पहुंच नहीं है। एक उदाहरण जब लूप के for मूल आवश्यक है:

for(int i = 0; i < array.length; i++) {
   if(i < 5) {
      // Do something special
   }  else {
      // Do other stuff
   }
}

हालांकि आप foreach साथ मैन्युअल रूप से एक अलग इंडेक्स int-variable बना सकते हैं,

int idx = -1;
for(int i : intArray) {
   idx++;
   ...
}

इसकी अनुशंसा नहीं की जाती है, क्योंकि variable-scope आदर्श नहीं है, और लूप के for मूल केवल इस उपयोग के मामले के लिए मानक और अपेक्षित प्रारूप है।

foreach बनाम: प्रदर्शन

संग्रहों तक पहुंचने पर, लूप की सरणी पहुंच के for मूल से एक foreach काफी तेज है। सरणी का उपयोग करते समय, कम से कम आदिम और रैपर-एरे के साथ - इंडेक्स के माध्यम से पहुंच नाटकीय रूप से तेज़ है।

आदिम int-arrays के लिए iterator और अनुक्रमणिका पहुंच के बीच अंतर का समय

int या Integer सरणी तक पहुंचने पर सूचकांक इटरेटर्स की तुलना में 23- 40 प्रतिशत तेज होते हैं। यहां इस पोस्ट के निचले भाग में परीक्षण वर्ग का आउटपुट है, जो 100-तत्व आदिम-int सरणी में संख्याओं को प्रस्तुत करता है (ए इटरेटर, बी इंडेक्स है):

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

मैंने इसे एक Integer सरणी के लिए भी चलाया, और इंडेक्स अभी भी स्पष्ट विजेता हैं, लेकिन केवल 18 से 25 प्रतिशत के बीच तेजी से हैं।

संग्रह के लिए, इटरेटर इंडेक्स से तेज़ होते हैं

Integers की एक List के लिए, हालांकि, इटरेटर स्पष्ट विजेता हैं। बस टेस्ट-क्लास में int-array को निम्न में बदलें:

List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

और टेस्ट-फ़ंक्शन ( int[] को List<Integer> , length से size() इत्यादि में आवश्यक परिवर्तन करें):

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

एक परीक्षण में वे लगभग बराबर हैं, लेकिन संग्रह के साथ, इटरेटर जीतता है।

* यह पोस्ट स्टैक ओवरफ़्लो पर लिखे गए दो उत्तरों पर आधारित है:

कुछ और जानकारी: कौन सा अधिक लूप, या एक इटरेटर के लिए अधिक कुशल है?

पूर्ण परीक्षण वर्ग

मैंने स्टैक ओवरफ़्लो पर इस प्रश्न को पढ़ने के बाद यह तुलना-समय-समय-करने-करने-करने-दो-चीजें कक्षा बनाई:

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;https://.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
 **/
public class TimeIteratorVsIndexIntArray {

    public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

    public static final void main(String[] tryCount_inParamIdx0) {
        int testCount;

        // Get try-count from a command-line parameter
        try {
           testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
        }
        catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
           throw  new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
        }

        //Test proper...START
        int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

        long lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testIterator(intArray);
        }

        long lADuration = outputGetNanoDuration("A", lStart);

        lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testFor(intArray);
        }

        long lBDuration = outputGetNanoDuration("B", lStart);

        outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
    }

    private static final void testIterator(int[] int_array) {
       int total = 0;
       for(int i = 0; i < int_array.length; i++) {
          total += int_array[i];
       }
    }

    private static final void testFor(int[] int_array) {
       int total = 0;
       for(int i : int_array) {
          total += i;
       }
    }
    //Test proper...END

    //Timer testing utilities...START
    public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
        long lDuration = System.nanoTime() - l_nanoStart;
        System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
        return  lDuration;
    }

    public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
        long lDiff = -1;
        double dPct = -1.0;
        String sFaster = null;
        if(l_aDuration > l_bDuration) {
            lDiff = l_aDuration - l_bDuration;
            dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
            sFaster = "B";
        }
        else {
            lDiff = l_bDuration - l_aDuration;
            dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
            sFaster = "A";
        }
        System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
        return  lDiff;
   }

   //Timer testing utilities...END

}

जावा 8 से पहले, आपको निम्न का उपयोग करने की आवश्यकता है:

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

हालांकि, जावा 8 में स्ट्रीम की शुरुआत के साथ आप बहुत कम वाक्यविन्यास में एक ही काम कर सकते हैं। उदाहरण के लिए, अपनी कुछ सूची के लिए आप कर सकते हैं:

someList.stream().forEach(System.out::println);

आप here धाराओं के बारे में अधिक जानकारी प्राप्त कर सकते हैं।


यह सभी बुनियादी लूपिंग अव्यवस्था को हटाकर आपके कोड में सुंदरता जोड़ता है। यह आपके कोड को एक साफ दिखता है, जो नीचे उचित है।

लूप के for सामान्य:

void cancelAll(Collection<TimerTask> list) {
    for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
         i.next().cancel();
}

प्रत्येक के लिए उपयोग करना:

void cancelAll(Collection<TimerTask> list) {
    for (TimerTask t : list)
        t.cancel();
}

प्रत्येक के लिए एक संग्रह पर एक निर्माण है जो इटरेटर लागू करता है। याद रखें कि, आपके संग्रह को इटरेटर लागू करना चाहिए; अन्यथा आप इसे प्रत्येक के साथ उपयोग नहीं कर सकते हैं।

निम्नलिखित पंक्ति को " सूची में प्रत्येक टाइमरटास्क टी के लिए " के रूप में पढ़ा जाता है

for (TimerTask t : list)

प्रत्येक के मामले में त्रुटियों के लिए कम मौका है। आपको इटरेटर को प्रारंभ करने या लूप काउंटर को प्रारंभ करने और इसे समाप्त करने के बारे में चिंता करने की आवश्यकता नहीं है (जहां त्रुटियों के लिए दायरा है)।


List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

आइटम तालिका में सभी वस्तुओं पर Iterates।


यह nsayer के उत्तर से निहित है, लेकिन यह ध्यान देने योग्य है कि ओपी का (..) वाक्यविन्यास काम करेगा जब " कुछ सूची " कुछ भी है जो java.lang लागू करता है। अक्षम - इसे एक सूची, या कुछ संग्रह नहीं होना चाहिए java.util। इसलिए, अपने स्वयं के प्रकार भी इस वाक्यविन्यास के साथ उपयोग किया जा सकता है।





syntactic-sugar