¿Por qué las enumeraciones se han calculado las propiedades, pero no se almacena propiedades en Swift?

Soy nuevo en Swift y sólo encontré esto en la documentación:

Calculada propiedades son proporcionados por las clases, estructuras, y
las enumeraciones. Almacena las propiedades son proporcionados únicamente por las clases y
estructuras.

¿Por qué? ¿Asociada a los valores de la enumeración de trabajo como almacenados propiedades? Parece que se había almacenado propiedades inicialmente – Por qué no almacena las propiedades de tipo para las clases de swift?

OriginalEl autor Adit Gupta | 2015-08-28

4 Kommentare

  1. 12

    enumque no se han almacenado tipo propiedades – es decir, static propiedades. Ellos no tienen almacenados instancia propiedades. No sé si hay una razón técnica por la almacena las propiedades de la instancia no están disponibles para enums. Puede que tenga que hacer su pregunta en el dev foro si quieres una respuesta técnica para el «por qué».

    En su pregunta se pregunte si los valores asociados de trabajo como almacenados propiedades. De hecho, lo hacen, y son más flexibles (en algunos aspectos) que almacena las propiedades de structs y classes. Cada case en un enum puede tener su propia especializada conjunto de datos que se asocia con ella. En lugar de tener un conjunto de almacena las propiedades que se aplican a todos los cases, consigue individualizar a los almacena las propiedades de cada case.

    OriginalEl autor Aaron Rasmussen

  2. 13

    Las enumeraciones no permitir que almacena las propiedades de la instancia es una opción de diseño. Tener enum con almacenan las propiedades de la instancia que hace como un struct (con enum superpoderes), pero sólo a partir del tipo de perspectiva ahora las enumeraciones actuará como tipo de multiplicadores. Básicamente considerar

    enum Set1 {
        case a
        case b
        case c
    }
    
    enum Times {
        case x
        case y
    
        var k: Set1
    }

    Lo que esto realmente significa que la enumeración Times nos permite tener cualquier combinación de elementos de Set1 y Set2 resultando en 6 distintos casos, pero espera, sabemos que en realidad este es un propósito de una tupla tipo como (Set1, Set2), donde Times puede ser declarado como

    typealias Times = (Set1, Set2)

    Espero que esto les sirva como una razonable justificación para no permitir que el caso anterior.

    Que se dice, swift enumeraciones nos permiten asociar un arbitrario n-tupla con cada caso, lo que nos permite declarar lo que se conoce como unión discriminada en la programación funcional. Llamar a un almacenan los bienes embargados a caso si te gusta. A partir de los tipos de perspectivas que ahora actúa como el tipo de serpiente.

    enum Add {
        case lhs(Set1)
        case rhs(Set2)
    }

    Ahora tenemos 5 casos diferentes. Si ahora nos almacén de 2-tuplas:

    enum AddTimes {
        case lhs(Set1, Set2)
        case rhs(Set3, Set4)
    }

    que ahora tienen básicamente la suma de la multiplicación (Set1 * Set2 + Set3 * Set4).
    Esta es una herramienta muy poderosa cuando se trata de la coincidencia de patrones.

    Sin EMBARGO, existen algunos casos reales cuando en realidad se quiere emular la forma de bienes almacenados dentro de la enumeración. Considere esto:

    public enum Service {
        case registerNewUser(username: String, password: String, language: String)
        case login(username: String, password: String, deviceTokenº: String?)
        case logout(sessionToken: String)
        case sendForgotPassword(email: String)
    }

    es una forma declarativa para definir RESTO extremos (en el marco como Moya)
    Cuando se desea activar una petición que haría algo como

    MoyaProvider<Service>.request(.sendForgotPassword(email: "[email protected]"))

    Pero ahora imagine que usted quiere diferenciar entre la producción y el servidor de prueba. Si agrega un servidor como otro elemento de la tupla en cada caso:

    case forgotPassword(sessionToken: String, serverBaseURLString: String)

    este será tener un mal semántica, ya que originalmente la intención de cada tupla para almacenar los parámetros de solicitud, pero ahora se almacena en un servidor de base de la dirección.

    Para evitar cosas como esta realidad podemos parametrizar nuestro tipo de la siguiente manera. En lugar de tener el Servidor se define como decir:

    enum Server: String {
        case production = "https://service.info"
        case test = "http://test.service.info"
    }

    podemos definir con distinto tipo para cada caso como:

    public struct ProductionServer: ServerType {
        public static var baseURLString: String { return "https://service.info" }
    }
    public struct TestServer: ServerType {
        public static var baseURLString: String { return  "http://test.service.info" }
    }
    public protocol ServerType {
        static var baseURLString: String { get }
    }

    y finalmente parametrizar nuestro ServiceType como

    public enum Service<T> where T: ServerType {
        case registerNewUser(username: String, password: String, language: String)
        case login(username: String, password: String, deviceTokenº: String?)
        case logout(sessionToken: String)
        case sendForgotPassword(email: String)
    
        var serverURL: URL {
            return T.baseURL
        }
    }
    
    public typealias ProdutionService = Service<ProductionServer>
    public typealias TestService = Service<TestServer>

    OriginalEl autor ambientlight

  3. 4

    Puedo usar un pequeño truco para almacenar las propiedades que no están accesibles en la inicialización.

    En primer lugar, crear una clase Future que almacenará los bienes almacenados en el futuro:

    class Future<T> {
      var value: T?
      init(value: T? = nil) {
          self.value = value
      }
    }

    Entonces puedo crear mi enum:

    enum Sample {
      case Test(future: Future<String>)
    }

    Instanciar:

    let enumTest = Sample.Test(future: Future())

    Más adelante en el código:

    switch enumTest {
      case let .Test(future):
      future.value = "Foo"
    }

    Y más tarde, usted puede acceder al valor:

    switch enumTest {
      case let .Test(future):
      //it will print Optional("Foo")
      print("\(future.value)")
    }

    Esto no es algo que usted debe abusar, pero puede ser útil en algunos casos.

    Espero que ayude.

    ¿Por qué no almacenar la Cadena o lo que sea directamente en la enumeración del valor asociado?

    OriginalEl autor manueGE

  4. 0

    Un enum es considerado como un tipo de datos estructurado que puede ser modificado sin necesidad de cambiar de decir una Cadena o Int varias veces dentro de su código y con un enum podemos nunca tener que preocuparse de cambiar la misma cosa más de una vez. Por ejemplo menú desplegable:

    enum DropDownMenuOptions: String {
      case MenuOptionOne
      case MenuOptionTwo
      case MenuOptionThree
    }

    Con almacenan las propiedades de u puede calcular previamente la información necesaria y reducir el código en su función principal. El mejor ejemplo es el cálculo de tamaño de rect por ejemplo:

    struct Point {
        var x = 0.0, y = 0.0
    }
    struct Size {
        var width = 0.0, height = 0.0
    }
    struct Rect {
        var origin = Point()
        var size = Size()
        var center: Point {
            get {
                let centerX = origin.x + (size.width / 2)
                let centerY = origin.y + (size.height / 2)
                return Point(x: centerX, y: centerY)
            }
            set(newCenter) {
                origin.x = newCenter.x - (size.width / 2)
                origin.y = newCenter.y - (size.height / 2)
            }
        }
    }
    
    var square = Rect(origin: Point(x: 0.0, y: 0.0),
        size: Size(width: 10.0, height: 10.0))
    Pero las Enumeraciones había almacenado propiedades inicialmente – stackoverflow.com/questions/24029581/…
    Bien enum se estructura por defecto, de modo que tal vez u puede extender y hacer algunas de las funciones que puede hacer eso, pero no veo una razón para ello … se utilizan para la estática , se conoce , calcula la estructura y la mejor manera de utilizarlas es como que …

    OriginalEl autor Kristijan Delivuk

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea