ios - como - iphone

¿Cómo comprobar la versión de iOS? (30)

Quiero comprobar si la versión de iOS del dispositivo es mayor que 3.1.3 . Intenté cosas como:

[[UIDevice currentDevice].systemVersion floatValue]

pero no funciona, solo quiero un:

if (version > 3.1.3) { }

¿Cómo puedo conseguir esto?

Enfoque preferido

En Swift 2.0, Apple agregó la verificación de disponibilidad usando una sintaxis mucho más conveniente (lea más here ). Ahora puedes verificar la versión del sistema operativo con una sintaxis más limpia:

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

Esta es la opción preferida sobre la verificación de respondsToSelector etc. ( What''s New In Swift ). Ahora el compilador siempre te advertirá si no estás protegiendo tu código correctamente.

Pre Swift 2.0

Lo nuevo en iOS 8 es NSProcessInfo permite mejores verificaciones de versiones semánticas.

Implementación en iOS 8 y superior

Para los objetivos de implementación mínimos de iOS 8.0 o superior, use NSProcessInfo operatingSystemVersion o isOperatingSystemAtLeastVersion .

Esto daría lo siguiente:

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

Implementación en iOS 7

Para los objetivos de implementación mínimos de iOS 7.1 o inferior, use compare con NSStringCompareOptions.NumericSearch en UIDevice systemVersion .

Esto daría lugar a:

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

Más lecturas en NSHipster .

La respuesta rápida ...

A partir de Swift 2.0, puede usar #available en if o guard para proteger el código que solo debe ejecutarse en ciertos sistemas.

if #available(iOS 9, *) {}

En Objective-C, debe verificar la versión del sistema y realizar una comparación.

[[NSProcessInfo processInfo] operatingSystemVersion] en iOS 8 y superior.

A partir de Xcode 9:

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

La respuesta completa ...

En Objective-C, y Swift en casos raros, es mejor evitar confiar en la versión del sistema operativo como una indicación de las capacidades del dispositivo o sistema operativo. Por lo general, existe un método más confiable para verificar si una característica o clase en particular está disponible.

Comprobando la presencia de APIs:

Por ejemplo, puede verificar si UIPopoverController está disponible en el dispositivo actual usando NSClassFromString :

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

Para las clases débilmente vinculadas, es seguro enviar mensajes a la clase directamente. En particular, esto funciona para marcos que no están explícitamente vinculados como "Requerido". Para las clases faltantes, la expresión se evalúa como nula, fallando la condición:

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

Algunas clases, como CLLocationManager y UIDevice , proporcionan métodos para verificar las capacidades del dispositivo:

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

Comprobando la presencia de símbolos:

Muy ocasionalmente, debes verificar la presencia de una constante. Esto surgió en iOS 8 con la introducción de UIApplicationOpenSettingsURLString , que se utiliza para cargar la aplicación de configuración a través de -openURL: El valor no existía antes de iOS 8. El paso de cero a esta API se bloqueará, por lo que debe asegurarse de verificar primero la existencia de la constante:

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

Comparando con la versión del sistema operativo:

Supongamos que se enfrenta a la necesidad relativamente rara de comprobar la versión del sistema operativo. Para proyectos dirigidos a iOS 8 y superiores, NSProcessInfo incluye un método para realizar comparaciones de versiones con menos posibilidades de error:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

Los proyectos dirigidos a sistemas más antiguos pueden usar systemVersion en UIDevice . Apple lo usa en su código de ejemplo 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; }

Si por alguna razón usted decide que la systemVersion es lo que quiere, asegúrese de tratarlo como una cadena o corre el riesgo de truncar el número de revisión del parche (por ejemplo, 3.1.2 -> 3.1).

A partir de Xcode 9, en Objective-C :

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

A partir de Xcode 7, en Swift :

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

Para la versión, puede especificar el MAYOR, el MENOR o el PARCHE (ver http://semver.org/ para definiciones). Ejemplos:

iOS 11 y iOS 11.0 son la misma versión mínima
iOS 10 , iOS 10.3 , iOS 10.3.1 son versiones mínimas diferentes

Puede ingresar valores para cualquiera de esos sistemas:

iOS , macOS , watchOS , tvOS

Ejemplo de un caso real tomado de una de mis vainas :

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

documentation

Como una variación de la solución de yasimturks, definí una función y unos pocos valores de enumeración en lugar de cinco macros. Me parece más elegante, pero eso es cuestión de gustos.

Uso:

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

archivo .h:

typedef enum { LessThan, LessOrEqual, Equal, GreaterOrEqual, GreaterThan, NotEqual } Comparison; BOOL systemVersion(Comparison test, NSString* version);

archivo .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; } }

Debe agregar el prefijo de su aplicación a los nombres, especialmente al tipo de Comparison .

Con la clase de versión contenida en el proyecto nv-ios-version (Licencia Apache, Versión 2.0), es fácil obtener y comparar la versión de iOS. Un código de ejemplo a continuación descarga la versión de iOS y verifica si la versión es mayor o igual a 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. }

Página del proyecto: nv-ios-version
nv-ios-version

Blog: Obtenga y compare la versión de iOS en tiempo de ejecución con la clase de versión
Obtenga y compare la versión de iOS en tiempo de ejecución con la clase de versión

En general, es mejor preguntar si un objeto puede realizar un selector determinado, en lugar de verificar un número de versión para decidir si debe estar presente.

Cuando esta no es una opción, debe ser un poco cuidadoso aquí porque [@"5.0" compare:@"5" options:NSNumericSearch] devuelve NSOrderedDescending que bien podría no tener ninguna intención; Podría esperar NSOrderedSame aquí. Esta es al menos una preocupación teórica, una contra la que vale la pena defender en mi opinión.

También vale la pena considerar la posibilidad de una entrada de versión incorrecta que no se pueda comparar razonablemente. Apple proporciona las tres constantes predefinidas NSOrderedAscending , NSOrderedSame y NSOrderedDescending pero puedo pensar en un uso para algo llamado NSOrderedUnordered en el caso de que no pueda comparar dos cosas y quiero devolver un valor que indique esto.

Además, no es imposible que Apple algún día amplíe sus tres constantes predefinidas para permitir una variedad de valores de retorno, haciendo una comparación != NSOrderedAscending sabio.

Dicho esto, considere el siguiente código.

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

Esto se usa para verificar la versión del SDK compatible en Xcode, esto es si tiene un equipo grande con diferentes versiones de Xcode o múltiples proyectos que admiten diferentes SDK que comparten el mismo código:

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

Lo que realmente quieres es comprobar la versión de iOS en el dispositivo. Puedes hacer eso con esto:

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

Versión rápida:

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 }

Las versiones actuales de swift deberían usar esto:

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

Hay versiones como 7.0 o 6.0.3, por lo que simplemente podemos convertir la versión en números para comparar. Si la versión es como 7.0, simplemente agregue otro ".0" y luego tome su valor numérico.

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];

Para 6.0.0

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

para 7.0

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

Nueva forma de verificar la versión del sistema usando Swift Forget [[UIDevice currentDevice] systemVersion] y NSFoundationVersionNumber.

Podemos usar NSProcessInfo -isOperatingSystemAtLeastVersion

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

Prueba esto

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

Pruebe el siguiente código:

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

Sé que esta es una pregunta antigua, pero alguien debería haber mencionado las macros en tiempo de compilación en Availability.h . Todos los otros métodos aquí son soluciones de tiempo de ejecución, y no funcionarán en un archivo de encabezado, categoría de clase o definición de ivar.

Para estas situaciones, utilizar.

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

h / t this respuesta

Según lo sugerido por los documentos oficiales de Apple : puede usar el NSFoundationVersionNumber , desde el archivo de encabezado NSObjCRuntime.h .

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

Siempre los guardo en mi archivo 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)

Solo para recuperar el valor de la cadena de versión del sistema operativo:

[[UIDevice currentDevice] systemVersion]

Tratar:

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 }

Un poco tarde para la fiesta, pero a la luz de iOS 8.0, esto podría ser relevante:

si puedes evitar usar

[[UIDevice currentDevice] systemVersion]

En su lugar, compruebe la existencia de un método / clase / lo que sea.

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

Descubrí que es útil para el administrador de ubicación donde tengo que llamar a requestWhenInUseAuthorization para iOS 8.0 pero el método no está disponible para iOS <8

Una versión más genérica en Obj-C ++ 11 (probablemente podrías reemplazar algunas de estas cosas con las funciones NSString / C, pero esto es menos detallado. Esto te da dos mecanismos. SplitSystemVersion te da una matriz de todas las partes, lo cual es útil si solo desea activar la versión principal (por ejemplo, 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; }

Usando la forma recomendada recomendada ... si no hay una definición en los archivos de encabezado, siempre puede obtener la versión imprimiéndola en la consola con un dispositivo de la versión de IOS deseada.

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

Yo recomiendo:

if ([[[UIDevice currentDevice] systemVersion] floatValue] > 3.13) { ; // ... }

Crédito: ¿Cómo apuntar a una versión específica de iPhone?

Solución para comprobar la versión de iOS en Swift.

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

Con esta solución: es simplemente una mala práctica verificar los números de versión del SO, sea cual sea la forma en que lo haga. De esta manera, nunca se deben dependencias de código rígido, siempre se deben verificar las características, capacidades o la existencia de una clase. Considera esto; Apple puede lanzar una versión compatible con versiones anteriores de una clase, si lo hicieran, entonces el código que sugieres nunca lo usaría, ya que tu lógica busca un número de versión del sistema operativo y NO la existencia de la clase.

( NSHipster )

Solución para comprobar la existencia de clase en Swift.

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

No lo use if (NSClassFromString("UIAlertController") == nil) porque funciona correctamente en el simulador de iOS con iOS 7.1 y 8.2, pero si realiza la prueba en un dispositivo real con iOS 7.1, lamentablemente notará que nunca pasará a través de la otra parte del fragmento de código.

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

Ejemplo rápido que realmente funciona:

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

No use NSProcessInfo porque no funciona en 8.0, por lo que es bastante inútil hasta 2016

#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)

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

Luego agregue una condición if de la siguiente manera:

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"); }

+(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; } }

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

if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) { // Your code here }

Donde, por supuesto, NSFoundationVersionNumber_iOS_6_1 debe cambiarse según corresponda para la versión de iOS que desee verificar. Lo que he escrito ahora probablemente se usará mucho al probar si un dispositivo está ejecutando iOS7 o una versión anterior.