Swap string case - swift

Question

let str = "tHIS is A test"
let swapped_case = "This IS a TEST"

Swift noob here, how to do the second statement programatically?

Answer 1

This function works with all upper/lowercase characters defined in Unicode, even those from "foreign" languages such as Ä or ć:

func swapCases(_ str : String) -> String {
    var result = ""
    for c in str.characters { // Swift 1: for c in str {
        let s = String(c)
        let lo = s.lowercased() //Swift 1 & 2: s.lowercaseString
        let up = s.uppercased() //Swift 1 & 2: s.uppercaseString
        result += (s == lo) ? up : lo
    }
    return result
}

Example:

let str = "tHIS is a test ÄöÜ ĂćŒ Α" // The last character is a capital Greek Alpha
let swapped_case = swapCases(str)
print(swapped_case)
// This IS A TEST äÖü ăĆœ α

Answer 2

Use switch statement in-range checks to determine letter case, and use NSString-bridged methods to convert accordingly.

let str = "tHIS is A test"
let swapped_case = "This IS a TEST"

func swapCase(string: String) -> String {
    var swappedCaseString: String = ""
    for character in string {
        switch character {
        case "a"..."z":
            let uppercaseCharacter = (String(character) as NSString).uppercaseString
            swappedCaseString += uppercaseCharacter
        case "A"..."Z":
            let lowercaseCharacter = (String(character) as NSString).lowercaseString
            swappedCaseString += lowercaseCharacter
        default:
            swappedCaseString += String(character)
        }
    }

    return swappedCaseString
}

swapCase(str)

Answer 3

I'm a bit too late but this works too :-)

let str = "tHIS is A test"
var res = ""
for c in str {
  if contains("ABCDEFGHIJKLMNOPQRSTUVWXYZ", c) {
    res += "\(c)".lowercaseString
  } else {
    res += "\(c)".uppercaseString
  }
}
res

Answer 4

In Swift 5 I achieved it by creating a function which iterates through each character of the string, and using string methods to change each character I appended each character back into a new variable:

func reverseCase(string: String) -> String {
    var newCase = ""
    for char in string {
        if char.isLowercase {
            newCase.append(char.uppercased())
        }
        else if char.isUppercase {
            newCase.append(char.lowercased())
        }
        else {
            newCase.append(char)
        }
    }
    return newCase
}

Then just pass your string through to the function when you call it in a print statement:

print(reverseCase(string: str))

Answer 5

You already have plenty of good succinct answers but here’s an over-elaborate one for fun.

Really this is a job for map – iterate over a collection (in this case String) and do a thing to each element (here, each Character). Except map takes any collection, but only gives you back an array, which you’d have to then turn into a String again.

But here’s a version of map that, given an extensible collection, gives you back that same kind of extensible collection.

(It does have the limitation of needing both collections to contain the same type, but that’s fine for strings. You could make it return a different type, but then you’d have to tell it which type you wanted i.e. map(s, transform) as String which would be annoying)

func map<C: ExtensibleCollectionType>(source: C, transform: (C.Generator.Element) -> C.Generator.Element) -> C {
    var result = C()

    for elem in source {
        result.append(transform(elem))
    }

    return result
}

Then to write the transform function, first here’s an extension to character similar to the other answers. It does seem quite unsatisfying that you have to convert to a string just to uppercase a character, is there really no good (international characterset-friendly) way to do this?

extension Character {
    var uppercaseCharacter: Character {
        let s = String(self).uppercaseString
        return s[s.startIndex]
    }

    var lowercaseCharacter: Character {
        let s = String(self).lowercaseString
        return s[s.startIndex]
    }
}

And the function to flip the case. What I wonder is whether this pattern matching is international-friendly. It seems to be – "A"..."Z" ~= "Ä" returns true.

func flipCase(c: Character) -> Character {
    switch c {
    case "A"..."Z":
        return c.lowercaseCharacter
    case "a"..."z":
        return c.uppercaseCharacter
    default:
        return c
    }
}

Finally:

let s = map("Hello", flipCase)
// s is a String = "hELLO"

Answer 6

I hope this helps. inputString and resultString are the input and output respectively.

let inputString = "Example"

let outputString = inputString.characters.map { (character) -> Character in
    let string = String(character)
    let lower = string.lowercased()
    let upper = string.uppercased()
    return (string == lower) ? Character(upper) : Character(lower)
}

let resultString = String(outputString)