Swift - Propriedades

A linguagem Swift 4 fornece propriedades para classe, enumeração ou estrutura para associar valores. As propriedades podem ser classificadas em propriedades armazenadas e propriedades computadas.

Diferença entre propriedades armazenadas e propriedades computadas

Propriedade Armazenada	Propriedade Computada
Armazene valores constantes e variáveis como instância	Calcule um valor em vez de armazená-lo
Fornecido por classes e estruturas	Fornecido por classes, enumerações e estruturas

As propriedades Armazenadas e Computadas estão associadas ao tipo de instância. Quando as propriedades são associadas aos seus valores de tipo, ela é definida como 'Propriedades de tipo'. Propriedades armazenadas e calculadas geralmente são associadas a instâncias de um tipo específico. No entanto, as propriedades também podem ser associadas ao próprio tipo. Essas propriedades são conhecidas como propriedades de tipo. Observadores de propriedade também são usados

Para observar o valor das propriedades armazenadas
Para observar a propriedade da subclasse herdada derivada da superclasse

Propriedades Armazenadas

Swift 4 introduz o conceito de propriedade armazenada para armazenar as instâncias de constantes e variáveis. As propriedades armazenadas de constantes são definidas pela palavra-chave 'let' e as propriedades armazenadas de variáveis são definidas pela palavra-chave 'var'.

Durante a definição, a propriedade armazenada fornece 'valor padrão'
Durante a inicialização, o usuário pode inicializar e modificar os valores iniciais

struct Number {
   var digits: Int
   let pi = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.pi)")

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

67
3.1415

Considere a seguinte linha no código acima -

let pi = 3.1415

Aqui, a variável pi é inicializada como um valor de propriedade armazenado com a instância pi = 3,1415. Portanto, sempre que a instância for referenciada, ela conterá apenas o valor 3,1415.

Outro método para ter propriedades armazenadas é ter como estruturas constantes. Portanto, toda a instância das estruturas será considerada como 'Propriedades armazenadas das constantes'.

struct Number {
   var digits: Int
   let numbers = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.numbers)")
n.numbers = 8.7

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

error: cannot assign to 'numbers' in 'n'
n.numbers = 8.7

Em vez de reinicializar o 'número' para 8,7, ele retornará uma mensagem de erro indicando que o 'número' é declarado como constante.

Propriedade Armazenada Preguiçosa

O Swift 4 fornece uma propriedade flexível chamada 'Lazy Stored Property' onde não calcula os valores iniciais quando a variável é inicializada pela primeira vez. O modificador 'preguiçoso' é usado antes da declaração da variável para tê-la como uma propriedade armazenada preguiçosa.

Propriedades preguiçosas são usadas -

Para atrasar a criação do objeto.
Quando a propriedade depende de outras partes de uma classe, que ainda não são conhecidas

class sample {
   lazy var no = number()    // `var` declaration is required.
}

class number {
   var name = "Swift 4"
}

var firstsample = sample()
print(firstsample.no.name)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

Swift 4

Variáveis de instância

Em Objective C, as propriedades armazenadas também têm variáveis de instância para fins de backup para armazenar os valores declarados na propriedade armazenada.

O Swift 4 integra esses dois conceitos em uma única declaração de 'propriedade armazenada'. Em vez de ter uma variável de instância correspondente e valor de backup, a 'propriedade armazenada' contém todas as informações integradas definidas em um único local sobre a propriedade das variáveis por nome de variável, tipo de dados e funcionalidades de gerenciamento de memória.

Propriedades Computadas

Em vez de armazenar os valores calculados, as propriedades fornecem um getter e um setter opcional para recuperar e definir outras propriedades e valores indiretamente.

class sample {
   var no1 = 0.0, no2 = 0.0
   var length = 300.0, breadth = 150.0

   var middle: (Double, Double) {
      get {
         return (length / 2, breadth / 2)
      }
      
      set(axis){
         no1 = axis.0 - (length / 2)
         no2 = axis.1 - (breadth / 2)
      }
   }
}

var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)

print(result.no1)
print(result.no2)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

(150.0, 75.0)
-150.0
-65.0

Quando uma propriedade computada deixa o novo valor como indefinido, o valor padrão será definido para aquela variável particular.

Propriedades calculadas como propriedades somente leitura

Uma propriedade somente leitura na propriedade computada é definida como uma propriedade com getter, mas sem setter. É sempre usado para retornar um valor. As variáveis são posteriormente acessadas por meio de um '.' Sintaxe, mas não pode ser definida para outro valor.

class film {
   var head = ""
   var duration = 0.0
   var metaInfo: [String:String] {
      return [
         "head": self.head,
         "duration":"\(self.duration)"
      ]
   }
}

var movie = film()
movie.head = "Swift 4 Properties"
movie.duration = 3.09

print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

Swift 4 Properties
3.09

Propriedades calculadas como observadores de propriedade

No Swift 4, para observar e responder aos valores das propriedades, são usados Observadores de Propriedades. Sempre que os valores das propriedades são definidos, os observadores das propriedades são chamados. Exceto as propriedades lazy stored, podemos adicionar observadores de propriedade à propriedade 'herdada' pelo método 'override'.

Observadores de propriedade podem ser definidos por qualquer

Antes de armazenar o valor - willset
Depois de armazenar o novo valor - didset
Quando uma propriedade é definida em um inicializador, os observadores willset e didset não podem ser chamados.

class Samplepgm {
   var counter: Int = 0 {
      willSet(newTotal){
         print("Total Counter is: \(newTotal)")
      }
      
      didSet {
         if counter > oldValue {
            print("Newly Added Counter \(counter - oldValue)")
         }
      }
   }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

Variáveis locais e globais

Variáveis locais e globais são declaradas para calcular e observar as propriedades.

Variáveis Locais	Variáveis globais
Variáveis que são definidas em uma função, método ou contexto de fechamento.	Variáveis que são definidas fora do contexto de função, método, encerramento ou tipo.
Usado para armazenar e recuperar valores.	Usado para armazenar e recuperar valores.
As propriedades armazenadas são usadas para obter e definir os valores.	As propriedades armazenadas são usadas para obter e definir os valores.
Propriedades computadas também são usadas.	Propriedades computadas também são usadas.

Propriedades de tipo

As propriedades são definidas na seção de definição de tipo com chaves {} e o escopo das variáveis também é definido anteriormente. Para definir propriedades de tipo para tipos de valor, a palavra-chave 'estática' é usada e para tipos de classe, a palavra-chave 'classe' é usada.

Sintaxe

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

class Classname {
   class var computedTypeProperty: Int {
      // return an Int value here
   }
}

Consultando e definindo propriedades

Assim como as propriedades de instância, as propriedades de tipo são consultadas e definidas com '.' Sintaxe apenas no tipo em vez de apontar para a instância.

struct StudMarks {
   static let markCount = 97
   static var totalCount = 0
   
   var InternalMarks: Int = 0 {
      didSet {
         if InternalMarks > StudMarks.markCount {
            InternalMarks = StudMarks.markCount
         }
         if InternalMarks > StudMarks.totalCount {
            StudMarks.totalCount = InternalMarks
         }
      }
   }
}

var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()

stud1Mark1.InternalMarks = 98
print(stud1Mark1.InternalMarks)

stud1Mark2.InternalMarks = 87
print(stud1Mark2.InternalMarks)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -