Swift!.opcionais.oh!.my()?!?

Swift!.opcionais?.oh!.my()?!?

Tales Pinheiroco-founder Newt Labs,dev SalesForce na Top Information

@[email protected]

DisclaimerLooking forward to next month: I'll be the first and only guy with 4 years of swift programming experience :-)— LATTNER, Chris (@clattner_llvm)

image by http://instagram.com/p/rWyQdUDBhH/

Disclaimer

Eu escrevi não mais nos que 30 linhas de código em Swift a mais dos que as que aparecem nessa apresentação, não sou mais especialista em Swift do que vocês.— PINHEIRO, Tales


Disclaimer

Não gosto de boa parte do estilo de código apresentado aqui, mas ainda não consegui escolher um bom.— PINHEIRO, Tales


A linguagem Zen

Opcionais - questão existêncial:

— Existe um valor, e é igual a x

ou

— NÃO existe um valor (nenhum MESMO!)

nil versus Optional

— nil: "equivalente" em Objective-C, válido apenas para objetos

— Optional: valido para qualquer tipo

Quando usar ?

let possibleNumber = "123"let convertedNumber = possibleNumber.toInt()

let anotherPossibleNumber = "Hello, World"let whatIsMyValue = anotherPossibleNumber.toInt()

Qual o tipo ?



//possibleNumber = 123, whatIsMyValue=nil

Qual o tipo ?



//possibleNumber = 123, whatIsMyValue=nil//whatIsMyValue: inferida como Int?

Qual o tipo ?



//possibleNumber = 123, whatIsMyValue=nil//whatIsMyValue: inferida como Int?//convertedNumber: inferida como Int?

Definição manual do tipo

var myVar: String?//compilador atribui automaticamente o valor nil

Declarações if e desempacotamento forçadoforced wrapping

//1:if convertedNumber !=nil { println("Contem algum valor")}//2:if convertedNumber !=nil { println("Contem o valor \(convertedNumber!)") //eu sei que tem um valor. Use!}

convertedNumber! : desempacotamento forçado

Erro de runtime se convertedNumber contém nil.

Atribuição opcional (optional binding)

//3:if let actualNumber = convertedNumber { println("Contem o valor \(actualNumber)")}else { println("não foi dessa vez")} //imprime "123"

//4:if let maybeOtherNumber = "Hello again" { println("Contem o valor \(maybeOtherNumber)")}else { println("não foi dessa vez")} //imprime "não foi dessa vez"

Desenpacotamento implicito de opcionaisImplictly Unwrapped Optionals

let possibleString: String? = "An optional string."println(possibleString!) // requires an exclamation mark to access its value// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optional string."println(assumedString) // no exclamation mark is needed to access its value// prints "An implicitly unwrapped optional string.”


class MyClass { var myInt: Int! { didSet { println("New Value: \(myInt).") } }

func doSomethingSlow() { // a few 7.5 million years later... myInt = 42 //quando chamado, imprime "New Value: 42" }}

var obj = MyClass()obj.doSomethingSlow()


Você ainda pode verificar se tem conteúdo:

if obj.myInt != nil { //do something cool with answer to life, the universe and everything}

ou

if let verifiedInt = obj.myInt { //do something cool with answer to life, the universe and everything}

Bool

bool opcional não pode mais ser usado para comparação

Erro de compilação

var myBool : Bool?if myBool { println("falso")}else { println("true")}

Bool

bool opcional não pode mais ser usado para comparação

Erro de compilação

var myBool : Bool?if myBool != true { println("falso")}else { println("true")}

nil coalescing operator

Considere o código:

var a : Int? //implicitamente atribuido valor nilvar b = 0var c = a != nil ? a! : b// c possui tipo Int (e não Int?) e valor 0

Xcode 6 beta 5 introduz o atalho:

c = a ?? b


levemente analogo, em Objective-C (na verdade, C99), a:

c = a ?: b


Um exemplo mais concreto:

let defaultColorname = "red"var userDefinedColorName: String? //default igual a nil

var colorNameToUse = userDefinedColorName ?? defaultColorname//colorNameToUse tem valor "red"

userDefinedColorName = "green"colorNameToUse = userDefinedColorName ?? defaultColorname//agora colorNameToUse tem valor "green"

Opcionais e subscripts (dicionários)

var hexColors = ["red" : "ff0000", "green" : "00ff00", "blue" : "0000ff"]var hexForRed = hexColors["red"]



O tipo de retorno também é inferido como "String?"



if let hexForGray = hexColors["gray"] { // is there 50 shades here?}else { printf("¯\_(�)_/¯")}

forced unwrap...


E no caso de remover um valor?

if let removedColor = hexColors.removeValueForKey["grey"] { println("I don't know anymore that red is \(removedColor)")}else { printf("¯\_(�)_/¯") //imprime esta mensagem}

Ou pelo atalho:

hexColors["green"] = nil

Tuplas opcionais

Podemos ter tuplas com valores opcionais ou tuplas opcionais:

(Int, Int?)

versus

(Int, Int)?

Tuplas opcionais

func parseDate(date: String) -> (Int, Int?, Int?) { comp = date.componentsSeparatedByString("/") return (comp[0].toInt()!, comp[1].toInt(), comp[2].toInt())}

— Método toInt() retorna opcional

— toInt()! força o desempacotamento

— função acima sempre retorna uma tupla, possívelmente com algum dos componentes nil

Tuplas opcionais

func minMax(array: [Int]) -> (min: Int, max: Int)? { if array.isEmpty { return nil }

var currentMin = array[0] var currentMax = array[0]

for value in array[1..<array.count] { if value < currentMin { currentMin = value } else if value > currentMax { currentMax = value } } return (currentMin, currentMax)}

Enumerações - Raw value

enum WeekDay: Int { case Sunday = 0, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}

let weekDayNumber = WeekDay.Friday.toRaw() //weekDay = 6

Enumerações - Raw value

enum WeekDay: Int { case Sunday = 0, Monday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}

let weekDayNumber = WeekDay.Friday.toRaw() //weekDay = 5

let isThisAWeekDay = WeekDay.fromRaw(8) //isThisAWeekDay: Int?, valor: nil

Propriedades com tipos opcionais

class SurveyQuestion { var text: String var response: String?

init(text: String) { self.text = text }}

^vamos dar um exemplo de proprieadade com tipo opcional. Nesse exemplo, response é definida como uma string opcional. Na inicalização ela tem valor nil, então terá o valor atribuido posteriormente

Propriedades com tipos opcionais

var questionOfLife = SurveyQuestion(text: "What is the answer to life, \ the universe and everything?")questionOfLife.response = "Forty two"

A propriedade response tem tipo "String?" e valor "nil" até ter um valor atribuido

Encadeamento de opcionaisOptional chainging

Processo de acessar propriedades, métodos e índices em uma contante ou váriável opcional que pode na verdade conter um nil

É similar a enviar uma mensagem para um objeto nil em Objective-C, mas pode ser usado com qualquer tipo


Usamos interrogação após o valor opcional, ao invés de exclamação, porém aqui falha usavemente, ao invés de gerar erro de runtime

O resultado é sempre do mesmo tipo esperado, mas empacotado em um opcional


class Residence { var numberOfRooms = 1}

class Person { var residence: Residence?}


let john = Person()

let numberOfRooms = john.residence!.numberOfRooms// PAN! -> erro de runtime

//mas o código abaixo não tem problemaif let numberOfRooms = john.residence?.numberOfRooms { println("John's residence has \ \(numberOfRooms) room(s).")}


Mesmo com inicialização:

john.residence = Residence()

if let numberOfRooms = john.residence?.numberOfRooms { println("John's residence has \ \(numberOfRooms) rooms.")}//imprime "John's residence has 1 room(s)"

O tipo ainda é inferido como "Int?"


class Room { var name: String init(name: String) { self.name = name }}

class Address { var street: String? var number: Int?}


class Residence { var rooms = [Room]() var numberOfRooms: Int { return rooms.count } subscript(i: Int) -> Room { get { return rooms[i] } set { rooms[i] = newValue } } func printNumberOfRooms() { println("The number of rooms is \(numberOfRooms)") } var address: Address?}


let john = Person()let residence = Residence()residence.address = someAddressresidence.rooms.append(Room(name: "Kitchem"))john.residence = residenceprintln("John's residence has \ \(john.residence?.numberOfRooms) room(s)")//Imprime: "John's residence has Optional(1) room(s)"


println("John's first room is \(john.residence?[0].name)")//Imprime: "John's first room is Optional("Kitchem")"john.residence?[0].name = "Living Room"println("John's first room is \(john.residence?[0].name)")//Imprime: "John's first room is Optional("Living Room")"


var hexColors = ["red" : ["00", "00", "00"], "green" : ["00", "ff", "00"], "blue" : ["00", "00", "ff"]]hexColors["red"]?[0] = "ff"


var hexColors = ["red" : ["00", "00", "00"], "green" : ["00", "ff", "00"], "blue" : ["00", "00", "ff"]]hexColors["red"]?[0] = "ff"if (hexColors["gray"]?[0] = "ff") == nil { println("It was not possible to change \ color component")}//Imprime: //"It was not possible to change color component"


— É possivel encadear multiplos níveis de opcionais

— se o tipo que você está tentando acessar não é opcional, ele se tornará opcional através do encadeamento

— se o tipo que você está tentando acessar já é opcional, ele não se tornará "mais" opcional

Encadeamento de opcionais

let mary = Person()if let street = mary.residence?.address?.street { println("Mary lives in \(street)")}else { println("I don't know the address")}//imprime "I don't know the address"//ok, não faz nadamary.residence?.address?.street = "Faria Lima"//erro de runtimemary.residence!.address?.street = "Faria Lima"

Encadeamento de opcionaismétodos com retorno opcional

class Address { //... func moveTo(streetName: String, number: Int) { self.street = streetName self.number = number }}


if let hasPrefix = mary.residence? .address? .street .hasPrefix("Brigadeiro") { println("Mary may live at Brigadeiro Faria Lima")}else { println("I don't know the address")}//imprime "I don't know the address"


class Address { //... func moveTo(streetName: String?, number: Int?) -> String? { if streetName == nil || number == nil { return nil } self.street = streetName self.number = number return "\(self.street), \(self.number)" }}


if let newAddress = john.residence? .address?.moveTo(nil, number: 123) { println("Moved to \(newAddress)")} //não imprime nada

if let newAddress = john.residence? .address?.moveTo("Augusta", number: 123) { println("Moved to \(newAddress)")}


if let hasPrefix = mary.residence? .address? .moveTo("Augusta", number: 123)? //note o ? .hasPrefix("Brigadeiro") { println("Mary may live at Brigadeiro Faria Lima")}

TypecastingDowncasting

Uma constante ou variável de um tipo pode referir para uma instância ou variável de uma subclasse.

Se acredita que este pode ser o caso, você deve fazer o downcast com o operador de type casting as.

TypecastingDowncasting

Como pode falhar (caso sejam realmente de tipos diferentes), vem em dois "sabores"

— Forma opcional de type casting as?

— Forma forçada de type casting as (sem o uso ?)

Typecasting

class MediaItem { var name: String init(name: String) { self.name = name }}

Typecasting

class Movie : MediaItem { var director: String init(name: String, director: String) { self.director = director super.init(name: name) }}

Typecasting

class Song : MediaItem { var artist: String init(name: String, artist: String) { self.artist = artist super.init(name: name) }}

Typecasting

let library = [ Movie(name:"Iron Man", director: "Jon Favreau"), Song(name: "Hooked on a feeling": artist: "Blue Swede")]

Typecasting

let library = [ Movie(name:"Iron Man", director: "Jon Favreau"), Song(name: "Hooked on a feeling": artist: "Blue Swede")]for item in library { if let movie = item as? Movie { println("Movie: \(movie.name) directed by \(movie.director)") } else if let song = item as? Song { println("Song: \(song.name) by \(song.artist)") }}

Typecasting

var movieLibrary = [AnyObject]movieLibrary.append(Movie(name:"Iron Man", director: "Jon Favreau"))movieLibrary.append(Movie(name:"2001: A Space Odyssey", director: "Stanley Kubrick"))

Typecasting

var movieLibrary = [AnyObject]()movieLibrary.append(Movie(name:"Iron Man", director: "Jon Favreau"))movieLibrary.append(Movie(name:"2001: A Space Odyssey", director: "Stanley Kubrick"))

for item in movieLibrary { let movie = item as Movie println("Movie: \(movie.name) directed by \(movie.director)")}

Protocolos opcionais

Protocolos definem métodos, por exemplo, que devem ser implementados por objetos que

Mas podemos declarar em um protocolo que a implementação de um método é opcional.

Protocolo deve ser declarado com o atributo @objc

@objc só pode ser usado com structs e enuns


@objc protocol CounterDataSource { func incrementForCount(count: Int) -> Int ? var fixedIncrement: Int { get } ?}


@objc protocol CounterDataSource { func incrementForCount(count: Int) -> Int ? var fixedIncrement: Int { get } ?}

ERRADO


@objc protocol CounterDataSource { optional func incrementForCount(count: Int) -> Int optional var fixedIncrement: Int { get }}


@objc class Counter { var count = 0 var dataSource: CounterDataSource? func increment() { if let amount = dataSource?.incrementForCount?(count) { count += amount } else if let amount = dataSource?.fixedIncrement? { count += amount } }}

Navegando por águas mais profundasGenerics

struc Stack<T> { var items = [T]() mutating func push(item: T) { items.append(item) }

mutating func pop() -> T { return items.removeLast() }}

Generics

extension Stack { var topItem: T? { return items.isEmpty ? nil : items[items.count - 1] }}

Swift!.opcionais.oh!.my()?!?

Technology

Transcript of Swift!.opcionais.oh!.my()?!?