Rozważmy następujący przykład:

"    Hello      this  is a   long       string!   "

Chcę przekonwertować to na:

"Hello this is a long string!"

OS X 10.7+ i iOS 3.2+

Użyj natywnego rozwiązania regexp dostarczonego przez hfossli.

Inaczej

Użyj swojej ulubionej biblioteki wyrażeń regularnych lub użyj następującego rozwiązania używanego w kakao:

NSString *theString = @"    Hello      this  is a   long       string!   ";

NSCharacterSet *whitespaces = [NSCharacterSet whitespaceCharacterSet];
NSPredicate *noEmptyStrings = [NSPredicate predicateWithFormat:@"SELF != ''"];

NSArray *parts = [theString componentsSeparatedByCharactersInSet:whitespaces];
NSArray *filteredArray = [parts filteredArrayUsingPredicate:noEmptyStrings];
theString = [filteredArray componentsJoinedByString:@" "];

Regex i NSCharacterSet są tutaj, aby Ci pomóc. To rozwiązanie usuwa początkowe i końcowe białe znaki, a także wiele białych znaków.

NSString *original = @"    Hello      this  is a   long       string!   ";

NSString *squashed = [original stringByReplacingOccurrencesOfString:@"[ ]+"
                                                         withString:@" "
                                                            options:NSRegularExpressionSearch
                                                              range:NSMakeRange(0, original.length)];

NSString *final = [squashed stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];

Logowanie finaldaje

"Hello this is a long string!"

Możliwe alternatywne wzorce regex:

• Zastąp tylko spację: [ ]+
• Zastąp spację i tabulatory: [ \\t]+
• Zastąp spację, tabulatory i znaki nowej linii: \\s+

Podsumowanie wydajności

• To rozwiązanie: 7,6 sekundy
• Dzielenie, filtrowanie, łączenie (Georg Schölly) : 13,7 sekundy

Łatwość rozbudowy, wydajność, liczba wierszy kodu i liczba tworzonych obiektów sprawia, że ​​jest to odpowiednie rozwiązanie.

Właściwie jest na to bardzo proste rozwiązanie:

NSString *string = @" spaces in front and at the end ";
NSString *trimmedString = [string stringByTrimmingCharactersInSet:
                                  [NSCharacterSet whitespaceAndNewlineCharacterSet]];
NSLog(@"%@", trimmedString)

( Źródło )

Z wyrażeniem regularnym, ale bez potrzeby korzystania z żadnej zewnętrznej struktury:

NSString *theString = @"    Hello      this  is a   long       string!   ";

theString = [theString stringByReplacingOccurrencesOfString:@" +" withString:@" "
                       options:NSRegularExpressionSearch
                       range:NSMakeRange(0, theString.length)];

Jednoliniowe rozwiązanie:

NSString *whitespaceString = @" String with whitespaces ";

NSString *trimmedString = [whitespaceString
        stringByReplacingOccurrencesOfString:@" " withString:@""];

To powinno wystarczyć ...

NSString *s = @"this is    a  string    with lots  of     white space";
NSArray *comps = [s componentsSeparatedByCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];

NSMutableArray *words = [NSMutableArray array];
for(NSString *comp in comps) {
  if([comp length] > 1)) {
    [words addObject:comp];
  }
}

NSString *result = [words componentsJoinedByString:@" "];

Inną opcją dla wyrażenia regularnego jest RegexKitLite , który można bardzo łatwo osadzić w projekcie iPhone'a:

[theString stringByReplacingOccurencesOfRegex:@" +" withString:@" "];

Spróbuj tego

NSString *theString = @"    Hello      this  is a   long       string!   ";

while ([theString rangeOfString:@"  "].location != NSNotFound) {
    theString = [theString stringByReplacingOccurrencesOfString:@"  " withString:@" "];
}

Oto fragment NSStringrozszerzenia, gdzie "self"jest NSStringinstancja. Można go użyć do zwinięcia ciągłych białych znaków w jedną spację, przekazując [NSCharacterSet whitespaceAndNewlineCharacterSet]i ' 'do dwóch argumentów.

- (NSString *) stringCollapsingCharacterSet: (NSCharacterSet *) characterSet toCharacter: (unichar) ch {
int fullLength = [self length];
int length = 0;
unichar *newString = malloc(sizeof(unichar) * (fullLength + 1));

BOOL isInCharset = NO;
for (int i = 0; i < fullLength; i++) {
    unichar thisChar = [self characterAtIndex: i];

    if ([characterSet characterIsMember: thisChar]) {
        isInCharset = YES;
    }
    else {
        if (isInCharset) {
            newString[length++] = ch;
        }

        newString[length++] = thisChar;
        isInCharset = NO;
    }
}

newString[length] = '\0';

NSString *result = [NSString stringWithCharacters: newString length: length];

free(newString);

return result;
}

Alternatywne rozwiązanie: zdobądź kopię OgreKit (biblioteka wyrażeń regularnych Cocoa).

• OgreKit (japońska strona internetowa - kod jest w języku angielskim)
• OgreKit (automatyczne tłumaczenie Google):

Cała funkcja jest zatem:

NSString *theStringTrimmed =
   [theString stringByTrimmingCharactersInSet:
        [NSCharacterSet whitespaceAndNewlineCharacterSet]];
OGRegularExpression  *regex =
    [OGRegularExpression regularExpressionWithString:@"\s+"];
return [regex replaceAllMatchesInString:theStringTrimmed withString:@" "]);

Krótkie i słodkie.

Jeśli szukasz najszybszego rozwiązania, starannie skonstruowana seria instrukcji z użyciem NSScannerprawdopodobnie zadziałaby najlepiej, ale byłoby to konieczne tylko wtedy, gdy planujesz przetwarzać ogromne (wiele megabajtów) bloki tekstu.

według @Mathieu Godart jest najlepszą odpowiedzią, ale brakuje jakiejś linii, wszystkie odpowiedzi po prostu zmniejszają odstępy między słowami, ale jeśli mają tabulatory lub mają spację w miejscu, na przykład: "to jest tekst \ t i \ tTab między, tak dalej ”w trzywierszowym kodzie będziemy: ciąg, który chcemy zredukować

NSString * str_aLine = @"    this is text \t , and\tTab between      , so on    ";
// replace tabs to space
str_aLine = [str_aLine stringByReplacingOccurrencesOfString:@"\t" withString:@" "];
// reduce spaces to one space
str_aLine = [str_aLine stringByReplacingOccurrencesOfString:@" +" withString:@" "
                                                    options:NSRegularExpressionSearch
                                                      range:NSMakeRange(0, str_aLine.length)];
// trim begin and end from white spaces
str_aLine = [str_aLine stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];

wynik to

"this is text , and Tab between , so on"

bez wymiany zakładki wynik będzie:

"this is text    , and  Tab between , so on"

Możesz także użyć prostego argumentu while. Nie ma tam magii RegEx, więc może łatwiej będzie to zrozumieć i zmienić w przyszłości:

while([yourNSStringObject replaceOccurrencesOfString:@"  "
                         withString:@" "
                         options:0
                         range:NSMakeRange(0, [yourNSStringObject length])] > 0);

Następujące dwa wyrażenia regularne działałyby w zależności od wymagań

1. @ „+” dla pasujących spacji i tabulatorów
2. @ "\\ s {2,}" do dopasowywania spacji, tabulatorów i podziałów linii

Następnie zastosuj metodę instancji nsstring, stringByReplacingOccurrencesOfString:withString:options:range:aby zastąpić je pojedynczym odstępem.

na przykład

[string stringByReplacingOccurrencesOfString:regex withString:@" " options:NSRegularExpressionSearch range:NSMakeRange(0, [string length])];

Uwaga: nie korzystałem z biblioteki „RegexKitLite” dla powyższej funkcjonalności dla iOS 5.x i nowszych.