时区计算

1、 JS

两个函数

1. 获得标准时区的时间

//获得标准时区的时间
function getLocalTime(i) {
    //参数i为时区值数字，好比北京为东八区则输入8,西5输入-5,现默认东八区北京时间
    var i=i?parseFloat(i):8; 
 
    //获得本地时间
    var d = new Date();
 
    //获得1970年一月一日到如今的秒数
    var local = d.getTime();
 
    //本地时间与GMT时间的时间偏移差
    var offset = d.getTimezoneOffset() * 60000;
 
    //获得如今的格林尼治时间
    var utcTime = local + offset;
 
    return new Date(utcTime + 3600000 * i);
}

2. 转换服务器时区时间

//转换服务器时区时间
function formatTime(t,utc){
    //t传入的时间参数,utc传入的时区参数
    if(!t) return;
 
    //获取本地时间
    var d=new Date();
 
    //得到本地时区
    utc=utc?parseFloat(utc):d.getTimezoneOffset()/60;
 
    //格式化传入时间
    var time=new Date(t);
 
    //转换传入时间为本地时间（默认传入服务器时间为东八区时间）
    time.setHours(time.getHours()+(utc-8));
 
    //输出时间
    var yy=time.getFullYear();
    var MM=time.getMonth()+1;
    MM=MM<10?'0'+MM:MM;
    var dd=time.getDate();
    dd=dd<10?'0'+dd:dd;
    var hh=time.getHours();
    hh=hh<10?'0'+hh:hh;
    var mm=time.getMinutes();
    mm=mm<10?'0'+mm:mm;
    var ss=time.getSeconds();
    ss=ss<10?'0'+ss:ss;
    var date=yy+'-'+MM+'-'+dd+' '+hh+':'+mm+':'+ss;
 
    return date;
}

利用Date对象获得本地时间

d = new Date();
localTime = d.getTime(); //经过调用Data()对象的getTime()方法，便可显示1970年1月1往后到此时时间之间的毫秒数。

接下来，经过Data()对象的getTimezoneOffset()方法来找出当地时间偏移值。在缺省状况下，此方法以分钟显示时区偏移值结果，所以在早先的计算中要将此值转换成毫秒。

localOffset = d.getTimezoneOffset() * 3600000;

而后将当前时间与时区偏移量相加，获得国际标准时间（用毫秒表示的，由于后面还须要计算，因此这里不作转换），而后与你想要知道的时区的偏移量再进行相加，获得那个时间的时间，而后再利用Date对象将其转换为时间字符串。

utc = localTime + localOffset; //获得国际标准时间  
offset = 5.5;  // 已知的时区
calctime = utc + (3600000*offset);  
nd = new Date(calctime);  
document.write('指定时区时间是：' + nd.toLocalString());

实例

场景描述：根据国外用户所在的时区，获取数据库（东八区录入）在当地所应展现的时间

function getLocalTime() {
    var d = new Date();//得到当前时间
    var gmtHours =-( d.getTimezoneOffset()/60);//根据当前时间获得你是哪一个时区的
    var date = '2014-08-12 09:25:24';//上课时间
    date=date.replace(/-/g,':').replace(' ',':');
    date=date.split(':');
    var time1 = new Date(date[0],(date[1]-1),date[2],date[3],date[4],date[5]);
    console.log("时区：" + gmtHours);
    //获得1970年一月一日到如今的秒数
    var len = time1.getTime();
    //本地时间与GMT时间的时间偏移差
    var offset = -8 * 3600000; // 东八区
    //获得如今的格林尼治时间 
    var utcTime = len + offset;
    return new Date(utcTime + 3600000 *gmtHours );
}

2、Java

1. Date中保存的是什么

在java中，只要咱们执行 Date date = new Date(); 就能够获得当前时间。如：

Date date = new Date();  
System.out.println(date);

输出结果是： Thu Aug 24 10:15:29 CST 2017

也就是我执行上述代码的时刻：2017年8月24日10点15分29秒。是否是Date对象里存了年月日时分秒呢？不是的，Date对象里存的只是一个long型的变量，其值为自1970年1月1日0点至Date对象所记录时刻通过的毫秒数，调用Date对象getTime()方法就能够返回这个毫秒数，以下代码：

Date date = new Date();  
System.out.println(date + ", " + date.getTime());

输出以下： Thu Aug 24 10:48:05 CST 2017, 1503542885955 即上述程序执行的时刻是2017年8月24日10点48分05秒，该时刻距离1970年1月1日0点通过了1503542885955毫秒。反过来讲，输出的年月日时分秒实际上是根据这个毫秒数来反算出来的。

2. 时区

全球分为24个时区，相邻时区时间相差1个小时。好比北京处于东八时区，东京处于东九时区，北京时间比东京时间晚1个小时，而英国伦敦时间比北京晚7个小时（英国采用夏令时时，8月英国处于夏令时）。好比此刻北京时间是2017年8月24日11:17:10，则东京时间是2017年8月24日12:17:10，伦敦时间是2017年8月24日4:17:10。

既然Date里存放的是当前时刻距1970年1月1日0点时刻的毫秒数，若是此刻在伦敦、北京、东京有三个程序员同时执行以下语句：

Date date = new Date();

那这三个date对象里存的毫秒数是相同的吗？仍是北京的比东京的小3600000（北京时间比东京时间晚1小时，1小时为3600秒即3600000毫秒）？答案是，这3个Date里的毫秒数是彻底同样的。确切的说，Date对象里存的是自格林威治时间（ GMT）1970年1月1日0点至Date对象所表示时刻所通过的毫秒数。因此，若是某一时刻遍及于世界各地的程序员同时执行new Date语句，这些Date对象所存的毫秒数是彻底同样的。也就是说，Date里存放的毫秒数是与时区无关的。

继续上述例子，若是上述3个程序员调用那一刻的时间是2017年8月24日11:17:10，他们继续调用

System.out.println(date);

那么北京的程序员将会打印出2017年8月24日11:17:10，而东京的程序员会打印出2017年8月24日12:17:10，伦敦的程序员会打印出2017年8月24日4:17:10。既然Date对象只存了一个毫秒数，为何这3个毫秒数彻底相同的Date对象，能够打印出不一样的时间呢？这是由于Sysytem.out.println函数在打印时间时，会取操做系统当前所设置的时区，而后根据这个时区将同毫秒数解释成该时区的时间。固然咱们也能够手动设置时区，以将同一个Date对象按不一样的时区输出。能够作以下实验验证：

Date date = new Date(1503544630000L);  // 对应的北京时间是2017-08-24 11:17:10  
  
SimpleDateFormat bjSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");     // 北京  
bjSdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));  // 设置北京时区  
  
SimpleDateFormat tokyoSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  // 东京  
tokyoSdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));  // 设置东京时区  
  
SimpleDateFormat londonSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 伦敦  
londonSdf.setTimeZone(TimeZone.getTimeZone("Europe/London"));  // 设置伦敦时区  
  
System.out.println("毫秒数:" + date.getTime() + ", 北京时间:" + bjSdf.format(date));  
System.out.println("毫秒数:" + date.getTime() + ", 东京时间:" + tokyoSdf.format(date));  
System.out.println("毫秒数:" + date.getTime() + ", 伦敦时间:" + londonSdf.format(date));

输出为：

毫秒数:1503544630000, 北京时间:2017-08-24 11:17:10
毫秒数:1503544630000, 东京时间:2017-08-24 12:17:10
毫秒数:1503544630000, 伦敦时间:2017-08-24 04:17:10

能够看出，同一个Date对象，按不一样的时间来格式化，将获得不一样时区的时间。因而可知，Date对象里保存的毫秒数和具体输出的时间（即年月日时分秒）是模型和视图的关系，而时区（即Timezone)则决定了将同模型展现成什么样的视图。

3. 从字符串中读取时间

有时咱们会遇到从一个字符串中读取时间的要求，即从字符串中解析时间并获得一个Date对象，好比将"2017-8-24 11:17:10"解析为一个Date对象。如今问题来了，这个时间到底指的是北京时间的2017年8月24日11:17:10，仍是东京时间的2017年8月24日11:17:10？若是指的是北京时间，那么这个时间对应的东京时间2017年8月24日12:17:10；若是指的是东京时间，那么这个时间对应的北京时间就是2017年8月24日10:17:10。所以，只说年月日时分秒而不说是哪一个时区的，是有歧义的，没有歧义的作法是，给出一个时间字符串，同时指明这是哪一个时区的时间。 从字符串中解析时间的正确做法是：指定时区来解析。示例以下：

String timeStr = "2017-8-24 11:17:10"; // 字面时间  
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
sdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai")); // 设置北京时区  
Date d = sdf.parse(timeStr);  
System.out.println(sdf.format(d) + ", " + d.getTime());

输出为： 2017-08-24 11:17:10, 1503544630000,

将一个时间字符串按不一样时区来解释，获得的Date对象的值是不一样的。验证以下：

String timeStr = "2017-8-24 11:17:10"; // 字面时间  
SimpleDateFormat bjSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
bjSdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));  
Date bjDate = bjSdf.parse(timeStr);  // 解析  
System.out.println("字面时间: " + timeStr +",按北京时间来解释:" + bjSdf.format(bjDate) + ", " + bjDate.getTime());  
  
SimpleDateFormat tokyoSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  // 东京  
tokyoSdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));  // 设置东京时区  
Date tokyoDate = tokyoSdf.parse(timeStr); // 解析  
System.out.println("字面时间: " + timeStr +",按东京时间来解释:"  + tokyoSdf.format(tokyoDate) + ", " + tokyoDate.getTime());

输出为：

字面时间: 2017-8-24 11:17:10,按北京时间来解释:2017-08-24 11:17:10, 1503544630000
字面时间: 2017-8-24 11:17:10,按东京时间来解释:2017-08-24 11:17:10, 1503541030000
能够看出，对于"2017-8-24 11:17:10"这个字符串，按北京时间来解释获得Date对象的毫秒数是
1503544630000；而按东京时间来解释获得的毫秒数是1503541030000，前者正比如后者大于3600000毫秒即1个小时，正好是北京时间和东京时间的时差。这很好理解，北京时间2017-08-24 11:17:10对应的毫秒数是1503544630000，而东京时间2017-08-24 11:17:10对应的北京时间实际上是2017-08-24 10:17:10（由于北京时间比东京时间晚1个小时），北京时间2017-08-24
 10:17:10天然比北京时间2017-08-24 11:17:10少3600000毫秒。

4. 将字符串表示的时间转换成另外一个时区的时间字符串

综合以上分析，若是给定一个时间字符串，并告诉你这是某个时区的时间，要将它转换为另外一个时区的时间并输出，正确的作法是：

1. 将字符串按原时区转换成Date对象；
2. 将Date对象格式化成目标时区的时间。

好比，将北京时间"2017-8-24 11:17:10"输出成东京时间，代码为：

String timeStr = "2017-8-24 11:17:10"; // 字面时间  
SimpleDateFormat bjSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
bjSdf.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));  
Date date = bjSdf.parse(timeStr);  // 将字符串时间按北京时间解析成Date对象  
  
SimpleDateFormat tokyoSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  // 东京  
tokyoSdf.setTimeZone(TimeZone.getTimeZone("Asia/Tokyo"));  // 设置东京时区  
System.out.println("北京时间: " + timeStr +"对应的东京时间为:"  + tokyoSdf.format(date));

输出为： 北京时间:2017-8-24 11:17:10对应的东京时间为:2017-08-24 12:17:10