Bagaimana cara memotong string .NET?

Saya ingin memotong string sehingga panjangnya tidak lebih dari nilai yang diberikan. Saya menulis ke tabel database dan ingin memastikan bahwa nilai yang saya tulis memenuhi batasan tipe data kolom.

Sebagai contoh, alangkah baiknya jika saya dapat menulis yang berikut ini:

string NormalizeLength(string value, int maxLength)
{
    return value.Substring(0, maxLength);
}

Sayangnya, ini menimbulkan pengecualian karena maxLengthumumnya melebihi batas string value. Tentu saja, saya bisa menulis fungsi seperti berikut ini, tetapi saya berharap sesuatu seperti ini sudah ada.

string NormalizeLength(string value, int maxLength)
{
    return value.Length <= maxLength ? value : value.Substring(0, maxLength);
} 

Di mana API yang sulit dipahami yang melakukan tugas ini? Apakah ada satu?

Truncate()Sayangnya, tidak ada metode pada string. Anda harus menulis logika semacam ini sendiri. Namun, yang dapat Anda lakukan adalah membungkusnya dengan metode ekstensi sehingga Anda tidak perlu menduplikasinya di mana saja:

public static class StringExt
{
    public static string Truncate(this string value, int maxLength)
    {
        if (string.IsNullOrEmpty(value)) return value;
        return value.Length <= maxLength ? value : value.Substring(0, maxLength); 
    }
}

Sekarang kita bisa menulis:

var someString = "...";
someString = someString.Truncate(2);

Atau alih-alih operator ternary, Anda bisa menggunakan Math.min

public static class StringExt
{
    public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return value.Substring(0, Math.Min(value.Length, maxLength));
    }
}

Saya pikir saya akan memasukkan implementasi saya karena saya percaya itu mencakup semua kasus yang telah disentuh oleh yang lain dan melakukannya dengan cara ringkas yang masih dapat dibaca.

public static string Truncate(this string value, int maxLength)
{
    if (!string.IsNullOrEmpty(value) && value.Length > maxLength)
    {
        return value.Substring(0, maxLength);
    }

    return value;
}

Solusi ini terutama dibangun di atas solusi Ray dan membuka metode untuk digunakan sebagai metode ekstensi dengan menggunakan kata kunci ini seperti halnya LBushkin dalam solusinya.

Karena pengujian kinerja itu menyenangkan: (menggunakan metode ekstensi linqpad )

var val = string.Concat(Enumerable.Range(0, 50).Select(i => i % 10));

foreach(var limit in new[] { 10, 25, 44, 64 })
    new Perf<string> {
        { "newstring" + limit, n => new string(val.Take(limit).ToArray()) },
        { "concat" + limit, n => string.Concat(val.Take(limit)) },
        { "truncate" + limit, n => val.Substring(0, Math.Min(val.Length, limit)) },
        { "smart-trunc" + limit, n => val.Length <= limit ? val : val.Substring(0, limit) },
        { "stringbuilder" + limit, n => new StringBuilder(val, 0, Math.Min(val.Length, limit), limit).ToString() },
    }.Vs();

The truncateMetode adalah "signifikan" lebih cepat. #microoptimization

Dini

• truncate10 5788 ticks berlalu (0,5788 ms) [dalam 10K repetisi, 5,788E-05 ms per]
• smart-trunc10 8206 ticks berlalu (0,8206 ms) [dalam 10K repetisi, 8,206E-05 ms per]
• stringbuilder10 10557 ticks berlalu (1,0557 ms) [dalam 10K repetisi, 0,00010557 ms per]
• concat10 45495 ticks berlalu (4.5495 ms) [dalam 10K repetisi, 0,00045495 ms per]
• newstring10 72535 ticks berlalu (7.2535 ms) [dalam 10K repetisi, 0,00072535 ms per]

Terlambat

• truncate44 8835 ticks berlalu (0,8835 ms) [dalam 10K repetisi, 8,835E-05 ms per]
• stringbuilder44 13106 ticks berlalu (1,3106 ms) [dalam 10K repetisi, 0,00013106 ms per]
• smart-trunc44 14821 ticks berlalu (1,4821 ms) [dalam 10K repetisi, 0,00014821 ms per]
• kutu newstring44 144324 berlalu (14,4324 ms) [dalam 10K repetisi, 0,00144324 ms per]
• concat44 174610 ticks berlalu (17.461 ms) [dalam 10K repetisi, 0,0017461 ms per]

Terlalu panjang

• smart-trunc64 6944 ticks berlalu (0,6944 ms) [dalam 10K repetisi, 6,944E-05 ms per]
• truncate64 7686 ticks berlalu (0,7686 ms) [dalam 10K repetisi, 7,686E-05 ms per]
• stringbuilder64 13314 ticks berlalu (1,3314 ms) [dalam 10K repetisi, 0,00013314 ms per]
• newstring64 177481 ticks berlalu (17.7481 ms) [dalam 10K repetisi, 0,00177481 ms per]
• concat64 241601 ticks elapsed (24.1601 ms) [dalam 10K repetisi, 0,00241601 ms per]

Di .NET 4.0 Anda dapat menggunakan Takemetode ini:

string.Concat(myString.Take(maxLength));

Tidak diuji efisiensi!

Anda bisa menggunakan LINQ ... itu menghilangkan kebutuhan untuk memeriksa panjang string. Memang mungkin bukan yang paling efisien, tapi itu menyenangkan.

string result = string.Join("", value.Take(maxLength)); // .NET 4 Join

atau

string result = new string(value.Take(maxLength).ToArray());

Saya melakukan milik saya dalam satu baris seperti ini

value = value.Length > 1000 ? value.Substring(0, 1000) : value;

Sepertinya belum ada yang mengirim ini:

public static class StringExt
{
    public static string Truncate(this string s, int maxLength)
    {
        return s != null && s.Length > maxLength ? s.Substring(0, maxLength) : s;
    }
}

Menggunakan operator && menjadikannya sedikit lebih baik daripada jawaban yang diterima.

NET Framework. Memiliki API untuk memotong string seperti ini:

Microsoft.VisualBasic.Strings.Left(string, int);

Tetapi dalam aplikasi C # Anda mungkin akan lebih memilih untuk roll sendiri daripada mengambil ketergantungan pada Microsoft.VisualBasic.dll, yang raison d'etre utamanya adalah kompatibilitas mundur.

Solusi lain:

return input.Substring(0, Math.Min(input.Length, maxLength));

Saya tahu ini adalah pertanyaan lama, tapi ini solusi yang bagus:

public static string Truncate(this string text, int maxLength, string suffix = "...")
{
    string str = text;
    if (maxLength > 0)
    {
        int length = maxLength - suffix.Length;
        if (length <= 0)
        {
            return str;
        }
        if ((text != null) && (text.Length > maxLength))
        {
            return (text.Substring(0, length).TrimEnd(new char[0]) + suffix);
        }
    }
    return str;
}

var myString = "hello world"
var myTruncatedString = myString.Truncate(4);

Pengembalian: halo ...

Varian serupa dengan operator propagasi Null C # 6

public static string Truncate(this string value, int maxLength)
{
    return value?.Length <= maxLength ? value : value?.Substring(0, maxLength);
}

Harap dicatat, kami pada dasarnya memeriksa apakah valueada nol dua kali di sini.

Masih tidak ada metode terpotong pada 2016 untuk string C #. Tapi - Menggunakan Sintaks C # 6.0:

public static class StringExtension
{
  public static string Truncate(this string s, int max) 
  { 
    return s?.Length > max ? s.Substring(0, max) : s ?? throw new ArgumentNullException(s); 
  }
}

Ini bekerja seperti pesona:

"Truncate me".Truncate(8);
Result: "Truncate"

Mengambil @CaffGeek dan menyederhanakannya:

public static string Truncate(this string value, int maxLength)
    {
        return string.IsNullOrEmpty(value) ? value : value.Substring(0, Math.Min(value.Length, maxLength));
    }

Kndly mencatat bahwa memotong string tidak hanya berarti memotong talinya pada panjang tertentu saja tetapi harus berhati-hati untuk tidak membagi kata.

mis. string: ini adalah string tes.

Saya ingin memotongnya jam 11. Jika kita menggunakan salah satu metode yang diberikan di atas hasilnya akan menjadi

ini adalah sebuah

Ini bukan hal yang kita inginkan

Metode yang saya gunakan mungkin juga tidak begitu sempurna tetapi dapat menangani sebagian besar situasi

public string CutString(string source, int length)
{
        if (source== null || source.Length < length)
        {
            return source;
        }
        int nextSpace = source.LastIndexOf(" ", length);
        return string.Format("{0}...", input.Substring(0, (nextSpace > 0) ? nextSpace : length).Trim());
} 

Kenapa tidak:

string NormalizeLength(string value, int maxLength)
{
    //check String.IsNullOrEmpty(value) and act on it. 
    return value.PadRight(maxLength).Substring(0, maxLength);
}

yaitu dalam value.Length < maxLengthruang pad acara ke ujung atau memotong kelebihan.

Kalau-kalau tidak ada jawaban yang cukup di sini, ini milik saya :)

public static string Truncate(this string str, 
                              int totalLength, 
                              string truncationIndicator = "")
{
    if (string.IsNullOrEmpty(str) || str.Length < totalLength) 
        return str;

    return str.Substring(0, totalLength - truncationIndicator.Length) 
           + truncationIndicator;
}

menggunakan:

"I use it like this".Truncate(5,"~")

Demi kompleksitas (over), saya akan menambahkan versi kelebihan beban saya yang menggantikan 3 karakter terakhir dengan ellipsis sehubungan dengan parameter maxLength.

public static string Truncate(this string value, int maxLength, bool replaceTruncatedCharWithEllipsis = false)
{
    if (replaceTruncatedCharWithEllipsis && maxLength <= 3)
        throw new ArgumentOutOfRangeException("maxLength",
            "maxLength should be greater than three when replacing with an ellipsis.");

    if (String.IsNullOrWhiteSpace(value)) 
        return String.Empty;

    if (replaceTruncatedCharWithEllipsis &&
        value.Length > maxLength)
    {
        return value.Substring(0, maxLength - 3) + "...";
    }

    return value.Substring(0, Math.Min(value.Length, maxLength)); 
}

Dua sen saya dengan panjang contoh 30:

  var truncatedInput = string.IsNullOrEmpty(input) ? 
      string.Empty : 
      input.Substring(0, Math.Min(input.Length, 30));

Saya lebih suka jawaban jpierson, tetapi tidak ada contoh di sini yang dapat saya lihat menangani parameter maxLength yang tidak valid, seperti ketika maxLength <0.

Pilihan akan berupa menangani kesalahan dalam mencoba / menangkap, menjepit parameter maxLength min ke 0, atau jika maxLength kurang dari 0 mengembalikan string kosong.

Tidak kode yang dioptimalkan:

public string Truncate(this string value, int maximumLength)
{
    if (string.IsNullOrEmpty(value) == true) { return value; }
    if (maximumLen < 0) { return String.Empty; }
    if (value.Length > maximumLength) { return value.Substring(0, maximumLength); }
    return value;
}

Berikut ini adalah solusi vb.net, tandai bahwa pernyataan if (walaupun jelek) meningkatkan kinerja karena kita tidak memerlukan pernyataan substring ketika string sudah lebih kecil dari maxlength ... Dengan menjadikannya ekstensi ke string, mudah digunakan. ..

 <System.Runtime.CompilerServices.Extension()> _
    Public Function Truncate(String__1 As String, maxlength As Integer) As String
        If Not String.IsNullOrEmpty(String__1) AndAlso String__1.Length > maxlength Then
            Return String__1.Substring(0, maxlength)
        Else
            Return String__1
        End If
    End Function

Saya tahu sudah ada banyak jawaban, tetapi kebutuhan saya adalah menjaga agar awal dan akhir string tetap pendek tetapi dipersingkat menjadi di bawah panjang maksimal.

    public static string TruncateMiddle(string source)
    {
        if (String.IsNullOrWhiteSpace(source) || source.Length < 260) 
            return source;

        return string.Format("{0}...{1}", 
            source.Substring(0, 235),
            source.Substring(source.Length - 20));
    }

Ini untuk membuat URL SharePoint yang memiliki panjang maksimal 260 karakter.

Saya tidak membuat panjang parameter karena ini adalah konstanta 260. Saya juga tidak membuat panjang substring pertama sebagai parameter karena saya ingin memecah pada titik tertentu. Akhirnya, substring kedua adalah panjang sumber - 20 karena saya tahu struktur folder.

Ini dapat dengan mudah disesuaikan dengan kebutuhan spesifik Anda.

Saya tahu sudah ada banyak jawaban di sini, tetapi ini adalah jawaban yang telah saya pakai, yang menangani string nol dan situasi di mana panjangnya negatif:

public static string Truncate(this string s, int length)
{
    return string.IsNullOrEmpty(s) || s.Length <= length ? s 
        : length <= 0 ? string.Empty 
        : s.Substring(0, length);
}

Di C # 8 fitur Ranges baru dapat digunakan ...

value = value[..Math.Min(30, value.Length)];

Tidak ada di .net untuk ini yang saya ketahui - ini adalah versi saya yang menambahkan "...":

public static string truncateString(string originalString, int length) {
  if (string.IsNullOrEmpty(originalString)) {
   return originalString;
  }
  if (originalString.Length > length) {
   return originalString.Substring(0, length) + "...";
  }
  else {
   return originalString;
  }
}

TruncateString

public static string _TruncateString(string input, int charaterlimit)
{
    int characterLimit = charaterlimit;
    string output = input;

    // Check if the string is longer than the allowed amount
    // otherwise do nothing
    if (output.Length > characterLimit && characterLimit > 0)
    {
        // cut the string down to the maximum number of characters
        output = output.Substring(0, characterLimit);
        // Check if the character right after the truncate point was a space
        // if not, we are in the middle of a word and need to remove the rest of it
        if (input.Substring(output.Length, 1) != " ")
        {
            int LastSpace = output.LastIndexOf(" ");

            // if we found a space then, cut back to that space
            if (LastSpace != -1)
            {
                output = output.Substring(0, LastSpace);
            }
        }
        // Finally, add the "..."
        output += "...";
    }
    return output;
}

Sebagai tambahan terhadap kemungkinan yang dibahas di atas, saya ingin membagikan solusi saya. Ini adalah metode ekstensi yang memungkinkan null (mengembalikan string.Empty) juga ada .Truncate () kedua untuk menggunakannya dengan ellipsis. Hati-hati, ini bukan kinerja yang dioptimalkan.

public static string Truncate(this string value, int maxLength) =>
    (value ?? string.Empty).Substring(0, (value?.Length ?? 0) <= (maxLength < 0 ? 0 : maxLength) ? (value?.Length ?? 0) : (maxLength < 0 ? 0 : maxLength));
public static string Truncate(this string value, int maxLength, string ellipsis) =>
    string.Concat(value.Truncate(maxLength - (((value?.Length ?? 0) > maxLength ? ellipsis : null)?.Length ?? 0)), ((value?.Length ?? 0) > maxLength ? ellipsis : null)).Truncate(maxLength);

public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return new string(value.Take(maxLength).ToArray());// use LINQ and be happy
    }

String terpotong

public static string TruncateText(string strText, int intLength)
{
    if (!(string.IsNullOrEmpty(strText)))
    {                                
        // split the text.
        var words = strText.Split(' ');

        // calculate the number of words
        // based on the provided characters length 
        // use an average of 7.6 chars per word.
        int wordLength = Convert.ToInt32(Math.Ceiling(intLength / 7.6));

        // if the text is shorter than the length,
        // display the text without changing it.
        if (words.Length <= wordLength)
            return strText.Trim();                

        // put together a shorter text
        // based on the number of words
        return string.Join(" ", words.Take(wordLength)) + " ...".Trim();
    }
        else
        {
            return "";
        }            
    }

Ini adalah kode yang biasanya saya gunakan:

string getSubString(string value, int index, int length)
        {
            if (string.IsNullOrEmpty(value) || value.Length <= length)
            {
                return value;
            }
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            for (int i = index; i < length; i++)
            {
                sb.AppendLine(value[i].ToString());
            }
            return sb.ToString();
        }