एक स्ट्रिंग

Question

में संग्रहीत कोड की अनदेखी लाइनों के कुशल तरीका मेरे पास string[] है जिसमें कोड शामिल है। प्रत्येक पंक्ति में कुछ प्रमुख रिक्त स्थान होते हैं। मुझे मौजूदा प्रारूपण को बदलने के बिना जितना संभव हो सके कोड को 'अनइंडेंट' करने की आवश्यकता है।

उदाहरण के लिए की सामग्री को मेरी string[] हो सकता है

           public class MyClass 
             { 
              private bool MyMethod(string s) 
              { 
               return s == ""; 
              } 
             } 

मैं एक यथोचित सुरुचिपूर्ण और कुशल पद्धति प्राप्त करना चाहते हैं (LINQ?) यह

public class MyClass 
{ 
    private bool MyMethod(string s) 
    { 
     return s == ""; 
    } 
}

को बदलने के लिए स्पष्ट रूप से कहें मैं

IEnumerable<string> UnindentAsMuchAsPossible(string[] content) 
{ 
    return ???; 
} 

Answer 1

टिम Schmelter के जवाब पर निर्माण:

static IEnumerable<string> UnindentAsMuchAsPossible(IEnumerable<string> input) 
{ 
    const int TabWidth = 4; 

    if (!input.Any()) 
    { 
     return Enumerable.Empty<string>(); 
    } 

    int minDistance = input 
     .Where(line => line.Length > 0) 
     .Min(line => line 
      .TakeWhile(Char.IsWhiteSpace) 
      .Sum(c => c == '\t' ? TabWidth : 1)); 

    return input 
     .Select(line => line.Replace("\t", new string(' ', TabWidth))) 
     .Select(line => line.Substring(Math.Min(l.Length, minDistance)); 
} 

यह संभालता है:

• टैब वर्ण
• स्रोत कोड है कि खाली लाइनों

Answer 2

यह पहली बार न्यूनतम पहचान पायेगा और फिर थै को हटा देगा प्रत्येक पंक्ति के लिए रिक्त स्थान की संख्या।

var code = new [] { " foo", " bar" }; 

var minIndent = code.Select(line => line.TakeWhile(ch => ch == ' ').Count()).Min(); 
var formatted = code.Select(line => line.Remove(0, minIndent)); 

यह एक ही अभिव्यक्ति में सब कुछ लिखने के लिए संभव हो जाएगा, लेकिन मुझे लगता है कि minIndent चर कोड अधिक पठनीय बनाता है, जबकि यह अधिक कार्यात्मक सुरुचिपूर्ण है।

Answer 3

बस पहली पंक्ति पर प्रमुख स्थानों की संख्या गिनती, और फिर प्रत्येक पंक्ति की शुरुआत से "निकालें" कि सारे वर्ण:

IEnumerable<string> UnindentAsMuchAsPossible(string[] content) 
{ 
    int spacesOnFirstLine = content[0].TakeWhile(c => c == ' ').Count(); 
    return content.Select(line => line.Substring(spacesOnFirstLine)); 
} 

Answer 4

एक छोटे से LINQ और regex का उपयोग कम से कम खरोज लगता है, फिर सभी पंक्तियों से वर्णों की संख्या हटा दें।

string[] l_lines = { 
         "           public class MyClass", 
         "           {", 
         "            private bool MyMethod(string s)", 
         "            {", 
         "             return s == \"\";", 
         "            }", 
         "           }" 
        }; 

int l_smallestIndentation = 
    l_lines.Min(s => Regex.Match(s, "^\\s*").Value.Length); 

string[] l_result = 
    l_lines.Select(s => s.Substring(l_smallestIndentation)) 
      .ToArray(); 

foreach (string l_line in l_result) 
    Console.WriteLine(l_line); 

प्रिंटों:

public class MyClass 
{ 
    private bool MyMethod(string s) 
    { 
     return s == ""; 
    } 
} 

इस कार्यक्रम सरणी में सभी स्ट्रिंग्स को स्कैन करेगा। आप यह मान सकते हैं कि पहली पंक्ति से कम दांतेदार है, तो आप केवल पहली पंक्ति को स्कैन करके प्रदर्शन में सुधार कर सकते हैं:

int l_smallestIndentation = 
    Regex.Match(l_lines[0], "^\\s*").Value.Length; 

यह भी ध्यान रखें कि यह एक एकल चरित्र के रूप में एक टैब वर्ण ("\t") को संभाल लेंगे। यदि टैब और रिक्त स्थान का मिश्रण होता है, तो इंडेंट को उलटना मुश्किल हो सकता है। इसे संभालने का सबसे आसान तरीका रिक्त स्थान की उचित संख्या के साथ टैब के सभी उदाहरणों को प्रतिस्थापित करना होगा (अक्सर 4, हालांकि व्यक्तिगत अनुप्रयोग जंगली रूप से भिन्न हो सकते हैं) ऊपर दिए गए कोड को चलाने से पहले।

टैब पर अतिरिक्त वजन देने के लिए ऊपर दिए गए कोड को संशोधित करना भी संभव होगा। उस बिंदु पर, रेगेक्स अब अधिक उपयोग नहीं है।

public class MyClass 
{ 
     private bool MyMethod(string s) 
     { 
       return s == ""; 
     } 
} 

आप किनारे मामले के परिदृश्यों के साथ काम करने के लिए इस कोड को संशोधित करने की आवश्यकता हो सकती है, जैसे शून्य:

string[] l_lines = { 
     "\t\t\tpublic class MyClass", 
     "      {", 
     "        private bool MyMethod(string s)", 
     "        {", 
     "  \t  \t\treturn s == \"\";", 
     "        }", 
     "\t\t\t}" 
    }; 

int l_tabWeight = 8; 
int l_smallestIndentation = 
    l_lines.Min 
    (
     s => s.ToCharArray() 
       .TakeWhile(c => Char.IsWhiteSpace(c)) 
       .Select(c => c == '\t' ? l_tabWeight : 1) 
       .Sum() 
    ); 

string[] l_result = 
    l_lines.Select 
    (
     s => 
     { 
      int l_whitespaceToRemove = l_smallestIndentation; 
      while (l_whitespaceToRemove > 0) 
      { 
       l_whitespaceToRemove -= s[0] == '\t' ? l_tabWeight : 1; 
       s = s.Substring(1); 
      } 
      return s; 
     } 
    ).ToArray(); 

प्रिंटों (अपने कंसोल विंडो संभालने मेरे जैसे एक टैब 8 की चौड़ाई है) लंबाई रेखाएं या रेखाएं जिनमें केवल सफेद जगहें होती हैं।

Answer 5

यह काम करना चाहिए:

static IEnumerable<string> UnindentAsMuchAsPossible(IEnumerable<string> input) 
{ 
    int minDistance = input.Min(l => l.TakeWhile(Char.IsWhiteSpace).Count()); 
    return input.Select(l => l.Substring(minDistance)); 
} 

यह बाईं ओर कोड चलता है, रिक्त स्थान की एक ही नंबर के साथ सभी लाइनों।

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

string testString = @"  
        public class MyClass 
        { 
         private bool MyMethod(string s) 
         { 
          return s == ""; 
         } 
        }"; 


string[] lines = testString.Split(new[] { Environment.NewLine }, StringSplitOptions.None); 
string[] unindentedArray = UnindentAsMuchAsPossible(lines).ToArray(); 

Answer 6

अपने वांछित विधि इंटरफ़ेस से मेल करने के लिए:

IEnumerable<string> UnindentAsMuchAsPossible(string[] content) 
{ 
    int minIndent = content.Select(s => s.TakeWhile(c => c == ' ').Count()).Min(); 
    return content.Select(s => s.Substring(minIndent)).AsEnumerable(); 
} 

यह सभी लाइनों की न्यूनतम मांगपत्र (रिक्त स्थानों केवल, कोई टैब ग्रहण), तो से minIndent रिक्त स्थान स्ट्रिप्स हो जाता है प्रत्येक पंक्ति की शुरुआत और IEnumerable के रूप में लौटाता है।