Olá! Mais de um ano se passou desde o lançamento do Swift 5, que trouxe muitas coisas novas para os desenvolvedores. Neste artigo, quero falar sobre o desenvolvimento móvel para IOS, como funciona, o que é necessário para isso e muito mais. O artigo é destinado a pessoas que estão apenas começando sua programação no Swift 5 .
Requisitos de sistema operacional e hardware
De uma forma ou de outra, para construir um aplicativo para IOS de qualquer versão, você precisa de um computador rodando o sistema operacional Mac OS (e de preferência a versão mais recente, caso contrário alguma parte das ferramentas do desenvolvedor e o Xcode podem começar a funcionar de forma totalmente imprevisível). A necessidade de um sistema rodando Mac OS é causa de controvérsia e ódio de outros desenvolvedores que não estão acostumados a serem limitados em suas capacidades por causa do sistema operacional. Na maioria das vezes, existem várias maneiras: comprando ou montando um Hackintosh (no entanto, no caso de automontagem, quero avisar que não será fácil montar um computador sem um problema constante de driver). Já vi tanto a instalação de uma imagem do sistema operacional em uma máquina virtual quanto a implementação do Mac OS em um laptop comum, sem problemas de driver.No entanto, esse caminho exigirá algumas habilidades de hardware de você e corre o risco de não ter suporte de 100% para versões futuras do Mac OS.
Uma forma alternativa, é claro, é comprar um computador originalmente da Apple. Se você queria um laptop, provavelmente sabe o que fazer (mas quero avisá-lo imediatamente que o Xcode imediatamente leva cerca de 25 gigabytes, e pode facilmente ocupar todos os 44 gigabytes se você baixar simuladores adicionais para dispositivos. o tamanho de 128 gigabytes deve ser apenas para desenvolvimento IOS sem quaisquer peças adicionais, como node_modules, Pycharm e Unity cache, homebrew e outras coisas para desenvolvedores, que ocupam uma tonelada de espaço em disco. Se você vai fazer outra coisa, você precisará de um disco, pelo menos de 256 gigabytes ou mais).
Opções de ambiente de desenvolvimento
Além da maneira mais ou menos clássica de desenvolver aplicativos em Xcode usando Swift e usando as bibliotecas Cocoa e CocoaTouch, agora existem muitas outras maneiras de desenvolver quase sem usar Xcode (apenas sem Xcode você não pode mais construir um aplicativo). Existem várias tecnologias:
- Xamarin . Os aplicativos nesta plataforma são escritos em C #. Com o Xamarin, você pode criar qualquer aplicativo nativo para Android ou IOS. O desenvolvimento pode ser feito usando o Visual Studio. Apesar de tais vantagens, provavelmente. alguns fragmentos de aplicativo precisarão ser escritos separadamente para cada plataforma
- React Native. React , -. . , - , - . , .
- Flutter. , Flutter Dart Google. , , . , Flutter — React Native, . Dart, -
- PhoneGap/Cordova. Nitobi, Adobe. , PhoneGap, Apache Cordova, WebView,
- Unity. IOS, . , . gamedev.
A Apple recomenda o uso da linguagem de programação Swift para o desenvolvimento de aplicativos. Swift é uma linguagem de programação relativamente nova que não foi lançada oficialmente até 2014. Ele pode ser usado para desenvolvimento para Mac OS, IOS, e também há suporte para Linux (então, se você tiver, digamos, um Linux não muito específico, pode fazer o download com segurança e experimentar o idioma, por exemplo, neste link).
O próprio Swift é uma linguagem típica de nova geração, como Golang.
Inicialmente, a linguagem foi concebida como uma linguagem mais fácil de ler e resistente a erros para o programador do que Objective C. Ao mesmo tempo, Swift pode trabalhar com C e Objective C dentro do mesmo projeto.
Em vez de tentar dar uma descrição desta linguagem (que à primeira vista é C ++, apenas modificada para a realidade moderna com uma função de digitação automática da moda), convido o leitor a estudar a bela documentação da Apple, que descreve em detalhes como a linguagem funciona e qual é a sua sintaxe. A versão em inglês pode ser encontrada aqui , a tradução em russo pode ser encontrada aqui . Depois de se familiarizar com o básico da linguagem Swift, podemos prosseguir para o que estamos aqui hoje - criar nossa calculadora simples usando o Xcode.
Criação de uma calculadora
Para criar um aplicativo, precisamos do Xcode, que pode ser baixado gratuitamente na AppStore. Não se deixe intimidar por sua classificação - embora as cinco primeiras avaliações forneçam 1 estrela, isso não significa que você ficará em choque. Talvez a sintaxe e as dicas não sejam incluídas muito rapidamente durante a edição - mas, em geral, o Xcode me deixou impressões muitas vezes mais favoráveis do que o mesmo Android Studio (embora talvez eu simplesmente não saiba como prepará-lo). Se você, de repente, deseja experimentar o desenvolvimento fora do Xcode e prefere os produtos JetBrains, pode experimentar o AppCode - ele suporta interoperabilidade com o Xcode, trabalhando com Swift e Objective C e muitos outros recursos interessantes. Eu, pessoalmente, não tentei, mas se você tem uma assinatura de todos os softwares da JetBrains - por que não baixe e execute-o.
Então você instalou o Xcode. Agora você pode começar a desenvolver. Inicie um novo projeto e selecione Aplicativo de página única:
Depois disso, você será solicitado a inserir dados sobre o seu aplicativo. Se esta é a primeira vez que inicia o Xcode, você precisará inserir o ID da Apple lá. Em seguida, você deve preencher os dados sobre o nome do seu projeto (no nosso caso, apenas Calculadora) e o nome da sua empresa e aplicativo. Você pode escrever o que quiser aqui se não tiver a intenção de publicar este aplicativo no futuro. Escolhi Swift como linguagem e Storyboard como interface do usuário. Eu rejeitei os testes até agora
Depois de criar nosso aplicativo, você pode acessar o arquivo em
Calculator.xcodeproje ajustar as configurações se achar necessário. Por enquanto, deixei tudo como está, desenvolvendo para a última versão do IOS 13.6 para Iphone e Ipad. Em princípio, você pode excluir o iPad por enquanto - nossa interface provavelmente não ficará muito boa nele. No entanto, quero avisá-lo que se você publicar de repente - os funcionários da Apple estão testando aplicativos para o iPhone, para que eles sejam pelo menos funcionais no Ipad. Mas antes disso, você ainda tem que gastar US $ 99 em chaves de desenvolvedor).
Depois de criar o aplicativo, você pode chamar imediatamente o emulador para rastrear o que acontece. Para fazer isso, você pode simplesmente pressionar a combinação de teclas CMD + R. No canto superior esquerdo, você pode selecionar os dispositivos nos quais executa o emulador e também pode conectar seu dispositivo físico real por meio de um cabo e testar imediatamente nele).
Há muitas maneiras de criar uma interface e widgets nela. Vou usar uma opção neutra - criar um suporte principal, colocá-lo na tela inteira e, em seguida, começar a posicionar meus widgets de maneira programática. Portanto, primeiro vamos ao arquivo
Main.storyboarde tornamos a View principal preta, a fim de posicionar mais convenientemente nossos elementos:
Depois disso, adicionaremos uma View, com a qual trabalharemos principalmente. Para fazer isso, clique no sinal de mais no canto superior direito, através do qual você pode adicionar widgets, e adicionar um novo widget, digite uiview na busca :
Depois disso, arrastamos este widget para a tela principal, e precisamos expandi-lo para tela inteira. Para isso, precisamos trabalhar
constaint. Para fazer isso, clique no ícone no canto inferior esquerdo, que se parece um pouco com a nave de Darth Vader, e atribua 0 em cada lado:
Depois disso, seu novo widget se expandirá para caber na tela inteira. Em seguida, como da última vez, precisamos mudar a cor do nosso widget, só agora para Clear Color para que não interfira conosco e possamos colocar widgets nele.
Agora você pode ir para o arquivo
ViewController.swift, em que teremos todo o resto da programação. Primeiro, precisamos usar um marcador especial @IBOutletpara poder vincular o Storyboard ao nosso código. Para fazer isso, devemos escrever a seguinte linha:
@IBOutlet var holder: UIView!
Agora podemos vincular o código ao widget. Para fazer isso, na verdade, você precisa conectar o nosso titular ao titular. Para fazer isso, clique com o botão direito
viewControllere arraste o suporte para nossa tela:
Finalmente, terminamos de vincular o código ao Storyboard e podemos iniciar a programação.
A seguir, adicionaremos duas variáveis, a primeira das quais será apenas um número no qual o primeiro valor pode ser escrito, e a segunda será o valor resultante. A terceira variável será um pouco mais específica, pois usaremos uma declaração opcional (você pode ler que tipo de animal é, você pode ler mais aqui) Opcional pode conter qualquer valor ou nulo. Opcionais também garantem que os valores nulos sejam processados explicitamente. Além disso, adicionaremos desde o início uma lista das operações matemáticas que a calculadora suporta:
var firstNumber = 0
var resultNumber = 0
var currentOperations: Operation?
enum Operation {
case add, subtract, multiply, divide
}
A seguir, temos que criar um Label, no qual mostraremos os números e o resultado dos cálculos. Por padrão, haverá 0 e uma fonte bastante grande. Todo o resto, eu acho, é perfeitamente claro:
private var resultLabel: UILabel = {
let label = UILabel()
label.text = "0"
label.textColor = .white
label.textAlignment = .right
label.font = UIFont(name: "Helvetica", size: 100)
return label
}()
Depois disso, pulando o método embutido que nos chama de renderização (estou falando
viewDidLoad), precisamos chamar um método que chamará uma função que desenhará todos os botões nos quais as funções do manipulador serão travadas.
override func viewDidLayoutSubviews() {
super.viewDidLayoutSubviews()
setupNumberPad() //,
}
Depois disso, temos a função
setupNumberPad. Primeiro, irei definir uma constante para o tamanho da nossa fonte, para que depois, se houver alguma coisa, você possa aumentar / diminuir imediatamente o tamanho da fonte no aplicativo, porque eu trabalho sem um layout. Depois disso, criarei um tamanho de botão - sua largura será igual a um quarto do tamanho da tela de nosso aplicativo.
private func setupNumberPad() {
let FontSize:CGFloat = 25
//
let buttonSize: CGFloat = view.frame.size.width / 4
// 1/4
let zeroButton = UIButton(frame: CGRect(x: 0, y: holder.frame.size.height-buttonSize, width: buttonSize*3, height: buttonSize))
// UIButton
zeroButton.setTitleColor(.black, for: .normal)
//
zeroButton.backgroundColor = .white
//
zeroButton.setTitle("0", for: .normal)
// 0
zeroButton.titleLabel?.font = UIFont(name: "Helvetica", size: FontSize)
// , family
zeroButton.tag = 1
//
holder.addSubview(zeroButton) // holder
zeroButton.addTarget(self, action: #selector(zeroTapped), for: .touchUpInside)
//
0 ocupa um terço da tela para que possamos ir para a coluna certa para operandos matemáticos. Em seguida, precisamos renderizar todos os botões de alguma forma. Claro, seria possível desenhá-los um por um, mas então será longo e triste. Porque teremos apenas uma série de números de 1 a 9, então a decisão de usar ciclos está bem superficial. Vou dar o primeiro ciclo com comentários, e desde os outros dois são essencialmente uma repetição, vou dar-lhes logo abaixo do corte:
for x in 0..<3 {
let button_row_1 = UIButton(frame: CGRect(x: buttonSize * CGFloat(x), y: holder.frame.size.height-(buttonSize*2), width: buttonSize, height: buttonSize))
// x x
button_row_1.setTitleColor(.black, for: .normal) //
button_row_1.backgroundColor = .white //
button_row_1.setTitle("\(x+1)", for: .normal) //
holder.addSubview(button_row_1) //
button_row_1.tag = x+2 // .. 1 , 2
button_row_1.addTarget(self, action: #selector(numberPressed(_:)), for: .touchUpInside)
//
}
O resto do código de nossos números
for x in 0..<3 {
let button_row_2 = UIButton(frame: CGRect(x: buttonSize * CGFloat(x), y: holder.frame.size.height-(buttonSize*3), width: buttonSize, height: buttonSize))
button_row_2.setTitleColor(.black, for: .normal)
button_row_2.backgroundColor = .white
button_row_2.setTitle("\(x+4)", for: .normal)
button_row_2.addSubview(button_row_2)
button_row_2.tag = x+5
button_row_2.addTarget(self, action: #selector(numberPressed(_:)), for: .touchUpInside)
}
for x in 0..<3 {
let button_row_3 = UIButton(frame: CGRect(x: buttonSize * CGFloat(x), y: holder.frame.size.height-(buttonSize*4), width: buttonSize, height: buttonSize))
button_row_3.setTitleColor(.black, for: .normal)
button_row_3.backgroundColor = .white
button_row_3.setTitle("\(x+7)", for: .normal)
holder.addSubview(button_row_3)
button_row_3.tag = x+8
button_row_3.addTarget(self, action: #selector(numberPressed(_:)), for: .touchUpInside)
}
Depois disso, precisamos colocar nosso botão CE, no qual iremos zerar os dados que foram inseridos. Vamos colocá-lo no topo e descrever sua carga funcional um pouco mais tarde. Por enquanto, precisamos apenas posicioná-lo e conectar os manipuladores:
let clearButton = UIButton(frame: CGRect(x: 0, y: holder.frame.size.height-(buttonSize*5), width: view.frame.size.width - buttonSize, height: buttonSize))
clearButton.setTitleColor(.black, for: .normal)
clearButton.backgroundColor = .init(red: 0, green: 2, blue: 0.8, alpha: 1) // rgb
clearButton.titleLabel?.font = UIFont(name: "Helvetica", size: FontSize-4) //
clearButton.setTitle("CE", for: .normal)
holder.addSubview(clearButton) // holder
clearButton.addTarget(self, action: #selector(clearResult), for: .touchUpInside) //
Terminamos com essa parte entediante de repetição, agora estamos prontos para outra coisa - nossos operandos com os quais podemos realizar operações matemáticas. Para começar, colocamos os operandos necessários dentro do array, de onde os tiraremos. Colocaremos os próprios botões de operandos em uma coluna e adicionaremos uma função de tratamento que reagirá ao pressionar nossos operandos. Farei os botões em uma
let operations = ["=","+", "-", "x", "÷"] //
for x in 0..<5 {
let button_operand = UIButton(frame: CGRect(x: buttonSize * 3, y: holder.frame.size.height-(buttonSize * CGFloat(x+1)), width: buttonSize, height: buttonSize))
button_operand.setTitleColor(.black, for: .normal)
button_operand.backgroundColor = .init(red: 2, green: 0.8, blue: 0, alpha: 1) //
button_operand.setTitle(operations[x], for: .normal)
holder.addSubview(button_operand)
button_operand.tag = x+1
// ,
button_operand.titleLabel?.font = UIFont(name: "Helvetica", size: FontSize)
button_operand.addTarget(self, action: #selector(operationPressed(_:)), for: .touchUpInside)
}
Após essas operações globais, precisamos apenas posicionar o Label, no qual escreveremos o resultado, e fechar a função:
resultLabel.frame = CGRect(x: 20, y: clearButton.frame.origin.y - 110.0, width: view.frame.size.width - 40, height: 100)
holder.addSubview(resultLabel)
} //
Agora você pode passar para os manipuladores:
Trabalho com manipuladores
Tudo isso era essencialmente apenas um layout, agora temos que injetar lógica no aplicativo. Para fazer isso, usaremos métodos do tempo de execução Objective C para simplificar nosso código. Se você não entende o que está acontecendo, posso recomendar este artigo para você ler.
Então, aqui estão nossas funções:
@objc func clearResult() {
resultLabel.text = "0" // 0
currentOperations = nil //
firstNumber = 0 // 0
}
@objc func zeroTapped() {
//
if resultLabel.text != "0" {
if let text = resultLabel.text {
resultLabel.text = "\(text)\(0)" //
}
}
}
Em seguida, precisamos adicionar uma função de manipulador aos nossos botões:
@objc func numberPressed(_ sender: UIButton) {
let tag = sender.tag - 1
if resultLabel.text == "0" {
resultLabel.text = "\(tag)"
}
else if let text = resultLabel.text {
//
resultLabel.text = "\(text)\(tag)"
}
}
A seguir está a lógica de negócios mais importante de nosso aplicativo. Usaremos a construção switch para controlar nossas operações matemáticas:
@objc func operationPressed(_ sender: UIButton) {
let tag = sender.tag
if let text = resultLabel.text, let value = Int(text), firstNumber == 0 {
//
firstNumber = value
resultLabel.text = "0"
}
if tag == 1 {
if let operation = currentOperations {
var secondNumber = 0
if let text = resultLabel.text, let value = Int(text) {
secondNumber = value
}
switch operation {
case .add:
firstNumber = firstNumber + secondNumber
secondNumber = 0 //
resultLabel.text = "\(firstNumber)"
currentOperations = nil
firstNumber = 0 // Label
break
case .subtract:
firstNumber = firstNumber - secondNumber
secondNumber = 0
resultLabel.text = "\(firstNumber)"
currentOperations = nil
firstNumber = 0
break
case .multiply:
firstNumber = firstNumber * secondNumber
secondNumber = 0
resultLabel.text = "\(firstNumber)"
currentOperations = nil
firstNumber = 0
break
case .divide:
firstNumber = firstNumber / secondNumber
secondNumber = 0
resultLabel.text = "\(firstNumber)"
currentOperations = nil
firstNumber = 0
break
}
}
}
else if tag == 2 {
currentOperations = .add
// . ,
}
else if tag == 3 {
currentOperations = .subtract
}
else if tag == 4 {
currentOperations = .multiply
}
else if tag == 5 {
currentOperations = .divide
}
}
}
Isso é tudo! O código-fonte deste aplicativo pode ser encontrado neste link. Como resultado, a aparência ficou assim:
Por tradição, darei vários recursos úteis que podem ser úteis para um desenvolvedor iniciante de IOS:
- Um ótimo site para um iniciante com toneladas de respostas para perguntas comuns do Swift
- Swift Tour, lugar legal se você já conhece programação e só quer se atualizar com a linguagem
- Um pouco sobre o SwiftUI relativamente novo e moderno
Um início rápido para o desenvolvimento do iOS. Webinar grátis