Entfernen Sie println () für die Release-Version iOS Swift

Ich möchte alle println()Aufrufe in meinem Swift-Code global ignorieren, wenn ich mich nicht in einem Debug-Build befinde. Ich kann keine robuste Schritt-für-Schritt-Anleitung dafür finden und würde mich über eine Anleitung freuen. Gibt es eine Möglichkeit, dies global zu tun, oder muss ich alle println()mit #IF DEBUG/#ENDIFAussagen umgeben?

Der einfachste Weg ist, Ihre eigene globale Funktion vor die von Swift zu stellen println:

func println(object: Any) {
    Swift.println(object)
}

Wenn es Zeit ist, die Protokollierung zu beenden, kommentieren Sie einfach den Hauptteil dieser Funktion aus:

func println(object: Any) {
    // Swift.println(object)
}

Oder Sie können es automatisch machen, indem Sie eine Bedingung verwenden:

func println(object: Any) {
    #if DEBUG
        Swift.println(object)
    #endif
}

BEARBEITEN In Swift 2.0 printlnwird in geändert print. Leider hat es jetzt einen variadischen ersten Parameter; Das ist cool, aber es bedeutet, dass Sie es nicht einfach überschreiben können, da Swift keinen "splat" -Operator hat, sodass Sie keine Variable im Code übergeben können (sie kann nur wörtlich erstellt werden). Sie können jedoch eine reduzierte Version erstellen, die funktioniert, wenn Sie wie gewöhnlich nur einen Wert drucken:

func print(items: Any..., separator: String = " ", terminator: String = "\n") {
    Swift.print(items[0], separator:separator, terminator: terminator)
}

In Swift 3 müssen Sie die externe Bezeichnung des ersten Parameters unterdrücken:

func print(_ items: Any..., separator: String = " ", terminator: String = "\n") {
    Swift.print(items[0], separator:separator, terminator: terminator)
}

Aktualisiert für Swift 4.x:

Mit Swift 2.0 / 3.0 und Xcode 7/8, die jetzt nicht mehr in der Beta sind, wurden einige Änderungen an der Deaktivierung der Druckfunktion in Release-Builds vorgenommen.

Es gibt einige wichtige Punkte, die von @matt und @Nate Birkholz oben erwähnt wurden und die noch gültig sind.

1. Die println()Funktion wurde ersetzt durchprint()

2. Um das #if DEBUG Makro zu verwenden, müssen Sie den "Swift Compiler - Benutzerdefinierte Flags - Andere Flags" definieren, um den Wert zu enthalten-D DEBUG

3. Ich würde empfehlen, das zu überschreiben Swift.print() Funktion im globalen Bereich zu damit Sie die print()Funktion wie gewohnt in Ihrem Code verwenden können, aber die Ausgabe für Nicht-Debug-Builds wird entfernt. Hier ist eine Funktionssignatur, die Sie im globalen Bereich hinzufügen können, um dies in Swift 2.0 / 3.0 zu tun:

   func print(items: Any..., separator: String = " ", terminator: String = "\n") {
   
       #if DEBUG
   
       var idx = items.startIndex
       let endIdx = items.endIndex
   
       repeat {
           Swift.print(items[idx], separator: separator, terminator: idx == (endIdx - 1) ? terminator : separator)
           idx += 1
       }
       while idx < endIdx
   
       #endif
   }

Hinweis: Wir haben das Standardtrennzeichen hier als Leerzeichen und das Standardterminator als Zeilenumbruch festgelegt. Sie können dies in Ihrem Projekt anders konfigurieren, wenn Sie möchten.

Hoffe das hilft.

Aktualisieren:

Es ist normalerweise vorzuziehen, diese Funktion in den globalen Bereich zu stellen, damit sie vor Swifts printFunktion steht. Ich finde, dass der beste Weg, dies zu organisieren, darin besteht, Ihrem Projekt eine Dienstprogrammdatei (wie DebugOptions.Swift) hinzuzufügen, in der Sie diese Funktion im globalen Bereich platzieren können.

Ab Swift 3 ist der ++Bediener veraltet. Ich habe das obige Snippet aktualisiert, um diese Änderung widerzuspiegeln.

Das Problem bei all diesen Ansätzen, einschließlich meiner, besteht darin, dass sie den Aufwand für die Bewertung der printArgumente nicht verringern . Egal welche von ihnen Sie verwenden, dies wird teuer:

print(myExpensiveFunction())

Die einzig vernünftige Lösung besteht darin, den eigentlichen Druckaufruf in eine bedingte Kompilierung zu verpacken (nehmen wir an, dass dies DEBUGnur für Debug-Builds definiert ist):

#if DEBUG
print(myExpensiveFunction())
#endif

Das und nur das verhindert, dass myExpensiveFunctiones in einem Release-Build aufgerufen wird.

Sie können die Auswertung jedoch mithilfe der automatischen Schließung um eine Ebene zurückschieben . So können Sie meine Lösung (dies ist Swift 3) folgendermaßen umschreiben:

func print(_ item: @autoclosure () -> Any, separator: String = " ", terminator: String = "\n") {
    #if DEBUG
    Swift.print(item(), separator: separator, terminator: terminator)
    #endif
}

Dies löst das Problem nur für den Fall, dass Sie nur eine Sache drucken, was normalerweise zutrifft. Das liegt daran item(), dass im Release-Modus nicht aufgerufen wird. print(myExpensiveFunction())Dies ist nicht mehr teuer, da der Anruf ohne Auswertung in einen Abschluss eingeschlossen wird und im Freigabemodus überhaupt nicht ausgewertet wird.

Wie bereits erwähnt, bin ich Student und brauche Dinge, die etwas klarer definiert sind, um mitzumachen. Nach vielen Recherchen musste ich folgende Reihenfolge einhalten:

Klicken Sie oben im Datei-Navigator links im Xcode-Projektfenster auf den Projektnamen. Dies ist eine Zeile mit dem Namen des Projekts, der Anzahl der Build-Ziele und der iOS SDK-Version.

Wählen Sie die Registerkarte Build Settings und scrollen Sie zum Abschnitt " Swift Compiler - Custom Flags " unten. Klicken Sie auf den Abwärtspfeil neben Andere Flags , um den Abschnitt zu erweitern.

Klicken Sie auf die Debug- Zeile, um sie auszuwählen. Platzieren Sie den Mauszeiger über der rechten Seite der Linie und doppelklicken Sie. Eine Listenansicht wird angezeigt. Klicken Sie unten links in der Listenansicht auf die Schaltfläche + , um einen Wert hinzuzufügen. Ein Textfeld wird aktiv.

Geben Sie im Textfeld den Text ein -D DEBUGund drücken Sie die Eingabetaste , um die Zeile festzuschreiben.

Fügen Sie Ihrem Projekt eine neue Swift-Datei hinzu. Sie möchten eine benutzerdefinierte Klasse für die Datei erstellen. Geben Sie daher Text wie folgt ein:

class Log {

  var intFor : Int

  init() {
    intFor = 42
   }

  func DLog(message: String, function: String = __FUNCTION__) {
    #if DEBUG
      println("\(function): \(message)")
    #endif
  }
}

Ich hatte Probleme, die Klasse heute von Xcode zu akzeptieren, daher ist der Init möglicherweise etwas schwerer als nötig.

Jetzt müssen Sie Ihre benutzerdefinierte Klasse in jeder Klasse referenzieren, in der Sie die neue benutzerdefinierte Funktion anstelle von println()Add this als Eigenschaft in jeder anwendbaren Klasse verwenden möchten:

   let logFor = Log()

Jetzt können Sie alle Instanzen von println()durch ersetzenlogFor.DLog() . Die Ausgabe enthält auch den Namen der Funktion, in der die Zeile aufgerufen wurde.

Beachten Sie, dass ich innerhalb von Klassenfunktionen die Funktion nur aufrufen konnte, wenn ich eine Kopie der Funktion als Klassenfunktion in dieser Klasse erstellt habe, und dass println()die Eingabe auch etwas flexibler ist, sodass ich sie nicht in jedem Fall in verwenden konnte mein Code.

Hier ist eine Funktion, die ich benutze und die in Swift 3 perfekt funktioniert:

func gLog<T>( _ object: @autoclosure() -> T, _ file: String = #file, _ function: String = #function, _ line: Int = #line)
    {
    #if DEBUG
        let value = object()
        let stringRepresentation: String

        if let value = value as? CustomDebugStringConvertible
            {
            stringRepresentation = value.debugDescription
            }
        else if let value = value as? CustomStringConvertible
            {
            stringRepresentation = value.description
            }
        else
            {
            fatalError("gLog only works for values that conform to CustomDebugStringConvertible or CustomStringConvertible")
            }

        let fileURL = NSURL(string: file)?.lastPathComponent ?? "Unknown file"
        let queue = Thread.isMainThread ? "UI" : "BG"
    let gFormatter = DateFormatter()
    gFormatter.dateFormat = "HH:mm:ss:SSS"
        let timestamp = gFormatter.string(from: Date())

        print("✅ \(timestamp) {\(queue)} \(fileURL) > \(function)[\(line)]: " + stringRepresentation + "\n")
    #endif
    }

Hier ist ein Beispiel für die Ausgabe, die es generiert:

Erläuterung:

• Mit dem grünen Häkchen können Sie Ihre Drucknachrichten (gLog) schnell in der Konsole anzeigen, wo sie manchmal in einem Meer anderer Nachrichten verloren gehen können

• den Zeit- / Datumsstempel

• der Thread, auf dem es ausgeführt wird - in meinem Fall ist es entweder der MainThread (den ich UI nenne) oder nicht der MainThread (den ich BG nenne, für den Hintergrund-Thread)

• Der Name der Datei, in der sich die gLog-Nachricht befindet

• Die Funktion in der Datei, in der sich die gLog-Nachricht befindet

• die Zeilennummer der gLog-Nachricht

• Die eigentliche gLog-Nachricht, die Sie ausdrucken möchten

Hoffe, das ist nützlich für jemand anderen!

Swift 4.2

Der folgende Code funktioniert perfekt für mich:

func print(_ items: Any..., separator: String = " ", terminator: String = "\n") {
    #if DEBUG
    items.forEach {
        Swift.print($0, separator: separator, terminator: terminator)        
    }
    #endif
}

Diese Funktion spiegelt den Standard-Swift-Druck wider, sodass Sie ihn genauso verwenden können print("hello world")(Sie müssen weder die Trennzeichen- noch die Abschlusszeichenparameter eingeben). Durch das Drucken jedes Elements auf diese Weise werden außerdem störende Array-Klammern um die Druckanweisungen entfernt, die angezeigt werden, wenn Sie direkt itemsin das Element übergehen Swift.print().

Für jemanden, der relativ neu in Swift ist, mag man sich fragen, was zum Teufel $0 ist. Es stellt nur das erste Argument dar, das an den forEachBlock übergeben wird. Die forEachAussage könnte auch so geschrieben werden:

items.forEach { item in
    Swift.print(item, separator: separator, terminator: terminator)        
}

Wenn Sie interessiert sind, printsieht die Swift-Erklärung folgendermaßen aus :

public func print(_ items: Any..., separator: String = default, terminator: String = default)

Die Dokumente sagen auch, dass das Standardtrennzeichen ein einzelnes Leerzeichen ( " ") und das Standardterminator ein Zeilenumbruch ( "\n") ist, sodass meine obige Antwort die genaue Swift-Implementierung widerspiegelt - obwohl ich nie mehr als eine Sache drucke oder Trennzeichen / Terminatoren ändere. Aber wer weiß, vielleicht möchten Sie.

Getestet mit Swift 2.1 & Xcode 7.1.1

Es gibt eine einfache Möglichkeit, alle Druckanweisungen von Release-Versionen auszuschließen, sobald Sie wissen, dass leere Funktionen vom Swift-Compiler entfernt werden .

Randnotiz: In der Ära von Objective-C gab es einen Pre-Parser, mit dem NSLog-Anweisungen vor dem Start des Compilers entfernt werden konnten, wie in meiner Antwort hier beschrieben . Da Swift jedoch keinen Pre-Parser mehr hat, ist dieser Ansatz nicht mehr gültig.

Folgendes verwende ich heute als erweiterte und einfach konfigurierbare Protokollfunktion, ohne mich jemals darum kümmern zu müssen, sie in Release-Builds zu entfernen. Durch Setzen verschiedener Compiler-Flags können Sie auch die protokollierten Informationen nach Bedarf anpassen.

Sie können die Funktion nach Bedarf anpassen. Jeder Vorschlag zur Verbesserung ist willkommen!

// Gobal log() function
//
// note that empty functions are removed by the Swift compiler -> use #if $endif to enclose all the code inside the log()
// these log() statements therefore do not need to be removed in the release build !
//
// to enable logging
//
// Project -> Build Settings -> Swift Compiler - Custom flags -> Other Swift flags -> Debug
// add one of these 3 possible combinations :
//
//      -D kLOG_ENABLE
//      -D kLOG_ENABLE -D kLOG_DETAILS
//      -D kLOG_ENABLE -D kLOG_DETAILS -D kLOG_THREADS
//
// you can just call log() anywhere in the code, or add a message like log("hello")
//
func log(message: String = "", filePath: String = #file, line: Int = #line, function: String = #function) {
            #if kLOG_ENABLE

            #if kLOG_DETAILS

            var threadName = ""
            #if kLOG_THREADS
                threadName = NSThread.currentThread().isMainThread ? "MAIN THREAD" : (NSThread.currentThread().name ?? "UNKNOWN THREAD")
                threadName = "[" + threadName + "] "
            #endif

            let fileName = NSURL(fileURLWithPath: filePath).URLByDeletingPathExtension?.lastPathComponent ?? "???"

            var msg = ""
            if message != "" {
                msg = " - \(message)"
            }

            NSLog("-- " + threadName + fileName + "(\(line))" + " -> " + function + msg)
        #else
            NSLog(message)
        #endif
    #endif
}

Hier setzen Sie die Compiler-Flags:

Eine Beispielausgabe mit allen Flags sieht folgendermaßen aus:

   2016-01-13 23:48:38.026 FoodTracker[48735:4147607] -- [MAIN THREAD] ViewController(19) -> viewDidLoad() - hello

Der Code mit log () sieht folgendermaßen aus:

    override func viewDidLoad() { log("hello")
    super.viewDidLoad()

   // Handle the text field's user input through delegate callbacks
   nameTextField.delegate = self
}

Noch einfacher, nachdem Sie sichergestellt haben -D DEBUG, dass die OTHER_SWIFT_FLAGSDebug-Build-Einstellungen festgelegt sind:

#if !DEBUG
    func print(_ items: Any..., separator: String = " ", terminator: String = "\n") { }
#endif

XCode 8 hat einige neue Build-Einstellungen eingeführt .
Insbesondere macht einer, auf den Bezug genommen wird, Active Compilation Conditionsauf ähnliche Weise wie die Einstellungen für andere Flags .

"Active Compilation Conditions" ist eine neue Build-Einstellung zum Übergeben von Flags für bedingte Kompilierungen an den Swift-Compiler.

Gemäß XCode 8 (getestet in 8.3.2) erhalten Sie dies standardmäßig:

Ohne Konfiguration können Sie also Folgendes schreiben:

#if DEBUG
    print("⚠️ Something weird happened")
#endif

Ich empfehle Ihnen dringend, wenn Sie diesen Ansatz ausgiebig verwenden, eine Klasse / Struktur / Funktion zu erstellen, die diese Protokollierungslogik umschließt. Vielleicht möchten Sie dies weiter unten verlängern.

Varun Naharia hat bisher die bessere Lösung. Ich würde seine Antwort mit Riveras ...

1. Erstellen Sie ein -D DEBUGFlag in den Compiler-Direktiven und erstellen Sie Einstellungen.

2. Fügen Sie dann diesen Code hinzu:

   #if !DEBUG
    public func print(_ items: Any..., separator: String = " ", terminator: String = "\n") {
   }
   #endif

Dieser Code wandelt alles printzur Veröffentlichung in nichts um.

Swift 4 Xcode 10.0

Vielleicht könntest du das gebrauchen

func dPrint(_ message: @autoclosure () -> Any) {
    #if DEBUG
    print(message())
    #endif
}

Der Grund der Verwendung @autoclosure ist, dass, wenn Sie eine Funktion als Nachrichtenparameter übergeben, die Funktion nur im Debug-Modus aufgerufen wird und einen Leistungseinbruch verursacht.

Im Gegensatz zur Swift.print(_ items: Any..., separator: String = default, terminator: String = default)Funktion hat meine Lösung nur einen Parameter, da in den meisten Fällen nicht mehrere Parameter übergeben werden, da die Druckfunktion nur Informationen in der Konsole anzeigt. Wir können die Parameter einfach in String konvertieren : "\(param1)"+"\(param2)", richtig? Ich hoffe du magst meine Lösung

Sie können auch einen Haltepunkt verwenden, ihn so einstellen, dass er nach der Auswertung fortgesetzt wird, und die Drucknachricht in den Haltepunkt schreiben!

Sie könnten definieren, debug_printlnwessen Inhalt ungefähr sein würde:

#if DEBUG
  println()
#endif

Meine Lösung besteht darin, diesen Code vor dem Unterricht in AppDelegate zu verwenden

// Disable console log in live app
#if !arch(x86_64) && !arch(i386)
    public func debugPrint(items: Any..., separator: String = " ", terminator: String = "\n") {

    }
    public func print(_ items: Any..., separator: String = " ", terminator: String = "\n") {

    }
#endif

class AppDelegate: UIResponder, UIApplicationDelegate {
// App Delegate Code 

}

Für meine Lösung mache ich es einfach

import UIKit

class DLog: NSObject {

   init(title:String, log:Any) {
       #if DEBUG
           print(title, log)
       #endif

   }

}

dann, um es zu zeigen, rufen Sie einfach an

_ = DLog(title:"any title", log:Any)

Am Ende habe ich Folgendes verwendet:

#if DEBUG
func dLog(_ item: @autoclosure () -> Any, _ file: String = #file, _ function: String = #function, _ line: Int = #line) {
    print("\(Date()) [\((file as NSString).lastPathComponent):\(line) \(function)] \(item())")
}
#else
func dLog(_ item: @autoclosure () -> Any) {}
#endif

Es ist ziemlich kompakt, druckt einige nützliche Informationen (Zeitstempel, schneller Dateiname, Codezeile, Funktionsname) und zumindest in meinen Tests konnte ich beim Öffnen im Hex-Editor keine protokollierten Zeichenfolgen in der Anwendungsbinärdatei finden.

Noch einfacher: Nutzen Sie die Tatsache, dass Asserts aus Release-Builds entfernt werden und nur von dort aus den Druck aufrufen. Dadurch werden alle Protokollaufrufe entfernt (ja, sogar die Aufrufe von Log.da), da sie beim Erstellen für die Freigabe leer sind.

Ich habe aber auch gehört, dass Ausdrucke für Release-Builds entfernt werden, konnte sie aber nicht schriftlich finden. Im Moment verwende ich so etwas Logunten. Ich habe eine fleischigere Version auf GitHub mit Emojis (aus Gründen der Lesbarkeit) und Protokollthemen (aus Gründen der Konsistenz):

https://github.com/Gatada/JBits/blob/master/Project/Utility/Log.swift

public enum Log {

    /// A date formatter used to create the timestamp in the log.
    ///
    /// This formatter is only created if it is actually used, reducing the
    /// overhead to zero.
    static var formatter: DateFormatter?

    // MARK: - API

    /// Call to print message in debug area.
    ///
    /// Asserts are removed in release builds, which make
    /// the function body empty, which caused all calls to
    /// be removed as well.
    ///
    /// Result is zero overhead for release builds.
    public static func da(_ message: String) {
        assert(debugAreaPrint(message))
    }

    // MARK: - Helpers

    /// The function that actually does the printing. It returns `true` to
    /// prevent the assert from kicking in on debug builds.
    private static func debugAreaPrint(_ message: String) -> Bool {
        print("\(timestamp) - \(message)")
        return true
    }

    /// Creates a timestamp used as part of the temporary logging in the debug area.
    static private var timestamp: String {

        if formatter == nil {
            formatter = DateFormatter()
            formatter!.dateFormat = "HH:mm:ss.SSS"
        }

        let date = Date()
        return formatter!.string(from: date)
    }
}

In Code:

Log.da("This is only handled in a debug build.")

Gesehen in dem Xcode Debug - Bereich nur , wenn ein Debug - Build ausgeführt wird :

13: 36: 15.047 - Dies wird nur in einem Debug-Build behandelt.

Mein Projekt wurde in Ziel C entwickelt, aber seit dem letzten Jahr habe ich begonnen, neuen Code in Swift zusammenzuführen. In der folgenden Swift-Lösung habe ich diesen Code in die konstante Datei "Mein Swift" eingefügt:

func print(_ items: Any..., separator: String = " ", terminator: String = "\n") {
    #if DEBUG
    items.forEach {
        Swift.print($0, separator: separator, terminator: terminator)
    }
    #endif
}