I'm trying to append and programmatically modify a NSString on the fly. I'd like to know a couple of things:
How do I modify specific chars in a defined NSString?
How do I add chars in a defined NSString?
For example if I have the following defined: NSString *word = [[NSString alloc] initWithString:#"Hello"]; how would I be able to replace the letter "e" with "a" and also how would I add another char to the string itself?
Nerver use NSString for string manipulation,Use NSMutableString.
NSMutableString is the subclass of NSString and used for that purpose.
From Apple Documentation:
The NSString class declares the programmatic interface for an object that manages immutable strings. (An immutable string is a text string that is defined when it is created and subsequently cannot be changed. NSString is implemented to represent an array of Unicode characters (in other words, a text string).
The mutable subclass of NSString is NSMutableString.
NSMutableString *word = [[NSMutableString alloc] initWithString:#"Hello"];
//Replace a character
NSString* word2 = [word stringByReplacingOccurrencesOfString:#"e" withString:#"a"];
[word release];
word = nil ;
word = [[NSMutableString alloc] initWithString:word2 ];
//Append a Character
[word appendString:#"a"];
There are more string manipulating function See Apple Documentation for NSMutableString
Edited:
you could first use rangeOfString to get the range of the string (in your case #"e").
- (NSRange)rangeOfString:(NSString *)aString options:(NSStringCompareOptions)mask
then check the NSRange object if it's valid then use the replaceCharactersInRange function on your NSMutableString to replace the set of characters with your string.
- (void)replaceCharactersInRange:(NSRange)aRange withString:(NSString *)aString
NSString instances are immutable. You can create new NSString instances by appending or replacing characters in another like this:
NSString *foo = #"Foo";
NSString *bar = #"Bar";
NSString *foobar = [foo stringByAppendingString:bar];
NSString *baz = [bar stringByReplacingOccurrencesOfString:#"r" withString:#"z"];
If you really need to modify an instance directly, you can use an NSMutableString instead of an NSString.
If you really want to use primitive characters, NSString has a couple of initializers that can take character arrays (e.g. initWithCharacters:length:).
First things first:
If you are going to modify an string, you have to use NSMutableString. NSStrings can't be modified, hence they have a modifiable companion.
Then, NSMutableString has two methods that you are going to find helpful:
replaceCharactersInRange:withString
deleteCharactersInRange:
(Sorry for not linking directly to those method's links. StackOverflow if always imposing limitations to me as a new user...).
Just to add, NSMutableString has a method called appendFormat, which can be of great help when appending stuff:
[str appendFormat:#"%#-%#-%#", #"1", #"2",#"3"]
will append "1-2-3" to to str
Related
NSMutableString *chars=[ [NSMutableString alloc] initWithString:#""] ;
NSString *temp=[[self convertDecimalToChar:(digitizer%10)] copy]; //temp is good
[chars stringByAppendingString:temp]; //chars is empty
Any idea whats wrong here ?
Thank you.
This line:
[chars stringByAppendingString:temp];
Is supossed to return a string combining both strings.
- (NSString *)stringByAppendingString:(NSString *)aString
If you want to just append a string to your string, do this:
[chars appendString:temp];
Find the documentation here:
NSmutableString
The stringByAppendingString method is on the non-mutable NSString class, where non-mutable means you cannot modify it.
Therefore, as with most other NSString methods, it returns a new NSString object, in this case containing the original string plus whatever you passed in the parameter.
However given you are actually manipulating an NSMutableString object, which is mutable, you probably want the appendString: method instead:
[chars appendString:temp];
If you take a look at the documentation of this method, you need to do:
chars = [chars stringByAppendingString:temp];
It is returning a new NSString combining the two NSString, not actually changing the receiver.
I'm studying Objective-C. Can you tell me what is the difference (if any) between these NSString declarations?
NSString *firstString;
firstString = #"First string";
NSString *secondString = [NSString string];
secondString = #"Second string";
The second one creates two strings, and throws the first one away without using it. In this line:
NSString *secondString = [NSString string];
you are creating a new string, which isn't really useful because it's empty, and you're assigning it to secondString. Then you're assigning a different string (#"Second String") to secondString.
There's no need to do this. In either case, you can just write:
NSString *myString = #"MyString";
The syntax #"Some string here" is called a string literal, and it's a shorthand for specifying an NSString with an actual value in your code.
No difference as the end result.
The first string is being declared and then assigned a value via the string literal syntax (you can also do this with NSNumbers as of Xcode 4.4).
The second is being initialised as a string (empty) and then is being assigned another NSString object. In this case there are actually two NSString objects being created, the former - [NSString string] is being overwritten by the latter #"string value"
So, the first one is nil to start with and then has a value. The second had a instantiated NSString object to start and was then overwritten.
In the end both string objects are the same, but obviously you are wasting resources in the second case.
For example I'd like to replace all occurrences of #"a" and #"b" in #"abcdabcd" with #"z". I'm currently doing this with repeated called to stringByReplacingOccurencesOfString:withString::
NSString *s1 = #"abcdabcd";
NSString *s2 = [[s1 stringByReplacingOccurencesOfString:#"a" withString:#"z"]
stringByReplacingOccurencesOfString:#"b" withString:#"z"];
What's a better way? I didn't find any similar methods that take an array of strings to replace.
You can use regular expressions:
NSString *s2 =
[s1 stringByReplacingOccurrencesOfString:#"[ab]"
withString:#"z"
options:NSRegularExpressionSearch
range:NSMakeRange(0, s1.length)];
There's also NSMutableString's replaceOccurrencesOfString:withString:options:range: method (so you don't have to create a new NSString object for every replacement call you want to make). Documentation linked for you.
NSString *string = #"HELLO";
For some reason, XCode won't auto-complete methods like remove characters or append etc... If that's the case, how can I, say, remove certain characters from my string? Say I want to remove all the L's.
NSString doesn't respond to those methods. NSMutableString does, but you've declared an immutable string variable and assigned to it a string literal. Since an Objective-C #"string literal" is always immutable (an instance of NSString but not NSMutableString), there's no way those messages can be sent to the object you're using.
If you want a mutable string, try:
NSMutableString *mutableString = [[#"HELLO" mutableCopy] autorelease];
That's an immutable string literal.
Here is a great post explaining it in further details:
What's the difference between a string constant and a string literal?
As for your question on how would you change it and remove the Ls:
NSString *hello = #"HELLO";
NSString *subString = [hello stringByReplacingOccurrencesOfString:#"L" withString:#""];
NSLog(#"subString: %#", subString);
That outputs "HEO"
Either that or you can create an NSMutableString by creating a copy of the mutable string like Jonathan mentioned. In both examples, you're copying it into a non-literal string.
I have an NSString and fail to apply the following statement:
NSString *myString = #"some text";
[myString stringByAppendingFormat:#"some text = %d", 3];
no log or error, the string just doesn't get changed. I already tried with NSString (as documented) and NSMutableString.
any clues most welcome.
I would suggest correcting to (documentation):
NSString *myString = #"some text";
myString = [myString stringByAppendingFormat:#" = %d", 3];
From the docs:
Returns a string made by appending to the receiver a string constructed from a given format string and the following arguments.
It's working, you're just ignoring the return value, which is the string with the appended format. (See the docs.) You can't modify an NSString — to modify an NSMutableString, use -appendFormat: instead.
Of course, in your toy example, you could shorten it to this:
NSString *myString = [NSString stringWithFormat:#"some text = %d", 3];
However, it's likely that you need to append a format string to an existing string created elsewhere. In that case, and particularly if you're appending multiple parts, it's good to think about and balance the pros and cons of using a mutable string or several immutable, autoreleased strings.
Creating strings with #"" always results in immutable strings. If you want to create a new NSMutableString do it as following.
NSMutableString *myString = [NSMutableString stringWithString:#"some text"];
[myString appendFormat:#"some text = %d", 3];
I had a similar warning message while appending a localized string. This is how I resolved it
NSString *msgBody = [msgBody stringByAppendingFormat:#"%#",NSLocalizedString(#"LOCALSTRINGMSG",#"Message Body")];