En Objective-C podemos saber si se está creando una aplicación para dispositivo o simulador usando macros:

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

Estas son macros de tiempo de compilación y no están disponibles en tiempo de ejecución.

¿Cómo puedo lograr lo mismo en Swift?

Actualización 30/01/19

Si bien esta respuesta puede funcionar, la solución recomendada para una comprobación estática (como lo aclararon varios ingenieros de Apple) es definir un indicador de compilador personalizado dirigido a los simuladores de iOS. Para obtener instrucciones detalladas sobre cómo hacerlo, consulte la respuesta de @ mbelsky .

Respuesta original

Si necesita una comprobación estática (por ejemplo, no es un tiempo de ejecución si / no) no puede detectar el simulador directamente, pero puede detectar iOS en una arquitectura de escritorio de la siguiente manera

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

Después de la versión Swift 4.1

El último uso, ahora directamente para todo en una condición para todos los tipos de simuladores necesita aplicar solo una condición:

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

Para más aclaraciones, puede consultar la propuesta de Swift SE-0190

Para versión anterior -

Claramente, esto es falso en un dispositivo, pero devuelve verdadero para el Simulador de iOS, como se especifica en la documentación :

La configuración de compilación de arch (i386) vuelve verdadera cuando se compila el código para el simulador de iOS de 32 bits.

Si está desarrollando un simulador que no sea iOS, simplemente puede variar el osparámetro: por ejemplo

Detecta el simulador de watchOS

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

Detecta el simulador de tvOS

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

O, incluso, detectar cualquier simulador

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

Si, en cambio, está de acuerdo con una verificación de tiempo de ejecución, puede inspeccionar la TARGET_OS_SIMULATORvariable (o TARGET_IPHONE_SIMULATORen iOS 8 y versiones posteriores), lo cual es cierto en un simulador.

Tenga en cuenta que esto es diferente y un poco más limitado que usar un indicador de preprocesador. Por ejemplo, no podrá usarlo en el lugar donde a if/elsees sintácticamente inválido (por ejemplo, fuera de los ámbitos de funciones).

Digamos, por ejemplo, que desea tener diferentes importaciones en el dispositivo y en el simulador. Esto es imposible con una verificación dinámica, mientras que es trivial con una verificación estática.

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

Además, dado que el indicador es reemplazado por a 0o a 1por el preprocesador rápido, si lo usa directamente en una if/elseexpresión, el compilador generará una advertencia sobre el código inalcanzable.

Para evitar esta advertencia, consulte una de las otras respuestas.

ACTUALIZADO PARA SWIFT 4.1. Usar en su #if targetEnvironment(simulator)lugar. Fuente

Para detectar el simulador en Swift, puede usar la configuración de compilación:

• Defina esta configuración -D IOS_SIMULATOR en el compilador Swift - Banderas personalizadas> Otras banderas Swift
• Seleccione Any iOS Simulator SDK en este menú desplegable

Ahora podría usar esta declaración para detectar el simulador:

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

También podría extender la clase UIDevice:

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

Información actualizada al 20 de febrero de 2018

Parece que @russbishop tiene una respuesta autorizada que hace que esta respuesta sea "incorrecta", a pesar de que pareció funcionar durante mucho tiempo.

Detecta si la aplicación se está creando para dispositivo o simulador en Swift

Respuesta anterior

Basado en la respuesta de @ WZW y los comentarios de @ Pang, creé una estructura de utilidad simple. Esta solución evita la advertencia producida por la respuesta de @ WZW.

import Foundation

struct Platform {

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

}

Ejemplo de uso:

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

Desde Xcode 9.3

#if targetEnvironment(simulator)

Swift admite una nueva condición de plataforma targetEnvironment con un único simulador de argumento válido. La compilación condicional de la forma '#if targetEnvironment (simulator)' ahora se puede usar para detectar cuándo el target de compilación es un simulador. El compilador Swift intentará detectar, advertir y sugerir el uso de TargetEnvironment (simulador) al evaluar las condiciones de la plataforma que parecen estar probando los entornos del simulador indirectamente, a través de las condiciones existentes de la plataforma os () y arch (). (SE-0190)

iOS 9+:

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 de iOS 9:

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

C objetivo:

@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

Ahora puede usarlo targetEnvironment(simulator)como argumento.

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

Actualizado para Xcode 9.3

Permítanme aclarar algunas cosas aquí:

1. TARGET_OS_SIMULATORno se establece en el código Swift en muchos casos; es posible que lo haya importado accidentalmente debido a un encabezado de puente, pero esto es frágil y no es compatible. Tampoco es posible en frameworks. Es por eso que algunas personas están confundidas acerca de si esto funciona en Swift.
2. Recomiendo encarecidamente no utilizar la arquitectura como sustituto del simulador.

Para realizar comprobaciones dinámicas:

La comprobación ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilestá perfectamente bien.

También puede obtener el modelo subyacente que se está simulando al verificar SIMULATOR_MODEL_IDENTIFIERqué devolverá cadenas como iPhone10,3.

Para realizar comprobaciones estáticas:

Xcode 9.2 y anteriores: defina su propio indicador de compilación Swift (como se muestra en otras respuestas).

Xcode 9.3+ usa la nueva condición targetEnvironment:

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

Lo que funciona para mí desde Swift 1.0 es buscar una arquitectura que no sea arm:

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

     //simulator
#else 
     //device

#endif

Tiempo de ejecución, pero más simple que la mayoría de las otras soluciones aquí:

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

Alternativamente, puede llamar a una función auxiliar Objective-C que devuelve un valor booleano que usa la macro del preprocesador (especialmente si ya está mezclando en su proyecto).

Editar: no es la mejor solución, especialmente a partir de Xcode 9.3. Ver la respuesta de HotJard

En sistemas modernos:

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

Es muy fácil.

TARGET_IPHONE_SIMULATORestá en desuso en iOS 9. TARGET_OS_SIMULATORes el reemplazo. También TARGET_OS_EMBEDDEDestá disponible

Desde 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 extensión sea útil.

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

Uso:

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

En Xcode 7.2 (y anteriores, pero no he probado cuánto antes), puede establecer un indicador de compilación específico de plataforma "-D TARGET_IPHONE_SIMULATOR" para "Any iOS Simulator".

Busque en la configuración de compilación del proyecto en "Compilador Swift - Indicadores del cliente" y luego establezca el indicador en "Otros indicadores Swift". Puede establecer un indicador específico de plataforma haciendo clic en el ícono 'más' cuando pasa el mouse sobre una configuración de compilación.

Hay un par de ventajas de hacerlo de esta manera: 1) Puede usar la misma prueba condicional ("#if TARGET_IPHONE_SIMULATOR") en su código Swift y Objective-C. 2) Puede compilar variables que solo se aplican a cada compilación.

Captura de pantalla de configuración de compilación de Xcode

Todo descrito aquí 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

Usé este código a continuación en Swift 3

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

Swift 4:

Actualmente, prefiero usar la clase ProcessInfo para saber si el dispositivo es un simulador y qué tipo de dispositivo está en uso:

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

Pero, como saben, simModelCodeno es un código cómodo para comprender de inmediato qué tipo de simulador se lanzó, por lo que, si es necesario, puede intentar ver esta otra respuesta SO para determinar el modelo actual de iPhone / dispositivo y tener un humano más cadena legible.

Aquí hay un ejemplo de Xcode 11 Swift basado en la increíble respuesta de HotJard anterior , esto también agrega un isDeviceBool y usa en SIMULATOR_UDIDlugar de nombre. Las asignaciones variables se realizan en cada línea para que pueda examinarlas más fácilmente en el depurador si lo desea.

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

También existe la entrada del diccionario DTPlatformNameque debe contener simulator.

Use este código a continuación:

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

Trabaja para Swift 4yXcode 9.4.1

Xcode 11, Swift 5

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

Además de otras respuestas.

En Objective-c, solo asegúrese de incluir TargetConditionals .

#include <TargetConditionals.h>

antes de usar TARGET_OS_SIMULATOR.