ios - ¿Cuándo usar la constante estática y la variable en Swift?

variables static

Question

Hay algunas publicaciones sobre cómo escribir código para static constant static variable y static variable en Swift. Pero no está claro cuándo usar static constant static variable y static variable lugar de constant y variable . ¿Alguien puede explicar?

Answer 1

Cuando define una var / let estática en una clase (o estructura), esa información se compartirá entre todas las instancias (o valores).

Compartiendo información

class Animal {
    static var nums = 0

    init() {
        Animal.nums += 1
    }
}

let dog = Animal()
Animal.nums // 1
let cat = Animal()
Animal.nums // 2

Como puede ver aquí, creé 2 instancias separadas de Animal pero ambas comparten los mismos nums variable estática.

Semifallo

A menudo se usa una constante estática para adoptar el patrón Singleton. En este caso, no queremos asignar más de una instancia de una clase. Para hacerlo, guardamos la referencia a la instancia compartida dentro de una constante y ocultamos el inicializador.

class Singleton {
    static let sharedInstance = Singleton()

    private init() { }

    func doSomething() { }
}

Ahora cuando necesitamos la instancia de Singleton escribimos

Singleton.sharedInstance.doSomething()
Singleton.sharedInstance.doSomething()
Singleton.sharedInstance.doSomething()

Este enfoque nos permite usar siempre la misma instancia, incluso en diferentes puntos de la aplicación.

Answer 2

Esto es más de un comentario importante:

class Person {
    static var name = "Static John" // a property of Person ''type''
    var name = "Alex" // a property of Person ''instance''

    var nonStaticName = "Peter"
    static var staticName = "Sara"



    static func statFunc() {
        let x = Person.name // Static John
        let y = name // Static John or Alex?!  Static John!!!!
        let r = staticName // Sara
        let k = nonStaticName // ERROR: instance member ''nonStaticName'' cannot be used on type ''Person''
        // The compiler is like: I''m referrting to the `nonStaticName` property of which instance?! There is no instance! Sorry can''t do!

    }

    func nonStaticFunc() {
        let x = Person.name // Static John
        let y = name // Static John or Alex?! Alex!!! Because we''re in a instance scope...
        let k = nonStaticName // Obviously works
        let r = staticName // ERROR: static member ''staticName'' cannot be used on instance of type ''Person''. Person.staticName will work
    }
}

Observaciones interesantes:

Primero:

static var name = "Static John" // a property of Person ''type''
var name = "Alex" // a property of Person ''instance''

No crea conflictos.

Segundo:

Nunca puedes usar variables de instancia dentro de variables estáticas. Puede usar variables estáticas dentro de las funciones de la instancia si lo refiere Person.name con el tipo ie do Person.name , mientras que

Se puede acceder a las variables estáticas dentro de las funciones estáticas con o sin prefijo el tipo, es decir, Person.staticName o staticName ambos funcionan.

Answer 3

Hay algunas publicaciones sobre cómo escribir código para constante estática y variable estática en Swift. Pero no está claro cuándo usar constante estática y variable estática en lugar de constante y variable. ¿Alguien puede explicar? Cuando define una var / let estática en una clase (o estructura), ese valor se compartirá entre todas las instancias (o valores).

Las variables / clase estáticas son variables a las que se puede acceder sin necesidad de crear ninguna instancia / objeto.

class Human {
    static let numberOfEyes = 2 //human have only 2 eyes
    static var eyeDefect = false //whether human have side-effect or not. he can have defect later so its variable

    //other variables and functions
}

//you can access numberOfEyes like below no object of Human is created
print(Human.numberOfEyes)
print(Human.eyeDefect)

//Object of Human
let john = Human()

Creo que sabes diferencia entre constante y variable. En resumen, constante es aquel cuyo valor nunca cambia; numberOfEyes en el ejemplo anterior y la variable es aquel cuyo valor cambia; EyeDefect en el ejemplo anterior.

Las constantes o variables estáticas se colocan en la memoria (RAM) por separado y luego los Objetos. es decir, numberOfEyes tienen diferente espacio de memoria asignado que el objeto John, no está dentro de John.

ahora, cuando usar constantes / variables estáticas:

1. Cuando usa el patrón de diseño singleton: static deje sharedInstance = APIManager ()

   class APIManager(){
       static let sharedInstance = APIManager()
       //Your other variables/functions here below
   }
   //Use it as to get singleton instance of APIManager from anywhere in your application
   let instanceOfAPIManager = APIManager.sharedInstance

2. Cuando necesita valor de cualquier cosa que sea globalmente igual sin necesidad de crear una instancia de la clase bajo la cual se define como numberOfEyes en clase humana.

3. El uso de variables / constantes estáticas no es muy recomendable debido a problemas de memoria porque una vez que se crea una instancia / asigna, permanece en la memoria hasta que su aplicación se elimina de la memoria. He encontrado que hasta ahora el mejor lugar para usar variables / constantes estáticas es solo mientras se crea un patrón único y, a veces, los indicadores para otras variables y constantes normales no usan estática porque: problema de memoria, será difícil ejecutar pruebas de unidad en su código Con variables / constantes estáticas. No se recomienda su uso como en clase humana también. en su lugar, utilícelas como constantes o variables y acceda a ellas creando instancia.

   class Human {
    let numberOfEyes = 2 //human have only 2 eyes
    var eyeDefect = false //whether human have side-effect or not. he can have defect later so its variable
   
      //other variables and functions
    }
   
   //you can access numberOfEyes like below if you need just those values.
   print(Human().numberOfEyes)
   print(Human().eyeDefect)

Answer 4

Las constantes y variables estáticas pertenecen a la clase en sí, no a una instancia en particular. Una clase también puede tener métodos estáticos a los que se puede llamar sin crear una instancia de una clase.

Entonces, cuando tienes una clase MyClass con una var x estática, también puedes acceder a ella a través de MyClass.x directamente. x será compartido entre todas las instancias de una clase