Forem: Beatriz da Silva

Dia 12 - #100DaysOfSwift

Beatriz da Silva — Sat, 21 Oct 2023 01:26:48 +0000

Opcionais

Permitem que representemos um dado que não existe, mas que pode ou não vir a existir na memória.

Unwrapping

Quando um dado é opcional regular o swift não nos permite acessá-lo sem antes verificar se ele é nil(não existe na memória) ou existe mesmo, essa verificação se chama unwrap.
As duas formas mais comuns de fazer unwrap são com if let e guard let.

if let

Faz o unwrap com uma condição, se tiver algum valor dentro do opcional você consegue usá-lo, caso contrário a condição falha e você pode fazer alguma outra ação que não use o opcional.

Checa se existe um dado dentro de nome pra que o dado possa ser usado

A partir do Swift 5.7 não é mais necessário o uso de binding(passar o valor do opcional pra uma constante) no if let

guard let

Faz o unwrap passando o dado existente pra uma constante(binding), caso ache nil fecha a função, loop ou condição onde foi usado.

Checa se foi passada uma string na chamada da função, como esse dado foi passado usa ele depois do guard

A maior diferença entre if let e guard let é que no guard o dado que foi checado e agora é não opcional continua usável depois do guard.

Force unwrapping

Quando você tem um valor opcional mas tem certeza absoluta de que ele não é nil é possível forçar o swift a transformar ele em um tipo não opcional usando !.

O próprio swift gera warnings em casos mais arriscados dando alternativas, mas nem sempre isso vai acontecer então é bom usar ! com cautela

O uso de force unwrapping é bastante contraindicado na maioria dos casos porque você pode esquecer alguma validação e o dado chegar nil no ponto do código que força essa conversão pra não opcional, caso isso aconteça o código crasha e esse é o pior cenário possível pra um app.

Implicitly Unwrapped Optionals

Assim como os opcionais regulares, podem conter um dado ou serem nil, mas diferente dos regulares você não precisa fazer unwrap pra utilizá-los.

Implicitly unwrapped optionals são criados adicionando uma exclamação depois do nome: let idade: Int! = nil

Por se comportarem como opcionais em que já foi feito o unwrap, não é necessário fazer if let ou guard let pra usá-los, mas se tentarmos usá-los e eles forem nil o código da crash.

Usamos esse tipo de opcional quando uma variável começa como nil, mas sabemos que sempre vai ter um valor dentro dela antes de precisarmos usá-la, o uso desse tipo evita que precisemos fazer if let toda hora, mas num geral é melhor evitar e usar opcionais regulares.

No UIKit são comumente usadas pra layout, já no SwiftUI quase não são utilizadas.

Nil coalescing | Valor padrão

O operador nil coalescing faz o unwrap do opcional e retorna o valor dentro dele, mas caso esse valor seja nil ele retorna o valor que foi colocado como padrão: ?? valorPadrao.

Valor padrão é um Int 7

Optional chaining

É um processo para consultar e chamar propriedades e métodos opcionais. Se o opcional contiver um valor, a chamada de propriedade/método da certo e retorna sempre um opcional, se for nil retorna nil. Várias consultas podem ser encadeadas e toda a cadeia falha se algum deles for nil.

O retorno de um optional chaining sempre é um valor opcional ou nil

O retorno é nil porque apesar Daken ser uma chave válida o valor(sobrenome) está vazio, assim o first retorna nil

Failable initializer

É possível criar um init para struct ou classe que pode falhar. Caso um objeto não possa ser instanciado com os dados que foram passados, ao invés de retornar sempre uma nova instância, retorna nil. Caso os dados sejam válidos retorna uma instância opcional.

Instância opcional criada

Typecasting

Nos permite verificar o tipo de uma instância e mostrar ao Swift como tratá-la dentro da sua própria hierarquia, é muito útil ao trabalhar com protocolos e herança de classe.

Dia 11 - #100DaysOfSwift

Beatriz da Silva — Sun, 15 Oct 2023 21:20:58 +0000

Protocolos

São uma forma de descrever quais propriedades e métodos algo(structs, classes, enums) deve ter, então quando escrevemos um código dizendo que algo conforma com um protocolo o Swift vai fazer com que implementemos todas as propriedades e métodos que existem nesse protocolo. É uma forma de tratar dados de uma forma mais geral.

Método comprar que só permite livros como parâmetro

Método comprar que aceita qualquer item que conforme com o protocolo Adquirivel como parâmetro

Assim como as classes, protocolos podem herdar de outros protocolos, isso ajuda a diminuir duplicação de código e a adicionar restrições quando necessário.

Extensions

Permitem adicionar métodos à tipos existentes pra fazer coisas que eles não foram criados originalmente pra fazer.

Outro uso para extensions é organização de código.
Conformance grouping é quando se adiciona uma conformidade de protocolo a uma extensão, adicionando todos os métodos necessários dentro dela.

Purpose grouping é quando se cria extensões para realizar tarefas específicas.

Protocol extensions

São como extensions normais, mas ao invés de estender um tipo específico como Int, podemos estender um protocolo inteiro para que todos os tipos em conformidade recebam as alterações.

Protocol extensions podem fornecer implementações pros métodos dos nossos próprios protocolos, permitindo o uso da técnica de programação orientada à protocolo.

Dia 10 - #100DaysOfSwift

Beatriz da Silva — Sun, 15 Oct 2023 18:59:38 +0000

Classes

Classes são bem parecidas com Structs mas tem algumas diferenças importantes:

1. Init

Classes não tem init padrão, caso tenha propriedades na classe você sempre tem que criar o seu próprio init ao cria-la.

2. Herança

Uma classe pode ser criada herdeira de outra classe, assim ela ganha as propriedades e métodos da classe pai; É possível adicionar novas propriedades e métodos nela.

Por segurança o Swift sempre nos faz usar super. init() em classes filho, pra caso a classe pai faça algo importante no init não tenha nenhum problema.

Sobrescrever métodos

Caso queira sobrescrever algum método da classe pai é só colocar a palavra reservada override no início da implementação do método na classe filho.

Final Class

Classes com a palavra final no início não podem ser herdadas e ter seus métodos sobrescritos, geram erro em tempo de compilação.
final também pode ser usado em métodos ou propriedades pro mesmo efeito, assim deixando o resto das coisas não marcadas com comportamento padrão pra herança.

3. Cópias

Classes são reference type, quando instanciamos uma classe a RAM aloca um espaço na memória e atribui o endereço à instância criada, objetos tipo referência apontam pro mesmo endereço de memória, por isso apontam pros mesmos dados compartilhados(mudar uma classe, muda todas), já Structs são value type, cada instância cria uma cópia exclusiva dos dados, caso uma instância seja modificada a outra não é.

Cópia de Classe

Cópia de Struct

4. Deinitializers

Classes podem ter deinitializers, que são métodos chamados quando uma instância da classe é destruída.

5. Mutabilidade

Propriedades variáveis em Classes constantes podem ser modificadas livremente, mas propriedades variáveis em Structs constantes não podem.

Propriedade variável sendo modificada em Classe constante

Erro ao tentar modificar propriedade variável em Struct constante

Dia 9 - #100DaysOfSwift

Beatriz da Silva — Sun, 15 Oct 2023 15:50:11 +0000

Inicializadores

Toda struct tem um init padrão(memberwise initializer), mas é possível criar outros inits e ao criar um init o padrão é substituído.
Caso queira manter o init padrão mesmo após criar um, é só mover o init personalizado pra uma extension.

Self

Dentro do método é possível nos referir à instância da estrutura usando self, isso é bastante usado pra usar o mesmo nome de variável ao criar o init.

O self serve para indicar que uma propriedade diz respeito ao elemento(struct, class) e não a uma variável local.

Lazy

Para otimização de performance o Swift nos deixa criar algumas propriedades apenas quando elas são necessárias(Lazy), parecido com as propriedades computadas; Mas ao contrário dessas, as propriedades lazy armazenam o resultado calculado, evitando retrabalho nos próximos acessos.
São bem performáticas quando não estão sendo utilizadas porque o código nunca roda e ainda mais performáticas quando usadas várias vezes porque seu valor é armazenado em cache.

Não são indicadas pra uso em coisas que não precisam de armazenamento ou que não são modificadas constantemente.
Não podem ser utilizadas em structs constantes.

Propriedades e métodos estáticos

Declarando uma propriedade ou método como estático é possível compartilhar eles em todas as instâncias da struct já que eles passam a ser membros da própria struct ao invés de cada instância ter o seu.

Controle de acesso

O controle de acesso do swift é baseado no conceito de módulos e arquivos e tem 5 níveis de acesso diferentes para entidades(propriedades, tipos, funções...) dentro do código.

Open - Permite que entidades sejam usadas no módulo de definição e em qualquer outro que importe o módulo de definição; Pode acessar e sobrescrever.

Public - Permite que entidades sejam usadas no módulo de definição e em qualquer outro que importe o módulo de definição; Pode acessar, mas não pode sobrescrever.

Internal - Padrão do Swift, tudo que está no mesmo módulo pode ser acessado.

File-private - Só quem está no mesmo arquivo pode usar.

Private - Só quem declarou ou extensões de quem declarou(no mesmo arquivo) podem usar.

Dia 8 - #100DaysOfSwift

Beatriz da Silva — Thu, 05 Oct 2023 01:05:12 +0000

Diferença de Struct e Tupla

Ambas tem comportamentos semelhantes, mas a struct leva um nome e a tupla não, por isso structs são melhores pra ser usadas em casos que você precisa usar a mesma estrutura de variáveis mais de uma vez.

Diferença de propriedade armazenada e computada e quando usar cada uma

Propriedade armazenada: Valor é armazenado na memória pra ser usado depois.

Se for lida regularmente e o valor não depender de outras propriedades.

Propriedade computada: Valor é recomputado toda vez que é chamado, nada mais é do que uma chamada de função que pertence à Struct.

Se a propriedade é lida raramente é melhor usar esse tipo, evitando o cálculo e armazenamento de algo quase nunca utilizado.
Se o valor da propriedade depende de valores de outras propriedades, assim você vai ter certeza de que o valor retornado sempre leva em conta o estado mais recente do programa.

Variáveis computadas criadas dentro de uma struct não podem ter seu valor modificado manualmente, ele só pode ser acessado.

Property Observers(willSet e didSet)

willSet é chamado antes do valor ser atribuído a uma propriedade
didSet é chamado depois de uma propriedade ter recebido um valor, toda vez que o valor for modificado a ação dentro dele será executada.

Métodos

Structs podem ter funções, elas se chamam métodos e eles podem usar as propriedades da struct conforme necessário. Apesar da nomenclatura diferente a palavra reservada pra declaração de métodos é a mesma de uma função: func.

Diferença entre método e função

Métodos pertencem à um tipo(struct, enum, class) e as funções não.
Essa associação à um tipo específico permite que os métodos façam referência a propriedades e métodos dentro do mesmo tipo e diferente das funções os nomes não ficam reservados, reduzindo conflitos de nomes por acidente.

Métodos mutantes

Para que as propriedades sejam mutáveis é necessário usar a palavra-chave mutating no início do método, mas ao fazer isso o método não poderá mais ser chamado por structs constantes(mesmo se o método nunca tiver mudado suas propriedades).
Um método que não for marcado como mutante não pode chamar uma função mutante, ambos tem que estar marcados pra se relacionar.

Quase todos os tipos principais do Swift são implementados como structs(String, Inteiros, Array, Dictionary, Bool).

Dia 6 - #100DaysOfSwift

Beatriz da Silva — Fri, 18 Aug 2023 03:27:11 +0000

Closures

Closures são funções passadas por parâmetro em outras funções.

O motivo mais comum pro uso de closures é pra fazer algo que você quer que o código faça, mas não exatamente naquele momento, por exemplo fazer algo após um delay, o fim de uma animação, o término de um download ou após o usuário selecionar alguma opção.

Closures nos permitem agrupar várias funcionalidades em uma única variável e em seguida armazenar em algum lugar, também é possível retornar de uma função e armazenar a closure em outro lugar.

Também é possível colocar parâmetros nas closures, a diferença entre uma closure e uma função padrão na chamada é que a função tem labels pros parâmetros e closures não.

Pra retornar um valor numa closure que não recebe parâmetros é preciso colocar parênteses vazio, a seta e o tipo que será retornado:

Trailing Closure

Quando o último parâmetro de uma função é uma closure, o swift nos deixa usar trailing closure, que nada mais é do que passar a closure diretamente depois da chamada da função; E em casos em que a closure é o único parâmetro os parênteses podem ser eliminados.

Função com closure

Mesma função, mas usando trailing closure

Dia 5 - #100DaysOfSwift

Beatriz da Silva — Thu, 10 Aug 2023 04:59:58 +0000

Funções

Servem pra criar blocos de código que serão usados mais de uma vez, assim reduzindo código repetido. É uma boa prática criar funções que tenham apenas uma responsabilidade.

Quando a função tem uma única expressão a palavra reservada return pode ser omitida:

É possível retornar mais de um valor numa função usando tuplas ou alguma coleção(array ou dicionário):

Swift permite que coloquemos dois nomes em cada parâmetro, sendo o primeiro de uso externo e o segundo de uso interno, permite também omitir o parâmetro na chamada da função(usando _), ambas as formas podem ser usadas pra deixar o código mais fácil de ler.

Quando temos um parâmetro que na maioria das vezes vai receber um valor específico, pra facilitar dá pra colocar um parâmetro padrão.

Throwing functions

As vezes num código algo pode dar erro, mas ser um erro mais "tranquilo", por exemplo quando um app consome dados de uma API e por algum motivo não foi possível decodificar os dados que estão sendo recebidos, nesses casos é muito útil saber que um erro aconteceu sem crashar o app, assim é possível dar um feedback visual pro usuário e deixá-lo livre pra tentar fazer outras coisas no app.

O Swift nos permite lançar erros dentro de funções, pra isso é preciso colocar a palavra throws antes do tipo de retorno da função, e dentro dela usar a palavra throw quando algo der errado e aí chamar algum erro que você criou num enum que conforma com o protocolo Error.

Pra chamar uma throwing function é preciso usar três palavras: do, try, e catch, como a linguagem nos força a usar try ao chamar uma throwing function, fica bem fácil de saber visualmente quais funções podem ou não causar erros.

Dia 4 - #100DaysOfSwift

Beatriz da Silva — Fri, 02 Jun 2023 20:26:10 +0000

For

É o loop mais comum em swift, é possível usar arrays e ranges nele. Depois da palavra for você pode usar qualquer string(desde que não seja uma palavra reservada) pra representar o contador do loop.
Quando o loop for a partir de um range você pode tanto colocar o range direto no loop quanto colocar o range numa variável e colocar a variável no loop.

Caso não vá usar a variável depois do for pra nada, nem precisa nomea-la, é só colocar um _.

While

Nesse tipo de loop você coloca uma condição a ser checada e dentro dele o que deve ser feito e um modificador dessa condição, o loop acaba quando a condição se tornar falsa.
São mais usados em casos onde você não sabe previamente quantas vezes precisará que o loop aconteça, como por exemplo quando você quer que algo aconteça até que o usuário pare a ação ou até que tenha carregado as informações necessárias.

Repeat

Bem pouco usado, esse é quase igual ao While, a diferença é que no Repeat a ação do loop será realizada pelo menos uma vez, já que a condição a ser checada acontece apenas no final de cada loop.

Dia 3 - #100DaysOfSwift

Beatriz da Silva — Thu, 01 Jun 2023 23:05:17 +0000

Operadores de comparação

Servem pra comparar dados num geral, podem ser usado pra dados numéricos, texto, etc.

Operador ternário

É muito útil pra quando se quer fazer algo específico se algo for verdadeiro ou falso de forma bem mais enxuta do que usando um if/else.

Nesse exemplo o valor resultante do ternário é atribuído à variável z:

Switch

Se tiver que fazer várias condicionais usando um mesmo valor como parâmetro, fica mais fácil usar um switch do que um if/else.

Caso queira que mesmo após cair num case ele também execute o próximo é só colocar a keyword fallthrough.

Operadores de range

No swift existem duas formas de representar um range.
..< exclui o último número do range:

... inclui todos os números que estão no range.

Dia 2 - #100DaysOfSwift

Beatriz da Silva — Fri, 26 May 2023 02:34:28 +0000

Arrays

São coleções de dados de um mesmo tipo que podem armazenar tanto dados primitivos(como Int, String, Bool) como classes e objetos; São usados pra guardar mais de um valor em apenas uma variável e pode conter dois ou mais valores iguais.

Cada espaço num array é chamado de elemento, cada elemento é representado por um número que sempre começa em 0 e chamamos de índice.

O array abaixo guarda o nome dos membros da equipe X-Men da abertura do evolution, são 8 membros, então o array tem 8 elementos, com índices que vão do 0 ao 7.

let xMen = ["Ciclope", "Jean Grey", "Spyke", "Wolverine", "Tempestade", "Vampira", "Lince Negra", "Noturno"]

É possível criar um array vazio e preenche-lo depois:

var xMen = [String]()

Se você tentar acessar um índice que não existe vai crashar o código, por exemplo, se você tentar acessar o índice 8 no array xMen[8].

Sets

Também são coleções de dados, mas diferente do array, ele guarda os dados de forma desordenada e não guarda itens repetidos, cada elemento é único, por isso caso coloque o mesmo elemento duas ou mais vezes, ele vai ignorar e guardar o elemento apenas uma vez e por ser desordenado não é possível acessar os elementos com índices.

Usamos o set ao invés do array quando precisamos garantir que cada elemento aparecerá apenas uma vez no conjunto e a ordem dos elementos não é importante.

let viloes: Set = ["fenix negra", "apocalipse", "magneto"]

É possíver criar um set vazio e depois preenche-lo:

var viloes = Set<String>()

Tuplas

Assim como o array, as tuplas permitem armazenar vários conjuntos de dados numa mesma variável, mas não é possível adicionar ou remover itens de uma tupla, elas tem um tamanho fixo; Não é possível mudar o tipo dos itens numa tupla depois dela criada.

var nome = (primeiroNome: "Laura", sobrenome: "Kinney")

Você pode acessar um elemento de uma tupla usando o índice(que também começa em 0):

nome.0

ou um nome que você deu pro elemento:

nome.primeiroNome

Você pode mudar o valor de dentro da tupla depois dela criada, mas não o tipo, se tentasse mudar pra (primeiroNome: "Logan", idade: 57) retornaria um erro.

Dicionários

É parecido com um array, mas no dicionário você escolhe a chave identificadora ao invés de ele criar isso automaticamente em forma de índice, os elementos são guardados em forma de chave : valor

let paises = [
    "Noturno": "Alemanha",
    "Wolverine": "Canadá",
    "Mancha Solar": "Brasil"
]

Caso um elemento não seja encontrado o dicionário retorna nil, é possível colocar um valor default pro dicionário quando ele não encontrar a chave entre os elementos:

paises["Vampira", default: "Desconhecido"]

É possível criar um dicionário vazio e depois preencher os elementos dele:

var paises = [String: String]()

paises["Vampira"] = "Estados Unidos"

Enums

É um jeito de definir um grupo de valores relacionados de um jeito que seja fácil de usa-los, por exemplo um enum poderia ser usado pra definir à qual grupo um mutante pertence:

enum Grupo {
    case instituto
    case irmandade
    case morlocks
}

let tempestade = Grupo.instituto

Enums também podem guardar valores associados à cada case, por exemplo um enum de ações simples:

enum Acao {
    case andando(destino: String)
    case falando(assunto: String)
    case voando(onde: String)
}

let falando = Acao.falando(assunto: "como derrotar o magneto")

Um bom lugar pra conseguir mais informações sobre como algo em Swift ou de um framework da Apple funciona com exemplos é a Developer Documentation, pra acessar a doc pelo Xcode:

Atalho de teclado - Command + Shift + 0
Menu superior do Xcode - Help >> Developer Documentation

Dia 1 - #100DaysOfSwift

Beatriz da Silva — Wed, 24 May 2023 02:29:31 +0000

Swift é uma linguagem type-safe, isso significa que ela obriga o código a respeitar os contratos estabelecidos.

Quando criamos uma variável em Swift não precisamos dizer o tipo da variável, o Swift pode inferir o tipo de acordo com o que for armazenado.

var greeting = "Hello"

Mas se preferir, podemos ser mais explícitos e especificar na declaração da variável o seu tipo:

var greeting: String = "Hello"

Depois disso o valor pode mudar quantas vezes for preciso, mas o tipo da variável não pode mais ser mudado.

Optional Chaining / Force Unwrapping

Beatriz da Silva — Thu, 22 Oct 2020 18:27:15 +0000

Evitar Force Unwrapping (Exclamação !) - Isso deixa o código inseguro, caso esqueça alguma verificação da crash no app

Optional Chaining (Interrogação ?) - Se for nil não faz nada, se existir faz (seguro em relação à crash), mas caso seja nil o usuário não recebe nenhuma notificação