Atajos en Objective-C para concatenar NSStrings

¿Hay atajos para la stringByAppendingString:concatenación de cadenas ( ) en Objective-C o atajos para trabajar NSStringen general?

Por ejemplo, me gustaría hacer:

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

algo mas como:

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

Se me ocurren dos respuestas ... ninguna es tan agradable como tener un operador de concatenación.

En primer lugar, utilice una NSMutableString, que tiene un appendStringmétodo, la eliminación de algunos de la necesidad de cadenas temporales adicionales.

Segundo, use un NSArraypara concatenar a través del componentsJoinedByStringmétodo.

Una opción:

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

Otra opción:

Supongo que no estás contento con múltiples anexos (a + b + c + d), en cuyo caso podrías hacer:

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

usando algo como

+ (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 tiene 2 literales NSString , también puede hacer esto:

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

Eso también es útil para unirse a #defines:

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

Disfrutar.

Sigo volviendo a esta publicación y siempre termino clasificando las respuestas para encontrar esta solución simple que funciona con tantas variables como sea necesario:

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

Por ejemplo:

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

Crea un método:

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

Luego, en cualquier función en la que lo necesite, configure su cadena o campo de texto o lo que sea para el valor de retorno de esta función.

O, para hacer un acceso directo, convierta el NSString en una cadena de C ++ y use el '+' allí.

Bueno, como los dos puntos son una especie de símbolo especial, pero es parte de la firma del método, es posible salir de la NSStringcategoría con para agregar este estilo no idiomático de concatenación de cadenas:

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

Puede definir tantos argumentos separados por dos puntos como considere útil ... ;-)

Para una buena medida, también he agregado concat:argumentos variables que toman una nillista terminada de cadenas.

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

Use de stringByAppendingString:esta manera:

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

Casos de prueba:

- (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: (si desea aplicar un número mínimo de argumentos)

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

Al crear solicitudes de servicios web, encuentro que hacer algo como lo siguiente es muy fácil y hace que la concatenación sea legible en 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>"
};

Atajo creando macro AppendString (AS) ...

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

NSString * myString = @ "Esto";

NSString * test = AS (myString, @ "es solo una prueba");

Nota:

Si usa una macro, por supuesto, hágalo con argumentos variables, vea la respuesta de 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];

Aquí hay una manera simple, utilizando la nueva sintaxis literal de matriz:

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

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

Después de un par de años con Objective CI, creo que esta es la mejor manera de trabajar con Objective C para lograr lo que está tratando de lograr.

Comience a escribir "N" en su aplicación Xcode y se autocompletará a "NSString". introduzca "str" ​​y se autocompletará a "stringByAppendingString". Por lo tanto, las pulsaciones de teclas son bastante limitadas.

Una vez que se acostumbra a presionar la tecla "@" y tabular el proceso de escribir código legible ya no se convierte en un problema. Es solo una cuestión de adaptación.

La única forma de c = [a stringByAppendingString: b]acortar es usar autocompletar alrededor del stpunto. El +operador es parte de C, que no conoce los objetos Objective-C.

¿Qué tal acortar stringByAppendingStringy usar un #define :

#define and stringByAppendingString

Así usarías:

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

El problema es que solo funciona para dos cadenas, debe ajustar corchetes adicionales para más apéndices:

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

Probé este código. Me ha funcionado.

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

Estaba intentando lo siguiente en el lldbpanel

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

que errores

en su lugar use alloc y initWithFormatmétodo:

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

Esto es para un mejor registro, y solo para el registro, basado en un excelente método de argumento múltiple dicius. Defino una clase Logger y la llamo así:

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

Casi bueno, excepto tener que terminar los argumentos de var con "nulo", pero supongo que no hay forma de evitarlo en 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 

Para solo concatenar cadenas, definiría una Categoría en NSString y agregaría un método de concatenación estático (+) que se ve exactamente como el método de registro anterior, excepto que devuelve la cadena. Está en NSString porque es un método de cadena, y es estático porque desea crear una nueva cadena a partir de cadenas 1-N, no invocarla en ninguna de las cadenas que forman parte del anexo.

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

Prueba stringWithFormat:

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

Cuando trato con cadenas a menudo me resulta más fácil hacer el archivo fuente ObjC ++, entonces puedo concatenar cadenas std :: usando el segundo método que se muestra en la pregunta.

std::string stdstr = [nsstr UTF8String];

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

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

Mi método preferido es este:

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

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

Puede lograrlo agregando el método de unión a NSArray con una categoría:

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

@[]es la definición corta de NSArray, creo que este es el método más rápido para concatenar cadenas.

Si no desea usar la categoría, use directamente el componentsJoinedByString:método:

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

Puedes usar NSArray como

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

puedes usar

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

Cualquiera de estos formatos funciona en XCode7 cuando probé:

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

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

Por alguna razón, solo necesita el carácter de operador @ en la primera cadena de la mezcla.

Sin embargo, no funciona con inserción variable. Para eso, puede usar esta solución extremadamente simple con la excepción de usar una macro en "cat" en lugar de "y".

Para todos los amantes del objetivo C que necesitan esto en una prueba de interfaz de usuario:

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

Imaginemos que no sabes cuántas cuerdas hay.

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