The protocol to which all class types implicitly conform.

You can use the AnyClass protocol as the concrete type for an instance of any class. When you do, all known @objc class methods and properties are available as implicitly unwrapped optional methods and properties, respectively. For example:

class IntegerRef {
    @objc class func getDefaultValue() -> Int {
        return 42
    }
}
 
func getDefaultValue(_ c: AnyClass) -> Int? {
    return c.getDefaultValue?()
}

The getDefaultValue(_:) function uses optional chaining to safely call the implicitly unwrapped class method on c. Calling the function with different class types shows how the getDefaultValue() class method is only conditionally available.

print(getDefaultValue(IntegerRef.self))
// Prints "Optional(42)"
 
print(getDefaultValue(NSString.self))
// Prints "nil"

The protocol to which all classes implicitly conform.

You use AnyObject when you need the flexibility of an untyped object or when you use bridged Objective-C methods and properties that return an untyped result. AnyObject can be used as the concrete type for an instance of any class, class type, or class-only protocol. For example:

class FloatRef {
    let value: Float
    init(_ value: Float) {
        self.value = value
    }
}
 
let x = FloatRef(2.3)
let y: AnyObject = x
let z: AnyObject = FloatRef.self

AnyObject can also be used as the concrete type for an instance of a type that bridges to an Objective-C class. Many value types in Swift bridge to Objective-C counterparts, like String and Int.

let s: AnyObject = "This is a bridged string." as NSString
print(s is NSString)
// Prints "true"
 
let v: AnyObject = 100 as NSNumber
print(type(of: v))
// Prints "__NSCFNumber"

The flexible behavior of the AnyObject protocol is similar to Objective-C's id type. For this reason, imported Objective-C types frequently use AnyObject as the type for properties, method parameters, and return values.

Casting AnyObject Instances to a Known Type

Objects with a concrete type of AnyObject maintain a specific dynamic type and can be cast to that type using one of the type-cast operators (as, as?, or as!).

This example uses the conditional downcast operator (as?) to conditionally cast the s constant declared above to an instance of Swift's String type.

if let message = s as? String {
    print("Successful cast to String: \(message)")
}
// Prints "Successful cast to String: This is a bridged string."

If you have prior knowledge that an AnyObject instance has a particular type, you can use the unconditional downcast operator (as!). Performing an invalid cast triggers a runtime error.

let message = s as! String
print("Successful cast to String: \(message)")
// Prints "Successful cast to String: This is a bridged string."
 
let badCase = v as! String
// Runtime error

Casting is always safe in the context of a switch statement.

let mixedArray: [AnyObject] = [s, v]
for object in mixedArray {
    switch object {
    case let x as String:
        print("'\(x)' is a String")
    default:
        print("'\(object)' is not a String")
    }
}
// Prints "'This is a bridged string.' is a String"
// Prints "'100' is not a String"

Accessing Objective-C Methods and Properties

When you use AnyObject as a concrete type, you have at your disposal every @objc method and property---that is, methods and properties imported from Objective-C or marked with the @objc attribute. Because Swift can't guarantee at compile time that these methods and properties are actually available on an AnyObject instance's underlying type, these @objc symbols are available as implicitly unwrapped optional methods and properties, respectively.

This example defines an IntegerRef type with an @objc method named getIntegerValue().

class IntegerRef {
    let value: Int
    init(_ value: Int) {
        self.value = value
    }
 
    @objc func getIntegerValue() -> Int {
        return value
    }
}
 
func getObject() -> AnyObject {
    return IntegerRef(100)
}
 
let obj: AnyObject = getObject()

In the example, obj has a static type of AnyObject and a dynamic type of IntegerRef. You can use optional chaining to call the @objc method getIntegerValue() on obj safely. If you're sure of the dynamic type of obj, you can call getIntegerValue() directly.

let possibleValue = obj.getIntegerValue?()
print(possibleValue)
// Prints "Optional(100)"
 
let certainValue = obj.getIntegerValue()
print(certainValue)
// Prints "100"

If the dynamic type of obj doesn't implement a getIntegerValue() method, the system returns a runtime error when you initialize certainValue.

Alternatively, if you need to test whether obj.getIntegerValue() exists, use optional binding before calling the method.

if let f = obj.getIntegerValue {
    print("The value of 'obj' is \(f())")
} else {
    print("'obj' does not have a 'getIntegerValue()' method")
}
// Prints "The value of 'obj' is 100"

A type that provides subscript access to its elements, with bidirectional index traversal.

In most cases, it's best to ignore this protocol and use the BidirectionalCollection protocol instead, because it has a more complete interface.

Deprecated: it will be removed in Swift 4.0. Please use 'BidirectionalCollection' instead.

The default type for an otherwise-unconstrained Boolean literal.

When you create a constant or variable using one of the Boolean literals true or false, the resulting type is determined by the BooleanLiteralType alias. For example:

let isBool = true
print("isBool is a '\(type(of: isBool))'")
// Prints "isBool is a 'Bool'"

The type aliased by BooleanLiteralType must conform to the ExpressibleByBooleanLiteral protocol.

The C '_Bool' and C++ 'bool' type.

The C 'char' type.

This will be the same as either CSignedChar (in the common case) or CUnsignedChar, depending on the platform.

The C++11 'char16_t' type, which has UTF-16 encoding.

The C++11 'char32_t' type, which has UTF-32 encoding.

The C 'double' type.

The C 'float' type.

The C 'int' type.

The C 'long long' type.

The C 'short' type.

The C 'signed char' type.

The C 'unsigned char' type.

The C 'unsigned int' type.

The C 'unsigned long long' type.

The C 'unsigned short' type.

The C++ 'wchar_t' type.

A type that can convert itself into and out of an external representation.

Codable is a type alias for the Encodable and Decodable protocols. When you use Codable as a type or a generic constraint, it matches any type that conforms to both protocols.

A type that can be initialized by string interpolation with a string literal that includes expressions.

Use string interpolation to include one or more expressions in a string literal, wrapped in a set of parentheses and prefixed by a backslash. For example:

let price = 2
let number = 3
let message = "One cookie: $\(price), \(number) cookies: $\(price * number)."
print(message)
// Prints "One cookie: $2, 3 cookies: $6."

Conforming to the ExpressibleByStringInterpolation Protocol

The ExpressibleByStringInterpolation protocol is deprecated. Do not add new conformances to the protocol.

Deprecated: it will be replaced or redesigned in Swift 4.0. Instead of conforming to 'ExpressibleByStringInterpolation', consider adding an 'init(_:String)'.

The default type for an otherwise-unconstrained Unicode extended grapheme cluster literal.

A 32-bit floating point type.

A 64-bit floating point type.

The default type for an otherwise-unconstrained floating point literal.

A type that provides subscript access to its elements, with forward index traversal.

In most cases, it's best to ignore this protocol and use the Collection protocol instead, because it has a more complete interface.

Deprecated: it will be removed in Swift 4.0. Please use 'Collection' instead.

A type that provides subscript access to its elements, with forward index traversal.

In most cases, it's best to ignore this protocol and use the Collection protocol instead, because it has a more complete interface.

Deprecated: it will be removed in Swift 4.0. Please use 'Collection' instead.

The default type for an otherwise-unconstrained integer literal.

A type that provides subscript access to its elements.

In most cases, it's best to ignore this protocol and use the MutableCollection protocol instead, because it has a more complete interface.

Deprecated: it will be removed in Swift 4.0. Please use 'MutableCollection' instead.

A collection that supports efficient random-access index traversal.

In most cases, it's best to ignore this protocol and use the RandomAccessCollection protocol instead, because it has a more complete interface.

Deprecated: it will be removed in Swift 4.0. Please use 'RandomAccessCollection' instead.

A type that supports replacement of an arbitrary subrange of elements with the elements of another collection.

In most cases, it's best to ignore this protocol and use the RangeReplaceableCollection protocol instead, because it has a more complete interface.

Deprecated: it will be removed in Swift 4.0. Please use 'RandomAccessCollection' instead.

Deprecated: it will be replaced or redesigned in Swift 4.0. Instead of conforming to 'StringInterpolationConvertible', consider adding an 'init(_:String)'.

The default type for an otherwise-unconstrained string literal.

The type of an unbounded range operator.

The return type of sequence(first:next:).

The default type for an otherwise-unconstrained unicode scalar literal.

The return type of functions that don't explicitly specify a return type, that is, an empty tuple ().

When declaring a function or method, you don't need to specify a return type if no value will be returned. However, the type of a function, method, or closure always includes a return type, which is Void if otherwise unspecified.

Use Void or an empty tuple as the return type when declaring a closure, function, or method that doesn't return a value.

// No return type declared:
func logMessage(_ s: String) {
    print("Message: \(s)")
}
 
let logger: (String) -> Void = logMessage
logger("This is a void function")
// Prints "Message: This is a void function"