it-swarm.com.de

Wie überprüfe ich die iOS-Version?

Ich möchte prüfen, ob die iOS-Version des Geräts größer als 3.1.3.__ ist.

[[UIDevice currentDevice].systemVersion floatValue]

aber es funktioniert nicht, ich will nur ein:

if (version > 3.1.3) { }

Wie kann ich das erreichen?

804
John

Die schnelle Antwort…


Ab Swift 2.0 können Sie #available in if oder guard verwenden, um Code zu schützen, der nur auf bestimmten Systemen ausgeführt werden sollte.

if #available(iOS 9, *) {}


In Objective-C müssen Sie die Systemversion überprüfen und einen Vergleich durchführen.

[[NSProcessInfo processInfo] operatingSystemVersion] in iOS 8 und höher.

Ab Xcode 9:

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


Die vollständige Antwort…

In Objective-C und in Swift in seltenen Fällen ist es besser, sich nicht auf die Betriebssystemversion als Hinweis auf Geräte- oder Betriebssystemfähigkeiten zu verlassen. Es gibt normalerweise eine zuverlässigere Methode, um zu überprüfen, ob ein bestimmtes Feature oder eine bestimmte Klasse verfügbar ist.

Überprüfung auf Vorhandensein von APIs:

Beispielsweise können Sie mit UIPopoverController prüfen, ob NSClassFromString auf dem aktuellen Gerät verfügbar ist:

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

Bei schwach verknüpften Klassen ist es sicher, die Klasse direkt zu benachrichtigen. Dies gilt insbesondere für Frameworks, die nicht explizit als "Erforderlich" verknüpft sind. Für fehlende Klassen wird der Ausdruck mit null ausgewertet, was die Bedingung nicht erfüllt:

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

Einige Klassen, wie CLLocationManager und UIDevice, bieten Methoden zum Überprüfen der Gerätefunktionen:

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

Auf Vorhandensein von Symbolen prüfen:

In seltenen Fällen müssen Sie überprüfen, ob eine Konstante vorhanden ist. Dies geschah in iOS 8 mit der Einführung von UIApplicationOpenSettingsURLString, das zum Laden der Einstellungs-App über -openURL: verwendet wurde. Der Wert war vor iOS 8 nicht vorhanden. Die Übergabe von nil an diese API führt zum Absturz. Überprüfen Sie daher zunächst, ob die Konstante vorhanden ist:

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

Vergleich mit der Betriebssystemversion:

Angenommen, Sie sehen sich mit der relativ seltenen Notwendigkeit konfrontiert, die Betriebssystemversion zu überprüfen. Für Projekte mit iOS 8 und höher enthält NSProcessInfo eine Methode zum Durchführen von Versionsvergleichen mit geringerer Fehlerwahrscheinlichkeit:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

Projekte, die auf ältere Systeme abzielen, können systemVersion auf UIDevice verwenden. Apple verwendet es in ihrem GLSprite Beispielcode.

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

Wenn Sie aus irgendeinem Grund entscheiden, dass systemVersion das ist, was Sie wollen, stellen Sie sicher, dass Sie es als Zeichenfolge behandeln, oder Sie riskieren, die Patch-Revisionsnummer abzuschneiden (z. B. 3.1.2 -> 3.1).

960
Justin
/*
 *  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")) {
    ...
}
1044
yasirmturk

Wie in den offiziellen Apple-Dokumenten vorgeschlagen, können Sie die NSFoundationVersionNumber aus der NSObjCRuntime.h-Header-Datei verwenden.

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

Starten Sie Xcode 9 in Objective-C

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

Starten Sie Xcode 7 in Swift

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

Für die Version können Sie MAJOR, MINOR oder PATCH angeben (Definitionen finden Sie unter http://semver.org/ ). Beispiele:

  • iOS 11 und iOS 11.0 sind die gleiche Minimalversion
  • iOS 10, iOS 10.3, iOS 10.3.1 sind verschiedene Minimalversionen

Sie können Werte für jedes dieser Systeme eingeben:

  • iOS, macOS, watchOS, tvOS

Echtes Fallbeispiel aus einer meiner Pods :

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

Dokumentation

77
Cœur

Hiermit wird nach kompatiblen SDK-Versionen in Xcode gesucht. Dies ist der Fall, wenn Sie ein großes Team mit verschiedenen Xcode-Versionen oder mehrere Projekte mit verschiedenen SDKs, die denselben Code verwenden, haben:

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

Was Sie wirklich wollen, ist die iOS-Version auf dem Gerät zu überprüfen. Das kannst du damit machen:

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

Schnelle Version:

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
}

Aktuelle Versionen von Swift sollten Folgendes verwenden:

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

Versuchen:

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

Bevorzugter Ansatz

In Swift 2.0 fügte Apple die Verfügbarkeitsprüfung mit einer weitaus praktischeren Syntax hinzu (Lesen Sie mehr hier ). Jetzt können Sie die Betriebssystemversion mit einer saubereren Syntax überprüfen:

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

Dies ist die bevorzugte Überprüfung von respondsToSelector etc ( Neue Funktionen in Swift ). Der Compiler warnt Sie immer, wenn Sie Ihren Code nicht ordnungsgemäß schützen.


Pre Swift 2.0

Neu in iOS 8 ist NSProcessInfo, wodurch bessere semantische Versionierungsprüfungen möglich sind.

Bereitstellung auf iOS 8 und höher

Verwenden Sie für minimale Implementierungsziele von iOS 8.0 oder höher NSProcessInfooperatingSystemVersion oder isOperatingSystemAtLeastVersion

Dies würde folgendes ergeben:

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

Bereitstellung unter iOS 7

Verwenden Sie für Mindestimplementierungsziele von iOS 7.1 oder darunter den Vergleich mit NSStringCompareOptions.NumericSearch auf UIDevice systemVersion.

Dies würde ergeben:

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

Mehr dazu unter NSHipster .

34
Daniel Galasko

Ich empfehle: 

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

credit: Wie kann man eine bestimmte iPhone-Version anvisieren

17
ohho

Die behalte ich immer in meiner Constants.h-Datei:

#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)
8
Segev
+(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;
  }


}
6
Jef

Mit der Klasse Version, die in nv-ios-version project (Apache License, Version 2.0) enthalten ist, ist es einfach, die iOS-Version abzurufen und zu vergleichen. Ein Beispielcode unten speichert die iOS-Version und prüft, ob die Version größer oder gleich 6.0 ist.

// 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.
}

Projektseite: nv-ios-version
TakahikoKawasaki/nv-ios-Version

Blog: iOS-Version zur Laufzeit mit Version-Klasse abrufen und vergleichen
iOS-Version zur Laufzeit mit Version-Klasse abrufen und vergleichen

6

Neue Möglichkeit zur Überprüfung der Systemversion mit der Systemversion Swift Forget [[UIDevice currentDevice] und NSFoundationVersionNumber.

Wir können NSProcessInfo -isOperatingSystemAtLeastVersion verwenden

     import Foundation

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

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
Oliver Pearmain
if (floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1) {
        // Your code here
}

Wo muss natürlich NSFoundationVersionNumber_iOS_6_1 geändert werden, und zwar für die iOS-Version, die Sie überprüfen möchten. Was ich jetzt geschrieben habe, wird wahrscheinlich beim Testen, ob auf einem Gerät iOS7 oder eine frühere Version ausgeführt wird, häufig verwendet.

4
OscarWyck

etwas spät zur Party, aber angesichts von iOS 8.0 könnte dies relevant sein:

wenn Sie es vermeiden können 

[[UIDevice currentDevice] systemVersion]

Überprüfen Sie stattdessen, ob eine Methode/Klasse/was auch immer vorhanden ist.

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

Ich fand es nützlich für den Standort-Manager, wo ich requestWhenInUseAuthorization für iOS 8.0 aufrufen muss, aber die Methode ist für iOS <8 nicht verfügbar

4
Denis Kanygin

Im Allgemeinen ist es besser zu fragen, ob ein Objekt einen bestimmten Selektor ausführen kann, anstatt eine Versionsnummer zu überprüfen, um zu entscheiden, ob es vorhanden sein muss.

Wenn dies keine Option ist, müssen Sie hier etwas vorsichtig sein, da [@"5.0" compare:@"5" options:NSNumericSearch]NSOrderedDescending zurückgibt, was möglicherweise überhaupt nicht beabsichtigt ist. Ich könnte hier NSOrderedSame erwarten. Dies ist zumindest ein theoretisches Anliegen, gegen das es meiner Meinung nach zu verteidigen gilt.

Überlegenswert ist auch die Möglichkeit einer fehlerhaften Versionseingabe, die sich nicht vernünftigerweise mit dieser vergleichen lässt. Apple liefert die drei vordefinierten Konstanten NSOrderedAscending, NSOrderedSame und NSOrderedDescending, aber ich kann mir eine Verwendung für etwas namens NSOrderedUnordered vorstellen, falls ich nicht zwei Dinge vergleichen kann und einen Wert zurückgeben möchte, der dies anzeigt.

Außerdem ist es nicht unmöglich, dass Apple eines Tages seine drei vordefinierten Konstanten erweitert, um eine Vielzahl von Rückgabewerten zu ermöglichen, und einen Vergleich != NSOrderedAscending unklug macht.

Berücksichtigen Sie dabei den folgenden Code.

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
4
SK9
#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)

Fügen Sie dann eine if-Bedingung wie folgt hinzu: -

if(SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"10.0")) {
   //Your code
}       
3
#define _kisiOS7 ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0)

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

Versuchen Sie den folgenden Code:

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

Es gibt Versionen wie 7.0 oder 6.0.3, sodass wir die Version zum Vergleich einfach in Zahlen umwandeln können. Wenn Version 7.0 ist, fügen Sie einfach ein weiteres ".0" hinzu und nehmen Sie dann den numerischen Wert.

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

Für 6.0.0

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

für 7.0

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

Nur zum Abrufen des OS-Versionszeichenfolgenwerts:

[[UIDevice currentDevice] systemVersion]
#define IsIOS8 (NSFoundationVersionNumber > NSFoundationVersionNumber_iOS_7_1)
1
Gank

Ich weiß, dass dies eine alte Frage ist, aber jemand hätte die Kompilierungsmakros in Availability.h erwähnen sollen. Alle anderen Methoden hier sind Laufzeitlösungen und funktionieren nicht in einer Header-Datei, Klassenkategorie oder IVAR-Definition. 

Verwenden Sie für diese Situationen 

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

h/t dies antwort

1
bcattle

Verwenden der empfohlenen Methode ... Wenn in den Header-Dateien keine Definition vorhanden ist, können Sie die Versión immer auf der Konsole mit einem Gerät der gewünschten IOS -Version ausdrucken.

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

Als Variation der yasimturks-Lösung definierte ich anstelle von fünf Makros eine Funktion und einige Enumerationswerte. Ich finde es eleganter, aber das ist Geschmackssache.

Verwendungszweck:

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

.h Datei:

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

BOOL systemVersion(Comparison test, NSString* version);

.m Datei:

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

Sie sollten das Präfix Ihrer App zu den Namen hinzufügen, insbesondere zum Typ Comparison.

1
jcsahnwaldt

Lösung zur Überprüfung der iOS-Version in 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 dieser Lösung: Es ist einfach unpraktisch, die Versionsnummern des Betriebssystems zu überprüfen, wie auch immer Sie es tun. Man sollte niemals Abhängigkeiten auf diese Weise hart codieren, immer nach Features, Fähigkeiten oder der Existenz einer Klasse suchen. Bedenken Sie; Apple veröffentlicht möglicherweise eine abwärtskompatible Version einer Klasse. Andernfalls würde der von Ihnen vorgeschlagene Code ihn niemals verwenden, da Ihre Logik nach einer Betriebssystemversionsnummer sucht und NICHT nach der Klasse.

( Quelle dieser Informationen )

Lösung zur Überprüfung der Klassenexistenz in Swift

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

Verwenden Sie if (NSClassFromString("UIAlertController") == nil) nicht, da es auf dem iOS-Simulator unter iOS 7.1 und 8.2 ordnungsgemäß funktioniert. Wenn Sie jedoch auf einem realen Gerät mit iOS 7.1 testen, werden Sie leider feststellen, dass Sie niemals den else-Teil des Code-Snippets passieren.

1
King-Wizard

Versuche dies

if ([[[UIDevice currentDevice] systemVersion] floatValue] >= 7) { 
// do some work
}
0
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
0
GJDK

Eine generischere Version in Obj-C++ 11 (Sie könnten wahrscheinlich einige dieser Funktionen durch die NSString/C-Funktionen ersetzen, dies ist jedoch weniger ausführlich. Dies gibt Ihnen zwei Mechanismen.) Sie möchten nur die Hauptversion einschalten (zB 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;
}
0
Vitali

Hier ist eine Swift-Version:

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

Verwendungszweck:

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

Ein schnelles Beispiel, das tatsächlich funktioniert:

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

Verwenden Sie NSProcessInfo nicht, da es unter 8.0 nicht funktioniert. Daher ist es bis 2016 ziemlich nutzlos

0
Esqarrouth

Fügen Sie den folgenden Swift-Code in Ihr Projekt ein und greifen Sie auf Informationen wie die iOS-Version und das Gerät zu.

class DeviceInfo: NSObject {

    struct ScreenSize
    {
        static let SCREEN_WIDTH = UIScreen.main.bounds.size.width
        static let SCREEN_HEIGHT = UIScreen.main.bounds.size.height
        static let SCREEN_MAX_LENGTH = max(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
        static let SCREEN_MIN_LENGTH = min(ScreenSize.SCREEN_WIDTH, ScreenSize.SCREEN_HEIGHT)
    }

    struct DeviceType
    {
        static let IS_IPHONE_4_OR_LESS =  UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH < 568.0
        static let IS_IPHONE_5 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 568.0
        static let IS_IPHONE_6 = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH >= 667.0
        static let IS_IPHONE_6P = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 736.0
        static let IS_IPHONE_X = UIDevice.current.userInterfaceIdiom == .phone && ScreenSize.SCREEN_MAX_LENGTH == 812.0
        static let IS_IPAD      = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1024.0
        static let IS_IPAD_PRO  = UIDevice.current.userInterfaceIdiom == .pad && ScreenSize.SCREEN_MAX_LENGTH == 1366.0
    }

    struct VersionType{
        static let SYS_VERSION_FLOAT = (UIDevice.current.systemVersion as NSString).floatValue
        static let iOS7 = (VersionType.SYS_VERSION_FLOAT < 8.0 && VersionType.SYS_VERSION_FLOAT >= 7.0)
        static let iOS8 = (VersionType.SYS_VERSION_FLOAT >= 8.0 && VersionType.SYS_VERSION_FLOAT < 9.0)
        static let iOS9 = (VersionType.SYS_VERSION_FLOAT >= 9.0 && VersionType.SYS_VERSION_FLOAT < 10.0)
        static let iOS10 = (VersionType.SYS_VERSION_FLOAT >= 9.0 && VersionType.SYS_VERSION_FLOAT < 11.0)
    }
}
0
Kiran K

Hier ist eine schnelle Version von Yasirmturk-Makros. Hoffe, es hilft einigen Völkern

// MARK: System versionning

func SYSTEM_VERSION_EQUAL_TO(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedSame
}

func SYSTEM_VERSION_GREATER_THAN(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedDescending
}

func SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) != NSComparisonResult.OrderedAscending
}

func SYSTEM_VERSION_LESS_THAN(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedAscending
}

func SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v: String) -> Bool {
    return UIDevice.currentDevice().systemVersion.compare(v, options: NSStringCompareOptions.NumericSearch) != NSComparisonResult.OrderedDescending
}

let kIsIOS7: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("7")
let kIsIOS7_1: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("7.1")
let kIsIOS8: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("8")
let kIsIOS9: Bool = SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO("9")
0
Beninho85