In Objective-C können wir mithilfe von Makros feststellen, ob eine App für ein Gerät oder einen Simulator erstellt wird:

#if TARGET_IPHONE_SIMULATOR
    // Simulator
#else
    // Device
#endif

Dies sind Kompilierungszeitmakros, die zur Laufzeit nicht verfügbar sind.

Wie kann ich dasselbe in Swift erreichen?

Update 30/01/19

Während diese Antwort möglicherweise funktioniert, besteht die empfohlene Lösung für eine statische Überprüfung (wie von mehreren Apple-Ingenieuren geklärt) darin, ein benutzerdefiniertes Compiler-Flag für iOS-Simulatoren zu definieren. Ausführliche Anweisungen dazu finden Sie in der Antwort von @ mbelsky .

Ursprüngliche Antwort

Wenn Sie eine statische Überprüfung benötigen (z. B. keine Laufzeit, wenn / sonst), können Sie den Simulator nicht direkt erkennen, aber Sie können iOS auf einer Desktop-Architektur wie folgt erkennen

#if (arch(i386) || arch(x86_64)) && os(iOS)
    ...
#endif

Nach Swift 4.1 Version

Die letzte Verwendung, jetzt direkt für alle in einer Bedingung für alle Arten von Simulatoren, muss nur eine Bedingung anwenden -

#if targetEnvironment(simulator)
  // your simulator code
#else
  // your real device code
#endif

Weitere Informationen finden Sie im Swift- Vorschlag SE-0190

Für ältere Version -

Dies ist auf einem Gerät eindeutig falsch, gibt jedoch für den iOS-Simulator den Wert true zurück, wie in der Dokumentation angegeben :

Die arch (i386) Build-Konfiguration gibt true zurück, wenn der Code für den 32-Bit-iOS-Simulator kompiliert wird.

Wenn Sie für einen anderen Simulator als iOS entwickeln, können Sie einfach den osParameter variieren : z

Erkennen Sie den watchOS- Simulator

#if (arch(i386) || arch(x86_64)) && os(watchOS)
...
#endif

Erkennen Sie den tvOS- Simulator

#if (arch(i386) || arch(x86_64)) && os(tvOS)
...
#endif

Oder erkennen Sie sogar einen Simulator

#if (arch(i386) || arch(x86_64)) && (os(iOS) || os(watchOS) || os(tvOS))
...
#endif

Wenn Sie stattdessen mit einer Laufzeitprüfung einverstanden sind, können Sie die TARGET_OS_SIMULATORVariable (oder TARGET_IPHONE_SIMULATORin iOS 8 und niedriger) überprüfen, was auf einem Simulator der Fall ist.

Bitte beachten Sie, dass dies anders und etwas eingeschränkter ist als die Verwendung eines Präprozessor-Flags. Zum Beispiel können Sie es nicht an Orten verwenden, an denen a if/elsesyntaktisch ungültig ist (z. B. außerhalb von Funktionsbereichen).

Angenommen, Sie möchten unterschiedliche Importe auf dem Gerät und im Simulator durchführen. Dies ist bei einer dynamischen Prüfung unmöglich, während es bei einer statischen Prüfung trivial ist.

#if (arch(i386) || arch(x86_64)) && os(iOS)
  import Foo
#else
  import Bar
#endif

Da das Flag durch den schnellen Präprozessor durch ein 0oder ein ersetzt 1wird, gibt if/elseder Compiler eine Warnung vor nicht erreichbarem Code aus , wenn Sie es direkt in einem Ausdruck verwenden.

Um diese Warnung zu umgehen, lesen Sie eine der anderen Antworten.

FÜR SWIFT veraltet 4.1. Verwenden Sie #if targetEnvironment(simulator)stattdessen. Quelle

Um den Simulator in Swift zu erkennen, können Sie die Build-Konfiguration verwenden:

• Definieren Sie diese Konfiguration -D IOS_SIMULATOR in Swift Compiler - Benutzerdefinierte Flags> Andere Swift Flags
• Wählen Sie in dieser Dropdown- Liste ein beliebiges iOS Simulator SDK aus

Jetzt können Sie diese Anweisung verwenden, um den Simulator zu erkennen:

#if IOS_SIMULATOR
    print("It's an iOS Simulator")
#else
    print("It's a device")
#endif

Sie können auch die UIDevice-Klasse erweitern:

extension UIDevice {
    var isSimulator: Bool {
        #if IOS_SIMULATOR
            return true
        #else
            return false
        #endif
    }
}
// Example of usage: UIDevice.current.isSimulator

Die Informationen wurden am 20. Februar 2018 aktualisiert

Es sieht so aus, als hätte @russbishop eine maßgebliche Antwort, die diese Antwort "falsch" macht - obwohl sie lange Zeit zu funktionieren schien.

Ermitteln Sie, ob in Swift eine App für ein Gerät oder einen Simulator erstellt wird

Vorherige Antwort

Basierend auf der Antwort von @ WZW und den Kommentaren von @ Pang habe ich eine einfache Dienstprogrammstruktur erstellt. Diese Lösung vermeidet Warnungen, die durch die Antwort von @ WZW erzeugt werden.

import Foundation

struct Platform {

    static var isSimulator: Bool {
        return TARGET_OS_SIMULATOR != 0
    }

}

Anwendungsbeispiel:

if Platform.isSimulator {
    print("Running on Simulator")
}

Ab Xcode 9.3

#if targetEnvironment(simulator)

Swift unterstützt eine neue Plattformbedingung targetEnvironment mit einem einzigen gültigen Argument-Simulator. Die bedingte Kompilierung des Formulars '#if targetEnvironment (simulator)' kann jetzt verwendet werden, um zu erkennen, wann das Build-Ziel ein Simulator ist. Der Swift-Compiler versucht, die Verwendung von targetEnvironment (Simulator) zu erkennen, zu warnen und vorzuschlagen, wenn Plattformbedingungen, die scheinbar indirekt auf Simulatorumgebungen getestet werden, über die vorhandenen Plattformbedingungen os () und arch () ausgewertet werden. (SE-0190)

iOS 9+:

extension UIDevice {
    static var isSimulator: Bool {
        return NSProcessInfo.processInfo().environment["SIMULATOR_DEVICE_NAME"] != nil
    }
}

Swift 3:

extension UIDevice {
    static var isSimulator: Bool {
        return ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nil
    }
}

Vor iOS 9:

extension UIDevice {
    static var isSimulator: Bool {
        return UIDevice.currentDevice().model == "iPhone Simulator"
    }
}

Ziel c:

@interface UIDevice (Additions)
- (BOOL)isSimulator;
@end

@implementation UIDevice (Additions)

- (BOOL)isSimulator {
    if([[NSProcessInfo processInfo] isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion){9, 0, 0}]) {
        return [NSProcessInfo processInfo].environment[@"SIMULATOR_DEVICE_NAME"] != nil;
    } else {
        return [[self model] isEqualToString:@"iPhone Simulator"];
    }
}

@end

Swift 4

Sie können jetzt targetEnvironment(simulator)als Argument verwenden.

#if targetEnvironment(simulator)
    // Simulator
#else
    // Device
#endif

Aktualisiert für Xcode 9.3

Lassen Sie mich hier einige Dinge klarstellen:

1. TARGET_OS_SIMULATORwird in vielen Fällen nicht im Swift-Code festgelegt; Möglicherweise wird es aufgrund eines Bridging-Headers versehentlich importiert, dies ist jedoch spröde und wird nicht unterstützt. Es ist auch nicht einmal in Frameworks möglich. Aus diesem Grund sind einige Leute verwirrt darüber, ob dies in Swift funktioniert.
2. Ich rate dringend davon ab, Architektur als Ersatz für Simulator zu verwenden.

So führen Sie dynamische Überprüfungen durch:

Die Überprüfung ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilist vollkommen in Ordnung.

Sie können das zugrunde liegende Modell auch simulieren lassen, indem Sie überprüfen, SIMULATOR_MODEL_IDENTIFIERwelche Zeichenfolgen wie zurückgegeben werden iPhone10,3.

So führen Sie statische Überprüfungen durch:

Xcode 9.2 und früher: Definieren Sie Ihr eigenes Swift-Kompilierungsflag (wie in anderen Antworten gezeigt).

Xcode 9.3+ verwendet die neue targetEnvironment-Bedingung:

#if targetEnvironment(simulator)
    // for sim only
#else
    // for device
#endif

Was für mich seit Swift 1.0 funktioniert, ist die Suche nach einer anderen Architektur als arm:

#if arch(i386) || arch(x86_64)

     //simulator
#else 
     //device

#endif

Laufzeit, aber einfacher als die meisten anderen Lösungen hier:

if TARGET_OS_SIMULATOR != 0 {
    // target is current running in the simulator
}

Alternativ können Sie einfach eine Objective-C-Hilfsfunktion aufrufen, die einen Booleschen Wert zurückgibt, der das Präprozessor-Makro verwendet (insbesondere, wenn Sie Ihr Projekt bereits einmischen).

Bearbeiten: Nicht die beste Lösung, insbesondere ab Xcode 9.3. Siehe die Antwort von HotJard

In modernen Systemen:

#if targetEnvironment(simulator)
    // sim
#else
    // device
#endif

Es ist einfach.

TARGET_IPHONE_SIMULATORist in iOS 9 veraltet. TARGET_OS_SIMULATORist der Ersatz. EbenfallsTARGET_OS_EMBEDDED verfügbar.

Von TargetConditionals.h :

#if defined(__GNUC__) && ( defined(__APPLE_CPP__) || defined(__APPLE_CC__) || defined(__MACOS_CLASSIC__) )
. . .
#define TARGET_OS_SIMULATOR         0
#define TARGET_OS_EMBEDDED          1 
#define TARGET_IPHONE_SIMULATOR     TARGET_OS_SIMULATOR /* deprecated */
#define TARGET_OS_NANO              TARGET_OS_WATCH /* deprecated */ 

Ich hoffe, diese Erweiterung ist praktisch.

extension UIDevice {
    static var isSimulator: Bool = {
        #if targetEnvironment(simulator)
        return true
        #else
        return false
        #endif
    }()
}

Verwendungszweck:

if UIDevice.isSimulator {
    print("running on simulator")
}

In Xcode 7.2 (und früher, aber ich habe noch nicht getestet, wie viel früher) können Sie ein plattformspezifisches Build-Flag "-D TARGET_IPHONE_SIMULATOR" für "Any iOS Simulator" setzen.

Schauen Sie in den Projekterstellungseinstellungen unter "Swift Compiler - Kundenflags" nach und setzen Sie dann das Flag unter "Andere Swift Flags". Sie können ein plattformspezifisches Flag setzen, indem Sie auf das Pluszeichen klicken, wenn Sie den Mauszeiger über eine Build-Konfiguration bewegen.

Dies hat einige Vorteile: 1) Sie können denselben bedingten Test ("#if TARGET_IPHONE_SIMULATOR") in Ihrem Swift- und Objective-C-Code verwenden. 2) Sie können Variablen kompilieren, die nur für jeden Build gelten.

Screenshot der Xcode-Build-Einstellungen

Alle hier beschriebenen Darwin.TargetConditionals : https://github.com/apple/swift-corelibs-foundation/blob/master/CoreFoundation/Base.subproj/SwiftRuntime/TargetConditionals.h

TARGET_OS_SIMULATOR - Generated code will run under a simulator

Ich habe diesen Code in Swift 3 verwendet

if TARGET_IPHONE_SIMULATOR == 1 {
    //simulator
} else {
    //device
}

Swift 4:

Derzeit bevorzuge ich die ProcessInfo- Klasse, um festzustellen , ob das Gerät ein Simulator ist und welche Art von Gerät verwendet wird:

if let simModelCode = ProcessInfo().environment["SIMULATOR_MODEL_IDENTIFIER"] {
            print("yes is a simulator :\(simModelCode)")
}

Wie Sie wissen, simModelCodeist es jedoch kein bequemer Code, sofort zu verstehen, welche Art von Simulator gestartet wurde. Wenn Sie dies benötigen, können Sie versuchen, diese andere SO- Antwort anzuzeigen , um das aktuelle iPhone- / Gerätemodell zu ermitteln und einen menschlicheren Charakter zu haben lesbare Zeichenfolge.

Hier ist ein Xcode 11 Swift Beispiel basiert weg HotJard die ehrfürchtige Antwort oben , das macht auch eine isDeviceBool und verwendet SIMULATOR_UDIDstatt Namen. Variablenzuweisungen werden in jeder Zeile vorgenommen, damit Sie sie im Debugger leichter überprüfen können, wenn Sie dies wünschen.

import Foundation

// Extensions to UIDevice based on ProcessInfo.processInfo.environment keys
// to determine if the app is running on an actual device or the Simulator.

@objc extension UIDevice {
    static var isSimulator: Bool {
        let environment = ProcessInfo.processInfo.environment
        let isSimulator = environment["SIMULATOR_UDID"] != nil
        return isSimulator
    }

    static var isDevice: Bool {
        let environment = ProcessInfo.processInfo.environment
        let isDevice = environment["SIMULATOR_UDID"] == nil
        return isDevice
    }
}

Es gibt auch den Wörterbucheintrag, der DTPlatformNameenthalten sollte simulator.

Verwenden Sie den folgenden Code:

#if targetEnvironment(simulator)
   // Simulator
#else
   // Device
#endif

Funktioniert für Swift 4undXcode 9.4.1

Xcode 11, Swift 5

    #if !targetEnvironment(macCatalyst)
    #if targetEnvironment(simulator)
        true
    #else
        false        
    #endif
    #endif

Neben anderen Antworten.

Stellen Sie in Objective-c einfach sicher, dass Sie TargetConditionals eingeschlossen haben .

#include <TargetConditionals.h>

vor dem Gebrauch TARGET_OS_SIMULATOR.