Skróty w celu C do łączenia NSStrings

Czy stringByAppendingString:w Objective-C są jakieś skróty do konkatenacji ciągów znaków ( ) lub skróty do NSStringogólnej pracy z nimi ?

Na przykład chciałbym zrobić:

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

coś więcej jak:

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

Dwie odpowiedzi, o których mogę myśleć ... żadna nie jest tak przyjemna jak posiadanie operatora konkatenacji.

Najpierw użyj metody NSMutableString, która ma appendStringmetodę, eliminując część potrzeby stosowania dodatkowych ciągów temp.

Po drugie, użyj NSArraydo konkatenacji componentsJoinedByStringmetodą.

Opcja:

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

Inna opcja:

Zgaduję, że nie jesteś zadowolony z wielu dodatków (a + b + c + d), w którym to przypadku możesz zrobić:

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

używając czegoś takiego

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

Jeśli masz 2 literały NSString , możesz również po prostu to zrobić:

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

Przydaje się to również przy dołączaniu do #defines:

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

Cieszyć się.

Powracam do tego postu i zawsze kończę sortowanie odpowiedzi, aby znaleźć to proste rozwiązanie, które działa z tyloma zmiennymi, ile potrzeba:

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

Na przykład:

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

Utwórz metodę:

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

Następnie, w dowolnej funkcji, w której jest to potrzebne, ustaw łańcuch lub pole tekstowe lub cokolwiek na wartość zwracaną przez tę funkcję.

Lub, aby utworzyć skrót, przekonwertuj NSString na ciąg C ++ i użyj tam znaku „+”.

Dobrze, że jelita grubego jest rodzajem specjalnym symbolem, ale jest częścią podpisu metodzie możliwe jest exted NSStringz kategorii, aby dodać ten zakaz idiomatyczne styl łańcuchów znaków:

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

Możesz zdefiniować tyle argumentów oddzielonych dwukropkami, ile uznasz za przydatne ... ;-)

Dla pewności dodałem również concat:zmienne argumenty, które pobierają nilzakończoną listę ciągów.

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

Użyj stringByAppendingString:tego sposobu:

NSString *string1, *string2, *result;

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

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

LUB

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

Przypadki testowe:

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

Alternatywne makro: (jeśli chcesz wymusić minimalną liczbę argumentów)

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

Podczas budowania żądań usług internetowych uważam, że wykonanie czegoś takiego jest bardzo łatwe i sprawia, że ​​konkatenacja jest czytelna w 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>"
};

Skrót przez utworzenie makra AppendString (AS) ...

# zdefiniować AS (A, B) [(A) stringByAppendingString: (B)]

NSString * myString = @ "This";

NSString * test = AS (myString, @ „to tylko test”);

Uwaga:

Jeśli używasz makra, oczywiście po prostu rób to z argumentami variadic, zobacz odpowiedź EthanB.

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

Oto prosty sposób, używając nowej składni literału tablicowego:

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

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

Po kilku latach pracy z Objective CI myśl, że jest to najlepszy sposób pracy z Celem C, aby osiągnąć to, co próbujesz osiągnąć.

Zacznij wpisywać „N” w swojej aplikacji Xcode, a automatycznie uzupełni się do „NSString”. wpisz „str” i automatycznie uzupełnia się do „stringByAppendingString”. Więc naciśnięcia klawiszy są dość ograniczone.

Po opanowaniu naciskania klawisza „@” i pisaniu na klawiaturze proces pisania czytelnego kodu nie staje się już problemem. To tylko kwestia dostosowania.

Jedynym sposobem c = [a stringByAppendingString: b]skrócenia jest użycie autouzupełniania w dowolnym stmomencie. +Operator jest częścią C, która nie wie o obiektach Objective-C.

Co powiesz na skrócenie stringByAppendingStringi użycie #define :

#define and stringByAppendingString

Zatem użyłbyś:

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

Problem polega na tym, że działa tylko dla dwóch ciągów, musisz owinąć dodatkowe nawiasy, aby uzyskać więcej dodatków:

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

Próbowałem tego kodu. zadziałało dla mnie.

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

Próbowałem następujące w lldbokienku

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

które błędy.

zamiast tego użyj przydziału i initWithFormatmetody:

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

Ma to na celu lepsze rejestrowanie i rejestrowanie tylko - w oparciu o doskonałą metodę wielu argumentów dicius. Definiuję klasę Logger i nazywam ją tak:

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

Prawie dobrze, z wyjątkiem konieczności kończenia var argumentów na „zero”, ale przypuszczam, że nie ma takiej możliwości w Objective-C.

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 

Aby tylko konkatować łańcuchy, zdefiniowałbym kategorię na NSString i dodałbym do niej statyczną (+) metodę konkatenacji, która wygląda dokładnie tak, jak metoda log powyżej, z tym wyjątkiem, że zwraca łańcuch. Działa na NSString, ponieważ jest to metoda łańcuchowa, i jest statyczna, ponieważ chcesz utworzyć nowy ciąg z ciągów 1-N, a nie wywoływać go na żadnym z ciągów, które są częścią append.

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

Wypróbuj stringWithFormat:

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

Podczas pracy z łańcuchami często łatwiej jest utworzyć plik źródłowy ObjC ++, a następnie mogę połączyć std :: strings przy użyciu drugiej metody przedstawionej w pytaniu.

std::string stdstr = [nsstr UTF8String];

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

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

Moja preferowana metoda to:

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

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

Możesz to osiągnąć, dodając metodę łączenia do NSArray z kategorią:

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

@[] jest to krótka definicja dla NSArray , myślę, że jest to najszybsza metoda łączenia łańcuchów.

Jeśli nie chcesz korzystać z kategorii, użyj bezpośrednio componentsJoinedByString:metody:

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

Możesz użyć NSArray jako

NSString *string1=@"This"

NSString *string2=@"is just"

NSString *string3=@"a test"  

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

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

lub

możesz użyć

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

Każdy z tych formatów działa w XCode7 podczas testowania:

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

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

Z jakiegoś powodu potrzebujesz tylko operatora @ w pierwszym ciągu miksu.

Jednak nie działa przy wstawianiu zmiennych. W tym celu możesz użyć tego niezwykle prostego rozwiązania, z wyjątkiem makra na „cat” zamiast „i”.

Dla wszystkich miłośników Celu C, którzy potrzebują tego w teście interfejsu użytkownika:

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

Wyobraźmy sobie, że nie wiesz, ile tam jest łańcuchów.

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