Java 基础语法
一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
第一个Java程序
下面看一个简单的Java程序，它将打印字符串 Hello World
public class HelloWorld {
public static void main(String []args) {
System.out.println(&Hello World&);
下面将逐步介绍如何保存、编译以及运行这个程序：
打开Notepad，把上面的代码添加进去；
把文件名保存为：HelloWorld.java；
打开cmd命令窗口，进入目标文件所在的位置，假设是C:\
在命令行窗口键入 javac HelloWorld.java& 按下enter键编译代码。如果代码没有错误，cmd命令提示符会进入下一行。（假设环境变量都设置好了）。
再键入java HelloWorld 按下Enter键就可以运行程序了
你将会在窗口看到 Hello World
C : & javac HelloWorld.java
C : & java HelloWorld
Hello World
Gif 图演示：
编写Java程序时，应注意以下几点：
大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如&MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。
Java标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关于Java标识符，有以下几点需要注意：
所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是任何字符的组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
Java修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, strictfp
在后面的章节中我们会深入讨论Java修饰符。
Java中主要有如下几种类型的变量
类变量（静态变量）
成员变量（非静态变量）
数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。
Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。
例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDUIM, LARGE }
FreshJuiceSize size;
public class FreshJuiceTest {
public static void main(String []args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice. FreshJuiceSize.MEDUIM ;
注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。
Java关键字
下面列出了Java保留字。这些保留字不能用于常量、变量、和任何标识符的名称。
抽象方法，抽象类的修饰符
断言条件是否满足
布尔数据类型
跳出循环或者label代码段
8-bit 有符号数据类型
switch语句的一个条件
和try搭配扑捉异常信息
16-bit Unicode字符数据类型
不执行循环体剩余部分
switch语句中的默认分支
循环语句，循环体至少会执行一次
64-bit双精度浮点数
if条件不成立时执行的分支
表示一个类是另一个类的子类
表示一个值在初始化之后就不能再改变了表示方法不能被重写，或者一个类不能有子类
为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
32-bit单精度浮点数
for循环语句
implements
表示一个类实现了接口
instanceof
测试一个对象是否是某个类的实例
32位整型数
接口，一种抽象的类型，仅有方法和常量的定义
64位整型数
表示方法用非java代码实现
分配新的类实例
一系列相关类组成一个包
表示私有字段，或者方法等，只能从类内部访问
表示字段只能通过类或者其子类访问子类或者在同一个包内的其他类
表示共有属性或者方法
方法返回值
表示在类级别定义，所有实例共享的
浮点数比较使用严格的规则
synchronized
表示同一时间只能由一个线程访问的代码块
表示调用当前实例或者调用另一个构造函数
定义方法可能抛出的异常
修饰不要序列化的字段
表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
标记方法不返回任何值
标记字段可能会被多个线程同时访问，而不做同步
类似于C/C++，Java也支持单行以及多行注释。注释中的字符将被Java编译器忽略。
public class HelloWorld {
public static void main(String []args){
System.out.println(&Hello World&);
空白行，或者有注释的的行，Java编译器都会忽略掉。
在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
Java 源程序与编译型运行区别
如下图所示：
下一节介绍Java编程中的类和对象。之后你将会对Java中的类和对象有更清楚的认识。
反馈内容（*必填）
截图标记颜色
联系方式(邮箱)
联系邮箱：
投稿页面：
记住登录状态
重复输入密码关于js如何将毫秒类型的时间转化成几小时几分钟前或者是日期（yyyyDDMM）
本来想省省事直接在网上找一个，结果找了好久都没有找到合适的，而且还发现好多标题为js实现，实则为Java实现，唉。。。。。。。。。。。。还是自己写吧！
function timeFmat(ms) {
var d_minutes, d_hours, d_
var timeNow = new Date().getTime();
var d = (timeNow - ms)/1;
d_days = Math.round(d / (24*60*60));
d_hours = Math.round(d / (60*60));
d_minutes = Math.round(d / 60);
d_secend = Math.round(d);
if (d_days & 0 && d_days & 2) {
return d_days + "天前";
} else if (d_days &= 0 && d_hours & 0) {
return d_hours + "小时前";
} else if (d_hours &= 0 && d_minutes & 0) {
return d_minutes + "分钟前";
} else if (d_minutes &= 0 && d_secend & 0) {
return d_secend + "秒钟前";
} else if (d_secend == 0) {
return "刚刚";
var s = new Date();
s.setTime(ms);
return (s.getFullYear() + "-" + (s.getMonth() + 1) + "-" + s.getDate() + " "+s.getHours() + ":"+s.getMinutes());
传入参数为：1L
根据时间不同返回不同：分别返回（刚刚、几秒钟前、几分钟前、几小时前、一天前、 12：24）。
> 本站内容系网友提交或本网编辑转载，其目的在于传递更多信息，并不代表本网赞同其观点和对其真实性负责。如涉及作品内容、版权和其它问题，请及时与本网联系，我们将在第一时间删除内容！
/* 编写程序,将用分钟表示的时间转换成以小时 和分钟表示的时间.使用#define来创建一个代 表60的符号常量.使用while循环来允许用户重 复键入值并当键入一个小于等于0的时间是终止循环. */ #include &stdio.h& #define T 60 int main(void) { int n, h, scanf(&quo ...
这篇文章主要介绍了基于JavaScript将表单序列化类型的数据转化成对象的处理允许对象中包含对象 的相关资料,需要的朋友可以参考下表单序列化类型的数据是指url传递的数据的格式,形如&key=value&key=value&key=value&这样的key/value的键值对.一般来说使用jQuery的$.fn.seri ...
php中时间轴开发,即显示为&刚刚&.&5分钟前&.&昨天10:23&等其实这个没什么技术含量,当然就直接贴代码,不废话了, 但是在其实开发中还是蛮有用的,譬如论坛帖子,围脖等都有相关应用 代码如下: function tranTime($time) { $rtime = date(&m- ...
方法一:Convert.ToDateTime(string) string格式有要求,必须是yyyy-MM-dd hh:mm:ss ================================================ 方法二:Convert.ToDateTime(string, IFormatProvider) DateT Date ...
在sql server数据库中,sql server日期时间格式转换字符串可以改变sql server日期和时间的格式,是每个SQL数据库用户都应该掌握的. 日期时间转字符串: Select CONVERT(varchar(100), GETDATE(), 0): 05 16 AM
Select CONVERT(varchar(10 ...
public static Long dateDiff(String startTime, String endTime, String format, String str) { // 按照传入的格式生成一个simpledateformate对象 SimpleDateFormat sd = new SimpleDateFormat(format); lon ...
由于保存的文件需要加上保存的时间,所以需要一个函数来将系统当前时间获取出来,同时转换成时间字符串,具体的时间代码如下: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 ...
直接上代码,取汉字首字母的js方法是在网上搜的,网上大部分不支持火狐,下面的js支持火狐亲测通过.如果有问题可留言相互讨论. &!-- // /* 功能:生成与中文字符串相对映的拼音首字母串 版本: V1.0 alpha */ // 汉字拼音首字母列表 本列表包含了20902个汉字,用于配合 ToChineseSpell //函数使用,本表收录的字符的 ...java语言的11大特点，你掌握了几点_仲联达吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0可签7级以上的吧50个
本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：8贴子：
java语言的11大特点，你掌握了几点
仲联达专家介绍java语言具备的11大特点。1、Java语言是简单的
Java 语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。另一方面，Java丢弃了C++中很少使用的、很难理解的、令人迷惑 的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java语言不使用指针，并提供了自动的废料收集，使得程序员不必为内存管理而担忧。
2、Java语言是一个面向对象的
Java 语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements）。Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。总之，Java语言是 一个纯的面向对象程序设计语言。
3、Java语言是分布式的
Java 语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包 括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。
4、Java语言是健壮的
Java的强类型机制、异常处理、废料的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。
5、Java语言是安全的
Java 通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以 外，Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安 全管理机制（类SecurityManager）让Java应用设置安全哨兵。
6、Java语言是体系结构中立的
Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件）,然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
7、Java语言是可移植的
这种可移植性来源于体系结构中立性，另外，Java还严格规定了各个基本数据类型的长度。Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。
8、Java语言是解释型的
Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
9、Java是高性能的
与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time)编译器技术的发展越来越接近于C++。
10、Java语言是多线程的
在 Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为 Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法， 使用该子类创建的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，因此，任何一个线程均有它的run方法，而run方法中包含 了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。
11、Java语言是动态的
Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
贴吧热议榜
使用签名档&&
保存至快速回贴Java多线程常见面试问题及解答 - ImportNew
| 标签： ,
如果你即将去一家从事大型系统研发的公司进行Java面试，不可避免的会有多线程相关的问题。下面是一些针对初学者或者新手的问题，如果你已经具备良好的基础，那么你可以跳过本文，直接尝试针对进阶水平的Java多线程编程问题及解答。
问题：进程和线程的区别
解答：一个进程对应一个程序的执行，而一个线程则是进程执行过程中的一个单独的执行序列，一个进程可以包含多个线程。线程有时候也被称为轻量级进程.
一个Java虚拟机的实例运行在一个单独的进程中，不同的线程共享Java虚拟机进程所属的堆内存。这也是为什么不同的线程可以访问同一个对象。线程彼此共享堆内存并保有他们自己独自的栈空间。这也是为什么当一个线程调用一个方法时，他的局部变量可以保证线程安全。但堆内存并不是线程安全的，必须通过显示的声明同步来确保线程安全。
问题:列举几种不同的创建线程的方法.
解答:可以通过如下几种方式：
继承Thread 类
实现Runnable 接口
使用Executor framework (这会创建一个线程池)
class Counter extends Thread {
//method where the thread execution will start
public void run(){
//logic to execute in a thread
//let’s see how to start the threads
public static void main(String[] args){
Thread t1 = new Counter();
Thread t2 = new Counter();
t1.start();
//start the first thread. This calls the run() method.
t2.start(); //this starts the 2nd thread. This calls the run() method.
class Counter extends Base implements Runnable{
//method where the thread execution will start
public void run(){
//logic to execute in a thread
//let us see how to start the threads
public static void main(String[] args){
Thread t1 = new Thread(new Counter());
Thread t2 = new Thread(new Counter());
t1.start();
//start the first thread. This calls the run() method.
t2.start();
//this starts the 2nd thread. This calls the run() method.
通过线程池来创建更有效率。
问题：推荐通过哪种方式创建线程，为什么?
解答：最好使用Runnable接口，这样你的类就不必继承Thread类，不然当你需要多重继承的时候，你将一筹莫展（我们都知道Java中的类只能继承自一个类，但可以同时实现多个接口）。在上面的例子中，因为我们要继承Base类，所以实现Runnable接口成了显而易见的选择。同时你也要注意到在不同的例子中，线程是如何启动的。按照面向对象的方法论，你应该只在希望改变父类的行为的时候才去继承他。通过实现Runnable接口来代替继承Thread类可以告诉使用者Counter是Base类型的一个对象，并会作为线程执行。
问题：简要的说明一下高级线程状态.
解答：下图说明了线程的各种状态.
o 可执行(Runnable)：当调用start()方法后，一个线程变为可执行状态，但是并不意味着他会立刻开始真正地执行。而是被放入线程池，由线程调度器根据线程优先级决定何时挂起执行。
MyThread aThread = new MyThread();
aThread.start();
//becomes runnable
o 执行中(Running)：处理器已经在执行线程的代码。他会一直运行直到被阻断，或者通过静态方法Thread.yield()自行放弃执行的机会，考虑到场景切换所带来的开销，yield()方法不应该被经常调用。
o 等待中(Waiting)：线程由于等待I/O等外部进程的处理结果而处于被阻断的状态，调用currObject.wait( )方法会使得当前线程进入等待状态，直到其它线程调用currObject.notify() 或者currObject.notifyAll() 。
o 睡眠中(Sleeping)：重载方法Thread.sleep(milliseconds)，Thread.sleep(milliseconds， nanoseconds)可以迫使Java线程进入睡眠状态（挂起）。
o 由于I/O阻塞（Blocked on I/O）：当I/O条件发生变化时（例如读取了几个字节的数据）会迁移到可执行状态。
o 由于同步阻塞中（Blocked on synchronization）: 当获取锁之后会进入执行中状态。
Thread.State
枚举类型包含了Java虚拟机支持的全部的线程状态类型，下面几点Java的线程宗旨确保了这些线程状态成为可能。
o 对象可以被任何线程共享和修改。
o 线程调度器的抢占性特性，使得线程可以随时在/不在多核处理之间切换处理器内核，这意味着方法可以在执行的过程中切换状态。否则方法中的死循环将永远阻塞CPU，并且使得不同线程的其他方法始终得不到执行。
o 为了防止线程安全问题，那些脆弱的方法或者代码块可以被锁定。这使得线程可以处于被锁定或者加锁请求处理中两种状态。
o 线程在处理I/O资源（如Sockets，文件句柄，数据库连接等）时会进入等待状态，
o 处于I/O读写中的线程不能被切换，因此他们或者以成功/失败的结果正常完成处理，或者其它线程关闭了相应的资源，迫使他进入死亡或者完成的状态。这也是为什么一个合理的超时时间可以避免线程由于I/O处理而被永远阻塞，从而导致严重的性能问题。
o 线程可以进入睡眠状态，以使得其他处于等待状态的线程有机会执行。
问题：yield和sleeping有何区别，sleep()和wait()有何区别？
解答：当一个任务调用了yield()方法，它将从执行中状态转变为可执行。而当一个任务调用了sleep()，则将从执行中状态转变为等待中/睡眠中状态。
方法wait(1000)使得当前线程睡眠1秒钟，但调用notify() 或者notifyAll()会随时唤醒线程。而sleep(1000)则会导致当前线程休眠1秒钟。
问题：为什么为了线程安全而锁定一个方法或者一个代码块称为“同步”而不是“锁定”或者“被锁定”
解答：当某个方法或者代码块被声明为”synchronized”后，保存数据的内存空间（例如堆内存）将保持被同步状态。
这意味着：当一个线程获取锁并且执行到已被声明为synchronized的方法或者代码块时，该线程首先从主堆内存空间中读取该锁定对象的所有变化，以确保其在开始执行之前拥有最新的信息。在synchronized部分执行完毕，线程准备释放锁的时候，所有针对被锁定对象的修改都将为写入主堆内存中。这样其他线程在请求锁的时候就可以获取最新的信息。
问题：线程如何进行的同步处理？你可以列举出那些同步级别？同步方法和代码块如何区别？
解答：在Java语言中，每个对象都有一个锁，一个线程可以通过关键字synchronized来申请获取某个对象的锁，关键字synchronized可以被用于方法（粗粒度锁，对性能影响较大）或代码块（细粒度锁）级别。锁定方法往往不是一个很好的选择，取而代之的我们应该只锁定那些访问共享资源的代码块，因为每一个对象都有一个锁，所以可以通过创建虚拟对象来实现代码块级别的同步，方法块级别的锁比锁定整个方法更有效。
Java虚拟机灵活的使用锁和监视器，一个监视器总体来说就是一个守卫者，他负责确保只有一个线程会在同一时间执行被同步的代码。每个监视器对应一个对象的引用，在线程执行代码块的第一条指令之前，他必须持有该引用对象的锁，否则他将无法执行这段代码。一旦他获得锁，该线程就可以进入这段受到保护的代码。当线程不论以何种方式退出代码块时，他都将释放关联对象的锁。对于静态方法，需要请求类级别的锁。
英文原文：，编译：-
译文地址：
【如需转载，请在正文中标注并保留原文链接、译文链接和译者等信息，谢谢合作！】
关于作者：
王晓杰。已过而立之年，毕业于北京工业大学，计算机科学与技术学士学位。
PMP，SCJP，SCWCD。
目前就职于高森明晨信息科技有限公司，任助理产品总监。
潜心学习中，目前主要方向为Java分布式系统架构，Java虚拟机，Android应用。
平时喜爱打篮球和厨艺。
显然楼主没用过Jprofile
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
– 好的话题、有启发的回复、值得信赖的圈子
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– UI,网页，交互和用户体验
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
& 2016 ImportNewjs实现时间显示几天前、几小时前或者几分钟前的方法集锦
作者：wo_soul
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了js实现时间显示几天前、几小时前或者几分钟前的方法,实例汇总分析了时间显示格式转换的常用思路与技巧,需要的朋友可以参考下
这里汇总了js实现时间显示几天前、几小时前或者几分钟前的常见方法。分享给大家供大家参考。具体如下：
个人做法是保存时间戳，然后在前端用jq插件做转换，比如 smart-time-ago
（通过freemarker模板）如果用freemarker模板可以这样写，别的模板类推
根据自己的意愿修改条件和输出，把你的datetime传进去即可
&#macro timeline_dt datetime=.now&
&#assign ct = (.now?long-datetime?long)/1000&
&#if ct gte &&#--n年前--&${(ct/)?int}年前
&#t&&#elseif ct gte 2592000&&#--n月前--&${(ct/2592000)?int}个月前
&#t&&#elseif ct gte 86400*2&&#--n天前--&${(ct/86400)?int}天前
&#t&&#elseif ct gte 86400&&#--1天前--&昨天
&#t&&#elseif ct gte 3600&&#--n小时前--&${(ct/3600)?int}小时前
&#t&&#elseif ct gte 60&&#--n分钟前--&${(ct/60)?int}分钟前
&#t&&#elseif ct gt 0&&#--n秒前--&${ct?int}秒前
&#t&&#else&刚刚
找到一个专门的插件PrettyTime
public static void main(String[] args) {
PrettyTime p = new PrettyTime();
System.out.println(p.format(DateUtils.addDays(new Date(), 2)));
自定义Java方法：
private final static long minute = 60 * 1000;// 1分钟
private final static long hour = 60 *// 1小时
private final static long day = 24 *// 1天
private final static long month = 31 *// 月
private final static long year = 12 *// 年
* 返回文字描述的日期
* @param date
public static String getTimeFormatText(Date date) {
if (date == null) {
long diff = new Date().getTime() - date.getTime();
long r = 0;
if (diff & year) {
r = (diff / year);
return r + "年前";
if (diff & month) {
r = (diff / month);
return r + "个月前";
if (diff & day) {
r = (diff / day);
return r + "天前";
if (diff & hour) {
r = (diff / hour);
return r + "个小时前";
if (diff & minute) {
r = (diff / minute);
return r + "分钟前";
return "刚刚";
使用js插件：（原版的timeago.js）
// Smart Time Ago v0.1.0
// Copyright 2012, Terry Tai, Pragmatic.ly
// https://pragmatic.ly/
// Licensed under the MIT license.
// /pragmaticly/smart-time-ago/blob/master/LICENSE
(function() {
TimeAgo = (function() {
function TimeAgo(element, options) {
this.startInterval = 60000;
this.init(element, options);
TimeAgo.prototype.init = function(element, options) {
this.$element = $(element);
this.options = $.extend({}, $.fn.timeago.defaults, options);
this.updateTime();
return this.startTimer();
TimeAgo.prototype.startTimer = function() {
return this.interval = setInterval((function() {
return self.refresh();
}), this.startInterval);
TimeAgo.prototype.stopTimer = function() {
return clearInterval(this.interval);
TimeAgo.prototype.restartTimer = function() {
this.stopTimer();
return this.startTimer();
TimeAgo.prototype.refresh = function() {
this.updateTime();
return this.updateInterval();
TimeAgo.prototype.updateTime = function() {
return this.$element.findAndSelf(this.options.selector).each(function() {
var timeAgoInW
timeAgoInWords = self.timeAgoInWords($(this).attr(self.options.attr));
return $(this).html(timeAgoInWords);
TimeAgo.prototype.updateInterval = function() {
var filter, newestTime, newestTimeInMinutes, newestTimeS
if (this.$element.findAndSelf(this.options.selector).length & 0) {
if (this.options.dir === "up") {
filter = ":first";
} else if (this.options.dir === "down") {
filter = ":last";
newestTimeSrc = this.$element.findAndSelf(this.options.selector).filter(filter).attr(this.options.attr);
newestTime = this.parse(newestTimeSrc);
newestTimeInMinutes = this.getTimeDistanceInMinutes(newestTime);
if (newestTimeInMinutes &= 0 && newestTimeInMinutes &= 44 && this.startInterval !== 60000) {
this.startInterval = 60000;
return this.restartTimer();
} else if (newestTimeInMinutes &= 45 && newestTimeInMinutes &= 89 && this.startInterval !== 60000 * 22) {
this.startInterval = 60000 * 22;
return this.restartTimer();
} else if (newestTimeInMinutes &= 90 && newestTimeInMinutes &= 2519 && this.startInterval !== 60000 * 30) {
this.startInterval = 60000 * 30;
return this.restartTimer();
} else if (newestTimeInMinutes &= 2520 && this.startInterval !== 60000 * 60 * 12) {
this.startInterval = 60000 * 60 * 12;
return this.restartTimer();
TimeAgo.prototype.timeAgoInWords = function(timeString) {
var absolutT
absolutTime = this.parse(timeString);
return this.distanceOfTimeInWords(absolutTime) + (this.options.lang.suffix);
TimeAgo.prototype.parse = function(iso8601) {
timeStr = $.trim(iso8601);
timeStr = timeStr.replace(/\.\d\d\d+/, "");
timeStr = timeStr.replace(/-/, "/").replace(/-/, "/");
timeStr = timeStr.replace(/T/, " ").replace(/Z/, " UTC");
timeStr = timeStr.replace(/([\+\-]\d\d)\:?(\d\d)/, " $1$2");
return new Date(timeStr);
TimeAgo.prototype.getTimeDistanceInMinutes = function(absolutTime) {
timeDistance = new Date().getTime() - absolutTime.getTime();
return Math.round((Math.abs(timeDistance) / 1000) / 60);
TimeAgo.prototype.distanceOfTimeInWords = function(absolutTime) {
dim = this.getTimeDistanceInMinutes(absolutTime);
if (dim === 0) {
return "" + this.options.lang.prefixes.lt + " " + this.options.lang.units.
} else if (dim === 1) {
return "1 " + this.options.lang.units.
} else if (dim &= 2 && dim &= 44) {
return "" + dim + " " + this.options.lang.units.
} else if (dim &= 45 && dim &= 89) {
return "" + this.options.lang.prefixes.about + " 1 " + this.options.lang.units.
} else if (dim &= 90 && dim &= 1439) {
return "" + this.options.lang.prefixes.about + " " + (Math.round(dim / 60)) + " " + this.options.lang.units.
} else if (dim &= 1440 && dim &= 2519) {
return "1 " + this.options.lang.units.
} else if (dim &= 2520 && dim &= 43199) {
return "" + (Math.round(dim / 1440)) + " " + this.options.lang.units.
} else if (dim &= 43200 && dim &= 86399) {
return "" + this.options.lang.prefixes.about + " 1 " + this.options.lang.units.
} else if (dim &= 86400 && dim &= 525599) {
return "" + (Math.round(dim / 43200)) + " " + this.options.lang.units.
} else if (dim &= 525600 && dim &= 655199) {
return "" + this.options.lang.prefixes.about + " 1 " + this.options.lang.units.
} else if (dim &= 655200 && dim &= 914399) {
return "" + this.options.lang.prefixes.over + " 1 " + this.options.lang.units.
} else if (dim &= 914400 && dim &= 1051199) {
return "" + this.options.lang.prefixes.almost + " 2 " + this.options.lang.units.
return "" + this.options.lang.prefixes.about + " " + (Math.round(dim / 525600)) + " " + this.options.lang.units.
return TimeA
$.fn.timeago = function(options) {
if (options == null) options = {};
return this.each(function() {
var $this,
$this = $(this);
data = $this.data("timeago");
if (!data) $this.data("timeago", new TimeAgo(this, options));
if (typeof options === 'string') return data[options]();
$.fn.findAndSelf = function(selector) {
return this.find(selector).add(this.filter(selector));
$.fn.timeago.Constructor = TimeA
$.fn.timeago.defaults = {
selector: 'time.timeago',
attr: 'datetime',
dir: 'up',
second: "second",
seconds: "seconds",
minute: "minute",
minutes: "minutes",
hour: "hour",
hours: "hours",
day: "day",
days: "days",
month: "month",
months: "months",
year: "year",
years: "years"
prefixes: {
lt: "less than a",
about: "about",
over: "over",
almost: "almost"
suffix: ' ago'
}).call(this);
使用js插件：（改装版（简哟版）timeago.js）中文的
(function (factory) {
if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module.
define(['jquery'], factory);
// Browser globals
factory(jQuery);
}(function ($) {
$.timeago = function(timestamp) {
if (timestamp instanceof Date) {
return inWords(timestamp);
} else if (typeof timestamp === "string") {
return inWords($.timeago.parse(timestamp));
} else if (typeof timestamp === "number") {
return inWords(new Date(timestamp));
return inWords($.timeago.datetime(timestamp));
var $t = $.
$.extend($.timeago, {
settings: {
refreshMillis: 60000,
allowFuture: false,
localeTitle: false,
cutoff: 0,
strings: {
prefixAgo: null,
prefixFromNow: null,
suffixAgo: "前",
suffixFromNow: "from now",
seconds: "1分钟",
minute: "1分钟",
minutes: "%d分钟",
hour: "1小时",
hours: "%d小时",
day: "1天",
days: "%d天",
month: "1月",
months: "%d月",
year: "1年",
years: "%d年",
wordSeparator: "",
numbers: []
inWords: function(distanceMillis) {
var $l = this.settings.
var prefix = $l.prefixA
var suffix = $l.suffixA
if (this.settings.allowFuture) {
if (distanceMillis & 0) {
prefix = $l.prefixFromN
suffix = $l.suffixFromN
var seconds = Math.abs(distanceMillis) / 1000;
var minutes = seconds / 60;
var hours = minutes / 60;
var days = hours / 24;
var years = days / 365;
function substitute(stringOrFunction, number) {
var string = $.isFunction(stringOrFunction) ? stringOrFunction(number, distanceMillis) : stringOrF
var value = ($l.numbers && $l.numbers[number]) ||
return string.replace(/%d/i, value);
var words = seconds & 45 && substitute($l.seconds, Math.round(seconds)) ||
seconds & 90 && substitute($l.minute, 1) ||
minutes & 45 && substitute($l.minutes, Math.round(minutes)) ||
minutes & 90 && substitute($l.hour, 1) ||
hours & 24 && substitute($l.hours, Math.round(hours)) ||
hours & 42 && substitute($l.day, 1) ||
days & 30 && substitute($l.days, Math.round(days)) ||
days & 45 && substitute($l.month, 1) ||
days & 365 && substitute($l.months, Math.round(days / 30)) ||
years & 1.5 && substitute($l.year, 1) ||
substitute($l.years, Math.round(years));
var separator = $l.wordSeparator || "";
if ($l.wordSeparator === undefined) { separator = " "; }
return $.trim([prefix, words, suffix].join(separator));
parse: function(iso8601) {
var s = $.trim(iso8601);
s = s.replace(/\.\d+/,""); // remove milliseconds
s = s.replace(/-/,"/").replace(/-/,"/");
s = s.replace(/T/," ").replace(/Z/," UTC");
s = s.replace(/([\+\-]\d\d)\:?(\d\d)/," $1$2"); // -04:00 -& -0400
return new Date(s);
datetime: function(elem) {
var iso8601 = $t.isTime(elem) ? $(elem).attr("datetime") : $(elem).attr("title");
return $t.parse(iso8601);
isTime: function(elem) {
// jQuery's `is()` doesn't play well with HTML5 in IE
return $(elem).get(0).tagName.toLowerCase() === "time"; // $(elem).is("time");
// functions that can be called via $(el).timeago('action')
// init is default when no action is given
// functions are called with context of a single element
var functions = {
init: function(){
var refresh_el = $.proxy(refresh, this);
refresh_el();
var $s = $t.
if ($s.refreshMillis & 0) {
setInterval(refresh_el, $s.refreshMillis);
update: function(time){
$(this).data('timeago', { datetime: $t.parse(time) });
refresh.apply(this);
updateFromDOM: function(){
$(this).data('timeago', { datetime: $t.parse( $t.isTime(this) ? $(this).attr("datetime") : $(this).attr("title") ) });
refresh.apply(this);
$.fn.timeago = function(action, options) {
var fn = action ? functions[action] : functions.
throw new Error("Unknown function name '"+ action +"' for timeago");
// each over objects here and call the requested function
this.each(function(){
fn.call(this, options);
function refresh() {
var data = prepareData(this);
var $s = $t.
if (!isNaN(data.datetime)) {
if ( $s.cutoff == 0 || distance(data.datetime) & $s.cutoff) {
$(this).text(inWords(data.datetime));
function prepareData(element) {
element = $(element);
if (!element.data("timeago")) {
element.data("timeago", { datetime: $t.datetime(element) });
var text = $.trim(element.text());
if ($t.settings.localeTitle) {
element.attr("title", element.data('timeago').datetime.toLocaleString());
} else if (text.length & 0 && !($t.isTime(element) && element.attr("title"))) {
element.attr("title", text);
return element.data("timeago");
function inWords(date) {
return $t.inWords(distance(date));
function distance(date) {
return (new Date().getTime() - date.getTime());
// fix for IE6 suckage
document.createElement("abbr");
document.createElement("time");
希望本文所述对大家的javascript程序设计有所帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具}