C# Language => सामान्य स्ट्रिंग संचालन

विशिष्ट चरित्र द्वारा एक स्ट्रिंग को विभाजित करना

string helloWorld = "hello world, how is it going?";
string[] parts1 = helloWorld.Split(',');

//parts1: ["hello world", " how is it going?"]

string[] parts2 = helloWorld.Split(' ');

//parts2: ["hello", "world,", "how", "is", "it", "going?"]

किसी दिए गए स्ट्रिंग के सबस्ट्रिंग प्राप्त करना

string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"

Substring किसी दिए गए इंडेक्स से या दो इंडेक्स (दोनों समावेशी) के बीच से स्ट्रिंग लौटाता है।

निर्धारित करें कि क्या एक स्ट्रिंग दिए गए अनुक्रम से शुरू होती है

string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false

एक तार के भीतर एक स्ट्रिंग ढूँढना

System.String.Contains का उपयोग करके आप यह पता लगा सकते हैं कि क्या किसी स्ट्रिंग में एक विशेष स्ट्रिंग मौजूद है। विधि एक बूलियन लौटाती है, यह सच है कि यदि स्ट्रिंग मौजूद है और झूठी है।

string s = "Hello World";
bool stringExists = s.Contains("ello");  //stringExists =true as the string contains the substring

स्टार्टिंग और / या स्ट्रिंग्स के अंत से अनचाहे वर्ण ट्रिमिंग।

`String.Trim()`

string x = "   Hello World!    ";
string y = x.Trim(); // "Hello World!"

string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"

`String.TrimStart()` और `String.TrimEnd()`

string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' );   // "{(Hi"

एक तार का प्रारूपण

स्ट्रिंग में निर्दिष्ट वस्तु के स्ट्रिंग प्रतिनिधित्व के साथ स्ट्रिंग में एक या एक से अधिक आइटम को बदलने के लिए String.Format() विधि का String.Format() करें:

String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar

एक नए में तार की एक सरणी में शामिल होना

var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);

//joined = "Foo, Bar, Fizz, Buzz"

एक स्ट्रिंग को एक निश्चित लंबाई में बांधना

string s = "Foo";
string paddedLeft = s.PadLeft(5);        // paddedLeft = "  Foo" (pads with spaces by default)
string paddedRight = s.PadRight(6, '+'); // paddedRight = "Foo+++"
string noPadded = s.PadLeft(2);          // noPadded = "Foo" (original string is never shortened)

ऐरे से एक तार का निर्माण

String.Join विधि से हमें एक स्ट्रिंग बनाने में मदद मिलेगी सरणी से / वर्णों की सूची या स्ट्रिंग। यह विधि दो मापदंडों को स्वीकार करती है। पहला एक सीमांकक या विभाजक है जो आपको सरणी में प्रत्येक तत्व को अलग करने में मदद करेगा। और दूसरा पैरामीटर Array ही है।

स्ट्रिंग char array :

string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);

आउटपुट : a,b,c यदि हम delimiter को "" रूप में बदलते हैं तो आउटपुट abc बन जाएगा।

स्ट्रिंग की List of char से स्ट्रिंग:

string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);

आउटपुट : a|b|c

स्ट्रिंग की List of Strings :

string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);

आउटपुट : Ram is a boy

स्ट्रिंग की array of strings :

string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);

आउटपुट : Ram_is_a_boy

ToString का उपयोग करके स्वरूपण

आमतौर पर हम String.Format को फॉर्मेट करने के तरीके के लिए उपयोग कर रहे हैं, .ToString का उपयोग आमतौर पर अन्य प्रकार के स्ट्रिंग में परिवर्तित करने के लिए किया जाता है। जब रूपांतरण हो रहा हो तब हम ToString पद्धति के साथ प्रारूप निर्दिष्ट कर सकते हैं, इसलिए हम एक अतिरिक्त स्वरूपण से बच सकते हैं। मुझे बताएं कि यह विभिन्न प्रकारों के साथ कैसे काम करता है;

स्वरूपित स्ट्रिंग के लिए पूर्णांक:

int intValue = 10;
string zeroPaddedInteger = intValue.ToString("000"); // Output will be "010"
string customFormat = intValue.ToString("Input value is 0"); // output will be   "Input value is 10"

स्वरूपित स्ट्रिंग के लिए डबल:

double doubleValue = 10.456;
string roundedDouble = doubleValue.ToString("0.00"); // output 10.46
string integerPart = doubleValue.ToString("00");    // output 10
string customFormat = doubleValue.ToString("Input value is 0.0");  // Input value is 10.5

ToString का उपयोग करके DateTime को प्रारूपित करना

DateTime currentDate = DateTime.Now; //  {7/21/2016 7:23:15 PM}
string dateTimeString = currentDate.ToString("dd-MM-yyyy HH:mm:ss"); // "21-07-2016 19:23:15"
string dateOnlyString = currentDate.ToString("dd-MM-yyyy"); // "21-07-2016"
string dateWithMonthInWords = currentDate.ToString("dd-MMMM-yyyy HH:mm:ss"); // "21-July-2016 19:23:15"

स्ट्रिंग के दाईं ओर से x अक्षर प्राप्त करना

Visual Basic में लेफ्ट, राइट, और मिड फंक्शन्स हैं जो एक स्ट्रिंग के लेफ्ट, राइट और मिडल से कैरेक्टर लौटाते हैं। ये विधियाँ C # में मौजूद नहीं हैं, लेकिन Substring() साथ लागू की जा सकती हैं। उन्हें निम्नलिखित की तरह विस्तार विधियों के रूप में लागू किया जा सकता है:

   public static class StringExtensions
   {
      /// <summary>
      /// VB Left function
      /// </summary>
      /// <param name="stringparam"></param>
      /// <param name="numchars"></param>
      /// <returns>Left-most numchars characters</returns>
      public static string Left( this string stringparam, int numchars )
      {
         // Handle possible Null or numeric stringparam being passed
         stringparam += string.Empty;
    
         // Handle possible negative numchars being passed
         numchars = Math.Abs( numchars );
    
         // Validate numchars parameter        
         if (numchars > stringparam.Length)
            numchars = stringparam.Length;
    
         return stringparam.Substring( 0, numchars );
      }
    
      /// <summary>
      /// VB Right function
      /// </summary>
      /// <param name="stringparam"></param>
      /// <param name="numchars"></param>
      /// <returns>Right-most numchars characters</returns>
      public static string Right( this string stringparam, int numchars )
      {
         // Handle possible Null or numeric stringparam being passed
         stringparam += string.Empty;
    
         // Handle possible negative numchars being passed
         numchars = Math.Abs( numchars );
    
         // Validate numchars parameter        
         if (numchars > stringparam.Length)
            numchars = stringparam.Length;
    
         return stringparam.Substring( stringparam.Length - numchars );
      }
    
      /// <summary>
      /// VB Mid function - to end of string
      /// </summary>
      /// <param name="stringparam"></param>
      /// <param name="startIndex">VB-Style startindex, 1st char startindex = 1</param>
      /// <returns>Balance of string beginning at startindex character</returns>
      public static string Mid( this string stringparam, int startindex )
      {
         // Handle possible Null or numeric stringparam being passed
         stringparam += string.Empty;
    
         // Handle possible negative startindex being passed
         startindex = Math.Abs( startindex );
    
         // Validate numchars parameter        
         if (startindex > stringparam.Length)
            startindex = stringparam.Length;
         
         // C# strings are zero-based, convert passed startindex
         return stringparam.Substring( startindex - 1 );
      }
    
      /// <summary>
      /// VB Mid function - for number of characters
      /// </summary>
      /// <param name="stringparam"></param>
      /// <param name="startIndex">VB-Style startindex, 1st char startindex = 1</param>
      /// <param name="numchars">number of characters to return</param>
      /// <returns>Balance of string beginning at startindex character</returns>
      public static string Mid( this string stringparam, int startindex, int numchars)
      {
         // Handle possible Null or numeric stringparam being passed
         stringparam += string.Empty;
    
         // Handle possible negative startindex being passed
         startindex = Math.Abs( startindex );
    
         // Handle possible negative numchars being passed
         numchars = Math.Abs( numchars );
    
         // Validate numchars parameter        
         if (startindex > stringparam.Length)
            startindex = stringparam.Length;
    
         // C# strings are zero-based, convert passed startindex
         return stringparam.Substring( startindex - 1, numchars );

       }
    }

इस विस्तार विधि का उपयोग निम्नानुसार किया जा सकता है:

string myLongString = "Hello World!";
string myShortString = myLongString.Right(6);  // "World!"
string myLeftString = myLongString.Left(5);    // "Hello"
string myMidString1 = myLongString.Left(4);    // "lo World"
string myMidString2 = myLongString.Left(2,3);    // "ell"

String.IsNullOrEmpty () और String.IsNullOrWhiteSpace () का उपयोग करके खाली स्ट्रिंग की जाँच करना

string nullString = null;
string emptyString = "";
string whitespaceString = "    ";
string tabString = "\t";
string newlineString = "\n";
string nonEmptyString = "abc123";

bool result;

result = String.IsNullOrEmpty(nullString);            // true
result = String.IsNullOrEmpty(emptyString);           // true
result = String.IsNullOrEmpty(whitespaceString);      // false
result = String.IsNullOrEmpty(tabString);             // false
result = String.IsNullOrEmpty(newlineString);         // false
result = String.IsNullOrEmpty(nonEmptyString);        // false

result = String.IsNullOrWhiteSpace(nullString);       // true
result = String.IsNullOrWhiteSpace(emptyString);      // true
result = String.IsNullOrWhiteSpace(tabString);        // true
result = String.IsNullOrWhiteSpace(newlineString);    // true
result = String.IsNullOrWhiteSpace(whitespaceString); // true
result = String.IsNullOrWhiteSpace(nonEmptyString);   // false

विशिष्ट सूचकांक पर एक चार्ट प्राप्त करना और स्ट्रिंग की गणना करना

आप किसी भी स्थान पर स्ट्रिंग से किसी भी वर्ण की संख्या प्राप्त करने के लिए Substring विधि का उपयोग कर सकते हैं। हालाँकि, यदि आप केवल एकल वर्ण चाहते हैं, तो आप किसी भी दिए गए अनुक्रमणिका में एकल वर्ण प्राप्त करने के लिए स्ट्रिंग अनुक्रमणिका का उपयोग कर सकते हैं जैसे कि आप किसी सरणी में करते हैं:

string s = "hello";
char c = s[1]; //Returns 'e'

सूचना है कि वापसी प्रकार है char , के विपरीत Substring विधि है जो एक रिटर्न string प्रकार।

आप स्ट्रिंग के पात्रों के माध्यम से अनुक्रमित करने के लिए अनुक्रमणिका का उपयोग कर सकते हैं:

string s = "hello";
foreach (char c in s)
    Console.WriteLine(c);
/********* This will print each character on a new line:
h
e
l
l
o
**********/

दशमलव संख्या को बाइनरी, ऑक्टल और हेक्साडेसिमल प्रारूप में परिवर्तित करें

दशमलव संख्या को द्विआधारी प्रारूप में बदलने के लिए आधार 2 का उपयोग करें
```
Int32 Number = 15;
Console.WriteLine(Convert.ToString(Number, 2));  //OUTPUT : 1111
```
दशमलव संख्या को अष्टक प्रारूप में बदलने के लिए आधार 8 का उपयोग करें
```
int Number = 15;
Console.WriteLine(Convert.ToString(Number, 8));  //OUTPUT : 17
```
दशमलव संख्या को हेक्साडेसिमल प्रारूप में बदलने के लिए बेस 16 का उपयोग करें
```
var Number = 15;
Console.WriteLine(Convert.ToString(Number, 16));  //OUTPUT : f
```

एक स्ट्रिंग को दूसरी स्ट्रिंग से विभाजित करना

string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);

परिणाम:

["यह", "है", "ए", "पूर्ण", "वाक्य"]

सही ढंग से एक स्ट्रिंग उलट

ज्यादातर बार जब लोगों को एक स्ट्रिंग को उल्टा करना पड़ता है, तो वे इसे कम या ज्यादा इस तरह करते हैं:

char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);

हालांकि, इन लोगों को क्या एहसास नहीं है कि यह वास्तव में गलत है।
और मेरे पास NULL चेक गुम होने की वजह से कोई मतलब नहीं है।

यह वास्तव में गलत है क्योंकि एक ग्लिफ़ / ग्रैपहेमक्स्टर में कई कोडपॉइंट्स (उर्फ अक्षर) शामिल हो सकते हैं।

यह देखने के लिए कि ऐसा क्यों है, हमें पहले इस तथ्य से अवगत होना होगा कि "वर्ण" शब्द का वास्तव में क्या मतलब है।

संदर्भ:

चरित्र एक अतिभारित शब्द है जिसकी तुलना में कई चीजें हो सकती हैं।
एक कोड बिंदु सूचना की परमाणु इकाई है। पाठ कोड बिंदुओं का एक क्रम है। प्रत्येक कोड बिंदु एक संख्या है जिसे यूनिकोड मानक द्वारा अर्थ दिया जाता है।
एक अंगूर एक या एक से अधिक कोड बिंदुओं का एक क्रम है जो एकल, चित्रमय इकाई के रूप में प्रदर्शित होता है जिसे एक पाठक लेखन प्रणाली के एकल तत्व के रूप में पहचानता है। उदाहरण के लिए, दोनों और ä ग्रैफेम हैं, लेकिन उनमें कई कोड पॉइंट शामिल हो सकते हैं (जैसे ä दो कोड पॉइंट हो सकते हैं, एक बेस कैरेक्टर के लिए एक के बाद एक डायरिसिस के लिए; लेकिन एक वैकल्पिक, विरासत, सिंगल कोड भी है; बिंदु इस अंगूर का प्रतिनिधित्व करते हैं)। कुछ कोड पॉइंट किसी भी ग्रेपमे का हिस्सा नहीं होते हैं (जैसे शून्य-चौड़ाई वाला गैर-जॉइनर, या दिशात्मक ओवरराइड)।
एक ग्लिफ़ एक छवि है, जिसे आमतौर पर एक फ़ॉन्ट (जो ग्लिफ़ का संग्रह होता है) में संग्रहीत किया जाता है, जिसका उपयोग अंगूर या उसके कुछ हिस्सों का प्रतिनिधित्व करने के लिए किया जाता है। फ़ॉन्ट एक एकल प्रतिनिधित्व में कई ग्लिफ़्स की रचना कर सकते हैं, उदाहरण के लिए, यदि ऊपर का ä एक एकल कोड बिंदु है, तो एक फ़ॉन्ट को दो अलग-अलग, स्थानिक रूप से ओवरलाइड ग्लिफ़ के रूप में प्रस्तुत करना चुना जा सकता है। ओटीएफ के लिए, फ़ॉन्ट के जीएसयूबी और जीपीओएस टेबल में यह काम करने के लिए प्रतिस्थापन और स्थिति की जानकारी होती है। एक फ़ॉन्ट में एक ही अंगूर के लिए कई वैकल्पिक ग्लिफ़ हो सकते हैं।

तो सी # में, एक चरित्र वास्तव में एक कोडपॉइंट है।

जिसका मतलब है, अगर आप Les Misérables तरह एक वैध स्ट्रिंग को उल्टा करते हैं, जो इस तरह दिख सकता है

string s = "Les Mise\u0301rables";

पात्रों के अनुक्रम के रूप में, आपको मिलेगा:

selbaŕesiM seL

जैसा कि आप देख सकते हैं, उच्चारण ई चरित्र के बजाय, आर अक्षर पर है।
यद्यपि string.reverse.reverse मूल स्ट्रिंग का उत्पादन करेगा यदि आप दोनों बार चार सरणी को उलटते हैं, तो निश्चित रूप से इस तरह का उलट मूल स्ट्रिंग के विपरीत नहीं होगा।

आपको प्रत्येक GraphemeCluster को उल्टा करना होगा।
तो, अगर सही ढंग से किया जाता है, तो आप इस तरह से एक स्ट्रिंग उल्टा करते हैं:

    private static System.Collections.Generic.List<string> GraphemeClusters(string s)
    {
        System.Collections.Generic.List<string> ls = new System.Collections.Generic.List<string>();

        System.Globalization.TextElementEnumerator enumerator = System.Globalization.StringInfo.GetTextElementEnumerator(s);
        while (enumerator.MoveNext())
        {
            ls.Add((string)enumerator.Current);
        }

        return ls;
    }


    // this 
    private static string ReverseGraphemeClusters(string s)
    {
        if(string.IsNullOrEmpty(s) || s.Length == 1)
             return s;
        
        System.Collections.Generic.List<string> ls = GraphemeClusters(s);
        ls.Reverse();

        return string.Join("", ls.ToArray());
    }

    public static void TestMe()
    {
        string s = "Les Mise\u0301rables";
        // s = "noël";
        string r = ReverseGraphemeClusters(s);

        // This would be wrong:
        // char[] a = s.ToCharArray();
        // System.Array.Reverse(a);
        // string r = new string(a);

        System.Console.WriteLine(r);
    }

और - ओह आनंद - आपको एहसास होगा कि अगर आप इसे सही तरीके से करते हैं, तो यह एशियाई / दक्षिण-एशियाई / पूर्व-एशियाई भाषाओं (और फ्रेंच / स्वीडिश / नार्वेजियन, आदि) के लिए भी काम करेगा ...

एक स्ट्रिंग के भीतर एक स्ट्रिंग की जगह

System.String.Replace पद्धति का उपयोग करके, आप एक स्ट्रिंग के भाग को दूसरे स्ट्रिंग से बदल सकते हैं।

string s = "Hello World";
 s = s.Replace("World", "Universe"); // s = "Hello Universe"

खोज स्ट्रिंग की सभी घटनाओं को प्रतिस्थापित किया जाता है।

इस विधि का उपयोग स्ट्रिंग के भाग को निकालने के लिए भी किया जा सकता है, स्ट्रिंग का उपयोग कर। String.Empty क्षेत्र:

string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"

एक स्ट्रिंग के भीतर पात्रों के मामले को बदलना

System.String वर्ग एक स्ट्रिंग में अपरकेस और लोअरकेस वर्णों के बीच कनवर्ट करने के लिए कई तरीकों का समर्थन करता है।

System.String.ToLowerInvariant का उपयोग स्ट्रींग ऑब्जेक्ट को लोअरकेस में कनवर्ट करने के लिए किया जाता है।

System.String.ToUpperInvariant का उपयोग अपरकेस में परिवर्तित स्ट्रिंग वस्तु को वापस करने के लिए किया जाता है।

नोट: इन विधियों के अपरिवर्तनीय संस्करणों का उपयोग करने का कारण अप्रत्याशित संस्कृति-विशिष्ट अक्षरों का उत्पादन रोकना है। इसे यहां विस्तार से बताया गया है ।

उदाहरण:

string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"

ध्यान दें कि आप एक विशिष्ट संस्कृति को निर्दिष्ट करने के लिए चुन सकते हैं जब String.ToLower (CultureInfo) और String.ToUpper (CultureInfo) तरीकों का उपयोग करके लोअरकेस और अपरकेस में कनवर्ट किया जाता है।

एक स्ट्रिंग में स्ट्रिंग की एक सरणी को समेटें

System.String.Join विधि प्रत्येक तत्व के बीच एक निर्दिष्ट विभाजक का उपयोग करके, एक स्ट्रिंग सरणी में सभी तत्वों को System.String.Join करने की अनुमति देती है:

string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"

स्ट्रिंग कॉनटेनटेशन

स्ट्रिंग संघनन System.String.Concat विधि का उपयोग करके किया जा सकता है, या (बहुत आसान) + का उपयोग करके किया जा सकता है:

string first = "Hello ";
string second = "World";

string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"

C # 6 में इस प्रकार किया जा सकता है:

string concat = $"{first},{second}";

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

C# Language
सामान्य स्ट्रिंग संचालन

खोज…

विशिष्ट चरित्र द्वारा एक स्ट्रिंग को विभाजित करना

किसी दिए गए स्ट्रिंग के सबस्ट्रिंग प्राप्त करना

निर्धारित करें कि क्या एक स्ट्रिंग दिए गए अनुक्रम से शुरू होती है

स्टार्टिंग और / या स्ट्रिंग्स के अंत से अनचाहे वर्ण ट्रिमिंग।

`String.Trim()`

`String.TrimStart()` और `String.TrimEnd()`

एक तार का प्रारूपण

एक नए में तार की एक सरणी में शामिल होना

एक स्ट्रिंग को एक निश्चित लंबाई में बांधना

ऐरे से एक तार का निर्माण

ToString का उपयोग करके स्वरूपण

स्ट्रिंग के दाईं ओर से x अक्षर प्राप्त करना

String.IsNullOrEmpty () और String.IsNullOrWhiteSpace () का उपयोग करके खाली स्ट्रिंग की जाँच करना

विशिष्ट सूचकांक पर एक चार्ट प्राप्त करना और स्ट्रिंग की गणना करना

दशमलव संख्या को बाइनरी, ऑक्टल और हेक्साडेसिमल प्रारूप में परिवर्तित करें

एक स्ट्रिंग को दूसरी स्ट्रिंग से विभाजित करना

सही ढंग से एक स्ट्रिंग उलट

एक स्ट्रिंग के भीतर एक स्ट्रिंग की जगह

एक स्ट्रिंग के भीतर पात्रों के मामले को बदलना

एक स्ट्रिंग में स्ट्रिंग की एक सरणी को समेटें

स्ट्रिंग कॉनटेनटेशन

विशिष्ट चरित्र द्वारा एक स्ट्रिंग को विभाजित करना

किसी दिए गए स्ट्रिंग के सबस्ट्रिंग प्राप्त करना

निर्धारित करें कि क्या एक स्ट्रिंग दिए गए अनुक्रम से शुरू होती है

स्टार्टिंग और / या स्ट्रिंग्स के अंत से अनचाहे वर्ण ट्रिमिंग।

String.Trim()

String.TrimStart() और String.TrimEnd()

एक तार का प्रारूपण

एक नए में तार की एक सरणी में शामिल होना

एक स्ट्रिंग को एक निश्चित लंबाई में बांधना

ऐरे से एक तार का निर्माण

ToString का उपयोग करके स्वरूपण

स्ट्रिंग के दाईं ओर से x अक्षर प्राप्त करना

String.IsNullOrEmpty () और String.IsNullOrWhiteSpace () का उपयोग करके खाली स्ट्रिंग की जाँच करना

विशिष्ट सूचकांक पर एक चार्ट प्राप्त करना और स्ट्रिंग की गणना करना

दशमलव संख्या को बाइनरी, ऑक्टल और हेक्साडेसिमल प्रारूप में परिवर्तित करें

एक स्ट्रिंग को दूसरी स्ट्रिंग से विभाजित करना

सही ढंग से एक स्ट्रिंग उलट

एक स्ट्रिंग के भीतर एक स्ट्रिंग की जगह

एक स्ट्रिंग के भीतर पात्रों के मामले को बदलना

एक स्ट्रिंग में स्ट्रिंग की एक सरणी को समेटें

स्ट्रिंग कॉनटेनटेशन

`String.Trim()`

`String.TrimStart()` और `String.TrimEnd()`