我会使用这个扩展，以灵活和模仿其他集合如何做到这一点:

extension String {
    func filter(pred: Character -> Bool) -> String {
        var res = String()
        for c in self.characters {
            if pred(c) {
                res.append(c)
            }
        }
        return res
    }
}

"this is a String".filter { $0 != Character(" ") } // "thisisaString"

如果你想要从前面(和后面)而不是中间删除空格，你应该使用stringByTrimmingCharactersInSet

    let dirtyString   = " First Word "
    let cleanString = dirtyString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

如果你想从字符串的任何地方删除空格，那么你可能需要查看stringbyreplacement…

Swift 4、4.2和5

仅从前端和尾部移除空间

let str = "  Akbar Code  "
let trimmedString = str.trimmingCharacters(in: .whitespacesAndNewlines)

从字符串中的每一个地方删除空格

let stringWithSpaces = " The Akbar khan code "
let stringWithoutSpaces = stringWithSpaces.replacingOccurrences(of: " ", with: "")

extension String {

    var removingWhitespaceAndNewLines: String {
        return removing(.whitespacesAndNewlines)
    }

    func removing(_ forbiddenCharacters: CharacterSet) -> String {
        return String(unicodeScalars.filter({ !forbiddenCharacters.contains($0) }))
    }
}

快速解决方案:

用法:

let txt = "        hello world     "
let txt1 = txt.trimStart() // "hello world     "
let txt2 = txt.trimEnd()   // "        hello world"

用法二:

let txt = "rr rrr rrhello world r r r r r r"
let txt1 = txt.trimStart(["r", " "]) // "hello world r r r r r r"
let txt2 = txt.trimEnd(["r", " "])   // "rr rrr rrhello world"

如果你需要移除字符串中的所有空白:

txt.replace(of: " ", to: "")

public extension String {
    func trimStart(_ char: Character) -> String {
        return trimStart([char])
    }
    
    func trimStart(_ symbols: [Character] = [" ", "\t", "\r", "\n"]) -> String {
        var startIndex = 0
        
        for char in self {
            if symbols.contains(char) {
                startIndex += 1
            }
            else {
                break
            }
        }
        
        if startIndex == 0 {
            return self
        }
        
        return String( self.substring(from: startIndex) )
    }
    
    func trimEnd(_ char: Character) -> String {
        return trimEnd([char])
    }
    
    func trimEnd(_ symbols: [Character] = [" ", "\t", "\r", "\n"]) -> String {
        var endIndex = self.count - 1
        
        for i in (0...endIndex).reversed() {
            if symbols.contains( self[i] ) {
                endIndex -= 1
            }
            else {
                break
            }
        }
        
        if endIndex == self.count {
            return self
        }
        
        return String( self.substring(to: endIndex + 1) )
    }
}

/////////////////////////
/// ACCESS TO CHAR BY INDEX
////////////////////////
extension StringProtocol {
    subscript(offset: Int) -> Character { self[index(startIndex, offsetBy: offset)] }
    subscript(range: Range<Int>) -> SubSequence {
        let startIndex = index(self.startIndex, offsetBy: range.lowerBound)
        return self[startIndex..<index(startIndex, offsetBy: range.count)]
    }
    subscript(range: ClosedRange<Int>) -> SubSequence {
        let startIndex = index(self.startIndex, offsetBy: range.lowerBound)
        return self[startIndex..<index(startIndex, offsetBy: range.count)]
    }
    subscript(range: PartialRangeFrom<Int>) -> SubSequence { self[index(startIndex, offsetBy: range.lowerBound)...] }
    subscript(range: PartialRangeThrough<Int>) -> SubSequence { self[...index(startIndex, offsetBy: range.upperBound)] }
    subscript(range: PartialRangeUpTo<Int>) -> SubSequence { self[..<index(startIndex, offsetBy: range.upperBound)] }
}

斯威夫特5 + 从字符串的前缀(开始)删除所有空白，你可以使用类似的后缀/字符串的结束

 extension String {
    func deletingPrefix(_ prefix: String) -> String {
      guard self.hasPrefix(prefix) else { return self }
      return String(self.dropFirst(prefix.count))
    }
    
    func removeWhitespacePrefix() -> String {
     let prefixString = self.prefix(while: { char in
        return char == " "
      })
      return self.deletingPrefix(String(prefixString))
    }
  }