Comme l'indique la question, je voudrais principalement savoir si mon code fonctionne ou non dans le simulateur, mais je serais également intéressé à connaître la version spécifique de l'iPhone qui fonctionne ou est simulée.

EDIT: J'ai ajouté le mot «par programme» au nom de la question. Le point de ma question est de pouvoir inclure / exclure dynamiquement du code en fonction de la version / du simulateur en cours d'exécution, donc je chercherais vraiment quelque chose comme une directive de pré-processeur qui peut me fournir ces informations.

Déjà demandé, mais avec un titre très différent.

Quelles # définitions sont configurées par Xcode lors de la compilation pour iPhone

Je vais répéter ma réponse à partir de là:

C'est dans la documentation du SDK sous "Compilation conditionnelle du code source"

La définition pertinente est TARGET_OS_SIMULATOR, qui est définie dans /usr/include/TargetConditionals.h dans le cadre iOS. Sur les versions antérieures de la chaîne d'outils, vous deviez écrire:

#include "TargetConditionals.h"

mais cela n'est plus nécessaire sur la chaîne d'outils actuelle (Xcode 6 / iOS8).

Ainsi, par exemple, si vous souhaitez vérifier que vous exécutez sur l'appareil, vous devez faire

#if TARGET_OS_SIMULATOR
    // Simulator-specific code
#else
    // Device-specific code
#endif

selon ce qui est approprié pour votre cas d'utilisation.

Code mis à jour:

Il est censé fonctionner 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

Message d'origine (déconseillé depuis)

Ce code vous indiquera si vous utilisez un simulateur.

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

Pas de directive pré-processeur, mais c'est ce que je cherchais quand je suis arrivé à cette question;

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

La meilleure façon de procéder est:

#if TARGET_IPHONE_SIMULATOR

et pas

#ifdef TARGET_IPHONE_SIMULATOR

puisque son toujours défini: 0 ou 1

IL Y A UNE MEILLEURE FAÇON MAINTENANT!

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

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

UPDATE
Xcode 10 et iOS 12 SDK le prennent également en charge.

Dans le cas de Swift, nous pouvons implémenter ce qui suit

Nous pouvons créer une structure qui vous permet de créer une donnée structurée

struct Platform {
    static var isSimulator: Bool {
        #if targetEnvironment(simulator)
            // We're on the simulator
            return true
        #else
            // We're on a device
             return false
        #endif
    }
}

Ensuite, si nous voulions détecter si l'application est en cours de création pour un appareil ou un simulateur dans Swift, alors.

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

Fonctionne pour Swift 5etXcode 11.3.1

Utilisez ce code:

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

Toutes ces réponses sont bonnes, mais cela dérange en quelque sorte les débutants comme moi car cela ne clarifie pas le contrôle de compilation et le contrôle d'exécution. Le préprocesseur est avant le moment de la compilation, mais nous devons le rendre plus clair

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

Durée

Tout d'abord, discutons brièvement. UIDevice vous fournit déjà des informations sur l'appareil

[[UIDevice currentDevice] model]

vous renverra "iPhone Simulator" ou "iPhone" selon l'endroit où l'application est en cours d'exécution.

Compiler le temps

Cependant, ce que vous voulez, c'est utiliser le temps de compilation définit. Pourquoi? Parce que vous compilez votre application strictement pour qu'elle soit exécutée à l'intérieur du simulateur ou sur l'appareil. Apple fait un définir appelé TARGET_IPHONE_SIMULATOR. Regardons donc le code:

#if TARGET_IPHONE_SIMULATOR

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

#endif

Les réponses précédentes sont un peu datées. J'ai trouvé que tout ce que vous devez faire est d'interroger la TARGET_IPHONE_SIMULATORmacro ( pas besoin d'inclure d'autres fichiers d'en-tête [en supposant que vous codez pour iOS]).

J'ai essayé TARGET_OS_IPHONEmais il a retourné la même valeur (1) lors de l'exécution sur un appareil et un simulateur réels, c'est pourquoi je recommande d'utiliser à la TARGET_IPHONE_SIMULATORplace.

En bref:

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

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

J'ai eu le même problème, les deux TARGET_IPHONE_SIMULATORet TARGET_OS_IPHONEsont toujours définis, et sont définis sur 1. La solution de Pete fonctionne, bien sûr, mais s'il vous arrive de construire sur autre chose qu'Intel (peu probable, mais qui sait), voici quelque chose qui est sûr comme tant que le matériel de l'iphone ne change pas (donc votre code fonctionnera toujours pour les iphones actuellement disponibles):

#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 cela dans un endroit pratique, puis faites comme si le TARGET_* constantes étaient correctement définies.

Quelqu'un at-il considéré 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 Swift 4.2 / xCode 10

J'ai créé une extension sur UIDevice, donc je peux facilement demander si le simulateur fonctionne.

// 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 si l'enregistrement pour une notification à distance est nécessaire, ce qui n'est pas possible pour le simulateur.

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

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

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
}

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

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

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

C'est ce qui a fonctionné pour moi:

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

/// Renvoie vrai si son simulateur et non un appareil

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

Apple a ajouté un support pour vérifier que l'application est ciblée pour le simulateur avec les éléments suivants:

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

si rien ne fonctionne, essayez ceci

public struct Platform {

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

}

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

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

est la meilleure réponse car elle est évidemment exécutée au RUNTIME par rapport à une DIRECTIVE DE COMPILATION.

Cela a fonctionné le mieux pour moi

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


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

}