What are 'get' and 'set' in Swift?

问题

I'm learning Swift and I'm reading The Swift Programming Language from Apple, I have no Objective C background (only PHP, JS, and other but no Obj C)

On page 24-25 I see this code:

//...Class definition stuff...

var perimeter: Double {
    get {
        return 3.0 * sideLength
    }
    set {
        sideLength = newValue / 3.0
    }
}

//...Class continues...

This part is NOT specified in the book and I can't get what those are for.

Can anyone explain me what get and set are?

回答1:

That's actually explained right before the code:

In addition to simple properties that are stored, properties can have a getter and a setter.
class EquilateralTriangle: NamedShape {
    ...

When some other class wants to get that perimeter variable, they do this:

let someVar = myTriangle.perimeter

... Which calls this:

get{
    return 3.0 * self.sideLength
}

And thus it's essentially like if the calling controller did this:

let someVar = 3.0 * myTriangle.sideLength

When you set the variable from another object, it looks like this:

myTriangle.perimeter = 100

Which invokes the code in the set{} block:

set {
    sideLength = newValue / 3.0
}

And so it's like if the class that's setting the variable had done this:

myTriangle.sideLength = 100/3.0

It's really just for convenience - you can call this from other code without having to divide by or multiply by 3 all the time, because that's done right before setting the variable and right before you get the variable.

In Swift, we can have properties that are computed when gotten and can do something when set. We could do this in Objective-C too:

// .h
@property (nonatomic) double perimeter;

//.m

- (double)perimeter
{
    return self.sideLength * 3.0;
}
- (void)setPerimeter:(double)perimeter
{
    self.perimeter = perimeter; // In Swift, this is done automatically.
    self.sideLength = perimeter / 3.0;
}

回答2:

The getting and setting of variables within classes refers to either retrieving ("getting") or altering ("setting") their contents.

Consider a variable members of a class family. Naturally, this variable would need to be an integer, since a family can never consist of two point something people.

So you would probably go ahead by defining the members variable like this:

class family {
   var members:Int
}

This, however, will give people using this class the possibility to set the number of family members to something like 0 or 1. And since there is no such thing as a family of 1 or 0, this is quite unfortunate.

This is where the getters and setters come in. This way you can decide for yourself how variables can be altered and what values they can receive, as well as deciding what content they return.

Returning to our family class, let's make sure nobody can set the members value to anything less than 2:

class family {
  var _members:Int = 2
  var members:Int {
   get {
     return _members
   }
   set (newVal) {
     if newVal >= 2 {
       _members = newVal
     } else {
       println('error: cannot have family with less than 2 members')
     }
   }
  }
}

Now we can access the members variable as before, by typing instanceOfFamily.members, and thanks to the setter function, we can also set it's value as before, by typing, for example: instanceOfFamily.members = 3. What has changed, however, is the fact that we cannot set this variable to anything smaller than 2 anymore.

Note the introduction of the _members variable, which is the actual variable to store the value that we set through the members setter function. The original members has now become a computed property, meaning that it only acts as an interface to deal with our actual variable.

回答3:

A simple question should be followed by a short, simple and clear answer.

When we are getting a value of the property it fires its get{} part.
When we are setting a value to the property it fires its set{} part.

PS. When setting a value to the property, SWIFT automatically creates a constant named "newValue" = a value we are setting. After a constant "newValue" becomes accessible in the property's set{} part.

Example:

var A:Int = 0
var B:Int = 0

var C:Int {
get {return 1}
set {print("Recived new value", newValue, " and stored into 'B' ")
     B = newValue
     }
}

//When we are getting a value of C it fires get{} part of C property
A = C 
A            //Now A = 1

//When we are setting a value to C it fires set{} part of C property
C = 2
B            //Now B = 2

回答4:

You should look at Computed Properties

In your code sample, perimeter is a property not backed up by a class variable, instead its value is computed using the get method and stored via the set method - usually referred to as getter and setter.

When you use that property like this:

var cp = myClass.perimeter

you are invoking the code contained in the get code block, and when you use it like this:

myClass.perimeter = 5.0

you are invoking the code contained in the set code block, where newValue is automatically filled with the value provided at the right of the assignment operator.

Computed properties can be readwrite if both a getter and a setter are specified, or readonly if the getter only is specified.

来源：https://stackoverflow.com/questions/24699327/what-are-get-and-set-in-swift

标签

swift

accessor