Atalhos no Objective-C para concatenar NSStrings

Existem atalhos para stringByAppendingString:concatenação de strings ( ) no Objective-C ou atalhos para trabalhar NSStringem geral?

Por exemplo, eu gostaria de fazer:

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

algo mais como:

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

Duas respostas em que consigo pensar ... nenhuma delas é tão agradável quanto ter apenas um operador de concatenação.

Primeiro, use an NSMutableString, que possui um appendStringmétodo, removendo parte da necessidade de seqüências de caracteres extras de temperatura.

Segundo, use um NSArraypara concatenar através do componentsJoinedByStringmétodo

Uma opção:

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

Outra opção:

Suponho que você não esteja satisfeito com vários anexos (a + b + c + d). Nesse caso, você pode fazer:

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

Se você possui 2 literais NSString , também pode fazer isso:

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

Isso também é útil para ingressar em #defines:

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

Aproveitar.

Continuo retornando a este post e sempre acabo classificando as respostas para encontrar essa solução simples que funciona com quantas variáveis ​​forem necessárias:

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

Por exemplo:

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

Crie um método:

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

Então, em qualquer função que você precisar, configure sua string ou campo de texto ou o valor de retorno dessa função.

Ou, para criar um atalho, converta o NSString em uma string C ++ e use o '+' lá.

Bem, como dois pontos é uma espécie de símbolo especial, mas faz parte da assinatura do método, é possível estender a NSStringcategoria with para adicionar esse estilo não-idiomático de concatenação de strings:

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

Você pode definir quantos argumentos separados por dois pontos achar úteis ... ;-)

Para uma boa medida, também adicionei concat:argumentos variáveis ​​que levam a nillista terminada de strings.

//  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 stringByAppendingString:desta maneira:

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

Casos de teste:

- (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 você deseja impor um 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:@""];

Ao criar solicitações de serviços da web, acho que fazer algo como o seguinte é muito fácil e torna a concatenação legível no 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>"
};

Atalho criando a macro AppendString (AS) ...

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

NSString * myString = @ "Isto";

NSString * test = AS (myString, @ "é apenas um teste");

Nota:

Se estiver usando uma macro, é claro que apenas faça isso com argumentos variados, veja a resposta do 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];

Aqui está uma maneira simples, usando a nova sintaxe literal da matriz:

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

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

Depois de alguns anos com o Objective CI, pense que esta é a melhor maneira de trabalhar com o Objective C para alcançar o que você está tentando alcançar.

Comece digitando "N" no seu aplicativo Xcode e ele será concluído automaticamente como "NSString". digite "str" ​​e é preenchido automaticamente como "stringByAppendingString". Portanto, as teclas são bastante limitadas.

Depois de pressionar a tecla "@" e tabular o processo de escrever código legível, não se torna mais um problema. É apenas uma questão de adaptação.

A única maneira de c = [a stringByAppendingString: b]diminuir é usar o preenchimento automático em torno do stponto. O +operador faz parte de C, que não conhece objetos Objective-C.

Que tal encurtar stringByAppendingStringe usar um #define :

#define and stringByAppendingString

Assim, você usaria:

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

O problema é que ele funciona apenas para duas cadeias, você precisa agrupar colchetes adicionais para mais anexos:

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

Eu tentei esse código. funcionou para mim.

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

Estava tentando o seguinte no lldbpainel

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

quais erros.

em vez disso, use o initWithFormatmétodo e a atribuição :

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

Isso é para melhor registro e registro apenas - com base no excelente método de múltiplos argumentos da dicius. Eu defino uma classe Logger e chamo-a assim:

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

Quase bom, exceto ter que terminar os argumentos com "nil", mas suponho que não há como contornar isso no 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 concatear apenas as seqüências de caracteres, eu definiria uma categoria no NSString e adicionaria um método estático (+) concatenado a ele que se parece exatamente com o método de log acima, exceto que ele retorna a sequência. Está no NSString porque é um método de sequência e é estático porque você deseja criar uma nova sequência a partir de seqüências 1-N, não a chame em nenhuma das sequências que fazem parte do anexo.

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

Tente stringWithFormat:

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

Ao lidar com strings com frequência, acho mais fácil tornar o arquivo de origem ObjC ++, então posso concatenar std :: strings usando o segundo método mostrado na pergunta.

std::string stdstr = [nsstr UTF8String];

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

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

Meu método preferido é o seguinte:

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

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

Você pode conseguir isso adicionando o método join ao NSArray com uma categoria:

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

@[] é a definição curta para NSArray , acho que esse é o método mais rápido para concatenar strings.

Se você não quiser usar a categoria, use diretamente o componentsJoinedByString:método:

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

Você pode usar o 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:@" "];

ou

você pode usar

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

Um desses formatos funciona no XCode7 quando eu testei:

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

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

Por alguma razão, você só precisa do caractere @ operator na primeira sequência do mix.

No entanto, ele não funciona com inserção de variável. Para isso, você pode usar esta solução extremamente simples, com a exceção de usar uma macro em "gato" em vez de "e".

Para todos os amantes de Objective C que precisam disso em um teste de interface do usuário:

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

Vamos imaginar que você não sabe quantas cordas lá.

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