留言板

  • 💊有任何疑问和建议都可以在这里讨论!
  • ✌️去注册个账号以接收更新通知和评论留言;
  • 😘帮忙宣传哟~~~

 

《留言板》有278个想法

  1. Swift 4 的”协议”中的”类专用的协议”部分已经更新了:

    You can limit protocol adoption to class types (and not structures or enumerations) by adding the AnyObject protocol to a protocol’s inheritance list.

    protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
    // class-only protocol definition goes here
    }

    即类的专用协议需要使用 AnyObject 关键字, 译文中还写的是使用 class 关键字. 示例代码也更新了.

    参考链接:
    https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-ID267

  2. 关于”Argument Labels”和”Parameter Names”的翻译.
    把他们翻译成”实际参数”和”形式参数”好像不太合适吧, 实际参数应该是调用方法时传入的参数.

    我觉得把它们直译成”参数提示标签(或内容提要标签)”和”参数名”更好一些.

    1. 这个是国际公认的软件开发方面的专业名词,我也没办法。argument 就是 实际参数,而 parameter 就是 形式参数,也就是我们常说的实参和形参。在开源版本里以前就是统一翻译为 参数,现在也都改正了。
      我比较讨厌实参和形参的说法,所以我就写全了,叫 实际参数 和 形式参数。

        1. 并不会,如果说简写,那就直接形参实参最好了,但这是一种古老的叫法,会给新手带来不可想象的困惑。至于是标签还是名称,实际上都是参数名,翻译为标签并不合适。
          另外就是技术名词不应该自己创造,也好考虑到后来人和其他技术人员沟通时候的通用性,不应该随意增减创造(实在没标准翻译的也没办法,但这个是公认的哈。

  3. “Swift 指南->初始化”中:
    当满足规则2的一部分时,子类的便捷初始化器可以实现父类指定初始化器。

    原文:
    A subclass can implement a superclass designated initializer as a subclass convenience initializer as part of satisfying rule 2.

    as part of satisfying rule 2 应该翻译为: “作为满足规则二的一种情况”, 而不是”当满足规则2的一部分时”.

    1. 子类能够以便捷初始化器的形式实现父类指定初始化器来作为满足规则2的一部分。

      这个不是满足规则2的一种情况,而就是一部分,实际上我好像也没这么用过,总之,我重新翻译了一下,这下和原文文风一致(绕口+没有标点符号短句),这句应该是我校对时候丢了。另外我还统一了本文中便捷初始化器和便利初始化器的冲突问题。

  4. 我发现 However 基本上都翻译成了 “总之”, 有的地方已经偏离原意很远了, 比如:

    “Swift 指南->可选链” 中:
    john.residence 的值当前包含合法的 Residence 实例。总之, john.residence.address 的值目前为 nil 。

    原文:
    The value of john.residence currently contains a valid Residence instance. However, the value of john.residence.address is currently nil.

    这个地方是一个很明显的转折了, 肯定得翻译成”然而”的.

    1. 要不翻译为更旧的通用翻译「无论如何」怎样?这句里 john.residence.address是空的,原文中并明有解释,因为原因很明显,所以就「总而言之」了一下,我觉得是很合理的。你也可以理解为转折,但我理解的是递进。1、这是合法的;2、这个是空的;3、它是 nil。
      文中重点要描述这个nil,所以说了一个 however,是一个结束论点的句式,不愿在「为什么是空」这个问题上多做纠结。

  5. “Swift 指南->可选链” 中的第一句话:
    可选链是在可能递归为 nil 的可选项中查询和调用属性、方法和下标的过程。

    原文是:
    Optional chaining is a process for querying and calling properties, methods, and subscripts on an optional that might currently be nil.

    是不是把 currently 误翻译成了”递归”?

  6. Swift指南->属性:
    “总之,属性也可以与类型本身相关联” 的原文是 “However, properties can also be associated with the type itself”, 需要把”总之”改为”然而”.

    1. however 也可译做 「总之」。 在上下文中,取「然而」并不符合原文意思,这里并没有转折的意思,我们常说「这个怎么怎么样,然而,它也怎么怎么。」但这里显然是一个进一步的说明「can also」是说「也能」。所以,我认为这里是一个进一步的总结,意思是 「总之,这个属性也可以与类型本身去关联。」是一个补充和说明,并无转折的意思。

      1. Stored and computed properties are usually associated with instances of a particular type. However, properties can also be associated with the type itself.

        翻译一: 存储属性和计算属性通常和特定类型的实例相关联。总之,属性也可以与类型本身相关联。
        翻译二: 存储属性和计算属性通常和特定类型的实例相关联。然而,属性也可以与类型本身相关联。

        我觉得还是翻译二比较符合原意. “总之”是对前面表述的总结, 但这里不是对前面的总结, 而是在阐述另一种情况.

        1. 那理解为进一步说明呢?这里不是转折,我还是不喜欢也不理解这个「然而」的翻译方法,把原文的语气等内容都给抹除了,它的色彩更偏向于略贬义。

          1. “Swift 指南->可选链”中:
            你可以通过连接多个可选链来在模型中深入访问属性、方法以及下标。总之,多层可选链不会给返回的值添加多层的可选性。

            原文:
            You can link together multiple levels of optional chaining to drill down to properties, methods, and subscripts deeper within a model. However, multiple levels of optional chaining do not add more levels of optionality to the returned value.

            这个地方的 However 翻译成 “总之” 好像意思就不太符合原意了. However 后面有较明显的转折的意思.

          2. 总之,是总而言之,但如果是总结,我们尝试一下「你可以通过连接多个可选链来在模型中深入访问属性、方法以及下标。但是,多层可选链不会给返回的值添加多层的可选性。」这是严重的转折语气,但前后似乎并没有这么严重的转折,「你可以通过连接多个可选链来在模型中深入访问属性、方法以及下标。另外,多层可选链不会给返回的值添加多层的可选性。」这是严重的递进语气,这两个其实都不是很合适。这句上下文本身就没有一个很明确的关系,并不是上文有「会」,下文出现「不会」就一定是转折,这里是一个进一步的说明。是说你可以链接多层……,可返回的不是多层。这里如果用但是,语句上更通顺,但是,这样就不是中文的用法,我认为用「总之」,比一个烂大街的「然而」要好很多。用「然而」取前肯定后否定的意思,是可以的。我用「总之」则是说后边的内容是前边内容的一个递进。——合并来讲,可以说是「无论你链接多少层可选,返回的总是一个」这样的意思,而不是「你可以链接很多层但是返回的只有一个」。意思是一样的,但描述的方式是不一样的。所以我觉得这里这个连接,用什么都可以,去掉也行,为了保持文风,我才留下的。我始终觉得从小学就教的把 however 翻译为「然而」是一个很�的选项。

  7. 类型转换
    case let stringConverter as String -> String:
    print(stringConverter(“Michael”))
    中的第一个String应该加上()变为
    case let stringConverter as (String) -> String:
    print(stringConverter(“Michael”))

  8. /”使用断言和先决条件不能代替你代码中小概率非法情况的处理设计。总之,使用他们来强制数据和状态正确会让你的 app 在有非法状态时终止的更可预料,并帮助你更好的 debug。在检测到异常状态时尽可能快地停止执行同样能够泥减小由于异常状态造成的损失。/”

    最后一句话,同样能够泥减小?

  9. 控制流:
    与 C 不同,Swift 允许多个 switch 情况来判断相同的这。事实上,坐标 (0,0) 可能匹配这个栗子中所有四个情况,第一个匹配到的情况会被使用。坐标 (0,0) 将会最先匹配 case(0,0) ,所以接下来的所有再匹配到的情况讲被忽略。

    第一句和最后一句有误,烦请修正,谢谢!

  10. 大大们,“ Swift 同样也为三个主要的集合类型提供了更牛逼的版本, Array” 一个严谨的翻译,不应该出现“更牛逼”这样的俗语吧~~~

  11. 楼主你好,在学习 Swift 4 的时候搜到了你的网站,之前看到过 SwfitGG 也做过翻译的工作,不过就像你说的,你这里是第一时间紧跟官方的预览文档,所以也让我有了第一时间学习到中文版新知识的机会,英文文档我也能看,只不过我看起来太慢了,所以感觉还是看母语的文档能快速学习。另外看到这里的中文版有一些小伙伴参与了翻译,所以我也想参与进来,不知道楼主对参与翻译有哪些要求,如果能满足这些具体要求,我也很愿意参与进来。

  12. 相反,传给 someFunctionWithNonescapingClosure(_:) 的闭包是非逃逸闭包,也就是说它可以引式地引用 self
    更正:
    相反,传给 someFunctionWithNonescapingClosure(_:) 的闭包是非逃逸闭包,也就是说它可以隐式地引用 self

  13. 书写错误
    位置:方法-在实例方法中修改值类型
    错误:mutating func moveByX(deltaX: Double, y deltaY: Double)
    正确:mutating func moveBy(x deltaX: Double, y deltaY: Double)

  14. 闭包那一节:
    “在 Swift 中,一个能够捕获值的闭包最简单的模型是内嵌函数,即被书写在另一个函数的内部。一个内嵌函数能够捕获外部函数的实际参数并且能够捕获任何在外部函数的内部定义了的常理与变量。”
    倒数第四个字是错别字,应该是:“常量与变量”

  15. 建议和疑问:

    为何不用 GitHub 开源,然后用 GitHub Pages 轻松建站?
    这样别人可以很方便地提交PR和issue。
    而且很多程序员都在用GitHub,也便于宣传和搜索到。

    或者,像[The swift programming language 3.0 中文版](https://www.gitbook.com/book/znoodl/swift/details)一样用GitBook。不过,我没发现参与贡献的方法,所以不太推荐。

    1. 因为我不会用那个,当时最熟悉这个,顺手就搭建了,而且是我自己翻译和校对(后来才有朋友参与进来),所以并不想那样做。现在我维护不过来了,但遗憾的是我没时间把它迁移过去。

      1. 你没有时间,就只能等你有时间了。这没啥好说的……
        不过,github早晚要学的吧……
        你可以慢慢来。先在github上发点别的简单东西试水。

      1. 我能理解你的意思。
        但我认为这里原文并不是强调“把代码转换成自然语言来阅读”。
        这两行代码是高度符号化的(只有两个关键词”let”和“var”,且“let”跟常量字面上完全不沾边,只是出于别的考虑才选择了它吧),“转换成自然语言”是非常牵强的。
        而且,一般程序员阅读代码也不应该转换成自然语言,这不是好习惯,不应提倡或暗示新手。

        阅读由两步组成:第一步是你阅读了代码`let maximumNumberOfLoginAttempts = 10`,识别出里面的结构、词法和值;而第二步是理解其含义和效果。
        在英文里,一个”read”兼顾了两者。而”read as”更侧重后者,而且往往是需要深入思考或体会的。
        我给的链接(有道词典)的例子(比如”All western films can be read as a series of codes and the variations on those codes.”)无疑也都是侧重后者。
        中文的“读作”则更侧重表面(发音和简单的词语变换),而并不太侧重理解。
        当“读作”和“理解为”两个翻译候选都不足以覆盖原文”read as”的内涵的情况下,我认为还是选择后者,相对更好一些。

        1. read as 可以被翻译为“读作”“理解为”“看作”“解读”等等,在数学上,课本中经常会有某些定义公式,说xxxx(某公式),可以被读作xxxx(中文的解释),而不是“理解为xxxx(中文的解释)”。
          比如这一段:

          蕴涵词”→”也是个二元命题联结词。将两个命题P、Q联结起来, 构成一个新的命题P→Q, 读作如果P则Q, 或读作P蕴涵Q, 如果P那么Q, 其中P称前件(前项、条件), Q称后件(后项、结论)。

          这里只是解释了字面的意思,并不带有主观上要求读者把它理解为什么。“新的命题P→Q, 读作如果P则Q”而不是“新的命题P→Q, 可以理解为如果P则Q”,本章或者本翻译中大量类似的内容,也应该是具体代码的人类语言中立解释,应该是“读作”,而不是很主观的“可以被理解为”,每个人的理解都是不同的,而读作,是必须的、固定的、官方的。

          参考链接:
          http://202.197.191.206:8080/29/text/chapter01/section2/part5/r1.htm
          http://blog.wenxuecity.com/blog/frontend.php?act=articlePrint&blogId=15490&date=200702&postId=21673
          http://cn.linguee.com/中文-英语/search?source=auto&query=read+as

  16. 错误处理的指定清理操作的第2句,

    “这个语句允许你做任何无论执行如何离开当前代码块都必须要做的清理工作——无论是因为抛出了错误还是因为 return或者 break这样的语句。”

    “任何无论执行如何离开当前代码块” -》“如何离开当前代码块”更通俗易懂

  17. 函数 — 多形式参数的函数 — 报错
    func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
    return greetAgain(person: person)
    } else {
    return greet(person: person) //此处会报错,提示少了 alreadyGreeted: Bool 这个参数
    }
    }
    print(greet(person: “Tim”, alreadyGreeted: true))
    // Prints “Hello again, Tim!”

    1. return greet(person: person) 这里的 greet(person:)是上文中的一个函数,本例中声明的函数类型是greet(person:alreadyGreeted:)

      正如下文所述:“注意这个函数与之前展示的函数 greet(person:) 是明显不同的。尽管两个函数都叫做 greet , greet(person:alreadyGreeted:) 接收两个实际参数但 greet(person:) 函数只接收一个。”

  18. 自动引用计数-闭包的循环强引用,第6行代码,lazy var asHTML: Void -> String = {,官网已更新为:lazy var asHTML: () -> String = {

  19. 你好,枚举的隐式指定的原始值这节中,
    let earthsOrder = Planet.Earth.rawValue
    // earthsOrder is 3

    let sunsetDirection = CompassPoint.west.rawValue
    // sunsetDirection is “west”

    rowValue不支持这种用法了?
    xcode8 求帮助,谢谢

  20. 刚开始学习。
    在https://www.cnswift.org/a-swift-tour 这页上面的函数和闭包这一章:

    ……使用 _ 来避免使用实际参数标签。
    func greet(_ person: String, on day: String) -> String {
    ……
    greet(“John”, on: “Wednesday”)
    ……

    on day: String =>这个是我漏掉了什么吗?
    因为按这节上面那个例子,看起来应该是on : String,
    或者 两行一起改为day : String呢?
    func greet(_ person: String, day : String) -> String {
    ……
    greet(“John”, day: “Wednesday”)
    ……

  21. func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
    if condition(item) {
    return true
    }
    }
    return false
    }
    func lessThanTen(number: Int) -> Bool {
    return number 10 后仍旧显示true,想请教一下这是什么原因,未入门的新手求指导,非常感谢。

  22. 延迟存储属性那一节最后部分“只有在 importer 属性第一次被访问时才会创建DataManager实例”有误,应当是创建DataImporter实例才对吧。

      1. 在 Swift 指南 – 基础内容 里面。这样的坏链好像不止一个,你可以打开源文件搜搜你的博客网址。

          1. 在 Swift 指南 – 字符串和字符 里面:
            ” Swift 的 String类型桥接到了基础库中的 NSString类。如同 AnyObject(此处应有链接)中描述的那样 ”
            链接不可点.

  23. 能否共享一份英文原版的下载链接?

    自定义运算符这一章节应该还没有更新到最新版本吧。

    我来跟进翻译一下?

  24. 最近学swift,主要看官方的文档,用这里的中文版做辅助。发现有些章节还没有翻译,正好最近有时间,想帮忙做些事情。

  25. 概览-错误处理 中译文第一句话有误:
    译文:
    你可以用任何遵循 ErrorType 协议的类型来表示错误。
    原文:
    You represent errors using any type that adopts the Error protocol.

  26. 概览-枚举和结构体漏掉了一段内容:

    If an enumeration has raw values, those values are determined as part of the declaration, which means every instance of a particular enumeration case always has the same raw value. Another choice for enumeration cases is to have values associated with the case—these values are determined when you make the instance, and they can be different for each instance of an enumeration case. You can think of the associated values as behaving like stored properties of the enumeration case instance. For example, consider the case of requesting the sunrise and sunset times from a server. The server either responds with the requested information, or it responds with a description of what went wrong.

    enum ServerResponse {
    case result(String, String)
    case failure(String)
    }

    let success = ServerResponse.result(“6:00 am”, “8:09 pm”)
    let failure = ServerResponse.failure(“Out of cheese.”)

    switch success {
    case let .result(sunrise, sunset):
    print(“Sunrise is at \(sunrise) and sunset is at \(sunset).”)
    case let .failure(message):
    print(“Failure… \(message)”)
    }

    Add a third case to ServerResponse and to the switch.

    Notice how the sunrise and sunset times are extracted from the ServerResponse value as part of matching the value against the switch cases.

    1. 补充:
      我在译文中找到了这段内容,看起来只是译文的顺序有点问题,上面指出的那段内容应该放在“枚举”之后,“结构体”之前。

  27. 在 概览-枚举与结构体 里面,有翻译漏掉了部分信息:
    译文:
    添加一个 color()方法到 Suit,方法返回“black”
    原文是:
    Add a color() method to Suit that returns “black” for spades and clubs, and returns “red” for hearts and diamonds.

  28. 函数和闭包勘误:
    错误:
    func makeIncrementer() -> (Int -> Int)
    应更正为:
    func makeIncrementer() -> ((Int) -> Int)

  29. 在类和结构体这一章中的类是引用类型中举的例子中:使用let 创建某个常量,后来又给此常量修改值,是不是错误了,应该声明为var变量

      1. 引用类型的值对其修改其实改的是其内容而不是引用本身,这里我们说的“引用”其实就是这个对象的指针啦。
        结构体啊数组啊这些不能改,是因为它们是值拷贝类型,他们的内容就是他们的值。

  30. 控制流中while square < finalSquare {
    // roll the dice
    if ++diceRoll == 7 { diceRoll = 1 }
    // move by the rolled amount
    square += diceRoll
    if square < board.count {
    // if we're still on the board, move up or down for a snake or a ladder
    square += board[square]
    }

    官方文档为:
    while square < finalSquare {
    // roll the dice
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    // move by the rolled amount
    square += diceRoll
    if square < board.count {
    // if we're still on the board, move up or down for a snake or a ladder
    square += board[square]
    }

  31. 控制流中 游戏棋盘用 Int 值的数组来表现。它的大小基于一个叫做 finalSquare 的常量,它被用来初始化数组同样用来检测稍后的胜利条件。棋盘使用 26 个零 Int 值初始化,而不是 25 个(从 0 到 25 ):

    let finalSquare = 25
    var board = [Int](count: finalSquare + 1, repeatedValue: 0)

    变量board错了,官网上是var board = [Int](repeating: 0, count: finalSquare + 1)

  32. 在 控制流 -> fallthrough 中, 『fallthrough 关键字不会为switch情况检查贯穿入情况的条件。』 -> 『fallthrough 关键字不会检查它下一个将要落入的 case 中的匹配条件』??

  33. 在 控制流 -> fallthrough 中,『并且因此它们避免了意外执行多个 switch 情况』。 『switch』 -> 『case』??

  34. 在 集合类型 -> 访问和修改数组 中,『除非当 count为 (就是说数组为空),否则最大的合法索引永远都是 count – 1,因为数组的索引从零开始』,应该为 『count 为 0』。

  35. 在 集合类型 -> 中,『下边的离子创建了一个叫做 shoppingList的数组来储存 String值』, 『离子』 -> 『例子』?

  36. 在 集合类型 -> 数据类型缩写语法 中,『尽管两种格式功能上相同,我们更推荐缩写并且全书涉及到数组类型的时候都会使用简写』 中 『简写』是不是应该为 『缩写』?

  37. 在 字符串和字符 -> UTF-8 表示法 中,『 print(“\(codeUnit) “, appendNewline: false) 』应该为 『print(“\(codeUnit) “, terminator: “”)』。

  38. 在 字符串和字符 -> 前缀和后缀相等性 中,『如同字符串和字符相等性一节所描述的那样, hasPrefix(_:)和 hasSuffix(_:)方法执对字符串当中的每一个扩展字形集群之间进行了一个逐字符的规范化相等比较』 中 『执对字符串』是不是应该为『执行对字符串』?

  39. 在 字符串和字符 -> 前缀和后缀相等性 中,『要检查一个字符串是否拥有特定的自出福安前缀或者后缀』,是不是多了 『自出福安』?

  40. 在 基本运算符->混合逻辑运算 中,『如果我们输入了正确的密码并通过了视网膜扫描,或者如果我们有合法的钥匙或者我们知道紧急超驰密码,就允许进入』中,『紧急超驰密码』应该改为『紧急强制密码』。

  41. 在 基本运算符->逻辑非运算符 中,『在这个栗子当中,要注意布尔量的的常量和变量名能够帮助你保持代码的可读和简洁』,应该将『布尔量的的常量』改为『布尔量的常量』

  42. 在 基本运算符->合并空置运算符 中,『下边的栗子使用了合并空值运算符来在默认颜色名和可选的用户定义颜色明之间做选择』,这句话中『用户定义颜色明』应该改为『用户定义颜色名』。

  43. 在 基础内容 -> 类型别名 章节中,『在这个栗子中, AudioSample 就是 UInt 的别名』,应该为将 UInt 改为 UInt16。

  44. 有个地方看了原文文档,感觉有点不太对劲,大神们仔细看一看吧
    初始化部分最后那个棋盘的地方,那个程序是不是有点不对劲,我把实例最后的一个row和coumn写成7和7,返回出来的是true。
    我的想法是,两个for循环做的一个事情是将8×8的棋盘拉成了一条64个格子的首位相连的长条然后依次赋予false和true,但是实际的棋盘的情况则是,(7,0)和(0,1)两个格子是一样的,但是在64个格子的长条中则是相反的。
    不知道我表达清楚没有。。。。
    望大神给回复

        1. 嗯我查看了官方文档,确实是一致的,这个没有办法了。我们翻译的目标是与官方完全一致,至于好不好理解这个……原则上不能随意更改,不然就不叫翻译啦!

          我想,既然你已经能够对它有自己的看法,那这一章你一定已经掌握的很好了:)继续你的旅程吧~

  45. hello,版主
    我是一个3年移动开发经验的开发者,最近赋闲,想要为Swift的翻译做出一份贡献。
    我的邮箱是k9629@qq.com。
    希望可以获得这次机会。

  46. 大神们幸苦了
    方法里面,枚举的self属性的TriStateSwitch例子中,next方法中,对三个case的应用都少打了一个引用的点

  47. 可选项绑定中你可以在同一个 if 语句中包含多可选项绑定,使用 where 分句来检查布尔量条件:
    if let firstNumber = Int(“4”), secondNumber = Int(“42”) where firstNumber < secondNumber {
    print("\(firstNumber) < \(secondNumber)")
    }
    // prints "4 < 42"

    这个是错误的吧? 官方文档上是
    if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
    print("\(firstNumber) < \(secondNumber) < 100")
    }
    这样的

  48. 控制流章节中3.3,3.4应该归在3.2下面。官网网页版中,3.2的Switch是18磅字体,“Where“”Compound Cases“是16磅字体

  49. 能不能在更新文档时,把从1.0到2.0到3.0-xxx的更新之处写出来,这样后人在看文档时能知道之前是怎么写的,在后面开发中更好的适配。

  50. 1. 概览里面的《泛型》好像还没更新到swift3.0吧?
    译文:
    func anyCommonElements (lhs: T, _ rhs: U) -> Bool

    swift3.0:
    func anyCommonElements(_ lhs: T, _ rhs: U) -> Bool
    where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element

    2. 泛型下面的 EXPERIMENT 的翻译也有点不妥
    译文:
    修改 anyCommonElements(_:_:)函数来让一个返回任何有两个相同顺序元素的数组。

    原文:
    Modify the anyCommonElements(_:_:) function to make a function that returns an array of the elements that any two sequences have in common.

    个人建议:
    修改 anyCommonElements(_:_:)函数,使之返回任意两个Sequence的公共元素组成的数组。

    1. 确实,这里当时更新的时候好像有点问题,已经更正了。最后一句话也更新了——不知道什么时候悄悄改的。 那个实验的内容确实有点奇怪,已经改正为“两个数组中共有元素”。
      感谢反馈!

  51. 有错字,反初始化那一节的‘deinit{}’代码后面一段话写的‘…你不能自行调用反初始化器。父类的反初始化器可以被自雷继承’

  52. 「Swift 概览」的「函数和闭包」中,「在闭包中使用 in来分隔参数和返回类型。」的翻译不正确。原文是「Use in to separate the arguments and return type from the body.」,应该翻译为「在闭包中使用 in来把参数以及返回类型和函数体分隔开。」

    1. separate from 这是一个词组,用来说明是“分开、区别”的意思,这里是 separate from body,这里body显然指代的是闭包函数体,翻译为中文则是 闭包(函数体),这里闭包即指代闭包函数体本身。

      关于 arguments ,这里是旧翻译,应该翻译为 实际参数 ,那么比较本地化的翻译就是 “在闭包中使用 in 来分隔实际参数和返回类型。” 如果非要说严肃一点,那就是“在闭包(函数体)中使用 in 来分隔实际参数和返回类型。”

      已更正。

  53. 枚举那一节的代码 func evaluate(expression: ArithmeticExpression) -> Int { 有问题
    应该是 func evaluate(_ expression: ArithmeticExpression) -> Int {

  54. 现在xcode8和swift已经正式推出了,咱们这里的译文什么时候推出epub版本呢?这样方便做笔记和勾画知识点

  55. 在“属性”-“全局变量和局部变量”一节,第一段的第二句翻译为:
    全局变量是定义在任何函数、方法、闭包或者类型环境当中的变量。局部变量是定义在函数、方法或者闭包环境中的变量。
    原文:
    Global variables are variables that are defined outside of any function, method, closure, or type context. Local variables are variables that are defined within a function, method, or closure context.
    个人建议这里翻译为:
    全局变量是定义在任何函数、方法、闭包或者类型之外的变量。局部变量是定义在函数、方法或者闭包内部的变量。
    因为有个outside和within,都译成“环境中”,阅读起来有一定的理解难度。

  56. 函数那个位置:
    ————————————————————————
    func greet(person: String, day: String) -> String {
    return “Hello \(person), today is \(day).”
    }
    greet(person: “Bob”, day: “Tuesday”)
    ————————————————————————
    调用函数的时候有 person: 么?
    Xcode报错

  57. 在“集合类型”–> “数组”–>“使用默认值创建数组”中,方法不对,在 Swift3.0中已经更改为:public func repeatElement(_ element: T, count n: Int) -> Repeated;所以对于示例应该改为:var threeDoubles = Array(repeatElement(0.0, count: 3));同时显示的结果为[0, 0, 0]

      1. 但是这个方法在 Xcode8 beta 版本确实是无法找到的,不知道为什么?能调到的方法var threeDoubles = Array(repeatElement(0.0, count: 3));只有这个,而且实现的效果是一样的!

  58. 闭包“简写的实际参数名”中。这里s1和s2并不占内存,所以省略的应该是“形式参数”而不是“实际参数”。但是看了一下原文,原文用的是argument,搜索了一下,形参是parameter,实参是argument。大概是原文本身就自相矛盾吧?

    1. 这里确实用哪个都行,对外是形式参数,但对内这个确实是实际参数的名字……这么说的话其实也算对。如果都说成参数就没有歧义了。——不我过还是遵照原文的意思,把两个参数区分了哈。

  59. 请问一下,在基本运算符一章的浮点数取余计算里,我用 Swift3.0也就是 Xcode8的版本去写,发现不能直接那样写会报错的!报错信息:% is unavailable:Use truncatingRemainder instead。
    所以想问一下是什么情况?

  60. 闭包一章,非逃逸闭包,
    func someFunctionWithNonescapingClosure(closure: @noescape () -> Void) {
    closure()
    } 目前这样书写报错,正确写法:
    func someFunctionWithNonescapingClosure(@noescape closure: () -> Void) {
    closure()
    }

  61. let bicycle = Bicycle()
    print(“Bicycle: (bicycle.description)”)
    // Bicycle: 2 wheel(s)

    少了\

    print(“Bicycle: \(bicycle.description)”)

  62. 在这个栗子中,初始化过程从一个子类的便捷初始化器开始。这个便利初始化器还不能修改任何属性。它委托给了同一类里的指定初始化器。

    栗子。。。

    1. 例子就是上文的插图,初始化过程从子类的便捷初始化开始,然后它调用了自己的指定初始化器,指定初始化器又调用了父类的指定初始化器~这个示例不是代码哈,原文也是这么写的,我也觉得改成“图示”之类的会好些。

  63. 所有类的存储属性——包括从它的父类继承的任何属性——必须在初始化期间分配一个初始值。
    这句话应该写清楚,初始值包含可选值?

    1. 要求赋值,如果你规定这个属性为可选类型,那它就会在没有赋值的情况下自动赋值为nil,这和初始化需要赋值没有任何冲突——所有的属性在初始化的时候都必须赋值。

  64. 概览/错误处理中 let printerResponse = try sendToPrinter(“Bi Sheng”) 应改为 let printerResponse = try send(job: 1040, toPrinter: “Bi Sheng”)

  65. 你好,非常感谢你们翻译的这么及时。想问下,有PDF版可以下载吗,因为边看边做笔记有助于记忆。看网页我有时候找不到阅读过的印象。非常感谢。

    1. 很遗憾,如你所见——现在 Swift 编程语言 还没有全部翻译完成,PDF等格式电子书一定会有——只不过会在全部翻译完成之后才会提供,至少在基础部分翻译完成之后吧:)
      所以还要稍微等一等咯~

  66. “在用浮点数初始化一个新的整数类型的时候,数值会被删减。也就是说 4.75 会变成 4 , -3.9 会变为 -3 。” 这里“删减”用截断可能会更合适。

  67. 你可以从函数和方法同事还有类,枚举以及结构体创建泛型。 这里的“同事”应该是错别字。

  68.   “Swift 语言中逻辑运算符 && 和 || 是左相关的,这意味着多个逻辑运算符组合的表达式会首先计算最左边的子表达式。”
      这句话有点歧义,会误以为 && 和 || 具有相同的优先级。最好改为:
      “……这意味着多个 ‘相同的’ 逻辑运算符组合的表达式会首先计算最左边的子表达式。”

    1. :) 感谢你的建议,苹果官方 Swift 3 原文就是这样的呢……另外,在 Swift 中,它们同优先级的,确实是“多个逻辑运算符组合的表达式会首先计算最左边的子表达式”,它的意义就是“多个相同或者不同的逻辑运算符”,这一点可能是和其他语言不同的地方。另外据我经验,手册全文应该也没有提到逻辑运算符的优先级问题,如果有,欢迎你再来斧正。

      1. if true || false && false
        {
        print(“&& 具有比 || 更高的优先级,因此右边的逻辑运算符首先计算。”)
        }
        else
        {
        print(“|| 和 && 具有相同优先级,因此按从左到右的顺序计算。”)
        }

        结果是 true。
        实际计算过程是 true || (false && false)。原文有误。另外,辛苦了。

    1. 嗯,这是一个比较尴尬的问题……简单来讲就是PDF等格式的电子书会比较晚才能出来,因为:一、要等整个文档全部翻译完成;二、全部翻译结束之后,还要进行一遍精翻来处理那些比较生硬的段落。在这之后,才会进行处理生成好看方便的PDF、epub、mobi等格式电子书:)

  69. 前几天打开时,无法连接服务器,以为你们不做了……

    原来在更新3.0,非常真诚的感谢你们,你们做的有意义的事情,也将影响/改变我们使用这个语言做有意义的事情!

    再次感谢,并加油,并支持~

    1. 首先感谢你的留言,好感动!
      但我还是要认真地承认错误,前几天网站挂掉的时候其实 3.0 就已经完成了的……只不过后台数据库更新导致不太兼容所以网站都挂了。持续时间大概断断续续 10 个小时之多,我们深感抱歉 XD。不过,现在问题已经解决了,现在网站速度更加迅速:)
      (其实我一度以为是服务器遭到了攻击,还好不是呐)

    1. 很抱歉由于我的疏忽在个别页面的翻译上出现了错误,我把迄今为止所有翻译了的页面都进行了检索,一共找出了接近10处错误,现在应该不会再有“整形”出现了。关于“栗子”的问题我一直坚持这是个风格问题——但实际上可能真的是“栗子”和“例子”交替出现的,暂时我不会去修改因为还没有想好。我想将来翻译完成了如果集结成书,则可能会为了严谨而改为“例子”,不过在此之前,我们还是多举几颗栗子来放松心情吧:)
      Swift 编程语言与其他翻译不同的地方之一就是“快速响应”,总之,感谢你的提醒呢,希望这个网站的内容能在你的学习之路上祝你一臂之力!祝学的开心,读得愉快。
      另:如果有其他问题,还请继续留言哦~
      十奶。

  70. 来自单表达式闭的隐式返回

    单表达式闭包能够通过从它们的声明中删掉 return 关键字来隐式返回它们单个表达式的结果,前面的栗子可以写作:

    reversed = named.sort({s1, s2, in s1 > s2})
    1

    这里, sort(_:) 方法的第二个实际参数的函数类型已经明确必须通过闭包返回一个 Bool 值。因为闭包的结构包涵返回 Bool 值的单一表达式 (s1 > s2),因此没有歧义,并且 return 关键字能够被省略。

    标注:reversed = named.sort({s1, s2, in s1 > s2})多写了个逗号,导致报错,应该是reversed = named.sort({s1, s2 in s1 > s2}) ,希望你们能改掉

发表评论

电子邮件地址不会被公开。 必填项已用*标注

证明你不是机器人 *