Forget about the filter for a moment. Think how you would check if a car's color is a value in an array.

let colors = [ "Green", "Blue" ]
// or let colors: Set = [ "Green", "Blue" ]
if colors.contains(someCar.color) {
}

Simple enough. Now use that same simple expression in the filter.

let filterdObject = cars.filter { $0.model == currModel || colors.contains($0.color) }

You would have an easier time by simplifying and breaking up your code into smaller pieces. There's no reason why a function to filter an array by some conditions, also has to be responsible for figuring out if an element meets those conditions. You've mentally trapped yourself thinking that the filter predicate has be one one long chain of && conditions in a closure.

struct CarOffer {
    let brand: String
    let price: Int
    let color: String
    let consumption: Int
}

struct CarFilter {
    let brand: String?
    let price: Int?
    let consumption: Int?

    func matches(car: CarOffer) -> Bool {
        if let brand = self.brand, brand != car.brand { return false }
        if let price = self.price, price != car.price { return false }
        if let consumption = self.consumption, consumption != car.consumption { return false }
        return true
    }
}

extension Sequence where Element == CarOffer {
    func filter(carFilter: CarFilter) -> [CarOffer] {
        return self.filter(carFilter.matches)
    }
}

let filter = CarFilter(brand: nil, price: nil, consumption: nil)
let offers: [CarOffer] = [] //...
let filteredOffers = offers.filter(carFilter: filter)

I am having a hard time understanding precisely what you want to achieve in particular. However, here is how the filter function plays out:

Given that users is an array of elements of type:

struct User {
    let age: Int
    let isMale: Bool
    // ...
}

You can filter like so:

filteredUsers = users.filter { user in
     return (user.age <= maxAge && user.age >= minAge) && /* include any other condition you need */ 
}

First of all I made a little bit changes to your model:

struct Student {
    var fName: String?
    var lname: String?
    var `class`: String?
    var pincode: Int?
    var active: Bool
    var location: Address
}
struct Address {
    var street1: String?
    var street2: String?
    var country: String?
}

Building dummy objects:

let address1 = Address(street1: "Kiwi str", street2: nil, country: "US")
let address2 = Address(street1: "Cherry str", street2: nil, country: "GB")
let student1 = Student(fName: "Mark", lname: nil, active: false, location: address1)
let student2 = Student(fName: "Diana", lname: "Luck", active: true, location: address2)
let student3 = Student(fName: "Gaga", lname: "Merry", active: true, location: address2)
let student4 = Student(fName: "Mark", lname: "Luck", active: true, location: address1)

let students = [student1, student2, student3, student4]
 

Filtering extension on Array with students elements:

extension Array where Element == Student {
    func filtered(fName: String? = nil, lName: String? = nil, active: Bool? = nil, street1: String? = nil) -> [Student] {
        students.filter { student in
            var fNameOk = false
            if let fName = fName, student.fName == fName {
                fNameOk = true
            }
            
            var lNameOk = false
            if let lName = lName, student.lname == lName {
                lNameOk = true
            }
            
            var activeOk = false
            if let active = active, student.active == active {
                activeOk = true
            }
            
            var street1Ok = false
            if let street1 = street1, student.location.street1 == street1 {
                street1Ok = true
            }
            return (
                (fName == nil ? true : fNameOk) &&
                (lName == nil ? true : lNameOk) &&
                (active == nil ? true : activeOk) &&
                (street1 == nil ? true : street1Ok)
            )
        }
    }
}

Testing filtering extension:

let r1 = students.filtered(fName: "Diana", lName: "Luck", active: true)
let r2 = students.filtered(fName: "Mark", active: true, street1: "Kiwi str")

Test output:

// r1
{fName "Diana", lname "Luck", nil, nil, active true, {street1 "Cherry str", nil, country "GB"}}
// r2
{fName "Mark", lname "Luck", nil, nil, active true, {street1 "Kiwi str", nil, country "US"}}

let filteredArray = users.filter({ $0.firstName.lowercased().contains("firstName") || $0.lastName.lowercased().contains("lastName") || ... })

One approach is to update your filter to see if any value in pets is in the petArr array:

users = users.filter { $0.pets.contains(where: { petArr.contains($0) }) }

The first $0 is from the filter and it represents each User.

The second $0 is from the first contains and it represents each pet within the pets array of the current User.

Use contains instead:

let arr = ["Hello","Bye","Halo"]
let filtered = arr.filter { $0.contains("lo") }
print(filtered)

Output

["Hello", "Halo"]

Thanks to @user3441734 for pointing out that functionality is of course only available when you import Foundation

struct Address {
    var name: String
    var imageURL: String
    var address: String
}

let VIPArray = [["name": "John B"], ["name": "Sara K"]]

let AddressArray = [Address(name: "John B",  imageURL: "johnb", address: "178 Main St."),
                    Address(name: "Dave H",  imageURL: "daveh", address: "1011 Victoria St.."),
                    Address(name: "Sara K",  imageURL: "sarak", address: "279 Maple Av."),
                    Address(name: "Niles K", imageURL: "nilesk", address: "45 King St."),
                    Address(name: "Ingrid G",  imageURL: "ingridg", address: "33 Union St.")]


var filtered = [Address]()

for element in VIPArray {
    for address in AddressArray {
        if element["name"] == address.name {
            filtered.append(address)
        }
    }
}

for record in filtered {
    print(record)
}

OUTPUT:

Address(name: "John B", imageURL: "johnb", address: "178 Main St.")

Address(name: "Sara K", imageURL: "sarak", address: "279 Maple Av.")

Or:

let filtered: [Address] = AddressArray.filter { (address) -> Bool in
    for vip in VIPArray {
        if vip["name"] == address.name {
            return true
        }
    }
    return false
}

You could do something like:

let monsters: [Monster] = ...

let monsterNames: [String] = ...

let filteredMonsters = monsters.filter { monsterNames.contains($0.name) }

This doesn't perform all that well, since it will go over the names array up to n times for each monster, but if your names arrays is small, this won't be a problem.