Como a pergunta indica, eu gostaria principalmente de saber se meu código está sendo executado no simulador, mas também estaria interessado em saber a versão específica do iphone que está sendo executada ou simulada.

EDIT: eu adicionei a palavra 'programaticamente' ao nome da pergunta. O objetivo da minha pergunta é ser capaz de incluir / excluir código dinamicamente, dependendo da versão / simulador em execução, então eu realmente procuraria algo como uma diretiva de pré-processador que possa me fornecer essas informações.

Já perguntei, mas com um título muito diferente.

Quais #defines são configuradas pelo Xcode ao compilar para o iPhone

Vou repetir minha resposta a partir daí:

Está nos documentos do SDK em "Compilando código-fonte condicionalmente"

A definição relevante é TARGET_OS_SIMULATOR, definida em /usr/include/TargetConditionals.h na estrutura do iOS. Nas versões anteriores do conjunto de ferramentas, era necessário escrever:

#include "TargetConditionals.h"

mas isso não é mais necessário na cadeia de ferramentas atual (Xcode 6 / iOS8).

Então, por exemplo, se você quiser verificar se está executando no dispositivo, faça

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

dependendo do que for apropriado para o seu caso de uso.

Código atualizado:

Isto é suposto funcionar oficialmente.

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

Postagem original (desde que descontinuada)

Este código informa se você está executando em um simulador.

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

Não diretiva pré-processador, mas era isso que eu estava procurando quando cheguei a essa pergunta;

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

A melhor maneira de fazer isso é:

#if TARGET_IPHONE_SIMULATOR

e não

#ifdef TARGET_IPHONE_SIMULATOR

desde sempre definido: 0 ou 1

HÁ UMA MANEIRA MELHOR AGORA!

A partir do Xcode 9.3 beta 4, você pode usar #if targetEnvironment(simulator)para verificar.

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

A ATUALIZAÇÃO
Xcode 10 e iOS 12 SDK também suporta isso.

No caso do Swift, podemos implementar os seguintes

Podemos criar struct que permite criar dados estruturados

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

Então, se quiséssemos detectar se o aplicativo está sendo criado para o dispositivo ou simulador no Swift, então.

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

Trabalhos para Swift 5eXcode 11.3.1

Use este código:

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

Todas essas respostas são boas, mas de alguma forma confunde o novato como eu, pois não esclarece a verificação de compilação e a verificação de tempo de execução. O pré-processador está antes do tempo de compilação, mas devemos deixar mais claro

Este artigo do blog mostra Como detectar o simulador do iPhone? claramente

Tempo de execução

Primeiro de tudo, vamos discutir em breve. O UIDevice já fornece informações sobre o dispositivo

[[UIDevice currentDevice] model]

retornará o "iPhone Simulator" ou "iPhone" de acordo com o local em que o aplicativo está sendo executado.

Tempo de compilação

No entanto, o que você deseja é usar o tempo de compilação definido. Por quê? Porque você compila seu aplicativo estritamente para ser executado dentro do Simulador ou no dispositivo. A Apple faz uma definição chamada TARGET_IPHONE_SIMULATOR. Então, vamos olhar o código:

#if TARGET_IPHONE_SIMULATOR

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

#endif

As respostas anteriores são um pouco datadas. Descobri que tudo que você precisa fazer é consultar a TARGET_IPHONE_SIMULATORmacro ( não é necessário incluir outros arquivos de cabeçalho [supondo que você esteja codificando para iOS]).

Tentei, TARGET_OS_IPHONEmas ele retornou o mesmo valor (1) ao executar em um dispositivo e simulador reais, é por isso que recomendo o uso TARGET_IPHONE_SIMULATOR.

Em rápida:

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

Em Detectar se o aplicativo está sendo criado para dispositivo ou simulador no Swift

Eu tive o mesmo problema, ambos TARGET_IPHONE_SIMULATORe TARGET_OS_IPHONEsempre definidos, e definido como 1. A solução de Pete funciona, é claro, mas se você desenvolver algo que não seja intel (improvável, mas quem sabe), aqui está algo seguro como desde que o hardware do iphone não seja alterado (portanto, seu código funcionará sempre para os iphones atualmente disponíveis):

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

Coloque isso em algum lugar conveniente e depois finja que as TARGET_*constantes foram definidas corretamente.

Alguém considerou a resposta fornecida aqui ?

Suponho que o objetivo-c equivalente seria

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

Para Swift 4.2 / xCode 10

Criei uma extensão no UIDevice, para poder facilmente perguntar se o simulador está em execução.

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

No meu AppDelegate, por exemplo, uso esse método para decidir se é necessário o registro para notificação remota, o que não é possível para o simulador.

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

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

Para incluir todos os tipos de "simuladores"

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

Com o Swift 4.2 (Xcode 10), podemos fazer isso

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

Minha resposta é baseada na resposta de Daniel Magnusson e nos comentários de @Nuthatch e @ n.Drake. e escrevo para economizar tempo para usuários rápidos que trabalham no iOS9 em diante.

Isto é o que funcionou para mim:

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

/// Retorna true se seu simulador e não um dispositivo

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

A Apple adicionou suporte para verificar se o aplicativo está direcionado para o simulador com o seguinte:

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

se nada funcionou, tente isso

public struct Platform {

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

}

Na minha opinião, a resposta (apresentada acima e repetida abaixo):

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

é a melhor resposta, pois é obviamente executada em RUNTIME, em vez de ser uma DIRETIVA COMPILE.

Isso funcionou para mim melhor

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


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

}