191

Sto cercando di controllare le informazioni di sistema in Swift. Ho capito che poteva essere raggiunto con il codice:

var sysData:CMutablePointer<utsname> = nil
let retVal:CInt = uname(sysData)

Ho due problemi con questo codice:

Quale dovrebbe essere il valore iniziale di sysData? Questo esempio fornisce -1 in retVal probabilmente perché sysData è zero.
Come posso leggere le informazioni da sysData?

ios macos swift

— Gergely
fonte

388

Per iOS, prova:

var systemVersion = UIDevice.current.systemVersion

Per OS X, prova:

var systemVersion = NSProcessInfo.processInfo().operatingSystemVersion

Se vuoi solo verificare se gli utenti eseguono almeno una versione specifica, puoi anche utilizzare la seguente funzione Swift 2 che funziona su iOS e OS X:

if #available(iOS 9.0, *) {
    // use the feature only available in iOS 9
    // for ex. UIStackView
} else {
    // or use some work around
}

MA non è consigliabile controllare la versione del sistema operativo. È meglio verificare se la funzionalità che si desidera utilizzare è disponibile sul dispositivo piuttosto che confrontare i numeri di versione. Per iOS, come detto sopra, è necessario verificare se risponde a un selettore; per esempio.:

if (self.respondsToSelector(Selector("showViewController"))) {
    self.showViewController(vc, sender: self)
} else {
    // some work around
}

— Miho
fonte

Sebbene ciò sia corretto per l'obiettivo c, esiste un modo molto più semplice di farlo rapidamente. Delineato qui ... hackingwithswift.com/new-syntax-swift-2-availability-checking

— Fogmeister

2

Un uso che posso vedere per verificare direttamente la versione del sistema operativo (invece di verificare funzionalità specifiche) è quello di raccogliere dati sulla distribuzione della versione del sistema operativo tra i tuoi utenti, per determinare la destinazione di distribuzione più bassa.

— Nicolas Miari,

91

Aggiornamento:
ora dovresti usare il nuovo controllo di disponibilità introdotto con Swift 2:
ad es. Per verificare iOS 9.0 o successivo al momento della compilazione usa questo:

if #available(iOS 9.0, *) {
    // use UIStackView
} else {
    // show sad face emoji
}

o può essere utilizzato con intero metodo o classe

@available(iOS 9.0, *)
func useStackView() {
    // use UIStackView
}

Per maggiori informazioni vedi questo .

Controlli del tempo di esecuzione:

se non vuoi la versione esatta ma vuoi controllare iOS 9,10 o 11 usando se:

let floatVersion = (UIDevice.current.systemVersion as NSString).floatValue

EDIT: ho appena trovato un altro modo per raggiungere questo obiettivo:

let iOS8 = floor(NSFoundationVersionNumber) > floor(NSFoundationVersionNumber_iOS_7_1)
let iOS7 = floor(NSFoundationVersionNumber) <= floor(NSFoundationVersionNumber_iOS_7_1)

— Aks
fonte

50

Ho trasformato rapidamente le funzioni di supporto che sono state trasferite dal link seguente:

Come possiamo rilevare a livello di programmazione su quale versione iOS è in esecuzione il dispositivo?

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

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

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

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

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

Può essere usato così:

SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO("7.0")

Rapido 4.2

func SYSTEM_VERSION_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) == .orderedSame
}

func SYSTEM_VERSION_GREATER_THAN(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) == .orderedDescending
}

func SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) != .orderedAscending
}

func SYSTEM_VERSION_LESS_THAN(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) == .orderedAscending
}

func SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) != .orderedDescending
}

— KVISH
fonte

31

Swift 5

Non è necessario creare l'estensione poiché ProcessInfoci fornisce le informazioni sulla versione. Puoi vedere il codice di esempio per iOS come di seguito.

let os = ProcessInfo().operatingSystemVersion

switch (os.majorVersion, os.minorVersion, os.patchVersion) {
case (let x, _, _) where x < 8:
    print("iOS < 8.0.0"

case (8, 0, _):
    print("iOS >= 8.0.0, < 8.1.0")

case (8, _, _):
    print("iOS >= 8.1.0, < 9.0")

case (9, _, _):
    print("iOS >= 9.0.0")

default:
    print("iOS >= 10.0.0")
}

Riferimento: http://nshipster.com/swift-system-version-checking/

— nahung89
fonte

17

Swift 5

func run() {
    let version = OperatingSystemVersion(majorVersion: 13, minorVersion: 0, patchVersion: 0)
    if ProcessInfo.processInfo.isOperatingSystemAtLeast(version) {
        runNewCode()
    } else {
        runLegacyCode()
    }
}

func runNewCode() {
    guard #available(iOS 13.0, *) else {
        fatalError()
    }
    // do new stuff
}

func runLegacyCode() {
    // do old stuff
}

— neoneye
fonte

1

perché in runNewCode è necessario #available (iOS 11.0, *)?

— Illya Krit,

1

@IllyaKrit Il #available(...)blocco impedisce al compilatore di visualizzare errori per il codice che non è supportato nelle versioni precedenti a quelle fornite.

— future-adam,

15

Ho creato questo Singleton per un semplice utilizzo, ho creato un IOSVersion.swiftfile e aggiunto questo codice:

import UIKit

public class IOSVersion {
    class func SYSTEM_VERSION_EQUAL_TO(version: NSString) -> Bool {
        return UIDevice.currentDevice().systemVersion.compare(version,
            options: NSStringCompareOptions.NumericSearch) == NSComparisonResult.OrderedSame
    }

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

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

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

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

USO :

IOSVersion.SYSTEM_VERSION_EQUAL_TO("8.0")
IOSVersion.SYSTEM_VERSION_LESS_THAN("8.0")

Grazie @KVISH

Modifica Swift 2:

if #available(iOS 9.0, *) {
    // 👍 
} else {
    // 👎
}

— YannSteph
fonte

4

È singleton? o semplicemente funzioni di classe su IOSVersion? non sarebbe un singleton static let shared = IOSVersion

— Charlton Provatas

9

Se stai utilizzando Swift 2 e desideri verificare la versione del sistema operativo per utilizzare una determinata API, puoi utilizzare la nuova funzionalità di disponibilità:

if #available(iOS 8, *) {
    //iOS 8+ code here.
}
else {
    //Code for iOS 7 and older versions.
    //An important note: if you use #availability, Xcode will also 
    //check that you don't use anything that was introduced in iOS 8+
    //inside this `else` block. So, if you try to use UIAlertController
    //here, for instance, it won't compile. And it's great.
}

Ho scritto questa risposta perché è la prima domanda in Google per la swift 2 check system versionquery.

— FreeNickname
fonte

7

Aggiornamento per Swift 3.0+

func SYSTEM_VERSION_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) == ComparisonResult.orderedSame
}

func SYSTEM_VERSION_GREATER_THAN(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) == ComparisonResult.orderedDescending
}

func SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) != ComparisonResult.orderedAscending
}

func SYSTEM_VERSION_LESS_THAN(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) == ComparisonResult.orderedAscending
}

func SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: .numeric) != ComparisonResult.orderedDescending
}

— Mellong Lau
fonte

1

Può saltare ComparisonResultper renderlo più breve.

— John Pang,

Inoltre, il factoring UIDevice.current.systemVersion.compare(version, options: .numeric)in a funcpuò aiutare a leggere il codice.

— John Pang,

5

Dettagli

Xcode 10.2.1 (10E1001), Swift 5

link

OperatingSystemVersion

Soluzione

extension OperatingSystemVersion {
    func getFullVersion(separator: String = ".") -> String {
        return "\(majorVersion)\(separator)\(minorVersion)\(separator)\(patchVersion)"
    }
}

let os = ProcessInfo().operatingSystemVersion
print(os.majorVersion)          // 12
print(os.minorVersion)          // 2
print(os.patchVersion)          // 0
print(os.getFullVersion())      // 12.2.0

— Vasily Bodnarchuk
fonte

1

Non ci sono potenziali problemi di arrotondamento quando si utilizza Doubleper un numero di versione, ad esempio 10.0999invece di 10.1?

— mschmidt,

No var stringVersion = "10.0999"; print(stringVersion.toDouble!) // print 10.0999, stamperà10.0999

— Vasily Bodnarchuk il

4

let Device = UIDevice.currentDevice()
let iosVersion = NSString(string: Device.systemVersion).doubleValue

let iOS8 = iosVersion >= 8
let iOS7 = iosVersion >= 7 && iosVersion < 8

e controlla come

if(iOS8)
{

}
else 
{
}

— poojathorat
fonte

4

Il modo più semplice e più semplice per controllare la versione del sistema (e molte altre versioni) in Swift 2 e versioni successive è:

if #available(iOS 9.0, *) { // check for iOS 9.0 and later

}

Inoltre, con #availablete puoi controllare le versioni di questi:

iOS
iOSApplicationExtension
macOS
macOSApplicationExtension
watchOS
watchOSApplicationExtension
tvOS
tvOSApplicationExtension
swift

— Tengai
fonte

2

Mattt Thompson condivide un modo molto utile

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

— dVaffection
fonte

2

Swift 4.x

func iOS_VERSION_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: NSString.CompareOptions.numeric) == ComparisonResult.orderedSame
}

func iOS_VERSION_GREATER_THAN(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: NSString.CompareOptions.numeric) == ComparisonResult.orderedDescending
}

func iOS_VERSION_GREATER_THAN_OR_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: NSString.CompareOptions.numeric) != ComparisonResult.orderedAscending
}

func iOS_VERSION_LESS_THAN(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: NSString.CompareOptions.numeric) == ComparisonResult.orderedAscending
}

func iOS_VERSION_LESS_THAN_OR_EQUAL_TO(version: String) -> Bool {
    return UIDevice.current.systemVersion.compare(version, options: NSString.CompareOptions.numeric) != ComparisonResult.orderedDescending
}

Uso:

if iOS_VERSION_GREATER_THAN_OR_EQUAL_TO(version: "11.0") {
    //Do something!
}

_{Risposta di PS KVISH tradotta in Swift 4.x con la ridenominazione delle funzioni, in quanto sto utilizzando questo frammento per l'app iOS.}

— Hemang
fonte

1

Nota: disponibile in iOS 8.0 e versioni successive. OS X v10.10 e versioni successive

var majorVersion: Int    { return NSProcessInfo.processInfo().operatingSystemVersion.majorVersion }
var minorVersion: Int    { return NSProcessInfo.processInfo().operatingSystemVersion.minorVersion }
var patchVersion: Int    { return NSProcessInfo.processInfo().operatingSystemVersion.patchVersion }
var myOSVersion:  String { return NSProcessInfo.processInfo().operatingSystemVersionString        }

— Leo Dabus
fonte

1

Basato sulla risposta di Matt Thompson, ecco un metodo con i rispettivi test unitari che funziona con Swift e Objective-c su iOS 7 e versioni successive (incluso iOS 9 che non consente più di controllare NSFoundationNumber ):

+ (BOOL) isAtLeastOSVersion:(NSString *)osVersion
{
    switch ([[UIDevice currentDevice].systemVersion compare:osVersion options:NSNumericSearch]) {
        case NSOrderedSame:
        case NSOrderedDescending:
            return YES;
        default:
            return NO;
    }
}

.

@interface ANFakeCurrDevice : NSObject
@property (nonatomic, strong) NSString *systemVersion;
@end
@implementation ANFakeCurrDevice
@end


@implementation MyHelperClassUnitTests

- (void)setUp {
    [super setUp];
}

- (void)tearDown {
    [super tearDown];
}

- (void)test_isAtLeastOSVersion
{
    id deviceMock = [OCMockObject niceMockForClass:[UIDevice class]];
    ANFakeCurrDevice *fakeCurrDevice = [ANFakeCurrDevice new];
    fakeCurrDevice.systemVersion = @"99.9.9";
    [[[deviceMock stub] andReturn:fakeCurrDevice] currentDevice];
    XCTAssertTrue([[UIDevice currentDevice].systemVersion isEqualToString:@"99.9.9"]);

    fakeCurrDevice.systemVersion = @"1.0.1";
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"1"]);
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"1.0"]);
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"1.0.1"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"1.0.2"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"1.1.0"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"2"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"2.0"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"2.0.0"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"2.0.1"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"2.1.0"]);


    fakeCurrDevice.systemVersion = @"8.4.0";
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"7.0.1"]);
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"8"]);
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"8.4"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"8.4.1"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"8.4.2"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"9.0"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"9.0.1"]);
    XCTAssertFalse([ANConstants isAtLeastOSVersion:@"9.0.2"]);
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"8.4"] && ![ANConstants isAtLeastOSVersion:@"9.0"]);

    fakeCurrDevice.systemVersion = @"8.4.1";
    XCTAssertTrue([ANConstants isAtLeastOSVersion:@"8.4"] && ![ANConstants isAtLeastOSVersion:@"9.0"]);
}


@end

— n8tr
fonte

ti rendi conto che il metodo attuale è molto breve e compatto e che ho appena aggiunto il codice unit test per l'illustrazione e la prova che funziona, giusto?

— n8tr

Mi dispiace di non aver capito che è XCTest a colpo d'occhio.

— DawnSong,

1

let osVersion = NSProcessInfo.processInfo().operatingSystemVersion
let versionString = osVersion.majorVersion.description + "." + osVersion.minorVersion.description + "." + osVersion.patchVersion.description
print(versionString)

— Matjan
fonte

0

Anche se vuoi controllare WatchOS.

veloce

let watchOSVersion = WKInterfaceDevice.currentDevice().systemVersion
print("WatchOS version: \(watchOSVersion)")

Objective-C

NSString *watchOSVersion = [[WKInterfaceDevice currentDevice] systemVersion];
NSLog(@"WatchOS version: %@", watchOSVersion);

— Edison
fonte

0

Ottieni la versione corrente del sistema e suddividila. Quindi puoi ottenere la versione principale e secondaria.

let sys_version = UIDevice.current.systemVersion
let all_version = sys_version.components(separatedBy: ".")
print("Major version : \(all_version[0])")
print("Minor version : \(all_version[1])")

— Mili Shah
fonte

0

La maggior parte dei codici di esempio scritti qui otterrà risultati imprevisti con versioni extra-zero. Per esempio,

func SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(version: String) -> Bool {
return UIDevice.current.systemVersion.compare(version, options: .numeric) != ComparisonResult.orderedAscending
}

Questo metodo non restituirà true con la versione passata "10.3.0" in iOS "10.3". Questo tipo di risultato non ha senso e devono essere considerati come la stessa versione. Per ottenere risultati di confronto accurati, dobbiamo considerare di confrontare tutti i componenti numerici nella stringa di versione. Inoltre, fornire metodi globali in tutte le lettere maiuscole non è una buona strada da percorrere. Poiché il tipo di versione che utilizziamo nel nostro SDK è una stringa, è logico estendere la funzionalità di confronto in String.

Per confrontare la versione del sistema, tutti i seguenti esempi dovrebbero funzionare.

XCTAssertTrue(UIDevice.current.systemVersion.isVersion(lessThan: "99.0.0"))
XCTAssertTrue(UIDevice.current.systemVersion.isVersion(equalTo: UIDevice.current.systemVersion))
XCTAssertTrue(UIDevice.current.systemVersion.isVersion(greaterThan: "3.5.99"))
XCTAssertTrue(UIDevice.current.systemVersion.isVersion(lessThanOrEqualTo: "10.3.0.0.0.0.0.0"))
XCTAssertTrue(UIDevice.current.systemVersion.isVersion(greaterThanOrEqualTo: "10.3"))

Puoi verificarlo nel mio repository qui https://github.com/DragonCherry/VersionCompare

— DragonCherry
fonte

Verifica la versione del sistema operativo in Swift?

Rapido 4.2

Swift 5

Swift 5

Dettagli

link

Soluzione