No Objective-C, podemos saber se um aplicativo está sendo criado para dispositivo ou simulador usando macros:

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

Essas são macros de tempo de compilação e não estão disponíveis no tempo de execução.

Como posso conseguir o mesmo no Swift?

Atualização 30/01/19

Embora essa resposta possa funcionar, a solução recomendada para uma verificação estática (conforme esclarecido por vários engenheiros da Apple) é definir um sinalizador de compilador personalizado direcionado aos simuladores do iOS. Para instruções detalhadas sobre como fazer isso, consulte a resposta de @ mbelsky .

Resposta original

Se você precisar de uma verificação estática (por exemplo, não um tempo de execução, se / else), não poderá detectar o simulador diretamente, mas poderá detectar o iOS em uma arquitetura de desktop, como segue

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

Após a versão Swift 4.1

Uso mais recente, agora diretamente para todos em uma condição, para todos os tipos de simuladores precisam aplicar apenas uma condição -

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

Para mais esclarecimentos, você pode verificar a proposta Swift SE-0190

Para versão mais antiga -

Claramente, isso é falso em um dispositivo, mas retorna verdadeiro para o iOS Simulator, conforme especificado na documentação :

A configuração de construção do arch (i386) retorna verdadeira quando o código é compilado para o simulador iOS de 32 bits.

Se você estiver desenvolvendo para um simulador que não seja o iOS, basta alterar o osparâmetro: por exemplo

Detectar o simulador watchOS

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

Detectar o simulador de tvOS

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

Ou, até, detectar qualquer simulador

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

Se você estiver bem com uma verificação de tempo de execução, poderá inspecionar a TARGET_OS_SIMULATORvariável (ou TARGET_IPHONE_SIMULATORno iOS 8 e abaixo), que é verdadeira em um simulador.

Observe que isso é diferente e um pouco mais limitado do que usar um sinalizador de pré-processador. Por exemplo, você não poderá usá-lo no lugar onde a if/elseé sintaticamente inválido (por exemplo, fora do escopo das funções).

Digamos, por exemplo, que você deseja ter importações diferentes no dispositivo e no simulador. Isso é impossível com uma verificação dinâmica, enquanto que é trivial com uma verificação estática.

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

Além disso, como o sinalizador é substituído por a 0ou a 1pelo pré-processador rápido, se você o usar diretamente em uma if/elseexpressão, o compilador emitirá um aviso sobre código inacessível.

Para contornar esse aviso, consulte uma das outras respostas.

ATUALIZADO PARA SWIFT 4.1. Use em #if targetEnvironment(simulator)vez disso. Fonte

Para detectar o simulador no Swift, você pode usar a configuração de compilação:

• Defina esta configuração -D IOS_SIMULATOR no Swift Compiler - Sinalizadores personalizados> Outros sinalizadores Swift
• Selecione Qualquer SDK do iOS Simulator neste menu suspenso

Agora você pode usar esta declaração para detectar o simulador:

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

Além disso, você pode estender a classe UIDevice:

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

Informações atualizadas a partir de 20 de fevereiro de 2018

Parece que @russbishop tem uma resposta autorizada que a torna "incorreta" - mesmo que pareça funcionar por um longo tempo.

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

Resposta Anterior

Com base na resposta do @ WZW e nos comentários do @ Pang, criei uma estrutura de utilitário simples. Esta solução evita os avisos produzidos pela resposta da @ WZW.

import Foundation

struct Platform {

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

}

Exemplo de uso:

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

Do Xcode 9.3

#if targetEnvironment(simulator)

O Swift suporta uma nova condição de plataforma targetEnvironment com um único simulador de argumento válido. A compilação condicional do formato '#if targetEnvironment (simulator)' agora pode ser usada para detectar quando o destino da compilação é um simulador. O compilador Swift tentará detectar, avisar e sugerir o uso do targetEnvironment (simulador) ao avaliar as condições da plataforma que parecem estar testando indiretamente os ambientes do simulador, por meio das condições existentes da plataforma os () e arch (). (SE-0190)

iOS 9 ou superior:

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

Antes do iOS 9:

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

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

Agora você pode usar targetEnvironment(simulator)como argumento.

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

Atualizado para o Xcode 9.3

Deixe-me esclarecer algumas coisas aqui:

1. TARGET_OS_SIMULATORnão está definido no código Swift em muitos casos; você pode importá-lo acidentalmente devido a um cabeçalho de ponte, mas isso é quebradiço e não é suportado. Também não é possível em estruturas. É por isso que algumas pessoas estão confusas sobre se isso funciona no Swift.
2. Eu desaconselho fortemente o uso da arquitetura como substituto do simulador.

Para executar verificações dinâmicas:

A verificação ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilestá perfeitamente bem.

Você também pode obter o modelo subjacente que está sendo simulado, verificando SIMULATOR_MODEL_IDENTIFIERcomo retornará as strings iPhone10,3.

Para executar verificações estáticas:

Xcode 9.2 e versões anteriores: defina seu próprio sinalizador de compilação Swift (como mostrado em outras respostas).

O Xcode 9.3+ usa a nova condição targetEnvironment:

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

O que funciona para mim desde o Swift 1.0 é procurar uma arquitetura diferente de arm:

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

     //simulator
#else 
     //device

#endif

Tempo de execução, mas mais simples do que a maioria das outras soluções aqui:

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

Como alternativa, você pode simplesmente chamar uma função auxiliar Objective-C que retorna um booleano que usa a macro do pré-processador (especialmente se você já estiver misturando no seu projeto).

Edit: Não é a melhor solução, especialmente a partir do Xcode 9.3. Veja a resposta do HotJard

Nos sistemas modernos:

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

É fácil.

TARGET_IPHONE_SIMULATORfoi descontinuado no iOS 9. TARGET_OS_SIMULATORé a substituição. Também TARGET_OS_EMBEDDEDestá disponível.

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

Espero que esta extensão seja útil.

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

Uso:

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

No Xcode 7.2 (e versões anteriores, mas ainda não testei quanto antes), você pode definir um sinalizador de compilação específico da plataforma "-D TARGET_IPHONE_SIMULATOR" para "Any iOS Simulator".

Procure nas configurações de construção do projeto em "Swift Compiler - Flags do Cliente" e defina o sinalizador em "Other Swift Flags". Você pode definir um sinalizador específico da plataforma clicando no ícone 'mais' quando passar o mouse sobre uma configuração de compilação.

Existem algumas vantagens em fazer isso desta maneira: 1) Você pode usar o mesmo teste condicional ("#if TARGET_IPHONE_SIMULATOR") em seu código Swift e Objective-C. 2) Você pode compilar variáveis ​​que se aplicam apenas a cada build.

Captura de tela das configurações de compilação do Xcode

Tudo descrito aqui 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

Eu usei esse código abaixo no Swift 3

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

Swift 4:

Atualmente, prefiro usar a classe ProcessInfo para saber se o dispositivo é um simulador e que tipo de dispositivo está em uso:

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

Mas, como você sabe, simModelCodenão é um código confortável para entender imediatamente que tipo de simulador foi lançado; portanto, se necessário, você pode tentar ver essa outra resposta do SO para determinar o modelo atual do iPhone / dispositivo e ter uma experiência mais humana. string legível.

Aqui está um exemplo do Xcode 11 Swift baseado na incrível resposta do HotJard acima , que também adiciona um isDeviceBool e usa em SIMULATOR_UDIDvez do nome. As atribuições variáveis ​​são feitas em cada linha, para que você possa examiná-las mais facilmente no depurador, se desejar.

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

Há também a entrada do dicionário DTPlatformNameque deve conter simulator.

Use este código abaixo:

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

Trabalhos para Swift 4eXcode 9.4.1

Xcode 11, Swift 5

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

Além de outras respostas.

No Objective-c, verifique se você incluiu TargetConditionals .

#include <TargetConditionals.h>

antes de usar TARGET_OS_SIMULATOR.