Există comenzi rapide pentru a (stringByAppendingString:
) concatenarea șirurilor în Objective-C, sau comenzi rapide pentru lucru cu `NSString în general?
De exemplu, am'd place să fac:
NSString *myString = @"This";
NSString *test = [myString stringByAppendingString:@" is just a test"];
ceva mai mult, cum ar fi:
string myString = "This";
string test = myString + " is just a test";
[NSString stringWithFormat:@"%@/%@/%@", one, two, three];
Am'm ghicitul're nu fericit cu multiple adaugă (a+b+c+d), caz în care ai putea face:
NSLog(@"%@", [Util append:one, @" ", two, nil]); // "one two"
NSLog(@"%@", [Util append:three, @"/", two, @"/", one, nil]); // three/two/one
folosind ceva de genul
+ (NSString *) append:(id) first, ...
{
NSString * result = @"";
id eachArg;
va_list alist;
if(first)
{
result = [result stringByAppendingString:first];
va_start(alist, first);
while (eachArg = va_arg(alist, id))
result = [result stringByAppendingString:eachArg];
va_end(alist);
}
return result;
}
Două răspunsuri pot să mă gândesc... nu este nici deosebit de plăcută ca având doar un operator de concatenare.
În primul rând, folosiți o NSMutableString
, care are o appendString
metoda, eliminarea unora dintre nevoia de extra temp siruri de caractere.
Al doilea rând, utilizați un NSArray
a înlănțui prin componentsJoinedByString
metoda.
Dacă aveți 2 NSString literali, puteți, de asemenea, face acest lucru:
NSString *joinedFromLiterals = @"ONE " @"MILLION " @"YEARS " @"DUNGEON!!!";
Ca's, de asemenea, util pentru aderarea la #definește:
#define STRINGA @"Also, I don't know "
#define STRINGB @"where food comes from."
#define JOINED STRINGA STRINGB
Bucurați-vă.
Eu revin la acest post și sfârșesc întotdeauna prin sortarea prin răspunsuri pentru a găsi această soluție simplă, care funcționează cu cât mai multe variabile după cum este necesar:
[NSString stringWithFormat:@"%@/%@/%@", three, two, one];
De exemplu:
NSString *urlForHttpGet = [NSString stringWithFormat:@"http://example.com/login/username/%@/userid/%i", userName, userId];
Ei bine, ca de colon este un fel de simbol special, dar este o parte din semnătura metodă, este posibil să exted la `NSString cu categorie pentru a adăuga acest non-idiomatice stil de concatenare șir:
[@"This " : @"feels " : @"almost like " : @"concatenation with operators"];
Puteți defini cât mai multe colon separate argumente ca veti gasi util... ;-)
Pentru o bună măsură, am'am adăugat, de asemenea, concat:
cu argumente variabile care ia "zero" reziliat listă de siruri de caractere.
// NSString+Concatenation.h
#import <Foundation/Foundation.h>
@interface NSString (Concatenation)
- (NSString *):(NSString *)a;
- (NSString *):(NSString *)a :(NSString *)b;
- (NSString *):(NSString *)a :(NSString *)b :(NSString *)c;
- (NSString *):(NSString *)a :(NSString *)b :(NSString *)c :(NSString *)d;
- (NSString *)concat:(NSString *)strings, ...;
@end
// NSString+Concatenation.m
#import "NSString+Concatenation.h"
@implementation NSString (Concatenation)
- (NSString *):(NSString *)a { return [self stringByAppendingString:a];}
- (NSString *):(NSString *)a :(NSString *)b { return [[self:a]:b];}
- (NSString *):(NSString *)a :(NSString *)b :(NSString *)c
{ return [[[self:a]:b]:c]; }
- (NSString *):(NSString *)a :(NSString *)b :(NSString *)c :(NSString *)d
{ return [[[[self:a]:b]:c]:d];}
- (NSString *)concat:(NSString *)strings, ...
{
va_list args;
va_start(args, strings);
NSString *s;
NSString *con = [self stringByAppendingString:strings];
while((s = va_arg(args, NSString *)))
con = [con stringByAppendingString:s];
va_end(args);
return con;
}
@end
// NSString+ConcatenationTest.h
#import <SenTestingKit/SenTestingKit.h>
#import "NSString+Concatenation.h"
@interface NSString_ConcatenationTest : SenTestCase
@end
// NSString+ConcatenationTest.m
#import "NSString+ConcatenationTest.h"
@implementation NSString_ConcatenationTest
- (void)testSimpleConcatenation
{
STAssertEqualObjects([@"a":@"b"], @"ab", nil);
STAssertEqualObjects([@"a":@"b":@"c"], @"abc", nil);
STAssertEqualObjects([@"a":@"b":@"c":@"d"], @"abcd", nil);
STAssertEqualObjects([@"a":@"b":@"c":@"d":@"e"], @"abcde", nil);
STAssertEqualObjects([@"this " : @"is " : @"string " : @"concatenation"],
@"this is string concatenation", nil);
}
- (void)testVarArgConcatenation
{
NSString *concatenation = [@"a" concat:@"b", nil];
STAssertEqualObjects(concatenation, @"ab", nil);
concatenation = [concatenation concat:@"c", @"d", concatenation, nil];
STAssertEqualObjects(concatenation, @"abcdab", nil);
}
A crea o metoda:
- (NSString *)strCat: (NSString *)one: (NSString *)two
{
NSString *myString;
myString = [NSString stringWithFormat:@"%@%@", one , two];
return myString;
}
Apoi, în ce funcție aveți nevoie de ea în, stabilit string sau un câmp de text sau orice altceva la valoarea returnată de această funcție.
Sau, pentru a face o scurtătură, pentru a converti NSString într-un C++ șir de caractere și de a folosi '+' acolo.
Utilizați acest mod:
NSString *string1, *string2, *result;
string1 = @"This is ";
string2 = @"my string.";
result = [result stringByAppendingString:string1];
result = [result stringByAppendingString:string2];
SAU
result = [result stringByAppendingString:@"This is "];
result = [result stringByAppendingString:@"my string."];
Macro:
// stringConcat(...)
// A shortcut for concatenating strings (or objects' string representations).
// Input: Any number of non-nil NSObjects.
// Output: All arguments concatenated together into a single NSString.
#define stringConcat(...) \
[@[__VA_ARGS__] componentsJoinedByString:@""]
Cazuri De Testare:
- (void)testStringConcat {
NSString *actual;
actual = stringConcat(); //might not make sense, but it's still a valid expression.
STAssertEqualObjects(@"", actual, @"stringConcat");
actual = stringConcat(@"A");
STAssertEqualObjects(@"A", actual, @"stringConcat");
actual = stringConcat(@"A", @"B");
STAssertEqualObjects(@"AB", actual, @"stringConcat");
actual = stringConcat(@"A", @"B", @"C");
STAssertEqualObjects(@"ABC", actual, @"stringConcat");
// works on all NSObjects (not just strings):
actual = stringConcat(@1, @" ", @2, @" ", @3);
STAssertEqualObjects(@"1 2 3", actual, @"stringConcat");
}
Alternativ macro: (dacă ai vrut pentru a impune un număr minim de argumente)
// stringConcat(...)
// A shortcut for concatenating strings (or objects' string representations).
// Input: Two or more non-nil NSObjects.
// Output: All arguments concatenated together into a single NSString.
#define stringConcat(str1, str2, ...) \
[@[ str1, str2, ##__VA_ARGS__] componentsJoinedByString:@""];
Atunci când construirea de facilitati pentru servicii web, aflu că faci ceva de genul următor este foarte ușor și face concatenare poate fi citit în Xcode:
NSString* postBody = {
@"<?xml version=\"1.0\" encoding=\"utf-8\"?>"
@"<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">"
@" <soap:Body>"
@" <WebServiceMethod xmlns=\"\">"
@" <parameter>test</parameter>"
@" </WebServiceMethod>"
@" </soap:Body>"
@"</soap:Envelope>"
};
Scurtătură prin crearea AppendString (CA) macro ...
#defini CA(a,B) [(A) stringByAppendingString:(B)]
NSString *myString = @"Acest";NSString *test = CA(myString,@" este doar un test");
Notă:
Dacă utilizați o macrocomandă, desigur, doar o fac cu variadic argumente, a se vedea EthanB's a răspunde.
NSString *label1 = @"Process Name: ";
NSString *label2 = @"Process Id: ";
NSString *processName = [[NSProcessInfo processInfo] processName];
NSString *processID = [NSString stringWithFormat:@"%d", [[NSProcessInfo processInfo] processIdentifier]];
NSString *testConcat = [NSString stringWithFormat:@"%@ %@ %@ %@", label1, processName, label2, processID];
NSString *myString = @"This";
NSString *test = [myString stringByAppendingString:@" is just a test"];
După un cuplu de ani, cu Obiectiv C cred că acest lucru este cel mai bun mod de a lucra cu Objective C pentru a realiza ceea ce încearcă să realizeze.
Începeți să tastați "N" în Xcode cerere și o completează automat la "NSString". tastați "str" și se completează automat la "stringByAppendingString". Deci intrarile de la tastatura sunt destul de limitate.
Odată ce te obișnuiești de a lovi "@" cheie și tab procesul de a scrie cod care poate fi citit nu mai devine o problemă. Este doar o chestiune de adaptare.
Cât despre scurtarea stringByAppendingString
și de a folosi o #define:
#define and stringByAppendingString
Astfel le-ar folosi:
NSString* myString = [@"Hello " and @"world"];
Problema este că funcționează doar pentru două șiruri, ai're este necesar să-și încheie paranteze suplimentare pentru mai adaugă:
NSString* myString = [[@"Hello" and: @" world"] and: @" again"];
NSString *label1 = @"Process Name: ";
NSString *label2 = @"Process Id: ";
NSString *processName = [[NSProcessInfo processInfo] processName];
NSString *processID = [NSString stringWithFormat:@"%d", [[NSProcessInfo processInfo] processIdentifier]];
NSString *testConcat = [NSString stringWithFormat:@"%@ %@ %@ %@", label1, processName, label2, processID];
A fost încercarea de a urma în lldb
panou
[NSString stringWithFormat:@"%@/%@/%@", three, two, one];
care erori.
în loc să utilizați alloc și initWithFormat
metoda:
[[NSString alloc] initWithFormat:@"%@/%@/%@", @"three", @"two", @"one"];
NSNumber *lat = [NSNumber numberWithDouble:destinationMapView.camera.target.latitude];
NSNumber *lon = [NSNumber numberWithDouble:destinationMapView.camera.target.longitude];
NSString *DesconCatenated = [NSString stringWithFormat:@"%@|%@",lat,lon];