ट्रिम केवल स्विफ्ट में काट-छाँट तार का हर उदाहरण स्विफ्ट 3

Question

में स्ट्रिंग के अंत से खाली स्थान के अनुगामी दोनों प्रमुख और अनुगामी सफेद स्थान को निकालना है, लेकिन कैसे केवल अनुगामी कर सकते हैं व्हाइटस्पेस निकाल जा सकता है?

उदाहरण के लिए

, अगर मैं एक स्ट्रिंग है:

" example " 

मैं कैसे साथ खत्म कर सकते हैं:

" example" 

हर समाधान मैं शो trimmingCharacters(in: CharacterSet.whitespaces) पाया है, लेकिन मैं अग्रणी बनाए रखना चाहते खाली स्थान के।

रेगुलर एक्सप्रेशन से एक संभावना है, या एक सीमा पात्रों में से सूचकांक का निर्धारण दूर करने के लिए प्राप्त किया जा सकता है, लेकिन मैं इस बात के लिए एक सुरुचिपूर्ण समाधान खोजने के लिए प्रतीत नहीं कर सकते हैं।

Answer 1

नियमित अभिव्यक्ति के साथ

:

let string = " example " 
let trimmed = string.replacingOccurrences(of: "\\s+$", with: "", options: .regularExpression) 
print(">" + trimmed + "<") 
// > example< 

\s+ एक या अधिक खाली स्थान के अक्षर, और $ मैचों स्ट्रिंग के अंत से मेल खाता है।

Answer 2

Foundation में आप एक नियमित अभिव्यक्ति मिलान सूचकांक की सीमाओं मिल सकती है। आप subranges भी बदल सकते हैं। इस के संयोजन, हम पाते हैं:

import Foundation 
extension String { 
    mutating func trimTrailingWhitespace() { 
     if let trailingWs = self.range(of: "\\s+$", options: .regularExpression) { 
      self.replaceSubrange(trailingWs, with: "") 
     } 
    } 
} 

अगर हम \s* के खिलाफ मेल खाते हैं (जैसा कि मार्टिन आर पहली बार में किया था) हम if let गार्ड को छोड़ सकते हैं:

import Foundation 
extension String { 
    func trimTrailingWhitespace() -> String { 
     if let trailingWs = self.range(of: "\\s+$", options: .regularExpression) { 
      return self.replacingCharacters(in: trailingWs, with: "") 
     } else { 
      return self 
     } 
    } 
} 

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

func removeTrailingSpaces(with spaces : String) -> String{ 

     var spaceCount = 0 
     for characters in spaces.characters{ 
      if characters == " "{ 
       print("Space Encountered") 
       spaceCount = spaceCount + 1 
      }else{ 
       break; 
      } 
     } 

     var finalString = "" 
     let duplicateString = spaces.replacingOccurrences(of: " ", with: "") 
     while spaceCount != 0 { 
      finalString = finalString + " " 
      spaceCount = spaceCount - 1 
     } 

     return (finalString + duplicateString) 


    } 

आप निम्नलिखित तरीके से इस सुविधा का उपयोग कर सकते हैं::

Answer 3

नियमित अभिव्यक्ति के बिना प्राप्त करने के लिए that.Alternatively आप अपने आवश्यक परिणाम प्राप्त करने के लिए नीचे दिए गए समारोह का उपयोग कर सकते सीधा रास्ता नहीं है -

let str = " Himanshu " 
print(removeTrailingSpaces(with : str)) 

Answer 4

यह hacky एक छोटा सा: डी

let message = " example " 
var trimmed = ("s" + message).trimmingCharacters(in: .whitespacesAndNewlines) 
trimmed = trimmed.substring(from: trimmed.index(after: trimmed.startIndex)) 

Answer 5

इस छोटे स्विफ्ट 3 स्ट्रिंग के विस्तार rangeOfCharacter की .anchored और .backwards विकल्प का उपयोग करता है और फिर खुद रिकर्सिवली कॉल अगर यह पाश की जरूरत है। चूंकि कंपाइलर कैरेक्टरसेट को पैरामीटर के रूप में उम्मीद कर रहा है, इसलिए आप कॉल करते समय केवल स्थिर आपूर्ति कर सकते हैं, उदा। "1234 ".trailing(.whitespaces)"1234" वापस करेगा। (मैं समय नहीं किया है, लेकिन regex की तुलना में तेजी उम्मीद होती है।)

extension String { 
    func trailingTrim(_ characterSet : CharacterSet) -> String { 
     if let range = rangeOfCharacter(from: characterSet, options: [.anchored, .backwards]) { 
      return self.substring(to: range.lowerBound).trailingTrim(characterSet) 
     } 
     return self 
    } 
} 

Answer 6

स्विफ्ट में 4

var trailingSpacesTrimmed: String { 
    var newString = self 

    while newString.hasSuffix(" ") { 
     newString = String(newString.dropLast()) 
    } 

    return newString 
} 

[स्विफ्ट को दूर ही स्ट्रिंग से पीछे वाले स्पेस] के