objective c - Atalhos no Objective-C para concatenar NSStrings




string-concatenation (20)

Existe algum atalho 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";

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

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 objetos Objective-C.


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

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

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

Bem, como o cólon é um tipo de símbolo especial, mas é parte da assinatura do método, é possível extinguir a categoria NSString com a categoria para adicionar este 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 você achar útil ... ;-)

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

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

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, defina sua string ou campo de texto ou qualquer outra coisa para o valor de retorno desta função.

Ou, para fazer um atalho, converta o NSString em uma string C ++ e use o '+' ali.


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"

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

Eu tentei esse código. funcionou para mim.

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

Isso é para melhor registro e registro apenas - com base no método de argumento múltiplo dicius excelente. Eu defino uma classe 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://.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.


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

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


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.


Tente stringWithFormat:

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

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

Você pode usar o NSArray como

NSString *string1[email protected]"This"

NSString *string2[email protected]"is just"

NSString *string3[email protected]"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];

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

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

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

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.





string-concatenation