Swift 与Objective-c语法参照

穆单鹗
2023-12-01

Swift已经推出了一段时间了,今天来总结一下Swift与Objective-c(以下简称OC)的语法有哪些不同。

1.常量与变量:

在Swift中定义常量和变量很简单,常量使用let关键字,变量使用var关键字。

var numberOfRows = 30
let maxNumberOfRows = 100

在OC中我们声明一个变量的时候需要指定数据类型:

const int count = 10;
double price = 23.55;
NSString *myMessage = @"Objective-C is not dead yet!";

但是在Swift中我们不用,虽然Swift是强类型语言,但是它可以根据赋值进行类型推断:

let count = 10
// count会被识别为Int
var price = 23.55
// price会被识别为Double
var myMessage = "Swift is the future!"
// myMessage会被识别为String

当然在Swift中写上变量名也不会有任何问题:

var myMessage : String = "Swift is the future!"

2.Swift中不用再写分号了!

在OC中你需要在每一句的后面写上“;”以表达结束,不然会报错,在Swift中你不需要再写分号了,当然你写上也没有问题。

var myMessage = "No semicolon is needed"

3.String

在Swift中字符串的类型是String,不论你定义的是常量字符串还是变量字符串。

let dontModifyMe = "You cannot modify this string"
var modifyMe = "You can modify this string"

在OC中你需要使用NSString和NSMutableString来区分字符串是否可以被修改。

在Swift中连接两个字符串组成新字符串非常方便,使用“+”:

let firstMessage = "Swift is awesome. "
let secondMessage= "What do you think?"
var message = firstMessage + secondMessage
println(message)

println是Swift中一个全局的打印方法。

在OC中我们使用stringWithFormat方法:

NSString *firstMessage = @"Swift is awesome. ";
NSString *secondMessage = @"What do you think?";
NSString *message = [NSString stringWithFormat:@"%@%@", firstMessage, secondMessage];
NSLog(@"%@", message);

在OC中要判断两个字符串是否相同你不能用“==”,你需要使用方法isEqualToString方法,但是在Swift中你可以使用“==”来判断字符串是否相同。

var string1 = "Hello"
var string2 = "Hello"<pre name="code" class="plain">if string1 == string2 {
    println("Both are the same")
} 

 4.Array数组 

数组的用法Swift和OC差不多,我们来看示例:

在OC中:

NSArray *recipes = @[@"Egg Benedict", @"Mushroom Risotto", @"Full Breakfast", @"Hamburger",
@"Ham and Egg Sandwich"];

在Swift中:

var recipes = ["Egg Benedict", "Mushroom Risotto", "Full Breakfast", "Hamburger", "Ham and Egg
Sandwich"]

在OC中你可以向NSArray和NSMutableArray中插入任意类型的参数,但是在OC中只能插入相同的参数。

和NSArray相似,Swift中的Array也有很多方法,比如count方法返回数组中的元素个数:

var recipes : [String] = ["Egg Benedict", "Mushroom Risotto", "Full Breakfast", "Hamburger",
"Ham and Egg Sandwich"]<pre name="code" class="plain">var numberOfItems = recipes.count
// recipes.count will return 5

 在OC中你使用NSMutableArray中的方法addObject来增加数组中的元素,Swift中的方法更简单,你可以使用“+=”,比如: 

recipes += ["Thai Shrimp Cake"]
不过请注意这个方法是数组间的,如果一个单个元素要加入数组中请在元素外面增加[]。

要取出或者替换数组中的元素,使用索引,这点跟OC中相同:

var recipeItem = recipes[0]
recipes[1] = "Cupcake"

在Swift中可以使用Range来表示范围:比如
recipes[1...3] = ["Cheese Cake", "Greek Salad", "Braised Beef Cheeks"]
这里替换的是recipes中的第二到第四个元素。

5.Dictionary字典

字典是一种集合类型,由键值对组成,这一点和OC中的NSDictionary很类似,请看示例:

OC中:

NSDictionary *companies = @{@"AAPL" : @"Apple Inc", @"GOOG" : @"Google Inc", @"AMZN" :
@"Amazon.com, Inc", @"FB" : @"Facebook Inc"};

Swift中:

var companies = ["AAPL" : "Apple Inc", "GOOG" : "Google Inc", "AMZN" : "Amazon.com, Inc",
"FB" : "Facebook Inc"]
你也可以声明它的字典类型:

var companies: Dictionary<String, String> = ["AAPL" : "Apple Inc", "GOOG" : "Google Inc",
"AMZN" : "Amazon.com, Inc", "FB" : "Facebook Inc"]

要遍历一个字典,需要使用元组来保存每一次循环的字典中的信息:

for (stockCode, name) in companies {
    println("\(stockCode) = \(name)")
}

你也可以单独遍历字典中的键或者值:

for stockCode in companies.keys {
    println("Stock code = \(stockCode)")
}
for name in companies.values {
    println("Company name = \(name)")
}

如果想给字典添加新的键值对,那么使用如下语句:

companies["TWTR"] = "Twitter Inc"

6.Class类

在OC中创建类的话,会得到两个文件,一个接口文件(.h文件)和一个实现文件(.m文件)。

而在Swift中生成类只有一个文件.swift文件。

示例:

class Recipe {
    var name: String = ""
    var duration: Int = 10
    var ingredients: [String] = ["egg"]
}

在上面的示例中我们创建了一个Recipe类,里面有三个属性,并且都声明了类型,做了初始化。在Swift中类在初始化的时候它的属性必须都被初始化。如果你不想设置某个属性的默认值的话,使用?把它加入可选链中:

class Recipe {
    var name: String?
    var duration: Int = 10
    var ingredients: [String]?
}
这样当你创建一个类的实例的时候:

var recipeItem = Recipe()

这些可选链中的属性的初始值是nil。你可以给它们赋值:

recipeItem.name = "Mushroom Risotto"
recipeItem.duration = 30
recipeItem.ingredients = ["1 tbsp dried porcini mushrooms", "2 tbsp olive oil", "1 onion,
chopped", "2 garlic cloves", "350g/12oz arborio rice", "1.2 litres/2 pints hot vegetable
stock", "salt and pepper", "25g/1oz butter"]

类可以继承父类和遵守协议,示例:

OC中:

@interface SimpleTableViewController : UIViewController <UITableViewDelegate,
UITableViewDataSource>

Swift中:

class SimpleTableViewController : UIViewController, UITableViewDelegate, UITableViewDataSource

7.Methods方法

Swift允许你在类、结构体和枚举中创建方法。

下面是一个没有参数和返回值的方法:

class TodoManager {
    func printWelcomeMessage() {
        println("Welcome to My ToDo List")
    }
}

在OC中调用一个方法的格式如下:

todoManager printWelcomeMessage];

在Swift中调用一个方法的格式如下:

todoManager.printWelcomeMessage()

如果要建立一个带参数和返回值的方法,格式如下:

class TodoManager {
    func printWelcomeMessage(name:String) -> Int {
        println("Welcome to \(name)'s ToDo List")
return 10 }
}

"->"用来指示方法的返回值类型。

你可以这样调用上面的方法:

var todoManager = TodoManager()
let numberOfTodoItem = todoManager.printWelcomeMessage("Simon")
println(numberOfTodoItem)


8.Control Flow控制流

Swift中的控制流和循环颇有C语言的风格。

8.1for循环

for循环使用 for - in的结构,并且可以和Range(...或者..<)配合使用:

for i in 0..<5 {
    println("index = \(i)")
}

会在控制台输出:

index = 0

index = 1

index = 2

index = 3

index = 4 



如果我们使用...这是个闭集合,结果会返回:

index = 0

index = 1

index = 2

index = 3

index = 4

index = 5 

如果你想用c中的结构也是可以的:

for var i = 0; i < 5; i++ {
    println("index = \(i)")
}

只不过for后面不用写括号了。


8.2 if-else结构

和OC中很像,只不过Swift中更简单一些,条件语句不需要写在括号中:

var bookPrice = 1000;
if bookPrice >= 999 {
    println("Hey, the book is expensive")
} else {
    println("Okay, I can affort it")
}

8.3 switch结构

Switch中的switch结构拥有非常强大的功能。

示例:

switch recipeName {
    case "Egg Benedict":
        println("Let's cook!")
    case "Mushroom Risotto":
        println("Hmm... let me think about it")
    case "Hamburger":
        println("Love it!")
    default:
}
println("Anything else")

首先Swift中的switch中可以控制字符串,OC中的NSString是不能被switch控制的,在OC中要实现类似功能你只能使用if-else。

另外你可以看到在每个case中我们都没有写break,在OC中你必须在每个case中写break,否则在当前case结束后会进入下一个case,在Swift中当前case被执行后就会自动跳出switch,如果需要进入下一个case,添加fallthrough语句。

最后,switch的case中可以包含Range操作:

var speed = 50
switch speed {
case 0:
    println("stop")
case 0...40:
    println("slow")
case 41...70:
    println("normal")
case 71..<101:
    println("fast")
default:
    println("not classified yet")
}

9.Tuple元组

元组类型在OC中是没有的,它可以包含多种不同的数据类型,你可以把它用作方法的返回值,这样就可以用一个元组来代替返回一个复杂的对象了。例如:

let company = ("AAPL", "Apple Inc", 93.5)

你可以把元组company中的值取出来,用法如下:

let (stockCode, companyName, stockPrice) = company
println("stock code = \(stockCode)")
println("company name = \(companyName)")
println("stock price = \(stockPrice)")

或者company.0、company.1这样的方法也能取到值,更好的做法是在定义元组的时候给每个元素起个名字:

let product = (id: "AP234", name: "iPhone 6", price: 599)
println("id = \(product.id)")
println("name = \(product.name)")
println("price = USD\(product.price)")

下面是一个把元组作为返回类型的例子:

class Store {
    func getProduct(number: Int) -> (id: String, name: String, price: Int) {
        var id = "IP435", name = "iMac", price = 1399
        switch number {
            case 1:
                id = "AP234"
                name = "iPhone 6"
                price = 599
        case 2:
            id = "PE645"
            name = "iPad Air"
            price = 499
default:<span style="font-family: Arial, Helvetica, sans-serif;">break }</span><pre name="code" class="plain">        return (id, name, price)
    }
}

 调用: 

let store = Store()
let product = store.getProduct(2)
println("id = \(product.id)")
println("name = \(product.name)")
println("price = USD\(product.price)")

10.Optional可选型

10.1可选型

可选型通常用在变量之中,可选型的默认值是nil。如果你给一个非可选型的变量赋值nil会报错:

var message: String = "Swift is awesome!" // OK
message = nil // compile-time error

当你的类中的属性没有全部初始化的时候会报错:

class Messenger {
    var message1: String = "Swift is awesome!" // OK
    var message2: String // compile-time error
}

在OC中当你给变量赋值为nil或者没有初始化属性的时候,你是不会收到一个编译时错误的:

NSString *message = @"Objective-C will never die!";
message = nil;
class Messenger {
    NSString *message1 = @"Objective will never die!";
    NSString *message2;<span style="font-family: Arial, Helvetica, sans-serif;">}</span>

但这不代表你不可以在Swift使用没有初始化的属性,我们可以使用?来表示这是一个可选型的变量:

class Messenger {
    var message1: String = "Swift is awesome!" // OK
    var message2: String? // OK
}

10.2那么我们为什么要用可选型呢?

Swift语言设计的时候有很多安全方面的考虑,可选型表示了Swift是一门类型安全的语言,从上面的例子中你可以看到Swift中的可选型会在编译时就去检查某些可能发生在运行时的错误。

考虑下面的OC中的方法:

- (NSString *)findStockCode:(NSString *)company {
    if ([company isEqualToString:@"Apple"]) {
        return @"AAPL";
    } else if ([company isEqualToString:@"Google"]) {
        return @"GOOG";
    }
return nil; }

这个方法用来判断输入的字符串是不是Apple和Google,如果是其他的话返回nil。

假设我们在类中定义这个方法,并且在类中使用它:

NSString *stockCode = [self findStockCode:@"Facebook"]; // nil is returned<pre name="code" class="plain">NSString *text = @"Stock Code - ";
NSString *message = [text stringByAppendingString:stockCode]; // runtime error
NSLog(@"%@", message);

 这段代码是可以通过编译的,但是会在运行时发生错误,原因就是方法中传入FaceBook返回了nil。 

上面OC中的代码我们在Swift中的话是这样写的:

func findStockCode(company: String) -> String? {
   if (company == "Apple") {
      return "AAPL"
   } else if (company == "Google") {
      return "GOOG"
   }
return nil }<pre name="code" class="plain">var stockCode:String? = findStockCode("Facebook")
let text = "Stock Code - "
let message = text + stockCode  // compile-time error
println(message)

 这段代码不能通过编译,可以避免运行时的错误了。显而易见,可选型的应用可以提高代码的质量。 

10.3解包可选型

在上面我们已经看到了可选型的用法,那么我们如何判断一个可选型的变量有值还是为nil呢?

示例:

var stockCode:String? = findStockCode("Facebook")
let text = "Stock Code - "
if stockCode != nil {
    let message = text + stockCode!
    println(message)
}

很像OC中的配对,我们使用if判断语句来做可选型的空值判断。一旦我们知道可选型肯定有值的时候,我们可以使用强制拆封(或者叫解包),也就是在变量名后面加一个感叹号来取得变量的值。

如果我们忘记做空值判断会怎样?你进形了强制拆封所以不会发生编译时错误

var stockCode:String? = findStockCode("Facebook")
let text = "Stock Code - "
let message = text + stockCode!  // runtime error

会发生运行时错误,错误提示:

Can’t unwrap Optional.None 


10.4可选绑定

除了强制拆封,可选绑定是一个更简单更好的做法。你使用if - let结构的可选绑定来判断一个变量是不是空值

示例:

var stockCode:String? = findStockCode("Facebook")
let text = "Stock Code - "
if let tempStockCode = stockCode {
    let message = text + tempStockCode
    println(message)
}

if let的意思是如果stockCode有值,那么解包它,并且把它赋给一个临时变量tempStockCode,并且执行下面大括号中(条件块)的代码,否则跳过大括号中的代码。

因为tempStockCode是一个新的常量,你不必再使用!来获取它的值。

你可以简化这个过程:

let text = "Stock Code - "
if var stockCode = findStockCode("Apple") {
    let message = text + stockCode
    println(message)
}

我们把stockCode的定义放到if中,这里stockCode不是可选型,所以在下面的大括号中也不用再使用!如果它是nil,那么大括号中的代码就不会执行。

10.5可选链

我们有一个类Code,里面有两个属性code和price,它们的类型是可选型。把上面示例中的stockCode方法的返回值由String改为返回一个Code类型。

class Stock {
    var code: String?
    var price: Double?
}
func findStockCode(company: String) -> Stock? {
    if (company == "Apple") {
        let aapl: Stock = Stock()
        aapl.code = "AAPL"
        aapl.price = 90.32
return aapl
    } else if (company == "Google") {
        let goog: Stock = Stock()
        goog.code = "GOOG"
        goog.price = 556.36
return goog }
return nil }

现在我们计算买了100个苹果需要多少钱:

if let stock = findStockCode("Apple") {
    if let sharePrice = stock.price {
        let totalCost = sharePrice * 100
        println(totalCost)
    }
}

因为findStockCode的返回值是可选值,我们使用可选绑定来判断,但是Stock的price属性也是可选的,所以我们又用了一个可选绑定来判断空值。

上面的代码运行没有问题,不用if let我们有更简单的办法,你可以把上面的代码改成可选链的操作,这个特性允许我们把多个可选类型用?连接,做法如下:

if let sharePrice = findStockCode("Apple")?.price {
    let totalCost = sharePrice * 100
    println(totalCost)
}





 类似资料: