codice aggiornato:

Questo è preteso di lavorare ufficialmente.

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

Post originale (dal deprecato)

Questo codice vi dirà se si esegue in un simulatore.

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

Non pre-processore direttiva, ma questo era quello che cercavo quando sono venuto a questa domanda;

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

Il modo migliore per farlo è:

#if TARGET_IPHONE_SIMULATOR

e non

#ifdef TARGET_IPHONE_SIMULATOR

poiché la sua sempre definito: 0 o 1

In caso di Swift possiamo implementare seguente

Possiamo creare struct che permette di creare un dati strutturati

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

Poi Se volessimo Rilevare se un'applicazione è in costruzione per il dispositivo o un simulatore a Swift poi.

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

Tutti coloro risposta sono buone, ma confonde in qualche modo novizio come me, in quanto non chiarisce controllo compilazione e verifica della fase di esecuzione. Preprocessore sono Prima di compilare il tempo, ma ci dovrebbe rendere più chiaro

Questo articolo del blog mostra Come rilevare il simulatore di iPhone? chiaramente

Runtime

Prima di tutto, cerchiamo di discutere a breve. UIDevice fornisce già informazioni sul dispositivo

[[UIDevice currentDevice] model]

si tornerà “iPhone Simulator” o “iPhone”, secondo cui l'applicazione è in esecuzione.

tempo di compilazione

Tuttavia ciò che si vuole è quella di utilizzare la compilazione definisce il tempo. Perché? Perché si compila la vostra applicazione rigorosamente da eseguire sia all'interno del simulatore o sul dispositivo. Apple fa un define chiamata TARGET_IPHONE_SIMULATOR. Quindi diamo un'occhiata al codice:

#if TARGET_IPHONE_SIMULATOR

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

#endif

C'è un modo meglio ora!

Come di Xcode 9.3 beta 4 è possibile utilizzare #if targetEnvironment(simulator)per controllare.

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

In rapida:

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

Da rilevare se l'applicazione è in fase di costruzione per il dispositivo o un simulatore a Swift

Le risposte precedenti sono un po 'datato. Ho scoperto che tutto quello che dovete fare è interrogare il TARGET_IPHONE_SIMULATORmacro ( non c'è bisogno di includere altri file di intestazione [supponendo che si esegue la codifica per iOS]).

Ho tentato TARGET_OS_IPHONEma è tornato lo stesso valore (1) durante l'esecuzione su un dispositivo reale e simulatore, è per questo che mi consiglia di utilizzare TARGET_IPHONE_SIMULATORinvece.

Ho avuto lo stesso problema, sia TARGET_IPHONE_SIMULATORe TARGET_OS_IPHONEsono sempre definite, e sono impostati a 1. opere di soluzioni di Pete, naturalmente, ma se mai capita di costruire qualcosa di diverso da Intel (improbabile, ma chi lo sa), ecco qualcosa che è sicuro finché l'hardware iPhone non cambia (in modo che il codice funzionerà sempre per gli iPhone attualmente là fuori):

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

Metti che un posto comodo, e poi far finta che le TARGET_*costanti sono state definite in modo corretto.

Per Swift 4.2 / 10 xCode

Ho creato un'estensione su UIDevice, in modo da poter facilmente chiedere se il simulatore è in esecuzione.

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

Nel mio AppDelegate per esempio io uso questo metodo per decidere wether registrazione per la notifica remota è necessario, che non è possibile per il simulatore.

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

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

Opere per Swift 4eXcode 9.4.1

Utilizzare questo codice:

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

Con Swift 4.2 (Xcode 10), siamo in grado di fare questo

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

Qualcuno ha considerato la risposta fornita qui ?

Suppongo che l'Objective-C equivalente sarebbe

+ (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);
    }
}

Per includere tutti i tipi di "simulatori"

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

se niente ha funzionato, provare questo

public struct Platform {

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

}

Apple ha aggiunto il supporto per il controllo della APP è mirato per il simulatore con il seguente:

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

SWIFT 4 Soluzione

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

TARGET_OS_SIMULATORsi trova nel Darwin.TargetConditionals.swiftfile.

/// Restituisce vero se il suo simulatore e non un dispositivo

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

La mia risposta si basa su @ Daniel Magnusson risposte e commenti di @Nuthatch e @ n.Drake. e scrivo a risparmiare un po 'di tempo per gli utenti che lavorano su veloci iOS9 in poi.

Questo è ciò che ha funzionato per me:

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

Questo ha funzionato per me migliore

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


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

}

A mio parere, la risposta (presentata sopra e ripetuto di seguito):

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

è la risposta migliore, perché è ovviamente eseguito in fase di esecuzione contro essere DIRETTIVA compilazione.