每个 .swift 文件不应该是一个类吗？

Question

我在 ObjC 方面有一些经验，而且我刚刚开始学习 Swift。在 Objc 中，一切都是通过.h 和.m 中的@interface 和@implementation 的类，或者在我见过的其他Swift 类中，一切通常都是某种形式的

class MyCustomClassInhertingfrom: SomeFoundationClass { //methods & properties}

然而在一些名为pancakeHouse.Swift 的类中却没有提到关键字class 为什么？这不是模型类吗？这不会破坏 MVC 设计模式吗？发生这种情况是因为 Swift 中枚举和结构与类的新强大功能吗？_____我显然很困惑！

import UIKit
import CoreLocation

enum PriceGuide : Int {
  case Unknown = 0
  case Low = 1
  case Medium = 2
  case High = 3
}

extension PriceGuide : CustomStringConvertible {
  var description : String {
    switch self {
    case .Unknown:
      return "?"
    case .Low:
      return "$"
    case .Medium:
      return "$$"
    case .High:
      return "$$$"
    }
  }
}

enum PancakeRating {
  case Unknown
  case Rating(Int)
}

extension PancakeRating {
  init?(value: Int) {
    if value > 0 && value <= 5 {
      self = .Rating(value)
    } else {
      self = .Unknown
    }
  }
}

extension PancakeRating {
  var ratingImage : UIImage? {
    guard let baseName = ratingImageName else {
      return nil
    }
    return UIImage(named: baseName)
  }

  var smallRatingImage : UIImage? {
    guard let baseName = ratingImageName else {
      return nil
    }
    return UIImage(named: "\(baseName)_small")
  }

  private var ratingImageName : String? {
    switch self {
    case .Unknown:
      return nil
    case .Rating(let value):
      return "pancake_rate_\(value)"
    }
  }
}



 struct PancakeHouse {
  let name: String
  let photo: UIImage?
  let thumbnail: UIImage?
  let priceGuide: PriceGuide
  let location: CLLocationCoordinate2D?
  let details: String
  let rating: PancakeRating
}

extension PancakeHouse {
   init?(dict: [String : AnyObject]) {
    guard let name = dict["name"] as? String,
      let priceGuideRaw = dict["priceGuide"] as? Int,
      let priceGuide = PriceGuide(rawValue: priceGuideRaw),
      let details = dict["details"] as? String,
      let ratingRaw = dict["rating"] as? Int,
      let rating = PancakeRating(value: ratingRaw) else {
        return nil
    }

    self.name = name
    self.priceGuide = priceGuide
    self.details = details
    self.rating = rating

    if let imageName = dict["imageName"] as? String where !imageName.isEmpty {
      photo = UIImage(named: imageName)
    } else {
      photo = nil
    }

    if let thumbnailName = dict["thumbnailName"] as? String where !thumbnailName.isEmpty {
      thumbnail = UIImage(named: thumbnailName)
    } else {
      thumbnail = nil
    }

    if let latitude = dict["latitude"] as? Double,
      let longitude = dict["longitude"] as? Double {
        location = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
    } else {
      location = nil
    }
  }
}

extension PancakeHouse {
  static func loadDefaultPancakeHouses() -> [PancakeHouse]? {
    return self.loadPancakeHousesFromPlistNamed("pancake_houses")
  } 

  static func loadPancakeHousesFromPlistNamed(plistName: String) -> [PancakeHouse]? {
    guard let path = NSBundle.mainBundle().pathForResource(plistName, ofType: "plist"),
      let array = NSArray(contentsOfFile: path) as? [[String : AnyObject]] else {
        return nil
    }

    return array.map { PancakeHouse(dict: $0) }
                .filter { $0 != nil }
                .map { $0! }
  }
}

extension PancakeHouse : CustomStringConvertible {
  var description : String {
    return "\(name) :: \(details)"
  }
}

extension PancakeHouse: Equatable {
}

func ==(lhs: PancakeHouse, rhs: PancakeHouse) -> Bool {
  return lhs.name == rhs.name
}

注意：我希望得到一个答案，其中还包括 .swift 与 .h + .m 的比较，即不要只将其视为特定问题，将其视为一般问题并解释或链接理解此问题所需的先决条件的详细信息）

Answer 1

pancakeHouse.swift 定义了PancakeHouse 以及与之相关的所有各种东西。这是非常好的 Swift 风格。这里没有 class，因为 PancakeHouse 恰好是 struct，这也是非常好的 Swift 风格（并且略微偏爱）。结构很像 Swift 中的类，因为它们可以有数据和方法（和扩展）。

ObjC 不要求每个类都定义在自己的 .h/.m 对中，但这样做是相当典型的 ObjC 风格。也就是说，即使在 ObjC 中也有例外。通常在与基类相同的文件中定义可变子类（NSArray 和NSMutableArray 都在NSArray.h 中定义）。 Swift 风格已经演变为将相关的事物更紧密地集中在一起。如果您知道其名称，则一种样式可以更轻松地找到某些东西。另一个更容易一起找到相关的概念。两者都有自己的优势，一旦人们习惯了一种，他们往往会相信那一种显然是正确的。但它们只是组织方式不同。

请注意，此文件还使用 Swift 扩展来分解相关方法。这也是常见且良好的 Swift。旧的 ObjC 使用类别来做到这一点，但如今以这种方式组织 ObjC 代码的情况要少得多（类别现在用于其他事情）。同样，两者都不是完全正确的。只是样式已经演变。

Answer 2

Swift 文件只需要有效的 swift 代码。就这样。在这种情况下，您的 swift 文件只是定义了两个枚举。一般来说，最好将每个枚举（及其扩展名）放在它自己的 .swift 文件中，但这只是你的个人意见。

A .m 是 .h 接口的实现。 !@#$ 让这两件事始终保持最新是一件很痛苦的事情。 Swift 只需将它们合并到一个事物/文件中，就可以轻松得多，并且您的整个项目会根据您设置的访问权限自动看到它。如果您没有设置任何访问权限，如上面的示例，那么您将拥有“内部”，这意味着整个项目。

Answer 3

编译器作者可以对这个问题采取两种哲学：

• 每个公共类都需要一个具有匹配名称的文件 - 这是 Java 的做法。尽管它的限制很小，但其背后的逻辑是让编译器无需查看所有文件即可找到类引用。它还可以帮助程序员组织他们的代码。
• 做你自己的方式 - 这是 Swift 和 C、C#、Objective-C 一起走的路。从本质上讲，编译器编写者会告诉您，无论您将类放在哪里，他们的编译器都会找到您的类，让您以一种对您和您的团队来说最直观的方式组织代码。