277

ऑब्जेक्टिव-सी में हम जान सकते हैं कि मैक्रो का उपयोग करके डिवाइस या सिम्युलेटर के लिए कोई ऐप बनाया जा रहा है या नहीं:

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

ये संकलन समय मैक्रो हैं और रनटाइम पर उपलब्ध नहीं हैं।

मैं स्विफ्ट में समान कैसे प्राप्त कर सकता हूं?

ios swift

— RaffAl
स्रोत

2

यह उद्देश्य-सी में रनटाइम पर सिम्युलेटर या एक वास्तविक डिवाइस का पता लगाने का तरीका नहीं है। वे कंपाइलर निर्देश हैं जो बिल्ड के आधार पर विभिन्न कोड में परिणाम करते हैं।

— आराध्य

धन्यवाद। मैंने अपना प्रश्न संपादित किया।

— राफेल

9

सबसे ऊंचे मत वाले उम्मीदवार इस समस्या को हल करने के लिए सर्वश्रेष्ठ नहीं हैं! mbelsky का जवाब (वर्तमान में बहुत नीचे है) एकमात्र समाधान है जो बिना किसी नुकसान के आता है। यहां तक कि Apple से ग्रेग पार्कर ने इसे इस तरह से करने का सुझाव दिया: lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160125/…

— jan.vogt

1

अंक में, यह ऐसा करने के लिए सबसे महत्वपूर्ण है कि एक समय सीमा के साथ कुछ भी गलत है। Apple इंजीनियरों के सुझाव अक्सर खराब-सोचा हुआ कचरा होते हैं, या केवल कुछ स्थितियों में लागू होते हैं, ताकि इनसाइड का मतलब किसी भी चीज़ से कम न हो।

— फेटी

1

@ फैटी: यह जानना दिलचस्प होगा कि दिए गए जवाबों में से कोई भी आपकी आवश्यकताओं को पूरा नहीं करता है, और आप इनाम की पेशकश करके क्या उम्मीद कर रहे हैं।

— मार्टिन आर

363

अपडेट 30/01/19

हालांकि यह जवाब काम कर सकता है, स्थिर जांच के लिए अनुशंसित समाधान (जैसा कि कई Apple इंजीनियरों द्वारा स्पष्ट किया गया है) iOS सिमलेटर को लक्षित करने वाले एक कस्टम कंपाइलर ध्वज को परिभाषित करना है। यह कैसे करना है पर विस्तृत निर्देशों के लिए, @ mbelsky का उत्तर देखें ।

मूल उत्तर

यदि आपको एक स्थिर जांच की आवश्यकता है (जैसे कि रनटाइम नहीं तो / और) आप सीधे सिम्युलेटर का पता नहीं लगा सकते हैं, लेकिन आप एक डेस्कटॉप आर्किटेक्चर पर आईओएस का पता लगा सकते हैं जैसे कि

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

स्विफ्ट 4.1 संस्करण के बाद

नवीनतम उपयोग, अब सभी प्रकार के सिमुलेटर के लिए सीधे एक ही स्थिति में सभी को केवल एक शर्त लागू करने की आवश्यकता है -

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

अधिक स्पष्टीकरण के लिए, आप स्विफ्ट प्रस्ताव SE-0190 की जांच कर सकते हैं

पुराने संस्करण के लिए -

स्पष्ट रूप से, यह एक डिवाइस पर गलत है, लेकिन यह iOS सिम्युलेटर के लिए सही है, जैसा कि प्रलेखन में निर्दिष्ट है :

जब 32-बिट iOS सिम्युलेटर के लिए कोड संकलित किया जाता है तो आर्क (i386) कॉन्फ़िगरेशन रिटर्न बनाता है।

यदि आप iOS के अलावा किसी अन्य सिम्युलेटर के लिए विकसित कर रहे हैं, तो आप बस osपैरामीटर को भिन्न कर सकते हैं : उदा

वॉचओएस सिम्युलेटर का पता लगाएं

#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_SIMULATORiOS 8 और नीचे) में निरीक्षण कर सकते हैं , जो एक सिम्युलेटर पर सत्य है।

कृपया ध्यान दें कि यह प्रीप्रोसेसर फ्लैग का उपयोग करने की तुलना में अलग और थोड़ा अधिक सीमित है। उदाहरण के लिए, आप इसे उस स्थान पर उपयोग करने में सक्षम नहीं होंगे जहां एक if/elseवाक्यविन्यास रूप से अमान्य है (जैसे फ़ंक्शंस स्कोप के बाहर)।

उदाहरण के लिए, कहें कि आप डिवाइस और सिम्युलेटर पर अलग-अलग आयात करना चाहते हैं। यह एक डायनामिक चेक के साथ असंभव है, जबकि यह एक स्थैतिक चेक के साथ तुच्छ है।

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

इसके अलावा, चूंकि ध्वज को स्विपर प्रीप्रोसेसर द्वारा 0या उसके साथ बदल दिया 1जाता है, यदि आप सीधे if/elseअभिव्यक्ति में इसका उपयोग करते हैं तो संकलक अगम्य कोड के बारे में चेतावनी देगा।

इस चेतावनी के आसपास काम करने के लिए, अन्य उत्तरों में से एक देखें।

— गेब्रियल पेट्रोनेला
स्रोत

1

यहाँ और अधिक पढ़ने । और भी अधिक प्रतिबंधक होने के लिए, आप उपयोग कर सकते हैं arch(i386) && os(iOS)।

— अहरुश

1

इसने मेरे लिए काम नहीं किया। मुझे

— 203 बजे

3

इस उत्तर के लिए इस समस्या को हल करने के लिए सबसे अच्छा तरीका नहीं है! mbelsky का जवाब (वर्तमान में बहुत नीचे है) एकमात्र समाधान है जो बिना किसी नुकसान के आता है। यहां तक कि Apple के ग्रेग पार्कर ने इसे इस तरह से करने का सुझाव दिया: lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160125/…

— jan.vogt

2

@russbishop यह एक लापता एपीआई के लिए क्षतिपूर्ति करने के लिए अब तक सैकड़ों लोगों के लिए सहायक सलाह साबित हुआ। शीर्ष पर एक टिप्पणी पर हस्ताक्षर करके उत्तर को अपहरण करने के बजाय, बस संवाद करें। मैंने यह स्पष्ट करने के लिए जवाब अपडेट किया कि यह अब अप-टू-डेट समाधान नहीं है और मैंने उस पर एक लिंक प्रदान किया है जो अधिक सही दिखता है।

— गेब्रियल पेट्रोनेला

9

स्विफ्ट 4.1 में, आप कहने में सक्षम होंगे #if targetEnvironment(simulator):) ( github.com/apple/swift-evolution/blob/master/proposals/… )

— Hamish

172

स्विफ्ट 4.1 के लिए आवश्यक। #if targetEnvironment(simulator)इसके बजाय उपयोग करें । स्रोत

स्विफ्ट में सिम्युलेटर का पता लगाने के लिए आप बिल्ड कॉन्फ़िगरेशन का उपयोग कर सकते हैं:

स्विफ्ट कंपाइलर में इस विन्यास -D IOS_SIMULATOR को परिभाषित करें - कस्टम झंडे> अन्य स्विफ्ट झंडे
इस ड्रॉप डाउन में किसी भी आईओएस सिम्युलेटर एसडीके का चयन करें

अब आप सिम्युलेटर का पता लगाने के लिए इस कथन का उपयोग कर सकते हैं:

#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

— mbelsky
स्रोत

8

यह सबसे अच्छा जवाब होना चाहिए! यहां तक कि Apple से ग्रेग पार्कर ने सुझाव दिया: lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160125/…

— jan.vogt

1

स्विफ्ट 3 के लिए उपयोग अपडेट: UIDevice.current.isSimulator

— tylernol

1

क्या मैं पूछ सकता हूं कि अगर मैं इसे रिलीज के तहत जोड़ता हूं तो यह काम नहीं करता है?

— विलियम हू

3

यह एकमात्र सही उत्तर है। आप इसे xcconfigफ़ाइलों में सेट अप करके OTHER_SWIFT_FLAGS = TARGET_OS_EMBEDDEDऔर OTHER_SWIFT_FLAGS[sdk=embeddedsimulator*] = TARGET_OS_SIMULATORसिम्युलेटर के लिए ओवरराइड करने के लिए भी कर सकते हैं ।

— रुसबिशप

1

Xcode 9.2 पर, यह उत्तर कुछ समय संकलन करने में विफल रहा। "डी" से पहले "-" को हटाने से मेरे लिए समस्या हल हो गई।

— ब्लेक

160

अपडेट की गई जानकारी 20 फरवरी, 2018 तक

ऐसा लगता है कि @russbishop के पास एक आधिकारिक उत्तर है जो इस उत्तर को "गलत" प्रदान करता है - भले ही वह लंबे समय तक काम करता दिखाई दे।

पता लगाएं कि क्या स्विफ्ट में डिवाइस या सिम्युलेटर के लिए ऐप बनाया जा रहा है

पिछला उत्तर

@ WZW के जवाब और @ पैंग की टिप्पणियों के आधार पर, मैंने एक साधारण उपयोगिता संरचना बनाई। यह समाधान @ WZW के उत्तर द्वारा निर्मित चेतावनी से बचा जाता है।

import Foundation

struct Platform {

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

}

उदाहरण का उपयोग:

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

— डैनियल
स्रोत

10

स्वीकार किए जाते हैं की तुलना में बेहतर समाधान। वास्तव में अगर किसी दिन (भले ही इसकी संभावना बहुत कम हो) Apple iOS उपकरणों पर i386 या x85_64 का उपयोग करने का निर्णय लेता है, तो स्वीकृत उत्तर काम नहीं करेगा ... या फिर भी अगर डेस्कटॉप कंप्यूटरों को एक नया प्रूफ़ मिलता है!

— फ्रेज़लाब

2

पुष्टि की कि यह पूरी तरह से Xcode 7 पर काम करता है: public let IS_SIMULATOR = (TARGET_OS_SIMULATOR != 0)... एक ही बात, सरलीकृत। +1 धन्यवाद

— डैन रोसेनस्टार्क

1

@daniel यह अच्छी तरह से काम करता है और यह वास्तव में मेरे समाधान से अधिक सीधा है। हालांकि यह ध्यान देने योग्य है कि यह वास्तविक प्रीप्रोसेसर कदम से अधिक सीमित है। यदि आपको लक्ष्य में शामिल नहीं किए जाने वाले कोड के कुछ हिस्से की आवश्यकता है (जैसे आप संकलन समय पर दो आयातों के बीच चयन करना चाहते हैं), तो आपको एक स्थिर चेक का उपयोग करना होगा। मैंने इस अंतर को उजागर करने के लिए अपना उत्तर संपादित किया है।

— गैब्रियल पेट्रोनेला

इस उत्तर के लिए इस समस्या को हल करने के लिए सबसे अच्छा तरीका नहीं है! mbelsky का जवाब (वर्तमान में बहुत नीचे है) एकमात्र समाधान है जो बिना किसी नुकसान के आता है। यहां तक कि Apple के ग्रेग पार्कर ने इसे इस तरह से करने का सुझाव दिया: lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160125/…

— jan.vogt

2

@Fattie TARGET_OS_SIMULATOR != 0है पहले से ही जवाब में । यह डेनियल द्वारा दिया गया समाधान है। एक मुफ्त चर में इसे फिर से जोड़ने की कोई आवश्यकता नहीं है, यह पहले से ही है। अगर आपको लगता है कि यह एक संरचना में होना बुरा है और एक मुक्त चर में होना बेहतर है तो इस बारे में एक टिप्पणी पोस्ट करें या अपना जवाब दें। धन्यवाद।

— एरिक आया

69

Xcode 9.3 से

#if targetEnvironment(simulator)

स्विफ्ट एक एकल मान्य तर्क सिम्युलेटर के साथ एक नया प्लेटफ़ॉर्म कंडीशन टारगेटइनवर्जन का समर्थन करता है। फॉर्म का सशर्त संकलन '# लक्ष्य लक्ष्यीकरण (सिम्युलेटर)' का उपयोग अब यह पता लगाने के लिए किया जा सकता है कि निर्माण लक्ष्य एक सिम्युलेटर है। स्विफ्ट कंपाइलर मौजूदा ओएस () और आर्च () और प्लेटफ़ॉर्म स्थितियों के माध्यम से अप्रत्यक्ष रूप से सिम्युलेटर वातावरण के परीक्षण के लिए दिखाई देने वाली प्लेटफ़ॉर्म स्थितियों का मूल्यांकन करते समय टारगेटनिवर्सन (सिम्युलेटर) के उपयोग का पता लगाने, चेतावनी देने और सुझाव देने का प्रयास करेगा। (एसई 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"
    }
}

उद्देश्य सी:

@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

— HotJard
स्रोत

2

तार की तुलना अधिक नाजुक है जो परिभाषित स्थिरांक का उपयोग कर रही है।

— माइकल पीटरसन

@ P1X3L5 आप सही हैं! लेकिन मुझे लगता है कि इस विधि को डिबग मोड में कहा जाता है - यह इतना ठोस नहीं हो सकता है, लेकिन एक परियोजना में जोड़ने के लिए जल्दी है

— HotJard

1

@GantMan प्रतिक्रिया के लिए धन्यवाद। मैंने कोड तय कर दिया है

— HotJard

@HotJard अच्छा है, यह will never be executedचेतावनी का उत्पादन नहीं करता है

— Dannie P

59

स्विफ्ट 4

अब आप targetEnvironment(simulator)एक तर्क के रूप में उपयोग कर सकते हैं ।

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

Xcode 9.3 के लिए अपडेट किया गया

— मैट स्विफ्ट
स्रोत

8

यह अब स्वीकृत उत्तर होना चाहिए। काश, OS / प्रोग्रामिंग भाषाओं के अपडेट के आधार पर एक नए सुझाए गए उत्तर का प्रस्ताव करने के लिए SO पर एक तरीका होता।

— quemeful

4

यह एक महान बिंदु @quemeful है - यह एसओ की कुछ बुनियादी विफलताओं में से एक है। चूंकि कंप्यूटिंग सिस्टम इतनी जल्दी बदलते हैं, इसलिए एसओ का लगभग हर उत्तर समय के साथ गलत हो जाता है ।

— फेटी

40

मुझे यहाँ कुछ बातें स्पष्ट करें:

TARGET_OS_SIMULATORकई मामलों में स्विफ्ट कोड में सेट नहीं है; आप गलती से इसे ब्रिजिंग हेडर के कारण आयात कर रहे होंगे लेकिन यह भंगुर है और समर्थित नहीं है। यह चौखटे में भी संभव नहीं है। यही कारण है कि कुछ लोग उलझन में हैं कि क्या यह स्विफ्ट में काम करता है।
मैं सिम्युलेटर के विकल्प के रूप में वास्तुकला का उपयोग करने के खिलाफ दृढ़ता से सलाह देता हूं।

गतिशील जाँच करने के लिए:

जाँच ProcessInfo.processInfo.environment["SIMULATOR_DEVICE_NAME"] != nilपूरी तरह से ठीक है।

आप अंतर्निहित मॉडल को भी जाँच कर नकली बना SIMULATOR_MODEL_IDENTIFIERसकते हैं जो स्ट्रिंग को लौटा देगा iPhone10,3।

स्थिर जाँच करने के लिए:

Xcode 9.2 और पूर्ववर्ती: अपने स्वयं के स्विफ्ट संकलन ध्वज को परिभाषित करें (जैसा कि अन्य उत्तरों में दिखाया गया है)।

Xcode 9.3+ नई लक्ष्यनिरीक्षण स्थिति का उपयोग करें:

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

— russbishop
स्रोत

1

ऐसा लगता है कि आपके पास यहां कुछ नई जानकारी है। बहुत मददगार! नोट TARGET_OS_SIMULATOR ने ऐप और फ्रेमवर्क कोड दोनों में काफी समय तक काम किया; और यह Xcode 9.3 b3 में भी काम कर रहा है। लेकिन, मुझे लगता है कि यह "आकस्मिक" है। एक बुमेर की तरह; क्योंकि यह कम से कम हैक करने का तरीका लगता है। फ्रेमवर्क कोड के एक प्रदाता के रूप में जिसे Xcode 9.3 या उससे पहले संकलित किया जा सकता है, ऐसा लगता है कि कंपाइलर त्रुटियों से बचने के लिए हमें #if targetEnvironment ... #if स्विफ्ट (> = 4.1) मैक्रो में लपेटना होगा। या मुझे लगता है कि उपयोग .... पर्यावरण ["SIMULATOR_DEVICE_NAME"]! = Nil। यह जांच अधिक हैमी, IMO लगती है।

— डैनियल

अगर "अनपेक्षित प्लेटफ़ॉर्म कंडीशन (अपेक्षित 'ओएस', 'आर्क', या 'स्विफ्ट')" टारगेटइन्वायरमेंट (सिम्युलेटर) का उपयोग कर त्रुटि है

— Zaporozhchenko ऑलेक्ज़ेंडर

@Aleksandr targetEnvironmentXcode 9.3 में उतरा। आपको Xcode का एक नया संस्करण चाहिए।

— रुसबिशप

@russbishop अच्छा काम यह नवीनतम नए युग के लिए समाशोधन - धन्यवाद!

— फेटी

मैंने एक 250 इनाम भेजा, क्योंकि यह उत्तर सबसे नई और नई जानकारी जोड़ने के लिए लगता है - चीयर्स

— फेटी

15

स्विफ्ट 1.0 के बाद से मेरे लिए क्या काम करता है?

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

     //simulator
#else 
     //device

#endif

— akaru
स्रोत

14

रनटाइम, लेकिन यहाँ अन्य समाधानों की तुलना में अधिक सरल:

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

वैकल्पिक रूप से, आप बस एक उद्देश्य-सी सहायक फ़ंक्शन को कॉल कर सकते हैं जो एक बूलियन देता है जो प्रीप्रोसेसर मैक्रो का उपयोग करता है (खासकर यदि आप पहले से ही अपने प्रोजेक्ट में मिश्रण कर रहे हैं)।

संपादित करें: सबसे अच्छा समाधान नहीं, विशेष रूप से Xcode 9.3 के रूप में। देखिए हॉटजार्ड का जवाब

— परत
स्रोत

3

मैं ऐसा करता हूं, लेकिन दूसरे खंड में चेतावनी मिलती है क्योंकि यह "कभी निष्पादित नहीं होगा"। हमारे पास एक शून्य चेतावनी नियम है, इसलिए :-(

— एरिकस

यह एक चेतावनी दिखाई देगा, लेकिन यह समझ में आता है, निर्भर करता है अगर तुम निर्माण के लिए चयनित सिम्युलेटर या डिवाइस है, चेतावनी बात यह है कि क्रियान्वित किया जा नहीं होते पर दिखाई देगा, लेकिन हाँ एक शून्य चेतावनी नीति के लिए कष्टप्रद

— Fonix

1

केवल जब मैं उपयोग के == 0बजाय चेतावनी देख रहा हूँ != 0। यह का उपयोग करते हुए, जैसा कि ऊपर लिखा है, यहां तक कि एक साथ elseके बाद ब्लॉक, स्विफ्ट 4 Xcode संस्करण 9.2 (9C40b) में कोई चेतावनी का उत्पादन नहीं करता

— शिम

इसके अलावा मैंने इसे एक सिम्युलेटर लक्ष्य के साथ-साथ एक भौतिक उपकरण पर चलाने का परीक्षण किया। साथ ही स्विफ्ट 3.2 (एक्सकोड संस्करण) में भी ऐसा ही प्रतीत होता है।

— शिम

Xcode 9.3 + स्विफ्ट 4.1 में मैंने सिर्फ यह देखा कि इसके साथ चेतावनी भी है! = 0। शीश।

— shim

10

आधुनिक प्रणालियों में:

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

यह आसान है।

— fattie
स्रोत

1

यह निश्चित नहीं है कि डैनियल के उत्तर की तुलना में पहले वाले को "अधिक सही" क्यों होना चाहिए । - नोट दूसरा एक है कि है एक संकलन समय की जांच। नववर्ष की शुभकामना!

— मार्टिन आर

5

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

— नाटहेच
स्रोत

1

मैंने TARGET_OS_SIMULATOR की कोशिश की, लेकिन काम नहीं करता है या Xcode द्वारा मान्यता प्राप्त नहीं है, जबकि TARGET_IPHONE_SIMULATOR करता है। मैं ऊपर iOS 8.0 के लिए निर्माण कर रहा हूं।

— कोडओवरराइड

मैं iOS 9 हेडर देख रहा हूं। मैं अपना जवाब अपडेट करूंगा।

— न्यूटच

5

मुझे उम्मीद है कि यह विस्तार काम आएगा।

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

उपयोग:

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

— लुकास च्वे
स्रोत

@ चेतनकॉली, मैं शॉर्ट के बजाय कोड को बहुत स्पष्ट करने जा रहा था, इसलिए किसी के लिए भी इसे समझना आसान है। मुझे यकीन नहीं है कि मैं आपके संपादन के बारे में कैसा महसूस कर रहा हूं।

— लुकास च्वे

3

Xcode 7.2 में (और पहले का लेकिन मैंने कितना परीक्षण नहीं किया है), आप "किसी भी iOS सिम्युलेटर" के लिए एक मंच विशिष्ट बिल्ड फ्लैग "-D TARGET_IPHONE_SIMULATOR" सेट कर सकते हैं।

"स्विफ्ट कंपाइलर - कस्टमर फ्लैग्स" के तहत प्रोजेक्ट बिल्ड सेटिंग्स में देखें और फिर "अन्य स्विफ्ट फ्लैग्स" में फ्लैग सेट करें। जब आप बिल्ड कॉन्फ़िगरेशन पर हॉवर करते हैं, तो आप 'प्लस' आइकन पर क्लिक करके एक मंच विशिष्ट ध्वज सेट कर सकते हैं।

इस तरह से करने के कुछ फायदे हैं: 1) आप अपने स्विफ्ट और ऑब्जेक्टिव-सी कोड में समान सशर्त परीक्षण ("#if TARGET_IPHONE_SIMULATOR") का उपयोग कर सकते हैं। 2) आप उन चर को संकलित कर सकते हैं जो केवल प्रत्येक बिल्ड पर लागू होते हैं।

Xcode बिल्ड सेटिंग्स स्क्रीनशॉट

— xgerrit
स्रोत

2

यहाँ सभी का वर्णन डार्विन.टार्गेटकॉन्डिशनल्स : https://github.com/apple/swift-corelibs-foundation/blob/master/CoreFoundation/Base.subproj/Swiftcuntime/TargetConditionals.h

TARGET_OS_SIMULATOR - Generated code will run under a simulator

— dimpiax
स्रोत

1

मैंने स्विफ्ट 3 में इस नीचे दिए गए कोड का उपयोग किया है

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

— ak_ninan
स्रोत

1

मैं ऐसा करता हूं, लेकिन दूसरे खंड में चेतावनी मिलती है क्योंकि यह "कभी निष्पादित नहीं होगा"। हमारे पास एक शून्य चेतावनी का नियम है, इसलिए

— गंभीर

यह एक चेतावनी दिखाएगा जब भी आप एक उपकरण के साथ चलने की कोशिश कर रहे हैं, अगर आपको चलाने के लिए चयनित सिम्युलेटर हैं तो यह चेतावनी नहीं दिखाएगा।

— ak_ninan

1

यह पदावनत है

— rcmstark

1

स्विफ्ट 4:

वर्तमान में, मैं यह जानने के लिए ProcessInfo वर्ग का उपयोग करना पसंद करता हूं कि क्या डिवाइस एक सिम्युलेटर है और किस तरह का डिवाइस उपयोग में है:

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

लेकिन, जैसा कि आप जानते हैं, simModelCodeतुरंत समझने के लिए एक आरामदायक कोड नहीं है कि किस तरह का सिम्युलेटर लॉन्च किया गया था, अगर आपकी ज़रूरत है, तो आप वर्तमान iPhone / डिवाइस मॉडल का निर्धारण करने के लिए और अधिक मानव होने के लिए इस अन्य SO उत्तर को देखने का प्रयास कर सकते हैं पढ़ने योग्य तार।

— एलेसेंड्रो ओरानो
स्रोत

1

यहां हॉटजार्ड के ऊपर दिए गए भयानक जवाब के आधार पर एक Xcode 11 स्विफ्ट उदाहरण है , यह एक बूल भी जोड़ता है isDeviceऔर 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
    }
}

इसमें डिक्शनरी की प्रविष्टि भी है DTPlatformNameजिसमें होना चाहिए simulator।

— एलेक्स ज़ावाटोन
स्रोत

0

इस कोड का उपयोग करें:

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

Swift 4और के लिए काम करता हैXcode 9.4.1

— हेरोल्डो गोंडिम
स्रोत

0

Xcode 11, स्विफ्ट 5

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

— UnchartedWorks
स्रोत

0

अन्य उत्तरों के अलावा।

ऑब्जेक्टिव-सी में, बस सुनिश्चित करें कि आपने टारगेटकंडिशनल्स को शामिल किया है ।

#include <TargetConditionals.h>

उपयोग करने से पहले TARGET_OS_SIMULATOR।

— एम। अली
स्रोत

अगर स्विफ्ट में डिवाइस या सिम्युलेटर के लिए ऐप बनाया जा रहा है तो कैसे पता करें

अपडेट 30/01/19

मूल उत्तर

स्विफ्ट 4

स्विफ्ट 4: