J'ai besoin d'un moyen de supprimer le premier caractère d'une chaîne qui est un espace. Je recherche une méthode ou même une extension pour le type String que je peux utiliser pour découper un caractère d'une chaîne.

Pour supprimer les espaces de début et de fin:

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

Swift 3 / Swift 4:

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

La méthode correcte lorsque vous souhaitez supprimer toutes sortes d'espaces blancs (en fonction de cette réponse SO ) est:

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

ÉDITER

Cette réponse a été publiée lorsque la question portait sur la suppression de tous les espaces, la question a été modifiée pour ne mentionner que les espaces de tête. Si vous souhaitez uniquement supprimer les espaces de début, utilisez ce qui suit:

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

Cette extension de chaîne supprime tous les espaces d'une chaîne, pas seulement les espaces de fin ...

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

Exemple:

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

Swift 3

Vous pouvez simplement utiliser cette méthode pour supprimer tous les espaces normaux dans une chaîne (ne prend pas en compte tous les types d'espaces):

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

Le résultat sera:

HelloWorld!

Vous pouvez également utiliser regex.

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

Pour Swift 3.0+, voyez les autres réponses. C'est maintenant une réponse héritée pour Swift 2.x

Comme indiqué ci-dessus, puisque vous êtes intéressé par la suppression du premier caractère, la méthode d'instance .stringByTrimmingCharactersInSet () fonctionnera bien:

myString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

Vous pouvez également créer vos propres jeux de caractères pour couper les limites de vos chaînes, par exemple:

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

Il existe également une méthode d'instance intégrée pour traiter la suppression ou le remplacement de sous-chaînes appelée stringByReplacingOccurrencesOfString (target: String, replacement: String) . Il peut supprimer des espaces ou tout autre modèle qui se produit n'importe où dans votre chaîne

Vous pouvez spécifier des options et des plages, mais vous n'avez pas besoin de:

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

C'est un moyen facile de supprimer ou de remplacer tout motif répétitif de caractères dans votre chaîne, et peut être enchaîné, bien qu'à chaque fois, il doit passer un autre passage à travers toute votre chaîne, ce qui diminue l'efficacité. Vous pouvez donc faire ceci:

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

... mais cela prendra deux fois plus de temps.

Documentation .stringByReplacingOccurrencesOfString () du site Apple

Le chaînage de ces méthodes d'instance String peut parfois être très pratique pour des conversions ponctuelles, par exemple si vous souhaitez convertir un blob NSData court en une chaîne hexadécimale sans espaces sur une ligne, vous pouvez le faire avec l'interpolation String intégrée de Swift et quelques ajustements et remplacement:

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

Pour 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

L'excellent cas pour utiliser l'expression régulière:

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

// thisiswrongcontainedteeext

J'utiliserais cette extension, pour être flexible et imiter la façon dont d'autres collections le font:

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 vous souhaitez supprimer des espaces à l'avant (et à l'arrière) mais pas au milieu, vous devez utiliser stringByTrimmingCharactersInSet

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

Si vous souhaitez supprimer des espaces de n'importe où dans la chaîne, vous pouvez consulter stringByReplacing ...

Swift 4, 4.2 et 5

Supprimer l'espace de l'avant et de l'extrémité uniquement

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

Supprimer les espaces de partout dans la chaîne

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

Vous pouvez également essayer ceci

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

Essayez la programmation fonctionnelle pour supprimer les espaces blancs:

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 quelqu'un supprime l'espace supplémentaire de la chaîne, par exemple = "This is the demo text remove extra space between the words."

Vous pouvez utiliser cette fonction dans 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
}

et le résultat sera

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

Salut, c'est peut-être tard mais ça vaut le coup d'essayer. Cela provient d'un fichier de terrain de jeu. Vous pouvez en faire une extension String.

Ceci est écrit dans Swift 5.3

Méthode 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éthode 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       "

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

Rognage des espaces blancs dans Swift 4

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

Encore une autre réponse, parfois la chaîne d'entrée peut contenir plus d'un espace entre les mots. Si vous avez besoin de standardiser pour n'avoir qu'un seul espace entre les mots, essayez ceci (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 !"

Pour moi, la ligne suivante permet de supprimer les espaces blancs.

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

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

Version Swift 3 de la réponse 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)
    }
}

Pour supprimer tous les espaces de la chaîne:

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