Quero verificar se a iOSversão do dispositivo é maior do 3.1.3 que tentei coisas como:

[[UIDevice currentDevice].systemVersion floatValue]

mas não funciona, eu só quero um:

if (version > 3.1.3) { }

Como posso conseguir isso?

A resposta rápida ...

A partir do Swift 2.0, você pode usar #availableum ifou guardpara proteger código que só deve ser executado em determinados sistemas.

if #available(iOS 9, *) {}


No Objective-C, você precisa verificar a versão do sistema e realizar uma comparação.

[[NSProcessInfo processInfo] operatingSystemVersion] no iOS 8 e superior.

A partir do Xcode 9:

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

A resposta completa…

Em Objective-C e Swift, em casos raros, é melhor evitar confiar na versão do sistema operacional como uma indicação dos recursos do dispositivo ou do sistema operacional. Geralmente, existe um método mais confiável para verificar se um recurso ou classe específico está disponível.

Verificando a presença de APIs:

Por exemplo, você pode verificar se UIPopoverControllerestá disponível no dispositivo atual usando NSClassFromString:

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

Para classes fracamente vinculadas, é seguro enviar uma mensagem diretamente para a classe. Notavelmente, isso funciona para estruturas que não estão explicitamente vinculadas como "Necessárias". Para classes ausentes, a expressão é avaliada como nula, com falha na condição:

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

Algumas classes, como CLLocationManagere UIDevice, fornecem métodos para verificar os recursos do dispositivo:

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

Verificando a presença de símbolos:

Muito ocasionalmente, você deve verificar a presença de uma constante. Isso surgiu no iOS 8 com a introdução de UIApplicationOpenSettingsURLString, usado para carregar o aplicativo Configurações via -openURL:. O valor não existia antes do iOS 8. A falta de nada para esta API trava, portanto, verifique primeiro a existência da constante:

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

Comparando com a versão do sistema operacional:

Vamos supor que você se depare com a necessidade relativamente rara de verificar a versão do sistema operacional. Para projetos direcionados ao iOS 8 e superior, NSProcessInfoinclui um método para realizar comparações de versão com menos chance de erro:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

Projetos voltados para sistemas mais antigos podem usar systemVersionno UIDevice. A Apple o usa em seu código de amostra 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;
}

Se, por qualquer motivo, você decidir que systemVersioné isso o que deseja, trate-o como uma sequência ou corre o risco de truncar o número de revisão do patch (por exemplo, 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")) {
    ...
}

Conforme sugerido pelos documentos oficiais da Apple : você pode usar o NSFoundationVersionNumber, no NSObjCRuntime.harquivo de cabeçalho.

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

Iniciando o Xcode 9, no Objective-C :

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

Iniciando o Xcode 7, no Swift :

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

Para a versão, você pode especificar o MAJOR, o MINOR ou o PATCH (consulte http://semver.org/ para obter definições). Exemplos:

• iOS 11e iOS 11.0são a mesma versão mínima
• iOS 10, iOS 10.3, iOS 10.3.1São diferentes versões mínimas

Você pode inserir valores para qualquer um desses sistemas:

• iOS, macOS, watchOS,tvOS

Exemplo de caso real retirado de um dos meus pods :

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

documentação

Isso é usado para verificar a versão do SDK compatível no Xcode, isto é, se você tiver uma equipe grande com versões diferentes do Xcode ou vários projetos que suportam SDKs diferentes que compartilham o mesmo código:

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

O que você realmente deseja é verificar a versão do iOS no dispositivo. Você pode fazer isso com isso:

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

Versão Swift:

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
}

As versões atuais do swift devem usar isso:

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

Tentar:

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
}

Abordagem preferida

No Swift 2.0, a Apple adicionou a verificação de disponibilidade usando uma sintaxe muito mais conveniente (Leia mais aqui ). Agora você pode verificar a versão do sistema operacional com uma sintaxe mais limpa:

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

Este é o preferido sobre a verificação respondsToSelectoretc ( O que há de novo no Swift ). Agora, o compilador sempre avisará se você não estiver protegendo seu código corretamente.

Pre Swift 2.0

O novo no iOS 8 está NSProcessInfopermitindo melhores verificações de versão semântica.

Implementando no iOS 8 e superior

Para destinos mínimos de implantação do iOS 8.0 ou superior, use NSProcessInfo operatingSystemVersionou isOperatingSystemAtLeastVersion.

Isso produziria o seguinte:

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

Implantando no iOS 7

Para destinos mínimos de implantação do iOS 7.1 ou inferior, use compare com NSStringCompareOptions.NumericSearchon UIDevice systemVersion.

Isso renderia:

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

Mais leitura em NSHipster .

Eu sempre mantenho aqueles no meu arquivo 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;
  }


}

Com a classe Version contida no projeto nv-ios-version (Licença Apache, versão 2.0), é fácil obter e comparar a versão do iOS. Um código de exemplo abaixo despeja a versão do iOS e verifica se a versão é maior ou 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 do projeto: nv-ios-version
TakahikoKawasaki / nv-ios-version

Blog: Obtenha e compare a versão do iOS em tempo de
execução com a classe Version

Nova maneira de verificar a versão do sistema usando o rápido Forget [[UIDevice currentDevice] systemVersion] e NSFoundationVersionNumber.

Podemos usar 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

Em geral, é melhor perguntar se um objeto pode executar um determinado seletor, em vez de verificar um número de versão para decidir se ele deve estar presente.

Quando isso não é uma opção, você precisa ter um pouco de cuidado aqui, porque [@"5.0" compare:@"5" options:NSNumericSearch]retornos NSOrderedDescendingque podem muito bem não ser pretendidos; Eu poderia esperar NSOrderedSameaqui. Essa é pelo menos uma preocupação teórica, que vale a pena defender contra, na minha opinião.

Também vale a pena considerar é a possibilidade de uma entrada de versão ruim, que não pode ser razoavelmente comparada. A Apple fornece as três constantes predefinidas NSOrderedAscending, NSOrderedSamee NSOrderedDescendingmas eu posso pensar de um uso para alguma coisa chamada NSOrderedUnorderedem caso eu não posso comparar duas coisas e eu quero retornar um valor indicando isso.

Além disso, não é impossível que a Apple um dia expanda suas três constantes predefinidas para permitir uma variedade de valores de retorno, fazendo uma comparação != NSOrderedAscendingimprudente.

Com isso dito, considere o seguinte 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

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

Onde é claro, NSFoundationVersionNumber_iOS_6_1deve ser alterado para aplicável à versão do iOS que você deseja verificar. O que eu escrevi agora provavelmente será muito usado ao testar se um dispositivo está executando o iOS7 ou uma versão anterior.

um pouco atrasado para a festa, mas à luz do iOS 8.0 lá fora, isso pode ser relevante:

se você pode evitar o uso

[[UIDevice currentDevice] systemVersion]

Em vez disso, verifique a existência de um método / classe / qualquer outra coisa.

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

Achei que era útil para o gerenciador de localizações, em que preciso chamar requestWhenInUseAuthorization for iOS 8.0, mas o método não está disponível para iOS <8

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

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

Sei que essa é uma pergunta antiga, mas alguém deveria ter mencionado as macros em tempo de compilação Availability.h. Todos os outros métodos aqui são soluções de tempo de execução e não funcionarão em um arquivo de cabeçalho, categoria de classe ou definição de ivar.

Para essas situações, use

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

h / t esta resposta

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

Em seguida, adicione uma condição if da seguinte maneira: -

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

Existem versões como 7.0 ou 6.0.3, para que possamos simplesmente converter a versão em números para comparar. se a versão for como 7.0, basta acrescentar outro ".0" a ela e, em seguida, levar seu 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];

For 6.0.0

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

para 7.0

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

Experimente o código abaixo:

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

Apenas para recuperar o valor da string da versão do SO:

[[UIDevice currentDevice] systemVersion]

Como uma variação da solução yasimturks, defini uma função e alguns valores de enumeração em vez de cinco macros. Acho mais elegante, mas isso é uma questão de gosto.

Uso:

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

arquivo .h:

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

BOOL systemVersion(Comparison test, NSString* version);

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

Você deve adicionar o prefixo do seu aplicativo aos nomes, especialmente ao Comparisontipo.

Usando a maneira recomendada mencionada ... se não houver definição nos arquivos de cabeçalho, você poderá obter a versão imprimindo-a no console com um dispositivo da versão IOS desejada.

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

Solução para verificar a versão iOS no 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 desta solução: é simplesmente uma má prática verificar os números de versão do sistema operacional, da maneira que você faz. Nunca se deve codificar as dependências dessa maneira, sempre verifique se há recursos, capacidades ou a existência de uma classe. Considere isto; A Apple pode lançar uma versão compatível com versões anteriores de uma classe, se o fizesse, o código sugerido nunca a usaria, pois sua lógica procura um número de versão do sistema operacional e NÃO a existência da classe.

( Fonte desta informação )

Solução para verificar a existência de classe no Swift

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

Não use if (NSClassFromString("UIAlertController") == nil)porque ele funciona corretamente no simulador do iOS usando o iOS 7.1 e 8.2, mas se você testar em um dispositivo real usando o iOS 7.1, infelizmente perceberá que nunca passará pela outra parte do snippet de código.

#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)

Uma versão mais genérica no Obj-C ++ 11 (você provavelmente poderia substituir algumas dessas coisas pelas funções NSString / C, mas isso é menos detalhado. Isso oferece dois mecanismos. SplitSystemVersion fornece uma matriz de todas as partes úteis se você só deseja ativar a versão principal (por exemplo 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;
}

Tente isto

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

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

Não use o NSProcessInfo porque ele não funciona com o 8.0, por isso é praticamente inútil até 2016

Aqui está uma versão rápida:

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

Uso:

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