Folha de Consulta Swift
Última atualização
Hello World e o básico
Swift não precisa de código repetitivo no nível superior - uma única linha já roda.
| Operação | Sintaxe |
|---|---|
| Exibir uma linha | print("Hello, World!") |
| Exibir sem quebra de linha | print("Hi", terminator: "") |
| Interpolação de string | print("Hi \(name)") |
| Comentário | // this is a comment |
| Comentário de várias linhas | /* ... */ |
| Importar um módulo | import Foundation |
| Executar um arquivo | swift run ou swift main.swift |
Variáveis (let / var) e tipos
Use let para constantes e var para valores mutáveis; os tipos costumam ser inferidos.
| Operação | Sintaxe |
|---|---|
| Constante | let age = 30 |
| Variável | var count = 0 |
| Tipo explícito | let name: String = "Ada" |
| Tipos básicos | Int, Double, String, Bool, Character |
| Conversão de tipo | Double(i), String(n), Int("42") |
| Tupla | let pair = (1, "a") |
| Apelido de tipo | typealias ID = Int |
| Verificar tipo | value is String, value as? String |
Optionals
Optionals modelam a possível ausência de um valor; faça o unwrap antes de usar.
| Operação | Sintaxe |
|---|---|
| Declarar optional | var name: String? = nil |
| Optional binding | if let n = name { ... } |
| Unwrap com guard | guard let n = name else { return } |
| Coalescência de nil | let n = name ?? "default" |
| Optional chaining | user?.address?.city |
| Force unwrap (inseguro) | name! |
| Implicitamente desempacotado | var name: String! |
| Map sobre optional | name.map { $0.count } |
Strings
Strings são tipos de valor com suporte completo a Unicode.
| Operação | Sintaxe |
|---|---|
| Comprimento | s.count |
| Maiúsculas / minúsculas | s.uppercased(), s.lowercased() |
| Concatenar | "foo" + "bar" |
| Interpolação | "Total: \(price)" |
| Contém | s.contains("ell") |
| Tem prefixo / sufixo | s.hasPrefix("he") |
| Dividir | s.split(separator: ",") |
| Substituir | s.replacingOccurrences(of: "a", with: "b") |
| String de várias linhas | """ ... """ |
Coleções (Array, Dictionary, Set)
Três tipos centrais de coleção, todos tipos de valor.
| Operação | Sintaxe |
|---|---|
| Literal de array | var nums = [1, 2, 3] |
| Append | nums.append(4) |
| Acesso / contagem | nums[0], nums.count |
| Map / filter | nums.map { $0 * 2 }, nums.filter { $0 > 1 } |
| Literal de dicionário | var ages = ["Ada": 30] |
| Acesso ao dicionário | ages["Ada"] retorna um optional |
| Literal de set | var ids: Set = [1, 2, 3] |
| Inserir em um set | ids.insert(4) |
| Iterar dicionário | for (k, v) in ages { ... } |
Controle de fluxo
Condições não precisam de parênteses; o switch precisa ser exaustivo.
| Operação | Sintaxe |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| Ternário | let r = x > 0 ? "pos" : "neg" |
| Switch | switch n { case 1: ...; default: ... } |
| Switch com range | case 1...5: ... |
| Laço for-in | for i in 0..<10 { ... } |
| For-in sobre array | for item in items { ... } |
| Laço while | while x < 100 { ... } |
| Repeat-while | repeat { ... } while x < 100 |
| Break / continue | break, continue |
Funções e closures
Funções têm parâmetros rotulados; closures são blocos de código autossuficientes.
| Operação | Sintaxe |
|---|---|
| Definir uma função | func add(a: Int, b: Int) -> Int { a + b } |
| Rótulo externo | func greet(to name: String) { ... } |
| Parâmetro padrão | func greet(name: String = "World") { ... } |
| Parâmetro variádico | func sum(_ nums: Int...) -> Int { ... } |
| Múltiplos retornos (tupla) | func bounds() -> (min: Int, max: Int) { ... } |
| Expressão de closure | let f = { (x: Int) -> Int in x * x } |
| Trailing closure | nums.map { $0 * 2 } |
| Argumentos abreviados | { $0 + $1 } |
Structs vs classes
Structs são tipos de valor (copiados); classes são tipos de referência (compartilhados).
| Operação | Sintaxe |
|---|---|
| Definir uma struct | struct Point { var x: Int; var y: Int } |
| Definir uma classe | class Person { var name: String } |
| Inicializador de classe | init(name: String) { self.name = name } |
| Criar instância | let p = Point(x: 1, y: 2) |
| Método mutating de struct | mutating func move() { x += 1 } |
| Método de classe | func greet() { ... } |
| Herança (apenas classe) | class Student: Person { ... } |
| Propriedade computada | var area: Int { width * height } |
| Membro estático | static let shared = Manager() |
Enums
Enums agrupam valores relacionados e podem carregar dados associados.
| Operação | Sintaxe |
|---|---|
| Definir um enum | enum Direction { case north, south } |
| Usar um case | let d = Direction.north |
| Switch sobre enum | switch d { case .north: ... } |
| Valores brutos | enum Status: Int { case ok = 200 } |
| Acessar valor bruto | Status.ok.rawValue |
| Inicializar a partir do valor bruto | Status(rawValue: 200) |
| Valores associados | case result(Int, String) |
| Métodos em enums | func label() -> String { ... } |
A sintaxe de Swift que você mais usa, em uma única página. Esta folha de consulta Swift é uma referência rápida para o núcleo da linguagem - constantes e variáveis, optionals, strings, coleções, controle de fluxo, funções e closures, além dos structs, classes e enums com os quais você constrói apps para iOS e macOS.
Tudo aqui é Swift padrão e compila com a toolchain oficial. Copie o que precisar ou teste cada trecho ao vivo no playground de Swift - sem necessidade do Xcode.
Perguntas frequentes sobre a folha de consulta Swift
Esta folha de consulta Swift é gratuita?
Sim. Esta folha de consulta Swift é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar um padrão de optional, a sintaxe de closure ou um método de coleção.
Como faço o unwrap de um optional em Swift?
Um optional pode conter um valor ou
nil, então você faz o unwrap dele antes de usar. As formas seguras são o optional binding (if let n = name { ... }), um guard let no topo de uma função, o operador de coalescência de nil (name ?? "default") e o optional chaining (user?.name). O force unwrap com name! funciona, mas causa crash se o valor for nil, então recorra a ele apenas quando tiver certeza.Qual é a diferença entre uma struct e uma classe em Swift?
Uma
struct é um tipo de valor: atribuí-la ou passá-la cria uma cópia, então as alterações não afetam o original. Uma class é um tipo de referência: as cópias compartilham a mesma instância, e apenas classes oferecem herança. A orientação da Apple é preferir structs por padrão e usar uma classe quando você precisar de estado mutável compartilhado ou de herança.Posso praticar Swift online?
Sim. Abra o playground de Swift para executar qualquer trecho desta folha de consulta no seu navegador - sem Xcode para instalar. Quando quiser estrutura, o curso interativo e gratuito de Swift da Coddy leva você passo a passo de optionals e coleções a structs, classes e enums.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos tópicos mais comuns (variáveis, optionals, controle de fluxo) até os avançados (closures, structs vs classes, enums), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
