Objective-C to Swift conversion cheat sheet

NSInteger score = 556;

NSString *name = @"Taylor";

BOOL loggedIn = NO;

var score = 556

var name = "Taylor"

var loggedIn = false

const NSInteger score = 556;

NSString * const name = @"Taylor";

const BOOL firstRun = YES;

Constants are used infrequently in Objective-C.

let score = 556

let name = "Taylor"

let firstRun = true

Constants are extremely common in Swift.

NSMutableArray *items = [NSMutableArray new];

NSMutableArray<NSString *> *results = [NSMutableArray new];

Generics in Objective-C are a contentious issue; you will see both styles.

var items = [String]()

var results = Array<String>()

The first style is strongly preferred.

NSArray *grades = @[@90, @85, @97];

NSArray *names = @[@"Taylor", @"Adele", @"Justin"];

let grades = [90, 85, 97]

let names = ["Taylor", "Adele", "Justin"]

NSMutableArray *array = [NSMutableArray new];
[array addObject:[NSValue valueWithRect:CGRectMake(0, 0, 32, 64)]];

Value types must be wrapped in a reference type before being added to a collection.

var array = [CGRect]()
array.append(CGRect(x: 0, y: 0, width: 32, height: 64))

NSDictionary *houseNumbers = @{ @"Paul": @7, @"Jess": @56, @"Peter": @332 };

let houseNumbers = ["Paul": 7, "Jess": 56, "Peter": 332]

typedef NS_ENUM(NSInteger, ShapeType) {
    kCircle,
    kRectangle,
    kHexagon
};

enum ShapeType: Int {
    case circle
    case rectangle
    case hexagon
}

NSString *first = @"Hello, ";
NSString *second = [first stringByAppendingString:@" world!"];

let first = "Hello, "
let second = first + "world!"

NSInteger rating = 4;
rating++;
rating += 3;

var rating = 4
rating += 1
rating += 3

NSString *account = @"twostraws";
NSString *str = [NSString stringWithFormat:@"Follow me on Twitter: %@", account];

let account = "twostraws"
let str = "Follow me on Twitter: \(account)"

NSString *username = @"twostraws";
NSLog(@"Username is %@", username);

let username = "twostraws"
print("Username is \(username)")

NSInteger result = 86;

if (result >= 85) {
    NSLog(@"You passed the test!");
} else {
    NSLog(@"Please try again.");
}

let result = 86

if result >= 85 {
    print("You passed the test!")
} else {
    print("Please try again.")
}

for (NSInteger i = 0; i < 100; ++i) {
    NSLog(@"This will be printed 100 times.");
}

for _ in 0 ..< 100 {
    print("This will be printed 100 times.")
}

NSArray *companies = @[@"Apple", @"Facebook", @"Twitter"];

for (NSString *name in companies) {
    NSLog(@"%@ is a well-known tech company.", name);
}

let companies = ["Apple", "Facebook", "Twitter"]

for name in companies {
    print("\(name) is a well-known tech company.")
}

NSInteger rating = 8;

switch (rating) {
    case 0 ... 3:
        NSLog(@"Awful");
        break;
    case 4 ... 7:
        NSLog(@"OK");
        break;
    case 8 ... 10:
        NSLog(@"Good");
        break;
    default:
        NSLog(@"Invalid rating.");
}

Many people are unaware that Objective-C has range support, so you might see alternative syntax.

let rating = 8

switch rating {
case 0...3:
    print("Awful")
case 4...7:
    print("OK")
case 8...10:
    print("Good")
default:
    print("Invalid rating.")
}

Swift will not fall through cases unless you use the fallthrough keyword.

- (void)printGreeting {
    NSLog(@"Hello!");
}

[self printGreeting];

func printGreeting() {
    print("Hello!")
}

printGreeting()

- (NSString*)printGreeting {
    return @"Hello!";
}

NSString *result = [self printGreeting];

func printGreeting() -> String {
    return "Hello!"
}

let result = printGreeting()

- (NSString*)printGreetingFor:(NSString*)user {
    return [NSString stringWithFormat:@"Hello, %@!", user];
}

NSString *result = [self printGreetingFor:@"Paul"];

The name for the first parameter should be part of the method name itself.

func printGreeting(for user: String) -> String {
    return "Hello, \(user)!"
}

let result = printGreeting(for: "Paul")

- (NSString*)printGreetingFor:(NSString*)user withAge:(NSInteger)age {
    if (age >= 18) {
        return [NSString stringWithFormat:@"Hello, %@! You're an adult.", user];
    } else {
        return [NSString stringWithFormat:@"Hello, %@! You're a child.", user];
    }
}

NSString *result = [self printGreetingFor:@"Paul" withAge:38];

func printGreeting(for user: String, age: Int) -> String {
    if age >= 18 {
        return "Hello, \(user) You're an adult."
    } else {
        return "Hello, \(user)! You're a child."
    }
}

let result = printGreeting(for: "Paul", age: 38)

- (NSDictionary<NSString*, NSString*>*)loadAddress {
    return @{
        @"house": @"65, Park Street",
        @"city": @"Bristol",
        @"country": @"UK"
    };
}

NSDictionary<NSString*, NSString*> *address = [self loadAddress];
NSString *house = address[@"house"];
NSString *city = address[@"city"];
NSString *country = address[@"country"];

Objective-C does not support tuples, so dictionaries or arrays are used instead.

func loadAddress() -> (house: String, city: String, country: String) {
    return ("65, Park Street", "Bristol", "UK")
}

let (city, street, country) = loadAddress()

void (^printUniversalGreeting)(void) = ^{
    NSLog(@"Bah-weep-graaaaagnah wheep nini bong");
};

printUniversalGreeting();

let universalGreeting = {
    print("Bah-weep-graaaaagnah wheep nini bong")
}

universalGreeting()

NSString* (^getUniversalGreeting)(void) = ^{
    return @"Bah-weep-graaaaagnah wheep nini bong";
};

NSString *greeting = getUniversalGreeting();
NSLog(@"%@", greeting);

let getUniversalGreeting = {
    return "Bah-weep-graaaaagnah wheep nini bong"
}

let greeting = getUniversalGreeting()
print(greeting)

NSString* (^getGreeting)(NSString *) = ^(NSString *name) {
    return [NSString stringWithFormat:@"Live long and prosper, %@.", name];
};

NSString *greeting = getGreeting(@"Paul");
NSLog(@"%@", greeting);

let getGreeting = { (name: String) in
    return "Live long and prosper, \(name)."
}

let greeting = getGreeting("Paul")
print(greeting)

@interface MyClass : NSObject
@end

@implementation MyClass
@end

class MyClass: NSObject {
}

It's preferable to use structs rather than classes. You may not need to inherit from NSObject.

@interface User : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSInteger age;
@end

@implementation User

@end

class User {
    var name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

Swift requires you to create an initializer to give these properties default values.

// in the header file
@interface User : NSObject
@property (nonatomic, copy) NSString *name;
@end

// in the implementation file
@interface User()
@property (nonatomic, assign) NSInteger age;
@end

@implementation User

@end

Objective-C doesn't really support private properties, so this workaround is common.

class User {
    var name: String
    private var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

@interface Civilization : NSObject
- (NSInteger)getMeaningOfLife;
@end

@implementation Civilization
- (NSInteger)getMeaningOfLife {
    return 42;
}
@end

class Civilization {
    func getMeaningOfLife() -> Int {
        return 42
    }
}

@interface Civilization : NSObject
+ (NSInteger)getMeaningOfLife;
@end

@implementation Civilization
+ (NSInteger)getMeaningOfLife {
    return 42;
}
@end

The difference is small: + is used rather than -.

class Civilization {
    class func getMeaningOfLife() -> Int {
        return 42
    }
}

Swift also supports static methods – methods that may not be overridden in a subclass.

@interface NSString (Trimming)
- (NSString*)trimmed;
@end

@implementation NSString (Trimming)

- (NSString*)trimmed {
    return [self stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
}

@end

extension String {
    func trimmed() -> String {
        return trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

if ([object isKindOfClass:[YourClass class]]) {
    NSLog(@"This is a YourClass.");
}

if object is YourClass {
    print("This is a YourClass.")
}

Dog *poodle = (Dog*)animalObject;

let poodle = animalObject as? Dog

let poodle = animalObject as! Dog

The former will set poodle to nil if it is not a dog; the latter will crash your program if it is not a dog.

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"Running in the background...");
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"Running back on the main thread");
    });
});

DispatchQueue.global().async {
    print("Running in the background...")
    
    DispatchQueue.main.async {
        print("Running on the main thread")
    }
}