ios - आईओएस संस्करण कैसे जांचें?




objective-c (20)

पसंदीदा दृष्टिकोण

स्विफ्ट 2.0 में ऐप्पल ने एक बहुत अधिक सुविधाजनक वाक्यविन्यास का उपयोग करके उपलब्धता जांच को जोड़ा ( here और पढ़ें)। अब आप एक क्लीनर सिंटैक्स के साथ ओएस संस्करण की जांच कर सकते हैं:

if #available(iOS 9, *) {
    // Then we are on iOS 9
} else {
    // iOS 8 or earlier
}

respondsToSelector लिए यह पसंदीदा पसंद है respondsToSelector आदि ( स्विफ्ट में नया क्या है )। अब संकलक हमेशा आपको चेतावनी देगा यदि आप अपने कोड को सही तरीके से सुरक्षित नहीं कर रहे हैं।

प्री स्विफ्ट 2.0

आईओएस 8 में नया NSProcessInfo बेहतर अर्थपूर्ण संस्करण जांच के लिए अनुमति देता है।

आईओएस 8 और अधिक पर तैनाती

आईओएस 8.0 या उसके बाद के न्यूनतम तैनाती लक्ष्यों के लिए , NSProcessInfo operatingSystemVersion NSProcessInfo operatingSystemVersion या isOperatingSystemAtLeastVersion उपयोग करें।

यह निम्नलिखित उत्पन्न करेगा:

let minimumVersion = NSOperatingSystemVersion(majorVersion: 8, minorVersion: 1, patchVersion: 2)
if NSProcessInfo().isOperatingSystemAtLeastVersion(minimumVersion) {
    //current version is >= (8.1.2)
} else {
    //current version is < (8.1.2)
}

आईओएस 7 पर तैनाती

आईओएस 7.1 या उससे कम के न्यूनतम तैनाती लक्ष्य के लिए , UIDevice systemVersion पर NSStringCompareOptions.NumericSearch साथ तुलना करें।

यह उपज होगा:

let minimumVersionString = "3.1.3"
let versionComparison = UIDevice.currentDevice().systemVersion.compare(minimumVersionString, options: .NumericSearch)
switch versionComparison {
    case .OrderedSame, .OrderedDescending:
        //current version is >= (3.1.3)
        break
    case .OrderedAscending:
        //current version is < (3.1.3)
        fallthrough
    default:
        break;
}

NSHipster पर और पढ़ना।

मैं यह जांचना चाहता हूं कि डिवाइस का iOS संस्करण 3.1.3 से बड़ा है या नहीं, मैंने इस तरह की चीजों की कोशिश की:

[[UIDevice currentDevice].systemVersion floatValue]

लेकिन यह काम नहीं करता है, मैं बस एक चाहता हूँ:

if (version > 3.1.3) { }

इसे कैसे प्राप्त किया जा सकता है?


त्वरित उत्तर ...


स्विफ्ट 2.0 के रूप में, आप कोड की सुरक्षा के लिए #available में उपयोग कर सकते हैं या केवल कुछ सिस्टम पर चलाना चाहिए।

if #available(iOS 9, *) {}


उद्देश्य-सी में, आपको सिस्टम संस्करण की जांच करने और तुलना करने की आवश्यकता है।

[[NSProcessInfo processInfo] operatingSystemVersion] आईओएस 8 और ऊपर में।

एक्सकोड 9 के रूप में:

if (@available(iOS 9, *)) {}


पूरा जवाब ...

उद्देश्य-सी में, और दुर्लभ मामलों में स्विफ्ट, डिवाइस या ओएस क्षमताओं के संकेत के रूप में ऑपरेटिंग सिस्टम संस्करण पर भरोसा करना बेहतर है। आमतौर पर एक विशेष सुविधा या कक्षा उपलब्ध है या नहीं, यह जांचने की एक और अधिक विश्वसनीय विधि है।

एपीआई की उपस्थिति की जांच:

उदाहरण के लिए, आप जांच सकते हैं कि UIPopoverController का उपयोग कर वर्तमान डिवाइस पर उपलब्ध है या नहीं:

if (NSClassFromString(@"UIPopoverController")) {
    // Do something
}

कमजोर रूप से जुड़े वर्गों के लिए, कक्षा को सीधे संदेश भेजना सुरक्षित है। विशेष रूप से, यह ढांचे के लिए काम करता है जिन्हें स्पष्ट रूप से "आवश्यक" के रूप में नहीं जोड़ा जाता है। कक्षाओं को खोने के लिए, अभिव्यक्ति शून्य में मूल्यांकन करती है, स्थिति को विफल करने में विफल होती है:

if ([LAContext class]) {
    // Do something
}

CLLocationManager और UIDevice जैसे कुछ वर्ग, डिवाइस क्षमताओं की जांच करने के तरीके प्रदान करते हैं:

if ([CLLocationManager headingAvailable]) {
    // Do something
}

प्रतीकों की उपस्थिति की जांच:

बहुत बार, आपको निरंतर उपस्थिति की जांच करनी चाहिए। यह -openURL: की शुरूआत के साथ आया था, जो सेटिंग ऐप को -openURL: माध्यम से लोड करने के लिए प्रयोग किया जाता था:। मूल्य आईओएस से पहले मौजूद नहीं था 8. इस एपीआई में शून्य पास करना दुर्घटनाग्रस्त हो जाएगा, इसलिए आपको पहले स्थिरता के अस्तित्व को सत्यापित करने के लिए सावधानी बरतनी चाहिए:

if (&UIApplicationOpenSettingsURLString != NULL) {
    [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
}

ऑपरेटिंग सिस्टम संस्करण के मुकाबले तुलना करना:

आइए मान लें कि आपको ऑपरेटिंग सिस्टम संस्करण की जांच करने की अपेक्षाकृत दुर्लभ आवश्यकता का सामना करना पड़ रहा है। आईओएस 8 और उससे ऊपर की परियोजनाओं के लिए, NSProcessInfo में त्रुटि की कम संभावना के साथ संस्करण तुलना करने के लिए एक विधि शामिल है:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

पुराने सिस्टम को लक्षित करने वाली परियोजनाएं UIDevice पर UIDevice उपयोग कर सकती हैं। ऐप्पल इसे अपने GLSprite नमूना कोड में उपयोग करता है।

// A system version of 3.1 or greater is required to use CADisplayLink. The NSTimer
// class is used as fallback when it isn't available.
NSString *reqSysVer = @"3.1";
NSString *currSysVer = [[UIDevice currentDevice] systemVersion];
if ([currSysVer compare:reqSysVer options:NSNumericSearch] != NSOrderedAscending) {
    displayLinkSupported = TRUE;
}

यदि किसी भी कारण से आप उस systemVersion को निर्णय लेते हैं, जिसे आप चाहते हैं, तो इसे एक स्ट्रिंग के रूप में पेश करना सुनिश्चित करें या आप पैच संशोधन संख्या (उदाहरण 3.1.2 -> 3.1) को कम करने का जोखिम उठाते हैं।


Obj-C ++ 11 में एक अधिक सामान्य संस्करण (आप शायद इस सामग्री में से कुछ को एनएसएसटींग / सी कार्यों के साथ प्रतिस्थापित कर सकते हैं, लेकिन यह कम वर्बोज़ है। यह आपको दो तंत्र देता है। विभाजन सिस्टम सिस्टम आपको सभी भागों की एक सरणी देता है जो उपयोगी है आप बस प्रमुख संस्करण (जैसे switch([self splitSystemVersion][0]) {case 4: break; case 5: break; } पर स्विच करना चाहते हैं switch([self splitSystemVersion][0]) {case 4: break; case 5: break; } )।

#include <boost/lexical_cast.hpp>

- (std::vector<int>) splitSystemVersion {
    std::string version = [[[UIDevice currentDevice] systemVersion] UTF8String];
    std::vector<int> versions;
    auto i = version.begin();

    while (i != version.end()) {
        auto nextIllegalChar = std::find_if(i, version.end(), [] (char c) -> bool { return !isdigit(c); } );
        std::string versionPart(i, nextIllegalChar);
        i = std::find_if(nextIllegalChar, version.end(), isdigit);

        versions.push_back(boost::lexical_cast<int>(versionPart));
    }

    return versions;
}

/** Losslessly parse system version into a number
 * @return <0>: the version as a number,
 * @return <1>: how many numeric parts went into the composed number. e.g.
 * X.Y.Z = 3.  You need this to know how to compare again <0>
 */
- (std::tuple<int, int>) parseSystemVersion {
    std::string version = [[[UIDevice currentDevice] systemVersion] UTF8String];
    int versionAsNumber = 0;
    int nParts = 0;

    auto i = version.begin();
    while (i != version.end()) {
        auto nextIllegalChar = std::find_if(i, version.end(), [] (char c) -> bool { return !isdigit(c); } );
        std::string versionPart(i, nextIllegalChar);
        i = std::find_if(nextIllegalChar, version.end(), isdigit);

        int part = (boost::lexical_cast<int>(versionPart));
        versionAsNumber = versionAsNumber * 100 + part;
        nParts ++;
    }

    return {versionAsNumber, nParts};
}


/** Assume that the system version will not go beyond X.Y.Z.W format.
 * @return The version string.
 */
- (int) parseSystemVersionAlt {
    std::string version = [[[UIDevice currentDevice] systemVersion] UTF8String];
    int versionAsNumber = 0;
    int nParts = 0;

    auto i = version.begin();
    while (i != version.end() && nParts < 4) {
        auto nextIllegalChar = std::find_if(i, version.end(), [] (char c) -> bool { return !isdigit(c); } );
        std::string versionPart(i, nextIllegalChar);
        i = std::find_if(nextIllegalChar, version.end(), isdigit);

        int part = (boost::lexical_cast<int>(versionPart));
        versionAsNumber = versionAsNumber * 100 + part;
        nParts ++;
    }

    // don't forget to pad as systemVersion may have less parts (i.e. X.Y).
    for (; nParts < 4; nParts++) {
        versionAsNumber *= 100;
    }

    return versionAsNumber;
}

Yasimturks समाधान की एक भिन्नता के रूप में, मैंने पांच मैक्रोज़ के बजाय एक समारोह और कुछ enum मान परिभाषित किया। मुझे यह अधिक सुरुचिपूर्ण लगता है, लेकिन यह स्वाद का मामला है।

उपयोग:

if (systemVersion(LessThan, @"5.0")) ...

एच फाइल:

typedef enum {
  LessThan,
  LessOrEqual,
  Equal,
  GreaterOrEqual,
  GreaterThan,
  NotEqual
} Comparison;

BOOL systemVersion(Comparison test, NSString* version);

एमएम फ़ाइल:

BOOL systemVersion(Comparison test, NSString* version) {
  NSComparisonResult result = [[[UIDevice currentDevice] systemVersion] compare: version options: NSNumericSearch];
  switch (test) {
    case LessThan:       return result == NSOrderedAscending;
    case LessOrEqual:    return result != NSOrderedDescending;
    case Equal:          return result == NSOrderedSame;
    case GreaterOrEqual: return result != NSOrderedAscending;
    case GreaterThan:    return result == NSOrderedDescending;
    case NotEqual:       return result != NSOrderedSame;
  }
}

आपको नामों पर विशेष रूप से Comparison प्रकार के लिए अपने ऐप का उपसर्ग जोड़ना चाहिए।


आम तौर पर यह पूछना बेहतर होता है कि कोई ऑब्जेक्ट किसी दिए गए चयनकर्ता को निष्पादित कर सकता है, यह निर्धारित करने के लिए कि क्या यह मौजूद होना चाहिए या नहीं।

जब यह कोई विकल्प नहीं है, तो आपको यहां थोड़ा सावधान रहने की आवश्यकता है क्योंकि [@"5.0" compare:@"5" options:NSNumericSearch] NSOrderedDescending देता है जो कि बिल्कुल भी नहीं हो सकता है; मैं यहां NSOrderedSame उम्मीद कर सकता हूं। यह कम से कम एक सैद्धांतिक चिंता है, जो मेरी राय में बचाव के लायक है।

विचार करने के लायक भी एक खराब संस्करण इनपुट की संभावना है जिसे उचित रूप से तुलना नहीं किया जा सकता है। ऐप्पल तीन पूर्वनिर्धारित स्थिरांक NSOrderedAscending , NSOrderedSame और NSOrderedDescending आपूर्ति करता है लेकिन मैं NSOrderedUnordered नामक किसी चीज़ के लिए उपयोग के बारे में सोच सकता हूं, जिसमें मैं दो चीजों की तुलना नहीं कर सकता हूं और मैं इसे इंगित करने वाला मान वापस करना चाहता हूं।

और भी, यह असंभव नहीं है कि ऐप्पल कुछ दिन अपने पूर्वनिर्धारित स्थिरांक का विस्तार करेगा ताकि विभिन्न प्रकार के रिटर्न वैल्यू की अनुमति मिल सके, तुलनात्मक हो != NSOrderedAscending मूर्खता से != NSOrderedAscending

इसके साथ, निम्नलिखित कोड पर विचार करें।

typedef enum {kSKOrderedNotOrdered = -2, kSKOrderedAscending = -1, kSKOrderedSame = 0, kSKOrderedDescending = 1} SKComparisonResult;

@interface SKComparator : NSObject
+ (SKComparisonResult)comparePointSeparatedVersionNumber:(NSString *)vOne withPointSeparatedVersionNumber:(NSString *)vTwo;
@end

@implementation SKComparator
+ (SKComparisonResult)comparePointSeparatedVersionNumber:(NSString *)vOne withPointSeparatedVersionNumber:(NSString *)vTwo {
  if (!vOne || !vTwo || [vOne length] < 1 || [vTwo length] < 1 || [vOne rangeOfString:@".."].location != NSNotFound ||
    [vTwo rangeOfString:@".."].location != NSNotFound) {
    return SKOrderedNotOrdered;
  }
  NSCharacterSet *numericalCharSet = [NSCharacterSet characterSetWithCharactersInString:@".0123456789"];
  NSString *vOneTrimmed = [vOne stringByTrimmingCharactersInSet:numericalCharSet];
  NSString *vTwoTrimmed = [vTwo stringByTrimmingCharactersInSet:numericalCharSet];
  if ([vOneTrimmed length] > 0 || [vTwoTrimmed length] > 0) {
    return SKOrderedNotOrdered;
  }
  NSArray *vOneArray = [vOne componentsSeparatedByString:@"."];
  NSArray *vTwoArray = [vTwo componentsSeparatedByString:@"."];
  for (NSUInteger i = 0; i < MIN([vOneArray count], [vTwoArray count]); i++) {
    NSInteger vOneInt = [[vOneArray objectAtIndex:i] intValue];
    NSInteger vTwoInt = [[vTwoArray objectAtIndex:i] intValue];
    if (vOneInt > vTwoInt) {
      return kSKOrderedDescending;
    } else if (vOneInt < vTwoInt) {
      return kSKOrderedAscending;
    }
  }
  if ([vOneArray count] > [vTwoArray count]) {
    for (NSUInteger i = [vTwoArray count]; i < [vOneArray count]; i++) {
      if ([[vOneArray objectAtIndex:i] intValue] > 0) {
        return kSKOrderedDescending;
      }
    }
  } else if ([vOneArray count] < [vTwoArray count]) {
    for (NSUInteger i = [vOneArray count]; i < [vTwoArray count]; i++) {
      if ([[vTwoArray objectAtIndex:i] intValue] > 0) {
        return kSKOrderedAscending;
      }
    }
  }
  return kSKOrderedSame;
}
@end

इसका उपयोग एक्सकोड में संगत एसडीके संस्करण की जांच के लिए किया जाता है, यह है कि यदि आपके पास एक्सकोड के विभिन्न संस्करणों के साथ एक बड़ी टीम है या एक ही कोड साझा करने वाले विभिन्न एसडीके का समर्थन करने वाली कई परियोजनाएं हैं:

#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000
  //programming in iOS 8+ SDK here
#else
  //programming in lower than iOS 8 here   
#endif

आप वास्तव में क्या चाहते हैं डिवाइस पर आईओएस संस्करण की जांच करना है। आप इसके साथ ऐसा कर सकते हैं:

if ([[[UIDevice currentDevice] systemVersion] floatValue] < 8.0) {
  //older than iOS 8 code here
} else {
  //iOS 8 specific code here
}

स्विफ्ट संस्करण:

if let version = Float(UIDevice.current.systemVersion), version < 9.3 {
    //add lower than 9.3 code here
} else {
    //add 9.3 and above code here
}

ओएस संस्करण स्ट्रिंग मान को पुनः प्राप्त करने के लिए:

[[UIDevice currentDevice] systemVersion]


नीचे दिए गए कोड का प्रयास करें:

NSString *versionString = [[UIDevice currentDevice] systemVersion];

पार्टी के लिए थोड़ा देर हो चुकी है लेकिन आईओएस 8.0 के प्रकाश में यह प्रासंगिक हो सकता है:

यदि आप उपयोग से बच सकते हैं

[[UIDevice currentDevice] systemVersion]

इसके बजाय किसी विधि / वर्ग / जो भी हो, के अस्तित्व की जांच करें।

if ([self.yourClassInstance respondsToSelector:@selector(<yourMethod>)]) 
{ 
    //do stuff 
}

मैंने इसे स्थान प्रबंधक के लिए उपयोगी पाया जहां मुझे आईओएस 8.0 के लिए अनुरोध करने के लिए अनुरोध करना है, लेकिन विधि आईओएस के लिए उपलब्ध नहीं है <8


मुझे पता है कि यह एक पुराना सवाल है, लेकिन किसी को Availability.h .h में संकलन-समय मैक्रोज़ का उल्लेख करना चाहिए था। यहां सभी अन्य विधियां रनटाइम समाधान हैं, और हेडर फ़ाइल, क्लास श्रेणी या ivar परिभाषा में काम नहीं करेंगे।

इन परिस्थितियों के लिए, उपयोग करें

#if __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_6_0
  // iOS 6+ code here
#else
  // Pre iOS 6 code here
#endif

एच / टी this जवाब



स्विफ्ट उदाहरण जो वास्तव में काम करता है:

switch UIDevice.currentDevice().systemVersion.compare("8.0.0", options: NSStringCompareOptions.NumericSearch) {
case .OrderedSame, .OrderedDescending:
    println("iOS >= 8.0")
case .OrderedAscending:
    println("iOS < 8.0")
}

NSProcessInfo का उपयोग न करें क्योंकि यह 8.0 के तहत काम नहीं करता है, इसलिए 2016 तक यह काफी बेकार है


UIDevice + IOSVersion.h

@interface UIDevice (IOSVersion)

+ (BOOL)isCurrentIOSVersionEqualToVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionGreaterThanVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionGreaterThanOrEqualToVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionLessThanVersion:(NSString *)iOSVersion;
+ (BOOL)isCurrentIOSVersionLessThanOrEqualToVersion:(NSString *)iOSVersion

@end

UIDevice + IOSVersion.m

#import "UIDevice+IOSVersion.h"

@implementation UIDevice (IOSVersion)

+ (BOOL)isCurrentIOSVersionEqualToVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] == NSOrderedSame;
}

+ (BOOL)isCurrentIOSVersionGreaterThanVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] == NSOrderedDescending;
}

+ (BOOL)isCurrentIOSVersionGreaterThanOrEqualToVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] != NSOrderedAscending;
}

+ (BOOL)isCurrentIOSVersionLessThanVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] == NSOrderedAscending;
}

+ (BOOL)isCurrentIOSVersionLessThanOrEqualToVersion:(NSString *)iOSVersion
{
    return [[[UIDevice currentDevice] systemVersion] compare:iOSVersion options:NSNumericSearch] != NSOrderedDescending;
}

@end

वर्जन क्लास के साथ जो nv-ios-version प्रोजेक्ट (अपाचे लाइसेंस, वर्जन 2.0) में निहित है, आईओएस संस्करण प्राप्त करना और तुलना करना आसान है। नीचे एक उदाहरण कोड आईओएस संस्करण को डंप करता है और यह जांचता है कि संस्करण 6.0 से अधिक या बराबर है या नहीं।

// Get the system version of iOS at runtime.
NSString *versionString = [[UIDevice currentDevice] systemVersion];

// Convert the version string to a Version instance.
Version *version = [Version versionWithString:versionString];

// Dump the major, minor and micro version numbers.
NSLog(@"version = [%d, %d, %d]",
    version.major, version.minor, version.micro);

// Check whether the version is greater than or equal to 6.0.
if ([version isGreaterThanOrEqualToMajor:6 minor:0])
{
    // The iOS version is greater than or equal to 6.0.
}

// Another way to check whether iOS version is
// greater than or equal to 6.0.
if (6 <= version.major)
{
    // The iOS version is greater than or equal to 6.0.
}

प्रोजेक्ट पेज: एनवी-आईओएस-वर्जन
nv-ios-version

ब्लॉग: वर्जन क्लास के साथ रनटाइम पर आईओएस संस्करण प्राप्त करें और तुलना करें
वर्जन क्लास के साथ रनटाइम पर आईओएस संस्करण प्राप्त करें और तुलना करें


स्विफ्ट में आईओएस संस्करण की जांच के लिए समाधान

switch (UIDevice.currentDevice().systemVersion.compare("8.0.0", options: NSStringCompareOptions.NumericSearch)) {
    case .OrderedAscending:
       println("iOS < 8.0")

    case .OrderedSame, .OrderedDescending:
       println("iOS >= 8.0")
}

इस समाधान का कॉन: ओएस संस्करण संख्याओं के खिलाफ जांच करने के लिए यह बस खराब अभ्यास है, जिस तरह से आप इसे करते हैं। One should never hard code dependencies in this way, always check for features, capabilities or the existence of a class. Consider this; Apple may release a backwards compatible version of a class, if they did then the code you suggest would never use it as your logic looks for an OS version number and NOT the existence of the class.

( NSHipster )

Solution for checking the class existence in Swift

if (objc_getClass("UIAlertController") == nil) {
   // iOS 7
} else {
   // iOS 8+
}

Do not use if (NSClassFromString("UIAlertController") == nil) because it works correctly on the iOS simulator using iOS 7.1 and 8.2, but if you test on a real device using iOS 7.1, you will unfortunately notice that you will never pass through the else part of the code snippet.


#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)

फिर एक शर्त अगर निम्नानुसार जोड़ें: -

if(SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"10.0")) {
   //Your code
}       

#define _kisiOS7 ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0)

if (_kisiOS7) {
            NSLog(@"iOS7 or greater")
} 
else {
           NSLog(@"Less than iOS7");
}

/*
 *  System Versioning Preprocessor Macros
 */ 

#define SYSTEM_VERSION_EQUAL_TO(v)                  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedSame)
#define SYSTEM_VERSION_GREATER_THAN(v)              ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedDescending)
#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
#define SYSTEM_VERSION_LESS_THAN(v)                 ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedDescending)

/*
 *  Usage
 */ 

if (SYSTEM_VERSION_LESS_THAN(@"4.0")) {
    ...
}

if (SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"3.1.1")) {
    ...
}

float deviceOSVersion = [[[UIDevice currentDevice] systemVersion] floatValue];
float versionToBeCompared = 3.1.3; //(For Example in your case)

if(deviceOSVersion < versionToBeCompared)
   //Do whatever you need to do. Device version is lesser than 3.1.3(in your case)
else 
   //Device version should be either equal to the version you specified or above




objective-c