When should we use NSString and NSMutableString?

Question

I want when to use NSString , and when we should use NSMutableString , because we can also add a string to NSString, so what is the efficient use of NSMutableString in Objective-C programming?

Answer 1

I expect the MutableString to be a bit more memory efficient, as you indicate at an early stage that the program may need memory dynamically. NSString will probably be allocated a single memory block of the appropriate size.

Using the NSString methods and its stringBy... methods stringBy... you create new objects, freeing the old (if necessary) and creating a new auto object. (Be careful if you are switching from unauthorized to auto-advertising, you may have a release in your dealloc that is no longer needed)

Answer 2

When using NSMutableString you can do without allocation and initialization as follows:

• add line or format
• delete or replace character in string
• insert or replace rows

I think that in this case the memory is only redistributed ( realloc() ), except for free() + alloc() + init in case of using NSString

Answer 3

With NSString, you only create new instances, which means allocating memory for a new instance of the object and losing the old instance is what happens when you add a line to an existing NSString under the hood. NSString should only be used for an object that does not change their value.

With NSMutableString, on the other hand, you only work with one instance of an object - it just mutates the string data it stores. More efficient memory is smarter and faster.

Answer 4

You should use NSString when you need a string as a fixed (immutable) string value and NSMutableString as an editable (mutable) string container (buffer) .

If you're not sure, use NSString first. In most cases, it will provide better overall performance.

Why do I prefer NSString ?

Value

NSString never changes. This means that you can be sure that once made NSString will be the same as forever, no matter what you do on it. This way you can trust a once-validated string value without additional verification. This reduces the complexity of the program and significantly increases the cost.

NSMutableString does not have such a guarantee. After you passed NSMutableString to some function or method, now you cannot find out its current value. Now you need to check or check again.

You may think that you know what will change or not. But for large programs or code in other people, this is difficult to determine. Just using NSString simplifies this, so you will have fewer problems to worry about.

How is NSString more efficient, although it needs to allocate a new object for every row change?

For a general program, in fact, you do not always change lines. In fact, many string values ​​do not need to be changed. You assign or copy strings in the same way as much more. When you copy NSMutableString , it makes an exact copy, and this requires a CPU resource, memory access, memory space. NSString does not require the actual copy operation because it is not copied. This is possible because it cannot be changed (unchanged), so it just reuses itself. Almost not worth it.

And you should have a relatively small piece of code that requires intensive line editing. Use NSMutableString there. Since NSString cannot be changed, it needs to create a new object when you need a new string value. This is an inefficient and almost the only inefficient NSString point.

The only NSMutableString pros are in-place editing support. In other words, when creating a new string value, you do not need to create new objects. Thus, you can save the cost of creating an object if you need to make a lot of changes.

Cocoa, designed to use this separation mutation. You will find that you need to declare @property (copy) instead of @property (strong) so that objects are not affected by any changes elsewhere in the program. NSString very efficient here, unlike NSMutableString , you need to copy it every time.

This is the same for all NS~/NSMutable~ classes.