'var'-Parameter sind veraltet und werden in Swift 3 entfernt

Okay, ich aktualisiere Xcode einfach auf 7.3 und erhalte jetzt diese Warnung:

'var'-Parameter sind veraltet und werden in Swift 3 entfernt

So beheben Sie das Problem, wenn ich die Variable in dieser Funktion verwenden muss:

public func getQuestionList(var language: String) -> NSArray {
    if self.data.count > 0 {
        if (language.isEmpty) {
            language = "NL"
        }
        return self.data.objectForKey("questionList" + language) as! NSArray
    }

    return NSArray()
}

Haben Sie versucht, eine neue Variable zuzuweisen?

public func getQuestionList(language: String) -> NSArray {
    var lang = language
    if self.data.count > 0 {
        if (lang.isEmpty) {
            lang = "NL"
        }
        return self.data.objectForKey("questionList" + lang) as! NSArray
    }

    return NSArray()
}

Die Diskussion über das Entfernen von Var aus einem Funktionsparameter ist in dieser Übermittlung auf GitHub: Remove Var Parameters vollständig dokumentiert

In diesem Dokument werden Sie feststellen, dass Benutzer varParameter häufig mit inoutParametern verwechseln . Ein varParameter bedeutet einfach, dass der Parameter im Kontext der Funktion veränderbar ist, während mit einem inoutParameter der Wert des Parameters am Rückkehrpunkt aus der Funktion in den Kontext des Aufrufers kopiert wird.

Der richtige Weg, um dieses Problem zu lösen, besteht darin, varaus dem Parameter zu entfernen und eine lokale varVariable einzuführen . Kopieren Sie oben in der Routine den Wert des Parameters in diese Variable.

Fügen Sie einfach diese eine Zeile am Anfang der Funktion hinzu:

var language = language

und der Rest Ihres Codes kann wie folgt unverändert bleiben:

public func getQuestionList(language: String) -> NSArray {
    var language = language
    if self.data.count > 0 {
        if (language.isEmpty) {
            language = "NL"
        }
        return self.data.objectForKey("questionList" + language) as! NSArray
    }

    return NSArray()
}

Viele Leute schlagen einen inoutParameter vor, aber dafür sind sie wirklich nicht ausgelegt. Außerdem ist es nicht möglich, die Funktion mit einer letKonstanten oder einem String-Literal aufzurufen . Warum fügen Sie der Funktionssignatur nicht einfach den Standardwert hinzu?

public func getQuestionList(language language: String = "NL") -> NSArray {
    if data.count > 0 {
        return data.objectForKey("questionList" + language) as! NSArray
    } else {
        return NSArray()
    }
}

Stellen Sie nur sicher, dass Sie nicht getQuestionListmit der leeren Zeichenfolge aufrufen, falls Sie die Standardsprache verwenden möchten, sondern lassen Sie den Parameter weg:

let list = getQuestionList() // uses the default "NL" language

Swift 4

public func getQuestionList(language: inout String) -> NSArray {
    if self.data.count > 0 {
        if (language.isEmpty) {
            language = "NL"
        }
        return self.data.objectForKey("questionList" + language) as! NSArray
    }

    return NSArray()
}

getQuestionList(language: &someString)

In einigen Fällen, wie ich erfahren habe (bei komplexeren Setups mit Arrays), funktioniert das Erstellen einer neuen Eigenschaft innerhalb der Methode und das Mutieren dieser Eigenschaft möglicherweise nicht immer. Ganz zu schweigen davon, dass Sie die Methode überladen, anstatt einfach inoutan einen Parameter und &dessen Argument anzuhängen, wofür diese Syntax erstellt wurde.

public func getQuestionList(language: inout String) -> NSArray {
if self.data.count > 0 {
    if (language.isEmpty) {
        language = "NL"
    }
    return self.data.objectForKey("questionList" + language) as! NSArray
}

return NSArray()

}}

Ich denke, die Antworten von @Harris und @garanda sind der beste Ansatz.

In Ihrem Fall ist keine Var erforderlich. Sie können Folgendes tun:

public func getQuestionList(language: String) -> NSArray {
    if self.data.count > 0 {
        return self.data.objectForKey("questionList" + (language.isEmpty ? "NL" : language)) as! NSArray
    }
    return NSArray()
}

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html

In-Out-Parameter

Funktionsparameter sind standardmäßig Konstanten. Der Versuch, den Wert eines Funktionsparameters aus dem Hauptteil dieser Funktion heraus zu ändern, führt zu einem Fehler bei der Kompilierung. Dies bedeutet, dass Sie den Wert eines Parameters nicht versehentlich ändern können. Wenn eine Funktion den Wert eines Parameters ändern soll und diese Änderungen nach Beendigung des Funktionsaufrufs beibehalten werden sollen, definieren Sie diesen Parameter stattdessen als In-Out-Parameter.

Sie schreiben einen In-Out-Parameter, indem Sie das Schlüsselwort inout direkt vor dem Typ eines Parameters platzieren. Ein In-Out-Parameter hat einen Wert, der an die Funktion übergeben, von der Funktion geändert und an die Funktion zurückgegeben wird, um den ursprünglichen Wert zu ersetzen. Eine ausführliche Beschreibung des Verhaltens von In-Out-Parametern und der damit verbundenen Compiler-Optimierungen finden Sie unter In-Out-Parameter.

Sie können nur eine Variable als Argument für einen In-Out-Parameter übergeben. Sie können keine Konstante oder einen Literalwert als Argument übergeben, da Konstanten und Literale nicht geändert werden können. Sie setzen ein kaufmännisches Und (&) direkt vor den Namen einer Variablen, wenn Sie es als Argument an einen In-Out-Parameter übergeben, um anzuzeigen, dass es von der Funktion geändert werden kann.

HINWEIS

In-Out-Parameter dürfen keine Standardwerte haben, und variable Parameter können nicht als Inout markiert werden.

Hier ist ein Beispiel für eine Funktion namens swapTwoInts ( : :), die zwei In-Out-Integer-Parameter mit den Namen a und b enthält:

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

Die Funktion swapTwoInts ( : :) tauscht einfach den Wert von b in a und den Wert von a in b. Die Funktion führt diesen Austausch durch, indem sie den Wert von a in einer temporären Konstante namens temporalA speichert, a den Wert von b zuweist und dann b temporärA zuweist.

Sie können die Funktion swapTwoInts ( : :) mit zwei Variablen vom Typ Int aufrufen , um deren Werte auszutauschen . Beachten Sie, dass den Namen von someInt und anotherInt ein kaufmännisches Und vorangestellt wird, wenn sie an die Funktion swapTwoInts ( : :) übergeben werden:

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// Prints "someInt is now 107, and anotherInt is now 3"

Das obige Beispiel zeigt, dass die ursprünglichen Werte von someInt und anotherInt durch die swapTwoInts ( : :) , obwohl sie ursprünglich außerhalb der Funktion definiert wurden.

HINWEIS

In-Out-Parameter sind nicht dasselbe wie die Rückgabe eines Werts von einer Funktion. Das obige Beispiel für swapTwoInts definiert keinen Rückgabetyp oder einen Wert, ändert jedoch die Werte von someInt und anotherInt. In-Out-Parameter sind eine alternative Möglichkeit für eine Funktion, eine Wirkung außerhalb des Bereichs ihres Funktionskörpers zu erzielen.

Hier ist eine andere Idee. Mein Anwendungsfall bestand darin, ein String-Array zum Anhängen herumzugeben, für das das Array veränderlich übergeben werden muss. Ich wollte auch dafür keinen Staat in meiner Klasse haben. Also habe ich eine Klasse erstellt, die das Array enthält, und diese übergeben. Abhängig von Ihrem Anwendungsfall mag es albern erscheinen, eine Klasse zu haben, die nur diese eine Variable enthält.

private class StringBuilder {
    var buffer: [String] = []

    func append(_ str: String) {
        buffer.append(str)
    }

    func toString() -> String {
        return buffer.joined()
    }
}

Ich verwende nur appendund joinedMethoden für das Array, so dass es einfach war, den Typ mit minimalen anderen Änderungen an meinem Code zu ändern.

Einige Anwendungsbeispiele:

private func writeMap(map: LevelMap, url: URL) -> Bool {
    let buffer = StringBuilder()

    if !writeHeader(map: map, buffer: buffer) {
        return false
    }
    if !writeFloors(map: map, buffer: buffer) {
        return false
    }

    let content = buffer.toString()
    do {
        try content.write(to: url, atomically: true, encoding: .utf8)
        return true
    } catch {}
    return false
}

private func writeHeader(map: LevelMap, buffer: StringBuilder) -> Bool {
    buffer.append("something here ...\n")
    return true
}