DEV Community: BC

Learn SwiftUI (Day 19/100)

BC — Fri, 03 May 2024 15:08:45 +0000

SwiftUI

Challenge day: Unit Converter

https://www.hackingwithswift.com/100/swiftui/19

I used VStack and HStack with the help of GPT-4.

import SwiftUI

struct ContentView: View {
    @State private var f: Double = 68
    @State private var c: Double = 0
    @FocusState private var isFocusedF
    @FocusState private var isFocusedC

    func f2c(_ f: Double) -> Double {
        Double(String(format: "%.2f", (f-32) * 5 / 9))!
    }

    func c2f(_ c: Double) -> Double {
        Double(String(format:"%.2f", c * 9 / 5 + 32))!
    }

    var body: some View {
        NavigationStack {
            Form {
                Section("Temperature") {
                    VStack(alignment: .leading) {
                        HStack {
                            TextField("F", value: $f, format: .number)
                                .keyboardType(.numberPad)
                                .onChange(of: f) { (oldValue, newValue) in
                                    if isFocusedF {
                                        self.c = f2c(newValue)
                                    }
                                }
                                .focused($isFocusedF)
                            Text("°F").foregroundColor(.gray)
                        }
                        Divider().padding(.vertical)
                        HStack {
                            TextField("C", value: $c, format: .number)
                                .keyboardType(.numberPad)
                                .onChange(of: c) { (oldValue, newValue) in
                                    if isFocusedC {
                                        self.f = c2f(newValue)
                                    }
                                }
                                .focused($isFocusedC)
                            Text("°C").foregroundColor(.gray)
                        }
                        .onAppear {
                            self.c = f2c(f)
                        }
                    }
                    .padding()
                }
            }
            .navigationTitle("Simple Metrics")
        }
    }
}

Screenshot:

Learn SwiftUI (Day 18/100)

BC — Thu, 02 May 2024 21:12:54 +0000

Project

Based on the current "We Split" app, make changes:

Add a header to the third section, saying “Amount per person”
Add another section showing the total amount for the check – i.e., the original amount plus tip value, without dividing by the number of people.
Change the tip percentage picker to show a new screen rather than using a segmented control, and give it a wider range of options – everything from 0% to 100%. Tip: use the range 0..<101 for your range rather than a fixed array.



import SwiftUI

struct ContentView: View {
    @State private var checkAmount:Double = 0
    @State private var numOfPeopleIndex:Int = 0
    @State private var tipsPercent:Int = 10
    @FocusState private var isFocused: Bool

    private let minPeopleCount = 2
    private let tipsPercentList: [Int] = Array(0...100)


    var total : Double {
        checkAmount * (1.0 + Double(tipsPercent) / 100.0)
    }
    var amountPerPerson: Double {
        total / Double(numOfPeopleIndex + minPeopleCount)
    }

    var body: some View {
        NavigationStack {
            Form {
                Section{
                    TextField("Amount", value: $checkAmount, format: .currency(code: Locale.current.currency?.identifier ?? "USD"))
                        .keyboardType(.numberPad)
                        .focused($isFocused)
                    Picker("Number of people", selection: $numOfPeopleIndex) {
                        ForEach(2..<20) {
                            Text("\($0) People")
                        }
                    }
                    .pickerStyle(.navigationLink)
                }

                Section("Tip") {
                    Picker("Tip Percentage", selection: $tipsPercent) {
                        ForEach(tipsPercentList, id: \.self) {
                            Text($0, format: .percent)
                        }
                    }
                    .pickerStyle(.navigationLink)
                }

                Section("Total") {
                    Text(total, format: .currency(code: Locale.current.currency?.identifier ?? "USD"))
                }

                Section("Amount per person") {
                    Text(amountPerPerson, format: .currency(code: Locale.current.currency?.identifier ?? "USD"))
                }

            }
            .navigationTitle("We Split")
            .toolbar {
                if isFocused {
                    Button("Done") {
                        isFocused = false
                    }
                }
            }
        }
    }
}

Result:

Learn SwiftUI (Day 17/100)

BC — Thu, 02 May 2024 20:46:14 +0000

Swift UI

TextField
Picker
Picker style
NavigationStack
Focus mode
Toolbar

import SwiftUI

struct ContentView: View {
    @State private var checkAmount:Double = 0
    @State private var numOfPeopleIndex:Int = 0
    @State private var tipsPercent:Int = 10
    @FocusState private var isFocused: Bool

    private let minPeopleCount = 2
    private let tipsPercentList: [Int] = [10, 15, 18, 20, 25, 0]


    var amountPerPerson: Double {
        checkAmount * (1.0 + Double(tipsPercent) / 100.0) / Double(numOfPeopleIndex + minPeopleCount)
    }

    var body: some View {
        NavigationStack {
            Form {
                Section{
                    TextField("Amount", value: $checkAmount, format: .currency(code: Locale.current.currency?.identifier ?? "USD"))
                        .keyboardType(.numberPad)
                        .focused($isFocused)
                    Picker("Number of people", selection: $numOfPeopleIndex) {
                        ForEach(2..<20) {
                            Text("\($0) People")
                        }
                    }
                    .pickerStyle(.navigationLink)
                }

                Section("Tip") {
                    Picker("Tip Percentage", selection: $tipsPercent) {
                        ForEach(tipsPercentList, id: \.self) {
                            Text("\($0)%")
                        }
                    }
                    .pickerStyle(.segmented)
                }

                Section("Amount per person") {
                    Text(amountPerPerson, format: .currency(code: Locale.current.currency?.identifier ?? "USD"))
                }

            }
            .navigationTitle("We Split")
            .toolbar {
                if isFocused {
                    Button("Done") {
                        isFocused = false
                    }
                }
            }
        }
    }
}

Running:

Learn SwiftUI (Day 16/100)

BC — Thu, 02 May 2024 19:38:40 +0000

Basic Structure

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
    }
}

Form

    NavigationStack {
        Form {
            Section {
                Text("Hello World")
            }
            Section {
                Text("Hello SwiftUI")
            }
        }
        .navigationTitle("Settings")
        .navigationBarTitleDisplayMode(.inline)
    }

Change state

    @State private var clicked = 0
    var body: some View {
        Button("You have clicked \(clicked) times") {
            self.clicked += 1
        }
    }

2-way binding

Notice the $name here:

    @State private var name = ""
    var body: some View {
        Form {
            TextField("Your name:", text: $name)
            Text(name.count != 0 ? "Hello, \(name)": "")
        }
    }

Create view in a loop

    var body: some View {
        Form {
            ForEach(0..<50) {
                Text("Hello \($0+1)")
            }
        }
    }

Learn SwiftUI (Day 15/100)

BC — Thu, 02 May 2024 18:51:33 +0000

This one is a review session on the swift programming language:

https://www.hackingwithswift.com/articles/242/learn-essential-swift-in-one-hour

Learn SwiftUI (Day 14/100)

BC — Thu, 02 May 2024 17:14:59 +0000

Swift

optionals
if let
guard let ... else
?? and chaining ?.
try?

import Cocoa

// ## optionals
/*
 Optionals are like a box that may or may not have something inside.
 var number: Int? = nil
 var name: String? = "hello world"
 */
// 3 ways to unwrap optionals
// 1) if let
var opposites = ["Mario": "Wario", "Luigi":"Waluigi"]
if let marioOpposite = opposites["Mario"] {
    print("Mario's opposite is \(marioOpposite)")
}

var name: String? = "hello world"
if let name = name {
    print("name is \(name)")
}

// 2). guard let ... else
func printSquare(of number: Int?) {
    guard let number = number else {
        print("Missing input")
        return
    }
    print("\(number) x \(number) is \(number * number)")
}
printSquare(of: 4)
// a more general version of guard is:
// guard someArray.isEmpty else { return }.

// 3) ??
let new = opposites["Peach"] ?? "N/A"

let input = ""
let number = Int(input) ?? 0
print(number)

// chaining
/*
 Optional chains can go as long as you want, and as soon as any part sends
 back nil the rest of the line of code is ignored and sends back nil.
 */
// example 1
let names = [String]()
let chosen = names.randomElement()?.uppercased() ?? "No one"
print("Next in line: \(chosen)")

// example 2
struct Book {
    let title: String
    let author: String?
}

var book: Book? = nil
let author = book?.author?.first?.uppercased() ?? "A"
print(author)

// ## use `try?`
/*
 If the function ran without throwing any errors then the optional will
 contain the return value, but if any error was thrown the function will
 return nil.
 */
enum UserError: Error {
    case badID, networkFailed
}

func getUser(id: Int) throws -> String {
    throw UserError.networkFailed
}

if let user = try? getUser(id: 23) {
    print("User: \(user)")
}
// or
let user = (try? getUser(id: 23)) ?? "Anonymous"


// ## checkpoint

/*
 write a function that accepts an optional array of integers, and returns one randomly. If the array is missing or empty, return a random number in the range 1 through 100.
 */

func randomPick(nums: [Int]?) -> Int {
    return nums?.randomElement() ?? Int.random(in: 1...100)
}
print(randomPick(nums: []))

Learn SwiftUI (Day 13/100)

BC — Thu, 02 May 2024 16:02:29 +0000

Swift

protocols
extensions
protocol extensions

import Cocoa

// ## protocol

// {get set} -> no comman in between
// {get} or {get set}, not possible for just {set}

protocol Vehicle {
    var name: String { get }
    var currentPassengers: Int { get set }
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

struct Rocket: Vehicle {
    let name = "rocket"
    var currentPassengers = 0

    func estimateTime(for distance: Int) -> Int {
        return distance / 100
    }

    func travel(distance: Int) {
        print("\(name) traveled \(distance) already")
    }
}

var r = Rocket()
r.travel(distance: 12)

// opaque return type
/*
 they let us hide information in our code, but not from the Swift compiler.
 This means we reserve the right to make our code flexible
 internally so that we can return different things in the future,
 but Swift always understands the actual data type being returned
 and will check it appropriately.
 */

func getRandomNumber() -> some Equatable {
    Int.random(in: 1...6)
}

/*
 when you see some View in your SwiftUI code, it’s effectively us telling
 Swift “this is going to send back some kind of view to lay out, but I don’t
 want to write out the exact thing – you figure it out for yourself.”
 */

// ## Extentions
/*
 Extensions let us add functionality to any type, whether we created it or 
 someone else created it – even one of Apple’s own types.
 */

extension String {
    func trimmed() -> String {
        self.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}
let a = " hello world   "
print(a.trimmed())

/*
 If want to change the string itself, use:
 mutating func trim() {
     self = self.trimmed()
 }
 */

// ## can add computed property extension to a type
/*
 var lines: [String] {
     self.components(separatedBy: .newlines)
 }
 */

// ## put custom init in extension
/*
 if we implement a custom initializer inside an extension, then Swift won’t
 disable the automatic memberwise initializer.
 extension Book {
     init(title: String, pageCount: Int) {
         self.title = title
         self.pageCount = pageCount
         self.readingHours = pageCount / 50
     }
 }
 */

// ## protocol extensions
extension Collection {
    var isNotEmpty: Bool {
        isEmpty == false
    }
}

// use extension to implement a default method in protocol
protocol Person {
    var name: String { get }
    func sayHello()
}

extension Person {
    func sayHello() {
        print("Hi, I'm \(name)")
    }
}

Learn SwiftUI (Day 12/100)

BC — Thu, 02 May 2024 04:09:34 +0000

Swift

class
inheritance and override
final class
init function in subclass
deep copy
deinit function
constant class instance can change var property

import Cocoa


// ## define class
/*
 * When you copy an instance of a class, both copies share the same data – if you change one copy, the other one also changes.
 */
class Game {
    var score = 0 {
        didSet {
            print("Score is now \(score)")
        }
    }
}

var game1 = Game()
// both game1 and game2 refer to the same object
// classes are reference types in Swift, which means all copies of a class all refer back to the same underlying pot of data.
var game2 = game1
game1.score += 10
print("game1 score:", game1.score) // 10
print("game2 score:", game2.score) // 10

// ## inheritance and override

/*
 This is where Swift enforces a simple rule: if a child class wants to change a method from a parent class, you must use override in the child class’s version
 */

class Employee {
    let hours: Int

    init(hours: Int) {
        self.hours = hours
    }

    func summary() {
        print("I'm an employee")
    }
}

class Developer: Employee {
    func work() {
        print("I'm writing code for \(hours) hours.")
    }

    override func summary() {
        print("I'm a developer")
    }
}

let john = Developer(hours: 8)
john.summary()

// ## final class
/*
 If you know for sure that your class should not support inheritance, you can mark it as final. This means the class itself can inherit from other things, but can’t be used to inherit from – no child class can use a final class as its parent.
 */

final class Person {
    let name: String
    let age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

// ## init func in sub class
/*
 If a child class has any custom initializers, it must always call the parent’s initializer after it has finished setting up its own properties, if it has any
 */

class Vehicle {
    let isElectric: Bool

    init(isElectric: Bool) {
        self.isElectric = isElectric
    }
}

class Car: Vehicle {
    let isConvertible: Bool

    init(isElectric: Bool, isConvertible: Bool) {
        self.isConvertible = isConvertible
        super.init(isElectric: isElectric)
    }
}

// ## Deep copy

/*
 If you want to create a unique copy of a class instance – sometimes called a deep copy – you need to handle creating a new instance and copy across all your data safely.
 */

class User {
    var username = "Anonymous"

    func copy() -> User {
        let user = User()
        user.username = username
        return user
    }
}

// ## deinitializer

/*
 1. Just like initializers, you don’t use func with deinitializers – they are special.
 2. Deinitializers can never take parameters or return data, and as a result aren’t even written with parentheses.
 3. Your deinitializer will automatically be called when the final copy of a class instance is destroyed. That might mean it was created inside a function that is now finishing, for example.
 4. We never call deinitializers directly; they are handled automatically by the system.
 5. Structs don’t have deinitializers, because you can’t copy them.
 */

// Notice there is no `func` or `()` around `deinit`
class Job {
    deinit {
        print("I quit!")
    }
}

// ## constant class instance can change var property

/*
 This is different from structs, because constant structs cannot have their properties changed even if the properties were made variable.
 structs don’t have the whole signpost thing going on, they hold their data directly. This means if you try to change a value inside the struct you’re also implicitly changing the struct itself, which isn’t possible because it’s constant
 */

Learn SwiftUI (Day 11/100)

BC — Wed, 01 May 2024 22:31:59 +0000

Swift

private / fileprivate / public
static, self and Self

import Cocoa

// ## private

struct BankAccount {
    private var funds = 0
}

/*
 * Use private for “don’t let anything outside the struct use this.”
 * Use private(set) for “let anyone read this property, but only let my methods write it.”
 * Use fileprivate for “don’t let anything outside the current file use this.”
 * Use public for “let anyone, anywhere use this.”
 */

// ## static variable and function

struct School {
    static var studentCount = 0
    static func add(student: String) {
        print("\(student) joined the school.")
        studentCount += 1
    }
}

// ## self and Self
/*
 To access static code from non-static code,
 always use your type’s name such as School.studentCount.
 You can also use Self to refer to the current type.
 */

// ## singleton

struct Employee {
    let username: String
    let password: String

    static let example = Employee(username: "abc", password: "xyz")
}

// ## Check point

/*
 create a struct to store information about a car,
 including its model, number of seats, and current gear,
 then add a method to change gears up or down.
 Have a think about variables and access control:
 what data should be a variable rather than a constant,
 and what data should be exposed publicly?
 Should the gear-changing method validate its input
 */

struct Car {
    let model: String
    let numberOfSeats: Int
    private var currentGear: Int

    init(model: String, numberOfSeats: Int) {
        self.model = model
        self.numberOfSeats = numberOfSeats
        self.currentGear = 0
    }

    mutating func gearUp() -> Bool {
        if self.currentGear == 6 {
            return false
        }
        self.currentGear += 1
        return true
    }

    mutating func gearDown() -> Bool {
        if self.currentGear == 0 {
            return false
        }
        self.currentGear -= 1
        return true
    }
}

Learn SwiftUI (Day 10/10)

BC — Wed, 01 May 2024 21:57:47 +0000

Swift

define struct
computed property
getter and setter
property observer: willSet, didSet
customize init function

import Cocoa

// ## Define struct

struct Employee {
    let name: String
    var vacationRemaining: Int

    mutating func takeVacation(days: Int) {
        if vacationRemaining > days {
            vacationRemaining -= days
            print("I'm going on vacation!")
            print("Days remaining: \(vacationRemaining)")
        } else {
            print("Oops! There aren't enough days remaining.")
        }
    }
}
// ## Computed Properties with getter and setter
struct Employee2 {
    let name: String
    var vacationAllocated = 14
    var vacationTaken = 0

    var vacationRemaining: Int {
        // getter
        get {
            vacationAllocated - vacationTaken
        }
        // setter -> even we have a setter here, no `mutating` needs to be added
        set {
            vacationAllocated = vacationTaken + newValue
        }
    }
}

// ## Property observers
// willSet and didSet
struct App {
    var contacts = [String]() {
        // newValue and oldValue are built-in variable in observers
        willSet {
            print("Current value is: \(contacts)")
            print("New value will be: \(newValue)")
        }

        didSet {
            print("There are now \(contacts.count) contacts.")
            print("Old value was \(oldValue)")
        }
    }
}

// ## custom initializers
// explicitly define `init` function - no `func` needed, and you can use `self.`

struct Player {
    let name: String
    let number: Int

    init(name: String) {
        self.name = name
        number = Int.random(in: 1...99)
    }
}

Learn SwiftUI (Day 9/100)

BC — Wed, 01 May 2024 17:11:38 +0000

Swift

closure
trailing closure
shorthand param

import Cocoa

// ## Function Closure

// The parameters have moved inside the braces, and the in keyword is there to mark the end of the parameter list and the start of the closure’s body itself
// example 1, closure that takes no parameter, return boolean
let demo = { () -> Bool in
    print("Paying an anonymous person…")
    return true
}

// example 2, closure that takes 2 params, return string

let payment = { (user: String, amount: Int) -> String in
    if user == "john" && amount == 10 {
        return "yes"
    }
    return "no"
}
print(payment("john", 8))

// Notice: We don't use parameter names when calling a closure.
// payment(user: "john", amount: 8) --> incorrect

// :warning: Closures cannot use external parameter labels.
/*
 var cutGrass = { (length currentLength: Double) in
    // this is an invalid closure
}
 */

// example 3, pass closure as function type parameter
let team = ["Gloria", "Suzanne", "Piper", "Tiffany", "Tasha"]
let captainFirstTeam = team.sorted(by: { (name1: String, name2: String) -> Bool in
    if name1 == "Suzanne" {
        return true
    } else if name2 == "Suzanne" {
        return false
    }

    return name1 < name2
})
print(captainFirstTeam)

// ## Trailing closure
// 1, swift can infer parameter and return types in closure when pass as func parameter
// 2, remove `(by:`, start the closure directly
let captainFirstTeam2 = team.sorted { name1, name2 in
    if name1 == "Suzanne" {
        return true
    } else if name2 == "Suzanne" {
        return false
    }

    return name1 < name2
}

// ## shorthand syntax with $0, $1, etc.
let captainFirstTeam3 = team.sorted {
    if $0 == "Suzanne" {
        return true
    } else if $1 == "Suzanne" {
        return false
    }
    return $0 < $1
}

// ## Take function as parameter
func makeArray(size: Int, using generator: () -> Int) -> [Int] {
    var numbers = [Int]()
    for _ in 0..<size {
        let newNumber = generator()
        numbers.append(newNumber)
    }
    return numbers
}

// ## Check point

/*
 Your input is this:
 let luckyNumbers = [7, 4, 38, 21, 16, 15, 12, 33, 31, 49]

 Your job is to:
 Filter out any numbers that are even
 Sort the array in ascending order
 Map them to strings in the format “7 is a lucky number”
 Print the resulting array, one item per line
 */

let luckyNumbers = [7, 4, 38, 21, 16, 15, 12, 33, 31, 49]
let result = luckyNumbers.filter({!$0.isMultiple(of: 2)}).sorted() .map({"\($0) is a luck number"})
for ele in result {
    print(ele)
}

Learn SwiftUI (Day 8/100)

BC — Wed, 01 May 2024 14:32:59 +0000

Swift

functions with throw Exceptions

import Cocoa

enum PasswordError: Error, LocalizedError {
    case TooShort
    case Obvious

    var errorDescription: String? {
        switch self {
        case .TooShort:
            return NSLocalizedString("Password is too short", comment: "Too short")
        case .Obvious:
            return NSLocalizedString("Password is too obvious", comment: "Obvious")
        }
    }
}

// although defined with `throws`,
// this function doesn't have to throw an exception
func checkPassword(_ pwd: String) throws -> Bool {
    if pwd.count < 6 {
        throw PasswordError.TooShort
    }
    if pwd == "123456" {
        throw PasswordError.Obvious
    }
    return true
}

do {
    let ok = try checkPassword("hello")
    print(ok)
} catch {
    print("Error happened: \(error.localizedDescription)")
}

// ## Checkpoints

/*
 write a function that accepts an integer from 1 through 10,000, and returns the integer square root of that number. That sounds easy, but there are some catches:

 You can’t use Swift’s built-in sqrt() function or similar – you need to find the square root yourself.
 If the number is less than 1 or greater than 10,000 you should throw an “out of bounds” error.
 You should only consider integer square roots – don’t worry about the square root of 3 being 1.732, for example.
 If you can’t find the square root, throw a “no root” error.
 */

enum RootError: Error, LocalizedError {
    case outOfBounds
    case noRoot

    var errorDescription: String? {
        switch self {
        case .outOfBounds:
            return NSLocalizedString("Out of Bounds", comment: "OOB")
        case .noRoot:
            return NSLocalizedString("No root", comment: "NR")
        }
    }
}

func sqroot(_ num: Int) throws -> Int {
    if num < 1 || num > 10_000 {
        throw RootError.outOfBounds
    }
    for i in 1...100 {
        if i * i == num {
            return i
        }
    }
    throw RootError.noRoot
}

do {
    print(try sqroot(9))
    print(try sqroot(25))
    print(try sqroot(37))
} catch {
    print("error happened: \(error.localizedDescription)")
}