Code Mise à jour:

Ceci est censé travailler officiellement.

#if TARGET_IPHONE_SIMULATOR
NSString *hello = @"Hello, iPhone simulator!";
#elif TARGET_OS_IPHONE
NSString *hello = @"Hello, device!";
#else
NSString *hello = @"Hello, unknown target!";
#endif

Original post (depuis dépréciée)

Ce code vous dira si vous exécutez dans un simulateur.

#ifdef __i386__
NSLog(@"Running in the simulator");
#else
NSLog(@"Running on a device");
#endif

Non directive pré-processeur, mais c'était ce que je cherchais quand je suis venu à cette question;

NSString *model = [[UIDevice currentDevice] model];
if ([model isEqualToString:@"iPhone Simulator"]) {
    //device is simulator
}

La meilleure façon de le faire est:

#if TARGET_IPHONE_SIMULATOR

et pas

#ifdef TARGET_IPHONE_SIMULATOR

depuis son toujours défini: 0 ou 1

En cas de Swift nous pouvons mettre en œuvre suite

Nous pouvons créer struct qui vous permet de créer une structure de données

struct Platform {
    static let isSimulator: Bool = {
        #if arch(i386) || arch(x86_64)
            return true
        #endif
        return false
    }()
}

Ensuite, si nous voulions détecter si l'application est en cours de construction pour l'appareil ou d'un simulateur à Swift puis.

if Platform.isSimulator {
    // Do one thing
}
else {
    // Do the other
}

Toutes les réponses sont bonnes, mais il confond en quelque sorte novice comme moi, car il ne précise pas la compilation vérification et le contrôle d'exécution. Préprocesseur sont avant la compilation du temps, mais nous devons le rendre plus clair

Cet article de blog montre Comment détecter le simulateur d'iPhone? clairement

Runtime

Tout d'abord, nous allons discuter sous peu. UIDevice vous fournit déjà des informations sur l'appareil

[[UIDevice currentDevice] model]

vous retourner « iPhone Simulator » ou « iPhone » selon l'endroit où l'application est en cours d'exécution.

La compilation

Cependant ce que vous voulez est d'utiliser la compilation définit le temps. Pourquoi? Parce que vous compilez votre application strictement à exécuter à l'intérieur du simulateur ou sur l'appareil. Apple fait DEFINE appelé TARGET_IPHONE_SIMULATOR. Alors regardons le code:

#if TARGET_IPHONE_SIMULATOR

NSLog(@"Running in Simulator - no app store or giro");

#endif

IL EST UN MEILLEUR MOYEN-NOUS MAINTENANT!

A partir de Xcode 9.3 beta 4 vous pouvez utiliser #if targetEnvironment(simulator)pour vérifier.

#if targetEnvironment(simulator)
//Your simulator code
#endif

En rapide:

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

De détecter si l' application est en cours de construction pour l' appareil ou d'un simulateur à Swift

Les réponses précédentes sont un peu vieillottes. Je trouve que tout ce que vous devez faire est interroger la TARGET_IPHONE_SIMULATORmacro ( pas nécessaire d'inclure d'autres fichiers d' en- tête [ en supposant que vous codez pour iOS]).

Je tentais , TARGET_OS_IPHONEmais il est revenu la même valeur (1) lors de l' exécution sur un périphérique réel et simulateur, c'est pourquoi je recommande d' utiliser à la TARGET_IPHONE_SIMULATORplace.

J'ai eu le même problème, à la fois TARGET_IPHONE_SIMULATORet TARGET_OS_IPHONEsont toujours définis et sont à 1. solution fonctionne de Pete, bien sûr, mais si jamais vous arrive de construire sur autre chose que intel (peu probable, mais qui sait), voici quelque chose qui est sûr que tant que le matériel iphone ne change pas (si votre code sera toujours travailler pour les iphones actuellement là - bas):

#if defined __arm__ || defined __thumb__
#undef TARGET_IPHONE_SIMULATOR
#define TARGET_OS_IPHONE
#else
#define TARGET_IPHONE_SIMULATOR 1
#undef TARGET_OS_IPHONE
#endif

Mettez cette pratique quelque part, puis faire semblant que les TARGET_*constantes ont été définies correctement.

Swift 4.2 / 10 xCode

J'ai créé une extension sur UIDevice, donc je peux facilement demander si le simulateur est en cours d'exécution.

// UIDevice+CheckSimulator.swift

import UIKit

extension UIDevice {

    /// Checks if the current device that runs the app is xCode's simulator
    static func isSimulator() -> Bool {        
        #if targetEnvironment(simulator)
            return true
        #else
            return false
        #endif
    }
}

Dans mon AppDelegate par exemple , j'utilise cette méthode pour décider wether enregistrement de notification à distance est nécessaire, ce qui est impossible pour le simulateur.

// CHECK FOR REAL DEVICE / OR SIMULATOR
if UIDevice.isSimulator() == false {

    // REGISTER FOR SILENT REMOTE NOTIFICATION
    application.registerForRemoteNotifications()
}

Travaux pour Swift 4etXcode 9.4.1

Utilisez ce code:

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

Avec Swift 4.2 (Xcode 10), nous pouvons le faire

#if hasTargetEnvironment(simulator)
  //simulator code
#else 
  #warning("Not compiling for simulator")
#endif

Quelqu'un at -il examiné la réponse fournie ici ?

Je suppose que l'équivalent objectif-c serait

+ (BOOL)isSimulator {
    NSOperatingSystemVersion ios9 = {9, 0, 0};
    NSProcessInfo *processInfo = [NSProcessInfo processInfo];
    if ([processInfo isOperatingSystemAtLeastVersion:ios9]) {
        NSDictionary<NSString *, NSString *> *environment = [processInfo environment];
        NSString *simulator = [environment objectForKey:@"SIMULATOR_DEVICE_NAME"];
        return simulator != nil;
    } else {
        UIDevice *currentDevice = [UIDevice currentDevice];
        return ([currentDevice.model rangeOfString:@"Simulator"].location != NSNotFound);
    }
}

Pour inclure tous les types de « simulateurs »

NSString *model = [[UIDevice currentDevice] model];
if([model rangeOfString:@"Simulator" options:NSCaseInsensitiveSearch].location !=NSNotFound)
{
    // we are running in a simulator
}

si rien ne fonctionnait, essayer

public struct Platform {

    public static var isSimulator: Bool {
        return TARGET_OS_SIMULATOR != 0 // Use this line in Xcode 7 or newer
    }

}

Apple a ajouté le support pour le contrôle de l'application est prévue pour le simulateur avec les éléments suivants:

#if targetEnvironment(simulator)
let DEVICE_IS_SIMULATOR = true
#else
let DEVICE_IS_SIMULATOR = false
#endif

SWIFT Solution 4

static let isSimulator: Bool = {
    return TARGET_OS_SIMULATOR == 1
}()

TARGET_OS_SIMULATORest situé dans le Darwin.TargetConditionals.swiftfichier.

/// Retourne true si son simulateur et non un dispositif

public static var isSimulator: Bool {
    #if (arch(i386) || arch(x86_64)) && os(iOS)
        return true
    #else
        return false
    #endif
}

Ma réponse est basée sur la réponse et Magnusson @ Daniel commentaires de @Nuthatch et @ n.Drake. et je l'écris pour gagner du temps pour les utilisateurs rapides travaillant sur iOS9 et les années suivantes.

C'est ce qui a fonctionné pour moi:

if UIDevice.currentDevice().name.hasSuffix("Simulator"){
    //Code executing on Simulator
} else{
    //Code executing on Device
}

Cela m'a travaillé pour le meilleur

NSString *name = [[UIDevice currentDevice] name];


if ([name isEqualToString:@"iPhone Simulator"]) {

}

À mon avis, la réponse (présentée ci-dessus et répété ci-dessous):

NSString *model = [[UIDevice currentDevice] model];
if ([model isEqualToString:@"iPhone Simulator"]) {
    //device is simulator
}

est la meilleure réponse car il est évidemment exécuté à l'exécution plutôt que d'être DIRECTIVE COMPILE.