IOS four ways to save data

In the process of iOS development, no matter what the application, you will encounter the problem of data preservation. Saving the data locally allows the program to run more smoothly without the appearance of an obnoxious chrysanthemum shape, making the user experience even better. Here's how data is saved:

1.NSKeyedArchiver: Save the data in the form of an archive that requires adherence to the Nscoding protocol, and that the class corresponding to the object must provide Encodewithcoder: and Initwithcoder: Methods. The previous method tells the system how to encode the object, and the latter method tells the system how to decode the object. For example, save the Possession object archive.

Define possession:

@interface possession:nsobject<nscoding>{//compliance with nscoding protocol

NSString *name;//Pending Archive type

}

@implementation Possession

-(void) Encodewithcoder: (Nscoder *) acoder{

[Acoder encodeobject:name forkey:@ "name"];

}

-(void) Initwithcoder: (Nscoder *) adecoder{

Name=[[adecoder decodeobjectforkey:@ "name"] retain];

}

Archive operations:

If you save the possession object Allpossession archive, you only need to nscoder the method Archiverootobject:tofile of the subclass Nskeyedarchiver: Yes.

NSString *path = [self possessionarchivepath];

[Nskeyedarchiver archiverootobject:allpossessions Tofile:path]

Decompression operation:

Also call the method of Nscoder subclass Nskeyedarchiver Unarchiverootobject:tofile: You can

Allpossessions = [[Nskeyedunarchiver Unarchiveobjectwithfile:path] retain];

Cons: Archive the form to save data, only one-time archive save and one-time decompression. So only a small amount of data, and the data operation is clumsy, that is, if you want to change a small part of the data, still need to extract the entire data or archive the entire data.

2.NSUserDefaults: Used to save application settings and properties, user-saved data. The data still exists after the user opens the program again or after powering it on. The types of data that Nsuserdefaults can store include: NSData, NSString, NSNumber, NSDate, Nsarray, Nsdictionary. If you want to store other types, you need to convert to the previous type to use Nsuserdefaults storage. The specific implementation is:

Save data:

Nsuserdefaults *defaults =[nsuserdefaults Standarduserdefaults];
NSString *name [email protected] "default string";
[Defaults setobject:firstname forkey:@ "name"];
Get UIImage instances

UIImage *image=[[uiimage alloc]initwithcontentsoffile:@ "Photo.jpg"];

NSData *imagedata = uiimagejpegrepresentation (image),//uiimage object converted to NSData

[Defaults synchronize];//uses synchronize method to persist data to the Standarduserdefaults database

Read data:

Nsuserdefaults *defaults =[nsuserdefaults Standarduserdefaults];
NSString *name = [Defaults objectforkey:@ "name"];//Remove name based on key value
NSData *imagedata = [Defaults dataforkey:@ "image"];
UIImage *image = [UIImage imagewithdata:imagedata];//nsdata converted to UIImage

3. Write writes: Permanently saved on disk. The specific methods are:

Step one: Get the path that the file is about to save:

Nsarray *documentpaths = Nssearchpathfordirectoriesindomains (nsdocumentdirectory, NSUserDomainMask,YES);// Use the C function nssearchpathfordirectoriesindomains to get the full path of the directory in the sandbox. The function has three parameters, a directory type, a he domain mask, and a Boolean value. Where the Boolean value indicates whether the path needs to be extended through the ~. And the first parameter is constant, which is nssearchpathdirectory. In iOS, the latter two parameters are the same: Nsuserdomainmask and YES.
NSString *ourdocumentpath =[documentpaths objectatindex:0];

Another way is to use the Nshomedirectory function to get the sandbox path. The specific usage is:

NSString *sandboxpath = Nshomedirectory ();
Once you has the full sandbox path, you can create a path from it, but cannot write files on the sandbox file layer and cannot create directories, but should be based on creating a new writable directory, such as D Ocuments,library or temp.
NSString *documentpath = [Sandboxpath
stringbyappendingpathcomponent:@ "Documents"];//to add documents to the sandbox path, the specific reason before the analysis!

The difference between the two is that using Nssearchpathfordirectoriesindomains is more secure than adding a document behind Nshomedirectory. Because the file directory may change on future systems that are sent.

Step two: Generate files under this path:

NSString *filename=[documentdirectory Stringbyappendingpathcomponent:filename];//filename is the filename of the saved file

Step three: Write data to the file:

[Data writetofile:filename atomically:yes];//writes NSData type Object data to a file named filename

Finally: Read the data from the file:

NSData data=[nsdata datawithcontentsoffile:filename options:0 error:null];//read out data from FileName
4. SQLite: Use SQLite database to store data. SQLite as a small and medium-sized database, the application of iOS, in front of three ways to save compared to a relatively more complex. It's a step-by-step!

First step: You need to add SQLite related libraries and header files: Under Build phases of the project file, locate the link Binary library (ies), Add Libsqlite3.0.dylib (the difference between Libsqlite3.dylib and the former does not know, the two should be similar); Add a header file to the header file or source file in the project file #import "/usr/include/sqlite3.h"

Step two: Start using SQLite:

Note Before use: If you do not add any tables to the database, this database is not established, does not generate any files on the hard disk, and if the database already exists, the database will open .

Nsarray *documentspaths=nssearchpathfordirectoriesindomains (NSDocumentDirectory, NSUserDomainMask, YES);
NSString *databasefilepath=[[documentspaths objectatindex:0] stringbyappendingpathcomponent:@ "MyDB"];
The above two sentences are already more familiar with it!
Open Database
if (Sqlite3_open ([Databasefilepath utf8string], &database) ==SQLITE_OK) {
NSLog (@ "SQLite dadabase is opened.");
}
else{return;} Turn on unsuccessful to return

When the database is open, if the database does not have a table, then you start to build the table Oh!
Char *error;
const char *createsql= "CREATE TABLE (ID integer primary key autoincrement, name text)";
if (sqlite3_exec (database, createsql, NULL, NULL, &ERROR) ==SQLITE_OK) {
NSLog (@ "CREATE TABLE is OK.");
}
Else
{
NSLog (@ "error:%s", error);
Sqlite3_free (error);//Empty the error string each time it is used, provided to the next use
}

After the build table is complete, insert the record:

const char *insertsql= "INSERT into a person (name) VALUES (' GG ')";
if (sqlite3_exec (database, insertsql, NULL, NULL, &ERROR) ==SQLITE_OK) {
NSLog (@ "insert operation is OK.");
}

Else
{
NSLog (@ "error:%s", error);
Sqlite3_free (error);//Empty the error string each time it is used, provided to the next use
}

Next, query the record:

const char *selectsql= "Select id,name from a person";
Sqlite3_stmt *statement;
if (SQLITE3_PREPARE_V2 (Database,selectsql,-1, &statement, nil) ==SQLITE_OK) {
NSLog (@ "Select operation is OK.");
}
Else
{
NSLog (@ "error:%s", error);
Sqlite3_free (Error);
}
while (Sqlite3_step (statement) ==sqlite_row) {
int _id=sqlite3_column_int (statement, 0);
NSString *name= (char*) sqlite3_column_text (statement, 1);
NSLog (@ "Row>>id%i, Name%s", _id,name);
}
Sqlite3_finalize (statement);

Finally, close the database:

Sqlite3_close (database);

Note: To write to a database, the string can be char, and the char type is removed from the database and garbled when the char type has a representation of the Chinese characters. This is because the database uses ASCII encoding by default. Therefore, in order to correctly remove the Chinese from the database, we need to use NSString to receive the string extracted from the database.

IOS four ways to save data