Ich brauche eine Möglichkeit, das erste Zeichen aus einer Zeichenfolge zu entfernen, die ein Leerzeichen ist. Ich suche nach einer Methode oder sogar einer Erweiterung für den String-Typ, mit der ich ein Zeichen eines Strings ausschneiden kann.

So entfernen Sie führende und nachfolgende Leerzeichen:

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

Swift 3 / Swift 4:

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

Der richtige Weg, wenn Sie alle Arten von Leerzeichen entfernen möchten (basierend auf dieser SO-Antwort ), ist:

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

BEARBEITEN

Diese Antwort wurde veröffentlicht, als es um das Entfernen aller Leerzeichen ging. Die Frage wurde bearbeitet, um nur führende Leerzeichen zu erwähnen. Wenn Sie nur führende Leerzeichen entfernen möchten, verwenden Sie Folgendes:

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

Diese String-Erweiterung entfernt alle Leerzeichen aus einem String, nicht nur nachgestellte Leerzeichen ...

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

Beispiel:

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

Swift 3

Mit dieser Methode können Sie einfach alle normalen Leerzeichen in einer Zeichenfolge entfernen (berücksichtigt nicht alle Arten von Leerzeichen):

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

Das Ergebnis wird sein:

HelloWorld!

Sie können auch Regex verwenden.

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

Für Swift 3.0+ siehe die anderen Antworten. Dies ist jetzt eine Legacy-Antwort für Swift 2.x.

Wie oben beantwortet, funktioniert die Instanzmethode .stringByTrimmingCharactersInSet () gut , da Sie das erste Zeichen entfernen möchten :

myString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())

Sie können auch eigene Zeichensätze erstellen, um die Grenzen Ihrer Zeichenfolgen zu verringern, z.

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

Es gibt auch eine integrierte Instanzmethode zum Entfernen oder Ersetzen von Teilzeichenfolgen mit dem Namen stringByReplacingOccurrencesOfString (Ziel: String, Ersetzung: String) . Es kann Leerzeichen oder andere Muster entfernen, die an einer beliebigen Stelle in Ihrer Zeichenfolge auftreten

Sie können Optionen und Bereiche angeben, müssen jedoch nicht:

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

Dies ist eine einfache Möglichkeit, sich wiederholende Zeichenmuster in Ihrer Zeichenfolge zu entfernen oder zu ersetzen. Sie kann verkettet werden, obwohl jedes Mal ein weiterer Durchlauf durch die gesamte Zeichenfolge erforderlich ist, wodurch die Effizienz verringert wird. So können Sie Folgendes tun:

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

... aber es wird doppelt so lange dauern.

.stringByReplacingOccurrencesOfString () -Dokumentation von der Apple-Site

Das Verketten dieser String-Instanzmethoden kann manchmal für einmalige Konvertierungen sehr praktisch sein. Wenn Sie beispielsweise einen kurzen NSData-Blob in einen Hex-String ohne Leerzeichen in einer Zeile konvertieren möchten, können Sie dies mit Swifts integrierter String-Interpolation und etwas Trimmen und tun Ersetzen:

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

Für schnelle 3.0

import Foundation

var str = " Hear me calling"

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

str.stringByRemovingWhitespaces  // Hearmecalling

Swift 4

Der ausgezeichnete Fall, um den regulären Ausdruck zu verwenden:

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

// thisiswrongcontainedteeext

Ich würde diese Erweiterung verwenden, um flexibel zu sein und nachzuahmen, wie andere Sammlungen dies tun:

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"

Wenn Sie Leerzeichen von vorne (und hinten), aber nicht von der Mitte entfernen möchten, sollten Sie verwenden stringByTrimmingCharactersInSet

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

Wenn Sie Leerzeichen an einer beliebigen Stelle in der Zeichenfolge entfernen möchten, sollten Sie sich stringByReplacing ...

Swift 4, 4.2 und 5

Entfernen Sie nur Platz von vorne und von Ende

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

Entfernen Sie Leerzeichen an jeder Stelle in der Zeichenfolge

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

Sie können dies auch versuchen

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

Versuchen Sie eine funktionale Programmierung, um Leerzeichen zu entfernen:

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

Wenn jemand zusätzlichen Platz aus der Zeichenfolge entfernt, z. B. = "This is the demo text remove extra space between the words."

Sie können diese Funktion in Swift 4 verwenden.

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
}

und Ergebnis wird sein

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

Hallo, das könnte spät sein, aber einen Versuch wert. Dies ist aus einer Spielplatzdatei. Sie können es zu einer String-Erweiterung machen.

Dies ist in Swift 5.3 geschrieben

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

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

Swift 3 Version

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

Leerzeichen in Swift 4 kürzen

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

Noch eine Antwort: Manchmal kann die Eingabezeichenfolge mehr als ein Leerzeichen zwischen Wörtern enthalten. Wenn Sie standardisieren müssen, um nur 1 Leerzeichen zwischen den Wörtern zu haben, versuchen Sie dies (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 !"

In der folgenden Zeile wurde für mich Leerzeichen entfernt.

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

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

Swift 3-Version der Antwort von 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)
    }
}

So entfernen Sie alle Leerzeichen aus der Zeichenfolge:

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