NSString 与NSMutableString的区别

 

NSString 与NSMutableString的区别 

 

Suppose You have a code like this

NSString *s = [[NSString alloc] initWithString:@"Hello"];

s = [s stringByAppendingString:@"World"];

 

假如NSString是这样

and other code like this

NSMutableString *ms = [[NSMutableString alloc] initWithString:@"Hello"];



[ms appendString:@"World"];

另一个可变的String是这样。

Both of these, functionally, do the same thing except for one difference - the top code block leaks

-[NSString stringByAppendingString:] generates a new immutable NSString object which you then tell the pointer s to point to.

[NSString stringByAppendingString:]产生一个新的不可变的NSString 对象，而这个对象就是你要的指针要指向的对象。

 

In the process, however, you orphan the NSString object that s originally pointed to. Replacing the line as follows would get rid of the leak:

s = [[s autorelease] stringByAppendingString:@"World"];

 

The difference between NSMutableString and NSString is that

 

NSMutableString: NSMutableString objects provide methods to modify the underlying array of characters they represent, while NSString does not. For example, NSMutableString exposes methods such as appendString, deleteCharactersInRange, insertString,replace Occurrences With String, etc. All these methods operate on the string as it exists in memory.

NSMutalbeString对象提供方法修改他们代表的字符串数组，而NSString不能。例如

NSMutalbeString提供了appendString ,deleteCharactersInRange,insertString ,replace occurrences with String。所有的方法都在 它已经存在的内存上操作

 

NSString: on the other hand only is a create-once-then-read-only string if you will; you'll find that all of its "manipulation" methods (substring, uppercaseString, etc) return other NSString objects and never actually modify the existing string in memory.

NSString :另一方面，NSString是一个创建一次，只读一次。你会发现所有的操作方法(substring,uppercaseString,等)返回另外的NSStirng对象，实际上，从来不会修改已经存在的对象。

 

 

When To Use Mutable Strings

 

Since NSString and NSMutableString provide such similar functionality, it can be hard to know when to use one over the other. In general, the static nature of NSString makes it more efficient for most tasks; however, the fact that an immutable string can’t be changed without generating a new object makes it less than ideal when you’re trying to perform several small edits.

一般情况下使用NSString 可以更有效，然而实际情况是immutable string 如果不是创建一个新的对象的话，就不能做修改。

 

 

 

The two examples presented in this section demonstrate the advantages of mutable strings. First, let’s take a look at an anti-pattern for immutable strings. The following loop generates a string containing all of the numbers between 0 and 999 using NSString.

// DO NOT DO THIS. EVER.
NSString *indices = @"";
for (int i=0; i<1000; i++) {
    indices = [indices stringByAppendingFormat:@"%d", i];
}

 

Remember that stringByAppendingFormat: creates a new NSStringinstance, which means that in each iteration, the entire string gets copied to a new block of memory. The above code allocates 999 string objects that serve only as intermediary values, resulting in an application that requires a whopping 1.76 MB of memory. Needless to say, this is incredibly inefficient.

stringByAppendingFormat:创建一个新的NSString 实例，意味着每次迭代，整个string 都会被拷贝到新的内存空间上去。上面的代码分配了999个string 对象。这开销很大的。

Now, let’s take a look at the mutable version of this snippet:

NSMutableString *indices = [NSMutableString stringWithCapacity:1];
for (int i=0; i<1000; i++) {
    [indices appendFormat:@"%d", i];
}

 

Since mutable strings manipulate their contents in place, no copying is involved, and we completely avoid the 999 unnecessary allocations. Internally, the mutable string’s storage dynamically expands to accommodate longer values. This reduces the memory footprint to around 19 KB, which is much more reasonable.

因为mutable strings 操作他们的内容在原来的位置，不需要拷贝，我们完全避免了不需要的999分配。