Dans Objective-C, nous pouvons savoir si une application est en cours de création pour un appareil ou un simulateur à l'aide de macros:

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

Ce sont des macros de compilation et non disponibles au moment de l'exécution.

Comment puis-je réaliser la même chose dans Swift?

Mise à jour 30/01/19

Bien que cette réponse puisse fonctionner, la solution recommandée pour une vérification statique (telle que clarifiée par plusieurs ingénieurs Apple) consiste à définir un indicateur de compilateur personnalisé ciblant les simulateurs iOS. Pour des instructions détaillées sur la façon de procéder, voir la réponse de @ mbelsky .

Réponse originale

Si vous avez besoin d'une vérification statique (par exemple pas un runtime si / sinon), vous ne pouvez pas détecter directement le simulateur, mais vous pouvez détecter iOS sur une architecture de bureau comme suit

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

Après la version Swift 4.1

Dernière utilisation, maintenant directement pour tous dans une condition pour tous les types de simulateurs doivent appliquer une seule condition -

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

Pour plus de précisions, vous pouvez consulter la proposition Swift SE-0190

Pour l'ancienne version -

De toute évidence, cela est faux sur un appareil, mais cela renvoie vrai pour le simulateur iOS, comme spécifié dans la documentation :

La configuration de construction arch (i386) renvoie true lorsque le code est compilé pour le simulateur iOS 32 bits.

Si vous développez pour un simulateur autre que iOS, vous pouvez simplement faire varier le osparamètre: par exemple

Détectez le simulateur watchOS

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

Détecter le simulateur tvOS

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

Ou même détecter n'importe quel simulateur

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

Si vous êtes plutôt d'accord avec une vérification de l'exécution, vous pouvez inspecter la TARGET_OS_SIMULATORvariable (ou TARGET_IPHONE_SIMULATORdans iOS 8 et ci-dessous), ce qui est vrai sur un simulateur.

Veuillez noter que cela est différent et légèrement plus limité que l'utilisation d'un indicateur de préprocesseur. Par exemple, vous ne pourrez pas l'utiliser à un endroit où a if/elseest syntaxiquement invalide (par exemple en dehors des étendues de fonctions).

Supposons, par exemple, que vous souhaitiez avoir des importations différentes sur l'appareil et sur le simulateur. C'est impossible avec une vérification dynamique, alors que c'est trivial avec une vérification statique.

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

De plus, comme l'indicateur est remplacé par a 0ou a 1par le préprocesseur rapide, si vous l'utilisez directement dans une if/elseexpression, le compilateur émet un avertissement concernant le code inaccessible.

Pour contourner cet avertissement, consultez l'une des autres réponses.

MIS À JOUR POUR SWIFT 4.1. Utilisez #if targetEnvironment(simulator)plutôt. La source

Pour détecter le simulateur dans Swift, vous pouvez utiliser la configuration de build:

• Définissez cette configuration -D IOS_SIMULATOR dans Swift Compiler - Indicateurs personnalisés> Autres indicateurs Swift
• Sélectionnez N'importe quel SDK iOS Simulator dans cette liste déroulante

Vous pouvez maintenant utiliser cette instruction pour détecter le simulateur:

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

Vous pouvez également étendre la classe UIDevice:

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

Informations mises à jour au 20 février 2018

Il semble que @russbishop ait une réponse faisant autorité qui rend cette réponse "incorrecte" - même si cela a semblé fonctionner pendant longtemps.

Détecter si l'application est en cours de création pour un appareil ou un simulateur dans Swift

Réponse précédente

Sur la base de la réponse de @ WZW et des commentaires de @ Pang, j'ai créé une structure utilitaire simple. Cette solution évite les avertissements produits par la réponse de @ WZW.

import Foundation

struct Platform {

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

}

Exemple d'utilisation:

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

Depuis Xcode 9.3

#if targetEnvironment(simulator)

Swift prend en charge une nouvelle condition de plate-forme targetEnvironment avec un seul simulateur d'argument valide. La compilation conditionnelle du formulaire '#if targetEnvironment (simulator)' peut maintenant être utilisée pour détecter quand la cible de build est un simulateur. Le compilateur Swift tentera de détecter, d'avertir et de suggérer l'utilisation de targetEnvironment (simulator) lors de l'évaluation indirecte des conditions de plate-forme qui semblent tester les environnements de simulateur, via les conditions de plate-forme os () et arch () existantes. (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
    }
}

Avant iOS 9:

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

Objectif 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

Vous pouvez maintenant utiliser targetEnvironment(simulator)comme argument.

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

Mis à jour pour Xcode 9.3

Permettez-moi de clarifier certaines choses ici:

1. TARGET_OS_SIMULATORn'est pas défini dans le code Swift dans de nombreux cas; vous pouvez l'obtenir accidentellement en raison d'un en-tête de pontage, mais il est fragile et non pris en charge. Ce n'est même pas possible dans les frameworks. C'est pourquoi certaines personnes ne savent pas si cela fonctionne dans Swift.
2. Je déconseille fortement d'utiliser l'architecture comme substitut du simulateur.

Pour effectuer des vérifications dynamiques:

La vérification ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilest parfaitement bien.

Vous pouvez également obtenir la simulation du modèle sous-jacent en vérifiant SIMULATOR_MODEL_IDENTIFIERqui renverra des chaînes comme iPhone10,3.

Pour effectuer des vérifications statiques:

Xcode 9.2 et versions antérieures: définissez votre propre drapeau de compilation Swift (comme indiqué dans les autres réponses).

Xcode 9.3+ utilise la nouvelle condition targetEnvironment:

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

Ce qui fonctionne pour moi depuis Swift 1.0 est de rechercher une architecture autre que arm:

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

     //simulator
#else 
     //device

#endif

Runtime, mais plus simple que la plupart des autres solutions ici:

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

Alternativement, vous pouvez simplement appeler une fonction d'assistance Objective-C qui renvoie un booléen qui utilise la macro du préprocesseur (surtout si vous mixez déjà dans votre projet).

Edit: Pas la meilleure solution, surtout depuis Xcode 9.3. Voir la réponse de HotJard

Dans les systèmes modernes:

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

C'est très simple.

TARGET_IPHONE_SIMULATORest obsolète dans iOS 9. TARGET_OS_SIMULATORest le remplacement. Est également TARGET_OS_EMBEDDEDdisponible.

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

J'espère que cette extension sera utile.

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

Usage:

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

Dans Xcode 7.2 (et plus tôt mais je n'ai pas testé combien auparavant), vous pouvez définir un indicateur de build spécifique à la plate-forme "-D TARGET_IPHONE_SIMULATOR" pour "Any iOS Simulator".

Regardez dans les paramètres de construction du projet sous "Compilateur Swift - Indicateurs client", puis définissez l'indicateur dans "Autres indicateurs Swift". Vous pouvez définir un indicateur spécifique à la plate-forme en cliquant sur l'icône «plus» lorsque vous survolez une configuration de build.

Il y a quelques avantages à le faire de cette façon: 1) Vous pouvez utiliser le même test conditionnel ("#if TARGET_IPHONE_SIMULATOR") dans votre code Swift et Objective-C. 2) Vous pouvez compiler des variables qui ne s'appliquent qu'à chaque build.

Capture d'écran des paramètres de construction de Xcode

Tous décrits ici 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

J'ai utilisé ce code ci-dessous dans Swift 3

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

Swift 4:

Actuellement, je préfère utiliser la classe ProcessInfo pour savoir si le périphérique est un simulateur et quel type de périphérique est utilisé:

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

Mais, comme vous le savez, ce simModelCoden'est pas un code confortable pour comprendre immédiatement quel type de simulateur a été lancé, donc, si vous en avez besoin, vous pouvez essayer de voir cette autre réponse SO pour déterminer le modèle actuel d'iPhone / appareil et d'avoir un humain plus chaîne lisible.

Voici un exemple Xcode 11 Swift basé sur la réponse impressionnante de HotJard ci - dessus , cela ajoute également un isDeviceBool et utilise à la SIMULATOR_UDIDplace du nom. Des affectations variables sont effectuées sur chaque ligne afin que vous puissiez les examiner plus facilement dans le débogueur si vous le souhaitez.

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

Il y a aussi l'entrée du dictionnaire DTPlatformNamequi devrait contenir simulator.

Utilisez ce code ci-dessous:

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

Fonctionne pour Swift 4etXcode 9.4.1

Xcode 11, Swift 5

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

En plus d'autres réponses.

Dans Objective-c, assurez-vous simplement que vous avez inclus TargetConditionals .

#include <TargetConditionals.h>

avant d'utiliser TARGET_OS_SIMULATOR.