通过SWIFT使用NSCore和NSKeyedArchiver

我一直在尝试在我的应用程序上获取持久数据，以便有用户条目的历史记录。在我将数据存储到阵列中之后，我想对其进行归档，在取消归档之后，我得到的是奇怪的值，而不是我想看到的值

这是我用来存储数据的类

进口基金会

class MyHistory: NSObject, NSCoding {
    var kicksNumber: Int
    var durationNumber: Int


     init(kicksNumber: Int,durationNumber: Int) {
        self.kicksNumber = kicksNumber
        self.durationNumber = durationNumber
    }

    required init(coder decoder: NSCoder) {
        kicksNumber = decoder.decodeObjectForKey("kicksNumber") as! Int
        durationNumber = decoder.decodeObjectForKey("durationNumber") as! Int
    }


    func encodeWithCoder(coder: NSCoder) {
        coder.encodeObject(self.kicksNumber, forKey: "kicksNumber")
        coder.encodeObject(self.durationNumber, forKey: "durationNumber")   
    }
}

接下来是我的课程，在这里发生了一些事情，我正在测试保存和加载过程

class Kicks: UIViewController {

    var myHistoryArray: [MyHistory] = []
    var currentMyHistory: MyHistory!
    var newHistory = [MyHistory]()

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        self.view.backgroundColor = UIColor(patternImage: UIImage(named: "background13.png")!)


        let defaults = NSUserDefaults.standardUserDefaults()

        if let savedPeople = defaults.objectForKey("MyHistory") as? NSData {
            newHistory = NSKeyedUnarchiver.unarchiveObjectWithData(savedPeople) as! [MyHistory]
            //print("this is archived ", newHistory[0])

        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    var count = 0 as Int
    var countKicks = 0 as Int
    var kickReached = false as Bool
    var pressedOnce = true as Bool
    var timer = NSTimer()
    var test: MyHistory!

    @IBOutlet var timerLabel: UITextField!
    @IBOutlet var kicksLabel: UITextField!


    @IBAction func kickButton() {
        //currentMyHistory.kicksNumber = 5


        if pressedOnce {
            pressedOnce = false
            timer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("counter"), userInfo: nil, repeats: true)
        } else if kickReached {

            //  let date = NSDate()
            //  let calendar = NSCalendar.currentCalendar()
            // let timer_total = calendar.components([ .Hour, .Minute, .Second], fromDate: date)
        } else if !pressedOnce {
            countKicks++
            kicksLabel.text = "\(countKicks)"
            if countKicks == 10 {
                kickReached = true
                timer.invalidate()
                congratsAlert()

                currentMyHistory = MyHistory(kicksNumber: 5, durationNumber: 10)
                print("this is currentMyHistory", currentMyHistory.kicksNumber )

                myHistoryArray.append(currentMyHistory)
                test = myHistoryArray[0]
                print("this is myHistoryArray0",  test.kicksNumber)
                //save data
                let savedData = NSKeyedArchiver.archivedDataWithRootObject(myHistoryArray)
                let defaults = NSUserDefaults.standardUserDefaults()
                defaults.setObject(savedData, forKey: "MyHistory")
                //load data
                //let defaults = NSUserDefaults.standardUserDefaults()

               // let person = people[indexPath.item]
               //let historyUnarchived = NSKeyedUnarchiver.unarchiveObjectWithFile("/path/to/archive") as? [MyHistory]
         //       let data1 = NSUserDefaults.standardUserDefaults().objectForKey("myHistoryArray")
                print("this is unrachived",newHistory[0])
                clear()
            }
        }
    }

    // save countKicks, count, and stamp i
    func congratsAlert() {
        let alert = UIAlertController(title: "Congratulation", message: "Yay!!! Angelina kicked 10 times in less than 2 hours.",preferredStyle: .Alert)

        let okAction = UIAlertAction(title: "Ok",style: .Default,handler:{(action:UIAlertAction) -> Void in})
        alert.addAction(okAction)

        presentViewController(alert,animated: true,completion: nil)
    }

    func clear() {
        count = 0
        countKicks = 0
        kickReached = false
        pressedOnce = true
        timerLabel.text = "00:00:0\(count)"
        kicksLabel.text = "\(countKicks)"
    }

    func counter() {
        ++count
        let (hour,minutes,seconds) = secondsToHoursMinutesSeconds(count)

        if seconds < 10 && minutes < 10 {
            timerLabel.text = "0\(hour):0\(minutes):0\(seconds)"
        } else if seconds > 9 && minutes < 10 {
            timerLabel.text = "0\(hour):0\(minutes):\(seconds)"
        } else if seconds > 9 && minutes > 9 {
            timerLabel.text = "0\(hour):\(minutes):\(seconds)"
        } else if seconds < 10 && minutes > 9 {
            timerLabel.text = "0\(hour):\(minutes):0\(seconds)"
        }
    }

    func secondsToHoursMinutesSeconds (seconds : Int) -> (Int, Int, Int) {
        return (seconds / 3600, (seconds % 3600) / 60, (seconds % 3600) % 60)
    }
    /*

    func savePlaces() {
        let placesArray = [myHistory(kicksNumber: 420, durationNumber: 89)]
        let placesData = NSKeyedArchiver.archivedDataWithRootObject(placesArray)
        NSUserDefaults.standardUserDefaults().setObject(placesData, forKey: "kicks")
    }

    func loadPlaces() {
    let placesData = NSUserDefaults.standardUserDefaults().objectForKey("kicks") as? NSData

    if let placesData = placesData {
    let placesArray = NSKeyedUnarchiver.unarchiveObjectWithData(placesData) as? [myHistory]

    if let placesArray = placesArray {
    // do something…
    }

    }
    }*/
}

class Kicks:UIViewController{
var myHistoryArray:[MyHistory]=[]
var currentMyHistory:MyHistory！
var newHistory=[MyHistory]（）
重写func viewDidLoad（）{
super.viewDidLoad（）
//加载视图后，通常从nib执行任何其他设置。
self.view.backgroundColor=UIColor（patternImage:UIImage（名为：“background13.png”）！）
让defaults=NSUserDefaults.standardUserDefaults（）
如果让savedPeople=defaults.objectForKey（“MyHistory”）作为NSData{
newHistory=NSKeyedUnarchiver.unarchiveObjectWithData（savedPeople）为！[MyHistory]
//打印（“已存档”，新历史记录[0]）
}
}
重写函数didReceiveMemoryWarning（）{
超级。我收到了记忆警告（）
//处置所有可以重新创建的资源。
}
变量计数=0作为Int
var countKicks=0作为Int
var KICKREACH=错误为布尔
var pressedOnce=作为布尔值为真
var timer=NSTimer（）
var测试：MyHistory！
@IBOutlet var timerLabel:UITextField！
@IBMOutlet标签：UITextField！
@iAction func kickButton（）{
//currentMyHistory.kickNumber=5
如果按下按钮{
pressedOnce=false
timer=NSTimer.scheduledTimerWithTimeInterval（1，目标：self，选择器：选择器（“计数器”），userInfo:nil，repeats:true）
}否则，如果到达{
//let date=NSDate（）
//让calendar=NSCalendar.currentCalendar（）
//让timer_total=calendar.components（[.Hour、.Minute、.Second]，fromDate:date）
}否则，请按Donce{
倒计时++
kicklabel.text=“\（countKicks）”
如果countKicks==10{
kickreach=true
timer.invalidate（）
祝贺你
currentMyHistory=MyHistory（kickNumber:5，durationNumber:10）
打印（“这是currentMyHistory”，currentMyHistory.kickNumber）
myHistoryArray.append（currentMyHistory）
test=myHistoryArray[0]
打印（“这是myHistoryArray0”，test.kickNumber）
//保存数据
让savedData=NSKeyedArchiver.archivedDataWithRootObject（myHistoryArray）
让defaults=NSUserDefaults.standardUserDefaults（）
setObject（savedData，forKey：“MyHistory”）
//加载数据
//让defaults=NSUserDefaults.standardUserDefaults（）
//让person=people[indexPath.item]
//让historyUnarchived=NSKeyedUnarchiver.unarchiveObjectWithFile（“/path/to/archive”）作为？[MyHistory]
//让data1=NSUserDefaults.standardUserDefaults（）.objectForKey（“myHistoryArray”）
打印（“这是未实现的”，newHistory[0]）
清除（）
}
}
}
//保存countKicks、count和stamp i
func Congreatsalert（）{
let alert=UIAlertController（标题：“祝贺”，信息：“耶！！！安吉丽娜在不到2小时内踢了10次。”，首选样式：。alert）
让okAction=UIAlertAction（标题：“确定”，样式：。默认值，处理程序：{（操作：UIAlertAction）->Void in}）
alert.addAction（okAction）
presentViewController（警报、动画：真、完成：无）
}
func clear（）{
计数=0
countKicks=0
kickreach=false
pressedOnce=true
timerLabel.text=“00:00:0\（计数）”
kicklabel.text=“\（countKicks）”
}
func计数器（）{
++计数
let（小时、分钟、秒）=秒到小时分钟秒（计数）
如果秒<10和分钟<10{
timerLabel.text=“0\（小时）：0\（分钟）：0\（秒）”
}否则，如果秒>9和分钟<10{
timerLabel.text=“0\（小时）：0\（分钟）：\（秒）”
}否则，如果秒数>9&&分钟数>9{
timerLabel.text=“0\（小时）：\（分钟）：\（秒）”
}否则，如果秒数<10和分钟数>9{
timerLabel.text=“0\（小时）：\（分钟）：0\（秒）”
}
}
func secondstohoursminuteseconds（秒：Int）->（Int，Int，Int）{
返回（秒/3600，（秒%3600）/60，（秒%3600）%60）
}
/*
func存储位置（）{
let placesArray=[myHistory（kickNumber:420，durationNumber:89）]
让placesData=NSKeyedArchiver.archivedDataWithRootObject（placesArray）
NSUserDefaults.standardUserDefaults（）.setObject（placesData，forKey：“kicks”）
}
func loadPlaces（）{
让placesData=NSUserDefaults.standardUserDefaults（）.objectForKey（“kicks”）作为NSData
如果让placesData=placesData{
让placesArray=NSKeyedUnarchiver.unarchiveObjectWithData（placesData）作为？[myHistory]
如果让placesArray=placesArray{
//做点什么…
}
}
}*/
}

我的输出如下：

这是我的历史记录5

这是我的历史阵列05

这是无法实现的

来自调试器的消息：由于信号15而终止

---

为什么未归档是奇怪的值

在MyHistory类中，您使用的是ints，因此在encodeWithCoder函数中，您应该使用ints

coder.encodeInteger(self.kicksNumber, forKey: "kicksNumber")
coder.encodeInteger(self.durationNumber, forKey: "durationNumber") 

同样，对于解码器，您应该使用decodeIntForKey，而不是decodeObjectForKey

kicksNumber = decoder.decodeIntegerForKey("kicksNumber")
durationNumber = decoder.decodeIntegerForKey("durationNumber")