Comment vérifier la version iOS?
Je veux vérifier si la iOS
version de l'appareil est supérieure à 3.1.3
J'ai essayé des choses comme:
[[UIDevice currentDevice].systemVersion floatValue]
Mais ça ne marche pas, je veux juste un:
if (version > 3.1.3) { }
Comment puis-je y parvenir?
30 réponses
La réponse rapide ...
Depuis Swift 2.0, vous pouvez utiliser #available
dans un if
ou guard
pour protéger le code qui ne doit être exécuté que sur certains systèmes.
if #available(iOS 9, *) {}
Dans Objective-C, vous devez vérifier la version du système et effectuer une comparaison.
[[NSProcessInfo processInfo] operatingSystemVersion]
dans iOS 8 et au-dessus.
À partir de Xcode 9:
if (@available(iOS 9, *)) {}
La réponse complète ...
Dans Objective-C, et Swift dans de rares cas, il vaut mieux éviter en s'appuyant sur la version du système d'exploitation comme une indication de l'appareil ou fonctionnalités du système d'exploitation. Il existe généralement une méthode plus fiable pour vérifier si une caractéristique ou une classe particulière est disponible.
Vérification de la présence D'API:
Par exemple, vous pouvez vérifier si UIPopoverController
est disponible sur le périphérique actuel en utilisant NSClassFromString
:
if (NSClassFromString(@"UIPopoverController")) {
// Do something
}
Pour les classes faiblement liées, il est sûr d'envoyer un message directement à la classe. Notamment, cela fonctionne pour les frameworks qui ne sont pas explicitement lié comme "requis". Pour les classes manquantes, l'expression est évaluée à nil, à défaut de la condition:
if ([LAContext class]) {
// Do something
}
Certaines classes, comme CLLocationManager
et UIDevice
, fournissent des méthodes pour vérifier les capacités de l'appareil:
if ([CLLocationManager headingAvailable]) {
// Do something
}
La Vérification de la présence de symboles:
Très occasionnellement, vous devez vérifier la présence d'une constante. Cela est apparu dans iOS 8 avec l'introduction de UIApplicationOpenSettingsURLString
, utilisé pour charger L'application Paramètres via -openURL:
. La valeur n'existait pas avant iOS 8. Passer nil à cette API va planter, vous devez donc prendre soin de vérifier l'existence de la constante en premier:
if (&UIApplicationOpenSettingsURLString != NULL) {
[[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
}
Comparaison avec la version du système d'exploitation:
Supposons que vous soyez confronté au besoin relativement rare de vérifier la version du système d'exploitation. Pour les projets ciblant iOS 8 et supérieur, NSProcessInfo
inclut une méthode pour effectuer des comparaisons de versions avec moins de risque d'erreur:
- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version
Les projets ciblant des systèmes plus anciens peuvent utiliser systemVersion
sur UIDevice
. Apple l'utilise dans leurGLSprite exemple de code.
// 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, pour une raison quelconque, vous décidez que systemVersion
Est ce que vous voulez, assurez-vous de le traiter comme une chaîne ou vous risquez de tronquer le numéro de révision du patch (par exemple. 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")) {
...
}
Comme suggéré par les documents officiels Apple : vous pouvez utiliser le NSFoundationVersionNumber
, à partir du fichier d'en-tête NSObjCRuntime.h
.
if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) {
// here you go with iOS 7
}
Démarrage de Xcode 9, dans Objective-C :
if (@available(iOS 11, *)) {
// iOS 11 (or newer) ObjC code
} else {
// iOS 10 or older code
}
Démarrage de Xcode 7, dans Swift :
if #available(iOS 11, *) {
// iOS 11 (or newer) Swift code
} else {
// iOS 10 or older code
}
Pour la version, vous pouvez spécifier la majeure, la mineure ou le correctif (voir http://semver.org / pour les définitions). Exemples:
-
iOS 11
etiOS 11.0
sont de la même version minimale -
iOS 10
,iOS 10.3
,iOS 10.3.1
sont différents minimale versions
, Vous pouvez entrer des valeurs pour l'un de ces systèmes:
-
iOS
,macOS
,watchOS
,tvOS
Exemple de cas réel tiré de un de mes pods :
if #available(iOS 10.0, tvOS 10.0, *) {
// iOS 10+ and tvOS 10+ Swift code
} else {
// iOS 9 and tvOS 9 older code
}
Essayez:
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
}
Ceci est utilisé pour vérifier la version du SDK compatible dans Xcode, c'est si vous avez une grande équipe avec différentes versions de Xcode ou plusieurs projets prenant en charge différents SDK qui partagent le même code:
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 80000
//programming in iOS 8+ SDK here
#else
//programming in lower than iOS 8 here
#endif
Ce que vous voulez vraiment est de vérifier la version iOS sur l'appareil. Vous pouvez le faire avec ceci:
if ([[[UIDevice currentDevice] systemVersion] floatValue] < 8.0) {
//older than iOS 8 code here
} else {
//iOS 8 specific code here
}
Version 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
}
Les versions actuelles de swift devraient utiliser ceci:
if #available(iOS 12, *) {
//iOS 12 specific code here
} else {
//older than iOS 12 code here
}
Approche Privilégiée
Dans Swift 2.0, Apple a ajouté la vérification de la disponibilité en utilisant une syntaxe beaucoup plus pratique (Lire la suite ici). Maintenant, vous pouvez vérifier la version du système d'exploitation avec une syntaxe plus propre:
if #available(iOS 9, *) {
// Then we are on iOS 9
} else {
// iOS 8 or earlier
}
C'est le préféré par rapport à la vérification respondsToSelector
etc ( Quoi de neuf dans Swift ). Maintenant, le compilateur vous avertira toujours si vous ne protégez pas votre code correctement.
Pré Swift 2.0
Nouveau dans iOS 8 est NSProcessInfo
permettant une meilleure gestion des versions sémantiques vérifier.
Déploiement sur iOS 8 et supérieur
Pour des cibles de déploiement minimales de iOS 8.0 ou supérieures, utilisez
NSProcessInfo
operatingSystemVersion
ouisOperatingSystemAtLeastVersion
.
Cela donnerait ce qui suit:
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)
}
Déploiement sur iOS 7
Pour des cibles de déploiement minimales de iOS 7.1 ou inférieures, utilisez comparer avec
NSStringCompareOptions.NumericSearch
surUIDevice systemVersion
.
Cela donnerait:
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;
}
Plus de lecture à NSHipster.
Je recommande:
if ([[[UIDevice currentDevice] systemVersion] floatValue] > 3.13) {
; // ...
}
Je les garde toujours dans mes constantes.fichier 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;
}
}
Avec la classe Version contenue dans le projet NV-iOS-version (Licence Apache, Version 2.0), Il est facile d'obtenir et de comparer la version iOS. Un exemple de code ci-dessous vide la version iOS et vérifie si la version est supérieure ou égale à 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.
}
Page du Projet: nv-ios-version
TakahikoKawasaki/nv-ios-version
Blog: Obtenez et comparez la version iOS à l'exécution avec la classe de Version
obtenez et comparez iOS version à l'exécution avec la classe de Version
Nouvelle façon de vérifier la version du système en utilisant swift Forget [[UIDevice currentDevice] systemVersion] et NSFoundationVersionNumber.
Nous pouvons utiliser 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
En général, il est préférable de demander si un objet peut effectuer un sélecteur donné, plutôt que de vérifier un numéro de version pour décider s'il doit être présent.
Lorsque ce n'est pas une option, vous devez être un peu prudent ici parce que [@"5.0" compare:@"5" options:NSNumericSearch]
renvoie NSOrderedDescending
ce qui pourrait bien ne pas être prévu du tout; je pourrais m'attendre à NSOrderedSame
ici. C'est au moins une préoccupation théorique, qui mérite d'être défendue à mon avis.
Il convient également de considérer la possibilité d'une mauvaise entrée de version qui ne peut pas raisonnablement être comparés. Apple fournit les trois constantes prédéfiniesNSOrderedAscending
, NSOrderedSame
et NSOrderedDescending
mais je peux penser à une utilisation pour quelque chose appelée NSOrderedUnordered
dans le cas où je ne peux pas comparer deux choses et je veux retourner une valeur indiquant cela.
De plus, il n'est pas impossible Qu'Apple étende un jour ses trois constantes prédéfinies pour permettre une variété de valeurs de retour, faisant une comparaison != NSOrderedAscending
imprudente.
Ceci étant dit, considérez le code suivant.
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
}
Où bien sûr, NSFoundationVersionNumber_iOS_6_1
doit être changé en par applicable pour la version iOS que vous souhaitez vérifier. Ce que j'ai maintenant écrit sera probablement beaucoup utilisé lors du test si un appareil exécute iOS7 ou une version précédente.
Un peu en retard à la fête mais à la lumière d'iOS 8.0 là-bas, cela pourrait être pertinent:
Si vous pouvez éviter d'utiliser
[[UIDevice currentDevice] systemVersion]
Au lieu de cela, vérifiez l'existence d'une méthode/classe/quoi que ce soit d'autre.
if ([self.yourClassInstance respondsToSelector:@selector(<yourMethod>)])
{
//do stuff
}
Je l'ai trouvé utile pour location manager où je dois appeler requestWhenInUseAuthorization pour iOS 8.0 mais la méthode n'est pas disponible pour iOS
#define _kisiOS7 ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0)
if (_kisiOS7) {
NSLog(@"iOS7 or greater")
}
else {
NSLog(@"Less than iOS7");
}
#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v) ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
Puis ajoutez une condition if comme suit: -
if(SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"10.0")) {
//Your code
}
Il existe des versions comme 7.0 ou 6.0.3, donc nous pouvons simplement convertir la version en numerics pour comparer. si la version est comme 7.0, ajoutez simplement un autre ".0 " et ensuite prendre sa valeur numérique.
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];
Pour 6.0.0
if (version==600) {
// Do something
}
Pour 7.0
if (version==700) {
// Do something
}
Essayez le code ci-dessous:
NSString *versionString = [[UIDevice currentDevice] systemVersion];
Juste pour récupérer la valeur de la chaîne de version du système D'exploitation:
[[UIDevice currentDevice] systemVersion]
En tant que variante de la solution yasimturks, j'ai défini une fonction et quelques valeurs enum au lieu de cinq macros. Je trouve ça plus élégant, mais c'est une question de goût.
Utilisation:
if (systemVersion(LessThan, @"5.0")) ...
.fichier h:
typedef enum {
LessThan,
LessOrEqual,
Equal,
GreaterOrEqual,
GreaterThan,
NotEqual
} Comparison;
BOOL systemVersion(Comparison test, NSString* version);
.m fichier:
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;
}
}
Vous devez ajouter le préfixe de votre application aux noms, en particulier au type Comparison
.
Je sais que c'est une vieille question, mais quelqu'un aurait dû mentionner les macros de compilation dans Availability.h
. Toutes les autres méthodes ici sont des solutions d'exécution et ne fonctionneront pas dans un fichier d'en-tête, une catégorie de classe ou une définition ivar.
Pour ces situations, utilisez
#if __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_6_0
// iOS 6+ code here
#else
// Pre iOS 6 code here
#endif
H/t ce réponse
En utilisant la manière recommandée référencée... s'il n'y a pas de définition dans les fichiers d'en-tête, vous pouvez toujours obtenir la version l'imprimer sur la console avec un périphérique de la version iOS souhaitée.
- (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;
}
Solution pour vérifier la version d'iOS dans 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 de cette solution: c'est simplement une mauvaise pratique de vérifier les numéros de version du système D'exploitation, quelle que soit la façon dont vous le faites. Il ne faut jamais les dépendances de code dur de cette façon, toujours vérifier les fonctionnalités, les capacités ou l'existence d'une classe. Considérez ceci; Apple peut publier une version rétrocompatible d'une classe, s'ils l'ont fait, le code que vous suggérez ne l'utiliserait jamais car votre logique recherche un numéro de version du système d'exploitation et non l'existence de la classe.
Solution pour vérifier l'existence de la classe dans Swift
if (objc_getClass("UIAlertController") == nil) {
// iOS 7
} else {
// iOS 8+
}
N'utilisez pas if (NSClassFromString("UIAlertController") == nil)
car il fonctionne correctement sur le simulateur iOS en utilisant iOS 7.1 et 8.2, mais si vous testez sur un appareil réel en utilisant iOS 7.1, vous remarquerez malheureusement que vous ne passerez jamais à travers la partie autre de l'extrait de code.
#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)
Une version plus générique dans Obj-C++ 11 (vous pourriez probablement remplacer certaines de ces choses par les fonctions NSString/C, mais c'est moins verbeux. Cela vous donne deux mécanismes. splitSystemVersion vous donne un tableau de toutes les parties qui est utile si vous voulez juste activer la version majeure (par exemple 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;
}
Essayez ceci
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
Exemple Swift qui fonctionne réellement:
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'utilisez pas NSProcessInfo car il ne fonctionne pas sous 8.0, donc c'est à peu près inutile jusqu'en 2016