字符串操作
#region 格式化
/// <summary>
/// 格式化
/// </summary>
/// <param name="sInput">本身字符串</param>
/// <param name="args"></param>
/// <returns></returns>
public static string format(this string sInput, params object[] args)
{
return String.Format(sInput, args);
}
#endregion
#region 倒转字符串
/// <summary>
/// 倒转字符串
/// </summary>
public static string Reverse(this string sInput)
{
char[] chars = sInput.ToCharArray();
Array.Reverse(chars);
return new String(chars);
}
#endregion
#region 判断是否为email
/// <summary>
/// 判断是否为email
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public static bool IsEmail(string email)
{
if (string.IsNullOrWhiteSpace(email))
{
return false;
}
string pattern = "\\w+([-+.'']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
return Regex.IsMatch(email, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 判断是否为手机号
/// <summary>
/// 判断是否为手机号
/// </summary>
/// <param name="mobile"></param>
/// <returns></returns>
public static bool IsMobile(string mobile)
{
if (string.IsNullOrWhiteSpace(mobile))
{
return false;
}
string pattern = "^(13|15|18)[0-9]{9}$";
return Regex.IsMatch(mobile, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 判断是否为电话
/// <summary>
/// 判断是否为电话
/// </summary>
/// <param name="phone">0755-45784678-85</param>
/// <returns></returns>
public static bool IsPhone(string phone)
{
if (string.IsNullOrWhiteSpace(phone))
{
return false;
}
string pattern = "^(([0-9]{3,4})|[0-9]{3,4}-)?[0-9]{7,8}(-[0-9]{2,4})?$";
return Regex.IsMatch(phone, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 判断是否为邮编
/// <summary>
/// 判断是否为邮编
/// </summary>
/// <param name="phone">415118</param>
/// <returns></returns>
public static bool IsPostCode(string postcode)
{
if (string.IsNullOrWhiteSpace(postcode))
{
return false;
}
string pattern = "^[0-9]{6}$";
return Regex.IsMatch(postcode, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 是否有效的姓名
/// <summary>
/// 是否有效的姓名
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static bool IsValidName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return false;
}
string pattern = "^(([\u4e00-\u9fa5]{2,5})|([a-zA-Z]{1,10}[a-zA-Z. ]{1,20}[a-zA-Z]{1,10}))$";
return Regex.IsMatch(name, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 是否有效的中文名
/// <summary>
/// 是否有效的中文名
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static bool IsValidChineseName(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return false;
}
string pattern = "^[\u4e00-\u9fa5]{2,5}$";
return Regex.IsMatch(name, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 是否为正确的QQ号
/// <summary>
/// 是否为正确的QQ号
/// </summary>
/// <param name="qq"></param>
/// <returns></returns>
public static bool IsQQ(string qq)
{
if (string.IsNullOrWhiteSpace(qq))
{
return false;
}
string pattern = "^[1-9][0-9]{4,}$";
return Regex.IsMatch(qq, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
}
#endregion
#region 是否数字
/// <summary>
/// 是否数字
/// </summary>
/// <param name="sNumeric"></param>
/// <returns></returns>
public static bool IsNumeric(string sNumeric)
{
return (new Regex("^[\\+\\-]?[0-9]*\\.?[0-9]+$")).IsMatch(sNumeric);
}
#endregion
#region 是否整数
/// <summary>
/// 是否整数
/// </summary>
/// <param name="sNumeric"></param>
/// <returns></returns>
public static bool IsInt(string intString)
{
return (new Regex("^[\\+\\-]?[0-9]+$")).IsMatch(intString);
}
#endregion
#region 是否为正整数
/// <summary>
/// 是否为正整数
/// </summary>
/// <param name="sNumeric"></param>
/// <returns></returns>
public static bool IsPosInt(string intString)
{
return (new Regex("^[0-9]*[1-9][0-9]*$")).IsMatch(intString);
}
#endregion
#region 自定义截取字符串
/// <summary>
/// 自定义截取字符串
/// </summary>
/// <param name="str">待截取的字符串</param>
/// <param name="len">长度</param>
/// <param name="hasDots">是否带"..."</param>
/// <returns></returns>
public static string SubString(string str, int len, bool hasDots)
{
if (string.IsNullOrWhiteSpace(str)) return string.Empty;
string dots = string.Empty;
if (len >= str.Length)
return str;
if (hasDots)
dots = "...";
return str.Substring(0, len) + dots;
}
#endregion
#region 取得客户端IP地址
//获取客户端IP
public static string GetClientIP()
{
string result = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (null == result || result == String.Empty)
{
result = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];
}
if (null == result || result == String.Empty)
{
result = HttpContext.Current.Request.UserHostAddress;
}
if (null == result || result == String.Empty)
{
return "0.0.0.0";
}
if (result.Equals("::1"))
{
return "127.0.0.1";
}
return result;
}
/// <summary>
/// 将最后一位数字换为*
/// </summary>
/// <param name="ip">输入的ip</param>
/// <returns></returns>
public static string FilterLastNum(string ip)
{
string result = string.Empty;
string[] s = ip.Split(''.'');
for (int i = 0; i < s.Length - 1; i++)
{
result += s[i] + ".";
}
result += "*";
return result;
}
#endregion
#region 将ID字符串转化为int数组
/// <summary>
/// 将ID字符串转化为int数组,默认使用空格和逗号分割
/// </summary>
/// <param name="idString"></param>
/// <param name="splitChars"> </param>
/// <returns></returns>
public static List<int> ConvertFromIdString(string idString,params char[] splitChars)
{
if (!string.IsNullOrWhiteSpace(idString))
{
List<string> strings;
if(splitChars == null||splitChars.Length == 0)
{
strings = idString.Split(new []{'' '', '',''}, StringSplitOptions.RemoveEmptyEntries).ToList();
}
else
{
strings = idString.Split(splitChars, StringSplitOptions.RemoveEmptyEntries).ToList();
}
return strings.ConvertAll(DataTypeHelper.GetInt32);
}
return new List<int>();
}
#endregion
#region 获取合法的主键字符串
/// <summary>
/// 获取合法的主键字符串，比如 1,3,6,7
/// </summary>
/// <param name="strKeys"></param>
/// <returns></returns>
public static String GetLegalKeyStr(String strKeys)
{
if (String.IsNullOrWhiteSpace(strKeys))
{
return String.Empty;
}
List<String> list = new List<String>();
foreach (String key in strKeys.Split('','', '' ''))
{
if (Regex.IsMatch(key, @"^[0-9]+$", RegexOptions.Compiled))
{
list.Add(key);
}
}
list.Sort();
return String.Join(",", list.Distinct().ToArray());
}
#endregion
#region 获取合法的字典字符串
/// <summary>
/// 获取合法的字典字符串，比如 a,b,d,e
/// </summary>
/// <param name="strKeys"></param>
/// <returns></returns>
public static string GetLegalDictKey(string strKeys)
{
if (string.IsNullOrWhiteSpace(strKeys))
{
return string.Empty;
}
strKeys = strKeys.ToLower();
strKeys = Regex.Replace(strKeys, "[^,a-z0-9_]", string.Empty, RegexOptions.Compiled);
strKeys = Regex.Replace(strKeys, "[,]{2,}", ",", RegexOptions.Compiled);
strKeys = strKeys.Trim('','');
return strKeys;
}
#endregion
#region 获取合法的主键字符串
/// <summary>
/// 获取前后有,的主键字符串，比如 ,1,3,6,7,
/// </summary>
/// <param name="strKeys"></param>
/// <returns></returns>
public static string GetWrapedKeyStr(string strKeys)
{
return strKeys = string.Format(",{0},", GetLegalKeyStr(strKeys));
}
#endregion
#region 获取合法的字典字符串
/// <summary>
/// 获取有''的字典字符串，比如 ''a'',''b'',''c'',''d''
/// </summary>
/// <param name="strKeys"></param>
/// <returns></returns>
public static string GetWrapedDictKey(string strKeys)
{
strKeys = GetLegalDictKey(strKeys);
if (string.IsNullOrEmpty(strKeys))
{
return string.Empty;
}
strKeys = strKeys.Replace(",", "'',''");
return strKeys = string.Format("''{0}''", strKeys);
}
#endregion
#region 转换文件大小
/// <summary>
/// 转换文件大小
/// </summary>
/// <param name="fileSize"></param>
/// <returns></returns>
public static String FormatFileSize(long fileSize)
{
String fileSizeString = "";
if (fileSize < 1024)
{
fileSizeString = fileSize + " B";
}
else if (fileSize < 1024 * 1024)
{
fileSizeString = String.Format("{0:F2}", (double)fileSize / 1024) + " K";
}
else if (fileSize < 1024 * 1024 * 1024)
{
fileSizeString = String.Format("{0:F2}", (double)fileSize / (1024 * 1024)) + " M";
}
else
{
fileSizeString = String.Format("{0:F2}", (double)fileSize / (1024 * 1024 * 1024)) + " G";
}
return fileSizeString;
}
#endregion
#region 通过正则匹配获取值
/// <summary>
/// 通过正则匹配获取值
/// </summary>
/// <param name="input"></param>
/// <param name="pattern"></param>
/// <returns></returns>
public static GroupCollection GetPatternValue(string input, string pattern)
{
if (string.IsNullOrWhiteSpace(input))
{
return null;
}
Match match = Regex.Match(input, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
if (match.Success && match.Groups.Count > 0)
{
return match.Groups;
}
return null;
}
/// <summary>
/// 通过正则匹配获取值
/// </summary>
/// <param name="input"></param>
/// <param name="pattern"></param>
/// <returns></returns>
public static MatchCollection GetPatternValues(string input, string pattern)
{
if (string.IsNullOrWhiteSpace(input))
{
return null;
}
MatchCollection match = Regex.Matches(input, pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
return match;
}
#endregion
#region 合并路径
/// <summary>
/// 合并路径
/// </summary>
/// <param name="separator"></param>
/// <param name="path1"></param>
/// <param name="path2"></param>
/// <returns></returns>
public static string CombinPath(char separator, string path1, string path2)
{
if (string.IsNullOrWhiteSpace(path1) || string.IsNullOrWhiteSpace(path2))
{
return path1 ?? path2;
}
bool b1 = path1[path1.Length - 1] == separator;
bool b2 = path2[0] == separator;
if (b1 && b2)
{
return path1 + path2.TrimStart(separator);
}
if (b1 || b2)
{
return path1 + path2;
}
return string.Concat(path1, separator, path2);
}
/// <summary>
/// 合并路径
/// </summary>
/// <param name="separator"></param>
/// <param name="paths"></param>
/// <returns></returns>
public static string CombinPath(char separator, params string[] paths)
{
if (paths == null || paths.Length == 0)
{
return string.Empty;
}
else if (paths.Length == 1)
{
return paths[0];
}
System.Text.StringBuilder sb = new System.Text.StringBuilder(paths[0]);
for (int i = 1; i < paths.Length; ++i)
{
string path = paths[i];
if (string.IsNullOrEmpty(path))
{
continue;
}
bool b1 = sb[sb.Length - 1] == separator;
bool b2 = path[0] == separator;
if (b1 && b2)
{
sb.Append(path.TrimStart(separator));
}
else if (b1 || b2)
{
sb.Append(path);
}
else
{
sb.Append(separator);
sb.Append(path);
}
}
return sb.ToString();
}
#endregion
#region 计算页数
/// <summary>
/// 计算页数
/// </summary>
/// <param name="totalRecordCount"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public static int GetPageCount(int totalRecordCount, int pageSize)
{
return Convert.ToInt32(Math.Ceiling((double)totalRecordCount / pageSize));
}
#endregion
#region 版本比较
/// <summary>
/// 版本比较
/// </summary>
/// <param name="version1"></param>
/// <param name="version2"></param>
/// <returns></returns>
public static int CompareVersion(string version1, string version2)
{
version1 = Regex.Replace(version1, "[^0-9.]", "", RegexOptions.Compiled);
version2 = Regex.Replace(version2, "[^0-9.]", "", RegexOptions.Compiled);
if (string.IsNullOrEmpty(version1) || string.IsNullOrEmpty(version2))
{
return string.Compare(version1, version2);
}
Version v1 = new Version(version1);
Version v2 = new Version(version2);
return v1.CompareTo(v2);
}
#endregion
#region 将字符串形式的IP转换位long
///<summary>
/// 将字符串形式的IP转换位long
///</summary>
///<param name="ipAddress"></param>
///<returns></returns>
public static long IpToLong(string ipAddress)
{
if (string.IsNullOrWhiteSpace(ipAddress)) return 0;
byte[] ip_bytes = new byte[8];
string[] strArr = ipAddress.Split(new char[] { ''.'' });
if (strArr.Length != 4) return 0;
for (int i = 0; i < 4; i++)
{
byte b = 0;
if (byte.TryParse(strArr[3 - i], out b))
{
ip_bytes[i] = b;
}
else
{
return 0;
}
}
return BitConverter.ToInt64(ip_bytes, 0);
}
#endregion
#region 混淆密码(如将123456变为1****6)
/// <summary>
/// 混淆密码(如将123456变为1****6)
/// </summary>
/// <param name="passwd"></param>
/// <returns></returns>
public static string MixPasswd(string passwd)
{
if (string.IsNullOrEmpty(passwd)) return string.Empty;
char[] newPasswd = new char[passwd.Length];
int mixed = 0;
int i = 0;
Random rand = new Random();
foreach (char ch in passwd)
{
if (rand.Next(100) > 55)
{
++mixed;
newPasswd[i++] = ''*'';
}
else
{
newPasswd[i++] = ch;
}
}
i = 0;
while (mixed < passwd.Length / 2) // 至少一半替换为*
{
if (newPasswd[i] != ''*'')
{
++mixed;
newPasswd[i++] = ''*'';
}
}
return new string(newPasswd);
}
#endregion
#region 日期
/// <summary>
/// 判断今天是第几周
/// </summary>
/// <param name="date"></param>
/// <returns></returns>
public static int WeekNumber(DateTime date)
{
string firstDateText = date.Year + "-1-1";
DateTime firstDay = Convert.ToDateTime(firstDateText);
int theday;
switch (firstDay.DayOfWeek)
{
case DayOfWeek.Monday:
theday = -1;
break;
case DayOfWeek.Tuesday:
theday = 0;
break;
case DayOfWeek.Wednesday:
theday = 1;
break;
case DayOfWeek.Thursday:
theday = 2;
break;
case DayOfWeek.Friday:
theday = 3;
break;
case DayOfWeek.Saturday:
theday = 4;
break;
default:
theday = 5;
break;
}
int weekNum = (date.DayOfYear + theday) / 7 + 1;
return weekNum;
}
/// <summary>
/// 年内某周的日期范围
/// </summary>
/// <param name="yearNum"></param>
/// <param name="weekNum"></param>
/// <returns></returns>
public static String WeekRange(int yearNum, int weekNum)
{
DateTime firstOfYear = new DateTime(yearNum, 1, 1);
System.DayOfWeek dayofweek = firstOfYear.DayOfWeek;
DateTime stand = firstOfYear.AddDays(weekNum * 7);
DateTime start = default(DateTime);
DateTime end = default(DateTime);
switch (dayofweek)
{
case DayOfWeek.Monday:
start = stand.AddDays(0);
end = stand.AddDays(6);
break;
case DayOfWeek.Tuesday:
start = stand.AddDays(-1);
end = stand.AddDays(5);
break;
case DayOfWeek.Wednesday:
start = stand.AddDays(-2);
end = stand.AddDays(4);
break;
case DayOfWeek.Thursday:
start = stand.AddDays(-3);
end = stand.AddDays(3);
break;
case DayOfWeek.Friday:
start = stand.AddDays(-4);
end = stand.AddDays(2);
break;
case DayOfWeek.Saturday:
start = stand.AddDays(-5);
end = stand.AddDays(1);
break;
default:
start = stand.AddDays(-6);
end = stand.AddDays(0);
break;
}
return start.ToString("yyyy/MM/dd") + " — " + end.ToString("yyyy/MM/dd");
}
#endregion
