Swift: Convert enum value to String?

The idiomatic interface for 'getting a String' is to use the CustomStringConvertible interface and access the description getter. You could specify the 'raw type' as String but the use of description hides the 'raw type' implementation; avoids string comparisons in switch/case and allows for internationalization, if you so desire. Define your enum as:

enum Foo : CustomStringConvertible {
  case Bing
  case Bang
  case Boom
  
  var description : String { 
    switch self {
    // Use Internationalization, as appropriate.
    case .Bing: return "Bing"
    case .Bang: return "Bang"
    case .Boom: return "Boom"
    }
  }
}

In action:

 > let foo = Foo.Bing
foo: Foo = Bing
 > println ("String for 'foo' is \(foo)"
String for 'foo' is Bing

Updated: For Swift >= 2.0, replaced Printable with CustomStringConvertible

Note: Using CustomStringConvertible allows Foo to adopt a different raw type. For example enum Foo : Int, CustomStringConvertible { ... } is possible. This freedom can be useful.

In swift 3, you can use this

var enumValue = Customer.Physics
var str = String(describing: enumValue)

from Swift how to use enum to get string value

For now, I'll redefine the enum as:

enum Audience: String {
    case Public = "Public"
    case Friends = "Friends"
    case Private = "Private"
}

so that I can do:

audience.toRaw() // "Public"

But, isn't this new enum definition redundant? Can I keep the initial enum definition and do something like:

audience.toString() // "Public"

I like to use Printable with Raw Values.

enum Audience: String, Printable {
    case Public = "Public"
    case Friends = "Friends"
    case Private = "Private"

    var description: String {
        return self.rawValue
    }
}

Then we can do:

let audience = Audience.Public.description // audience = "Public"

or

println("The value of Public is \(Audience.Public)") 
// Prints "The value of Public is Public"

A swift 3 and above example if using Ints in Enum

public enum ECategory : Int{
        case Attraction=0, FP, Food, Restroom, Popcorn, Shop, Service, None;
        var description: String {
            return String(describing: self)
        }
    }

let category = ECategory.Attraction
let categoryName = category.description //string Attraction

Updated for the release of Xcode 7 GM. It works as one would hope now--thanks Apple!

enum Rank:Int {
    case Ace = 1, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King
}

let r = Rank.Ace

print(r)               // prints "Ace"
print("Rank: \(r)!")   // prints "Rank: Ace!"

It couldn't get simpler than this in Swift 2 and the latest Xcode 7 (no need to specify enum type, or .rawValue, descriptors etc...)

Updated for Swift 3 and Xcode 8:

    enum Audience {
        case Public
        case Friends
        case Private
    }

    let audience: Audience = .Public  // or, let audience = Audience.Public
    print(audience) // "Public"

You can also use "\(enumVal)" Here is an example :

enum WeekDays{ case Sat, Sun, Mon, Tue, Wed, The, Fri } 

let dayOfWeek: String = "\(WeekDays.Mon)"

Tried and tested in Swift 5

After try few different ways, i found that if you don't want to use:

let audience = Audience.Public.toRaw()

You can still archive it using a struct

struct Audience {
   static let Public  = "Public"
   static let Friends = "Friends"
   static let Private = "Private"
}

then your code:

let audience = Audience.Public

will work as expected. It isn't pretty and there are some downsides because you not using a "enum", you can't use the shortcut only adding .Private neither will work with switch cases.

For anyone reading the example in "A Swift Tour" chapter of "The Swift Programming Language" and looking for a way to simplify the simpleDescription() method, converting the enum itself to String by doing String(self) will do it:

enum Rank: Int
{
    case Ace = 1 //required otherwise Ace will be 0
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
            case .Ace, .Jack, .Queen, .King:
                return String(self).lowercaseString
            default:
                return String(self.rawValue)
        }
     }
 }

Starting from Swift 3.0 you can

var str = String(describing: Audience.friends)

Use Ruby way

var public: String = "\(Audience.Public)"

There are multiple ways to do this. Either you could define a function in the enum which returns the string based on the value of enum type:

enum Audience{
    ...
func toString()->String{
  var a:String

  switch self{
   case .Public:
    a="Public"
   case .Friends:
    a="Friends"
   ...
 }
 return a
}

Or you could can try this:

enum Audience:String{
   case Public="Public"
   case Friends="Friends"
   case Private="Private"
}

And to use it:

var a:Audience=Audience.Public
println(a.toRaw())

Friendly by guides if you need to use static strings as enum values:

class EncyclopediaOfCats {
    struct Constants {
        static var playHideAndSeek: String { "Play hide-and-seek" }
        static var eat: String { "Eats" }
        static var sleep: String { "Sleep" }
        static var beCute: String { "Be cute" }
    }
}

enum CatLife {
    case playHideAndSeek
    case eat
    case sleep
    case beCute

    typealias RawValue = String
    
    var rawValue: String {
        switch self {
        case .playHideAndSeek:
            return EncyclopediaOfCats.Constants.playHideAndSeek
        case .eat:
            return EncyclopediaOfCats.Constants.eat
        case .sleep:
            return EncyclopediaOfCats.Constants.sleep
        case .beCute:
            return EncyclopediaOfCats.Constants.beCute
        }
    }
    
    init?(rawValue: CatLife.RawValue) {
        switch rawValue {
        case EncyclopediaOfCats.Constants.playHideAndSeek:
            self = .playHideAndSeek
        case EncyclopediaOfCats.Constants.eat:
            self = .eat
        case EncyclopediaOfCats.Constants.sleep:
            self = .sleep
        case EncyclopediaOfCats.Constants.beCute:
            self = .beCute
        default:
            self = .playHideAndSeek
        }
    }
}

XCode 14.0.1/Swift 5.7:

This is something that should be simple to achieve, but that is quite confusing, with some pitfalls!

Most answers here explain how to associate strings to each enum values, or to create enums of explicit Strings, but is only possible when you are creating your own enums.

In case of enums already existing, like numerous enums in Apple's APIs, one could really want to convert enums values to String.

To take a concrete example, if one wants to display NWConnection.States values in a SwiftUI Text view.

According to some answers, and assuming that we have something like:

Class tcpClient() {
    var connection: NWConnection
    (...)

then

Text("Current state: \(tcpClient.connection.state)")

should work. But you get a "No exact matches in call to instance method 'appendInterpolation'" error.

A reason to explain this behaviour is because despite being described as enum in Apple's documentation, some enumerations are in fact not Swift enumerations, but C-Style enumerations. And according to Apple, Swift can't print the text version, because all it has at runtime is enum's number value. This could be the case for quite some APIs. See: https://stackoverflow.com/a/70910402/5965609

Other solution proposed here is:

Text(String(describing: tcpClient.connection.state))

Seems to work, but @Eric Aya comment here says : String(describing:) should never be used to convert anything to String, it's not its purpose and will give unexpected results in many cases. Better use string interpolation or string initializers.

So, in case of C-Style enumarations from APIs or other imported code, the only viable solution seems to have a function with a switch case to associate Strings to each enum's value.

One more way

public enum HTTP{
case get
case put
case delete
case patch
var value: String? {
return String(describing: self)
}

If you want a string representation of an existing enum, you can extend that enum with CustomStringConvertible.

e.g. I wanted to see a string version of UIGestureRecognizer.State

extension UIGestureRecognizer.State: CustomStringConvertible {
    public var description: String {
        switch self {
            case .possible:
                return "possible"
            case .began:
                return "began"
            case .changed:
                return "changed"
            case .ended:
                return "ended"
            case .cancelled:
                return "cancelled"
            case .failed:
                return "failed"
            @unknown default:
                return "default"
        }
    }
}

let state = UIGestureRecognizer.State.began

print("state: \(state)")

prints:

"state: began"

I agree with all the above answers but in your enum private and the public cases can't be defined since those are default keywords. I'm including CaseIterable in my answer, it may help you to get all cases if you required to loop over.

enum Audience: String, CaseIterable {
 case publicAudience
 case friends
 case privateAudience

 var description: String {
    switch self {
    case .publicAudience: return "Public"
    case .friends: return "Friends"
    case .privateAudience: return "Private"
    }
 }

 static var allAudience: [String] {
    return Audience { $0.rawValue }
 }
}