Verknüpfungen in Objective-C zum Verketten von NSStrings

Gibt es Verknüpfungen zur stringByAppendingString:Verkettung von ( ) Zeichenfolgen in Objective-C oder Verknüpfungen zum Arbeiten mitNSString allgemeine ?

Zum Beispiel möchte ich machen:

NSString *myString = @"This";
NSString *test = [myString stringByAppendingString:@" is just a test"];

so etwas wie:

string myString = "This";
string test = myString + " is just a test";

Zwei Antworten, die ich mir vorstellen kann ... keine ist besonders angenehm, als nur einen Verkettungsoperator zu haben.

Verwenden Sie zuerst eine NSMutableString, die eine hatappendString Methode, die zum Teil die Notwendigkeit für zusätzliche temporäre Strings zu entfernen.

Zweitens verwenden Sie eine, NSArrayum über die componentsJoinedByStringMethode zu verketten .

Eine Option:

[NSString stringWithFormat:@"%@/%@/%@", one, two, three];

Andere Option:

Ich vermute, Sie sind mit mehreren Anhängen (a + b + c + d) nicht zufrieden. In diesem Fall könnten Sie Folgendes tun:

NSLog(@"%@", [Util append:one, @" ", two, nil]); // "one two"
NSLog(@"%@", [Util append:three, @"/", two, @"/", one, nil]); // three/two/one

mit so etwas wie

+ (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;
}

Wenn Sie 2 NSString- Literale haben , können Sie dies auch einfach tun:

NSString *joinedFromLiterals = @"ONE " @"MILLION " @"YEARS " @"DUNGEON!!!";

Dies ist auch nützlich, um #defines beizutreten:

#define STRINGA @"Also, I don't know "
#define STRINGB @"where food comes from."
#define JOINED STRINGA STRINGB

Genießen.

Ich kehre immer wieder zu diesem Beitrag zurück und sortiere immer die Antworten, um diese einfache Lösung zu finden, die mit so vielen Variablen wie nötig funktioniert:

[NSString stringWithFormat:@"%@/%@/%@", three, two, one];

Zum Beispiel:

NSString *urlForHttpGet = [NSString stringWithFormat:@"http://example.com/login/username/%@/userid/%i", userName, userId];

Erstellen Sie eine Methode:

- (NSString *)strCat: (NSString *)one: (NSString *)two
{
    NSString *myString;
    myString = [NSString stringWithFormat:@"%@%@", one , two];
    return myString;
}

Setzen Sie dann in der Funktion, in der Sie sie benötigen, Ihre Zeichenfolge oder Ihr Textfeld oder was auch immer auf den Rückgabewert dieser Funktion.

Um eine Verknüpfung zu erstellen, konvertieren Sie den NSString in einen C ++ - String und verwenden Sie dort das '+'.

Nun, wie Kolon Art speziellen Symbol ist, sondern ist Teil der Methodensignatur, ist es möglich, die exted NSStringmit Kategorie dieses hinzufügen nicht-idiomatischen Stil der String - Verkettung:

[@"This " : @"feels " : @"almost like " : @"concatenation with operators"];

Sie können so viele durch Doppelpunkte getrennte Argumente definieren, wie Sie nützlich finden ... ;-)

Für eine gute Maßnahme habe ich auch concat:variable Argumente hinzugefügt , die eine nilterminierte Liste von Zeichenfolgen verwenden.

//  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);
}

Verwenden Sie stringByAppendingString:diesen Weg:

NSString *string1, *string2, *result;

string1 = @"This is ";
string2 = @"my string.";

result = [result stringByAppendingString:string1];
result = [result stringByAppendingString:string2];

ODER

result = [result stringByAppendingString:@"This is "];
result = [result stringByAppendingString:@"my string."];

Makro:

// 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:@""]

Testfälle:

- (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");
}

Alternatives Makro: (wenn Sie eine Mindestanzahl von Argumenten erzwingen möchten)

// 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:@""];

Beim Erstellen von Anforderungen für Webdienste finde ich Folgendes sehr einfach und macht die Verkettung in Xcode lesbar:

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>"
};

Verknüpfung durch Erstellen eines AppendString (AS) -Makros ...

#define AS (A, B) [(A) stringByAppendingString: (B)]

NSString * myString = @ "This";

NSString * test = AS (myString, @ "ist nur ein Test");

Hinweis:

Wenn Sie ein Makro verwenden, tun Sie dies natürlich nur mit verschiedenen Argumenten, siehe EthanBs Antwort.

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];

Hier ist eine einfache Möglichkeit, die neue Array-Literal-Syntax zu verwenden:

NSString * s = [@[@"one ", @"two ", @"three"] componentsJoinedByString:@""];
                  ^^^^^^^ create array ^^^^^
                                               ^^^^^^^ concatenate ^^^^^

NSString *myString = @"This";
NSString *test = [myString stringByAppendingString:@" is just a test"];

Nach ein paar Jahren mit Objective CI ist dies der beste Weg, mit Objective C zusammenzuarbeiten, um das zu erreichen, was Sie erreichen möchten.

Geben Sie in Ihrer Xcode-Anwendung "N" ein und es wird automatisch zu "NSString" vervollständigt. Geben Sie "str" ​​ein und es wird automatisch zu "stringByAppendingString" vervollständigt. Die Tastenanschläge sind also recht begrenzt.

Sobald Sie den Dreh raus haben, die Taste "@" zu drücken und den Vorgang des Schreibens von lesbarem Code zu starten, wird dies kein Problem mehr. Es ist nur eine Frage der Anpassung.

Die einzige Möglichkeit, c = [a stringByAppendingString: b]eine Verkürzung vorzunehmen, besteht darin, die automatische Vervollständigung um den stPunkt herum zu verwenden. Der +Operator ist Teil von C, das keine Kenntnisse über Objective-C-Objekte hat.

Wie wäre es mit einer Verkürzung stringByAppendingStringund Verwendung eines #define :

#define and stringByAppendingString

So würden Sie verwenden:

NSString* myString = [@"Hello " and @"world"];

Das Problem ist, dass es nur für zwei Zeichenfolgen funktioniert. Sie müssen zusätzliche Klammern einschließen, um weitere Anhänge zu erhalten:

NSString* myString = [[@"Hello" and: @" world"] and: @" again"];

NSString *result=[NSString stringWithFormat:@"%@ %@", @"Hello", @"World"];

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];

Ich habe diesen Code ausprobiert. es hat bei mir funktioniert.

NSMutableString * myString=[[NSMutableString alloc]init];
myString=[myString stringByAppendingString:@"first value"];
myString=[myString stringByAppendingString:@"second string"];

Versucht die folgende in der lldbScheibe

[NSString stringWithFormat:@"%@/%@/%@", three, two, one];

welche Fehler.

Verwenden Sie stattdessen alloc und initWithFormatmethod:

[[NSString alloc] initWithFormat:@"%@/%@/%@", @"three", @"two", @"one"];

Dies dient der besseren Protokollierung und nur der Protokollierung - basierend auf der hervorragenden Mehrfachargument-Methode von dicius. Ich definiere eine Logger-Klasse und nenne sie so:

[Logger log: @"foobar ", @" asdads ", theString, nil];

Fast gut, außer dass man die var args mit "nil" beenden muss, aber ich nehme an, dass es in Objective-C keinen Weg daran vorbei gibt.

Logger.h

@interface Logger : NSObject {
}
+ (void) log: (id) first, ...;
@end

Logger.m

@implementation Logger

+ (void) log: (id) first, ...
{
    // TODO: make efficient; handle arguments other than strings
    // thanks to @diciu http://stackoverflow.com/questions/510269/how-do-i-concatenate-strings-in-objective-c
    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);
    }
    NSLog(@"%@", result);
}

@end 

Um nur Zeichenfolgen zu verknüpfen , würde ich eine Kategorie in NSString definieren und eine statische (+) Verkettungsmethode hinzufügen, die genau wie die obige Protokollmethode aussieht, außer dass sie die Zeichenfolge zurückgibt. Es ist auf NSString, weil es eine Zeichenfolgenmethode ist, und es ist statisch, weil Sie eine neue Zeichenfolge aus 1-N-Zeichenfolgen erstellen möchten, und sie nicht für eine der Zeichenfolgen aufrufen, die Teil des Anhangs sind.

NSNumber *lat = [NSNumber numberWithDouble:destinationMapView.camera.target.latitude];
NSNumber *lon = [NSNumber numberWithDouble:destinationMapView.camera.target.longitude];
NSString *DesconCatenated = [NSString stringWithFormat:@"%@|%@",lat,lon];

Versuchen Sie stringWithFormat:

NSString *myString = [NSString stringWithFormat:@"%@ %@ %@ %d", "The", "Answer", "Is", 42];

Wenn ich mich oft mit Strings beschäftige, fällt es mir leichter, die Quelldatei ObjC ++ zu erstellen, dann kann ich std :: strings mit der zweiten in der Frage gezeigten Methode verketten.

std::string stdstr = [nsstr UTF8String];

//easier to read and more portable string manipulation goes here...

NSString* nsstr = [NSString stringWithUTF8String:stdstr.c_str()];

Meine bevorzugte Methode ist folgende:

NSString *firstString = @"foo";
NSString *secondString = @"bar";
NSString *thirdString = @"baz";

NSString *joinedString = [@[firstString, secondString, thirdString] join];

Sie können dies erreichen, indem Sie die Join-Methode mit einer Kategorie zu NSArray hinzufügen:

#import "NSArray+Join.h"
@implementation NSArray (Join)
-(NSString *)join
{
    return [self componentsJoinedByString:@""];
}
@end

@[] es ist die kurze Definition für NSArray , ich denke, dies ist die schnellste Methode, um Zeichenfolgen zu verketten.

Wenn Sie die Kategorie nicht verwenden möchten, verwenden Sie direkt die componentsJoinedByString:Methode:

NSString *joinedString = [@[firstString, secondString, thirdString] componentsJoinedByString:@""];

Sie können NSArray als verwenden

NSString *string1=@"This"

NSString *string2=@"is just"

NSString *string3=@"a test"  

NSArray *myStrings = [[NSArray alloc] initWithObjects:string1, string2, string3,nil];

NSString *fullLengthString = [myStrings componentsJoinedByString:@" "];

oder

Sie können verwenden

NSString *imageFullName=[NSString stringWithFormat:@"%@ %@ %@.", string1,string2,string3];

Jedes dieser Formate funktioniert in XCode7, als ich getestet habe:

NSString *sTest1 = {@"This" " and that" " and one more"};
NSString *sTest2 = {
  @"This"
  " and that"
  " and one more"
};

NSLog(@"\n%@\n\n%@",sTest1,sTest2);

Aus irgendeinem Grund benötigen Sie nur das @ -Operatorzeichen in der ersten Zeichenfolge der Mischung.

Es funktioniert jedoch nicht mit variabler Einfügung. Dafür können Sie diese extrem einfache Lösung verwenden, mit der Ausnahme, dass Sie ein Makro für "cat" anstelle von "und" verwenden.

Für alle Objective C-Liebhaber, die dies in einem UI-Test benötigen:

-(void) clearTextField:(XCUIElement*) textField{

    NSString* currentInput = (NSString*) textField.value;
    NSMutableString* deleteString = [NSMutableString new];

    for(int i = 0; i < currentInput.length; ++i) {
        [deleteString appendString: [NSString stringWithFormat:@"%c", 8]];
    }
    [textField typeText:deleteString];
}

listOfCatalogIDs =[@[@"id[]=",listOfCatalogIDs] componentsJoinedByString:@""];

Stellen wir uns vor, Sie wissen nicht, wie viele Saiten es gibt.

NSMutableArray *arrForStrings = [[NSMutableArray alloc] init];
for (int i=0; i<[allMyStrings count]; i++) {
    NSString *str = [allMyStrings objectAtIndex:i];
    [arrForStrings addObject:str];
}
NSString *readyString = [[arrForStrings mutableCopy] componentsJoinedByString:@", "];