Necesito una forma de eliminar el primer carácter de una cadena que es un espacio. Estoy buscando un método o incluso una extensión para el tipo de cadena que pueda usar para cortar un carácter de una cadena.

Para eliminar espacios en blanco iniciales y finales:

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

Swift 3 / Swift 4:

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

La forma correcta cuando desea eliminar todo tipo de espacios en blanco (en base a esta respuesta SO ) es:

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 respuesta se publicó cuando la pregunta era sobre la eliminación de todos los espacios en blanco, la pregunta se editó para mencionar solo los espacios en blanco principales. Si solo desea eliminar los espacios en blanco iniciales, use lo siguiente:

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

Esta extensión de cadena elimina todo el espacio en blanco de una cadena, no solo el espacio en blanco final ...

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

Ejemplo:

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

Swift 3

Simplemente puede usar este método para eliminar todos los espacios normales en una cadena (no considera todos los tipos de espacios en blanco):

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

El resultado será:

HelloWorld!

También puedes usar regex.

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

Para Swift 3.0+, vea las otras respuestas. Esta es ahora una respuesta heredada para Swift 2.x

Como se respondió anteriormente, dado que está interesado en eliminar el primer carácter, el método de instancia .stringByTrimmingCharactersInSet () funcionará bien:

myString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

También puede crear sus propios conjuntos de caracteres para recortar los límites de sus cadenas, por ejemplo:

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

También hay un método de instancia incorporado para tratar de eliminar o reemplazar subcadenas llamado stringByReplacingOccurrencesOfString (target: String, replace: String) . Puede eliminar espacios o cualquier otro patrón que ocurra en cualquier parte de su cadena

Puede especificar opciones y rangos, pero no necesita:

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

Esta es una manera fácil de eliminar o reemplazar cualquier patrón repetitivo de caracteres en su cadena, y se puede encadenar, aunque cada vez que lo haga tiene que pasar de nuevo por toda su cadena, disminuyendo la eficiencia. Entonces puedes hacer esto:

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

... pero tomará el doble de tiempo.

.stringByReplacingOccurrencesOfString () documentación del sitio de Apple

Encadenar estos métodos de instancia de String a veces puede ser muy conveniente para conversiones únicas, por ejemplo, si desea convertir un blob NSData corto en una cadena hexadecimal sin espacios en una línea, puede hacerlo con la interpolación de String incorporada de Swift y algunos recortes y reemplazando:

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

Para 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

El excelente caso para usar la expresión regular:

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

// thisiswrongcontainedteeext

Usaría esta extensión, para ser flexible e imitar cómo lo hacen otras colecciones:

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"

Si desea eliminar espacios del frente (y la parte posterior) pero no del medio, debe usar stringByTrimmingCharactersInSet

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

Si desea eliminar espacios de cualquier parte de la cadena, puede que desee mirar stringByReplacing ...

Swift 4, 4.2 y 5

Elimine el espacio de la parte frontal y final solamente

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

Eliminar espacios de cada parte de la cadena

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

Puedes probar esto también

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

Pruebe la programación funcional para eliminar espacios en blanco:

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

Si alguien elimina el espacio extra de la cadena, por ejemplo = "This is the demo text remove extra space between the words."

Puede usar esta función en 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
}

y el resultado será

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

Hola, esto puede ser tarde pero vale la pena intentarlo. Esto es de un archivo del patio de recreo. Puede convertirlo en una extensión de cadena.

Esto está escrito en 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       "

Versión 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)
        }

Recortar espacios en blanco en Swift 4

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

Otra respuesta más, a veces la cadena de entrada puede contener más de un espacio entre palabras. Si necesita estandarizar para tener solo 1 espacio entre palabras, intente esto (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 mí, la siguiente línea solía eliminar espacios en blanco.

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

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

Versión Swift 3 de la respuesta de 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 eliminar todos los espacios de la cadena:

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