පරමාර්ථ-සී හි තවත් නූලක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

( NSString) නූලක තවත් කුඩා නූලක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

මම බලාපොරොත්තු වුණේ මේ වගේ දෙයක්:

NSString *string = @"hello bla bla";
NSLog(@"%d",[string containsSubstring:@"hello"]);

නමුත් මට සොයාගත හැකි ආසන්නතම දෙය නම්:

if ([string rangeOfString:@"hello"] == 0) {
    NSLog(@"sub string doesnt exist");
} 
else {
    NSLog(@"exists");
}

කෙසේ වෙතත්, නූලක වෙනත් නූලක් තිබේදැයි සොයා ගැනීමට හොඳම ක්‍රමය එයද?

NSString *string = @"hello bla bla";
if ([string rangeOfString:@"bla"].location == NSNotFound) {
  NSLog(@"string does not contain bla");
} else {
  NSLog(@"string contains bla!");
}

ප්රධාන දෙය rangeOfString:නම් NSRangeව්යුහයක් ආපසු ලබා දෙන බව සැලකිල්ලට ගැනීමයි , සහ ලියකියවිලි පවසන්නේ{NSNotFound, 0} "පිදුරු මල්ලේ" ඉඳිකටුවක් නොමැති නම් එය ව්‍යුහය ආපසු ලබා දෙන බවයි.

ඔබ iOS 8 හෝ OS X යොස්මයිට් හි සිටී නම්, ඔබට දැන් කළ හැක්කේ: (* සටහන: මෙම කේතය iOS7 උපාංගයකට කැඳවනු ලැබුවහොත් මෙය ඔබගේ යෙදුම බිඳ වැටෙනු ඇත).

NSString *string = @"hello bla blah";
if ([string containsString:@"bla"]) {
  NSLog(@"string contains bla!");
} else {
  NSLog(@"string does not contain bla");
}

(ස්විෆ්ට් හි එය ක්‍රියාත්මක වන්නේ ද මෙයයි)

👍

IOS 8.0+ සහ macOS 10.10+ සඳහා, ඔබට NSString හි ස්වදේශීය භාවිතා කළ හැකිය containsString:.

IOS සහ macOS හි පැරණි සංස්කරණ සඳහා, ඔබට NSString සඳහා ඔබේම (යල්පැනගිය) කාණ්ඩයක් නිර්මාණය කළ හැකිය:

@interface NSString ( SubstringSearch )
    - (BOOL)containsString:(NSString *)substring;
@end

// - - - - 

@implementation NSString ( SubstringSearch )

- (BOOL)containsString:(NSString *)substring
{    
    NSRange range = [self rangeOfString : substring];
    BOOL found = ( range.location != NSNotFound );
    return found;
}

@end

සටහන: නම් කිරීම සම්බන්ධයෙන් ඩැනියෙල් ගැලස්කෝගේ අදහස පහතින් නිරීක්ෂණය කරන්න

මෙය ගූගල්හි ඉහළ පෙළේ ප්‍රති result ලයක් ලෙස පෙනෙන බැවින් මට මෙය එක් කිරීමට අවශ්‍යයි:

iOS 8 සහ OS X 10.10 මෙම containsString:ක්‍රමය එකතු කරයි NSString. එම පද්ධති සඳහා ඩේව් ඩෙලොන්ග්ගේ උදාහරණයේ යාවත්කාලීන කළ අනුවාදයක්:

NSString *string = @"hello bla bla";
if ([string containsString:@"bla"]) {
    NSLog(@"string contains bla!");
} else {
    NSLog(@"string does not contain bla");
}

NSString *myString = @"hello bla bla";
NSRange rangeValue = [myString rangeOfString:@"hello" options:NSCaseInsensitiveSearch];

if (rangeValue.length > 0)
{
    NSLog(@"string contains hello");
} 
else 
{
    NSLog(@"string does not contain hello!");
}

// ඔබට විකල්පයක් ලෙස පහත සඳහන් දෑ ද භාවිතා කළ හැකිය:

if (rangeValue.location == NSNotFound) 
{
    NSLog(@"string does not contain hello");
} 
else 
{
    NSLog(@"string contains hello!");
}

සමග , iOS 8 හා ස්විෆ්ට් , අපි භාවිතා කළ හැකි localizedCaseInsensitiveContainsString ක්රමය

 let string: NSString = "Café"
 let substring: NSString = "É"

 string.localizedCaseInsensitiveContainsString(substring) // true

ඒ නිසා පෞද්ගලිකව මම ඇත්තටම වෛර කරනවා NSNotFoundනමුත් එහි අවශ්‍යතාවය තේරුම් ගන්නවා.

නමුත් සමහර අයට NSNotFound සමඟ සංසන්දනය කිරීමේ සංකීර්ණතා නොතේරෙනු ඇත

උදාහරණයක් ලෙස, මෙම කේතය:

- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
    if([string rangeOfString:otherString].location != NSNotFound)
        return YES;
    else
        return NO;
}

එහි ගැටළු ඇත:

1) නිසැකවම otherString = nilමෙම කේතය බිඳ වැටෙනු ඇත. සරල පරීක්ෂණයක් වනුයේ:

NSLog(@"does string contain string - %@", [self doesString:@"hey" containString:nil] ? @"YES": @"NO");

ප්‍රති results ල !! ක්‍රෑෂ් !!

2) වෛෂයික-සී වලට අළුත් කෙනෙකුට එතරම් පැහැදිලිව පෙනෙන දෙය නම් එකම කේතය බිඳ වැටෙන්නේ නැති විටය string = nil. උදාහරණයක් ලෙස, මෙම කේතය:

NSLog(@"does string contain string - %@", [self doesString:nil containString:@"hey"] ? @"YES": @"NO");

සහ මෙම කේතය:

NSLog(@"does string contain string - %@", [self doesString:nil containString:nil] ? @"YES": @"NO");

දෙකම සිදුවනු ඇත

does string contains string - YES

එය පැහැදිලිවම ඔබට අවශ්‍ය දේ නොවේ.

එබැවින් මා විශ්වාස කරන වඩා හොඳ විසඳුම වන්නේ rangeOfString 0 හි දිග නැවත ලබා දීමයි. එබැවින් වඩා හොඳ විශ්වාසදායක කේතයක් මෙයයි:

- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
    if(otherString && [string rangeOfString:otherString].length)
        return YES;
    else
        return NO;
}

හෝ සරලයි:

- (BOOL)doesString:(NSString*)string containString:(NSString*)otherString {
    return (otherString && [string rangeOfString:otherString].length);
}

1 සහ 2 නඩු සඳහා නැවත පැමිණේ

does string contains string - NO

ඒ මගේ ශත 2 ;-)

වඩාත් ප්‍රයෝජනවත් කේතය සඳහා කරුණාකර මගේ සාරාංශය බලන්න .

එන්එස්එස්ට්රිං හි කාණ්ඩයක් වන පී අයි විසඳුමේ වැඩිදියුණු කළ අනුවාදයක්, වෙනත් නූලක් තුළ නූලක් හමු වූවා නම් පමණක් නොව, යොමු දැක්වීමක් අනුව පරාසයක් ගනී නම්,

@interface NSString (Contains)
-(BOOL)containsString: (NSString*)substring
              atRange:(NSRange*)range;

-(BOOL)containsString:(NSString *)substring;
@end

@implementation NSString (Contains)

-(BOOL)containsString:(NSString *)substring
              atRange:(NSRange *)range{

    NSRange r = [self rangeOfString : substring];
    BOOL found = ( r.location != NSNotFound );
    if (range != NULL) *range = r;
    return found;
}

-(BOOL)containsString:(NSString *)substring
{
    return [self containsString:substring
                        atRange:NULL];
}

@end

එය භාවිතා කරන්න:

NSString *string = @"Hello, World!";

//If you only want to ensure a string contains a certain substring
if ([string containsString:@"ello" atRange:NULL]) {
    NSLog(@"YES");
}

// Or simply
if ([string containsString:@"ello"]) {
    NSLog(@"YES");
}

//If you also want to know substring's range
NSRange range;
if ([string containsString:@"ello" atRange:&range]) {
    NSLog(@"%@", NSStringFromRange(range));
}

මෙන්න පිටපත් හා පේස්ට් ශ්‍රිත ස්නිපටයක්:

-(BOOL)Contains:(NSString *)StrSearchTerm on:(NSString *)StrText
{
    return [StrText rangeOfString:StrSearchTerm 
        options:NSCaseInsensitiveSearch].location != NSNotFound;
}

ඔනෙලිනර් (කුඩා කේත ප්‍රමාණයක්. ඩ්‍රයි, ඔබට ඇත්තේ එකක් පමණක් බැවින් NSLog):

NSString *string = @"hello bla bla";
NSLog(@"String %@", ([string rangeOfString:@"bla"].location == NSNotFound) ? @"not found" : @"cotains bla"); 

NSString *categoryString = @"Holiday Event";
if([categoryString rangeOfString:@"Holiday"].location == NSNotFound)
{
    //categoryString does not contains Holiday
}
else
{
    //categoryString contains Holiday
}

මේක උත්සාහ කරන්න,

NSString *string = @"test Data";
if ([[string lowercaseString] rangeOfString:@"data"].location == NSNotFound) 
{
    NSLog(@"string does not contain Data");
}   
else 
{
    NSLog(@"string contains data!");
}

හොඳම විසඳුම. මේ තරම් සරලයි! ඔබට වචනයක් හෝ නූලක් සොයා ගැනීමට අවශ්‍ය නම්. ඔබට මෙම කේතය භාවිතා කළ හැකිය. මෙම උදාහරණයේ දී අපි වචනයේ වටිනාකමෙහි "ක්‍රියාකරු" අඩංගු දැයි පරීක්ෂා කිරීමට යන්නෙමු.

NSString *word =@"find a word or character here";
if ([word containsString:@"acter"]){
    NSLog(@"It contains acter");
} else {
     NSLog (@"It does not contain acter");
}

ස්විෆ්ට් 4 හි:

let a = "Hello, how are you?"
a.contains("Hello")   //will return true

ඔබට මෙය අවශ්‍ය නම් වරක් ලියන්න:

NSString *stringToSearchThrough = @"-rangeOfString method finds and returns the range of the first occurrence of a given string within the receiver.";
BOOL contains = [stringToSearchThrough rangeOfString:@"occurence of a given string"].location != NSNotFound;

වේගවත් නම්, මෙය භාවිතා කළ හැකිය

let string = "Package #23"
if string.containsString("Package #") {
    //String contains substring
}
else {
    //String does not contain substring
}

සිද්ධි සංවේදී නූල් ගැන කරදර නොවන්නේ නම්. මෙය වරක් උත්සාහ කරන්න.

NSString *string  = @"Hello World!";

if([string rangeOfString:@"hello" options:NSCaseInsensitiveSearch].location !=NSNotFound)
{
    NSLog(@"found");
}
else
{
    NSLog(@"not found");
}

කරුණාකර මෙම කේතය භාවිතා කරන්න

NSString *string = @"hello bla bla";
if ([string rangeOfString:@"bla"].location == NSNotFound) 
{
    NSLog(@"string does not contain bla");
} 
else 
{  
    NSLog(@"string contains bla!");
}

RangeOfString සමඟ NSCaseInsensitiveSearch විකල්පය භාවිතා කරන්න: විකල්ප:

NSString *me = @"toBe" ;
NSString *target = @"abcdetobe" ;
NSRange range = [target  rangeOfString: me options: NSCaseInsensitiveSearch];
NSLog(@"found: %@", (range.location != NSNotFound) ? @"Yes" : @"No");
if (range.location != NSNotFound) {
// your code
}

ප්‍රතිදාන ප්‍රති result ලය හමු විය: ඔව්

විකල්ප එකට "or'ed" කළ හැකි අතර ඇතුළත් වන්නේ:

NSCaseInsensitiveSearch NSLiteralSearch NSBackwardsSearch සහ තවත් දේ

පළමු නූල දෙවන නූල් අඩංගු හෝ නැත,

NSString *first = @"Banana";
NSString *second = @"BananaMilk";
NSRange range = [first rangeOfString:second options:NSCaseInsensitiveSearch];

if (range.length > 0) {
    NSLog(@"Detected");
}
else {
    NSLog(@"Not detected");
}

මේක උත්සාහ කරන්න:

ස්විෆ්ට් 4.1, 4.2:

let stringData = "Black board"

//swift quick way and case sensitive
if stringData.contains("bla") {
    print("data contains string");
}

//case sensitive
if stringData.range(of: "bla",options: .caseInsensitive) != nil {
    print("data contains string");
}else {
    print("data does not contains string");
}

පරමාර්ථ-සී සඳහා:

NSString *stringData = @"Black board";

//Quick way and case sensitive
if ([stringData containsString:@"bla"]) {
    NSLog(@"data contains string");
}

//Case Insensitive
if ([stringData rangeOfString:@"bla" options:NSCaseInsensitiveSearch].location != NSNotFound) {
   NSLog(@"data contains string");
}else {
   NSLog(@"data does not contain string");
}

ස්විෆ්ට් 4 සහ ඊට ඉහළින්

let str = "Hello iam midhun"

if str.contains("iam") {
  //contains substring
}
else {
  //doesn't contain substring
}

පරමාර්ථය-සී

NSString *stringData = @"Hello iam midhun";

if ([stringData containsString:@"iam"]) {
    //contains substring
}
else {
    //doesn't contain substring
}

-(Bool)checkIf:(String)parentString containsSubstring:(String)checkString {
    NSRange textRange =[parentString rangeOfString:checkString];
    return textRange.location != NSNotFound // returns true if parent string contains substring else returns false
  }

නූලෙහි නිශ්චිත පිහිටීමක් අවශ්‍ය නම්, මෙම කේතය ස්විෆ්ට් 3.0 හි ක්‍රියාත්මක වේ :

let string = "This is my string"
let substring = "my"

let position = string.range(of: substring)?.lowerBound