Cómo hacer que tu código Swift sea más Swift

Swift tiene muchas construcciones y métodos únicos que otros lenguajes no tienen, por lo que muchos desarrolladores que son nuevos en Swift no lo aprovechan.

1. Bucle for con condición where

Ahora, queremos hacer algunas cosas indescriptibles view.subviewsen el medio , ¿cómo usar el bucle for para atravesarlo?UIButton

Entre los siguientes métodos de escritura, los dos últimos métodos de escritura son los más recomendados:

❌
for subView in view.subviews {
    if let button = subView as? UIButton {
        //不可描述的事情
    }
}

✅
for case let button as UIButton in view.subviews {
    //不可描述的事情
}

✅
for button in view.subviews where button is UIButton {
    //不可描述的事情
}

2. Enumeración enumerada()

Para realizar un bucle for en Swift, para obtener el valor del subíndice, la forma general de escribir es 定义局部变量记录下标值o 遍历 0..<view.subviews.count. De hecho, hay una forma más conveniente de escribir: enumerated(), puede obtener el valor del subíndice y los elementos atravesados al mismo tiempo.

❌ Definitivamente no se recomienda el primer tipo, porque es necesario definir variables locales adicionales, lo cual es propenso a errores, pase
✅ El segundo tipo se puede usar cuando solo necesita usar el valor del subíndice, pero si desea usar el elemento correspondiente al valor del subíndice, debe buscarlo nuevamente, problema, pase
✅ El tercer tipo es más perfecto. Aunque puede obtener el valor del subíndice y el elemento al mismo tiempo , puede usar uno de ellos si no lo necesita _

❌
var index: Int = 0
for subView in view.subviews {
    //不可描述的事情
    index += 1
}

✅
for index in 0..<view.subviews.count {
    let subView = view.subviews[index]
    //不可描述的事情
}

✅
//index 和 subView 在循环体中都能使用到
for (index, subView) in view.subviews.enumerated() {
    //不可描述的事情
}

//只用到 index
for (index, _) in view.subviews.enumerated() {
    //不可描述的事情
}

//只用到 subView
for (_, subView) in view.subviews.enumerated() {
    //不可描述的事情
}

3, primero (donde:)

filter Es una de varias funciones avanzadas en Swift, es muy útil cuando se filtran elementos en una colección, pero en algunos casos, como cuando se obtiene el primer elemento de una colección que cumple la condición, hay una mejor opciónfirst(where: )

let article1 = ArticleModel(title: "11", content: "内容1", articleID: "11111", comments: [])

let article2 = ArticleModel(title: "11", content: "内容2", articleID: "22222", comments: [])

let article3 = ArticleModel(title: "33", content: "内容3", articleID: "3333", comments: [])

let articles = [article1, article2, article3]

❌
if let article = articles.filter({ $0.articleID == "11111" }).first {
    print("\(article.title)-\(article.content)-\(article.articleID)")
}

✅
if let article = articles.first(where: {$0.articleID == "11111"}) {
    print("\(article.title)-\(article.content)-\(article.articleID)")    //11-内容1-11111
}

4, contiene (donde: )

Esto es casi lo mismo que lo anterior first(where: ). Por ejemplo, aquí es para juzgar si la lista de artículos contiene el artículo con ID de artículo 11111:

❌
if !articles.filter({ $0.articleID == "11111" }).isEmpty {
    //不可描述的事情
}

✅
if articles.contains(where: { $0.articleID == "11111"}) {
    //不可描述的事情
}

5, para cada uno

Cuando la lógica en el cuerpo del ciclo es relativamente simple, forEach suele ser más conciso que for...in...:

func removeArticleBy(ID: String) {
    //删库跑路
}

❌
for article in articles {
    removeArticleBy(ID: $0.articleID)
}

✅
articles.forEach { removeArticleBy(ID: $0.articleID) }

6. Propiedades calculadas vs métodos

Sabemos que la propiedad calculada en sí misma no almacena datos, pero devuelve el valor calculado en get y establece el valor de otras propiedades en set, por lo que es similar al método, pero más conciso que el método. Echemos un vistazo al siguiente ejemplo:

❌
class YourManager {
    static func shared() -> YourManager {
        //不可描述的事情
    }
}

let manager = YourManager.shared()

❌
extension Date {
    func formattedString() -> String {
        //不可描述的事情
    }
}

let string = Date().formattedString()


✅
class YourManager {
    static var shared: YourManager {
        //不可描述的事情
    }
}

let manager = YourManager.shared

✅
extension Date {
    var formattedString: String {
        //不可描述的事情
    }
}

let string = Date().formattedString
复制代码

7. Protocolo vs Subclasificación

Intente usar protocolos en lugar de herencia. Los protocolos hacen que su código sea más flexible porque una clase puede ajustarse a más de un protocolo al mismo tiempo.

Además, las estructuras y las enumeraciones no se pueden subclasificar, pero pueden ajustarse a los protocolos, lo que aumenta aún más los beneficios de los protocolos.

8. Mantenga el inicializador predeterminado de Struct

Como todos sabemos, Struct en Swift es un tipo de valor con un inicializador de miembros.

No sé si se ha encontrado con una situación así, necesita personalizar el inicializador de Struct y desea mantener el inicializador predeterminado, pero después de la personalización, el inicializador predeterminado desaparece.

Primero mire el inicializador predeterminado:

Después del inicializador personalizado, el inicializador predeterminado desaparece:

Si desea mantener el personalizado y el predeterminado al mismo tiempo, debe usar el método de extensión:

Estructura vs Clase

Utilice Struct en lugar de Class siempre que sea posible. Struct es más seguro y rápido en un entorno de subprocesos múltiples.

La principal diferencia entre ellos es que Struct es un tipo de valor, mientras que Classe es un tipo de referencia, lo que significa que cada instancia de Struct tiene su propia copia única, mientras que cada instancia de Class tiene una referencia a una sola copia de los datos.

Este enlace es el documento oficial de Apple que explica cómo elegir entre Struct y Class. Elegir entre estructuras y clases | Documentación para desarrolladores de Apple