ตัวพิมพ์เล็กและใหญ่ 'มี (สตริง)'

มีวิธีที่จะทำให้ผลตอบแทนต่อไปนี้เป็นจริงหรือไม่?

string title = "ASTRINGTOTEST";
title.Contains("string");

มีไม่ดูเหมือนจะเกินที่ช่วยให้ผมตั้งค่าความไวกรณี .. ขณะนี้ฉันพิมพ์ใหญ่พวกเขาทั้งสอง แต่นั่นเป็นเพียงโง่ (โดยที่ฉันหมายถึงi18nปัญหาที่มาพร้อมกับการขึ้นและลงท่อ)

อัพเดท
คำถามนี้เก่าแก่และตั้งแต่นั้นมาฉันก็รู้ว่าฉันขอคำตอบง่ายๆสำหรับหัวข้อที่กว้างใหญ่และยากมากถ้าคุณสนใจตรวจสอบอย่างเต็มที่
สำหรับกรณีส่วนใหญ่ในภาษาพูดเดียวรหัสภาษาอังกฤษจะใช้คำตอบนี้เพียงพอ ฉันสงสัยเพราะคนส่วนใหญ่ที่มาที่นี่ตกอยู่ในหมวดหมู่นี้นี่เป็นคำตอบที่ได้รับความนิยมมากที่สุด อย่างไรก็ตามคำตอบ
นี้ทำให้เกิดปัญหาโดยธรรมชาติที่เราไม่สามารถเปรียบเทียบตัวพิมพ์เล็กและตัวพิมพ์เล็กจนกว่าเราจะรู้ว่าข้อความทั้งสองเป็นวัฒนธรรมเดียวกันและเรารู้ว่าวัฒนธรรมนั้นคืออะไร นี่อาจเป็นคำตอบที่ได้รับความนิยมน้อยกว่า แต่ฉันคิดว่ามันถูกต้องมากกว่าและนั่นเป็นสาเหตุที่ฉันทำเครื่องหมายว่าเป็นเช่นนั้น

เพื่อทดสอบว่าสตริงparagraphมีสตริงword(ขอบคุณ @QuarterMeister)

culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0

ในกรณีที่cultureเป็นตัวอย่างของCultureInfoการอธิบายภาษาที่ข้อความที่ถูกเขียนใน

การแก้ปัญหานี้มีความโปร่งใสเกี่ยวกับความหมายของกรณีความไม่รู้สึกซึ่งเป็นภาษาที่ขึ้นอยู่กับ ตัวอย่างเช่นภาษาอังกฤษใช้อักขระIและตัวอักษรตัวiพิมพ์ใหญ่และตัวพิมพ์เล็กในขณะที่ภาษาตุรกีใช้อักขระเหล่านี้สำหรับตัวอักษรที่สิบเอ็ดและสิบสองของตัวอักษรยาว 29 ตัว เวอร์ชั่นตัวพิมพ์ใหญ่ของตุรกีคือ 'i' เป็นตัวละครที่ไม่คุ้นเคย 'İ'

ดังนั้นสตริงtinและTINเป็นคำเดียวกันในภาษาอังกฤษแต่คำพูดที่แตกต่างกันในตุรกี ดังที่ฉันเข้าใจแล้วหนึ่งในนั้นหมายถึง 'วิญญาณ' และอีกอันหนึ่งคือคำเลียนเสียงธรรมชาติ (เติร์กโปรดแก้ไขฉันหากฉันผิดหรือแนะนำตัวอย่างที่ดีกว่า)

เพื่อสรุปคุณเท่านั้นที่สามารถตอบคำถาม 'เหล่านี้เป็นสองสายเดียวกัน แต่ในกรณีที่แตกต่างกันถ้าคุณรู้ว่าสิ่งที่ภาษาข้อความที่อยู่ใน หากคุณไม่รู้คุณจะต้องถ่อ เมื่อพิจารณาจากซอฟต์แวร์ภาษาอังกฤษของเจ้าโลกคุณควรใช้วิธีนี้CultureInfo.InvariantCultureเพราะมันจะผิดในแบบที่คุ้นเคย

คุณสามารถใช้วิธี String.IndexOfและส่งผ่านStringComparison.OrdinalIgnoreCaseเป็นประเภทการค้นหาที่จะใช้:

string title = "STRING";
bool contains = title.IndexOf("string", StringComparison.OrdinalIgnoreCase) >= 0;

ที่ดียิ่งขึ้นคือการกำหนดวิธีการขยายใหม่สำหรับสตริง:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source?.IndexOf(toCheck, comp) >= 0;
    }
}

โปรดทราบว่าการเผยแพร่ null ?.นั้นมีให้ตั้งแต่ C # 6.0 (VS 2015) สำหรับรุ่นที่เก่ากว่าใช้

if (source == null) return false;
return source.IndexOf(toCheck, comp) >= 0;

การใช้:

string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);

คุณสามารถใช้IndexOf()สิ่งนี้:

string title = "STRING";

if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
{
    // The string exists in the original
}

เนื่องจาก 0 (ศูนย์) สามารถเป็นดัชนีคุณตรวจสอบกับ -1

MSDN

ตำแหน่งดัชนีตามศูนย์ถ้าพบสตริงนั้นหรือ -1 ถ้าไม่ใช่ ถ้า value เป็น String.Empty ค่าส่งคืนจะเป็น 0

โซลูชันทางเลือกโดยใช้ Regex:

bool contains = Regex.IsMatch("StRiNG to search", Regex.Escape("string"), RegexOptions.IgnoreCase);

คุณสามารถเพิ่มหรือลดขนาดสตริงได้เสมอ

string title = "string":
title.ToUpper().Contains("STRING")  // returns true

อ๊ะเพิ่งเห็นว่าบิตสุดท้าย การเปรียบเทียบแบบตัวพิมพ์เล็กและตัวพิมพ์เล็ก*อาจจะ*ทำแบบเดียวกันอยู่ดีและหากประสิทธิภาพไม่ใช่ปัญหาฉันไม่เห็นปัญหาในการสร้างสำเนาตัวพิมพ์ใหญ่และเปรียบเทียบสิ่งเหล่านั้น ฉันสาบานได้ว่าเคยเห็นการเปรียบเทียบแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่หนึ่งครั้ง ...

. NET Core 2.0+ เท่านั้น (ณ ตอนนี้)

.NET Core มีวิธีการสองอย่างที่จะจัดการกับสิ่งนี้ตั้งแต่รุ่น 2.0:

• String.Contains (Char, StringComparison )
• String.Contains (String, StringComparison )

ตัวอย่าง:

"Test".Contains("test", System.StringComparison.CurrentCultureIgnoreCase);

ทันเวลาพวกเขาอาจเข้าสู่. NET Standard และจากที่นั่นไปสู่การใช้งานอื่น ๆ ทั้งหมดของ Base Class Library

ปัญหาหนึ่งที่มีคำตอบคือมันจะโยนข้อยกเว้นถ้าสตริงเป็นโมฆะ คุณสามารถเพิ่มสิ่งนั้นเป็นเช็คเพื่อที่จะไม่:

public static bool Contains(this string source, string toCheck, StringComparison comp)
{
    if (string.IsNullOrEmpty(toCheck) || string.IsNullOrEmpty(source))
        return true;

    return source.IndexOf(toCheck, comp) >= 0;
} 

StringExtension class เป็นทางไปข้างหน้าฉันได้รวมโพสต์สองสามข้อด้านบนเพื่อให้ตัวอย่างรหัสที่สมบูรณ์:

public static class StringExtensions
{
    /// <summary>
    /// Allows case insensitive checks
    /// </summary>
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source.IndexOf(toCheck, comp) >= 0;
    }
}

นี่สะอาดและเรียบง่าย

Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)

OrdinalIgnoreCase, CurrentCultureIgnoreCase หรือ InvariantCultureIgnoreCase?

เนื่องจากนี่หายไปนี่คือคำแนะนำบางประการเกี่ยวกับเวลาที่จะใช้:

Dos

• ใช้StringComparison.OrdinalIgnoreCaseสำหรับการเปรียบเทียบเป็นค่าเริ่มต้นที่ปลอดภัยสำหรับการจับคู่สตริงที่ไม่เชื่อเรื่องพระเจ้า
• ใช้StringComparison.OrdinalIgnoreCaseการเปรียบเทียบเพื่อเพิ่มความเร็ว
• ใช้StringComparison.CurrentCulture-basedการทำงานของสตริงเมื่อแสดงผลลัพธ์ไปยังผู้ใช้
• สลับการใช้งานการดำเนินงานสตริงปัจจุบันตามวัฒนธรรมที่ไม่เปลี่ยนแปลงเพื่อใช้ที่ไม่ใช่ภาษาStringComparison.Ordinalหรือ StringComparison.OrdinalIgnoreCaseเมื่อการเปรียบเทียบนั้น
  ไม่เกี่ยวข้องกับภาษา (ตัวอย่างเช่นสัญลักษณ์)
• ใช้ToUpperInvariantแทนที่จะเป็นToLowerInvariantเมื่อ normalizing สตริงสำหรับการเปรียบเทียบ

Don'ts

• ใช้โอเวอร์โหลดสำหรับการดำเนินการกับสตริงที่ไม่ได้ระบุกลไกการเปรียบเทียบสตริงโดยชัดแจ้งหรือโดยปริยาย
• ใช้StringComparison.InvariantCulture-based
  การดำเนินงานสตริงในกรณีส่วนใหญ่; หนึ่งในข้อยกเว้นบางประการจะยัง
  คงมีความหมายทางภาษา แต่ข้อมูลที่ไม่เชื่อเรื่องพระเจ้าเกี่ยวกับวัฒนธรรม

ตามกฎเหล่านี้คุณควรใช้:

string title = "STRING";
if (title.IndexOf("string", 0, StringComparison.[YourDecision]) != -1)
{
    // The string exists in the original
}

ในขณะที่ [YourDecision] ขึ้นอยู่กับคำแนะนำจากด้านบน

ลิงก์ของแหล่งที่มา: http://msdn.microsoft.com/en-us/library/ms973919.aspx

นี่คือทางออกที่ง่ายที่สุด

1. โดยดัชนีของ

   string title = "STRING";
   
   if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
   {
       // contains 
   }

2. โดยการเปลี่ยนเคส

   string title = "STRING";
   
   bool contains = title.ToLower().Contains("string")

3. โดย Regex

   Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);

ฉันรู้ว่านี่ไม่ใช่ C # แต่ในกรอบงาน (VB.NET) มีฟังก์ชั่นดังกล่าวอยู่แล้ว

Dim str As String = "UPPERlower"
Dim b As Boolean = InStr(str, "UpperLower")

ตัวแปร C #:

string myString = "Hello World";
bool contains = Microsoft.VisualBasic.Strings.InStr(myString, "world");

InStrวิธีจาก VisualBasic การชุมนุมที่ดีที่สุดคือถ้าคุณมีความกังวลเกี่ยวกับความเป็นสากล (หรือคุณอาจจะ reimplement มัน) การดูที่ dotNeetPeek แสดงให้เห็นว่าไม่เพียง แต่จะคำนึงถึงตัวพิมพ์ใหญ่และตัวพิมพ์เล็กเท่านั้น แต่ยังรวมถึงตัวอักษรคานาและตัวอักษรเต็มความกว้างครึ่งตัว (ส่วนใหญ่เกี่ยวข้องกับภาษาเอเชียแม้ว่าจะมีตัวอักษรโรมันแบบเต็มความกว้างเช่นกัน) ) ฉันกำลังข้ามรายละเอียดบางอย่าง แต่ลองดูวิธีส่วนตัวInternalInStrText:

private static int InternalInStrText(int lStartPos, string sSrc, string sFind)
{
  int num = sSrc == null ? 0 : sSrc.Length;
  if (lStartPos > num || num == 0)
    return -1;
  if (sFind == null || sFind.Length == 0)
    return lStartPos;
  else
    return Utils.GetCultureInfo().CompareInfo.IndexOf(sSrc, sFind, lStartPos, CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth);
}

แบบนี้:

string s="AbcdEf";
if(s.ToLower().Contains("def"))
{
    Console.WriteLine("yes");
}

ใช้สิ่งนี้:

string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase);

นี่ค่อนข้างคล้ายกับตัวอย่างอื่น ๆ ที่นี่ แต่ฉันตัดสินใจที่จะทำให้ enum เป็นบูลง่ายขึ้นหลักเพราะทางเลือกอื่นมักไม่ต้องการ นี่คือตัวอย่างของฉัน:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, bool bCaseInsensitive )
    {
        return source.IndexOf(toCheck, bCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) >= 0;
    }
}

และการใช้งานเป็นสิ่งที่ชอบ:

if( "main String substring".Contains("SUBSTRING", true) )
....

การใช้ RegEx เป็นวิธีที่ตรงไปตรงมาเพื่อทำสิ่งนี้:

Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);

เพื่อสร้างคำตอบที่นี่คุณสามารถสร้างวิธีการขยายสตริงเพื่อทำให้ใช้งานง่ายขึ้น:

    public static bool ContainsIgnoreCase(this string paragraph, string word)
    {
        return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;
    }

หากคุณต้องการตรวจสอบว่าสตริงที่ส่งผ่านของคุณอยู่ในสตริงหรือไม่นั้นมีวิธีการง่ายๆ

string yourStringForCheck= "abc";
string stringInWhichWeCheck= "Test abc abc";

bool isContained = stringInWhichWeCheck.ToLower().IndexOf(yourStringForCheck.ToLower()) > -1;

ค่าบูลีนนี้จะส่งคืนหากสตริงมีอยู่หรือไม่

เรียบง่ายและใช้งานได้ดี

title.ToLower().Contains("String".ToLower())

if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}

คุณสามารถใช้string.indexof ()ฟังก์ชั่น นี่จะเป็นแบบตัวเล็ก

เคล็ดลับที่นี่คือการค้นหาสตริงโดยไม่สนใจขนาดตัวพิมพ์ แต่เพื่อให้เหมือนกันทั้งหมด (ด้วยตัวพิมพ์เล็ก)

 var s="Factory Reset";
 var txt="reset";
 int first = s.IndexOf(txt, StringComparison.InvariantCultureIgnoreCase) + txt.Length;
 var subString = s.Substring(first - txt.Length, txt.Length);

ผลลัพธ์คือ "รีเซ็ต"

public static class StringExtension
{
    #region Public Methods

    public static bool ExContains(this string fullText, string value)
    {
        return ExIndexOf(fullText, value) > -1;
    }

    public static bool ExEquals(this string text, string textToCompare)
    {
        return text.Equals(textToCompare, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExHasAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index]) == false) return false;
        return true;
    }

    public static bool ExHasEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return true;
        return false;
    }

    public static bool ExHasNoEquals(this string text, params string[] textArgs)
    {
        return ExHasEquals(text, textArgs) == false;
    }

    public static bool ExHasNotAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return false;
        return true;
    }

    /// <summary>
    /// Reports the zero-based index of the first occurrence of the specified string
    /// in the current System.String object using StringComparison.InvariantCultureIgnoreCase.
    /// A parameter specifies the type of search to use for the specified string.
    /// </summary>
    /// <param name="fullText">
    /// The string to search inside.
    /// </param>
    /// <param name="value">
    /// The string to seek.
    /// </param>
    /// <returns>
    /// The index position of the value parameter if that string is found, or -1 if it
    /// is not. If value is System.String.Empty, the return value is 0.
    /// </returns>
    /// <exception cref="ArgumentNullException">
    /// fullText or value is null.
    /// </exception>
    public static int ExIndexOf(this string fullText, string value)
    {
        return fullText.IndexOf(value, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExNotEquals(this string text, string textToCompare)
    {
        return ExEquals(text, textToCompare) == false;
    }

    #endregion Public Methods
}

วิธีง่ายๆสำหรับมือใหม่:

title.ToLower().Contains("string");//of course "string" is lowercase.