Check if string contains special characters in Swift

Question

I have to detect whether a string contains any special characters. How can I check it? Does Swift support regular expressions?

var characterSet:NSCharacterSet         


        

Answer 1

With Swift 5 you can just do

if let hasSpecialCharacters =  "your string".range(of: ".*[^A-Za-z0-9].*", options: .regularExpression) != nil {}

Answer 2

Two Solutions:

1)

extension String {
    var stripped: String {
        let okayChars = Set("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        return self.filter {okayChars.contains($0) }
    }
}

2)

class TrimDictionary {

    static func trimmedWord(wordString: String) -> String {
        var selectedString = wordString
    
        let strFirst = selectedString.first
        let strLast = selectedString.last
    
        let characterset = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
        if strFirst?.description.rangeOfCharacter(from: characterset.inverted) != nil {
            selectedString = String(selectedString.dropFirst())
        }
        if strLast?.description.rangeOfCharacter(from: characterset.inverted) != nil {
            selectedString = String(selectedString.dropLast())
        }
        return selectedString
    }
}

Answer 3

Password validation With following:- (Password at least eight characters long, one special character, one uppercase, one lower case letter and one digit)

var isValidateSecialPassword : Bool {

        if(self.count>=8 && self.count<=20){
        }else{
            return false
        }
        let nonUpperCase = CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZ").inverted
        let letters = self.components(separatedBy: nonUpperCase)
        let strUpper: String = letters.joined()

        let smallLetterRegEx  = ".*[a-z]+.*"
        let samlltest = NSPredicate(format:"SELF MATCHES %@", smallLetterRegEx)
        let smallresult = samlltest.evaluate(with: self)

        let numberRegEx  = ".*[0-9]+.*"
        let numbertest = NSPredicate(format:"SELF MATCHES %@", numberRegEx)
        let numberresult = numbertest.evaluate(with: self)

        let regex = try! NSRegularExpression(pattern: ".*[^A-Za-z0-9].*", options: NSRegularExpression.Options())
        var isSpecial :Bool = false
        if regex.firstMatch(in: self, options: NSRegularExpression.MatchingOptions(), range:NSMakeRange(0, self.count)) != nil {
            print("could not handle special characters")
            isSpecial = true
        }else{
            isSpecial = false
        }
        return (strUpper.count >= 1) && smallresult && numberresult && isSpecial
    }

Answer 4

For the purpose of filename sanitization, I prefer to detect the invalid characters, rather than provide an allowed character set. After all, many non-English speaking users need accented characters. The following function is inspired by this gist:

func checkForIllegalCharacters(string: String) -> Bool {
    let invalidCharacters = CharacterSet(charactersIn: "\\/:*?\"<>|")
    .union(.newlines)
    .union(.illegalCharacters)
    .union(.controlCharacters)

    if string.rangeOfCharacter(from: invalidCharacters) != nil {
        print ("Illegal characters detected in file name")
        // Raise an alert here
        return true
    } else {
    return false
}

Answer 5

This answer may help the people who are using Swift 4.1

func hasSpecialCharacters() -> Bool {

    do {
        let regex = try NSRegularExpression(pattern: ".*[^A-Za-z0-9].*", options: .caseInsensitive)
        if let _ = regex.firstMatch(in: self, options: NSRegularExpression.MatchingOptions.reportCompletion, range: NSMakeRange(0, self.count)) {
            return true
        }

    } catch {
        debugPrint(error.localizedDescription)
        return false
    }

    return false
}

Taken reference from @Martin R's answer.

Answer 6

Mahendra's answer can be stripped down a bit by using an inversion(^) within the regex clause. Additionally, you don't need A-Z and a-z when using the caseInsensitive option, as Swift covers that eventuality for you:

extension String {

  func containsSpecialCharacters(string: String) -> Bool {
        
        do {
            let regex = try NSRegularExpression(pattern: "[^a-z0-9 ]", options: .caseInsensitive)
            if let _ = regex.firstMatch(in: string, options: [], range: NSMakeRange(0, string.count)) {
                return true
            } else {
                return false
            }
        } catch {
            debugPrint(error.localizedDescription)
            return true
        }
    }