Atalhos no Objective-C para concatenar NSStrings

1129

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";
typeoneerror
fonte
4
Gostaria apenas de propor '@ +' como um operador de concatenação. Vou esperar isso na próxima atualização para Objective-C, kthxbai
powerj1984
44
@NicolasMiari Este não é o único recurso que falta ao Objective-C. Existem dezenas de outros. Citando o link publicado por Jordão: "O Objective-C é, para ser franco, uma linguagem primitiva. Compare-a com qualquer linguagem moderna e você rapidamente a achará insuficiente". Concordo. O objetivo C (início dos anos 80) é C (início dos anos 70) com a adição de um tipo de POO muito simples e pouco seguro. Tudo bem, mas comparado com Java ou C #, parece muito antiquado.
jcsahnwaldt disse GoFundMonica 15/08
5
@NicolasMiari: idioma interpretado? C # e Java são linguagens compiladas. Compilado no bytecode, que é compilado novamente no código da máquina.
Joren
3
As coisas estão mudadas agora: Swift (maçã nova língua) é mais simples
Pradeep
6
Em relação à "segurança do tipo", acho que é um problema de estilo. Para alguém vindo de C # / C ++, ter matrizes heterogêneas de objetos de qualquer tipo pode parecer estranho, mas para alguém acostumado a Objective-C / Cocoa, é uma forma de dinamismo e liberdade; é uma vantagem, desde que você saiba o que está fazendo. Gosto praticamente de tudo sobre C que programadores mais jovens
fazem

Respostas:

616

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

Chris Blackwell
fonte
34
Embora a outra opção tenha muitos votos positivos, acho que essa é a melhor resposta se você não souber todas as suas strings na construção. Toda vez que você anexa uma string, você cria muita sobrecarga. O uso de uma sequência mutável remove esse problema.
Eli
22
+1 Concordo com @Eli. Essas geralmente são as melhores soluções. NSArray -componentsJoinedByString pode ser feito em uma única linha muito bem: string = [[NSArray arrayWithObjects: @ "This", "Is", "A", "Test", nil] componentsJoinedByString: @ ""];
Rob Napier
4
+1 para esta resposta. [NSMutableString appendString]é mais amigável que a memória [NSString stringByAppendingStrings].
Pierre-David Belanger
2
@ RobNapier: Agora, com a nova sintaxe literal da matriz, é ainda melhor.
Amogh Talpallikar
27
A [NSString stringWithFormat:@"%@/%@/%@", three, two, one];técnica parece a mais elegante. Deve ser a resposta selecionada.
precisa saber é o seguinte
1129

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;
}
diciu
fonte
8
@pablasso Concordou. O método Util é bastante feio. Se você deseja algo assim, deve ser feito como uma categoria NSString com um nome como + stringByAppendingStrings :. Mesmo uma função direta com um nome como NSStringForAppendedStrings (...) seria melhor que um método estático em uma classe como Util (qualquer coisa com "Util" no nome provavelmente é mal fatorada). A função também é melhor implementada com um NSMutableString e -appendString para evitar a criação de um conjunto ilimitado de NSStrings temporários liberados automaticamente.
Rob Napier
1
Com cordas grandes, isso pode desperdiçar memória. Recomendado é algo mais parecido com o StringBuilder em linguagens de programação reais. Então você pode descobrir quanta memória é necessária antes de começar a acrescentar. A abordagem acima pode ser refatorada para fazer isso. No entanto, seria melhor criar um objeto StringBuilder, pois isso evitaria que o usuário tivesse que acompanhar uma lista de todas as seqüências que elas precisam combinar.
George
Como você importa o Util? esse IDE é frustrante (não é sugerido "importar algo.
Até
stringWithFormat não é apenas muito elegante, é também muito mais poderoso. Você o usa com @ "% @% @" para concatenar duas strings, @ "% @% @% @" para concatenar três strings, mas você pode colocar caracteres extras dentro, imprimir números, reordenar parâmetros, se quiser e assim por diante . A cadeia de formato pode ser localizada, tornando-a dez vezes mais poderosa. A concatenação de cadeias é para iniciantes.
precisa saber é o seguinte
150

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.

Johannes Fahrenkrug
fonte
13
@ CristiBăluță :) Mas isso funciona apenas com literais e não com instâncias NSString criadas dinamicamente.
Johannes Fahrenkrug
9
Na verdade, você não precisa do @s nas cordas após o primeiro. @"I" " really" " enjoy"...
11553 Kevin
Provavelmente, você deve colocar STRINGA e STRINGB entre parênteses, caso contrário, poderá obter resultados estranhos quando a macro for resolvida. #define JOINED (STRINGA STRINGB)
digory doo 30/07/2013
@JohannesFahrenkrug Então por que isso NSString* const SQL_CREATE_TABLE_str = @"CREATE TABLE IF NOT EXISTS " TABLE_NAME @" (...);";não funciona? Estou tendo Expected '@' in programerro :(
Vagif
@ Vagif como é TABLE_NAMEdefinido?
Johannes Fahrenkrug
75

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];
Kyle Clegg
fonte
48

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

Sidd Menon
fonte
Esta é a solução mais simples.
GeneCode
44

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);
}
Palimondo
fonte
20
Eu votei isso um ano atrás porque não é uma resposta muito boa. Para lidar com a concatenação de um grande número de strings, a implementação do Palimondo requer a implementação de um grande número de métodos de aparência muito semelhantes ou a chamada dos métodos várias vezes, resultando em um grande pedaço de código que basicamente concatena as strings. Usando essa abordagem, você não obtém nenhum benefício em relação a um simples stringWithFormat:. Sem mencionar a falta de parâmetros nomeados que não são apenas fora do padrão, mas também confusos.
FreeAsInBeer 26/03
2
O autor original mencionou stringByAppendingStringe nunca disse nada sobre o uso de mais de dois argumentos. Eu gosto desta resposta melhor do que a aceita. É bem esperto.
Sudo
32

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."];
Taimur Ajmal
fonte
34
Você percebe que está sugerindo exatamente o que ele queria não fazer, certo?
SilverSideDown
tanto vazamento!
RamGrg 6/02
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:@""]

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:@""];
EthanB
fonte
2
Não checo essa pergunta há algum tempo, mas estou inclinado a aceitar isso como a resposta certa depois de todos esses anos!
precisa saber é o seguinte
1
Isso também tem um comportamento melhor do que -[NSString stringByAppendingString:]neste caso de uso - com o primeiro, você receberá uma exceção se o argumento for, nilmas não se o receptor for. Portanto, é possível que haja 50% de chance de um erro no alimentador de cordas falhando silenciosamente e 50% em uma exceção. Com stringConcatvocê, uma exceção garantida em qualquer nillugar da lista. Que pelo menos é mais previsível.
Tommy
27

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>"
};
FreeAsInBeer
fonte
Para um objetivo-c noob, você pode explicar o que esta sintaxe está fazendo? Isso está criando uma matriz de strings e juntando-as de alguma forma? Uma referência a qualquer documento também seria legal.
Norman H
2
@ NormanH: Na verdade, isso faz parte da linguagem C. Depois de um pouco de escavação, consegui encontrar isso . Ele afirma na fase "Concatenação de cadeia": todas as literais de cadeia adjacente e de cadeia ampla são concatenadas. Por exemplo, "String" "concatenação" se torna "Concatenação de String".
FreeAsInBeer
27

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.

etarion
fonte
Legal! Eu ainda acho que o Util acima é uma solução muito mais elegante; você pode anexar apenas uma string com essa macro, certo?
Typeoneerror 18/07/09
1
Verdadeiro, a macro AS acima faz um acréscimo por linha de código. Se vários anexos forem uma necessidade comum, mais macros poderão ser criadas. Por exemplo, uma macro para anexar duas cadeias de caracteres: <pre> #define A2S (A, B, C) [[(A) stringByAppendingString: (B)] stringByAppendingString: (C)] </pre>
2
Ou simplesmente reduza a digitação necessária com uma macro como "#define AS stringByAppendingString" e use "AS" onde você normalmente digitaria "stringByAppendingString" e desfrute de vários anexos por linha de código.
15
O problema com essas macros é que elas comprometem um dos principais objetivos do Objective-C, que é a legibilidade. Não é muito claro o que "AS" faz. Salvar algumas teclas digitadas (a maioria das quais é tratada com preenchimento automático) às custas da legibilidade raramente é uma boa opção. Existem exceções (a sintaxe @ "" é muito mais legível do que ter que usar + stringWithUTF8String: toda vez), mas o objetivo ainda deve ser a legibilidade, e não simplesmente a brevidade. Você escreve uma vez, mas você depura para sempre.
Rob Napier
Oi Rob - Não posso concordar com você nisso. Claro, "AS" é um nome ruim. Deve ser nomeado talvez "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];
coder284
fonte
11

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

NSString * s = [@[@"one ", @"two ", @"three"] componentsJoinedByString:@""];
                  ^^^^^^^ create array ^^^^^
                                               ^^^^^^^ concatenate ^^^^^
justin
fonte
9
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.

Ian Clay
fonte
Você percebe que está sugerindo exatamente o que ele queria não fazer, certo?
Usuário que não é usuário
8

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.


fonte
Você percebe que está sugerindo exatamente o que ele queria não fazer, certo? No mínimo, um #definepoderia ser usado para encurtá-lo.
Usuário que não é usuário
8

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"];
Domingo Ironfoot
fonte
O XCode7 não permitirá mais que você use essa opção - diz "e" é uma palavra reservada. No entanto, você pode usar "cat" em vez disso, para conCATenation. Eu fiz e sua solução funciona perfeitamente e é extremamente simples.
Volomike 28/01
8
NSString *result=[NSString stringWithFormat:@"%@ %@", @"Hello", @"World"];
Gobi M
fonte
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];
aleemb
fonte
6

Eu tentei esse código. funcionou para mim.

NSMutableString * myString=[[NSMutableString alloc]init];
myString=[myString stringByAppendingString:@"first value"];
myString=[myString stringByAppendingString:@"second string"];
Erhan Demirci
fonte
2
Este é o pior abuso de um NSMutableString de todos os tempos. O ponto principal do NSMutableString é que você não precisa de métodos para criar strings liberadas automaticamente, mas pode modificar a própria string.
precisa saber é o seguinte
Aceita. Pelo menos use appendString:se você estiver usando um NSMutableString.
Usuário que não é usuário
6

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"];
Anthony De Souza
fonte
1
... gostaria de ter reputação suficiente para comentar, mas espero que isso ajude outra pessoa.
Anthony De Souza
4

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.

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

Tente stringWithFormat:

NSString *myString = [NSString stringWithFormat:@"%@ %@ %@ %d", "The", "Answer", "Is", 42];
CommanderHK
fonte
Por que isso tem 2 votos negativos? É porque isso já foi mencionado em outra resposta?
Reimius
3

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

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

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];
Uma corrida
fonte
1

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

Volomike
fonte
como fazer isso? por exemplo: sTest3 = sTest1 + sTest2;
@ user285594 Esse era o ponto da pergunta: essa sintaxe não é permitida no Objective-C. Veja as outras respostas.
Usuário que não é usuário
1

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];
}
netshark1000
fonte
0
listOfCatalogIDs =[@[@"id[]=",listOfCatalogIDs] componentsJoinedByString:@""];
user4951
fonte
0

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