Cara memformat string sebagai nomor telepon di C #

Saya memiliki string "1112224444 'itu adalah nomor telepon. Saya ingin memformat sebagai 111-222-4444 sebelum saya menyimpannya dalam sebuah file. Ini pada flatecord dan saya lebih suka untuk dapat melakukan ini tanpa menetapkan yang baru variabel.

Saya berpikir:

String.Format("{0:###-###-####}", i["MyPhone"].ToString() );

tapi itu tampaknya tidak berhasil.

** PEMBARUAN **

Baik. Saya pergi dengan solusi ini

Convert.ToInt64(i["Customer Phone"]).ToString("###-###-#### ####")

Sekarang menjadi kacau ketika ekstensi kurang dari 4 digit. Itu akan mengisi angka-angka dari kanan. begitu

1112224444 333  becomes

11-221-244 3334

Ada ide?

Harap dicatat, jawaban ini berfungsi dengan tipe data numerik (int, panjang). Jika Anda memulai dengan sebuah string, Anda harus mengonversinya menjadi angka terlebih dahulu. Selain itu, harap perhatikan bahwa Anda harus memvalidasi bahwa string awal paling tidak panjangnya 10 karakter.

Dari halaman yang bagus penuh dengan contoh:

String.Format("{0:(###) ###-####}", 8005551212);

    This will output "(800) 555-1212".

Meskipun regex dapat bekerja lebih baik, ingatlah kutipan pemrograman lama:

Beberapa orang, ketika dihadapkan dengan masalah, berpikir "Saya tahu, saya akan menggunakan ekspresi reguler." Sekarang mereka memiliki dua masalah.
--Jamie Zawinski, di comp.lang.emacs

Saya lebih suka menggunakan ekspresi reguler:

Regex.Replace("1112224444", @"(\d{3})(\d{3})(\d{4})", "$1-$2-$3");

Anda harus memecahnya menjadi substring. Meskipun Anda bisa melakukannya tanpa variabel tambahan, itu tidak akan terlalu bagus. Inilah salah satu solusi potensial:

string phone = i["MyPhone"].ToString();
string area = phone.Substring(0, 3);
string major = phone.Substring(3, 3);
string minor = phone.Substring(6);
string formatted = string.Format("{0}-{1}-{2}", area, major, minor);

Saya menyarankan ini sebagai solusi bersih untuk nomor AS.

public static string PhoneNumber(string value)
{ 
    if (string.IsNullOrEmpty(value)) return string.Empty;
    value = new System.Text.RegularExpressions.Regex(@"\D")
        .Replace(value, string.Empty);
    value = value.TrimStart('1');
    if (value.Length == 7)
        return Convert.ToInt64(value).ToString("###-####");
    if (value.Length == 10)
        return Convert.ToInt64(value).ToString("###-###-####");
    if (value.Length > 10)
        return Convert.ToInt64(value)
            .ToString("###-###-#### " + new String('#', (value.Length - 10)));
    return value;
}

Sejauh yang saya tahu Anda tidak dapat melakukan ini dengan string.Format ... Anda harus menangani ini sendiri. Anda bisa menghapus semua karakter non-numerik dan kemudian melakukan sesuatu seperti:

string.Format("({0}) {1}-{2}",
     phoneNumber.Substring(0, 3),
     phoneNumber.Substring(3, 3),
     phoneNumber.Substring(6));

Ini mengasumsikan data telah dimasukkan dengan benar, yang dapat Anda gunakan ekspresi reguler untuk memvalidasi.

Ini seharusnya bekerja:

String.Format("{0:(###)###-####}", Convert.ToInt64("1112224444"));

ATAU dalam kasus Anda:

String.Format("{0:###-###-####}", Convert.ToInt64("1112224444"));

Jika Anda bisa mendapatkan i["MyPhone"]sebagai long, Anda dapat menggunakan long.ToString()metode untuk memformatnya:

Convert.ToLong(i["MyPhone"]).ToString("###-###-####");

Lihat halaman MSDN pada String Format Numerik .

Hati-hati menggunakan panjang daripada int: int bisa meluap.

static string FormatPhoneNumber( string phoneNumber ) {

   if ( String.IsNullOrEmpty(phoneNumber) )
      return phoneNumber;

   Regex phoneParser = null;
   string format     = "";

   switch( phoneNumber.Length ) {

      case 5 :
         phoneParser = new Regex(@"(\d{3})(\d{2})");
         format      = "$1 $2";
       break;

      case 6 :
         phoneParser = new Regex(@"(\d{2})(\d{2})(\d{2})");
         format      = "$1 $2 $3";
       break;

      case 7 :
         phoneParser = new Regex(@"(\d{3})(\d{2})(\d{2})");
         format      = "$1 $2 $3";
       break;

      case 8 :
         phoneParser = new Regex(@"(\d{4})(\d{2})(\d{2})");
         format      = "$1 $2 $3";
       break;

      case 9 :
         phoneParser = new Regex(@"(\d{4})(\d{3})(\d{2})(\d{2})");
         format      = "$1 $2 $3 $4";
       break;

      case 10 :
         phoneParser = new Regex(@"(\d{3})(\d{3})(\d{2})(\d{2})");
         format      = "$1 $2 $3 $4";
       break;

      case 11 :
         phoneParser = new Regex(@"(\d{4})(\d{3})(\d{2})(\d{2})");
         format      = "$1 $2 $3 $4";
       break;

      default:
        return phoneNumber;

   }//switch

   return phoneParser.Replace( phoneNumber, format );

}//FormatPhoneNumber

    enter code here

Jika Anda mencari nomor telepon (AS) yang akan dikonversi secara real time. Saya sarankan menggunakan ekstensi ini. Metode ini berfungsi sempurna tanpa mengisi angka-angka mundur. The String.Formatsolusi tampaknya mundur pekerjaan. Cukup terapkan ekstensi ini ke string Anda.

public static string PhoneNumberFormatter(this string value)
{
    value = new Regex(@"\D").Replace(value, string.Empty);
    value = value.TrimStart('1');

    if (value.Length == 0)
        value = string.Empty;
    else if (value.Length < 3)
        value = string.Format("({0})", value.Substring(0, value.Length));
    else if (value.Length < 7)
        value = string.Format("({0}) {1}", value.Substring(0, 3), value.Substring(3, value.Length - 3));
    else if (value.Length < 11)
        value = string.Format("({0}) {1}-{2}", value.Substring(0, 3), value.Substring(3, 3), value.Substring(6));
    else if (value.Length > 10)
    {
        value = value.Remove(value.Length - 1, 1);
        value = string.Format("({0}) {1}-{2}", value.Substring(0, 3), value.Substring(3, 3), value.Substring(6));
    }
    return value;
}

Anda juga dapat mencoba ini:

  public string GetFormattedPhoneNumber(string phone)
        {
            if (phone != null && phone.Trim().Length == 10)
                return string.Format("({0}) {1}-{2}", phone.Substring(0, 3), phone.Substring(3, 3), phone.Substring(6, 4));
                return phone;
        }

Keluaran:

Anda mungkin menemukan diri Anda dalam situasi di mana Anda memiliki pengguna yang mencoba memasukkan nomor telepon dengan segala macam pemisah antara kode area dan blok nomor utama (mis. Spasi, tanda hubung, titik, dll ...) Jadi, Anda ingin menghapus input semua karakter yang bukan angka sehingga Anda dapat mensterilkan input yang Anda kerjakan. Cara termudah untuk melakukan ini adalah dengan ekspresi RegEx.

string formattedPhoneNumber = new System.Text.RegularExpressions.Regex(@"\D")
    .Replace(originalPhoneNumber, string.Empty);

Maka jawaban yang Anda daftarkan harusnya berfungsi dalam banyak kasus.

Untuk menjawab apa yang Anda miliki tentang masalah ekstensi, Anda dapat menghapus apa pun yang lebih panjang dari yang diharapkan dari sepuluh (untuk nomor telepon biasa) dan menambahkannya ke akhir menggunakan

formattedPhoneNumber = Convert.ToInt64(formattedPhoneNumber)
     .ToString("###-###-#### " + new String('#', (value.Length - 10)));

Anda akan ingin melakukan pemeriksaan 'jika' untuk menentukan apakah panjang input Anda lebih besar dari 10 sebelum melakukan ini, jika tidak, gunakan saja:

formattedPhoneNumber = Convert.ToInt64(value).ToString("###-###-####");

Function FormatPhoneNumber(ByVal myNumber As String)
    Dim mynewNumber As String
    mynewNumber = ""
    myNumber = myNumber.Replace("(", "").Replace(")", "").Replace("-", "")
    If myNumber.Length < 10 Then
        mynewNumber = myNumber
    ElseIf myNumber.Length = 10 Then
        mynewNumber = "(" & myNumber.Substring(0, 3) & ") " &
                myNumber.Substring(3, 3) & "-" & myNumber.Substring(6, 3)
    ElseIf myNumber.Length > 10 Then
        mynewNumber = "(" & myNumber.Substring(0, 3) & ") " &
                myNumber.Substring(3, 3) & "-" & myNumber.Substring(6, 3) & " " &
                myNumber.Substring(10)
    End If
    Return mynewNumber
End Function

        string phoneNum;
        string phoneFormat = "0#-###-###-####";
        phoneNum = Convert.ToInt64("011234567891").ToString(phoneFormat);

Coba ini

string result;
if ( (!string.IsNullOrEmpty(phoneNumber)) && (phoneNumber.Length >= 10 ) )
    result = string.Format("{0:(###)###-"+new string('#',phoneNumber.Length-6)+"}",
    Convert.ToInt64(phoneNumber)
    );
else
    result = phoneNumber;
return result;

Bersulang.

Gunakan Match in Regex untuk memecah, kemudian output string yang diformat dengan match.groups

Regex regex = new Regex(@"(?<first3chr>\d{3})(?<next3chr>\d{3})(?<next4chr>\d{4})");
Match match = regex.Match(phone);
if (match.Success) return "(" + match.Groups["first3chr"].ToString() + ")" + " " + 
  match.Groups["next3chr"].ToString() + "-" + match.Groups["next4chr"].ToString();

Berikut ini akan berfungsi tanpa menggunakan ekspresi reguler

string primaryContactNumber = !string.IsNullOrEmpty(formData.Profile.Phone) ? String.Format("{0:###-###-####}", long.Parse(formData.Profile.Phone)) : "";

Jika kita tidak menggunakan long.Parse, string.format tidak akan berfungsi.

public string phoneformat(string phnumber)
{
String phone=phnumber;
string countrycode = phone.Substring(0, 3); 
string Areacode = phone.Substring(3, 3); 
string number = phone.Substring(6,phone.Length); 

phnumber="("+countrycode+")" +Areacode+"-" +number ;

return phnumber;
}

Output akan menjadi: 001-568-895623

Silakan gunakan tautan berikut untuk C # http://www.beansoftware.com/NET-Tutorials/format-string-phone-number.aspx

Cara termudah untuk melakukan format menggunakan Regex.

private string FormatPhoneNumber(string phoneNum)
{
  string phoneFormat = "(###) ###-#### x####";

  Regex regexObj = new Regex(@"[^\d]");
  phoneNum = regexObj.Replace(phoneNum, "");
  if (phoneNum.Length > 0)
  {
    phoneNum = Convert.ToInt64(phoneNum).ToString(phoneFormat);
  }
  return phoneNum;
}

Berikan nomor telepon Anda sebagai string 2021231234 hingga 15 karakter.

FormatPhoneNumber(string phoneNum)

Pendekatan lain adalah menggunakan Substring

private string PhoneFormat(string phoneNum)
    {
      int max = 15, min = 10;
      string areaCode = phoneNum.Substring(0, 3);
      string mid = phoneNum.Substring(3, 3);
      string lastFour = phoneNum.Substring(6, 4);
      string extension = phoneNum.Substring(10, phoneNum.Length - min);
      if (phoneNum.Length == min)
      {
        return $"({areaCode}) {mid}-{lastFour}";
      }
      else if (phoneNum.Length > min && phoneNum.Length <= max)
      {
        return $"({areaCode}) {mid}-{lastFour} x{extension}";
      }
      return phoneNum;
    }

Untuk mengatasi masalah ekstensi Anda, bagaimana dengan:

string formatString = "###-###-#### ####";
returnValue = Convert.ToInt64(phoneNumber)
                     .ToString(formatString.Substring(0,phoneNumber.Length+3))
                     .Trim();

Bukan untuk membangkitkan kembali pertanyaan lama tapi pikir saya mungkin menawarkan setidaknya sedikit lebih mudah untuk menggunakan metode, jika sedikit lebih rumit dari suatu pengaturan.

Jadi jika kita membuat formatter kustom baru kita dapat menggunakan format sederhana string.Formattanpa harus mengubah nomor telepon kita menjadi along

Jadi pertama-tama mari kita buat formatter khusus:

using System;
using System.Globalization;
using System.Text;

namespace System
{
    /// <summary>
    ///     A formatter that will apply a format to a string of numeric values.
    /// </summary>
    /// <example>
    ///     The following example converts a string of numbers and inserts dashes between them.
    ///     <code>
    /// public class Example
    /// {
    ///      public static void Main()
    ///      {          
    ///          string stringValue = "123456789";
    ///  
    ///          Console.WriteLine(String.Format(new NumericStringFormatter(),
    ///                                          "{0} (formatted: {0:###-##-####})",stringValue));
    ///      }
    ///  }
    ///  //  The example displays the following output:
    ///  //      123456789 (formatted: 123-45-6789)
    ///  </code>
    /// </example>
    public class NumericStringFormatter : IFormatProvider, ICustomFormatter
    {
        /// <summary>
        ///     Converts the value of a specified object to an equivalent string representation using specified format and
        ///     culture-specific formatting information.
        /// </summary>
        /// <param name="format">A format string containing formatting specifications.</param>
        /// <param name="arg">An object to format.</param>
        /// <param name="formatProvider">An object that supplies format information about the current instance.</param>
        /// <returns>
        ///     The string representation of the value of <paramref name="arg" />, formatted as specified by
        ///     <paramref name="format" /> and <paramref name="formatProvider" />.
        /// </returns>
        /// <exception cref="System.NotImplementedException"></exception>
        public string Format(string format, object arg, IFormatProvider formatProvider)
        {
            var strArg = arg as string;

            //  If the arg is not a string then determine if it can be handled by another formatter
            if (strArg == null)
            {
                try
                {
                    return HandleOtherFormats(format, arg);
                }
                catch (FormatException e)
                {
                    throw new FormatException(string.Format("The format of '{0}' is invalid.", format), e);
                }
            }

            // If the format is not set then determine if it can be handled by another formatter
            if (string.IsNullOrEmpty(format))
            {
                try
                {
                    return HandleOtherFormats(format, arg);
                }
                catch (FormatException e)
                {
                    throw new FormatException(string.Format("The format of '{0}' is invalid.", format), e);
                }
            }
            var sb = new StringBuilder();
            var i = 0;

            foreach (var c in format)
            {
                if (c == '#')
                {
                    if (i < strArg.Length)
                    {
                        sb.Append(strArg[i]);
                    }
                    i++;
                }
                else
                {
                    sb.Append(c);
                }
            }

            return sb.ToString();
        }

        /// <summary>
        ///     Returns an object that provides formatting services for the specified type.
        /// </summary>
        /// <param name="formatType">An object that specifies the type of format object to return.</param>
        /// <returns>
        ///     An instance of the object specified by <paramref name="formatType" />, if the
        ///     <see cref="T:System.IFormatProvider" /> implementation can supply that type of object; otherwise, null.
        /// </returns>
        public object GetFormat(Type formatType)
        {
            // Determine whether custom formatting object is requested. 
            return formatType == typeof(ICustomFormatter) ? this : null;
        }

        private string HandleOtherFormats(string format, object arg)
        {
            if (arg is IFormattable)
                return ((IFormattable)arg).ToString(format, CultureInfo.CurrentCulture);
            else if (arg != null)
                return arg.ToString();
            else
                return string.Empty;
        }
    }
}

Jadi jika Anda ingin menggunakan ini, Anda akan melakukan sesuatu ini:

String.Format(new NumericStringFormatter(),"{0:###-###-####}", i["MyPhone"].ToString());

Beberapa hal lain untuk dipikirkan:

Saat ini jika Anda menentukan formatter yang lebih panjang dari yang Anda lakukan string untuk memformat itu hanya akan mengabaikan tanda # tambahan. Misalnya ini String.Format(new NumericStringFormatter(),"{0:###-###-####}", "12345");akan menghasilkan 123-45- jadi Anda mungkin ingin memilikinya mengambil semacam karakter pengisi yang mungkin dalam konstruktor.

Juga saya tidak menyediakan cara untuk keluar dari tanda # jadi jika Anda ingin memasukkannya ke dalam string keluaran Anda, Anda tidak akan bisa seperti sekarang.

Alasan saya lebih suka metode ini daripada Regex adalah saya sering memiliki persyaratan untuk memungkinkan pengguna untuk menentukan format sendiri dan itu jauh lebih mudah bagi saya untuk menjelaskan cara menggunakan format ini daripada mencoba untuk mengajarkan regex pengguna.

Juga nama kelas agak keliru karena sebenarnya berfungsi untuk memformat string apa pun selama Anda ingin menyimpannya dalam urutan yang sama dan hanya menyuntikkan karakter di dalamnya.

Anda dapat mencoba {0: (000) 000 - ####} jika nomor target Anda dimulai dengan 0.

Inilah cara lain untuk melakukannya.

public string formatPhoneNumber(string _phoneNum)
{
    string phoneNum = _phoneNum;
    if (phoneNum == null)
        phoneNum = "";
    phoneNum = phoneNum.PadRight(10 - phoneNum.Length);
    phoneNum = phoneNum.Insert(0, "(").Insert(4,") ").Insert(9,"-");
    return phoneNum;
}