Eu preciso de uma maneira de remover o primeiro caractere de uma seqüência de caracteres que é um espaço. Estou procurando um método ou mesmo uma extensão para o tipo String que eu possa usar para cortar um caractere de uma string.

Para remover os espaços em branco iniciais e finais:

let trimmedString = string.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

Swift 3 / Swift 4:

let trimmedString = string.trimmingCharacters(in: .whitespaces)

A maneira correta quando você deseja remover todos os tipos de espaços em branco (com base nesta resposta do SO ) é:

extension String {
    var stringByRemovingWhitespaces: String {
        let components = componentsSeparatedByCharactersInSet(.whitespaceCharacterSet())
        return components.joinWithSeparator("")
    }
}

Swift 3.0+ (3.0, 3.1, 3.2, 4.0)

extension String {
    func removingWhitespaces() -> String {
        return components(separatedBy: .whitespaces).joined()
    }
}

EDITAR

Esta resposta foi publicada quando a pergunta era sobre a remoção de todos os espaços em branco. A pergunta foi editada para mencionar apenas os espaços em branco à esquerda. Se você deseja remover apenas os espaços em branco à esquerda, use o seguinte:

extension String {
    func removingLeadingSpaces() -> String {
        guard let index = firstIndex(where: { !CharacterSet(charactersIn: String($0)).isSubset(of: .whitespaces) }) else {
            return self
        }
        return String(self[index...])
    }
}

Essa extensão String remove todo o espaço em branco de uma string, não apenas o espaço em branco à direita ...

 extension String {
    func replace(string:String, replacement:String) -> String {
        return self.replacingOccurrences(of: string, with: replacement, options: NSString.CompareOptions.literal, range: nil)
    }

    func removeWhitespace() -> String {
        return self.replace(string: " ", replacement: "")
    }
  }

Exemplo:

let string = "The quick brown dog jumps over the foxy lady."
let result = string.removeWhitespace() // Thequickbrowndogjumpsoverthefoxylady.

Swift 3

Você pode simplesmente usar esse método para remover todos os espaços normais em uma string (não considera todos os tipos de espaço em branco):

let myString = " Hello World ! "
let formattedString = myString.replacingOccurrences(of: " ", with: "")

O resultado será:

HelloWorld!

Você também pode usar regex.

let trimmedString = myString.stringByReplacingOccurrencesOfString("\\s", withString: "", options: NSStringCompareOptions.RegularExpressionSearch, range: nil)

Para o Swift 3.0+, consulte as outras respostas. Esta é agora uma resposta herdada para o Swift 2.x

Como respondido acima, como você está interessado em remover o primeiro caractere, o método de instância .stringByTrimmingCharactersInSet () funcionará bem:

myString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

Você também pode criar seus próprios conjuntos de caracteres para aparar os limites de suas cordas, ex:

myString.stringByTrimmingCharactersInSet(NSCharacterSet(charactersInString: "<>"))

Também existe um método de instância integrado para lidar com a remoção ou substituição de substrings chamados stringByReplacingOccurrencesOfString (target: String, substituição: String) . Ele pode remover espaços ou quaisquer outros padrões que ocorram em qualquer lugar da sua string

Você pode especificar opções e intervalos, mas não precisa:

myString.stringByReplacingOccurrencesOfString(" ", withString: "")

Essa é uma maneira fácil de remover ou substituir qualquer padrão repetido de caracteres em sua string e pode ser encadeada, embora cada vez que ela tenha que passar por outra passagem por toda a string, diminuindo a eficiência. Então você pode fazer isso:

 myString.stringByReplacingOccurrencesOfString(" ", withString: "").stringByReplacingOccurrencesOfString(",", withString: "")

... mas levará o dobro do tempo.

.stringByReplacingOccurrencesOfString () documentação do site da Apple

Às vezes, encadear esses métodos de instância String pode ser muito conveniente para conversões únicas, por exemplo, se você deseja converter um blob NSData curto em uma string hexadecimal sem espaços em uma linha, é possível fazer isso com a interpolação String incorporada do Swift e alguns ajustes e substituindo:

("\(myNSDataBlob)").stringByTrimmingCharactersInSet(NSCharacterSet(charactersInString: "<>")).stringByReplacingOccurrencesOfString(" ", withString: "")

For swift 3.0

import Foundation

var str = " Hear me calling"

extension String {
    var stringByRemovingWhitespaces: String {
        return components(separatedBy: .whitespaces).joined()
    }
}

str.stringByRemovingWhitespaces  // Hearmecalling

Swift 4

O excelente caso para usar a regex:

" this is    wrong contained teee xt     "
    .replacingOccurrences(of: "^\\s+|\\s+|\\s+$", 
                          with: "", 
                          options: .regularExpression)

// thisiswrongcontainedteeext

Eu usaria essa extensão para ser flexível e imitar como outras coleções fazem isso:

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"

Se você deseja remover espaços da frente (e de trás), mas não do meio, use stringByTrimmingCharactersInSet

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

Se você deseja remover espaços de qualquer lugar da string, consulte stringByReplacing ...

Swift 4, 4.2 e 5

Remova espaço apenas da frente e do fim

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

Remova espaços de todos os lugares da cadeia

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

Você pode tentar isso também

   let updatedString = searchedText?.stringByReplacingOccurrencesOfString(" ", withString: "-")

Experimente a programação funcional para remover os espaços em branco:

extension String {
  func whiteSpacesRemoved() -> String {
    return self.filter { $0 != Character(" ") }
  }
}

extension String {

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

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

Se alguém remover espaço extra da string, por exemplo, = "This is the demo text remove extra space between the words."

Você pode usar esta função no Swift 4.

func removeSpace(_ string: String) -> String{
    var str: String = String(string[string.startIndex])
    for (index,value) in string.enumerated(){
        if index > 0{
            let indexBefore = string.index(before: String.Index.init(encodedOffset: index))
            if value == " " && string[indexBefore] == " "{
            }else{
                str.append(value)
            }
        }
    }
    return str
}

e o resultado será

"This is the demo text remove extra space between the words."

Oi, isso pode ser tarde, mas vale a pena tentar. Isso é de um arquivo de playground. Você pode torná-lo uma extensão String.

Isso está escrito no Swift 5.3

Método 1:

var str = "\n \tHello, playground       "
if let regexp = try? NSRegularExpression(pattern: "^\\s+", options: NSRegularExpression.Options.caseInsensitive) {
    let mstr = NSMutableString(string: str)
    regexp.replaceMatches(in: mstr, options: [], range: NSRange(location: 0, length: str.count), withTemplate: "")
    str = mstr as String
}

Result: "Hello, playground       "

Método 2:

if let c = (str.first { !($0 == " " || $0 == "\t" || $0 == "\n") }) {
    if let nonWhiteSpaceIndex = str.firstIndex(of: c) {
        str.replaceSubrange(str.startIndex ..< nonWhiteSpaceIndex, with: "")
    }
}

Result: "Hello, playground       "

Versão 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)
        }

Aparar espaços em branco no Swift 4

let strFirstName = txtFirstName.text?.trimmingCharacters(in: 
 CharacterSet.whitespaces)

Ainda outra resposta, às vezes a sequência de entrada pode conter mais de um espaço entre as palavras. Se você precisar padronizar para ter apenas 1 espaço entre as palavras, tente isso (Swift 4/5)

let inputString = "  a very     strange   text !    "
let validInput = inputString.components(separatedBy:.whitespacesAndNewlines).filter { $0.count > 0 }.joined(separator: " ")

print(validInput) // "a very strange text !"

Para mim, a seguinte linha costumava remover o espaço em branco.

let result = String(yourString.filter {![" ", "\t", "\n"].contains($0)})

string = string.filter ({!" ".contains($0) })

Versão Swift 3 da resposta do BadmintonCat

extension String {
    func replace(_ string:String, replacement:String) -> String {
        return self.replacingOccurrences(of: string, with: replacement, options: NSString.CompareOptions.literal, range: nil)
    }

    func removeWhitespace() -> String {
        return self.replace(" ", replacement: "")
    }
}

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

Para remover todos os espaços da sequência:

let space_removed_string = (yourstring?.components(separatedBy: " ").joined(separator: ""))!