时间戳如何转换为日期格式？MySQL、C#、JS时间戳转换方法

　　时间戳如何转换为日期格式？当初把日期格式转换为时间戳是为了更好的记录数据，现在如果想要看看当初时间戳被转换的时间，可以按照以下方法来实现，详情请阅读下文MySQL、C#、JS时间戳转换方法。

　　MySQL、C#、JS时间戳转换方法：

　　一、MySQL戳转换方法：

　　1、原理：

　　时间戳的原理是把时间格式转为十进制格式，这样就方便时间的计算，如：1377216000000 转化后是 2013年08月23日 。

　　2、步骤：

　　(1) 创建 DateUtilsl类。

　　(2) 输入代码：

1. 01importjava.text.ParseException;
2. 02importjava.text.SimpleDateFormat;
3. 03importjava.util.Date;　　
4. 04/*
5. 05* @author Msquirrel
6. 06*/
7. 07public class DateUtils {　　
8. 08privateSimpleDateFormat sf = null;
9. 09/*获取系统时间 格式为："yyyy/MM/dd "*/
10. 10public static String getCurrentDate() {
11. 11Date d = newDate();
12. 12sf = newSimpleDateFormat("yyyy年MM月dd日");
13. 13returnsf.format(d);
14. 14}　　
15. 15/*时间戳转换成字符窜*/
16. 16public static String getDateToString(long time) {
17. 17Date d = newDate(time);
18. 18sf = newSimpleDateFormat("yyyy年MM月dd日");
19. 19returnsf.format(d);
20. 20}　　
21. 21/*将字符串转为时间戳*/
22. 22public static long getStringToDate(String time) {
23. 23sdf = newSimpleDateFormat("yyyy年MM月dd日");
24. 24Date date = newDate();
25. 25try{
26. 26date = sdf.parse(time);
27. 27} catch(ParseException e) {
28. 28// TODO Auto-generated catch block
29. 29e.printStackTrace();
30. 30}
31. 31returndate.getTime();
32. 32}

importjava.text.ParseException; importjava.text.SimpleDateFormat; importjava.util.Date;　　 /* * @author Msquirrel */ public class DateUtils {　　 privateSimpleDateFormat sf = null; /*获取系统时间 格式为："yyyy/MM/dd "*/ public static String getCurrentDate() { Date d = newDate(); sf = newSimpleDateFormat("yyyy年MM月dd日"); returnsf.format(d); }　　 /*时间戳转换成字符窜*/ public static String getDateToString(long time) { Date d = newDate(time); sf = newSimpleDateFormat("yyyy年MM月dd日"); returnsf.format(d); }　　 /*将字符串转为时间戳*/ public static long getStringToDate(String time) { sdf = newSimpleDateFormat("yyyy年MM月dd日"); Date date = newDate(); try{ date = sdf.parse(time); } catch(ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } returndate.getTime(); }

　　3、在对应使用的地方调用：

1. 01DateUtils.getCurrentDate(); //获取系统当前时间　　
2. 02DateUtils.getDateToString(时间戳); //时间戳转为时间格式　　
3. 03DateUtils.getStringToDate("时间格式");//时间格式转为时间戳.

DateUtils.getCurrentDate(); //获取系统当前时间　　 DateUtils.getDateToString(时间戳); //时间戳转为时间格式　　 DateUtils.getStringToDate("时间格式");//时间格式转为时间戳.

　　二、C#时间戳转换方法：

　　C#的代码（加入了闰年）：

　　注：.Net的DateTime对象返回的是100纳秒的时间单位，年份是从AD1开始计算的。

1. 01class Program
2. 02{
3. 03// 定义必须变量
4. 04const int _1M = 60; // 分钟
5. 05const int _1H = _1M * 60; // 小时
6. 06const int _1D = _1H * 24; // 天
7. 07const long _1Y = _1D * 365; // 年(非闰年)
8. 08const long _YS = _1Y * 3 + _1D * 366; // 一个闰年年度
9. 09const long _30D = _1D * 30; // 30天(月)
10. 10const long _31D = _1D * 31; // 31天(月)
11. 11const long _28D = _1D * 28; // 28天(月)
12. 12const long _29D = _1D * 29; // 29天(月)
13. 13long[] NormalYear = { _31D, _28D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D }; // 年
14. 14long[] LeapYear = { _31D, _29D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D }; // 闰年
15. 15static void Main(string[] args)
16. 16{
17. 17Program P = new Program();
18. 18System.Console.WriteLine(P.getDate(P.getTimeSpame()));
19. 19DateTime T = DateTime.Now;
20. 20System.Console.WriteLine(P.getTimeSpame() + " : " + P.getTimeSpame(T.Year, T.Month, T.Day, T.Hour, T.Minute, T.Second));
21. 21System.Console.ReadKey();
22. 22}
23. 23private Program() {}
24. 24public string getDate(long TimeSp)
25. 25{
26. 26// 年,月,天,小时,分钟,秒
27. 27int year = 0;
28. 28int month = 0;
29. 29int day = 0;
30. 30int hour = 0;
31. 31int minute = 0;
32. 32int second = 0;
33. 33//DateTime now = DateTime.Now;
34. 34//long TimeSp = getTimeSpame(); // 当前时间戳
35. 35// 年
36. 36int _y1 = (int)(TimeSp / _YS); // 获得按年度得到的年度
37. 37TimeSp -= _YS * _y1; // 计算剩余秒
38. 38int _y2 = (int)(TimeSp / _1Y); // 剩余年
39. 39TimeSp -= _1Y * _y2;
40. 40year = _y1 * 4 + _y2 + 1970;
41. 41// 月
42. 42long[] YearArr = isLeapYear(year) ? LeapYear : NormalYear; // 获取年的月度表
43. 43month = 1; // 从1月开始计算
44. 44for (int i = 0; i < YearArr.Length; i++)
45. 45{
46. 46if (TimeSp - YearArr[i] < 0) break;
47. 47++month;
48. 48TimeSp -= YearArr[i];
49. 49}
50. 50// 天
51. 51day = (int)(TimeSp / _1D);
52. 52TimeSp -= day * _1D;
53. 53// 时
54. 54hour = (int)(TimeSp / _1H);
55. 55TimeSp -= hour * _1H;
56. 56// 分
57. 57minute = (int)(TimeSp / _1M);
58. 58// 秒
59. 59second = (int)(TimeSp % _1M);
60. 60string DateStr = year + "年" + month + "月" + day + "日 " + hour + "点" + minute + "分" + second + "秒";
61. 61return DateStr;
62. 62}
63. 63// 判断是否闰年
64. 64private bool isLeapYear(int year)
65. 65{
66. 66return (year % 4 == 0 ? true : false);
67. 67}
68. 68// 获取当前时间戳 按1970年开始计算,精度为秒!
69. 69private long getTimeSpame()
70. 70{
71. 71DateTime _Now = DateTime.Now;
72. 72DateTime _1970 = new DateTime(1970, 1, 1);
73. 73long _Sp = (_Now.Ticks - _1970.Ticks) / 10000000;
74. 74return _Sp;
75. 75}
76. 76// 按既定格式把时间转成成时间戳
77. 77private long getTimeSpame(int Year, int Month, int Day, int Hour, int Minute, int Second)
78. 78{
79. 79long val = 0;
80. 80val += Second; // 秒
81. 81val += Minute * _1M; // 分钟
82. 82val += Hour * _1H; // 小时
83. 83val += Day * _1D; // 天
84. 84long[] YearArr = isLeapYear(Year) ? LeapYear : NormalYear;
85. 85for (int i = 0; i < Month - 1; i++)
86. 86{
87. 87val += YearArr[i];
88. 88}
89. 89Year -= 1970;
90. 90val += (Year / 4) * _YS;
91. 91Year -= (int)(Year / 4) * 4;
92. 92val += Year * _1Y;
93. 93return val;
94. 94}
95. 95}

class Program { // 定义必须变量 const int _1M = 60; // 分钟 const int _1H = _1M * 60; // 小时 const int _1D = _1H * 24; // 天 const long _1Y = _1D * 365; // 年(非闰年) const long _YS = _1Y * 3 + _1D * 366; // 一个闰年年度 const long _30D = _1D * 30; // 30天(月) const long _31D = _1D * 31; // 31天(月) const long _28D = _1D * 28; // 28天(月) const long _29D = _1D * 29; // 29天(月) long[] NormalYear = { _31D, _28D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D }; // 年 long[] LeapYear = { _31D, _29D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D }; // 闰年 static void Main(string[] args) { Program P = new Program(); System.Console.WriteLine(P.getDate(P.getTimeSpame())); DateTime T = DateTime.Now; System.Console.WriteLine(P.getTimeSpame() + " : " + P.getTimeSpame(T.Year, T.Month, T.Day, T.Hour, T.Minute, T.Second)); System.Console.ReadKey(); } private Program() {} public string getDate(long TimeSp) { // 年,月,天,小时,分钟,秒 int year = 0; int month = 0; int day = 0; int hour = 0; int minute = 0; int second = 0; //DateTime now = DateTime.Now; //long TimeSp = getTimeSpame(); // 当前时间戳 // 年 int _y1 = (int)(TimeSp / _YS); // 获得按年度得到的年度 TimeSp -= _YS * _y1; // 计算剩余秒 int _y2 = (int)(TimeSp / _1Y); // 剩余年 TimeSp -= _1Y * _y2; year = _y1 * 4 + _y2 + 1970; // 月 long[] YearArr = isLeapYear(year) ? LeapYear : NormalYear; // 获取年的月度表 month = 1; // 从1月开始计算 for (int i = 0; i < YearArr.Length; i++) { if (TimeSp - YearArr[i] < 0) break; ++month; TimeSp -= YearArr[i]; } // 天 day = (int)(TimeSp / _1D); TimeSp -= day * _1D; // 时 hour = (int)(TimeSp / _1H); TimeSp -= hour * _1H; // 分 minute = (int)(TimeSp / _1M); // 秒 second = (int)(TimeSp % _1M); string DateStr = year + "年" + month + "月" + day + "日 " + hour + "点" + minute + "分" + second + "秒"; return DateStr; } // 判断是否闰年 private bool isLeapYear(int year) { return (year % 4 == 0 ? true : false); } // 获取当前时间戳 按1970年开始计算,精度为秒! private long getTimeSpame() { DateTime _Now = DateTime.Now; DateTime _1970 = new DateTime(1970, 1, 1); long _Sp = (_Now.Ticks - _1970.Ticks) / 10000000; return _Sp; } // 按既定格式把时间转成成时间戳 private long getTimeSpame(int Year, int Month, int Day, int Hour, int Minute, int Second) { long val = 0; val += Second; // 秒 val += Minute * _1M; // 分钟 val += Hour * _1H; // 小时 val += Day * _1D; // 天 long[] YearArr = isLeapYear(Year) ? LeapYear : NormalYear; for (int i = 0; i < Month - 1; i++) { val += YearArr[i]; } Year -= 1970; val += (Year / 4) * _YS; Year -= (int)(Year / 4) * 4; val += Year * _1Y; return val; } }

　　三、JS时间戳转换方法：

　　代码如下：

1. 01// 定义常量
2. 02var _1M = 60; // 分钟
3. 03var _1H = _1M * 60; // 小时
4. 04var _1D = _1H * 24; // 天
5. 05var _1Y = _1D * 365; // 年(非闰年)
6. 06var _YS = _1Y * 3 + _1D * 366; // 一个闰年年度
7. 07var _30D = _1D * 30; // 30天(月)
8. 08var _31D = _1D * 31; // 31天(月)
9. 09var _28D = _1D * 28; // 28天(月)
10. 10var _29D = _1D * 29; // 29天(月)
11. 11var NormalYear = [ _31D, _28D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D ]; // 年
12. 12var LeapYear = [ _31D, _29D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D ]; // 闰年
13. 13var Now = new Date();
14. 14TimeSp = Now.getTime() / 1000;
15. 15//alert(Now.getTimezoneOffset()); // 时区差
16. 16TimeSp += -1 * Now.getTimezoneOffset() * _1M; // 修正UTC
17. 17// 年,月,天,小时,分钟,秒
18. 18var year = month = day = hour = minute = second = 0;
19. 19// 年
20. 20var _y1 = parseInt(TimeSp / _YS); // 获得按年度得到的年度
21. 21TimeSp -= _YS * _y1; // 计算剩余秒
22. 22var _y2 = parseInt(TimeSp / _1Y); // 剩余年
23. 23TimeSp -= _1Y * _y2;
24. 24year = _y1 * 4 + _y2 + 1970;
25. 25// 月
26. 26var YearArr = year % 4 == 0 ? LeapYear : NormalYear; // 获取年的月度表
27. 27month = 1; // 从1月开始计算
28. 28for (i=0; i<YearArr.length; i++)
29. 29{
30. 30if (TimeSp - YearArr[i] < 0) break;
31. 31++month;
32. 32TimeSp -= YearArr[i];
33. 33}
34. 34// 天
35. 35day = parseInt(TimeSp / _1D);
36. 36TimeSp -= day * _1D;
37. 37// 时
38. 38hour = parseInt(TimeSp / _1H);
39. 39TimeSp -= hour * _1H;
40. 40// 分
41. 41minute = parseInt(TimeSp / _1M);
42. 42// 秒
43. 43second = parseInt(TimeSp % _1M);
44. 44var DateStr = year + "年" + month + "月" + day + "日 " + hour + "点" + minute + "分" + second + "秒";
45. 45alert(DateStr);

// 定义常量 var _1M = 60; // 分钟 var _1H = _1M * 60; // 小时 var _1D = _1H * 24; // 天 var _1Y = _1D * 365; // 年(非闰年) var _YS = _1Y * 3 + _1D * 366; // 一个闰年年度 var _30D = _1D * 30; // 30天(月) var _31D = _1D * 31; // 31天(月) var _28D = _1D * 28; // 28天(月) var _29D = _1D * 29; // 29天(月) var NormalYear = [ _31D, _28D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D ]; // 年 var LeapYear = [ _31D, _29D, _31D, _30D, _31D, _30D, _31D, _31D, _30D, _31D, _30D, _31D ]; // 闰年 var Now = new Date(); TimeSp = Now.getTime() / 1000; //alert(Now.getTimezoneOffset()); // 时区差 TimeSp += -1 * Now.getTimezoneOffset() * _1M; // 修正UTC // 年,月,天,小时,分钟,秒 var year = month = day = hour = minute = second = 0; // 年 var _y1 = parseInt(TimeSp / _YS); // 获得按年度得到的年度 TimeSp -= _YS * _y1; // 计算剩余秒 var _y2 = parseInt(TimeSp / _1Y); // 剩余年 TimeSp -= _1Y * _y2; year = _y1 * 4 + _y2 + 1970; // 月 var YearArr = year % 4 == 0 ? LeapYear : NormalYear; // 获取年的月度表 month = 1; // 从1月开始计算 for (i=0; i<YearArr.length; i++) { if (TimeSp - YearArr[i] < 0) break; ++month; TimeSp -= YearArr[i]; } // 天 day = parseInt(TimeSp / _1D); TimeSp -= day * _1D; // 时 hour = parseInt(TimeSp / _1H); TimeSp -= hour * _1H; // 分 minute = parseInt(TimeSp / _1M); // 秒 second = parseInt(TimeSp % _1M); var DateStr = year + "年" + month + "月" + day + "日 " + hour + "点" + minute + "分" + second + "秒"; alert(DateStr);

　　注：JS的Date对象的getTime()方法返回的是UTC的时间戳，可以使用getTimezoneOffset()的方法来返回与UTC时差的分钟。

　　以上代码便是MySQL、C#、JS的时间戳转换方法介绍，因为闰年的存在，代码的使用前请阅读一下。