CODEWITHSUNDEEP
iosswift
Riley Osborne
Riley Osborne

Reputation: 35

Swift Turning Long Code Into Short Code

1.)I have these two functions that my team lead wants me to shorten using closures. I'm a new developer and can't figure out the right way to shorten these.

func sortUsers() {
    var sorted = [Member]()
    var sortedObjects = [PFObject]()

    for j in 0...2 {
        if member.count >  0 {
            for i in 0...member.count - 1 {
                if j == 0 {
                    if member[i].role == "OWNER" {
                        sorted.append(member[i])
                        sortedObjects.append(memberObject[i])
                    }
                } else if j == 1 {
                    if member[i].role == "ADMIN" {
                        sorted.append(member[i])
                        sortedObjects.append(memberObject[i])
                    }
                } else {
                    if member[i].role == "USER" {
                        sorted.append(member[i])
                        sortedObjects.append(memberObject[i])
                    }
                }
            }
        }
    }
    member = sorted
    memberObject = sortedObjects

}

Can almost be shortened by using this closure. member.sort {$0.role < $1.role } however it shorts alphabetically and that would be okay, but I need Owner to always be first.

2.)This second function I haven't figured anything out for. It has the way we had been doing it and then a closure in it that I tried replacing the longer method with but it didn't work.

    func filterUsers() {
    sortUsers()
    switch roleSelector.selectedSegmentIndex {
    case 0:
        filtered = member
        filteredObjects = memberObject
        tableView.reloadData()
    case 1:
        filtered = []
        filteredObjects = []
        for i in 0...member.count - 1 {
            if member[i].role == "OWNER" {
                filtered.append(member[i])
                filteredObjects.append(memberObject[i])
            }
        }
        tableView.reloadData()
    case 2:
      member.filter  { $0.role  == "ADMIN" }
       tableView.reloadData()
    case 3:
        filtered = []
        filteredObjects = []
        for i in 0...member.count - 1 {
            if member[i].role == "USER" {
                filtered.append(member[i])
                filteredObjects.append(memberObject[i])
            }
        }
        tableView.reloadData()
    default:
        break
    }
}

I greatly appreciate any help any kind soul may offer me :)

Upvotes: 1

Views: 211

Answers (1)

Sulthan
Sulthan

Reputation: 130102

First of all, create constants for Role, for example, using an enum:

enum Role : String {
    case owner = "OWNER"
    case admin = "ADMIN"
    case user = "USER"
}

Now let's declare ordering for roles:

extension Role : Comparable {
    var order: Int {
        switch self {
        case .owner:
            return 0
        case .admin:
            return 1
        case .user:
            return 2
        }
    }

    static func < (lhs: Role, rhs: Role) -> Bool {
        return lhs.order < rhs.order
    }
}

Let's suppose Member looks like this (note I have used my Role enum instead of your String).

class Member : CustomDebugStringConvertible {
    var role: Role
    var name: String

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

    var debugDescription: String {
        return self.name
    }
}

let members: [Member] = [
    Member(role: .user, name: "user1"),
    Member(role: .owner, name: "owner"),
    Member(role: .user, name: "user2"),
    Member(role: .admin, name: "admin2"),
    Member(role: .admin, name: "admin2"),
]

Now your sorting can be reduced to:

let sortedMembers = members.sorted { $0.role < $1.role }

To sort both arrays together, we can, for example, create pairs member-object and sort those pairs:

let pairs = zip(members, objects)
let sortedPairs = pairs.sorted { $0.0.role < $1.0.role }

let sortedMembers = sortedPairs.map { $0.0 }
let sortedObjects = sortedPairs.map { $0.1 }

To get the filtered objects, let's simplify again using roles:

if roleSelector.selectedSegmentIndex == 0 { // all selected
     filtered = member
     filteredObjects = memberObject
     tableView.reloadData()
     return
}

let roles: [Role] = [.owner, .admin, .user]
let role = roles[roleSelector.selectedSegmentIndex - 1]

filtered = members.filter { $0.role == role }

tableView.reloadData()

Upvotes: 7

Related Questions