NSStrings සමපාත කිරීම සඳහා පරමාර්ථ-සී හි කෙටිමං

( stringByAppendingString:) පරමාර්ථ-සී හි ( ) නූල් සම්මුතියට කෙටිමං තිබේද , නැතහොත් NSStringපොදුවේ වැඩ කිරීම සඳහා කෙටිමං තිබේද?

උදාහරණයක් ලෙස, මම සෑදීමට කැමතියි:

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

තවත් සමාන දෙයක්:

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

මට සිතිය හැකි පිළිතුරු දෙකක් ... සමෝධානික ක්‍රියාකරුවෙකු සිටීම තරම් ප්‍රසන්න නොවේ.

පළමුවෙන්ම, ක්‍රමයක් භාවිතා කරන NSMutableString, appendStringඅමතර තාවකාලික නූල් සඳහා අවශ්‍යතාවය ඉවත් කරන්න.

දෙවනුව, ක්‍රමවේදය NSArrayහරහා සමපාත වීමට an භාවිතා කරන්න componentsJoinedByString.

විකල්පයක්:

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

තවත් විකල්පයක්:

බහුවිධ එකතු කිරීම් (a + b + c + d) ගැන ඔබ සතුටු නොවන බව මම අනුමාන කරමි.

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

වැනි දෙයක් භාවිතා කිරීම

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

ඔබ 2 NSString නම් literals , ඔබ ද හුදෙක් මෙය කළ හැකි:

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

# නිර්වචන සමඟ සම්බන්ධ වීමටද එය ප්‍රයෝජනවත් වේ:

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

විනෝද වන්න.

මම දිගටම මෙම තනතුරට නැවත පැමිණෙන අතර අවශ්‍ය තරම් විචල්‍යයන් සමඟ ක්‍රියා කරන මෙම සරල විසඳුම සොයා ගැනීම සඳහා සෑම විටම පිළිතුරු හරහා වර්ග කිරීම අවසන් කරමි:

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

උදාහරණයක් වශයෙන්:

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

ක්රමයක් සාදන්න:

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

ඉන්පසුව, ඔබට අවශ්‍ය ඕනෑම ශ්‍රිතයකදී, ඔබේ නූල හෝ පෙළ ක්ෂේත්‍රය හෝ මෙම ශ්‍රිතයේ ප්‍රතිලාභ අගයට ඕනෑම දෙයක් සකසන්න.

නැතහොත්, කෙටිමඟක් සෑදීම සඳහා, එන්එස්එස්ට්‍රිං සී ++ නූලක් බවට පරිවර්තනය කර එහි '+' භාවිතා කරන්න.

හොඳයි, අන්ත්ර, විශේෂ සංකේතය ආකාරයේ, නමුත් වේ ක්රමය අත්සන කොටසක්, එය කළ හැකි ද exted කිරීමට NSStringමෙම එක් කිරීමට ප්රවර්ග සහිත -සෙන්දගශයෙහි නොවන string අකාර ශෛලිය:

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

ඔබට ප්‍රයෝජනවත් යැයි පෙනෙන තරමට විශාල වෙන් කළ තර්ක නිර්වචනය කළ හැකිය ... ;-)

හොඳ මිනුමක් සඳහා, අවසන් කරන ලද නූල් ලැයිස්තුවක් ගන්නා concat:විචල්‍ය තර්ක සමඟ මම එකතු කර ඇත්තෙමි 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);
}

stringByAppendingString:මේ ආකාරයට භාවිතා කරන්න :

NSString *string1, *string2, *result;

string1 = @"This is ";
string2 = @"my string.";

result = [result stringByAppendingString:string1];
result = [result stringByAppendingString:string2];

හෝ

result = [result stringByAppendingString:@"This is "];
result = [result stringByAppendingString:@"my string."];

මැක්‍රෝ:

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

පරීක්ෂණ අවස්ථා:

- (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");
}

විකල්ප සාර්ව: (ඔබට අවම තර්ක ගණනක් බලාත්මක කිරීමට අවශ්‍ය නම්)

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

වෙබ් සේවා සඳහා ඉල්ලීම් ගොඩනඟන විට, පහත දැක්වෙන දේ කිරීම ඉතා පහසු වන අතර 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>"
};

AppendString (AS) සාර්ව නිර්මාණය කිරීමෙන් කෙටිමඟ ...

# AS (A, B) [(A) stringByAppendingString: (B)] යන්න අර්ථ දක්වන්න

NSString * myString = @ "මෙය";

NSString * test = AS (myString, @ "යනු පරීක්ෂණයක් පමණි");

සටහන:

සාර්ව භාවිතා කරන්නේ නම්, ඇත්ත වශයෙන්ම එය විචල්‍ය තර්ක සමඟ කරන්න, ඊතන්බීගේ පිළිතුර බලන්න.

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

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

දැන් වසර කිහිපයකට පසු වෛෂයික සීඅයි සමඟ සිතන්න ඔබ සාක්ෂාත් කර ගැනීමට උත්සාහ කරන දේ සාක්ෂාත් කර ගැනීම සඳහා පරමාර්ථ සී සමඟ වැඩ කිරීමට හොඳම ක්‍රමය මෙයයි.

ඔබගේ Xcode යෙදුමේ "N" හි යතුරු කිරීම ආරම්භ කරන්න, එය "NSString" වෙත ස්වයංක්‍රීයව සම්පුර්ණ වේ. "str" ​​හි යතුර එය ස්වයංක්‍රීයව "stringByAppendingString" වෙත සම්පුර්ණ කරයි. එබැවින් යතුරු එබීම තරමක් සීමිතය.

ඔබ "@" යතුර එබීමෙන් පසු කියවිය හැකි කේත ලිවීමේ ක්‍රියාවලිය ටැබ් කිරීම තවදුරටත් ගැටලුවක් නොවේ. එය අනුවර්තනය වීමේ කාරණයක් පමණි.

c = [a stringByAppendingString: b]ඕනෑම කෙටි කිරීමක් කළ හැකි එකම ක්‍රමය වන්නේ ස්වයං සම්පුර්ණ කිරීම stලක්ෂ්‍යය වටා භාවිතා කිරීමයි . මෙම +ක්රියාකරු අරමුණ සී වස්තූන් ගැන දන්නේ නොවන සී කොටසක් වේ.

කෙටි කිරීම stringByAppendingStringසහ # අර්ථ දැක්වීම භාවිතා කරන්නේ කෙසේද :

#define and stringByAppendingString

මේ අනුව ඔබ භාවිතා කරන්නේ:

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

ගැටළුව වන්නේ එය ක්‍රියා කරන්නේ නූල් දෙකක් සඳහා පමණක් වන අතර, තවත් එකතු කිරීම් සඳහා අමතර වරහන් එතීමට ඔබට අවශ්‍ය වේ:

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

මම මෙම කේතය උත්සාහ කළෙමි. ඒක මට වැඩක්.

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

lldbකවුළුව තුළ පහත සඳහන් දෑ උත්සාහ කරමින් සිටියේය

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

කුමන දෝෂ.

ඒ වෙනුවට ප්‍රතිපාදන සහ initWithFormatක්‍රමය භාවිතා කරන්න:

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

මෙය වඩා හොඳ ල ging ු-සටහන් සඳහා වන අතර, ලොග් වීම පමණි - dicius විශිෂ්ට බහු තර්ක ක්‍රමය මත පදනම්ව. මම ලොගර් පන්තියක් නිර්වචනය කර එය එසේ අමතන්න:

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

Var args "නිල්" සමඟ අවසන් කිරීම හැරෙන්නට බොහෝ දුරට හොඳයි, නමුත් පරමාර්ථ-සී හි ඒ වටා වෙනත් මගක් නැතැයි සිතමි.

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 

කොන්ක්‍රීට් නූල් පමණක් කිරීම සඳහා , මම එන්එස්එස්ට්රිං හි කාණ්ඩයක් නිර්වචනය කර එයට ස්ථිතික (+) සංයුක්ත ක්‍රමයක් එක් කරමි, එය හරියටම ල log ු-සටහන් ක්‍රමය මෙන් පෙනේ. එය එන්එස්එස්ට්‍රිං හි ඇත්තේ එය නූල් ක්‍රමයක් නිසා වන අතර එය ස්ථිතික වන්නේ ඔබට 1-එන් නූල් වලින් නව නූලක් සෑදීමට අවශ්‍ය නිසා මිස උපග්‍රන්ථයේ කොටසක් වන කිසිම නූල් එකකට එය නොකියන්න.

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

StringWithFormat උත්සාහ කරන්න:

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

බොහෝ විට නූල් සමඟ ගනුදෙනු කරන විට ප්‍රභව ගොනුව ObjC ++ බවට පත් කිරීම මට පහසු වේ, එවිට මට ප්‍රශ්නයේ පෙන්වා ඇති දෙවන ක්‍රමය භාවිතා කරමින් std :: strings එකලස් කළ හැකිය.

std::string stdstr = [nsstr UTF8String];

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

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

මගේ ප්‍රියතම ක්‍රමය මෙයයි:

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

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

කාණ්ඩයක් සමඟ NSArray වෙත සම්බන්ධ වීමේ ක්‍රමය එකතු කිරීමෙන් ඔබට එය සාක්ෂාත් කරගත හැකිය:

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

@[]එය කෙටි අර්ථ දැක්වීමකි NSArray, මම සිතන්නේ මෙය නූල් එකිනෙක සම්බන්ධ කිරීමේ වේගවත්ම ක්‍රමයයි.

ඔබට කාණ්ඩය භාවිතා කිරීමට අවශ්‍ය නැතිනම්, කෙලින්ම componentsJoinedByString:ක්‍රමය භාවිතා කරන්න:

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

ඔබට NSArray ලෙස භාවිතා කළ හැකිය

NSString *string1=@"This"

NSString *string2=@"is just"

NSString *string3=@"a test"  

NSArray *myStrings = [[NSArray alloc] initWithObjects:string1, string2, string3,nil];

NSString *fullLengthString = [myStrings componentsJoinedByString:@" "];

හෝ

ඔයාට පාවිච්චි කරන්න පුළුවන්

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

මා පරීක්ෂා කළ විට මෙම ආකෘති වලින් එකක් XCode7 හි ක්‍රියා කරයි:

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

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

කිසියම් හේතුවක් නිසා, ඔබට අවශ්‍ය වන්නේ මිශ්‍රණයේ පළමු නූලෙහි @ ක්‍රියාකරු අක්‍ෂරය පමණි.

කෙසේ වෙතත්, එය විචල්ය ඇතුළත් කිරීම් සමඟ ක්රියා නොකරයි. ඒ සඳහා ඔබට "සහ" වෙනුවට "බළලා" මත සාර්ව භාවිතා කිරීම හැරුණු විට මෙම අතිශය සරල විසඳුම භාවිතා කළ හැකිය .

UI- පරීක්ෂණයකදී මෙය අවශ්‍ය සියලුම අරමුණු C ආදරවන්තයින් සඳහා:

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

එහි ඇති නූල් කීයක් දැයි ඔබ නොදන්නා බව සිතමු.

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