Scorciatoie in Objective-C per concatenare le stringhe NSS

Esistono collegamenti a ( stringByAppendingString:) concatenazione di stringhe in Objective-C o collegamenti con cui lavorare NSStringin generale?

Ad esempio, vorrei fare:

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

qualcosa di più simile a:

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

Due risposte che mi vengono in mente ... nessuna delle due è particolarmente piacevole come avere un operatore di concatenazione.

Per prima cosa, usa un NSMutableString, che ha un appendStringmetodo, eliminando la necessità di stringhe di temperatura extra.

In secondo luogo, utilizzare un NSArrayper concatenare tramite il componentsJoinedByStringmetodo.

Un opzione:

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

Un'altra opzione:

Immagino che non sei soddisfatto di più appendi (a + b + c + d), nel qual caso potresti fare:

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

usando qualcosa di simile

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

Se hai 2 letterali NSString , puoi anche fare questo:

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

Questo è utile anche per unirti a #defines:

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

Godere.

Continuo a tornare a questo post e finisco sempre con l'ordinare le risposte per trovare questa semplice soluzione che funziona con tutte le variabili necessarie:

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

Per esempio:

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

Crea un metodo:

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

Quindi, in qualunque funzione ti serva, imposta la stringa o il campo di testo o qualunque cosa sul valore restituito di questa funzione.

Oppure, per creare una scorciatoia, converti NSString in una stringa C ++ e usa il '+' lì.

Bene, poiché i due punti sono una specie di simbolo speciale, ma fanno parte della firma del metodo, è possibile estendere la NSStringcategoria with per aggiungere questo stile non idiomatico di concatenazione di stringhe:

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

Puoi definire quanti argomenti separati da due punti quanti ne ritieni utili ... ;-)

Per una buona misura, ho anche aggiunto concat:con argomenti variabili che accetta l' nilelenco di stringhe terminato.

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

Usa in stringByAppendingString:questo modo:

NSString *string1, *string2, *result;

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

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

O

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

Casi test:

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

Macro alternativa: (se si desidera imporre un numero minimo di argomenti)

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

Quando costruisco richieste per servizi web, trovo che fare qualcosa di simile al seguente sia molto semplice e rende la concatenazione leggibile in 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>"
};

Collegamento creando macro AppendString (AS) ...

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

NSString * myString = @ "Questo";

NSString * test = AS (myString, @ "è solo un test");

Nota:

Se usi una macro, ovviamente fallo solo con argomenti variadici, vedi la risposta di 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];

Ecco un modo semplice, usando la nuova sintassi letterale di array:

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

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

Dopo un paio d'anni con Objective CI, penso che questo sia il modo migliore per lavorare con Objective C per raggiungere ciò che stai cercando di ottenere.

Inizia a digitare "N" nell'applicazione Xcode e si completa automaticamente in "NSString". digitare "str" ​​e si completa automaticamente in "stringByAppendingString". Quindi i tasti sono abbastanza limitati.

Una volta che hai capito di premere il tasto "@" e di eseguire la tabulazione, il processo di scrittura del codice leggibile non diventa più un problema. È solo una questione di adattamento.

L'unico modo per ridurre c = [a stringByAppendingString: b]i tempi è utilizzare il completamento automatico intorno al stpunto. L' +operatore fa parte di C, che non conosce oggetti Objective-C.

Che ne dici di accorciare stringByAppendingStringe usare un #define :

#define and stringByAppendingString

Quindi useresti:

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

Il problema è che funziona solo per due stringhe, è necessario avvolgere parentesi aggiuntive per più aggiunte:

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

Ho provato questo codice. ha funzionato per me.

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

Stava provando quanto segue nel lldbriquadro

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

quali errori.

utilizzare invece alloc e initWithFormatmetodo:

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

Questo serve per una migliore registrazione e registrazione - basata sul metodo a argomento multiplo eccellente dicius. Definisco una classe Logger e la chiamo così:

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

Quasi bene, tranne per il fatto di dover terminare le discussioni con "zero", ma suppongo che non ci sia modo di aggirarlo in 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 

Per soli concat corde, mi piacerebbe definire una categoria sulla NSString e aggiungi un metodo statico (+) concatena ad esso che appare esattamente come il metodo di registro di cui sopra, eccetto che restituisce la stringa. È su NSString perché è un metodo stringa ed è statico perché si desidera creare una nuova stringa da stringhe 1-N, non chiamarla su nessuna delle stringhe che fanno parte dell'appendice.

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

Prova stringWithFormat:

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

Quando ho a che fare con le stringhe spesso trovo più facile rendere il file sorgente ObjC ++, quindi posso concatenare std :: stringhe usando il secondo metodo mostrato nella domanda.

std::string stdstr = [nsstr UTF8String];

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

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

Il mio metodo preferito è questo:

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

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

È possibile ottenerlo aggiungendo il metodo join a NSArray con una categoria:

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

@[] è la definizione breve per NSArray , penso che questo sia il metodo più veloce per concatenare le stringhe.

Se non si desidera utilizzare la categoria, utilizzare direttamente il componentsJoinedByString:metodo:

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

È possibile utilizzare NSArray come

NSString *string1=@"This"

NSString *string2=@"is just"

NSString *string3=@"a test"  

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

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

o

Puoi usare

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

Uno di questi formati funziona in XCode7 quando ho testato:

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

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

Per qualche motivo, è necessario solo il carattere di operatore @ sulla prima stringa del mix.

Tuttavia, non funziona con l'inserimento variabile. Per questo, è possibile utilizzare questa soluzione estremamente semplice, ad eccezione dell'utilizzo di una macro su "gatto" anziché "e".

Per tutti gli amanti dell'obiettivo C che ne hanno bisogno in un test dell'interfaccia utente:

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

Immaginiamo che tu non sappia quante stringhe ci sono.

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