W Objective-C możemy wiedzieć, czy aplikacja jest budowana na urządzenie lub symulator przy użyciu makr:

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

Są to makra czasu kompilacji i niedostępne w czasie wykonywania.

Jak mogę to samo osiągnąć w Swift?

Aktualizacja 30/01/19

Chociaż ta odpowiedź może zadziałać, zalecanym rozwiązaniem dla kontroli statycznej (wyjaśnione przez kilku inżynierów Apple) jest zdefiniowanie niestandardowej flagi kompilatora ukierunkowanej na symulatory iOS. Aby uzyskać szczegółowe instrukcje, jak to zrobić, zobacz odpowiedź @ mbelsky'ego .

Oryginalna odpowiedź

Jeśli potrzebujesz sprawdzenia statycznego (np. Nie środowiska wykonawczego, jeśli / else), nie możesz bezpośrednio wykryć symulatora, ale możesz wykryć iOS na architekturze pulpitu, jak poniżej

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

Po wersji Swift 4.1

Najnowsze zastosowanie, teraz bezpośrednio dla wszystkich w jednym stanie dla wszystkich typów symulatorów, musi mieć zastosowanie tylko jeden warunek -

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

Aby uzyskać więcej wyjaśnień, możesz sprawdzić propozycję Swift SE-0190

W przypadku starszej wersji -

Oczywiście jest to fałsz na urządzeniu, ale zwraca wartość true dla symulatora iOS, jak określono w dokumentacji :

Konfiguracja kompilacji arch (i386) zwraca wartość true, gdy kod jest kompilowany dla 32-bitowego symulatora systemu iOS.

Jeśli opracowujesz symulator inny niż iOS, możesz po prostu zmienić osparametr: np

Wykryj symulator watchOS

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

Wykryj symulator tvOS

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

Lub nawet wykryj dowolny symulator

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

Jeśli zamiast tego masz rację sprawdzania czasu wykonywania, możesz sprawdzić TARGET_OS_SIMULATORzmienną (lub TARGET_IPHONE_SIMULATORw iOS 8 i niższych), co jest prawdą w symulatorze.

Zauważ, że jest to inne i nieco bardziej ograniczone niż użycie flagi preprocesora. Na przykład nie będziesz mógł używać go w miejscu, w którym a if/elsejest składniowo niepoprawny (np. Poza zakresem funkcji).

Powiedz na przykład, że chcesz mieć różne importy na urządzeniu i na symulatorze. Jest to niemożliwe przy kontroli dynamicznej, podczas gdy jest trywialne przy kontroli statycznej.

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

Ponadto, ponieważ flaga jest zastąpiona przez a 0lub a 1przez szybki preprocesor, jeśli używasz go bezpośrednio wif/else wyrażeniu, kompilator wyświetli ostrzeżenie o nieosiągalnym kodzie.

Aby obejść to ostrzeżenie, zobacz jedną z pozostałych odpowiedzi.

NIEAKTUALIZOWANE DLA SWIFT 4.1. Użyj #if targetEnvironment(simulator)zamiast tego. Źródło

Aby wykryć symulator w Swift, możesz użyć konfiguracji kompilacji:

• Zdefiniuj tę konfigurację -D IOS_SIMULATOR w Swift Compiler - Flagi niestandardowe> Inne flagi Swift
• W tym menu wybierz Dowolny zestaw SDK symulatora systemu iOS

Teraz możesz użyć tej instrukcji do wykrycia symulatora:

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

Możesz także rozszerzyć klasę UIDevice:

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

Zaktualizowano informacje na dzień 20 lutego 2018 r

Wygląda na to, że @ russbishop ma autorytatywną odpowiedź, która czyni tę odpowiedź „niepoprawną” - mimo że wydawała się działać przez długi czas.

Wykryj, czy aplikacja Swift tworzy aplikację na urządzenie lub symulator

Poprzednia odpowiedź

Na podstawie odpowiedzi @ WZW i komentarzy @ Panga stworzyłem prostą strukturę narzędzia. To rozwiązanie pozwala uniknąć ostrzeżeń generowanych przez odpowiedź @ WZW.

import Foundation

struct Platform {

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

}

Przykładowe użycie:

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

Z Xcode 9.3

#if targetEnvironment(simulator)

Swift obsługuje nowy docelowy stan środowiska platformy z jednym ważnym symulatorem argumentów. Kompilacja warunkowa postaci „#if targetEnvironment (symulator)” może być teraz używana do wykrywania, gdy celem kompilacji jest symulator. Kompilator Swift będzie próbował wykryć, ostrzec i zasugerować użycie targetEnvironment (symulator) podczas oceny warunków platformy, które wydają się pośrednio testować środowiska symulatora, poprzez istniejące warunki platformy os () i arch (). (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
    }
}

Przed iOS 9:

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

Cel 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

Szybki 4

Możesz teraz użyć targetEnvironment(simulator)jako argumentu.

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

Zaktualizowano dla Xcode 9.3

Pozwól mi wyjaśnić kilka rzeczy tutaj:

1. TARGET_OS_SIMULATORw wielu przypadkach nie jest ustawiony w kodzie Swift; możesz przypadkowo go zaimportować z powodu mostkowego nagłówka, ale jest on łamliwy i nie jest obsługiwany. Nie jest to nawet możliwe w ramach. To dlatego niektórzy ludzie są zdezorientowani, czy to działa w Swift.
2. Zdecydowanie odradzam używanie architektury jako zamiennika symulatora.

Aby wykonać kontrole dynamiczne:

Sprawdzanie ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != niljest w porządku.

Można również uzyskać symulację modelu bazowego, sprawdzając, SIMULATOR_MODEL_IDENTIFIERktóre zwracają łańcuchy takie jak iPhone10,3.

Aby wykonać kontrolę statyczną:

Xcode 9.2 i wcześniejsze: zdefiniuj własną flagę kompilacji Swift (jak pokazano w innych odpowiedziach).

Xcode 9.3+ korzysta z nowego celu Warunek środowiskowy:

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

Co działa dla mnie, odkąd Swift 1.0 sprawdza architekturę inną niż arm:

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

     //simulator
#else 
     //device

#endif

Środowisko wykonawcze, ale prostsze niż większość innych rozwiązań tutaj:

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

Alternatywnie możesz po prostu wywołać funkcję pomocniczą Objective-C, która zwraca wartość logiczną, która używa makra preprocesora (szczególnie jeśli już miksujesz w swoim projekcie).

Edycja: Nie najlepsze rozwiązanie, szczególnie od Xcode 9.3. Zobacz odpowiedź HotJard

W nowoczesnych systemach:

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

To proste.

TARGET_IPHONE_SIMULATORjest przestarzałe w iOS 9. TARGET_OS_SIMULATORjest zamiennikiem. TARGET_OS_EMBEDDEDJest również dostępny.

From 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 */ 

Mam nadzieję, że to rozszerzenie się przyda.

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

Stosowanie:

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

W Xcode 7.2 (i wcześniejszych, ale wcześniej nie testowałem), możesz ustawić flagę kompilacji specyficzną dla platformy „-D TARGET_IPHONE_SIMULATOR” dla „Any iOS Simulator”.

Sprawdź ustawienia kompilacji projektu w „Kompilatorze Swift - Flagi klienta”, a następnie ustaw flagę w „Innych flagach Swift”. Możesz ustawić flagę specyficzną dla platformy, klikając ikonę „plus” po najechaniu kursorem na konfigurację kompilacji.

Jest kilka zalet robienia tego w ten sposób: 1) Możesz użyć tego samego testu warunkowego („#if TARGET_IPHONE_SIMULATOR”) w kodzie Swift i Objective-C. 2) Możesz skompilować zmienne, które dotyczą tylko każdej kompilacji.

Zrzut ekranu ustawień kompilacji Xcode

Wszystko opisane tutaj 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

Użyłem tego kodu poniżej w Swift 3

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

Swift 4:

Obecnie wolę używać klasy ProcessInfo, aby wiedzieć, czy urządzenie jest symulatorem i jakiego rodzaju urządzenia jest używane:

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

Ale, jak wiesz, simModelCodenie jest wygodnym kodem do natychmiastowego zrozumienia, który rodzaj symulatora został uruchomiony, więc jeśli potrzebujesz, możesz spróbować zobaczyć inną odpowiedź SO, aby określić aktualny model iPhone / urządzenia i mieć bardziej ludzki charakter czytelny ciąg.

Oto przykład Xcode 11 Swift oparty na świetnej odpowiedzi HotJarda powyżej , to także dodaje isDeviceBool i używa SIMULATOR_UDIDzamiast nazwy. W każdym wierszu wykonywane są zmienne przypisania, dzięki czemu można łatwiej sprawdzić je w debuggerze, jeśli zdecydujesz.

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

Jest też wpis słownikowy, DTPlatformNamektóry powinien zawierać simulator.

Użyj tego kodu poniżej:

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

Działa dla Swift 4iXcode 9.4.1

Xcode 11, Swift 5

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

Oprócz innych odpowiedzi.

W Objective-c, upewnij się, że podałeś TargetConditionals .

#include <TargetConditionals.h>

przed użyciem TARGET_OS_SIMULATOR.