DEV Community: DanielJang

Closure(Handy methods)

DanielJang — Sun, 17 Oct 2021 14:15:57 +0000

We could see Concept of Closure from Closure (Concept)

Collections have several handy methods by using closure syntax.
Let’s study how Closure can be useful when dealing with collections.

forEach

forEach doesn’t return anything

syntax:

anyArrays.forEach { elementOfArray in
  print(elementOfArray)
}

//Same performance as for ~ in loop
for elementOfArray in anyArrays {
  print(elementOfArray)
}

Example:

var nameArray = ["Daniel", "Billy", "Gon"]
nameArray.forEach { name in
    print(name)
}
//or
nameArray.forEach { print($0) }
/*Result
 Daniel
 Billy
 Gon*/


var integerArray = [1, 2, 3]
integerArray.forEach{ print($0) }
/*Result
 1
 2
 3*/

map

map returns an array

syntax:

let returnedArray = anyArrays.map { elementOfArray in
  statements
}

Example 1 : below example return new string array from string array

var nameArray = ["Daniel", "Billy", "Gon"]
let returnedNameArray = nameArray.map { name in
    name.uppercased()   //TIP: you can remove return keyword when statement is singline in curly brace
}
//or same as below
let returnedNameArray = nameArray.map { $0.uppercased() }

//Result: returnedNameArray = ["DANIEL", "BILLY", "GON"]

Example 2: below example return new string array from integer array (i.e. based on your statement you can convert your original array to other type’s array 🤩

let numbers = [2, 4, 6]
let stringNumbers = numbers.map { number -> String in   
    "count is \(number)"  //TIP: return keyword is removed becuase of statement is singline
}
//or
let stringNumbers = numbers.map { number in   
    "count is \(number)"
}
//or
let stringNumbers = numbers.map {  "count is \($0)"  }

//Reesult: stringNumbers = ["count is 2", "count is 4", "count is 6"]

compactMap

compactMap return array without “nil” value

syntax:

let returnedArray = anyArrays.compactMap { elementOfArray in
  statements
}

Example:

let stringArray = ["3.14", "20.5", "Daniel"]

let integerArray = stringArray.compactMap{ element in
    Double(element)
}

//Result: integerArray = [3.14, 20.5]
// stringArray have 3 element
// first element(3.14) can be converted to Double by Double("3.14")
// second element(20.5) can be converted to Double by Double("20.5")
// BUT third element "Daniel" cannot be converted to Double. Double("Daniel") is nil value

flatMap

return combined single dimension array from multi dimension input array

syntax:

let returnedArray = anyArrays.flatMap { elementOfArray in
  statements
}

Example:

let multiDimensionArray = [ ["Apple", "Tomato", "Banana"], ["100", "200", "300"] ]
let combinedArray = multiDimensionArray.flatMap { $0 }

//Result: combinedArray = ["Apple", "Tomato", "Banana", "100", "200", "300"]

filter

return array with passed elements when condition statement is true in closure

syntax:

let returnedArray = anyArrays.filter { elementOfArray in
  condition statements
}

Example:

let inputScore = [ 34, 14, 68, 70, 23, 90, 95]
let passedScore = inputScore.filter { score in
    score > 50
}

//Result: passedScore = [68, 70, 90, 95]

reduce

return “Result” can be any types
reduce have 2 arguments, first is initial vlaue and sencond is closure with return Result
Closure which is second argument has return data type same as initialValue’s data type
Closure returns Result and closure’s first value get the return value until last element
closure:(Result,Any) -> Result)

syntax:

let returnedValue = anyArrays.reduce(initialValue: Result, closure:(Result,Element) -> Result)

Example:

let inputScore = [ 34, 14, 68, 70, 23, 90, 95]
//first argument(0) is initial valye and second argument is closure
//total is as stored property with 0 initial value
//score is element of inputScore array
let sumScore = inputScore.reduce(0, { total, score in  
    total + score
})

//Let's change format by trailling closure
let sumScore = inputScore.reduce(0) { total, score in  
    total + score
}

//Result: sumScore = 394

reduce(into:)

return “Result” can be any types
reduce have 2 arguments, first is initial vlaue and sencond is closure without return Result(Closure doesn’t return anything)
Closure’s first argument has “inout” label. That means the argument is mutable(we will store value to the first argument “Result”
“initialValue”’s data type and first argument’s data type of “closure” are same.

syntax:

let returnedValue = anyArrays.reduce(initialValue: Result, closure:(inout Result, Element) -> ( ))

Example:

var inputDic = [1: 3.5, 2: 6, 3: 4.4]

// [] is initial array, element is element of inputDic
var outputArray = inputDic.reduce(into: []) { partialResult, element in   
    partialResult.append(Double(element.key) * Double(element.value))
}

//Result: outputArray = [3.5, 12.0, 13.200000000000001]

sort

sorting ascending order
reassign return array to input array itself

syntax:

inputArray.sort()

Example:

var numbers = [3, 5, 1, 4, 6, 2]
numbers.sort()

//Result: numbers = [1, 2, 3, 4, 5, 6]

sort(by:)

sorting by “by” argument(closure)
reassign return array to input array itself

syntax:

inputArray.sort(by: (element, element) throws -> Bool)
//or
inputArray.sort { element, element in
  condition statement
}

Example

var numbers = [3, 5, 1, 4, 6, 2]
numbers.sort { a, b in
    a > b
}
//or
numbers.sort { $0 > $1 }
//or
number.sort(by: >)

//Result: numbers = [6, 5, 4, 3, 2, 1]

sorted

sorting ascending order
assign return array to new array
original input array value is no-change

syntax:

let newArray = inputArray.sorted()

Example:

var numbers = [3, 5, 1, 4, 6, 2]
let newNumbers = numbers.sorted()
//Result
//numbers = [3, 5, 1, 4, 6, 2]
//newNumbers = [1, 2, 3, 4, 5, 6]

sorted(by:)

sorting by “by” argument(closure)
assign return array to new array
original input array value is no-change

syntax:

let newArray = inputArray.sorted(by: (element, element) throws -> Bool)
//or
let newArray = inputArray.sorted{ element, element in
  condition statement
}

Example:

var numbers = [3, 5, 1, 4, 6, 2]

let newNumbers = numbers.sorted { a, b in
    a > b
}
//or
let newNumbers = numbers.sorted { $0 > $1 }
//or
let newNumbers = numbers.sorted(by: >)

//Result
//numbers = [3, 5, 1, 4, 6, 2]
//newNumbers = [6, 5, 4, 3, 2, 1]

Yea~~~~ Done !!!

Closure (Concept)

DanielJang — Sun, 17 Oct 2021 03:51:52 +0000

Closure is very important basic concept in Swift.
And many iOS API are using closure syntax.
Let's see Closure for basic concept.

Definition

Closure is function without name (Anonymous function)
Closure can be passed / used to argument of function

Syntax

{
  (Parameters) -> (ReturnType) in 
    Statements
}

//Example
{
  (a: Int, b: Int) -> (Int) in
    a + b
}

Function vs Closure

Function has “Name” ——— Closure doesn't

func myFunction(parameter1, prameter2) -> (ReturnType) {
  Statements
}

//Step 1. Remove "func" Keyword and "function name"
(parameter1, prameter2) -> (ReturnType) {
  Statements
}

//Step 2. Move all to curly brace with "in" keyword
{ (parameter1, prameter2) -> (ReturnType) in
  Statements
}

Function has “Argument labels” ——— Closure doesn’t (But can have parameter names)

func myFunction(argumentLabel parmeter:) //but Closure cannot use argumentLabel as above

Function has “Default parameter value” ——— Closure doesn’t

//myFunction and default value for parameter2
//but Closure cannot have defualt value for parameters
func myFunction(parmeter1: Int, parmeter2: Int = 0)

But Closure can be used “Inline"

//first parameter addValue is closure format(anonymous function)
func addTwoInteger(addValue: (a: Int, b:Int)->Int, a: Int, b: Int) {  
  print(addValue)
}

//Example
addTwoInteger( 
{ (a: Int, b: Int) -> Int in a + b },     //iniline closure
3, 2 )

Short Syntax - Let’s make Closure more simple !!!

//we declare custom type which is closure
typealias OperateType = (a: Int, b:Int) -> Int

Step1. Basic syntax

let myClosure = { (a: Int, b: Int) -> Int in
  a + b
}

Step2. Declare variable explicitly then compiler could know "a" is Int, "b" is Int and "return type" is Int also. So we can remove data types "Int" from parameters and return type

let myClosure: OperateType = { (a, b) in
  a + b
}

Step3. Also compiler could know "a" and "b" parameter from definition of OperateType too. So remove "(a, b)" and "in" keyword

let myClosure: OperateType = { a + b }

Step4. Based on Swift common syntax, we can use $0 instead first parmeter "a" and $1 instead second parmeter "b"

let myClosure: OperateType = { $0 + $1 }

Call Closure

myClosure(3, 4)

What is trailing Closure ? - When Closure is located as last parameter of function !

// See below function, myClosure is "last parmetter"
func myFunction(a: Int, b: Int, myClosure: (a: Int, b:Int) -> Int){
  print(myClosure)
}

//You can call as below
myFunction(3, 4, { a, b in a + b } )
//or call by simple sytax
myFunction(3, 4, { $0 + $1 } )
//When closure is placed as last parmeter, we can pull out after close parentheses
myFunction(3,4){ $0 + $1 }

Yeah~~~ Done !!!

Understand Protocols

DanielJang — Wed, 06 Oct 2021 06:09:52 +0000

When I studied Swift, It was big challenge to understand about Protocols. So I tried to summery it easily for future Daniel. 🤗

Concept of Protocols

Protocol is set of requirements without detail contents as abstract.
For example,
Here is a high school with many teachers for various class.
A requirements from principle of the school is_“Education”_to teachers with curriculum structure. The structure doesn’t include detail contents.

Each teacher can implement own curriculum based on the structure for students.
Then mathematic teacher implements curriculum for mathematic class.
And chemical teacher implements curriculum for chemical class.
So each teacher can implement the requirement what he/she wants based on the curriculum structure.

Declare of Protocols

Protocol can be defined as below

Protocol keyword
Protocol name
Requirements

For example by concept,

Adopt Protocols

Let’s learn how can adopt protocols to class or structure.
Structures and classes can adopt protocols, you add a set of colon and your add your protocol name after the name of your structure and class.

And the multiple protocols can be adopted with comma to classes and structures.

Confirm Protocols

After adoption of protocols, The requirements of the protocols should be implemented in classes or structures what adopted the protocols. We call it “Confirm the protocols”

Les’s use“Education”example again to learn confirming.

Coding practice

Let’s practice protocols by coding.

Run Xcode to make a project
Choose macOS template
And choose “Command Line Tool”
Put Product Name as “Protocols” and save project

Tips

1) To adopt protocols, always the protocols should be adopted
after super class(or other inherit of class)

2) As you know, Classes has super class and child class for inheriting but Structures doesn’t have super structure and child structure. BUT !!! Protocols can be adopted to classes and structures for both.

Thank you for your reading.
Daniel Jang

How can use UserDefaults to store custom class ?

DanielJang — Mon, 04 Oct 2021 06:50:54 +0000

Last time, we reviewed how could use UserDefault to save user's data with common data types into local device.
Please refer to Local Data Persistence - UserDefaults (Basic)

Typically UserDefault class doesn't support saving user's data with custom class!

But if we convert user's custom class to NSData then UserDefaults class can store the converted user's custom class by NSData to local device.

Lets' coding and test...

1) Declare custom class with "Codable" protocol

We will convert the custom class by using JSONEncoder() and JSONEncoder will return "Data" type which can be stored through UserDefaults. At this time we should declare custom class with "Codable" keyword. "Codable" means that the custom class will be converted by JSONEncoder() for data saving and JSONDecoder() for data loading.

class Product: Codable {
    let name: String
    let modelNum: String

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

2) [Save data to local device] Encoding custom class by JSONEncoder() to convert custom class as "Data" type and the converted "Data" type will be stored into local device through UserDefaults.set(Any?, forKey:) method.

let encoder = JSONEncoder()
let appleWatch = Product(name: "Apple Watch 7", modelNum: "W20215313")
do {
    let encodedData = try encoder.encode(appleWatch)
    defaults.set(encodedData, forKey: "AppleWatch")
}catch{
    print("Error encoding process\(error)")
}

As we could study last article, you could find ".plist" file from your device to see stored data as below image.
Please refer to this link Local Data Persistence - UserDefaults (Basic)

3) [Load data from local device] We load converted custom class as "Data" type what we saved at 2) from local device.

defaults.object(forKey: ) method will grab(return) stored data from local device

The stored(returned) data should be "Data" type because we converted custom class to "Data" type and we stored the "Data" into local device at 2)

Then we should decode returned data from "Data" type to custom class again by using JSONDecoder() to use it in our code as below code.

if let data = defaults.object(forKey: "AppleWatch")as? Data {
    let decoder = JSONDecoder()
    do {
        let decodedData = try decoder.decode(Product.self, from: data)
        print(decodedData.name)
        print(decodedData.modelNum)
    }catch{
        print("Error decoding\(error)")
    }
}

Result:
Apple Watch 7
W20215313

Finally we could see how we store common data type as integer, string, float, array, dictionary and even custom class.

Warning! UserDefaults class is not good solution to save secure data as password or banking account but UserDefault is perfect solution to save small data without secure information as user's setting. 🤗

Thank you for your reading.
Daniel JANG

Local Data Persistence - UserDefaults (Basic)

DanielJang — Mon, 04 Oct 2021 03:19:07 +0000

We need to consider data storing to persist user data in local device when we develop App. There are many solutions but today we are looking most simple solution by using UserDefaults Class.

UserDefaults class is good and easy solution to store small data as user's setting (ex, audio volume setting, on-off of Face ID and so on)

Let's see Apple documentation for definition of UserDefaults first.

An interface to the user’s defaults database, where you store key-value pairs persistently across launches of your app.

And another key sentence of Apple Document what kinds of data type UserDefaults supports.

The UserDefaults class provides convenience methods for accessing common types such as floats, doubles, integers, Boolean values, and URLs. These methods are described in Setting Default Values.

and

A default object must be a property list—that is, an instance of (or for collections, a combination of instances of) NSData, NSString, NSNumber, NSDate, NSArray, or NSDictionary. If you want to store any other type of object, you should typically archive it to create an instance of NSData. (I will review this advanced topic next article)

Usually we are using UserDefaults for small data with common data type as floats, doubles, integers, Boolean values, and URLs.

Let's Coding and Testing by Playground...

import UIKit

let defaults = UserDefaults.standard

let intValue = 10
let strValue = "Daniel Jang"
let arrValue = [1, 2, 3]
let dictValue = ["ZipCode": 98765]

// Save data TO Local device
defaults.set(intValue, forKey: "Volume")
defaults.set(strValue, forKey: "Name")
defaults.set(arrValue, forKey: "numArray")
defaults.set(dictValue, forKey: "Zipcode")

// Load data FROM Local device
let AudioVolume = defaults.integer(forKey: "Volume")
let personName = defaults.string(forKey: "Name")!
let myArray = defaults.array(forKey: "numArray")!
let townZipcode = defaults.dictionary(forKey: "Zipcode")!

print(AudioVolume)
print(personName)
print(myArray)
print(townZipcode)

Result
10
Daniel Jang
[1, 2, 3]
["ZipCode": 98765]

You could see very simple logic to save and load data.

Let's check some key code

1) let defaults = UserDefaults.standard

The UserDefaults class provides a programmatic interface for interacting with the defaults system. The defaults system allows an app to customize its behavior to match a user’s preferences. For example, you can allow users to specify their preferred units of measurement or media playback speed. Apps store these preferences by assigning values to a set of parameters in a user’s defaults database. The parameters are referred to as defaults because they’re commonly used to determine an app’s default state at startup or the way it acts by default

2) defaults.set(value: forKey:)

defaults.set(value: Int, forKey: String)
defaults.set(value: Bool, forKey: String)
defaults.set(value: Double, forKey: String)
defaults.set(value: Any?, forKey: String)
And other common data types

"set(value: forKey)" is a method to save user's data into local device.

"value" parameter should be common data types and

"forKey" parameter should be String as Key Value. Key Value means kinds of name tag. we will use this Key Value when we load user's data from local device.

3) defaults.object(forKey: )

defaults.integer(forKey: )
defaults.bool(forKey: )
defaults.double(forKey: )
defaults.string(forKey: )
And other methods to load common data types

Methods for loading are also simple enough! There are 2 ways to load user's data from local device usually.
First...

We can use "defaults.integer(forKey:)" method to load Integer data or "defaults.string(forKey: )" method to load String data from local device and so on.

"forKey" parameter should be same String value as above "forKey" when you save user's data. (IMPORTANT!!!)

Second...

We can use "defaults.object(forKey:)" method for all stored user's data even Integer, String, Array, Dictionary etc with as typecasting. Then we could change above code for data loading as below. (Sorry please find other article about "as" typecasting. I focus on UserDefault now)

"forKey" parameter is same as first.

let AudioVolume = defaults.object(forKey: "Volume") as! Int
let personName = defaults.object(forKey: "Name") as! String
let myArray = defaults.object(forKey: "numArray") as! [Int]
let townZipcode = defaults.object(forKey: "Zipcode") as! [String: Int]

By the way, where we can see stored user's data?

Please put below code end of your code editor then you will get a location path what your app is running in your device as below image.

print(FileManager.default.urls(for: .documentDirectory, in: .userDomainMask))

After running your playground. I hope you could find ".plist" file then click the ".plist"file then you can see your data is stored as key-value data in ".plist" file as below image.

What happen? if we try to save "custom class" instead common data types as below. You will get error message from Xcode immediately.

let defaults = UserDefaults.standard

class Product {
    let name: String
    let modelNum: String

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

let appleWatch = Product(name: "Apple Watch 7", modelNum: "W214312")
defaults.set(appleWatch, forKey: "Apple")

Then? Cannot use UserDefaults class to store custom class?

Yes we CAN use UserDefaults class to store custom class! Hint is above definition part of Apple Document.(by NSData Codable. We will review it next article)

Thank you for your reading...
Daniel JANG.

Section Insets & Min Spacing of CollectionView

DanielJang — Sat, 02 Oct 2021 12:43:09 +0000

[Simulator]

iPhone 13Pro (Display portrait dimension : 390 x 844 points)

[Basic layout of storyboard]

1. Insert "Collection View Controller" from object library.

2. Change background color and set identifier of Collection View Cell by attribute inspector of storyboard

Background : Tint Color
Identifier : Cell

3. Set collection view by size inspector of storyboard.

Cell Size: Width 100, Height 100
Min Spacing: For Cells 10, For Lines 10
Section Insets: Top 10, Bottom 10, Left 10, Right 10
Estimate Size: None

4. Assign ViewController.swift to Collection View Controller by Identity inspector of storyboard.

Class: ViewController

[Basic coding of ViewController.swift]

import UIKit

class ViewController: UICollectionViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

    }

    override func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return 20
    }

    override func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath)
        return cell
    }
}

After building...

You could see below result.

Let's Test by several setting conditions

1. First please go to storyboard again

Click "Collection View"
Go to Attributes inspector tab
Check Scroll direction as "Vertical"

2. About Min Spacing of "For Cells"

Go to Size inspector tab
Change Min Spacing of "For Cells" from 10 to 150
DO NOT Change Min Spacing of "For Lines"

Build and Check result...

If you change Min Spacing value of "For Cells" under Scroll direction as "Vertical" then distance is changed between each cells horizontally.

3. About Min Spacing of "For Lines"

Go to Size inspector tab
Change Min Spacing of "For Lines" from 10 to 150
DO NOT Change Min Spacing of "For Cells" as 10

Build and Check result...

If you change Min Spacing value of "For Lines" under Scroll direction as "Vertical" then distance is changed between each cells Vertically.

4. About Section Insets

Go to Size inspector tab
Change Section Insets values as below image ##Build and Check result... ###If you change Section Insets then there is no change between each cells's distance. Just changed distance between top, bottom, left and right of safe area of display and collection of cells.

Summery Image

Please test when Scroll direction is "Horizontal". Result will be inverted comparing to "Vertical"