In C / C ++ / Objective C können Sie ein Makro mithilfe von Compiler-Präprozessoren definieren. Darüber hinaus können Sie einige Codeteile mithilfe von Compiler-Präprozessoren ein- / ausschließen.

#ifdef DEBUG
    // Debug-only code
#endif

Gibt es eine ähnliche Lösung in Swift?

Ja, du kannst es schaffen.

In Swift können Sie weiterhin die Präprozessor-Makros "# if / # else / # endif" (obwohl eingeschränkter) gemäß Apple-Dokumenten verwenden . Hier ist ein Beispiel:

#if DEBUG
    let a = 2
#else
    let a = 3
#endif

Jetzt müssen Sie das Symbol "DEBUG" jedoch an einer anderen Stelle setzen. Stellen Sie es im Abschnitt "Swift Compiler - Benutzerdefinierte Flags" in der Zeile "Andere Swift Flags" ein. Sie fügen dem -D DEBUGEintrag das DEBUG-Symbol hinzu .

Wie üblich können Sie im Debug oder im Release einen anderen Wert festlegen.

Ich habe es in echtem Code getestet und es funktioniert; es scheint jedoch auf einem Spielplatz nicht erkannt zu werden.

Sie können meinen ursprünglichen Beitrag hier lesen .

WICHTIGER HINWEIS: -DDEBUG=1 funktioniert nicht. Funktioniert nur -D DEBUG. Der Compiler ignoriert anscheinend ein Flag mit einem bestimmten Wert.

Wie in Apple Docs angegeben

Der Swift-Compiler enthält keinen Präprozessor. Stattdessen werden Attribute zur Kompilierungszeit, Build-Konfigurationen und Sprachfunktionen verwendet, um dieselbe Funktionalität zu erzielen. Aus diesem Grund werden Präprozessoranweisungen nicht in Swift importiert.

Ich habe es geschafft, mit benutzerdefinierten Build-Konfigurationen das zu erreichen, was ich wollte:

1. Gehen Sie zu Ihrem Projekt / wählen Sie Ihr Ziel / Build-Einstellungen / suchen Sie nach benutzerdefinierten Flags
2. Setzen Sie für Ihr ausgewähltes Ziel Ihr benutzerdefiniertes Flag mit dem Präfix -D (ohne Leerzeichen) für Debug und Release
3. Führen Sie die obigen Schritte für jedes Ziel aus, das Sie haben

So überprüfen Sie das Ziel:

#if BANANA
    print("We have a banana")
#elseif MELONA
    print("Melona")
#else
    print("Kiwi")
#endif

Getestet mit Swift 2.2

In vielen Situationen benötigen Sie keine bedingte Kompilierung . Sie brauchen nur bedingtes Verhalten , das Sie ein- und ausschalten können. Dafür können Sie eine Umgebungsvariable verwenden. Dies hat den großen Vorteil, dass Sie nicht neu kompilieren müssen.

Sie können die Umgebungsvariable im Schema-Editor festlegen und einfach ein- oder ausschalten:

Sie können die Umgebungsvariable mit NSProcessInfo abrufen:

    let dic = NSProcessInfo.processInfo().environment
    if dic["TRIPLE"] != nil {
        // ... do secret stuff here ...
    }

Hier ist ein Beispiel aus dem wirklichen Leben. Meine App läuft nur auf dem Gerät, da sie die Musikbibliothek verwendet, die im Simulator nicht vorhanden ist. Wie mache ich dann Screenshots im Simulator für Geräte, die ich nicht besitze? Ohne diese Screenshots kann ich nicht an den AppStore senden.

Ich brauche gefälschte Daten und eine andere Art, sie zu verarbeiten . Ich habe zwei Umgebungsvariablen: eine, die die App beim Einschalten anweist, die gefälschten Daten aus den realen Daten zu generieren, während sie auf meinem Gerät ausgeführt wird; die andere, die beim Einschalten die gefälschten Daten (nicht die fehlende Musikbibliothek) verwendet, während sie auf dem Simulator ausgeführt wird. Das Ein- und Ausschalten jedes dieser speziellen Modi ist dank der Kontrollkästchen für Umgebungsvariablen im Schema-Editor einfach. Und der Bonus ist, dass ich sie nicht versehentlich in meinem App Store-Build verwenden kann, da die Archivierung keine Umgebungsvariablen enthält.

ifdefMit Xcode 8 wurde eine wesentliche Änderung des Ersatzes vorgenommen, dh die Verwendung der Bedingungen für die aktive Kompilierung .

Siehe Erstellen und Verknüpfen in Xcode 8 Versionshinweis .

Neue Build-Einstellungen

Neue Einstellung: SWIFT_ACTIVE_COMPILATION_CONDITIONS

“Active Compilation Conditions” is a new build setting for passing conditional compilation flags to the Swift compiler.

Zuvor mussten wir Ihre bedingten Kompilierungsflags unter OTHER_SWIFT_FLAGS deklarieren und dabei daran denken, der Einstellung "-D" voranzustellen. Zum bedingten Kompilieren mit einem MYFLAG-Wert:

#if MYFLAG1
    // stuff 1
#elseif MYFLAG2
    // stuff 2
#else
    // stuff 3
#endif

Der Wert, der der Einstellung hinzugefügt werden soll -DMYFLAG

Jetzt müssen wir nur noch den Wert MYFLAG an die neue Einstellung übergeben. Zeit, all diese bedingten Kompilierungswerte zu verschieben!

Weitere Funktionen für schnelle Build-Einstellungen in Xcode 8 finden Sie unter dem folgenden Link: http://www.miqu.me/blog/2016/07/31/xcode-8-new-build-settings-and-analyzer-improvements/

Ab Swift 4.1 können Sie die integrierten Funktionen verwenden, wenn Sie nur prüfen müssen, ob der Code mit Debug- oder Release-Konfiguration erstellt wurde:

• _isDebugAssertConfiguration()(wahr, wenn die Optimierung auf eingestellt ist -Onone)
• _isReleaseAssertConfiguration()(wahr, wenn die Optimierung auf eingestellt ist -O) (nicht verfügbar bei Swift 3+)
• _isFastAssertConfiguration()(wahr, wenn die Optimierung auf eingestellt ist -Ounchecked)

z.B

func obtain() -> AbstractThing {
    if _isDebugAssertConfiguration() {
        return DecoratedThingWithDebugInformation(Thing())
    } else {
        return Thing()
    }
}

Im Vergleich zu Präprozessor-Makros

• ✓ Sie müssen kein benutzerdefiniertes -D DEBUGFlag definieren , um es zu verwenden
• ~ Es wird tatsächlich anhand der Optimierungseinstellungen definiert, nicht anhand der Xcode-Build-Konfiguration

• ✗ Undokumentiert, was bedeutet, dass die Funktion bei jedem Update entfernt werden kann (sie sollte jedoch AppStore-sicher sein, da das Optimierungsprogramm diese in Konstanten umwandelt).

  • Diese wurden einst entfernt , aber aufgrund fehlender @testableAttribute wieder an die Öffentlichkeit gebracht. Das Schicksal ist für den zukünftigen Swift ungewiss.

• ✗ Wenn Sie in if / else verwenden, wird immer die Warnung "Wird nie ausgeführt" generiert.

Xcode 8 und höher

Verwenden Sie die Einstellung Active Compilation Conditions unter Build Settings / Swift Compiler - Custom Flags .

• Dies ist die neue Build-Einstellung zum Übergeben von bedingten Kompilierungsflags an den Swift-Compiler.
• Einfache Add - Flags wie folgt aus : ALPHA, BETAusw.

Überprüfen Sie es dann mit folgenden Kompilierungsbedingungen :

#if ALPHA
    //
#elseif BETA
    //
#else
    //
#endif

Tipp: Sie können auch #if !ALPHAetc. verwenden

Es gibt keinen Swift-Präprozessor. (Zum einen beeinträchtigt die willkürliche Codesubstitution die Typ- und Speichersicherheit.)

Swift enthält jedoch Konfigurationsoptionen für die Build-Zeit, sodass Sie Code für bestimmte Plattformen oder Build-Stile oder als Reaktion auf Flags, die Sie mit -DCompiler-Argumenten definieren, bedingt einschließen können . Im Gegensatz zu C muss ein bedingt kompilierter Abschnitt Ihres Codes jedoch syntaktisch vollständig sein. Es gibt einen Abschnitt darüber in Verwenden von Swift With Cocoa und Objective-C .

Zum Beispiel:

#if os(iOS)
    let color = UIColor.redColor()
#else
    let color = NSColor.redColor()
#endif

Meine zwei Cent für Xcode 8:

a) Ein benutzerdefiniertes Flag mit dem -DPräfix funktioniert einwandfrei, aber ...

b) Einfachere Verwendung:

In Xcode 8 gibt es einen neuen Abschnitt: "Active Compilation Conditions", bereits mit zwei Zeilen, zum Debuggen und Freigeben.

Fügen Sie einfach Ihre Definition OHNE hinzu -D.

isDebug-Konstante basierend auf aktiven Kompilierungsbedingungen

Eine andere, vielleicht einfachere Lösung, die immer noch zu einem Booleschen Wert führt, den Sie an Funktionen übergeben können, ohne die #ifBedingungen in Ihrer Codebasis zu verbessern , besteht darin, DEBUGals eines Ihrer Projekterstellungsziele zu definieren Active Compilation Conditionsund Folgendes einzuschließen (ich definiere es als globale Konstante):

#if DEBUG
    let isDebug = true
#else
    let isDebug = false
#endif

isDebug-Konstante basierend auf den Einstellungen für die Compileroptimierung

Dieses Konzept baut auf der Antwort von kennytm auf

Der Hauptvorteil beim Vergleich mit Kennytms besteht darin, dass dies nicht auf privaten oder nicht dokumentierten Methoden beruht.

In Swift 4 :

let isDebug: Bool = {
    var isDebug = false
    // function with a side effect and Bool return value that we can pass into assert()
    func set(debug: Bool) -> Bool {
        isDebug = debug
        return isDebug
    }
    // assert:
    // "Condition is only evaluated in playgrounds and -Onone builds."
    // so isDebug is never changed to true in Release builds
    assert(set(debug: true))
    return isDebug
}()

Im Vergleich mit Präprozessormakros und Antwort des kennytm ,

• ✓ Sie müssen kein benutzerdefiniertes -D DEBUGFlag definieren , um es zu verwenden
• ~ Es wird tatsächlich anhand der Optimierungseinstellungen definiert, nicht anhand der Xcode-Build-Konfiguration

• ✓ Dokumentiert , was bedeutet, dass die Funktion normalen API-Freigabe- / Verfallsmustern folgt.

• ✓ Wenn Sie in if / else verwenden, wird keine Warnung "Wird niemals ausgeführt" generiert.

Moignans Antwort hier funktioniert gut. Hier ist eine weitere Information, falls es hilft,

#if DEBUG
    let a = 2
#else
    let a = 3
#endif

Sie können die Makros wie folgt negieren.

#if !RELEASE
    let a = 2
#else
    let a = 3
#endif

In Swift-Projekten, die mit Xcode Version 9.4.1 erstellt wurden, ist Swift 4.1

#if DEBUG
#endif

funktioniert standardmäßig, da in den Präprozessor-Makros DEBUG = 1 bereits von Xcode festgelegt wurde.

Sie können also #if DEBUG "out of box" verwenden.

Übrigens ist in Apples Buch The Swift Programming Language 4.1 (Abschnitt Compiler Control Statements) beschrieben, wie die Bedingungskompilierungsblöcke im Allgemeinen verwendet werden und wie die Kompilierungsflags geschrieben werden und was das Gegenstück zu den C-Makros in Swift ist ein anderes Apple-Buch Verwenden von Swift mit Kakao und Ziel C (im Abschnitt Präprozessor-Richtlinien)

Wir hoffen, dass Apple in Zukunft die detaillierteren Inhalte und die Indizes für ihre Bücher schreiben wird.

XCODE 9 UND OBEN

#if DEVELOP
    //
#elseif PRODCTN
    //
#else
    //
#endif

Nach dem Festlegen DEBUG=1Ihrer GCC_PREPROCESSOR_DEFINITIONSBuild-Einstellungen bevorzuge ich die Verwendung einer Funktion, um diese Aufrufe zu tätigen:

func executeInProduction(_ block: () -> Void)
{
    #if !DEBUG
        block()
    #endif
}

Und dann fügen Sie in diese Funktion einfach jeden Block ein, den ich in Debug-Builds weglassen möchte:

executeInProduction {
    Fabric.with([Crashlytics.self]) // Compiler checks this line even in Debug
}

Der Vorteil gegenüber:

#if !DEBUG
    Fabric.with([Crashlytics.self]) // This is not checked, may not compile in non-Debug builds
#endif

Ist das, dass der Compiler die Syntax meines Codes überprüft, so bin ich sicher, dass seine Syntax korrekt ist und erstellt.

! [In Xcode 8 und höher gehen Sie zu Build-Einstellung -> Suche nach benutzerdefinierten Flags] 1

In Code

 #if Live
    print("Live")
    #else
    print("debug")
    #endif

func inDebugBuilds(_ code: () -> Void) {
    assert({ code(); return true }())
}

Quelle

Dies baut auf Jon Willis ' Antwort auf, die auf Assert beruht und nur in Debug-Kompilierungen ausgeführt wird:

func Log(_ str: String) { 
    assert(DebugLog(str)) 
}
func DebugLog(_ str: String) -> Bool { 
    print(str) 
    return true
}

Mein Anwendungsfall ist das Protokollieren von Druckanweisungen. Hier ist ein Benchmark für die Release-Version auf dem iPhone X:

let iterations = 100_000_000
let time1 = CFAbsoluteTimeGetCurrent()
for i in 0 ..< iterations {
    Log ("⧉ unarchiveArray:\(fileName) memoryTime:\(memoryTime) count:\(array.count)")
}
var time2 = CFAbsoluteTimeGetCurrent()
print ("Log: \(time2-time1)" )

Drucke:

Log: 0.0

Es sieht so aus, als würde Swift 4 den Funktionsaufruf vollständig eliminieren.