Comparing strings, ignoring case, punctuation, and whitespace

Question

I have built a search function that will compare strings regardless of punctuation and whitespace. It is case insensitive.

Here is my current function:

var itemsToFilter = MPMediaQuery.songs().items!

func searchForItemsWithString(_ searchText: String) {
    if searchText != "" {
            let filteredItems = itemsToFilter.filter { item in
                let filterStr = item.title

                if filterStr == nil {
                    return false
                }

                let punctuation = CharacterSet.punctuationCharacters
                let whitespace = CharacterSet.whitespaces
                let unwanted = punctuation.union(whitespace)
                let filterStringContainsSearchText = filterStr!.components(separatedBy: unwanted).joined(separator: " ")

                return filterStringContainsSearchText.contains(searchText)
            }

    }
}

This works, but it is very slow. How can I optimise it?

What else can I improve?

Answer 1

You might want to create a combined CharacterSet of punctuation and whitespace first and then apply this set using a single operation. This should speed things up. Please have a look at this code snippet:

let punctuation = CharacterSet.punctuationCharacters
let whitespace = CharacterSet.whitespaces
let unwanted = punctuation.union(whitespace)
let components = filterString.components(separatedBy: unwanted).joined(" ")
let filterStringContainsSearchText = components.contains(searchText)

Answer 2

Optimizing your search will require that you don't repeat costly operations on every item if they can be performed once beforehand.

It would also help to avoid the overhead of special character processing if the search text doesn't justify it (e.g if it has no spaces or special characters itself).

Finally, procedural code (for loops) are optimized more efficiently by the compiler than their "functional" equivalent (.filter / .map) so the traversal of songs should be performed in a loop instead of a .filter()

I would suggest extending the MPMediaQuery class to allow it to provide a filtered list of songs in the most optimal way possible. This has some reuse value and will keep your main logic more readable and maintainable.

On the other hand, if the MPMediaQuery goes back to storage every time, it will be more efficient to create a simple function that takes the array of songs as a parameter.

For example:

extension MPMediaQuery
{
   static func songsMatching(_ searchText:String) -> [MPMediaItem]
   {
      // Common function to turn special characters into spaces
      // will have a certain amount of overhead so we will try
      // to avoid using it if possible...
      func normalizedText(_ text:String) -> String
      {
         let chars = text.unicodeScalars.enumerated()
                         .map ({ 
                                   CharacterSet.punctuationCharacters.contains($1)
                                || CharacterSet.whitespaces.contains($1) 
                                   ? " " : Character($1)
                              })
         return String(chars)
      }

      // Search string should only be prepared once
      // This means that the whole filtering operation needs to be
      // included in the optimization.
      let searchString  = searchText.lowercased()      
      let cleanedString = normalizedText(searchString)

      // based on search string content, we can forgo complex comparisons
      // We only need to manage special characters if the search text
      // contains any.
      // If the search text doesn't contain spaces or special characters
      // then removing them from the titles is unnecessary
      let simpleFilter = !cleanedString.contains(" ")

      // The Swift optimizer is much more efficient compiling procedural
      // code (As opposed to the functional style .filter{} and such)
      // This can give a 20x speed boost in some cases.
      var result:[MPMediaItem] = []
      for song in songs().items ?? []
      {
         guard let title = song.title?.lowercased()
         else { continue }

         if simpleFilter
         { 
            if title.contains(searchString)
            { result.append(song) }
         }
         else
         {
            if normalizedText(title).contains(searchString)
            { result.append(song) }
         }
      }

      return result
  }    
}