Como Criar Um Aplicativo iOS do Zero: Primeiros passos no Playground
Se você quer aprender como criar aplicativos para iPhone, conhecido como sistema iOS e não sabe por onde começar então você está no lugar certo!
Este material irá te mostrar passo a passo o que você precisa saber para criar o seu primeiro aplicativo iOS no menor tempo possível, onde cobrimos a linguagem de programação Swift, a ferramenta de desenvolvimento Xcode, os componentes necessários para criar o app iOS e alguns aspectos e padrões de desenvolvimento de software.
A minha intenção ao final desse material e de toda essa série é que você seja capaz de criar um aplicativo do zero. Entretanto, o processo e a sua melhoria contínua em cada material é tão importante quanto o objetivo final desta série.
E a primeira lição que já quero deixar é que o processo de aprender uma nova habilidade (como desenvolver aplicativos iOS) depende de esforço e execução. Logo, além de ler e entender cada material, você precisa executar, por em prática cada passo e escrever mais e mais código!
É assim que melhoramos cada dia e que aprendemos de fato uma nova habilidade seja ela qual for.
EXECUÇÃO. Escreva essa palavra em um post-it e cole no seu computador ou algo assim. Pratique.
Resumindo, se você é um iniciante sem experiência em programação ou um desenvolvedor que quer aprender uma nova linguagem de programação ou até mesmo um Designer que quer tornar suas ideias em um aplicativo iOS, este material é pra você.
Então continue lendo este artigo onde explico mais sobre a ferramenta de desenvolvimento Xcode e a linguagem de programação Swift.
Go ahead and do It!
Tudo parece impossível, até que seja feito…
~Nelson Mandela
O primeiro passo para começarmos a criar um aplicativo iOS é configurar o ambiente de desenvolvimento Xcode IDE e entender a linguagem de programação Swift. Mas antes…
Conheça 3 Coisas que você precisa aprender para criar qualquer aplicativo iOS
Muitas pessoas ficam com dúvidas e não sabem por onde começar quando o assunto é aplicativos iOS.
O fato é que você precisa entender 3 conceitos para criar o seu app:
- Dominar Swift - Swift não é a única linguagem de programação para escrever aplicativos iOS. Mas é a moderna e recomendada nos dias atuais.
- Dominar Xcode - Xcode é a única ferramenta que você precisa para criar a interface do seu app, escrever linhas de código swift, compilar e publicar o seu aplicativo.
- Dominar SDK - SDK (Software Development Kit) - Kit de desenvolvimento de software fornecido pela Apple deixa nossa vida bem mais fácil. Este é um kit com diversos códigos fontes e ferramentas que nos auxiliam a criar componentes iOS como uma TableView para listar dados ou componentes para realizar popUps (alertas) no nosso aplicativo.
Você tem que enriquecer seu conhecimento nessas 3 categorias para criar aplicativos e melhorar cada vez mais.
E eu sei que você deve estar se perguntando…
“Nossa, é tanta coisa pra aprender, estou ficando paralisado. Como eu vou aprender tudo isso?”
E você tem 2 boas notícias aqui:
A primeira é que isso é completamente normal. Eu já passei por isso e vou te ajudar a entender cada detalhe desses 3 conceitos. A segunda notícia boa é que você tem esse material (e outros) que publiquei na web que irão te ajudar nessa jornada. Então fique tranquilo ;)
Computador Apple (Mac)
Primeiro, você precisará de um computador com o sistema operacional Mac OSX atualizado. Há diversas formas de conseguir um computador com o sistema operacional, porém, a que eu recomendo é adquirir no mínimo um Mac Mini, intel i5 com 4GB de memória RAM. Esta configuração de computador é o suficiente para conseguir executar o simulador de iPhone e/ou iPad e testar os seus aplicativos.
Agora, se você quiser uma melhor experiência, um Macbook ou iMac é excelente!
Dica extra: Caso não tenha ainda um Mac, há centenas de opções de computadores Mac em sites como Mercado Livre ou OLX para venda com o preço muito menor de mercado. Vale a pena conferir.
Conta Apple ID
Agora você precisará criar uma conta na Apple para ter um Apple ID e baixar a sua versão da ferramenta XCode. Este passo também é importante caso você queira testar o seu aplicativo em um dispositivo (iPhone/iPad) real, ao invés do simulador fornecido pela ferramenta.
Se você já baixou algum aplicativo para Mac que necessitou de uma conta, provavelmente já tenha um Apple ID. Caso contrário, você terá que criar um no seguinte link https://appleid.apple.com/account.
Ferramenta Xcode
Tudo pronto para baixarmos a nossa versão do Xcode. Você precisará somente desta IDE (Interface Development Environment). Isso porque ela já é uma ferramenta completa com Simulador de iPhone, Documentação de código, Debugging, interface interativa e muito mais.
O que precisa ser feito agora é acessar a App Store no ícone logo abaixo da desktop (Dock) 
Pesquise por “Xcode” e clique no botão “Get” / “Obter” conforme a imagem abaixo: 
O download se iniciará e posteriormente a instalação do Xcode.
Uma vez instalado, o Xcode ficará disponível junto aos outros aplicativos do Mac. Você pode acessá-lo clicando no ícone de launchpad ou com as teclas cmd + space e pesquisando pela palavra “Xcode”.
Swift
Finalmente chegamos a linguagem de programação. Neste momento, com o Xcode pronto, iremos começar a entender o que é e como trabalhar com essa linguagem tão rica e poderosa.
O Xcode já nos fornece um ambiente para nos familiarizarmos com a linguagem de programação chamada Playground. Como o próprio nome diz, é um ambiente para você testar a linguagem e se divertir com a sintaxe.
Para abrir o Playground basta clicar em “Get started with a playground” na tela inicial do Xcode.
Ok, vamos declarar algumas variáveis e constantes nessa nova linguagem de programação.
A linguagem Swift, assim como outras, não é obrigatório terminar uma sentença com “;” (ponto e virgula).
Comentários em uma linha são definidos por “// comment…” e múltiplas linhas por “/* comment.. */”. Ou seja, qualquer coisa escrita aqui não será interpretada pelo programa e compilador.
Pacotes e blibliotecas podem ser importadas com a sintaxe “import”:
1
2
3
import UIKit
import MapKit
Variáveis
Variáveis são definidas por “var” e constantes por “let”.
1
2
3
4
var message = "Hello" // variáveis são mutáveis e definidas por var
var msg: String = "World" // especificando um tipo String
var result = message + msg // é possível concatenar strings com +
result = "\(message) \(msg)" // syntaxe para concatenar variáveis em uma string única
Note que o Swift é uma linguagem segura que pode automaticamente definir o tipo das variáveis apenas pelo seu valor. Porém, caso precise definir o tipo é possível “var msg: String = “abc””
Sempre priorize definir tipos de variáveis immutáveis (constantes) quando possível. Logo, em muitos casos, definimos nossos tipos, seja ele qual for, como “let”.
1
2
let name = "xcode" // name não pode sofrer alterações, ela é uma constantes
name = "swift" // Erro
Uma vez utlizado o “let” garantimos a imutabilidade dos atributos definidos.
Swift é uma linguagem de programação muito mais simples e limpa em relação ao Objective-C.
1
2
3
// código escrito em obj-c
double price = 2.50;
NSString *message = @"Objective-C!";
Tipos de dados
Conheça agora os principais tipos utilizados no Swift:
1
2
3
4
5
6
let toggle: Bool = true
let age: Int = 22
let price: Double = 22.12
let pi: Float = 3.1415
let integer: Int = Int.max
let positiveInt: UInt = UInt.max
O ponto interessante no bloco acima é que a linguagem Swift permite definir variáveis como inteiros “unsigned”, ou seja, inteiros que recebem somente números positivos. Para simplificar, um tipo “Int8” pode ter valores entre -128 a 127, enquanto um tipo “UInt8” pode ter valores entre 0 até 255.
Tudo depende de quantos bytes o tipo suporta e o seu sinal.
Utilize o playground para entender melhor os tipos mais comuns declarando diversas variáveis e constantes.
Outros tipos de dados (Array e Dictionary)
Em diversas linguagens de programação, “arrays” são tão utlizados com muita frequência e em Swift não é diferente.
Arrays são, em poucas palavras, dados estruturados em uma determinada sequência que podem ser acessados por índices e podem ter tamanhos pré-definidos ou não.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// array de strings (coleção de dados)
var array = ["Swift", "Xcode", "Mac"]
array.append("Apple") // adiciona + 1 elemento a coleção
print(array[0])
// "output: Swift"
let arrayOfInt = [0, 1, 2]
var array = ["a", "b", "c"]
array += ["d", "e"] // adiciona um array ao fim deste array
array.insert("01", at: 0) // insere um elemento em um índice específico
array.remove(at: 3) // remove um elemento em um índice específico
array.append("f") // adicionado 1 único elemento a lista
// dictionary são úteis para definir tipos que precisem
// de uma chave e um valor para serem encontrados e atribuídos.
let dict: [Int : String] = [1 : "valor1", 2 : "valor2"]
dict[1] // "valor2"
// podemos definir qualquer tipo de chave e de valor
let dict: [String : String] = ["chave1" : "valor1", "chave2" : "valor2"]
dict["chave1"] // "valor1"
Loops
Há dois tipos de loops fundamentais: “for” e “while”.
Mais uma vez a linguagem de programação Swift nos surpreende com a clareza e simplicidade da syntax.
1
2
3
for (index, value) in array.enumerated() {
print("(index) - (value)")
}
Conseguimos iterar em cada elemento dentro do array e ainda assim, ter acesso ao seu índice facilmente.
Caso queira ter um array disponível com um tamanho específico já com valores específicos, usamos o código conforme o bloco abaixo:
1
2
3
4
let newArray = Array(repeating: 10, count: 3)
for element in newArray {
print(element)
}
Neste caso temos um array de “Int” com um tamanho de 3 elementos. Sendo que esses elementos são inteiros com número 10.
Mais uma vez eu reforço, utilize o “playground” e explore mais sobre os arrays.
Loops também podem ser aplicados em “dictionary”. Porém, neste caso conseguimos ter acesso a chave e o valor de cada elemento do dictonary.
1
2
3
for (key, value) in dict.enumerated() {
print("(key) - (value)")
}
O último método fundamental para criar loops em seu programa é com while.
1
2
3
4
5
var i = 0
while i < 3 {
print(" while (i)")
i += 1
}
Casting
Há determinads situações em que você precisará que um determinado valor gravado em memória seja tratado com um tipo de dado diferente do declarado ou interpretado.
Imagine a seguinte situação:
Seu aplicativo recebe dados de preço de um determinado produto como 25.0 e você quer tratá-lo em um determinado ponto como um inteiro 25. Neste caso, você pode dizer ao programa para fazer um “casting” deste tipo.
Em algumas linguagens, o casting não é verificado em tempo de compilação. Já em Swift, isto é possível.
1
2
3
4
5
// CASTING
let fl = 3.14
let floatToInt = Int(fl) // transformando 3.14 em 3 -> Float em Int
let intToString = String(floatToInt) // transformando 3 em "3" -> Int em String
//let uInt = UInt(-3) // error
Perceba que ao tentar transformar um número negativo (“Int”) em um número “unsigned” o compilador exibe um erro por não conseguir efetivar o casting deste tipo.
Para muitos pode parecer confuso o conceito de casting, mas basicamente, o tipo de um valor, seja ele int, string, bool, é apenas uma forma de interpretar um determinado dado. No fim do dia, tudo é espaço de memória alocado em bits :). Logo, um boolean (true ou false) pode ser interpretado como 1 ou 0.
Matemática
Abaixo temos algumas funções matemáticas básicas que o próprio SDK nos fornece.
1
2
let power = pow(4, 2) // potencia
let absolute = abs(-4) // numero absoluto
Há diversas e diversas funções disponíveis que você pode utilizar, mas quero mostrar apenas as fundamentais para que você possa futuramente criar seu primeiro aplicativo iOS.
Strings
Já utilizamos um pouco de “strings” no começo mas temos duas funções muito úteis e que você pode utilizar com bastante frequência.
1
2
3
var stringcount = "new string"
print(stringcount.characters.count) // quantidade de caracteres
stringcount.append(" a") // adiciona um string ao final desta string
Note que para usar o método “append()” é necessário que a string seja um “var” (mutável) pois estamos alterando a estrutura de seu dados.
Tuplas
Tuplas são estruturas de dados que podem retornar mais de 1 valor (tipo) na mesma chamada. Ou seja, se você precisar retornar o ID e o nome de um usuário ao mesmo tempo, usar tuplas pode ser uma forma para resolver isto.
1
2
let tuple: (Int, String) = (1, "nome")
print("tuple -> (tuple.0), (tuple.1)")
Para acessar os valores de um tipo “tuple” você precisa acessar o índice do elemento que você quer. “ tuple.0”, “tuple.1”, “tuple.N”.
Funções / Métodos
Métodos ou funções são capazes de alterar o estados de varáveis e comportamentos do seu programa. Para declarar métodos em Swift utilizamos “func”.
1
2
3
func println() {
print("hello")
}
No bloco acima declaramos uma função do nome println que não exige nenhum parâmetro e não retorna nenhum tipo de dado.
No exemplo abaixo, utilizamos uma função chamada “sum” que exige dois parâmetro Int (first e second). Logo, se quisermos executar esta função devemos fornecer para ela os 2 tipos de dados “sum(first: 2, second: 3)”.
1
2
3
func sum(first: Int, second: Int) {
print(first + second)
}
Diferente de outras linguagens, o Swift por padrão exige que você passe o nome declarado do parâmetro quando for chamado. Neste caso, “sum(2, 3)” não funciona. Precisamos definir que 2 é “first” e 3 é “second”.
No bloco abaixo, alteramos a função para que ela retorne a soma dos dois números fornecidos na chamada do método. Logo, utilizamos a sintaxe “ -> Int “ para definir o tipo de retorno daquela função.
Além disso, adicionamos mais uma palavra na declaração do parâmetro chamada “integer”. Ela é somente uma forma para que quando um determinado código executar esta função, ele substitua a palavra “first” para “integer”. Ou seja, dentro da function tratamos o tipo Int como “first” e qual código que o chamr deve tratar este tipo Int como “integer”.
Isso poderia ser qualquer nome que você quisesse.
1
2
3
4
5
func sum(integer first: Int, second: Int) -> Int {
return first + second
}
let response = sum(integer: 3, second: 10)
print(response)
Uma terceira forma de declarar os parâmetros desta função além de “(fisrt: Int)” e “(integer first: Int)” é omitir o nome da variável. Veja:
1
2
3
func sum(_ first: Int, _ second: Int) {
sum(first: first, second: second)
}
O sinal “_ “ indica que ao chamar esta função, seu nome não é necessário. “sum(2, 3)”, diferente de “sum(first: 2, second: 3)”.
Lembra das tuplas? Então, ela também é um tipo assim com Int, Bool ou Double. Logo, podemos retornar uma em qualquer função:
1
2
3
func mustReturnTuple(number: Double) -> (Double, Double) {
return (number / 2, number * 2)
}
Sendo que o retorno deve ser de acordo com índice “(valor1, valor2)”.
1
2
3
let tupleResponse = mustReturnTuple(number: 8)
print(tupleResponse.0) // resultado é 4
print(tupleResponse.1) // resultado é 16
Optional
Por fim, chegamos ao conceito fundamental mais importante em Swift. Optional.
Antes de explicar “optional” quero te mostrar a sua importância.
Imagine o seguinte código:
1
2
3
4
5
6
7
8
9
10
func findPlatform(company: String) -> String {
if (company == "Apple") {
return "iOS"
} else if (company == "Google") {
return "Android"
}
return nil
}
var platform: String = findPlatform(company: "Windows")
let text = platform + " platform"
Temos uma função que tenta encontrar uma plataforma de acordo com seu nome, caso não encontre, ele retorna um tipo nil (nulo).
Em uma determinada parte do código, onde precisamos desta plataforma, passamos o nome ““Windows”” e gravamos o retorno em uma variável imutável (let) chamada plataform. Como nossa função não possui um tipo que se encaixe com Windows, retornamos nil e consequentemente nossa variável “plataform” estará nula neste ponto.
Por fim, tentamos concatenar “plataform” (que neste momento esta com o valor nil) com a string ““plataform”. Logo, um erro acontecerá e o aplicativo poderá ter um crash por tentar concaternar nil com string.
O problema aqui é que o compilador não consegue prever isto. A responsabilidade de tratar ficou em tempo de execução “runtime” e que, não é uma boa notícia.
Pensando nisso, o Swift possui o conceito de Optional.
Quando declararmos uma variável desta forma “var name: String = “oi”” estamos dizendo que ele deve sempre receber um valor que não seja nulo. Se declararmos “var name: String? = “oi”” indicamos que ele pode ter um valor nulo.
Voltando ao exemplo anterior, se adicionarmos o retorno como optional “-> String?” e tentarmos executar o mesmo código, teremos o erro de compilação evitando o app de ter um crash no futuro.
Para que tipo optional seja acessado nós precisamos “descompactar” o valor que está dentro dele.
1
2
3
4
5
6
7
8
9
10
11
12
13
func findPlatform(company: String) -> String? {
if (company == "Apple") {
return "iOS"
} else if (company == "Google") {
return "Android"
}
return nil
}
var platform: String? = findPlatform(company: "Windows")
if let p = plataform {
let text = p + " platform"
}
No novo código acima, a variável “plataform” passou a ser um optional por causa do “?” adicionado ao retorno da função e a declaração desta variável. Neste ponto, como ele é um optional, ele pode ser nulo ou não, precisamos descompactar o tipo e verificar se é algo diferente de nulo.
O bloco “if let p = plataform” já verifica se é um tipo diferente de nulo e já cria uma nova constante “let p” o valor descompactado.
Se essa condição passar, o código interno será executado. Se o valor de “platform” for nil, nada irá causar um *crash!**.
Uma outra forma de descompactar um optional é usar o “!” desta forma “let text = plataform! + “ plataform””. Mas se a variável estiver nula, ocorrerá um crash no aplicativo. Logo, aconselho fortmente sempre utilizar a condição “if let” para verificar opcionais.
Assista nosso curso gratuito de Swift
Maravilha! Em breve você receberá conteúdos exclusivos por e-mail. Continue lendo os artigos para aprender mais sobre programação.