In Objective-C possiamo sapere se un'app viene costruita per dispositivo o simulatore usando le macro:

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

Si tratta di macro di tempo di compilazione e non disponibili in fase di esecuzione.

Come posso ottenere lo stesso in Swift?

Aggiornamento 30/01/19

Sebbene questa risposta possa funzionare, la soluzione consigliata per un controllo statico (come chiarito da diversi ingegneri Apple) è quella di definire un flag di compilatore personalizzato destinato ai simulatori iOS. Per istruzioni dettagliate su come procedere, vedere la risposta di @ mbelsky .

Risposta originale

Se hai bisogno di un controllo statico (ad es. Non un runtime if / else) non puoi rilevare direttamente il simulatore, ma puoi rilevare iOS su un'architettura desktop come segue

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

Dopo la versione Swift 4.1

Ultimo utilizzo, ora direttamente per tutti in una condizione per tutti i tipi di simulatori è necessario applicare una sola condizione:

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

Per ulteriori chiarimenti, è possibile controllare la proposta Swift SE-0190

Per la versione precedente -

Chiaramente, questo è falso su un dispositivo, ma restituisce true per il simulatore iOS, come specificato nella documentazione :

La configurazione di build arch (i386) restituisce true quando il codice viene compilato per il simulatore iOS a 32 bit.

Se stai sviluppando un simulatore diverso da iOS, puoi semplicemente variare il osparametro: ad es

Rileva il simulatore watchOS

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

Rileva il simulatore tvOS

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

O, persino, rilevare qualsiasi simulatore

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

Se invece stai bene con un controllo di runtime, puoi ispezionare la TARGET_OS_SIMULATORvariabile (o TARGET_IPHONE_SIMULATORin iOS 8 e precedenti), che è davvero su un simulatore.

Si noti che questo è diverso e leggermente più limitato rispetto all'utilizzo di un flag di preprocessore. Ad esempio, non sarai in grado di usarlo nel posto in cui if/elsesintatticamente non è valido (ad esempio al di fuori degli ambiti delle funzioni).

Supponiamo, ad esempio, che desideri avere importazioni diverse sul dispositivo e sul simulatore. Questo è impossibile con un controllo dinamico, mentre è banale con un controllo statico.

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

Inoltre, poiché il flag viene sostituito con 0ao 1dal rapido preprocessore, se lo si utilizza direttamente in if/elseun'espressione, il compilatore genererà un avviso sul codice non raggiungibile.

Per aggirare questo avviso, vedere una delle altre risposte.

Non aggiornato per Swift 4.1. Usa #if targetEnvironment(simulator)invece. fonte

Per rilevare il simulatore in Swift è possibile utilizzare la configurazione build:

• Definire questa configurazione -D IOS_SIMULATOR nel compilatore Swift - Bandiere personalizzate> Altre bandiere Swift
• Seleziona Qualsiasi SDK per iOS Simulator in questo menu a discesa

Ora puoi usare questa istruzione per rilevare il simulatore:

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

Inoltre puoi estendere la classe UIDevice:

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

Informazioni aggiornate al 20 febbraio 2018

Sembra che @russbishop abbia una risposta autorevole che rende questa risposta "errata", anche se sembra funzionare a lungo.

Rileva se l'app è in fase di creazione per dispositivo o simulatore in Swift

Risposta precedente

Sulla base della risposta di @ WZW e dei commenti di @ Pang, ho creato una semplice struttura di utilità. Questa soluzione evita gli avvertimenti prodotti dalla risposta di @ WZW.

import Foundation

struct Platform {

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

}

Esempio di utilizzo:

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

Da Xcode 9.3

#if targetEnvironment(simulator)

Swift supporta una nuova condizione della piattaforma targetEnvironment con un singolo simulatore di argomenti valido. La compilazione condizionale del modulo '#if targetEnvironment (simulator)' può ora essere utilizzata per rilevare quando il target di build è un simulatore. Il compilatore Swift tenterà di rilevare, avvisare e suggerire l'uso di targetEnvironment (simulatore) durante la valutazione delle condizioni della piattaforma che sembrano testare indirettamente gli ambienti del simulatore, tramite le condizioni della piattaforma os () e arch () esistenti. (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
    }
}

Prima di iOS 9:

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

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

Ora puoi usare targetEnvironment(simulator)come argomento.

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

Aggiornato per Xcode 9.3

Vorrei chiarire alcune cose qui:

1. TARGET_OS_SIMULATORnon è impostato nel codice Swift in molti casi; potresti essere accidentalmente importato a causa di un'intestazione ponte ma questo è fragile e non supportato. Inoltre non è nemmeno possibile nei framework. Questo è il motivo per cui alcune persone sono confuse sul fatto che funzioni in Swift.
2. Consiglio vivamente di non utilizzare l'architettura come sostituto del simulatore.

Per eseguire controlli dinamici:

Il controllo ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilva benissimo.

Puoi anche simulare il modello sottostante controllando SIMULATOR_MODEL_IDENTIFIERquale restituirà stringhe simili iPhone10,3.

Per eseguire controlli statici:

Xcode 9.2 e precedenti: definisci il tuo flag di compilazione Swift (come mostrato in altre risposte).

Xcode 9.3+ utilizza la nuova condizione targetEnvironment:

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

Ciò che funziona per me dal momento che Swift 1.0 sta verificando un'architettura diversa da arm:

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

     //simulator
#else 
     //device

#endif

Runtime, ma più semplice della maggior parte delle altre soluzioni qui:

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

In alternativa, puoi semplicemente chiamare una funzione helper Objective-C che restituisce un valore booleano che utilizza la macro del preprocessore (specialmente se stai già mescolando nel tuo progetto).

Modifica: non è la soluzione migliore, soprattutto a partire da Xcode 9.3. Vedi la risposta di HotJard

Nei sistemi moderni:

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

È facile.

TARGET_IPHONE_SIMULATORè obsoleto in iOS 9. TARGET_OS_SIMULATORè la sostituzione. Inoltre TARGET_OS_EMBEDDEDè disponibile.

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

Spero che questa estensione sia utile.

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

Uso:

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

In Xcode 7.2 (e precedenti ma non ho ancora testato quanto prima), puoi impostare un flag di build specifico per la piattaforma "-D TARGET_IPHONE_SIMULATOR" per "Any iOS Simulator".

Cerca nelle impostazioni di compilazione del progetto in "Compilatore Swift - Bandiere clienti", quindi imposta il flag in "Altre bandiere Swift". Puoi impostare un flag specifico per la piattaforma facendo clic sull'icona 'più' quando passi con il mouse sopra una configurazione di build.

Ci sono un paio di vantaggi nel farlo in questo modo: 1) Puoi usare lo stesso test condizionale ("#if TARGET_IPHONE_SIMULATOR") nel tuo codice Swift e Objective-C. 2) È possibile compilare variabili che si applicano solo a ogni build.

Schermata delle impostazioni di compilazione di Xcode

Tutto qui descritto 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

Ho usato questo codice di seguito in Swift 3

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

Swift 4:

Attualmente, preferisco usare la classe ProcessInfo per sapere se il dispositivo è un simulatore e quale tipo di dispositivo è in uso:

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

Ma, come sai, simModelCodenon è un codice comodo per capire immediatamente quale tipo di simulatore è stato lanciato, quindi, se necessario, puoi provare a vedere questa altra risposta SO per determinare l'attuale modello di iPhone / dispositivo e avere un più umano stringa leggibile.

Ecco un esempio di Xcode 11 Swift basato sulla fantastica risposta di HotJard sopra , questo aggiunge anche un isDeviceBool e usa al SIMULATOR_UDIDposto del nome. Le assegnazioni di variabili vengono eseguite su ogni riga in modo da poterle esaminare più facilmente nel debugger se lo si desidera.

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

C'è anche la voce del dizionario DTPlatformNameche dovrebbe contenere simulator.

Usa questo codice qui sotto:

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

Funziona per Swift 4eXcode 9.4.1

Xcode 11, Swift 5

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

Oltre ad altre risposte.

In Objective-c, assicurati di aver incluso TargetConditionals .

#include <TargetConditionals.h>

prima di usare TARGET_OS_SIMULATOR.