Raccourcis dans Objective-C pour concaténer des chaînes NSS

Existe-t-il des raccourcis vers stringByAppendingString:la concaténation de chaînes ( ) dans Objective-C, ou des raccourcis pour travailler avecNSString en général?

Par exemple, je voudrais faire:

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

quelque chose de plus comme:

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

Deux réponses auxquelles je peux penser ... ni l'une ni l'autre n'est particulièrement aussi agréable que le simple fait d'avoir un opérateur de concaténation.

Tout d'abord, utilisez un NSMutableString, qui a unappendString méthode, supprimant une partie du besoin de chaînes temporaires supplémentaires.

Deuxièmement, utilisez un NSArraypour concaténer via la componentsJoinedByStringméthode.

Une option:

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

Une autre option:

Je suppose que vous n'êtes pas satisfait des ajouts multiples (a + b + c + d), auquel cas vous pourriez faire:

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

en utilisant quelque chose comme

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

Si vous avez 2 littéraux NSString , vous pouvez également le faire:

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

C'est également utile pour rejoindre #defines:

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

Prendre plaisir.

Je reviens constamment à ce message et finis toujours par trier les réponses pour trouver cette solution simple qui fonctionne avec autant de variables que nécessaire:

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

Par exemple:

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

Créez une méthode:

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

Ensuite, dans la fonction dans laquelle vous en avez besoin, définissez votre chaîne ou champ de texte ou quoi que ce soit sur la valeur de retour de cette fonction.

Ou, pour créer un raccourci, convertissez la chaîne NSString en chaîne C ++ et utilisez le «+» à cet endroit.

Eh bien, comme deux-points est une sorte de symbole spécial, mais fait partie de la signature de la méthode, il est possible d'étendre la NSStringcatégorie with pour ajouter ce style non idiomatique de concaténation de chaînes:

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

Vous pouvez définir autant d'arguments séparés par deux points que vous le jugez utile ... ;-)

Pour une bonne mesure, j'ai également ajouté concat:des arguments variables qui prennent une nilliste terminée de chaînes.

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

Utilisez de stringByAppendingString:cette façon:

NSString *string1, *string2, *result;

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

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

OU

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

Cas de 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 alternative: (si vous souhaitez appliquer un nombre minimum d'arguments)

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

Lors de la création de demandes de services Web, je trouve que faire quelque chose comme ce qui suit est très facile et rend la concaténation lisible dans 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>"
};

Raccourci en créant une macro AppendString (AS) ...

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

NSString * myString = @ "This";

NSString * test = AS (myString, @ "n'est qu'un test");

Remarque:

Si vous utilisez une macro, bien sûr, faites-le simplement avec des arguments variadiques, voir la réponse d'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];

Voici un moyen simple, en utilisant la nouvelle syntaxe littérale du tableau:

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

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

Après quelques années maintenant avec Objective CI, je pense que c'est la meilleure façon de travailler avec Objective C pour atteindre ce que vous essayez d'atteindre.

Commencez à saisir "N" dans votre application Xcode et il se remplit automatiquement sur "NSString". entrez "str" ​​et il se remplit automatiquement par "stringByAppendingString". Les frappes sont donc assez limitées.

Une fois que vous maîtrisez la touche "@" et la tabulation, le processus d'écriture de code lisible ne devient plus un problème. C'est juste une question d'adaptation.

La seule façon de c = [a stringByAppendingString: b]raccourcir le tout est d'utiliser la saisie semi-automatique aux alentours du stpoint. L' +opérateur fait partie de C, qui ne connaît pas les objets Objective-C.

Que diriez-vous de raccourcir stringByAppendingStringet d'utiliser un #define :

#define and stringByAppendingString

Ainsi, vous utiliseriez:

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

Le problème est que cela ne fonctionne que pour deux chaînes, vous devez envelopper des crochets supplémentaires pour plus d'annexes:

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

J'ai essayé ce code. ça a marché pour moi.

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

J'essayais ce qui suit dans le lldbvolet

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

quelles erreurs.

utilisez plutôt alloc et initWithFormatmethod:

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

C'est pour une meilleure journalisation, et une journalisation uniquement - basée sur une excellente méthode à arguments multiples. Je définis une classe Logger et l'appelle comme ceci:

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

Presque bien, sauf qu'il faut mettre fin aux arguments var avec "nil" mais je suppose qu'il n'y a aucun moyen de contourner cela dans 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 

Afin de ne concaténer que des chaînes, je définirais une catégorie sur NSString et y ajouterais une méthode de concaténation statique (+) qui ressemble exactement à la méthode log ci-dessus, sauf qu'elle renvoie la chaîne. C'est sur NSString parce que c'est une méthode de chaîne, et c'est statique parce que vous voulez créer une nouvelle chaîne à partir de chaînes 1-N, ne pas l'appeler sur l'une des chaînes qui font partie de l'ajout.

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

Essayez stringWithFormat:

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

Lorsque je traite souvent des chaînes, je trouve plus facile de créer le fichier source ObjC ++, puis je peux concaténer std :: strings en utilisant la deuxième méthode indiquée dans la question.

std::string stdstr = [nsstr UTF8String];

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

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

Ma méthode préférée est la suivante:

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

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

Vous pouvez y parvenir en ajoutant la méthode join à NSArray avec une catégorie:

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

@[]c'est la définition courte pour NSArray, je pense que c'est la méthode la plus rapide pour concaténer des chaînes.

Si vous ne souhaitez pas utiliser la catégorie, utilisez directement la componentsJoinedByString:méthode:

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

Vous pouvez utiliser NSArray comme

NSString *string1=@"This"

NSString *string2=@"is just"

NSString *string3=@"a test"  

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

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

ou

vous pouvez utiliser

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

L'un ou l'autre de ces formats fonctionne dans XCode7 lorsque j'ai testé:

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

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

Pour une raison quelconque, vous n'avez besoin que du caractère d'opérateur @ sur la première chaîne du mix.

Cependant, cela ne fonctionne pas avec l'insertion de variables. Pour cela, vous pouvez utiliser cette solution extrêmement simple à l'exception de l'utilisation d'une macro sur "chat" au lieu de "et".

Pour tous les amateurs d'Objectif C qui en ont besoin dans un test UI:

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

Imaginons que vous ne connaissiez pas le nombre de cordes.

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