ใน Objective-C เรารู้ได้ว่ามีการสร้างแอปสำหรับอุปกรณ์หรือเครื่องมือจำลองโดยใช้มาโครหรือไม่:

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

นี่คือมาโครเวลารวบรวมและไม่สามารถใช้งานได้ในขณะใช้งานจริง

ฉันจะประสบความสำเร็จในสวิฟท์ได้อย่างไร

อัปเดต 30/01/19

ในขณะที่คำตอบนี้อาจใช้งานได้โซลูชันที่แนะนำสำหรับการตรวจสอบแบบคงที่ (ตามที่วิศวกรหลายคนอธิบายไว้) คือการกำหนดธงคอมไพเลอร์ที่กำหนดเองซึ่งกำหนดเป้าหมายไปที่ iOS Simulators สำหรับคำแนะนำรายละเอียดเกี่ยวกับวิธีการทำเพื่อให้ดูคำตอบ @ mbelsky ของ

คำตอบเดิม

หากคุณต้องการตรวจสอบแบบคงที่ (เช่นไม่ใช่รันไทม์หาก / อื่น ๆ ) คุณไม่สามารถตรวจสอบเครื่องมือจำลองได้โดยตรง แต่คุณสามารถตรวจพบ iOS บนสถาปัตยกรรมเดสก์ทอปดังต่อไปนี้

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

หลังจากรุ่นSwift 4.1

การใช้งานล่าสุดตอนนี้โดยตรงสำหรับทุกเงื่อนไขในการจำลองทุกประเภทต้องใช้เพียงหนึ่งเงื่อนไข -

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

หากต้องการคำชี้แจงเพิ่มเติมคุณสามารถตรวจสอบข้อเสนอSwift SE-0190

สำหรับรุ่นเก่า -

เห็นได้ชัดว่านี่เป็นเท็จบนอุปกรณ์ แต่จะคืนค่าจริงสำหรับ iOS Simulator ตามที่ระบุในเอกสารประกอบ :

คอนฟิกูเรชันการบิวด์ arch (i386) จะส่งคืนค่าจริงเมื่อโค้ดถูกคอมไพล์สำหรับเครื่องจำลอง iOS 32 บิต

หากคุณกำลังพัฒนาโปรแกรมจำลองอื่นที่ไม่ใช่ iOS คุณสามารถเปลี่ยนแปลงosพารามิเตอร์ได้เช่น:

ตรวจจับการจำลองwatchOS

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

ตรวจจับโปรแกรมจำลองtvOS

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

หรือแม้แต่ตรวจจับการจำลองใด ๆ

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

หากคุณใช้โอเคกับการตรวจสอบรันไทม์คุณสามารถตรวจสอบTARGET_OS_SIMULATORตัวแปร (หรือTARGET_IPHONE_SIMULATORใน iOS 8 และต่ำกว่า) ซึ่งเป็นความจริงในเครื่องจำลอง

โปรดสังเกตว่าสิ่งนี้แตกต่างและ จำกัด กว่าการใช้แฟล็กตัวประมวลผลก่อนเล็กน้อย ตัวอย่างเช่นคุณจะไม่สามารถใช้งานได้ในสถานที่ที่ a if/elseไม่ถูกต้องทางไวยากรณ์ (เช่นนอกขอบเขตฟังก์ชั่น)

ตัวอย่างเช่นคุณต้องการให้มีการนำเข้าที่แตกต่างกันบนอุปกรณ์และในเครื่องจำลอง นี่เป็นไปไม่ได้ด้วยการตรวจสอบแบบไดนามิกในขณะที่มันเป็นเรื่องเล็กน้อยกับการตรวจสอบแบบคงที่

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

นอกจากนี้เนื่องจากแฟล็กถูกแทนที่ด้วย a 0หรือ a 1โดยตัวประมวลผลก่อน swift หากคุณใช้โดยตรงในif/elseนิพจน์คอมไพเลอร์จะเพิ่มคำเตือนเกี่ยวกับโค้ดที่เข้าไม่ถึง

เพื่อที่จะหลีกเลี่ยงคำเตือนนี้ดูคำตอบอีกข้อหนึ่ง

ล้าสมัยสำหรับ SWIFT 4.1 ใช้#if targetEnvironment(simulator)แทน แหล่ง

ในการตรวจจับโปรแกรมจำลองใน Swift คุณสามารถใช้การกำหนดค่าการสร้าง

• กำหนดการตั้งค่านี้-D IOS_SIMULATORในSwift Compiler - Custom Flags> Swift Flags อื่น ๆ
• เลือกiOS Simulator SDK ใดก็ได้ในดรอปดาวน์นี้

ตอนนี้คุณสามารถใช้คำสั่งนี้เพื่อตรวจจับการจำลอง:

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

นอกจากนี้คุณสามารถขยายคลาส UIDevice:

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

อัปเดตข้อมูล ณ วันที่ 20 กุมภาพันธ์ 2018

ดูเหมือนว่า @russbishop มีคำตอบที่เชื่อถือได้ซึ่งทำให้คำตอบนี้ "ไม่ถูกต้อง" - แม้ว่ามันจะใช้งานได้นาน

ตรวจสอบว่ามีการสร้างแอปสำหรับอุปกรณ์หรือเครื่องมือจำลองใน Swift

คำตอบก่อนหน้า

จากคำตอบของ @ WZW และความคิดเห็นของ @ Pang ฉันได้สร้างโครงสร้างยูทิลิตี้อย่างง่าย วิธีนี้หลีกเลี่ยงคำเตือนที่เกิดจากคำตอบของ @ WZW

import Foundation

struct Platform {

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

}

ตัวอย่างการใช้งาน:

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

จาก Xcode 9.3

#if targetEnvironment(simulator)

Swift สนับสนุนแพลตฟอร์มเงื่อนไข targetEnvironment ใหม่ด้วยการจำลองอาร์กิวเมนต์ที่ถูกต้องเพียงครั้งเดียว การคอมไพล์ตามเงื่อนไขของรูปแบบ '#if targetEnvironment (โปรแกรมจำลอง)' สามารถใช้เพื่อตรวจจับได้เมื่อเป้าหมายการสร้างเป็นเครื่องจำลอง คอมไพเลอร์ Swift จะพยายามตรวจจับเตือนและแนะนำการใช้ targetEnvironment (โปรแกรมจำลอง) เมื่อประเมินสภาพของแพลตฟอร์มที่ดูเหมือนว่าเป็นการทดสอบสภาพแวดล้อมจำลองโดยทางอ้อมผ่านเงื่อนไขแพลตฟอร์ม os () และ arch () ที่มีอยู่ (SE-0190)

iOS 9+:

extension UIDevice {
    static var isSimulator: Bool {
        return NSProcessInfo.processInfo().environment["SIMULATOR_DEVICE_NAME"] != nil
    }
}

สวิฟท์ 3:

extension UIDevice {
    static var isSimulator: Bool {
        return ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nil
    }
}

ก่อน iOS 9:

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

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

สวิฟต์ 4

ตอนนี้คุณสามารถใช้targetEnvironment(simulator)เป็นอาร์กิวเมนต์

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

อัปเดตสำหรับ Xcode 9.3

ให้ฉันอธิบายบางสิ่งที่นี่:

1. TARGET_OS_SIMULATORไม่ได้ตั้งค่าในรหัส Swift ในหลายกรณี คุณอาจได้รับการนำเข้าโดยไม่ได้ตั้งใจเนื่องจากส่วนหัวการเชื่อมโยง แต่มันเปราะและไม่รองรับ นอกจากนี้ยังเป็นไปไม่ได้ในกรอบ นี่คือสาเหตุที่บางคนสับสนว่าการทำงานในสวิฟท์
2. ฉันขอแนะนำอย่างยิ่งให้ไม่ใช้สถาปัตยกรรมแทนตัวจำลอง

วิธีตรวจสอบแบบไดนามิก:

ตรวจสอบProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilได้อย่างสมบูรณ์แบบ

นอกจากนี้คุณยังจะได้รับรูปแบบพื้นฐานที่ถูกจำลองโดยการตรวจสอบซึ่งจะกลับมาเหมือนสตริงSIMULATOR_MODEL_IDENTIFIERiPhone10,3

วิธีตรวจสอบแบบสแตติก:

Xcode 9.2 และรุ่นก่อนหน้า: กำหนดธงการรวบรวม Swift ของคุณเอง (ดังที่แสดงในคำตอบอื่น ๆ )

Xcode 9.3+ ใช้เงื่อนไข targetEnvironment ใหม่:

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

อะไรที่เหมาะกับฉันตั้งแต่ Swift 1.0 กำลังตรวจสอบสถาปัตยกรรมอื่นที่ไม่ใช่แขน:

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

     //simulator
#else 
     //device

#endif

รันไทม์ แต่เรียบง่ายกว่าโซลูชันอื่น ๆ ส่วนใหญ่ที่นี่:

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

หรือคุณสามารถเรียกฟังก์ชันผู้ช่วย Objective-C ที่ส่งคืนบูลีนที่ใช้มาโครตัวประมวลผลก่อน (โดยเฉพาะถ้าคุณผสมอยู่ในโครงการของคุณ)

แก้ไข: ไม่ใช่โซลูชันที่ดีที่สุดโดยเฉพาะอย่างยิ่ง Xcode 9.3 ดูคำตอบของ HotJard

ในระบบที่ทันสมัย:

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

มันเป็นเรื่องง่าย

TARGET_IPHONE_SIMULATORเลิกใช้แล้วใน iOS 9 TARGET_OS_SIMULATORเป็นการทดแทน ยังTARGET_OS_EMBEDDEDสามารถใช้ได้

จาก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 */ 

ฉันหวังว่าส่วนขยายนี้จะมีประโยชน์

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

การใช้งาน:

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

ใน Xcode 7.2 (และก่อนหน้านี้ แต่ฉันยังไม่ได้ทดสอบก่อนหน้านี้เท่าไหร่) คุณสามารถตั้งค่าสถานะการ build เฉพาะแพลตฟอร์ม "-D TARGET_IPHONE_SIMULATOR" สำหรับ "Any iOS Simulator"

ดูในการตั้งค่าการสร้างโครงการภายใต้ "Swift Compiler - Customer Flags" จากนั้นตั้งค่าสถานะใน "Other Swift Flags" คุณสามารถตั้งค่าสถานะเฉพาะแพลตฟอร์มได้โดยคลิกที่ไอคอน 'บวก' เมื่อคุณวางเมาส์เหนือการกำหนดค่าการสร้าง

มีข้อดีสองสามข้อในการทำเช่นนี้: 1) คุณสามารถใช้การทดสอบตามเงื่อนไข ("#if TARGET_IPHONE_SIMULATOR" #) ในรหัส Swift และ Objective-C ของคุณ 2) คุณสามารถรวบรวมตัวแปรที่ใช้กับแต่ละบิลด์เท่านั้น

ภาพหน้าจอการตั้งค่าการสร้าง Xcode

ทั้งหมดอธิบายไว้ที่นี่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

ฉันใช้โค้ดด้านล่างนี้ใน Swift 3

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

สวิฟท์ 4:

ปัจจุบันฉันต้องการใช้คลาสProcessInfoเพื่อทราบว่าอุปกรณ์เป็นอุปกรณ์จำลองและอุปกรณ์ชนิดใดที่ใช้งานอยู่:

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

แต่อย่างที่คุณรู้simModelCodeไม่ใช่รหัสที่สะดวกสบายที่จะเข้าใจในทันทีซึ่งชนิดของการจำลองได้เปิดตัวดังนั้นหากคุณต้องการคุณสามารถลองดูคำตอบอื่น ๆ ของ SO เพื่อพิจารณา iPhone / อุปกรณ์รุ่นปัจจุบันและมีมนุษย์มากขึ้น สตริงที่อ่านได้

นี่คือตัวอย่าง Xcode 11 Swift จากคำตอบที่ยอดเยี่ยมของHotJard ข้างต้นนี่เป็นการเพิ่มisDeviceBool และใช้SIMULATOR_UDIDแทนชื่อ การมอบหมายตัวแปรจะทำในแต่ละบรรทัดเพื่อให้คุณสามารถตรวจสอบได้ง่ายขึ้นในตัวดีบักหากคุณเลือก

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

นอกจากนี้ยังมีรายการในพจนานุกรมของซึ่งควรประกอบด้วยDTPlatformNamesimulator

ใช้รหัสด้านล่างนี้:

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

ทำงานเพื่อSwift 4และXcode 9.4.1

Xcode 11, Swift 5

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

นอกจากคำตอบอื่น ๆ

ใน Objective-C, เพียงให้แน่ใจว่าคุณได้รวมTargetConditionals

#include <TargetConditionals.h>

TARGET_OS_SIMULATORก่อนที่จะใช้