mutating swift

2016-05-17 16:39:31 Apple_app 阅读数 420

在  swift 中,包含三种类型(type):  structure ,  enumeration ,  class

其中structureenumeration是值类型( value type ),class是引用类型( reference type )

但是与objective-c不同的是,structure和enumeration也可以拥有方法(method),其中方法可以为实例方法(instance method),也可以为类方法(type method),实例方法是和类型的一个实例绑定的。

在swift官方教程中有这样一句话:

“Structures and enumerations are value types.
 By default, the properties of a value type cannot be modified from within its instance methods.”
摘录来自: Apple Inc. “The Swift Programming Language”。 iBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

大致意思就是说,虽然结构体和枚举可以定义自己的方法,但是默认情况下,实例方法中是不可以修改值类型的属性。

举个简单的例子,假如定义一个点结构体,该结构体有一个修改点位置的实例方法:

struct Point {
  var x = 0, y = 0
  
  func moveXBy(x:Int,yBy y:Int) {
    self.x += x
    // Cannot invoke '+=' with an argument list of type '(Int, Int)'
    self.y += y
    // Cannot invoke '+=' with an argument list of type '(Int, Int)'
  }
}

编译器抛出错误,说明确实不能在实例方法中修改属性值。

为了能够在实例方法中修改属性值,可以在方法定义前添加关键字  mutating

struct Point {
  var x = 0, y = 0
  mutating func moveXBy(x:Int,yBy y:Int) {
    self.x += x
    self.y += y
  }
}
var p = Point(x: 5, y: 5)
p.moveXBy(3, yBy: 3)
另外,在值类型的实例方法中,也可以直接修改self属性值。

enum TriStateSwitch {
  case Off, Low, High
  mutating func next() {
    switch self {
    case Off:
      self = Low
    case Low:
      self = High
    case High:
      self = Off
    }
  }
}
var ovenLight = TriStateSwitch.Low
ovenLight.next()
// ovenLight is now equal to .High
ovenLight.next()
// ovenLight is now equal to .Off”

TriStateSwitch枚举定义了一个三个状态的开关,在next实例方法中动态改变self属性的值。

当然,在引用类型中(即class)中的方法默认情况下就可以修改属性值,不存在以上问题。






2019-02-12 17:02:09 jacob_ios 阅读数 434

在Swift中,structure和enumeration是值类型(value type)

class是引用类型(reference type)。

默认情况下,实例方法中是不可以修改值类型的属性,使用mutating后可修改属性的值

例如:

在结构体中,有一个实例方法,如果直接修改属性的值,编译器会报错。

可以使用mutating修饰

struct Point {
    var x = 0
    var y = 0
    
    mutating func movePoint(x: Int, y: Int) {
        self.x += x
    }
}

例如:

在枚举中修改self属性值,需要使用mutating修饰

enum TriSwitch {
    case Off, Low, High
    mutating func next() {
        switch self {
        case .Off:
            self = .Low
        case .Low:
            self = .High
        case .High:
            self = .Off
        }
    }
}

在引用类型中(即class)中的方法默认情况下就可以修改属性值,不存在以上问题。

2018-05-11 16:42:42 qq_30932479 阅读数 755

使用 mutating 关键字修饰方法是为了能在该方法中修改 struct 或是 enum 的变量

首先,先定义一个protocol

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

在上面,定义了一个ExampleProtocol,接下来我们写一个class来遵守这个协议

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class"
    var anotherProperty: Int = 110
func adjust() {
        simpleDescription += " Now 100% adjusted"
    }
}

struct中实现协议ExampleProtocol

struct SimpleStruct: ExampleProtocol {
var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += "(adjusted)"
    }
}

enum中实现协议ExampleProtocol同上




2017-02-16 10:22:36 qq_18674153 阅读数 4005

Swift中,包含三种类型(type): structure,enumeration,class

其中structure和enumeration是值类型(value type),class是引用类型(reference type)

但是与Objective-C不同的是,structure和enumeration也可以拥有方法(method),其中方法可以为实例方法(instance method),也可以为类方法(type method),实例方法是和类型的一个实例绑定的。

在swift官方教程中有这样一句话:

[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. “Structures and enumerations are value types. By default, the properties of a value type  
  2.  cannot be modified from within its instance methods.”  
  3.   
  4. 摘录来自: Apple Inc. “The Swift Programming Language”。 iBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329  

大致意思就是说,虽然结构体和枚举可以定义自己的方法,但是默认情况下,实例方法中是不可以修改值类型的属性。


举个简单的例子,假如定义一个点结构体,该结构体有一个修改点位置的实例方法:

[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. struct Point {  
  2.     var x = 0, y = 0  
  3.       
  4.     func moveXBy(x:Int,yBy y:Int) {  
  5.         self.x += x  
  6.         // Cannot invoke '+=' with an argument list of type '(Int, Int)'  
  7.         self.y += y  
  8.         // Cannot invoke '+=' with an argument list of type '(Int, Int)'  
  9.     }  
  10. }  

编译器抛出错误,说明确实不能在实例方法中修改属性值。

为了能够在实例方法中修改属性值,可以在方法定义前添加关键字mutating

[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. struct Point {  
  2.     var x = 0, y = 0  
  3.       
  4.     mutating func moveXBy(x:Int,yBy y:Int) {  
  5.         self.x += x  
  6.         self.y += y  
  7.     }  
  8. }  
  9.   
  10. var p = Point(x: 5, y: 5)  
  11.   
  12. p.moveXBy(3, yBy: 3)  


另外,在值类型的实例方法中,也可以直接修改self属性值。

[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. enum TriStateSwitch {  
  2.     case Off, Low, High  
  3.     mutating func next() {  
  4.         switch self {  
  5.         case Off:  
  6.             self = Low  
  7.         case Low:  
  8.             self = High  
  9.         case High:  
  10.             self = Off  
  11.         }  
  12.     }  
  13. }  
  14. var ovenLight = TriStateSwitch.Low  
  15. ovenLight.next()  
  16. // ovenLight is now equal to .High  
  17. ovenLight.next()  
  18. // ovenLight is now equal to .Off”  

TriStateSwitch枚举定义了一个三个状态的开关,在next实例方法中动态改变self属性的值。


当然,在引用类型中(即class)中的方法默认情况下就可以修改属性值,不存在以上问题。

2019-03-20 09:36:21 wufeifan_learner 阅读数 105

学校开课ios开发,人生中第二个ios程序就是苹果开发手册中的ApplePie。按照开发手册写肯定没问题,但是其中有许多东西不理解,其中一个函数:

 mutating func playerGuessed(letter: Character){
        guessedLetters.append(letter)
        if !word.contains(letter) {
            incorrectMovesRemaining -= 1
        }
    }

这里的mutating是什么?起到什么作用?我查了许多资料,现在总结一下。


首先,我们需要了解什么是协议(protocol),协议规定了我们在开发时需要实现某一功能所必须使用的属性和和方法。

swift开发手册是这么写的:协议 定义了一个蓝图,规定了用来实现某一特定任务或者功能的方法、属性,以及其他需要的东西。很抽象,所以用例子说明可能更形象:

现在假设你是女娲,你要造人。造人不是随便造的吧,总得有什么东西把人和其他动物区别开,比如人站立走路,两条腿,两只手,两只眼睛,一张嘴,智商高等等,满足所有这些条件我们才可以称之为人,否则像老虎非直立走路,猩猩智商不如人。

而需要满足的这些条件我们称之为协议。也就是我们在编程时,代码中需要实现的部分。

protocol human{
    var IQ: Int {get}   //声明可读
    var body: ComplexType {get set}  //可写可读
}

这就是一个简单的协议。好了,协议我们约定完了,接下来怎么使用呢?

struct Person: human{
    var IQ: Int
    var body: ComplexType
}

let John = Person(IQ: 110, body: strong)

这样一来,我们成功实现了一个协议:让一个叫做John的常量,他是结构体Person类型的,这个人现在拥有110的智商值IQ和一个强壮的身体。如果我们在构建结构体Person的时候没有实现协议human要求实现的属性,如没有定义IQ,编译器会报错。

属性大致就是这么实现,接下来是方法。

试想,现在你仍然是女娲,但是这时候天漏了,你要补天。补天一定得找个办法吧。

protocol fulfillSky{
    func fulfill()->String
}

协议我们声明好了,接下来是实现,也很简单:

class NvWafulfill: fulfillSky{
    func fulfill()->String{
        return "用石头补天"
    }
}

以上是最基本的协议及实现,接下来我们说关键字mutating

有时需要在方法中改变方法所属的实例。例如,在值类型(即结构体和枚举)的实例方法中,将 mutating 关键字作为方法的前缀,写在 func 关键字之前,表示可以在该方法中修改它所属的实例以及实例的任意属性的值。

看完这句话我很是不理解,直到看到这句话:

“Structures and enumerations are value types. By default, the properties of a value type cannot be modified from within its instance methods.”

结构体和枚举类型属于“值类型”,值类型属性在默认情况下不能被他的实例方法改变。

啥是值类型?除了值类型还有什么?

值类型(value types):每一个值类型的实例都有各自唯一的数据,也就是存储的都是值,且值类型的赋值为深拷贝。(存放在栈区、典型的有struct、enum、Int、Double等)
引用类型:(reference types):引用类型的实例共享其数据,也就是存储的都是指针,且引用类型的赋值为浅拷贝(存放在堆区、class和闭包)

以上问题解决了,我们继续说mutating。

struct Game{
    var word: String
    var incorrectMovesRemaining: Int 
    var guessedLetters: [Character]
    
    mutating func playerGuessed(letter: Character){
        guessedLetters.append(letter)
        if !word.contains(letter) {
            incorrectMovesRemaining -= 1
        }
    }
    
    var formattedWord: String{
        var guessedWord = ""
        for letter in word {
            if guessedLetters.contains(letter){
                guessedWord += "\(letter)"
            } else{
                guessedWord += "_"
            }
        }
        return guessedWord
    }
}
   

在这个结构体中,有String变量word,Int变量incorrectMovesRemaining,字符数组guessedLetters。我想要在函数playerGuess中改变guessedLetters和incorrectMovesRemaining的值,因此需要添加mutating关键字。

如果不添加此关键字,编译器报错:

啥意思?不能对不可变值使用可变成员。直接翻译比较牵强,其实他的意思就是本结构体中的变量在声明之后不可以改变值,而mutating关键字修饰后,意味着结构体声明的变量值可以改变。


参考文章:

https://www.jianshu.com/p/91a91ee1d8de

https://www.jianshu.com/p/14cc9d30770a

 http://blog.csdn.net/tounaobun/article/details/39694233

http://www.runoob.com/swift/swift-protocols.html

swift之mutating

阅读数 347

swift- mutating

阅读数 131