මම උත්සාහ කළ දේට iOSවඩා උපාංගයේ අනුවාදය විශාලදැයි පරීක්ෂා කිරීමට මට අවශ්‍යය 3.1.3:

[[UIDevice currentDevice].systemVersion floatValue]

නමුත් එය ක්‍රියා නොකරයි, මට අවශ්‍ය වන්නේ:

if (version > 3.1.3) { }

මට මෙය සාක්ෂාත් කරගත හැක්කේ කෙසේද?

ඉක්මන් පිළිතුර…

ස්විෆ්ට් 2.0 ලෙස, ඔබ භාවිතා කළ හැකිය #availableතුළ සිටින ifහෝ guardයම් පද්ධති මත පමණක් ක්රියාත්මක විය යුතු බව, රැකවරණය කේතය කිරීමට.

if #available(iOS 9, *) {}


Objective-C හි, ඔබ පද්ධති අනුවාදය පරීක්ෂා කර සංසන්දනයක් කළ යුතුය.

[[NSProcessInfo processInfo] operatingSystemVersion] iOS 8 සහ ඊට ඉහළ.

Xcode 9 වන විට:

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

සම්පූර්ණ පිළිතුර…

Objective-C, සහ ස්විෆ්ට් වල දුර්ලභ අවස්ථාවන්හිදී, උපාංග හෝ මෙහෙයුම් හැකියාවන් පිළිබඳ ඇඟවීමක් ලෙස මෙහෙයුම් පද්ධති අනුවාදය මත රඳා සිටීම වළක්වා ගැනීම වඩා හොඳය. කිසියම් අංගයක් හෝ පන්තියක් තිබේදැයි පරීක්ෂා කිරීමට සාමාන්‍යයෙන් වඩාත් විශ්වාසදායක ක්‍රමවේදයක් ඇත.

ඒපීඅයි තිබේද යන්න පරීක්ෂා කිරීම:

උදාහරණයක් ලෙස, UIPopoverControllerභාවිතා කරමින් වත්මන් උපාංගයේ තිබේදැයි ඔබට පරීක්ෂා කළ හැකිය NSClassFromString:

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

දුර්වල ලෙස සම්බන්ධිත පන්ති සඳහා, කෙලින්ම පන්තියට පණිවිඩ යැවීම ආරක්ෂිත වේ. විශේෂයෙන්, මෙය "අවශ්‍ය" ලෙස පැහැදිලිව සම්බන්ධ නොවූ රාමු සඳහා ක්‍රියා කරයි. අතුරුදහන් වූ පංති සඳහා, ප්‍රකාශනය තත්වය අසමත් වන පරිදි තක්සේරු කරයි:

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

සමහර පන්ති, වැනි, CLLocationManagerසහ UIDevice, උපාංග හැකියාවන් පරීක්ෂා කිරීමට ක්‍රම සපයයි:

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

සංකේත තිබේද යන්න පරීක්ෂා කිරීම:

ඉතා විටින් විට, නියතයක් තිබේද යන්න පරීක්ෂා කළ යුතුය. මෙය iOS 8 හි සිට UIApplicationOpenSettingsURLString, සැකසීම් යෙදුම හරහා පැටවීම සඳහා භාවිතා කරන ලදි -openURL:. IOS 8 ට පෙර අගය නොතිබුණි. මෙම API වෙත නොපැමිණීම බිඳ වැටෙනු ඇත, එබැවින් නියතයේ පැවැත්ම තහවුරු කිරීමට ඔබ සැලකිලිමත් විය යුතුය:

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

මෙහෙයුම් පද්ධති අනුවාදයට සාපේක්ෂව:

මෙහෙයුම් පද්ධති අනුවාදය පරීක්ෂා කිරීමේ සාපේක්ෂ වශයෙන් දුර්ලභ අවශ්‍යතාවයකට ඔබ මුහුණ දී ඇතැයි සිතමු. IOS 8 සහ ඊට ඉහළින් ඉලක්ක කරගත් ව්‍යාපෘති NSProcessInfoසඳහා, අඩු දෝෂයක් සහිත අනුවාද සංසන්දනයන් සිදු කිරීමේ ක්‍රමයක් ඇතුළත් වේ:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

පැරණි පද්ධති ඉලක්ක කර ව්යාපෘති භාවිතා කළ හැකි systemVersionමත 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).

/*
 *  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")) {
    ...
}

ලෙස යෝජනා කර නිල ඇපල් ලේඛන : ඔබ භාවිතා කළ හැකිය NSFoundationVersionNumberසිට, NSObjCRuntime.hශීර්ෂ ගොනුව.

if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) {
    // here you go with iOS 7
}

පරමාර්ථ-සී හි Xcode 9 ආරම්භ කිරීම :

if (@available(iOS 11, *)) {
    // iOS 11 (or newer) ObjC code
} else {
    // iOS 10 or older code
}

ස්විෆ්ට් හි Xcode 7 ආරම්භ කිරීම :

if #available(iOS 11, *) {
    // iOS 11 (or newer) Swift code
} else {
    // iOS 10 or older code
}

අනුවාදය සඳහා, ඔබට MAJOR, MINOR හෝ PATCH නියම කළ හැකිය ( අර්ථ දැක්වීම් සඳහා http://semver.org/ බලන්න ). උදාහරණ:

• iOS 11සහ iOS 11.0එකම අවම අනුවාදය වේ
• iOS 10, iOS 10.3, iOS 10.3.1විවිධ අවම පිටපත් ඇත

ඔබට ඕනෑම පද්ධතියක් සඳහා අගයන් ඇතුළත් කළ හැකිය:

• iOS, macOS, watchOS,tvOS

මගේ එක් කරත්තයකින් ගත් සැබෑ සිද්ධි උදාහරණය :

if #available(iOS 10.0, tvOS 10.0, *) {
    // iOS 10+ and tvOS 10+ Swift code
} else {
    // iOS 9 and tvOS 9 older code
}

ප්‍රලේඛනය

Xcode හි අනුකූල SDK අනුවාදය පරීක්ෂා කිරීම සඳහා මෙය භාවිතා කරයි, මෙය ඔබට Xcode හි විවිධ අනුවාදයන් සහිත විශාල කණ්ඩායමක් හෝ එකම කේතය බෙදා ගන්නා විවිධ SDK වලට සහාය දක්වන බහු ව්‍යාපෘති තිබේ නම්:

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

ඔබට සැබවින්ම අවශ්‍ය වන්නේ උපාංගයේ iOS අනුවාදය පරීක්ෂා කිරීමයි. ඔබට මෙය සමඟ එය කළ හැකිය:

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
}

ස්විෆ්ට් හි වර්තමාන අනුවාදයන් මෙය භාවිතා කළ යුතුය:

if #available(iOS 12, *) {
    //iOS 12 specific code here
} else {
    //older than iOS 12 code here
}

උත්සාහ කරන්න:

NSComparisonResult order = [[UIDevice currentDevice].systemVersion compare: @"3.1.3" options: NSNumericSearch];
if (order == NSOrderedSame || order == NSOrderedDescending) {
    // OS version >= 3.1.3
} else {
    // OS version < 3.1.3
}

කැමති ප්‍රවේශය

ස්විෆ්ට් 2.0 හි ඇපල් වඩාත් පහසු වාක්‍ය ඛණ්ඩයක් භාවිතා කරමින් උපයෝජ්‍යතා පරීක්ෂාව එකතු කළේය (වැඩි විස්තර මෙතැනින් කියවන්න ). දැන් ඔබට OS අනුවාදය පිරිසිදු වාක්‍ය ඛණ්ඩයකින් පරීක්ෂා කළ හැකිය:

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

respondsToSelectorආදිය පරීක්ෂා කිරීමට වඩා මෙය වඩාත් කැමති වේ ( ස්විෆ්ට් හි නව දේ ). ඔබ ඔබේ කේතය නිසි ලෙස ආරක්ෂා නොකරන්නේ නම් දැන් සම්පාදකයා ඔබට අනතුරු අඟවයි.

පෙර ස්විෆ්ට් 2.0

IOS 8 හි අළුත් NSProcessInfoදේ වඩා හොඳ අර්ථකථන අනුවාද චෙක්පත් සඳහා ඉඩ ලබා දේ.

IOS 8 සහ ඊට වැඩි ගණනක් යෙදවීම

IOS 8.0 හෝ ඊට වැඩි අවම යෙදවීමේ ඉලක්ක සඳහා , භාවිතා කරන්න 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)
}

IOS 7 මත යෙදවීම

අවම වශයෙන් යෙදවීම ඉලක්ක සඳහා , iOS 7.1 හෝ පහත, භාවිතය සමග සංසන්දනය NSStringCompareOptions.NumericSearchමත UIDevice systemVersion.

මෙය ලැබෙනු ඇත:

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 හි වැඩිදුර කියවීම .

මම සෑම විටම ඒවා මගේ Constants.h ගොනුවේ තබා ගන්නෙමි:

#define IS_IPHONE5 (([[UIScreen mainScreen] bounds].size.height-568)?NO:YES) 
#define IS_OS_5_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 5.0)
#define IS_OS_6_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 6.0)
#define IS_OS_7_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0)
#define IS_OS_8_OR_LATER    ([[[UIDevice currentDevice] systemVersion] floatValue] >= 8.0)

+(BOOL)doesSystemVersionMeetRequirement:(NSString *)minRequirement{

// eg  NSString *reqSysVer = @"4.0";


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

  if ([currSysVer compare:minRequirement options:NSNumericSearch] != NSOrderedAscending)
  {
    return YES;
  }else{
    return NO;
  }


}

සමග සංස්කරණය අඩංගු පන්ති , NV-iOS-අනුවාදය ව්යාපෘතිය (Apache License බලපත්රයෙහි 2.0), එය, iOS අනුවාදය ලබා ගැනීමට හා සන්සන්දනය කිරීම පහසු වේ. පහත උදාහරණ කේතයක් iOS අනුවාදය අතහැර දමා අනුවාදය 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
TakahikoKawasaki / nv-ios-version

බ්ලොග්: සංස්කරණය පන්තිය සමග ක්රියාත්මක වීමේදී, iOS අනුවාදය ලබා ගන්න සහ සංසන්දනය
සංස්කරණය පන්තිය සමග ක්රියාත්මක වීමේදී, iOS අනුවාදය ලබා ගන්න සහ සංසන්දනය

ස්විෆ්ට් ෆෝගට් [[UIDevice currentDevice] systemVersion] සහ NSFoundationVersionNumber භාවිතා කරමින් පද්ධති අනුවාදය පරීක්ෂා කිරීමට නව ක්‍රමයක්.

අපට NSProcessInfo -isOperatingSystemAtLeastVersion භාවිතා කළ හැකිය

     import Foundation

     let yosemite = NSOperatingSystemVersion(majorVersion: 10, minorVersion: 10, patchVersion: 0)
     NSProcessInfo().isOperatingSystemAtLeastVersion(yosemite) // false

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

පොදුවේ ගත් කල, යම් වස්තුවකට එය තිබිය යුතුද යන්න තීරණය කිරීම සඳහා අනුවාද අංකයක් පරික්ෂා කරනවාට වඩා ලබා දී ඇති තේරීම් කාරකයක් කළ හැකිදැයි විමසීම වඩා හොඳය.

මෙය විකල්පයක් නොවන විට, ඔබ මෙහි ටිකක් පරිස්සම් විය යුතුය, මන්ද [@"5.0" compare:@"5" options:NSNumericSearch]ප්‍රතිලාභ NSOrderedDescendingකිසිසේත්ම බලාපොරොත්තු නොවිය හැකි බැවිනි; මම බලාපොරොත්තු වෙන්න පුළුවන්NSOrderedSame මෙතන . මෙය අවම වශයෙන් න්‍යායාත්මක සැලකිල්ලක් වන අතර එය මගේ මතය අනුව ආරක්ෂා කිරීම වටී.

සාධාරණ ලෙස සැසඳිය නොහැකි නරක අනුවාද ආදානයක හැකියාව ද සලකා බැලීම වටී. ඇපල් සපයනවා නියත තුනක් සපයයි NSOrderedAscending, NSOrderedSameහා NSOrderedDescendingනමුත් මම නම් තවත් දෙයක් සඳහා භාවිතා සිතිය හැකිNSOrderedUnordered මට කරුණු දෙකක් සැසඳීමට මම මේ සඳහන් කරන අගය ආපසු යාමට අවශ්ය හැක අවස්ථාවට එක්විය.

එපමණක්ද නොව, ඇපල් විසින් යම් දිනෙක ඔවුන්ගේ පෙර නියම කළ නියතයන් තුන පුළුල් කර විවිධාකාර ප්‍රතිලාභ අගයන් ලබා ගැනීමට ඉඩ සලසයි != 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 (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) {
        // Your code here
}

ඇත්ත වශයෙන්ම, NSFoundationVersionNumber_iOS_6_1ඔබට පරීක්ෂා කිරීමට අවශ්‍ය iOS අනුවාදය සඳහා අදාළ වන පරිදි වෙනස් කළ යුතුය. උපාංගයක් iOS7 හෝ පෙර සංස්කරණයක් ක්‍රියාත්මක වේදැයි පරීක්ෂා කිරීමේදී මා දැන් ලියා ඇති දේ බොහෝ විට භාවිතා කරනු ඇත.

සාදයට ටිකක් ප්‍රමාද නමුත් iOS 8.0 අනුව මෙය අදාළ විය හැකිය:

ඔබට භාවිතා කිරීමෙන් වැළකී සිටිය හැකි නම්

[[UIDevice currentDevice] systemVersion]

ඒ වෙනුවට ක්‍රමවේදයක් / පන්තියක් / වෙනත් දෙයක් තිබේද යන්න පරීක්ෂා කරන්න.

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

IOS 8.0 සඳහා requestWhenInUseAuthorization ඇමතිය යුතු ස්ථාන කළමණාකරුට එය ප්‍රයෝජනවත් බව මට පෙනී ගිය නමුත් iOS <8 සඳහා මෙම ක්‍රමය නොමැත.

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

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

මෙය පැරණි ප්‍රශ්නයක් බව මම දනිමි, නමුත් යමෙකු විසින් සම්පාදනය කරන ලද මැක්‍රෝස් සඳහන් කළ යුතුය Availability.h. මෙහි ඇති අනෙක් සියලුම ක්‍රම ධාවන කාල විසඳුම් වන අතර ඒවා ශීර්ෂ ගොනුවක, පන්ති කාණ්ඩයේ හෝ අයිවර් අර්ථ දැක්වීමේදී ක්‍රියා නොකරනු ඇත.

මෙම තත්වයන් සඳහා, භාවිතා කරන්න

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

h / t මෙම පිළිතුර

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

7.0 හෝ 6.0.3 වැනි අනුවාද ඇත, එබැවින් අපට සංසන්දනය කිරීම සඳහා අනුවාදය සංඛ්‍යා බවට පරිවර්තනය කළ හැකිය. අනුවාදය 7.0 ට සමාන නම්, එයට තවත් ".0" එකතු කර එහි සංඛ්‍යාත්මක අගය ගන්න.

 int version;
 NSString* iosVersion=[[UIDevice currentDevice] systemVersion];
 NSArray* components=[iosVersion componentsSeparatedByString:@"."];
 if ([components count]==2) {
    iosVersion=[NSString stringWithFormat:@"%@.0",iosVersion];

 }
 iosVersion=[iosVersion stringByReplacingOccurrencesOfString:@"." withString:@""];
 version=[iosVersion integerValue];

6.0.0 සඳහා

  if (version==600) {
    // Do something
  }

7.0 සඳහා

 if (version==700) {
   // Do something
 }

පහත කේතය උත්සාහ කරන්න:

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

OS අනුවාදයේ අගය ලබා ගැනීම සඳහා:

[[UIDevice currentDevice] systemVersion]

යසිම්ටුර්ක්ස් විසඳුමේ විචල්‍යතාවයක් ලෙස, මම මැක්‍රෝස් පහක් වෙනුවට එක් ශ්‍රිතයක් සහ එනුම් අගයන් කිහිපයක් අර්ථ දැක්වුවෙමි. මම එය වඩාත් අලංකාර ලෙස සලකමි, නමුත් එය රසයේ කාරණයකි.

භාවිතය:

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

.h ගොනුව:

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

BOOL systemVersion(Comparison test, NSString* version);

.m ගොනුව:

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වර්ගයට එකතු කළ යුතුය .

නිර්දේශිත ක්‍රමය භාවිතා කිරීම ... ශීර්ෂ ලිපිගොනු වල අර්ථ දැක්වීමක් නොමැති නම්, ඔබට සෑම විටම එය අපේක්ෂිත IOS වර්සීන් උපාංගයක් සමඟ කොන්සෝලය මත මුද්‍රණය කළ හැකිය.

- (BOOL) isIOS8OrAbove{
    float version802 = 1140.109985;
    float version8= 1139.100000; // there is no def like NSFoundationVersionNumber_iOS_7_1 for ios 8 yet?
    NSLog(@"la version actual es [%f]", NSFoundationVersionNumber);
    if (NSFoundationVersionNumber >= version8){
        return true;
    }
    return false;
}

ස්විෆ්ට් හි iOS අනුවාදය පරීක්ෂා කිරීම සඳහා විසඳුම

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

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

මෙම විසඳුමේ එකඟතාවය: ඔබ එය කුමන ආකාරයකින් කළත් OS අනුවාද අංක පරීක්ෂා කිරීම නරක පුරුද්දකි. යමෙක් කිසි විටෙකත් මේ ආකාරයෙන් කේත පරායත්තතාවයන් දැඩි නොකළ යුතුය, සෑම විටම විශේෂාංග, හැකියාවන් හෝ පන්තියක පැවැත්ම පරීක්ෂා කරන්න. මෙය සලකා බලන්න; ඇපල් විසින් පංතියක පසුපසට අනුකූල අනුවාදයක් නිකුත් කළ හැකිය, ඔවුන් එසේ කළේ නම් ඔබ යෝජනා කරන කේතය ඔබේ තර්කනය OS අනුවාද අංකයක් සොයන බැවින් එය කිසි විටෙකත් භාවිතා නොකරනු ඇත.

( මෙම තොරතුරු වල මූලාශ්‍රය )

ස්විෆ්ට් හි පන්ති පැවැත්ම පරීක්ෂා කිරීම සඳහා විසඳුම

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

if (NSClassFromString("UIAlertController") == nil)IOS 7.1 සහ 8.2 භාවිතා කරමින් iOS සිමියුලේටරය මත එය නිවැරදිව ක්‍රියා කරන බැවින් භාවිතා නොකරන්න , නමුත් ඔබ iOS 7.1 භාවිතා කරමින් සැබෑ උපාංගයක් පරීක්ෂා කරන්නේ නම්, ඔබ කිසි විටෙකත් කේත ස්නිපටයේ අනෙක් කොටස හරහා නොයන බව ඔබට පෙනෙනු ඇත.

#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)

Obj-C ++ 11 හි වඩාත් සාමාන්‍ය අනුවාදයක් (ඔබට මෙම දේවල් සමහරක් NSString / C ශ්‍රිත සමඟ ප්‍රතිස්ථාපනය කළ හැකිය, නමුත් මෙය අඩු වාචිකය. මෙය ඔබට යාන්ත්‍රණ දෙකක් ලබා දෙයි. SplitSystemVersion මඟින් ඔබට ප්‍රයෝජනවත් වන සියලුම කොටස් පෙළක් ලබා දේ. ඔබට අවශ්‍ය වන්නේ ප්‍රධාන අනුවාදය (උදා 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;
}

මේක උත්සාහ කරන්න

if ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7) { 
// do some work
}

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

සැබවින්ම ක්‍රියාත්මක වන වේගවත් උදාහරණය:

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 වන තෙක් එය බොහෝ සෙයින් නිෂ් less ල ය

මෙන්න වේගවත් අනුවාදය:

struct iOSVersion {
    static let SYS_VERSION_FLOAT = (UIDevice.currentDevice().systemVersion as NSString).floatValue
    static let iOS7 = (Version.SYS_VERSION_FLOAT < 8.0 && Version.SYS_VERSION_FLOAT >= 7.0)
    static let iOS8 = (Version.SYS_VERSION_FLOAT >= 8.0 && Version.SYS_VERSION_FLOAT < 9.0)
    static let iOS9 = (Version.SYS_VERSION_FLOAT >= 9.0 && Version.SYS_VERSION_FLOAT < 10.0)
}

භාවිතය:

if iOSVersion.iOS8 {
    //Do iOS8 code here
}