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


1129

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

4
Je voudrais juste proposer '@ +' comme opérateur de concaténation. Je m'attendrai à cela dans la prochaine mise à jour d'Objective-C, kthxbai
powerj1984

44
@NicolasMiari Ce n'est pas la seule fonctionnalité qui manque à Objective-C. Il y en a des dizaines d'autres. Citant le lien que Jordão a posté: "Objective-C est, pour être franc, un langage primitif. Comparez-le à n'importe quel langage moderne et vous le trouverez rapidement manquant." Je suis d'accord. Objective-C (début des années 1980) est C (début des années 1970) avec l'ajout d'un type de POO très simple et peu sûr. C'est bon, mais par rapport à Java ou C #, cela semble très démodé.
jcsahnwaldt dit GoFundMonica

5
@NicolasMiari: Langage interprété? C # et Java sont des langages compilés. Compilé en bytecode, qui est ensuite compilé à nouveau en code machine.
Joren

3
Les choses ont changé maintenant: Swift (Apple nouvelle langue) est plus simple
Pradeep

6
En ce qui concerne la "sécurité de type", je pense que c'est un problème de style. Pour quelqu'un venant de C # / C ++, avoir des tableaux hétérogènes d'objets de tout type peut sembler étrange, mais pour quelqu'un habitué à Objective-C / Cocoa, c'est une forme de dynamisme et de liberté; c'est un avantage à condition de savoir ce que vous faites. Comme à peu près tout sur C que les programmeurs plus jeunes dénigrent ces jours-ci ...
Nicolas Miari

Réponses:


616

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.


34
Bien que l'autre option ait beaucoup de votes positifs, je pense que c'est la meilleure réponse si vous ne connaissez pas toutes vos chaînes lors de la construction. Chaque fois que vous ajoutez une chaîne, vous créez beaucoup de surcharge. L'utilisation d'une chaîne modifiable supprime ce problème.
Eli

22
+1 D'accord avec @Eli. Ce sont généralement les meilleures solutions. NSArray -componentsJoinedByString peut être fait sur une seule ligne assez bien: string = [[NSArray arrayWithObjects: @ "This", "Is", "A", "Test", nil] componentsJoinedByString: @ ""];
Rob Napier

4
+1 pour cette réponse. [NSMutableString appendString]est plus convivial que la mémoire [NSString stringByAppendingStrings].
Pierre-David Belanger

2
@RobNapier: Maintenant, avec la nouvelle syntaxe littérale du tableau, c'est encore mieux.
Amogh Talpallikar

27
La [NSString stringWithFormat:@"%@/%@/%@", three, two, one];technique semble la plus élégante. Ce devrait être la réponse choisie.
ekillaby

1129

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

8
@pablasso D'accord. La méthode Util est assez moche. Si vous vouliez une telle chose, cela devrait être fait comme une catégorie NSString avec un nom comme + stringByAppendingStrings :. Même une fonction directe avec un nom comme NSStringForAppendedStrings (...) serait meilleure qu'une méthode statique dans une classe comme Util (tout ce qui a "Util" dans le nom est probablement mal factorisé). La fonction est également mieux implémentée avec un NSMutableString et -appendString pour éviter de créer un ensemble illimité de NSStrings temporaires libérés automatiquement.
Rob Napier

1
Avec de grandes cordes, cela peut perdre de la mémoire. Recommandé est quelque chose de plus comme StringBuilder dans de vrais langages de programmation. Ensuite, vous pouvez simplement déterminer la quantité de mémoire nécessaire avant de commencer à ajouter. L'approche ci-dessus pourrait être refactorisée pour ce faire. Cependant, il serait préférable de créer un objet StringBuilder car cela éviterait à l'utilisateur d'avoir à garder une trace de la liste de toutes les chaînes dont ils ont besoin combinés.
George

comment importez-vous Util? cet IDE est frustrant (aucune suggestion "d'importer quelque chose
Utile

stringWithFormat est non seulement très élégant, mais aussi beaucoup plus puissant. Vous l'utilisez avec @ "% @% @" pour concaténer deux chaînes, @ "% @% @% @" pour concaténer trois chaînes, mais vous pouvez mettre des caractères supplémentaires à l'intérieur, imprimer des nombres, réorganiser les paramètres si vous le souhaitez, etc. . La chaîne de format peut être localisée, ce qui la rend dix fois plus puissante. La concaténation de chaînes est destinée aux débutants.
gnasher729

150

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.


13
@ CristiBăluță :) Mais cela ne fonctionne qu'avec des littéraux et non avec des instances NSString créées dynamiquement.
Johannes Fahrenkrug

9
En fait, vous n'avez pas besoin des @s sur les cordes après le premier. @"I" " really" " enjoy"...
Kevin

Vous devriez probablement vouloir mettre STRINGA et STRINGB entre parenthèses, sinon vous pourriez obtenir des résultats étranges lorsque la macro est résolue. #define JOINED (STRINGA STRINGB)
digory doo

@JohannesFahrenkrug Alors pourquoi ça NSString* const SQL_CREATE_TABLE_str = @"CREATE TABLE IF NOT EXISTS " TABLE_NAME @" (...);";ne marche pas? J'ai une Expected '@' in programerreur :(
Vagif

@Vagif comment est TABLE_NAMEdéfini?
Johannes Fahrenkrug

75

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

48

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.


C'est la solution la plus simple.
GeneCode

44

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

20
J'ai rétrogradé cela il y a un an parce que ce n'est pas une très bonne réponse. Pour faire face à la concaténation d'un grand nombre de chaînes, l'implémentation de Palimondo nécessite soit d'implémenter un grand nombre de méthodes très similaires, soit d'appeler les méthodes plusieurs fois, résultant en un gros morceau de code qui concatène simplement les chaînes. En utilisant cette approche, vous n'obtenez aucun avantage par rapport à un simple stringWithFormat:. Sans parler du manque de paramètres nommés qui est non seulement non standard mais aussi déroutant.
FreeAsInBeer

2
Le demandeur d'origine l'a mentionné stringByAppendingString, et il n'a jamais dit qu'il fallait utiliser plus de deux arguments. J'aime mieux cette réponse que celle acceptée. C'est assez intelligent.
sudo

32

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

34
Vous vous rendez compte que vous suggérez la chose exacte qu'il ne voulait pas faire, non?
SilverSideDown

tellement de fuites!
RamGrg

30

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

2
Je n'ai pas vérifié cette question depuis un moment, mais je penche pour l'accepter comme la bonne réponse après toutes ces années!
typeoneerror

1
Cela a également sans doute un meilleur comportement que -[NSString stringByAppendingString:]pour ce cas d'utilisation - avec le premier, vous obtiendrez une exception si l'argument l'est, nilmais pas si le récepteur l'est. Il est donc concevable de 50% de chance sur une erreur dans votre chargeur de chaîne échouant silencieusement et de 50% sur une exception. Avec stringConcatvous est garanti une exception sur tout nil, n'importe où dans la liste. Ce qui au moins est plus prévisible.
Tommy

27

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

Pour un noob objectif-c, pouvez-vous expliquer ce que fait cette syntaxe? Est-ce que cela crée un tableau de chaînes et les rejoint quelque part? Une référence à n'importe quel document serait cool aussi.
Norman H

2
@NormanH: Cela fait en fait partie du langage C. Après un peu de creuser, j'ai pu trouver ce . Il indique sous la phase de "concaténation de chaîne": tous les littéraux de chaîne et de chaîne large adjacents sont concaténés. Par exemple, "String" "concaténation" devient "String concatenation".
FreeAsInBeer

27

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.


Cool! Je pense toujours que l'Util ci-dessus est une solution beaucoup plus élégante; vous ne pouvez ajouter qu'une seule chaîne avec cette macro, non?
typeoneerror

1
Vrai, la macro AS ci-dessus ajoute un par ligne de code. Si plusieurs ajouts sont un besoin commun, davantage de macros peuvent être créées. Par exemple, une macro pour ajouter deux chaînes: <pre> #define A2S (A, B, C) [[(A) stringByAppendingString: (B)] stringByAppendingString: (C)] </pre>

2
Ou, raccourcissez simplement la saisie requise avec une macro comme "#define AS stringByAppendingString", puis utilisez simplement "AS" où votre taperait normalement "stringByAppendingString", et profitez de plusieurs ajouts par ligne de code.

15
Le problème avec ces macros est qu'elles sapent l'un des principaux objectifs d'Objective-C, qui est la lisibilité. Il est extrêmement difficile de savoir ce que fait "AS". L'enregistrement de quelques frappes (dont la plupart sont traitées avec la saisie semi-automatique) au détriment de la lisibilité est rarement un bon compromis. Il existe des exceptions (la syntaxe @ "" est beaucoup plus lisible que d'avoir à utiliser + stringWithUTF8String: à chaque fois), mais l'objectif devrait toujours être la lisibilité plutôt que la simple concision. Vous écrivez une fois, mais vous déboguez pour toujours.
Rob Napier

Salut Rob - Je ne peux pas être d'accord avec toi là-dessus. Bien sûr, "AS" est un mauvais nom. Il devrait être nommé peut-être "CAT".
Fattie

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

11

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

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

9
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.


Vous vous rendez compte que vous suggérez la chose exacte qu'il ne voulait pas faire, non?
Utilisateur qui n'est pas un utilisateur le

8

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.


Vous vous rendez compte que vous suggérez la chose exacte qu'il ne voulait pas faire, non? À tout le moins, un #definepourrait être utilisé pour le raccourcir.
Utilisateur qui n'est pas un utilisateur

8

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

XCode7 ne vous permettra plus d'utiliser cette option - dit "et" est un mot réservé. Cependant, vous pouvez utiliser "cat" à la place, pour conCATenation. Je l'ai fait et votre solution fonctionne parfaitement et est extrêmement simple.
Volomike

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

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

6

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

2
Il s'agit de la pire utilisation abusive d'une chaîne NSMutableString. L'intérêt de NSMutableString est que vous n'avez pas besoin de méthodes pour créer des chaînes publiées automatiquement, mais pouvez modifier la chaîne elle-même.
gnasher729

Se mettre d'accord. Utilisez au moins appendString:si vous utilisez un NSMutableString.
Utilisateur qui n'est pas un utilisateur

6

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

1
... j'aurais assez de réputation pour commenter mais j'espère que cela aidera quelqu'un d'autre.
Anthony De Souza

4

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.


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

3

Essayez stringWithFormat:

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

Pourquoi cela a-t-il 2 downvotes? Est-ce parce que cela a déjà été mentionné dans une autre réponse?
Reimius

3

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

3

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

3

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

1

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".


comment faire ça? par exemple: sTest3 = sTest1 + sTest2;

@ user285594 C'était le point de la question: cette syntaxe n'est pas autorisée dans Objective-C. Voir les autres réponses.
Utilisateur qui n'est pas un utilisateur

1

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

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

0

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:@", "];
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.