Atalhos no Objective-C para concatenar NSStrings

Existem atalhos para ( stringByAppendingString: concatenação de strings em Objective-C, ou atalhos para trabalhar com NSString em geral?

Por exemplo, gostaria de fazer:

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

algo mais parecido com:

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

Duas respostas que eu posso pensar … nem é particularmente tão agradável quanto ter apenas um operador de concatenação.

Primeiro, use um NSMutableString , que possui um método appendString , removendo um pouco da necessidade de strings temp extras.

Segundo, use um NSArray para concatenar por meio do método componentsJoinedByString .

Uma opção:

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

Outra opção:

Eu estou supondo que você não está feliz com vários anexos (a + b + c + d), caso em que você poderia 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ê tem 2 literais NSString, também pode fazer isso:

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

Isso também é útil para se juntar a #defines:

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

Apreciar.

Eu continuo voltando a este post e sempre acabo classificando as respostas para encontrar essa solução simples que funciona com quantas variables ​​forem necessárias:

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

Por exemplo:

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

Bem, como dois pontos é um tipo de símbolo especial, mas é parte da assinatura do método, é possível extingir a NSString com categoria para adicionar este estilo não-idiomático de concatenação de string:

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

Você pode definir quantos argumentos separados por dois pontos você achar útil … 😉

Por uma boa medida, eu também adicionei concat: com argumentos variables ​​que leva uma lista de strings terminada nil .

 // NSString+Concatenation.h #import  @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  #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); } 

crie um método ……

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

Em seguida, em qualquer function que você precisar, defina sua string ou campo de textfield ou o que quer que seja para o valor de retorno desta function.

Ou o que você pode fazer para criar um atalho é converter o NSString em uma string c ++ e usar o ‘+’ lá.

Espero que isto ajude!!!!!

Use 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ê quisesse 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 para 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\"?>" @"" @" " @" " @" test" @" " @" " @"" }; 

Atalho criando 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, apenas faça isso com argumentos variadicos, veja a resposta 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]; 

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

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

A única maneira de tornar c = [a stringByAppendingString: b] menor é usar o autocomplete em torno st ponto st . O operador + faz parte de C, que não conhece objects Objective-C.

Que tal encurtar stringByAppendingString e usar um #define :

 #define and stringByAppendingString 

Assim você usaria:

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

O problema é que ele só funciona para duas strings, você é obrigado a enrolar colchetes adicionais para mais anexos:

 NSString* myString = [[@"Hello" and: @" world"] and: @" again"]; 
 NSString *result=[NSString stringWithFormat:@"%@ %@", @"Hello", @"World"]; 
 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 a digitar “N” no seu aplicativo Xcode e o autocomplete para “NSString”. Digite “str” ​​e autocomplete para “stringByAppendingString”. Portanto, as teclas são bastante limitadas.

Depois que você pegar o jeito de apertar a tecla “@” e tabular o processo de escrever o código legível não se torna mais um problema. É apenas uma questão de adaptação.

 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 painel lldb

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

quais erros.

Em vez disso, use o método alloc e initWithFormat :

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

Isso é para melhor registro e registro apenas – com base no método de argumento múltiplo dicius excelente. Eu defino uma class Logger e a chamo assim:

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

Quase bom, exceto ter que terminar com o var args com “nil”, mas suponho que não há maneira de contornar isso em 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 concatenar somente strings, eu definiria uma categoria em NSString e adicionaria um método de concatenação estático (+) a ele que se parece exatamente com o método de log acima, exceto que retorna a string. Ele está no NSString porque é um método de string, e é estático porque você quer criar uma nova string a partir de strings 1-N, e não chamá-la em qualquer uma das strings que fazem parte do append.

 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 cadeias de caracteres, muitas vezes acho mais fácil fazer o arquivo de origem ObjC ++, então eu posso concatenar std :: strings usando o segundo método mostrado na questão.

 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 é este:

 NSString *firstString = @"foo"; NSString *secondString = @"bar"; NSString *thirdString = @"baz"; NSString *joinedString = [@[firstString, secondString, thirdString] join]; 

Você pode consegui-lo adicionando o método de junit 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 este é o método mais rápido para concatenar strings.

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

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

Qualquer um desses formatos funciona no XCode7 quando testei:

 NSString *sTest1 = {@"This" " and that" " and one more"}; NSString *sTest2 = { @"This" " and that" " and one more" }; NSLog(@"\n%@\n\n%@",sTest1,sTest2); 

Por algum motivo, você precisa apenas do caractere do operador @ na primeira string da mixagem.

No entanto, não funciona com inserção variável. Para isso, você pode usar essa solução extremamente simples, com exceção de usar uma macro em “cat” em vez de “e”.

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

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

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

Para todos os amantes do 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]; } 

Em Swift

 let str1 = "This" let str2 = "is just a test" var appendStr1 = "\(str1) \(str2)" // appendStr1 would be "This is just a test" var appendStr2 = str1 + str2 // // appendStr2 would be "This is just a test" 

Além disso, você pode usar o operador += para o mesmo que abaixo …

 var str3 = "Some String" str3 += str2 // str3 would be "Some String is just a test"