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
}

Use Set Operations

Set(toBeFiltered).intersection(Set(theFilter))

Read more: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html

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.

With "explicit" return and no $0.

let filtered = array2.filter { aString in
    return !exclude.contains(where: { anExcludedString in
        return aString.range(of: anExcludedString, options: .caseInsensitive) != nil
    })
}

Why var filter = array2.filter({exclude.contains($0)}) didn't work?

• First issue:
  There is no case insensitive check.

• Second issue:
  You are using contains() on a [String], not a String. So it expect full equality between the two strings. So if array2 was ["APP"], it would have worked.

For instance if you had:

let exclude = ["text 1", "text 2", "APP", "John"]
let array2 = ["this is text 1", "This is text 2", "This App is under development", "John is working on this project", "This is great", "This APP is under development"]
let filtered = array2.filter { aString in
    return !exclude.contains(where: { anExcludedString in
        return aString.contains(anExcludedString)
    })
}

Then "This APP is under development" would have been removed.

Now, going back to the initial answer, the way to check case insentive is to use range(of:options:).

Use Set Operations

Set(toBeFiltered).intersection(Set(theFilter))

Read more: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html

Use the filter function

var resultsArray = [String]()

let array1 = ["1","2","2","3","4"]
let array2 = ["1","2","2","3","4","5","6"]

let filteredArray = array2.filter{ !array1.contains($0) }

resultsArray.appendContentsOf(filteredArray)

If the collections contain unique items consider to use Set rather than Array

Update Swift 5.1:

In iOS 13, macOS 10.15 there is a new API in Array

public func difference<C>(from other: C) -> CollectionDifference<Element> where C : BidirectionalCollection, Self.Element == C.Element

var resultsArray = [String]()

let array1 = ["1","2","2","3","4"]
let array2 = ["1","2","2","3","4","5","6"]

let diff = array2.difference(from: array1)
resultsArray.append(contentsOf: array1)
for change in diff {
    switch change {
    case .remove(let offset, _, _): resultsArray.remove(at: offset)
    case .insert(let offset, let element, _): resultsArray.insert(element, at: offset)
    }
}

If you don't mind the O(n^2), then test directly in one step.

let arrayOne = [["keyphraseId":"tcpid1234", "name":"shakti"], ["keyphraseId":"tcpid456", "name":"shakti"], ["keyphraseId":"tcpid897", "name":"srichandan "], ["keyphraseId":"tcpid779", "name":"prakash"]]
let arrayTwo = [["idstring":"tcpid1234", "name":"shakti"],["idstring":"tcpid456", "name":"shakti"]]

arrayOne.filter { one in
    !arrayTwo.contains { two in
        one["keyphraseId"] == two["idstring"]
    }
}

If you want better performance O(n), drop stringids into a set

let arrayOne = [["keyphraseId":"tcpid1234", "name":"shakti"], ["keyphraseId":"tcpid456", "name":"shakti"], ["keyphraseId":"tcpid897", "name":"srichandan "], ["keyphraseId":"tcpid779", "name":"prakash"]]
let arrayTwo  = [["idstring":"tcpid1234", "name":"shakti"],["idstring":"tcpid456", "name":"shakti"]]

let idstrings = Set(arrayTwo.flatMap { $0["idstring"] })

arrayOne.filter {
    guard let keyphraseId = $0["keyphraseId"] else { return false }
    return !idstrings.contains(keyphraseId)
}

You can do it like this:

let roomTypes = [RoomFilter(roomType: "Twin Room"), RoomFilter(roomType: "Single Room")]

let result = hotels.filter { hotel in
    hotel.prices?.contains { price in
        roomTypes.contains { rt in
            rt.roomType == price.roomType
        }
    } ?? false
}