Property List 支持的数据类型（us…

Property list

Prerequisite Articles

Object
graph

Collection

Related Articles

Archiving

Object
mutability

A property list is a representation of a hierarchy of objects that
can be stored in the file system and reconstituted later. Property
lists give applications a lightweight and portable way to store
small amounts of data. They are hierarchies of data made from
specific types of objects—they are, in effect, an object graph.
Property lists are easy to create programmatically and are even
easier to serialize into a representation that is persistent.
Applications can later read the static representation back into
memory and recreate the original hierarchy of objects. Both Cocoa
Foundation and Core Foundation have APIs related to property list
serialization and deserialization.

Property List Types and Objects

Property lists consist only of certain types of data: dictionaries,
arrays, strings, numbers (integer and float), dates, binary data,
and Boolean values. Dictionaries and arrays are special types
because they are collections; they can contain one or multiple data
types, including other dictionaries and arrays. This hierarchical
nesting of objects creates a graph of objects. The abstract data
types have corresponding Foundation classes, Core Foundation types,
and XML elements for collection objects and value objects, as shown
in the following list:

Abstract type	Foundation framework class	Core Foundation type	XML element
Array	NSArray	CFArrayRef	<array>
Dictionary	NSDictionary	CFDictionaryRef	<dict>
String	NSString	CFStringRef	<string>
Data	NSData	CFDataRef	<data>
Date	NSDate	CFDateRef	<date>
Integer	NSNumber ( intValue 32-bit) NSNumber ( integerValue 64-bit)	CFNumberRef ( kCFNumberSInt32Type ) CFNumberRef ( kCFNumberSInt64Type )	<integer>
Floating-point value	NSNumber ( floatValue 32-bit) NSNumber ( doubleValue 64-bit)	CFNumberRef ( kCFNumberFloat32Type ) CFNumberRef ( kCFNumberFloat64Type )	<real>
Boolean	NSNumber ( boolValue )	CFBooleanRef	<true/> or <false/>
Mutable versions of the Foundation classes are also supported.

Collectively, instances of these classes are known
as property
list objects. For example, an

NSMutableDictionary

object
is a property list object, as are

NSNumber

object,
an

NSString

object,
and so on. For a property list to be valid, all objects in the
object graph must be property list objects.

Best Practices for Property Lists

You can write property lists out in both XML and binary formats.
The binary format is much more compact than the XML version and
thus more efficient. It is recommended for most situations.
However, you can manually edit an XML property list if you ever
need to. Property list files have the filename extension
of

plist

.

You should not use property lists to store large, complex graphs of
objects, especially when the objects have variable mutability
settings. And you cannot use property lists to store objects that
are not supported by the architecture, such as model objects. For
these cases, use archiving instead. Although property lists can
include

NSData

objects,
it’s best to not use data objects in property lists to hold large
amounts of binary data.

Property List Serialization

To serialize and deserialize property lists, call the appropriate
class methods of the

NSPropertyListSerialization

class
or, if using Core Foundation, the facilities related to
the

CFPropertyListRef

opaque
type. In Cocoa, the serialized output is in the form of
an

NSData

object.
You can therefore use the methods of that class (for
example,

writeToFile:atomically:

)
to write that data to the file system and use the
appropriate

NSData

class
factory memory to read it back into memory. Then, when you
deserialize it, you can specify mutability options for the property
list.

Definitive Discussion

Property List
Programming Guide

Sample Code Projects

People

© 2012 Apple Inc. All Rights Reserved. (Last updated:
2012-02-16)

Did this document help you? Yes It's good,
but... Not
helpful...