对于任何想要从字符串中删除前导空格的人(正如问题标题所明确要求的那样)，这里有一个答案:

假设:

let string = "   Hello, World!   "

要删除所有前导空格，使用以下代码:

var filtered = ""
var isLeading = true
for character in string {
    if character.isWhitespace && isLeading {
        continue
    } else {
        isLeading = false
        filtered.append(character)
    }
}
print(filtered) // "Hello, World!   "

我相信有比这更好的代码，但它已经完成了我的工作。

好吧，这是老问题了，但我自己也遇到过这个问题，除了删除所有空白之外，上面的答案都不起作用，这可能会损害应用的功能。我的问题是这样的:

["This", " is", " my", " array", " it is awesome"]

如果修剪所有的空白，这将是输出:

["This", "is", "my", "array", "itisawesome"]

所以我需要消除前导间距，并简单地从:

 let array = jsonData.components(separatedBy: ",")

To

let array = jsonData.components(separatedBy: ", ")

修正了这个问题。希望将来有人发现这个有用。

class SpaceRemover
{
    func SpaceRemover(str :String)->String
    {
        var array = Array(str)
        var i = array.count
        while(array.last == " ")
        {
            var array1 = [Character]()
            for item in  0...i - 1
            {
                array1.append(array[item])
            }
            i = i - 1
            array = array1
            print(array1)
            print(array)

        }

        var arraySecond = array
        var j = arraySecond.count

        while(arraySecond.first == " ")
        {
            var array2 = [Character]()
            if j > 1
            {
                for item in 1..<j
                {
                    array2.append(arraySecond[item])
                }
            }
            j = j - 1
            arraySecond = array2
            print(array2)
            print(arraySecond)

        }
        print(arraySecond)
        return String(arraySecond)
    }
}

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

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"

Swift 3版本

  //This function trim only white space:
   func trim() -> String
        {
            return self.trimmingCharacters(in: CharacterSet.whitespaces)
        }
    //This function trim whitespeaces and new line that you enter:
     func trimWhiteSpaceAndNewLine() -> String
        {
            return self.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
        }

快速解决方案:

用法:

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)] }
}