Ho bisogno di un modo per rimuovere il primo carattere da una stringa che è uno spazio. Sto cercando un metodo o anche un'estensione per il tipo String che posso usare per ritagliare un carattere di una stringa.

Per rimuovere spazi bianchi iniziali e finali:

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

Swift 3 / Swift 4:

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

Il modo corretto quando si desidera rimuovere tutti i tipi di spazi bianchi (in base a questa risposta 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()
    }
}

MODIFICARE

Questa risposta è stata pubblicata quando la domanda riguardava la rimozione di tutti gli spazi bianchi, la domanda è stata modificata per menzionare solo i principali spazi bianchi. Se desideri rimuovere solo gli spazi bianchi principali, utilizza quanto segue:

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

Questa estensione String rimuove tutto lo spazio bianco da una stringa, non solo lo spazio bianco finale ...

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

Esempio:

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

Swift 3

Puoi semplicemente usare questo metodo per rimuovere tutti gli spazi normali in una stringa (non considera tutti i tipi di spazi bianchi):

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

Il risultato sarà:

HelloWorld!

Puoi anche usare regex.

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

Per Swift 3.0+ vedi le altre risposte. Questa è ora una risposta legacy per Swift 2.x

Come spiegato sopra, poiché sei interessato a rimuovere il primo carattere, il metodo di istanza .stringByTrimmingCharactersInSet () funzionerà bene:

myString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

Puoi anche creare i tuoi set di caratteri per tagliare i confini delle tue stringhe, ad esempio:

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

Esiste anche un metodo di istanza incorporato per gestire la rimozione o la sostituzione di sottostringhe chiamato stringByReplacingOccurrencesOfString (target: String, sostituzione: String) . Può rimuovere spazi o altri schemi che si verificano in qualsiasi punto della stringa

È possibile specificare opzioni e intervalli, ma non è necessario:

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

Questo è un modo semplice per rimuovere o sostituire qualsiasi motivo ripetuto di caratteri nella stringa e può essere incatenato, anche se ogni volta deve passare un altro passaggio attraverso l'intera stringa, diminuendo l'efficienza. Quindi puoi farlo:

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

... ma ci vorrà il doppio del tempo.

.stringByReplacingOccurrencesOfString () documentazione dal sito Apple

Concatenare questi metodi di istanza String a volte può essere molto conveniente per conversioni una tantum, ad esempio se si desidera convertire un blob NSData breve in una stringa esadecimale senza spazi in una riga, è possibile farlo con l'interpolazione String incorporata di Swift e alcuni ritagli e sostituzione:

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

Per 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

Il caso eccellente per usare il regex:

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

// thisiswrongcontainedteeext

Userei questa estensione, per essere flessibile e imitare il modo in cui lo fanno altre collezioni:

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 si desidera rimuovere gli spazi dalla parte anteriore (e posteriore) ma non dal centro, è necessario utilizzare stringByTrimmingCharactersInSet

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

Se vuoi rimuovere spazi da qualsiasi punto della stringa, allora potresti voler guardare stringByReplacing ...

Swift 4, 4.2 e 5

Rimuovere lo spazio solo dalla parte anteriore e finale

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

Rimuovi gli spazi da ogni punto della stringa

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

Puoi provare anche questo

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

Prova la programmazione funzionale per rimuovere gli spazi bianchi:

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 qualcuno rimuove lo spazio aggiuntivo dalla stringa, ad es. = "This is the demo text remove extra space between the words."

È possibile utilizzare questa funzione in 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 il risultato sarà

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

Salve, potrebbe essere tardi, ma vale la pena provare. Questo proviene da un file del parco giochi. Puoi renderlo un'estensione String.

Questo è scritto in Swift 5.3

Metodo 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       "

Metodo 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       "

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

Tagliare gli spazi bianchi in Swift 4

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

Ancora un'altra risposta, a volte la stringa di input può contenere più di uno spazio tra le parole. Se devi standardizzare per avere solo 1 spazio tra le parole, prova questo (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 !"

Per me, la seguente riga ha usato per rimuovere lo spazio bianco.

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

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

Versione Swift 3 della risposta di 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)
    }
}

Per rimuovere tutti gli spazi dalla stringa:

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