Swift Language
Skriv gjutning

Syntax

• let name = json["name"] as? String ?? "" // Output: john

• let name = json["name"] as? String // Output: Optional("john")

• let name = rank as? Int // Output: Optional(1)

• let name = rank as? Int ?? 0 // Output: 1

• let name = dictionary as? [String: Any] ?? [:] // Output: ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]]

Downcasting

En variabel kan nedkastas till en subtyp med hjälp av typen cast-operatörer as? , och as! .

Den as? operatören försöker kasta till en subtyp.
Det kan misslyckas, därför returnerar det ett valfritt.

let value: Any = "John"

let name = value as? String
print(name) // prints Optional("John")

let age = value as? Double
print(age) // prints nil

Den as! operatör tvingar en roll.
Det returnerar inte ett valfritt, men kraschar om rollbesättningen misslyckas.

let value: Any = "Paul"

let name = value as! String
print(name) // prints "Paul"

let age = value as! Double // crash: "Could not cast value…"

Det är vanligt att använda typgjutningsoperatörer med villkorad uppackning:

let value: Any = "George"

if let name = value as? String {
    print(name) // prints "George"
}

if let age = value as? Double {
    print(age) // Not executed
}

Gjutning med brytare

switch kan också användas för att försöka gjutning i olika typer:

func checkType(_ value: Any) -> String {
    switch value {

    // The `is` operator can be used to check a type
    case is Double:
        return "value is a Double"

    // The `as` operator will cast. You do not need to use `as?` in a `switch`.
    case let string as String:
        return "value is the string: \(string)"

    default:
        return "value is something else"
    }

}

checkType("Cadena")  // "value is the string: Cadena"
checkType(6.28)      // "value is a Double"
checkType(UILabel()) // "value is something else"

Upcasting

Den as operatören kommer att kasta en supertyp. Eftersom det inte kan misslyckas, returnerar det inte ett valfritt.

let name = "Ringo"
let value = string as Any  // `value` is of type `Any` now

Exempel på att använda en nedkastning på en funktionsparameter som involverar underklassning

En nedkastning kan användas för att använda en underklasskod och data inuti en funktion som tar en parameter i dess superklass.

class Rat {
    var color = "white"
}

class PetRat: Rat {
    var name = "Spot"
}

func nameOfRat(🐭: Rat) -> String {
    guard let petRat = (🐭 as? PetRat) else {
        return "No name"
    }
    
    return petRat.name
}

let noName = Rat()
let spot = PetRat()

print(nameOfRat(noName))
print(nameOfRat(spot))

Skriv gjutning på Swift Language

Skriv gjutning

Typgjutning är ett sätt att kontrollera typen av en instans, eller att behandla den instansen som en annan superklass eller underklass än någon annanstans i sin egen klasshierarki.

Typgjutning i Swift implementeras med is och som operatörer. Dessa två operatörer tillhandahåller ett enkelt och uttrycksfullt sätt att kontrollera typen av värde eller kasta ett värde till en annan typ.

Downcasting

En konstant eller variabel av en viss klasstyp kan faktiskt hänvisa till en instans av en underklass bakom kulisserna. Där du tror att detta är fallet, kan du försöka nedställa till underklasstypen med en typ cast-operatör (som? Eller som!).

Eftersom nedkastning kan misslyckas finns operatören av typen cast i två olika former. Den villkorade formen, som?, Returnerar ett valfritt värde av den typ du försöker att sänka till. Den påtvingade formen, som!, Försöker nedställda och tvingar upp resultatet som en enda sammansatt handling.

Använd den villkorade formen för typen castoperatör (som?) När du inte är säker på om nedkastningen kommer att lyckas. Denna form av operatör kommer alltid att returnera ett valfritt värde, och värdet är noll om nedkastningen inte var möjlig. Detta gör att du kan kontrollera om en framgångsrik downcast har lyckats.

Använd den tvingade formen av typ cast-operatören (som!) Endast när du är säker på att nedkastningen alltid lyckas. Denna form av operatör utlöser ett körtidsfel om du försöker nedställa till en felaktig klasstyp. Veta mer.

String till konvertering av Int & Float: -

     let numbers = "888.00"
     let intValue = NSString(string: numbers).integerValue
     print(intValue) // Output - 888

     
     let numbers = "888.00"
     let floatValue = NSString(string: numbers).floatValue
     print(floatValue) // Output : 888.0

Flyt till strängkonvertering

    let numbers = 888.00
    let floatValue = String(numbers) 
    print(floatValue) // Output : 888.0

    // Get Float value at particular decimal point 
    let numbers = 888.00
    let floatValue = String(format: "%.2f", numbers) // Here %.2f will give 2 numbers after decimal points we can use as per our need
    print(floatValue) // Output : "888.00"

Värde för heltal till sträng

    let numbers = 888
    let intValue = String(numbers)
    print(intValue) // Output : "888"

Flyt till strängvärde

    let numbers = 888.00
    let floatValue = String(numbers)
    print(floatValue)

Valfritt Float-värde för String

    let numbers: Any = 888.00
    let floatValue = String(describing: numbers)
    print(floatValue) // Output : 888.0

Valfritt sträng till int-värde

    let hitCount = "100"
    let data :AnyObject = hitCount
    let score = Int(data as? String ?? "") ?? 0
    print(score)

Nedkastningsvärden från JSON

    let json = ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]] as [String : Any]
    let name = json["name"] as? String ?? ""
    print(name) // Output : john
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) // Output : ["Maths", "Science", "English", "C Language"]

Nedkastningsvärden från valfritt JSON

    let response: Any = ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]]
    let json = response as? [String: Any] ?? [:]
    let name = json["name"] as? String ?? ""
    print(name) // Output : john
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) // Output : ["Maths", "Science", "English", "C Language"]

Hantera JSON-svar med villkor

    let response: Any = ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]] //Optional Response 
    
    guard let json = response as? [String: Any] else {
        // Handle here nil value
        print("Empty Dictionary")
        // Do something here
        return
    }
    let name = json["name"] as? String ?? ""
    print(name) // Output : john
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) // Output : ["Maths", "Science", "English", "C Language"]

Hantera Nil Response med tillstånd

    let response: Any? = nil
    guard let json = response as? [String: Any] else {
        // Handle here nil value
        print("Empty Dictionary")
        // Do something here
        return
    }
    let name = json["name"] as? String ?? ""
    print(name) 
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) 

Output: Empty Dictionary