स्ट्रिंग ऑपरेटर + सरल है?

परिचय

एक स्ट्रिंग डेटा प्रकार मौलिक प्रकारों में से एक है, साथ ही संख्यात्मक (इंट, लॉन्ग, डबल) और लॉजिकल (बूल)। कम से कम किसी भी उपयोगी कार्यक्रम की कल्पना करना कठिन है जो इस प्रकार का उपयोग नहीं करता है।



.NET प्लेटफ़ॉर्म पर, एक स्ट्रिंग प्रकार को एक अपरिवर्तनीय स्ट्रिंग क्लास के रूप में दर्शाया जाता है। इसके अलावा, यह सीएलआर के सामान्य भाषा वातावरण में अत्यधिक एकीकृत है, और सी # कंपाइलर से भी समर्थन प्राप्त है।



इस लेख में, मैं संघनन के बारे में बात करना चाहूंगा, एक ऐसा ऑपरेशन जो स्ट्रिंग्स पर किया जाता है जितनी बार संख्याओं पर अतिरिक्त संचालन। ऐसा लगता है कि यहां हम बात कर सकते हैं, क्योंकि हम सभी स्ट्रिंग ऑपरेटर + के बारे में जानते हैं, लेकिन जैसा कि यह निकला, उसकी अपनी सूक्ष्मताएं हैं।

स्ट्रिंग ऑपरेटर + के लिए भाषा की विशिष्टता

सी # भाषा विनिर्देश स्ट्रिंग्स के लिए तीन ऑपरेटर + अधिभार प्रदान करता है:

string operator + (string x, string y) string operator + (string x, object y) string operator + (object x, string y)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि स्ट्रिंग समवर्ती के ऑपरेंड में से एक शून्य है, तो एक खाली स्ट्रिंग प्रतिस्थापित किया जाता है। अन्यथा, कोई भी तर्क जो एक स्ट्रिंग नहीं है, उसे वर्चुअल ToString विधि कहकर एक स्ट्रिंग में डाला जाता है। यदि ToString विधि शून्य हो जाती है, तो एक खाली स्ट्रिंग प्रतिस्थापित किया जाता है। यह कहा जाना चाहिए कि विनिर्देश के अनुसार, इस ऑपरेशन को कभी भी शून्य नहीं लौटना चाहिए ।



ऑपरेटर का विवरण पर्याप्त स्पष्ट दिखता है, हालांकि, अगर हम स्ट्रिंग वर्ग के कार्यान्वयन को देखते हैं, तो हम केवल दो ऑपरेटरों की स्पष्ट परिभाषा पाते हैं == और! =। एक वाजिब सवाल यह उठता है कि स्ट्रिंग कंसेंटेशन के पर्दे के पीछे क्या होता है? कंपाइलर स्ट्रिंग ऑपरेटर + को कैसे संभालता है?



इस सवाल का जवाब इतना जटिल नहीं था। आपको स्टैटिक स्ट्रिंग.कोन्कट विधि पर करीब से नज़र डालने की आवश्यकता है। String.Concat विधि - ऑब्जेक्ट के एक या एक से अधिक इंस्टेंस के मानों के स्ट्रिंग वर्ग या स्ट्रिंग प्रतिनिधित्वों के एक या अधिक उदाहरणों को जोड़ती है। इस विधि के निम्नलिखित अधिभार उपलब्ध हैं:

 public static String Concat(String str0, String str1) public static String Concat(String str0, String str1, String str2) public static String Concat(String str0, String str1, String str2, String str3) public static String Concat(params String[] values) public static String Concat(IEnumerable<String> values) public static String Concat(Object arg0) public static String Concat(Object arg0, Object arg1) public static String Concat(Object arg0, Object arg1, Object arg2) public static String Concat(Object arg0, Object arg1, Object arg2, Object arg3, __arglist) public static String Concat<T>(IEnumerable<T> values)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अधिक जानकारी

मान लीजिए कि हमारे पास निम्नलिखित अभिव्यक्ति है = ए + बी, जहां ए और बी तार हैं। संकलक इसे कॉल को स्टेटिक कॉनैट विधि में परिवर्तित करता है, अर्थात

 s = string.Concat(a, b)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सी # में किसी भी अन्य अतिरिक्त संचालन की तरह, स्ट्रिंग समवर्ती ऑपरेशन बाएं-सहयोगी है।



दो लाइनों के साथ, सब कुछ स्पष्ट है, लेकिन क्या होगा अगर अधिक लाइनें हैं? ऑपरेशन की बाईं-सहक्रियाशीलता को देखते हुए अभिव्यक्ति s = a + b + c को प्रतिस्थापित किया जा सकता है

 s = string.Concat(string.Concat(a, b), c)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हालाँकि, तीन तर्कों को लेने वाले अधिभार की उपस्थिति को देखते हुए इसे परिवर्तित किया जाएगा

 s = string.Concat(a, b, c)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चार रेखाओं के मिलन से स्थिति समान है। 5 या अधिक पंक्तियों को संक्षिप्त करने के लिए, हमारे पास string.Concat (params string []] का अधिभार है, इसलिए आपको किसी सरणी के लिए मेमोरी आवंटित करने से जुड़े ओवरहेड पर विचार करने की आवश्यकता है।



यह भी कहा जाना चाहिए कि स्ट्रिंग संघनन ऑपरेशन पूरी तरह से साहचर्य है : इससे कोई फर्क नहीं पड़ता कि हम किस क्रम में तारों को मिलाते हैं, इसलिए अभिव्यक्ति की प्राथमिकता के स्पष्ट संकेत के बावजूद अभिव्यक्ति s = a + (b + c) के रूप में संसाधित की जाती है।

 s = (a + b) + c = string.Concat(a, b, c)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उम्मीद के बजाय

 s = string.Concat(a, string.Concat(b, c))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस प्रकार, उपर्युक्त को संक्षेप में प्रस्तुत करने के लिए: स्ट्रिंग संघनन ऑपरेशन हमेशा बाएं से दाएं प्रस्तुत किया जाता है, और स्थिर स्ट्रिंग के लिए कॉल का उपयोग करता है। कॉनकट विधि।

शाब्दिक तार के लिए संकलक अनुकूलन

सी # भाषा संकलक में शाब्दिक तार के साथ जुड़े अनुकूलन हैं। इसलिए, उदाहरण के लिए, अभिव्यक्ति s = "a + +" b "+ c, ऑपरेटर की बाईं-सहक्रियाशीलता को देखते हुए, s = (" a "+" b ") + c के बराबर है

 s = string.Concat("ab", c)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अभिव्यक्ति ऑपरेशन के बाएं-समरूपता के बावजूद अभिव्यक्ति s = c + "a" + "b" को परिवर्तित किया गया है (s = (c + "a") + "b")

 s = string.Concat(c, "ab")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सामान्य तौर पर, कोई फर्क नहीं पड़ता कि शाब्दिक रूप से स्थित हैं, संकलक सब कुछ यह कर सकता है, और उसके बाद ही उपयुक्त कॉनैट विधि अधिभार चुनने की कोशिश करता है। अभिव्यक्ति s = a + "b" + "c" + d को रूपांतरित किया जाता है

 s = string.Concat(a, "bc", d)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह एक खाली और अशक्त स्ट्रिंग से जुड़े अनुकूलन के बारे में भी कहा जाना चाहिए। कंपाइलर जानता है कि खाली स्ट्रिंग जोड़ने से संघनन का परिणाम प्रभावित नहीं होता है, इसलिए अभिव्यक्ति s = a + "" + b को में बदल दिया जाता है

 s = string.Concat(a, b),
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उम्मीद के बजाय

 s = string.Concat (a, "", b)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसी प्रकार, एक तार स्ट्रिंग के लिए जिसका मान शून्य है, हमारे पास है:

 const string nullStr = null; s = a + nullStr + b;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

में परिवर्तित कर दिया

 s = string.Concat(a, b)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अभिव्यक्ति s = a + nullStr s = a ?? में बदल जाती है "" यदि एक स्ट्रिंग है, और string को कॉल करना है। Concat (a) मेथड, यदि कोई स्ट्रिंग नहीं है, उदाहरण के लिए, s = 17 + nullStr, s = string में बदल जाता है। (17)।



एक दिलचस्प विशेषता प्रसंस्करण शाब्दिकता के अनुकूलन और स्ट्रिंग ऑपरेटर + की बाईं-संबद्धता से संबंधित है।



अभिव्यक्ति पर विचार करें:

 var s1 = 17 + 17 + "abc";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

बाएं-समरूपता, यह समतुल्य है

 var s1 = (17 + 17) + "abc"; //   string.Concat(34, "abc")
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणामस्वरूप, संकलन चरण में, संख्याओं का जोड़ घटित होगा, जिससे परिणाम 34abc होगा।



दूसरी ओर अभिव्यक्ति

 var s2 = "abc" + 17 + 17;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

समतुल्य रूप

 var s2 = ("abc" + 17) + 17; //   string.Concat("abc", 17, 17)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणामस्वरूप abc1717।



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

String.Concat VS StringBuilder.Append

इस तुलना के बारे में कुछ शब्द कहा जाना चाहिए। निम्नलिखित कोड पर विचार करें:

 string name = "Timur"; string surname = "Guev"; string patronymic = "Ahsarbecovich"; string fio = surname + name + patronymic;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसे StringBuilder का उपयोग करके कोड से बदला जा सकता है:

 var sb = new StringBuilder(); sb.Append(surname); sb.Append(name); sb.Append(patronymic); string fio = sb.ToString();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



3 लाइनों के लिए कॉनैट विधि कार्यान्वयन:

 public static string Concat(string str0, string str1, string str2) { if (str0 == null && str1 == null && str2 == null) return string.Empty; if (str0 == null) str0 = string.Empty; if (str1 == null) str1 = string.Empty; if (str2 == null) str2 = string.Empty; string dest = string.FastAllocateString(str0.Length + str1.Length + str2.Length); //     string.FillStringChecked(dest, 0, str0); / string.FillStringChecked(dest, str0.Length, str1); string.FillStringChecked(dest, str0.Length + str1.Length, str2); return dest; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जावा में + ऑपरेटर

जावा में स्ट्रिंग ऑपरेटर + के बारे में कुछ शब्द। हालांकि मैं जावा में कार्यक्रम नहीं करता, लेकिन यह जानना दिलचस्प है कि चीजें कैसी हैं। Java कंपाइलर + ऑपरेटर को ऑप्टिमाइज़ करता है ताकि वह StringBuilder क्लास और एपेंड मेथड कॉल का उपयोग करे।



पिछला कोड परिवर्तित किया गया है

 String fio = new StringBuilder(String.valueOf(surname)).append(name).append(patronymic).ToString()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह भी उल्लेखनीय है कि सी # ने जानबूझकर इस तरह के अनुकूलन से इनकार कर दिया, एरिक लिपर्ट का इस विषय पर एक पोस्ट है । तथ्य यह है कि इस तरह के एक अनुकूलन के रूप में एक अनुकूलन नहीं है, यह कोड का पुनर्लेखन है। इसके अलावा, सी # भाषा के रचनाकारों का मानना ​​है कि डेवलपर्स को स्ट्रिंग वर्ग के साथ काम करने की विशेषताओं को जानना चाहिए और यदि आवश्यक हो, तो स्ट्रिंगबर्ल का उपयोग करने के लिए स्विच किया जाएगा।



वैसे, यह एरिक लिपर्ट था जो स्ट्रिंग संधि से संबंधित सी # संकलक अनुकूलन में शामिल था।

निष्कर्ष

शायद पहली नज़र में यह अजीब लग सकता है कि स्ट्रिंग वर्ग + ऑपरेटर को तब तक परिभाषित नहीं करता है जब तक कि हम कोड के एक बड़े टुकड़े की दृश्यता से संबंधित संकलक अनुकूलन की संभावनाओं के बारे में नहीं सोचते हैं। उदाहरण के लिए, यदि स्ट्रिंग संचालक में + संचालक को परिभाषित किया गया था, तो अभिव्यक्ति s = a + b + c + d दो मध्यवर्ती रेखाओं के निर्माण की ओर ले जाएगा, केवल string.Concat (a, b, c, d) विधि को और अधिक के लिए अनुमति देता है। प्रभावी ढंग से।