优大网

5 / 15

安卓中如何实现无限滚动列表

列表和网格是安卓原生应用程序中使用最广泛的两个设计组件。开发者之所以大量使用它们,因为它们虽然实现起来简单明了,但提供了简洁、优良的用户体验。

使用列表和网格的一个基本要求是,当用户向下滚动时可以动态加载数据支持无限滚动。这篇博客将教你如何在自己的应用中实现这个特性。

我们需要的一个主要组件是InfiniteScrollListener类,它实现了OnScrollListener接口。让我们直接看下面这个类的代码实现:

InfiniteScrollListener.java

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
public abstract class InfiniteScrollListener implements AbsListView.OnScrollListener {
    private int bufferItemCount = 10;
    private int currentPage = 0;
    private int itemCount = 0;
    private boolean isLoading = true;
    public InfiniteScrollListener(int bufferItemCount) {
        this.bufferItemCount = bufferItemCount;
    }
    public abstract void loadMore(int page, int totalItemsCount);
    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
        // Do Nothing
    }
    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount)
    {
        if (totalItemCount < itemCount) {
            this.itemCount = totalItemCount;
            if (totalItemCount == 0) {
                this.isLoading = true; }
        }
        if (isLoading && (totalItemCount > itemCount)) {
            isLoading = false;
            itemCount = totalItemCount;
            currentPage++;
        }
        if (!isLoading && (totalItemCount - visibleItemCount)<=(firstVisibleItem + bufferItemCount)) {
            loadMore(currentPage + 1, totalItemCount);
            isLoading = true;
        }
    }
}

YourActivity.java

1
2
3
4
5
6
7
8
9
// Attach the listener to the AdapterView onCreate
yourListView.setOnScrollListener(new InfiniteScrollListener(5) {
    @Override
    public void loadMore(int page, int totalItemsCount) {
        List<HashMap<String, String>> newData = loader.loadData();
        dataList.addAll(newData);
        adapter.notifyDataSetChanged();
    }
});

如你所见,把这个类声明为抽象类。InfiniteScrollListener包含一个已实现的onScroll方法,但同时定义了一个抽象方法loadMore()——当我们继承这个类的时候需要实现该方法。

当用户滚动列表的时候,安卓运行时环境会自动调用onScroll方法。因为它会被频繁调用,所以建议避免在这个方法中做繁重的处理或者大量资源计算。

为实现无限滚动列表,我们仅需实现InfiniteScrollListener类,并使用ListView的setOnScrollListener()设置。我们可以用一个匿名类实现,就像上面第二段代码展示的那样。

在实现InfiniteScrollListener时,需要实现LoadMore方法。在此方法中我们可以生成想添加到列表中的新条目,然后使用我们适配器的notifyDataSetChanged方法添加上去。你可能要自己生成数据,也可以从数据库或者服务端加载。

这就是安卓中实现无限滚动列表所需要做的全部做工。列表是一种向用户批量展示信息同时又带来不错体验的方法。如果你的应用中已经有ListView或者你打算实现一个,下载我们的Native Ads SDK,它允许在你自己的列表中完全自定义广告。不过10分钟,在不影响用户体验的情况下,应用就可以为你赚更多的钱了。可以从这里检出代码。

17条千万流量的网站运营经验

为什么有的社区访问量能够突破千万,为什么社区活动一天的UV就高达100多万,参与活动的成员数量高达几十万,一次晒图就能引发数几万人参与,一个热门话题就能产生几千转发?

仅凭这些数据,尚不敢断言社区在移动端已经复兴,但这种过千万级的访问量和用户积极的参与程度在PC端的社区是从来没有过的。通过下文,让我们就来看看这些站长们是如何做到如上成绩的。本文由三名微社区运营者口述内容整理而成。

“当一个新产品诞生的时候,你是选择观望还是切身体验?我选择了后者。”——梦想海贼王
  
1、 基于强关系社交的产品,用户活跃度相对较高,但关键仍在于你如何利用它;

2、 有无固定用户资源决定了微社区定位,一类为内容运营,一类为客户运营;

3、 引导和培养用户使用习惯很重要,特别是对于客户服务类社区;

4、 充分利用标签等现有功能加之用户引导能起到事半功倍的效果;

5、 放权给管理员,一定要让他觉得这是自己的社区,充分发挥其能动性和影响力;

6、 设置菜单、推送图文,不放过每一个推广微社区的机会;

7、 不定期做活动绝对是社区运营的润滑剂。

起初,我是在一个行业网站上看到微社区这个产品的,但是我并不知道这个产品形态如何,价值何在。出于好奇,我开始在网络上搜索与微社区相关的各种报道。后来,我关注并体验了几个已经开通的微社区站点,第一感觉是它的内容展现形式和微博一样,发帖和回帖也基本类似,赞、收藏、分享等功能统统都有。当时我甚至想,这是要灭了微博的节奏啊?

微博用户活跃度已经开始下降,又是基于弱关系链,而微社区则依托于手Q和微信两大社交平台,如果运营的好,用户活跃度和参与的必然会高于弱关系社交。一开始我纠结于如何定义这个产品,从形式上看,它更像是手机版的论坛,但在体验上更为轻便。后来我发现微社区是什么不重要,叫啥也不重要,主要是看你怎么使用它,并让它为你或者你的用户创造价值。

总体来看微社区的运营者无非有两种,一种是没有自己的用户资源,想要借助微社区这一平台来获取这个平台上的用户,我对这类的运营者理解为内容运营。因为你要在一个平台上获取用户,你就需要取悦于他们,为他们提供喜欢的内容,例如:段子、图片、话题。另一种是有一定的用户资源,例如微信资源,使用微社区以解决多方交流屏障,增强用户互动。我对这类运营者理解为服务运营,通俗点叫客户运营,逼格点讲叫CRM。

我操盘的梦想海贼王微社区属于后者,服务运营,因为我们是手游,其次我们是一群有梦想的小伙伴,而且我们这群有梦想的小伙伴还有个共同的兴趣爱好那就是“海贼王”。我从最基础的社区搭建开始讲起。Logo、简介、信息这三块不需要太多技巧,简单明了,实事求是就好。标签我要重点说下,因为这是一个策略技巧问题,或许你可以重点利用别的地方:

由于我们入住微社区才两个月,而我们的游戏上线已经快一年了,所以用户习惯了去PC论坛和贴吧去发帖子、求助,虽然操作繁琐、复杂,他们也依然会这么做,那如果我们前期一开始就引导用户来微社区的肯定是另一份景象,因为微社区没有门槛,不需要注册账号,传东西,发东西更便捷,更高效,所以引导和培训用户习惯非常重要,特别是对于服务类运营。

一共有六个可以自定义的标签,我们开放了两个关于游戏类的使用,一个叫“游戏攻略”一个叫“互助问答”他们可以选择不同的标签,顾名思义根据标签内容发布,例如发攻略,再例发“互助问答”可以求助也可以回答别人的问题,对用户来说能高效的解决自己的疑难杂症,对我们来说前期引导好了,后期用户之间可以自助问答,缓解客服压力,节省人力,一举两得。

还有两个是“活动公告”“游戏吐槽”。这两个我一个是开放一个是关闭的,活动公告只有我自己才能用,游戏吐槽是给用户反馈意见,对游戏体验不满而设立的,每间隔一段时间我可以根据标签提取所有的问题反馈,这对一个游戏的研发和产品用户体验至关重要。在现有的功能下用好每一个小功能,再加以对用户的引导能起到事半功倍的效果。

我前面说了,因为我们有微信资源的优势,我只着重针对微信说一下我们是如何做好微社区前期推广的,我将这一阶段的工作称为“预热”。我们都知道,对男人来说美女是让他们致命的杀伤武器,对女人来说金钱是让她们冒险的动力。在推广微社区之前,我们就在微信预热,并开始招募美女管理员,这引起了一阵骚动。其次对美女管理设置了丰厚的钻石(游戏道具)奖励,然后各种写真集,爆照。

然后是“放权”。授权给这些通过投票产生的美女管理员,让她们帮我们打理、维护、运营微社区,一定要告诉她们这不是你的社区,而是她们的。钻石拉动女人,女人拉动男人,活动拉动大家,慢慢的就玩起来了。最后是“造星”。把美管捧起来,让她们有一定的影响力和粉丝群,我们的美管都有自己的粉丝,表白的更是数不胜数,自然有人会帮你哄这些美管们,有了福利和人捧她们会更热衷帮你打理社区。

预热工作做完之后,要设置微社区的入口。自定义菜单门槛比较高,需要认证的才可以,没有认证是不可以使用自定义菜单的,认证后只需要编辑模式添加菜单,把自己的微社区URL放上去即可。带锚文字的自定义回复格式如下,如果大家不会编辑这些把下面复制,替换自己想要输入的文字和自己微社区URL即可。

阅读原文是在你编辑单条、多条图文消息时,最下面原文链接那儿,把微社区URL放在那里即可,每次推送文章都是推广微社区的好办法。最后再加以文字引导,更方便用户清楚的发现,最好引导语也是你微信主题相关的,例如“我的新世界”就是海贼王剧情里的。

最后,进入真正的运营阶段。我总结出的经验是,不定期做活动绝对是运营的润滑剂。我们微社区做过各种各样的活动,下面拿两个典型的案例来跟大家分享下:

梦想海贼王微社区举办的两次活动

活动一:晒梦想大赛。我们的社区名字叫梦想海贼王,所以我们策划的活动也是跟我们有比较高的匹配度的,让人家一看就知道你的是要干嘛,说白了就是不要跑题,其次就是参与门槛低,一定要优化参与方式,减少参与步骤,一个能唤起大多数人共鸣的活动一定离不开好的策划。另外,我建议给你的活动来个牛逼哄哄的开场白。晒梦想活动大赛活动当天日PV最高10万+,参与人数五千。

活动二:路飞生日快乐。与时俱进,挖掘当下最热门的话题和内容,改编或者借鉴一下改成自己的。内容类运营找热门话题最简单了,但服务类运营的就不能随便发那些热门话题。但是一定是有话题可以挖掘的,例如刚刚赶上路飞生日,最近乌索普,明哥很火这都是热门话题,如果实在没话题你也可以制造点话题。

作为最早一批开通微社区的站点,我在这里也给新手两点建议。一是先关注一些其它优秀社区,它们一定积累了大量的经验,新手可以从它们身上学到很多宝贵经验,拿别人碰的头破血流,犯错误的经验来减少自己的犯错几率,通过对比找到自己的不足。二是积极参与线上线下各种活动和培训,千万不要自己瞎琢磨,要经常在群里跟大家交流,听大家在聊啥,遇到了什么问题,参与其中交换看法,也许你参加培训不一定能学到什么实用的经验,但是你肯定会碰到很多运营者同行他们会帮你拓宽思维。

“身为80后,刚开始上网的那几年,我每天花很多时间泡论坛,后来人人网、微博、微信渐渐流行,论坛就玩得少了。不知道微社区能否重现当年论坛的繁荣景象。”——十点读书

1、 利用微信、微博等多个渠道宣传并加以文字引导;

2、 征集话题,发布公告引导用户进入社区交流讨论;

3、 定期举办活动,以物质奖励提高用户发帖积极性;

4 一次好的活动增加百万访问量,方法比努力更重要;

5、 多与用户互动,使其成为你的忠实用户。

微博刚开始其实也有社区,叫微群。我那个时候也做了一个,刚开始挺热闹,陆续做到3万粉丝,但是后期活跃度越来越低,后来发现微群的团队自己也不太看重这个产品的运营,重点去做微吧,我也随之放弃了。

去年底,腾讯推出了微社区,我是微信端第一批内测用户,也是手机QQ端早期的用户之一。目前微信上访问量近700万,手机QQ上有7万9千多订阅者。在这里与大家分享一些推广和运营上的经验。

首先是推广。

先说微信平台。微社区开通之后用单图文宣传,告诉大家我的微社区如何进入,可以做什么,比如我当时介绍说大家可以在微社区发表对文章的看法,推荐大家喜欢的书,问题求助,爱读书的粉丝有了自己的社区家园等。 如果你认证了,有自定义菜单,那就在自定义菜单中加上微社区链接,这是最好、最有效果的办法。

另外,我在关注自动回复中加入微社区地址,粉丝一关注我微信就可以先进入微社区体验,我还设置了个自动回复“BBS”也可以进入社区,方便粉丝下次进入。每天都尽量在推送文章的底部“阅读原文”加上微社区地址,并且加一句话提醒,“欢迎点底部阅读原文进微社区交流讨论”。

再说微博平台。在微博上宣传,说微信号里开通了一个微社区,相当于bbs,大家加微信就可以进入讨论,交流读书心得。吸引一些粉丝关注微信,来体验微社区。 之后,手机QQ也开始上线微社区,我开始在微博宣传,也在微信文末宣传,让大家上手机QQ上关注我的微社区,订阅用户当时排在所有微社区的前几名。

打开微社区,右上角有个分享,你也可以分享给你的微信QQ好友,也可以分享到微信QQ群,让大家加入微社区。

其次是内容。

引导用户发一些合适的交流、分享、求助的帖子,禁止广告等,可以写一个公告说明。平时在微信征集一些话题,让大家去微社区讨论。比如过年的时候我征集了“说说故乡的那些人那些事”,有不少粉丝参与写感动人的帖子。

十点读书微社区举办的活动

定期做一些活动,比如我和出版社合作在微信做连载,注明看连载的时候到微社区发帖有机会获得赠书。这个时候读者发帖写读后感的积极性就很高。

最后是管理。

每天有空的时候在网页或手机上去管理,互动,删帖,多在一些帖子评论,用户如果看到站长评论会很高兴的,促使他经常来社区留言互动,成为忠实用户。如果看到广告就删帖,过分的直接禁言。

可以多邀请一些活跃的用户成为管理员。我的社区本来有2位管理员,有段时间社区广告比较多,都删不过来,后来又邀请了几位活跃用户成为管理员,他们在登陆的时候看到广告就会帮忙删除。

可以设置标签,每个标签相当于一个版块。我在手机QQ微社区上看到一个”英雄联盟”的微社区里面已经有版块了,主版块里还有很多分版块,总成员达到3千多万,后来得知他们是与微社区数据打通之后的PC社区,这一点让我不得不承认DZ在移动社区方面做出的努力。

身为80后,刚开始上网的那几年,我们每天花很长时间用来泡论坛,后来人人网、QQ空间、微博、微信渐渐流行,论坛玩得少了。希望在移动互联网时代,微社区能重新开启当年论坛的繁荣景象。

“我们不会过多限制用户发帖的主题,除了广告和使用不文明用语,基本不限制玩家发言,但是社区出现舆论危机时,如果影响比较大,一定会及时解决。”——开心水族箱

1、 以活动和奖励引导用户进入并使用微社区;

2、 留住用户的前提是找对用户的胃口,投其所好;

3、 点赞等投票性质的活动可以促使用户主动传播;

4、 将运营活动周期化、固定化是培养长期用户的好办法;

5、 不限制用户发言,与意见领袖保持良好的沟通和联系。

开心水族箱一直想寻找一个可以集合大部分游戏玩家的移动端社区,我们有贴吧、论坛、微博、微信,也做过多酷社区,但是依然缺乏一个可以集合大部分玩家的手机端轻社区。今天3月初我们开通了苹果版的微社区,4月开通了安卓版微社区,如今这两个社区已经成为游戏最重要最活跃的社区,是玩家互动交友、举办活动和收集意见反馈的重要渠道。

引导用户进入并使用微社区
  
微社区刚开张时为了全方面引导玩家进入微社区,不光靠微信推送消息,我们也在微博贴吧全面发力,游戏内悬挂公告,配合以大力度的活动——萌鱼表情模仿秀,以真人秀+游戏IP结合这种玩家感兴趣的形式,并以游戏内当期热门的奖励,来引导玩家参与。

在安卓社区,因为已经有了苹果社区的认知基础,我们在玩家中预热做了一场盛大的抢楼活动,抢一楼,前五十楼,前一百五十楼都可以获得各种不同档次奖励。这个活动直接让社区在玩家中一炮而红。

引导还体现在引导玩家发高质量的帖子,我们的游戏有很多玩家互动的地方,也有分享攻略的需求,我们会通过嘉奖发攻略、分享、互助帖帮助其他玩家的用户培养用户爱发言爱分享的习惯。久而久之会有更多人分享,更多人来看。
  
发掘用户感兴趣的话题

用户来了之后就要想办法留住他们,发掘对玩家胃口的话题就很重要。我们的游戏是一款轻度休闲游戏,大部分玩家都是20-30岁之间的女性,很多是带着孩子的妈妈,他们有别于互联网上比较主流的那批用户,因此我们做活动都特别针对玩家的喜好进行考虑。比如妈妈都喜欢晒孩子,我们做过2次让玩家和游戏里小鱼的比萌大赛,效果都不错,还有各种追忆青春少女时光等情感向活动。

开心水族箱微社区举办的活动

除了大型活动以外,我们也会利用热门话题、小互动等等来吸引人气。比如在感恩节我们配合游戏活动做了看图猜蛋的互动,GM在感恩节彩蛋上画游戏里的鱼,在社区发帖让玩家来猜画的是哪条鱼,第一个猜对的可获得奖励,这个活动反响不错,相信未来还有更多好玩有趣的互动有待发掘。

促使用户主动传播

点赞活动是我们常用的一种方式,因为我们发现部分参与活动的玩家会把自己的帖子发到玩家群、贴吧等其他社区或直接发给好友让其为自己点赞,这种行为也很好的传播了我们的社区,因此点赞活动是我们常用的活动方式。

常做的点赞活动有图片点赞、作诗点赞,还有拼四格漫画等等。此外还会在游戏内页结合微社区做传播向活动——例如“装扮我的小布偶”即是让玩家装扮布偶,完成最后一步装扮后需要把自己做的独一无二的布偶发到微社区才可以领取奖励,这种方式让社区多了许多高质量UGC内容。

培养用户访问社区的习惯

要让用户形成访问社区的习惯,就要定期举行活动,并且让社区成为用户获取信息的重要渠道,我们时常会把游戏里还没出的新鱼、新活动预告放在社区,或者做个互动小活动,一般玩家对于新的东西兴趣都是最高的,因此就会很愿意参加。

总之用户能在这里获得想要的东西并且能在这个过程中获得快乐,持续感受到游戏的乐趣,并且能和一群兴趣相投的鱼友一起互动,这就是我们运营的宗旨和核心。把运营内容周期化、固定化不失为一个好方法,例如定期奖励活跃用户,定期举行主题活动,定期做互动,这种习惯的培养对于培养长期用户比较有帮助。

社区氛围的形成
  
我们不会过多限制玩家的主题,除了广告和使用不文明用语,基本不限制玩家发言,但是社区出现舆论危机时,如果影响比较大,一定会及时解决。社区的氛围受游戏里的情况影响比较深,因此风向有时候是很不确定的,在做社区时平时就要和很多意见领袖型用户保持好的沟通和联系,让他们帮忙引导社区的舆论和气氛,及时举报不良信息,健康的社区需要引导和管理,我们正在培养形成互动有爱的玩家社区这个目标上继续努力。

原文来自:iheima   作者:郝小亮

10个精妙的Java编码最佳实践

本文由 ImportNew – liken 翻译自 jooq。欢迎加入Java小组。转载请参见文章末尾的要求。

这是一个比Josh Bloch的Effective Java规则更精妙的10条Java编码实践的列表。和Josh Bloch的列表容易学习并且关注日常情况相比,这个列表将包含涉及API/SPI设计中不常见的情况,可能有很大影响。

我在编写和维护jOOQ(Java中内部DSL建模的SQL)时遇到过这些。作为一个内部DSL,jOOQ最大限度的挑战了Java的编译器和泛型,把泛型,可变参数和重载结合在一起,Josh Bloch可能不会推荐的这种太宽泛的API。

让我与你分享10个微妙的Java编码最佳实践:

1. 牢记C++的析构函数

记得C++的析构函数?不记得了?那么你真的很幸运,因为你不必去调试那些由于对象删除后分配的内存没有被释放而导致内存泄露的代码。感谢Sun/Oracle实现的垃圾回收机制吧!

尽管如此,析构函数仍提供了一个有趣的特征。它理解逆分配顺序释放内存。记住在Java中也是这样的,当你操作类析构函数语法:

  • 使用JUnit的@Before和@After注释
  • 分配,释放JDBC资源
  • 调用super方法

还有其他各种用例。这里有一个具体的例子,说明如何实现一些事件侦听器的SPI:

1
2
3
4
5
6
7
8
9
10
11
@Override
public void beforeEvent(EventContext e) {
    super.beforeEvent(e);
    // Super code before my code
}
@Override
public void afterEvent(EventContext e) {
    // Super code after my code
    super.afterEvent(e);
}

臭名昭著的哲学家就餐问题是另一个说明它为什么重要的好例子。 关于哲学家用餐的问题,请查看链接:
http://adit.io/posts/2013-05-11-The-Dining-Philosophers-Problem-With-Ron-Swanson.html

规则:无论何时使用before/after, allocate/free, take/return语义实现逻辑时,考虑是否逆序执行after/free/return操作。

2. 不要相信你早期的SPI演进判断

向客户提供SPI可以使他们轻松的向你的库/代码中注入自定义行为的方法。当心你的SPI演进判断可能会迷惑你,使你认为你 (不)打算需要附加参数 当然,不应当过早增加功能。但一旦你发布了你的SPI,一旦你决定遵循语义版本控制,当你意识到在某种情况下你可能需要另外一个参数时,你会真的后悔在SPI中增加一个愚蠢的单参数的方法:

1
2
3
4
interface EventListener {
    // Bad
    void message(String message);
}

如果你也需要消息ID和消息源,怎么办?API演进将会阻止你向上面的类型添加参数。当然,有了Java8,你可以添加一个defender方法,“防御”你早期糟糕的设计决策:

1
2
3
4
5
6
7
8
9
10
11
12
interface EventListener {
    // Bad
    default void message(String message) {
        message(message, null, null);
    }
    // Better?
    void message(
        String message,
        Integer id,
        MessageSource source
    );
}

注意,不幸的是,defender方法不能使用final修饰符
但是比起使用许多方法污染你的SPI,使用上下文对象(或者参数对象)会好很多。

1
2
3
4
5
6
7
8
9
10
interface MessageContext {
    String message();
    Integer id();
    MessageSource source();
}
interface EventListener {
    // Awesome!
    void message(MessageContext context);
}

比起EventListner SPI你可以更容易演进MessageContext API,因为很少用户会实现它。
规则: 无论何时指定SPI时,考虑使用上下文/参数对象,而不是写带有固定参数的方法。
备注: 通过专用的MessageResult类型交换结果也是一个好主意,该类型可以使用建设者API构造它。这样将大大增加SPI进化的灵活性。

3. 避免返回匿名,本地或者内部类

Swing程序员通常只要按几下快捷键即可生成成百上千的匿名类。在多数情况下,只要遵循接口、不违反SPI子类型的生命周期(SPI subtype lifecycle),这样做也无妨。 但是不要因为一个简单的原因——它们会保存对外部类的引用,就频繁的使用匿名、局部或者内部类。因为无论它们走到哪,外部类就得跟到哪。例如,在局部类的域外操作不当的话,那么整个对象图就会发生微妙的变化从而可能引起内存泄露。

规则:在编写匿名、局部或内部类前请三思能否将它转化为静态的或普通的顶级类,从而避免方法将它们的对象返回到更外层的域中。

注意:使用双层花括号来初始化简单对象:

1
2
3
4
new HashMap<String, String>() {{
  put("1", "a");
  put("2", "b");
}}

这个方法利用了 JLS §8.6规范里描述的实例初始化方法(initializer)。表面上看起来不错,但实际上不提倡这种做法。因为要是使用完全独立的HashMap对象,那么实例就不会一直保存着外部对象的引用。此外,这也会让类加载器管理更多的类。

4. 现在就开始编写SAM!

Java8的脚步近了。伴随着Java8带来了lambda表达式,无论你是否喜欢。尽管你的API用户可能会喜欢,但是你最好确保他们可以尽可能经常的使用。因此除非你的API接收简单的“标量”类型,比如int、long、String 、Date,否则让你的API尽可能经常的接收SAM。

什么是SAM?SAM是单一抽象方法[类型]。也称为函数接口,不久会被注释为@FunctionalInterface。这与规则2很配,EventListener实际上就是一个SAM。最好的SAM只有一个参数,因为这将会进一步简化lambda表达式的编写。设想编写

1
listeners.add(c -> System.out.println(c.message()));

来替代

1
2
3
4
5
6
listeners.add(new EventListener() {
  @Override
  public void message(MessageContext c) {
    System.out.println(c.message()));
  }
});

设想以JOOX的方式来处理XML。JOOX就包含很多的SAM:

1
2
3
4
5
6
7
$(document)
  // Find elements with an ID
  .find(c -> $(c).id() != null)
  // Find their child elements
  .children(c -> $(c).tag().equals("order"))
  // Print all matches
  .each(c -> System.out.println($(c)))

规则:对你的API用户好一点儿,从现在开始编写SAM/函数接口。

备注:有许多关于Java8 lambda表达式和改善的Collections API的有趣的博客:

5.避免让方法返回null

我曾写过1、2篇关于java NULLs的文章,也讲解过Java8中引入新的Optional类。从学术或实用的角度来看,这些话题还是比较有趣的。

尽管现阶段Null和NullPointerException依然是Java的硬伤,但是你仍可以设计出不会出现任何问题的API。在设计API时,应当尽可能的避免让方法返回null,因为你的用户可能会链式调用方法:

1
initialise(someArgument).calculate(data).dispatch();

从上面代码中可看出,任何一个方法都不应返回null。实际上,在通常情况下使用null会被认为相当的异类。像  jQuery或 jOOX这样的库在可迭代的对象上已完全的摒弃了null。

Null通常用在延迟初始化中。在许多情况下,在不严重影响性能的条件下,延迟初始化也应该被避免。实际上,如果涉及的数据结构过于庞大,那么就要慎用延迟初始化。

规则:无论何时方法都应避免返回null。null仅用来表示“未初始化”或“不存在”的语义。

6.设计API时永远不要返回空(null)数组或List

尽管在一些情况下方法返回值为null是可以的,但是绝不要返回空数组或空集合!请看 java.io.File.list()方法,它是这样设计的:

此方法会返回一个指定目录下所有文件或目录的字符串数组。如果目录为空(empty)那么返回的数组也为空(empty)。如果指定的路径不存在或发生I/O错误,则返回null。

因此,这个方法通常要这样使用:

1
2
3
4
5
6
7
8
9
10
11
File directory = // ...
if (directory.isDirectory()) {
  String[] list = directory.list();
  if (list != null) {
    for (String file : list) {
      // ...
    }
  }
}
1
大家觉得null检查有必要吗?大多数I/O操作会产生IOExceptions,但这个方法却只返回了null。Null是无法存放I/O错误信息的。因此这样的设计,有以下3方面的不足:
  • Null无助于发现错误
  • Null无法表明I/O错误是由File实例所对应的路径不正确引起的
  • 每个人都可能会忘记判断null情况

以集合的思维来看待问题的话,那么空的(empty)的数组或集合就是对“不存在”的最佳实现。返回空(null)数组或集合几乎是无任何实际意义的,除非用于延迟初始化。

规则:返回的数组或集合不应为null。

7. 避免状态,使用函数

HTTP的好处是无状态。所有相关的状态在每次请求和响应中转移。这是REST命名的本质:含状态传输(Representational state transfer)。在Java中这样做也很赞。当方法接收状态参数对象的时候从规则2的角度想想这件事。如果状态通过这种对象传输,而不是从外边操作状态,那么事情将会更简单。以JDBC为例。下述例子从一个存储的程序中读取一个光标。

1
2
3
4
5
6
7
8
9
10
11
12
CallableStatement s =
  connection.prepareCall("{ ? = ... }");
// Verbose manipulation of statement state:
s.registerOutParameter(1, cursor);
s.setString(2, "abc");
s.execute();
ResultSet rs = s.getObject(1);
// Verbose manipulation of result set state:
rs.next();
rs.next();

这使得JDBC API如此的古怪。每个对象都是有状态的,难以操作。具体的说,有两个主要的问题:

  • 在多线程环境很难正确的处理有状态的API
  • 很难让有状态的资源全局可用,因为状态没有被描述

规则:更多的以函数风格实现。通过方法参数转移状态。极少操作对象状态。

8. 短路式 equals()

这是一个比较容易操作的方法。在比较复杂的对象系统中,你可以获得显著的性能提升,只要你在所有对象的equals()方法中首先进行相等判断:

1
2
3
4
5
@Override
public boolean equals(Object other) {
  if (this == other) return true;
  // 其它相等判断逻辑...
}

注意,其它短路式检查可能涉及到null值检查,所以也应当加进去:

1
2
3
4
5
6
@Override
public boolean equals(Object other) {
  if (this == other) return true;
  if (other == null) return false;
  // Rest of equality logic...
}

规则: 在你所有的equals()方法中使用短路来提升性能。

9. 尽量使方法默认为final

有些人可能不同意这一条,因为使方法默认为final与Java开发者的习惯相违背。但是如果你对代码有完全的掌控,那么使方法默认为final是肯定没错的:

  • 如果你确实需要覆盖(override)一个方法(你真的需要?),你仍然可以移除final关键字
  • 你将永远不会意外地覆盖(override)任何方法

这特别适用于静态方法,在这种情况下“覆盖”(实际上是遮蔽)几乎不起作用。我最近在Apache Tika中遇到了一个很糟糕的遮蔽静态方法的例子。看一下:

TikaInputStream扩展了TaggedInputStream,以一种相对不同的实现遮蔽了它的静态get()方法。

与常规方法不同,静态方法不能互相覆盖,因为调用的地方在编译时就绑定了静态方法调用。如果你不走运,你可能会意外获得错误的方法。

规则:如果你完全掌控你的API,那么使尽可能多的方法默认为final。

10. 避免方法(T…)签名

在特殊场合下使用“accept-all”变量参数方法接收一个Object…参数就没有错的:

1
void acceptAll(Object... all);

编写这样的方法为Java生态系统带来一点儿JavaScript的感觉。当然你可能想要根据真实的情形限制实际的类型,比如String…。因为你不想要限制太多,你可能会认为用泛型T取代Object是一个好想法:

1
void acceptAll(T... all);

但是不是。T总是会被推断为Object。实际上你可能仅仅认为上述方法中不能使用泛型。更重要的是你可能认为你可以重载上述方法,但是你不能:

1
2
void acceptAll(T... all);
void acceptAll(String message, T... all);

这看起来好像你可以可选地传递一个String消息到方法。但是这个调用会发生什么呢?

1
acceptAll("Message", 123, "abc");

编译器将T推断为<? extends Serializable & Comparable<?>>,这将会使调用不明确!

所以无论何时你有一个“accept-all”签名(即使是泛型),你将永远不能类型安全地重载它。API使用者可能仅仅在走运的时候才会让编译器“偶然地”选择“正确的”方法。但是也可能使用accept-all方法或者无法调用任何方法。

规则: 如果可能,避免“accept-all”签名。如果不能,不要重载这样的方法。

结论

Java是一个野兽。不像其它更理想主义的语言,它慢慢地演进为今天的样子。这可能是一件好事,因为以Java的开发速度就已经有成百上千个警告,而且这些警告只能通过多年的经验去把握。

Google Java编程风格指南

http://hawstein.com/posts/google-java-style.html

Google Java编程风格指南

January 20, 2014
作者:Hawstein
出处:http://hawstein.com/posts/google-java-style.html
声明:本文采用以下协议进行授权: 自由转载-非商用-非衍生-保持署名|Creative Commons BY-NC-ND 3.0 ,转载请注明作者及出处。

目录

  1. 前言
  2. 源文件基础
  3. 源文件结构
  4. 格式
  5. 命名约定
  6. 编程实践
  7. Javadoc
  8. 后记

前言

这份文档是Google Java编程风格规范的完整定义。当且仅当一个Java源文件符合此文档中的规则, 我们才认为它符合Google的Java编程风格。

与其它的编程风格指南一样,这里所讨论的不仅仅是编码格式美不美观的问题, 同时也讨论一些约定及编码标准。然而,这份文档主要侧重于我们所普遍遵循的规则, 对于那些不是明确强制要求的,我们尽量避免提供意见。

1.1 术语说明

在本文档中,除非另有说明:

  1. 术语class可表示一个普通类,枚举类,接口或是annotation类型(@interface)
  2. 术语comment只用来指代实现的注释(implementation comments),我们不使用“documentation comments”一词,而是用Javadoc。

其他的术语说明会偶尔在后面的文档出现。

1.2 指南说明

本文档中的示例代码并不作为规范。也就是说,虽然示例代码是遵循Google编程风格,但并不意味着这是展现这些代码的唯一方式。 示例中的格式选择不应该被强制定为规则。

源文件基础

2.1 文件名

源文件以其最顶层的类名来命名,大小写敏感,文件扩展名为.java

2.2 文件编码:UTF-8

源文件编码格式为UTF-8。

2.3 特殊字符

2.3.1 空白字符

除了行结束符序列,ASCII水平空格字符(0x20,即空格)是源文件中唯一允许出现的空白字符,这意味着:

  1. 所有其它字符串中的空白字符都要进行转义。
  2. 制表符不用于缩进。

2.3.2 特殊转义序列

对于具有特殊转义序列的任何字符(\b, \t, \n, \f, \r, \“, \‘及\),我们使用它的转义序列,而不是相应的八进制(比如\012)或Unicode(比如\u000a)转义。

2.3.3 非ASCII字符

对于剩余的非ASCII字符,是使用实际的Unicode字符(比如∞),还是使用等价的Unicode转义符(比如\u221e),取决于哪个能让代码更易于阅读和理解。

Tip: 在使用Unicode转义符或是一些实际的Unicode字符时,建议做些注释给出解释,这有助于别人阅读和理解。

例如:

String unitAbbrev = "μs";                                 | 赞,即使没有注释也非常清晰
String unitAbbrev = "\u03bcs"; // "μs"                    | 允许,但没有理由要这样做
String unitAbbrev = "\u03bcs"; // Greek letter mu, "s"    | 允许,但这样做显得笨拙还容易出错
String unitAbbrev = "\u03bcs";                            | 很糟,读者根本看不出这是什么
return '\ufeff' + content; // byte order mark             | Good,对于非打印字符,使用转义,并在必要时写上注释

Tip: 永远不要由于害怕某些程序可能无法正确处理非ASCII字符而让你的代码可读性变差。当程序无法正确处理非ASCII字符时,它自然无法正确运行, 你就会去fix这些问题的了。(言下之意就是大胆去用非ASCII字符,如果真的有需要的话)

源文件结构

一个源文件包含(按顺序地):

  1. 许可证或版权信息(如有需要)
  2. package语句
  3. import语句
  4. 一个顶级类(只有一个)

以上每个部分之间用一个空行隔开。

3.1 许可证或版权信息

如果一个文件包含许可证或版权信息,那么它应当被放在文件最前面。

3.2 package语句

package语句不换行,列限制(4.4节)并不适用于package语句。(即package语句写在一行里)

3.3 import语句

3.3.1 import不要使用通配符

即,不要出现类似这样的import语句:import java.util.*;

3.3.2 不要换行

import语句不换行,列限制(4.4节)并不适用于import语句。(每个import语句独立成行)

3.3.3 顺序和间距

import语句可分为以下几组,按照这个顺序,每组由一个空行分隔:

  1. 所有的静态导入独立成组
  2. com.google imports(仅当这个源文件是在com.google包下)
  3. 第三方的包。每个顶级包为一组,字典序。例如:android, com, junit, org, sun
  4. java imports
  5. javax imports

组内不空行,按字典序排列。

3.4 类声明

3.4.1 只有一个顶级类声明

每个顶级类都在一个与它同名的源文件中(当然,还包含.java后缀)。

例外:package-info.java,该文件中可没有package-info类。

3.4.2 类成员顺序

类的成员顺序对易学性有很大的影响,但这也不存在唯一的通用法则。不同的类对成员的排序可能是不同的。 最重要的一点,每个类应该以某种逻辑去排序它的成员,维护者应该要能解释这种排序逻辑。比如, 新的方法不能总是习惯性地添加到类的结尾,因为这样就是按时间顺序而非某种逻辑来排序的。

3.4.2.1 重载:永不分离

当一个类有多个构造函数,或是多个同名方法,这些函数/方法应该按顺序出现在一起,中间不要放进其它函数/方法。

格式

术语说明:块状结构(block-like construct)指的是一个类,方法或构造函数的主体。需要注意的是,数组初始化中的初始值可被选择性地视为块状结构(4.8.3.1节)。

4.1 大括号

4.1.1 使用大括号(即使是可选的)

大括号与if, else, for, do, while语句一起使用,即使只有一条语句(或是空),也应该把大括号写上。

4.1.2 非空块:K & R 风格

对于非空块和块状结构,大括号遵循Kernighan和Ritchie风格 (Egyptian brackets):

  • 左大括号前不换行
  • 左大括号后换行
  • 右大括号前换行
  • 如果右大括号是一个语句、函数体或类的终止,则右大括号后换行; 否则不换行。例如,如果右大括号后面是else或逗号,则不换行。

示例:

return new MyClass() {
  @Override public void method() {
    if (condition()) {
      try {
        something();
      } catch (ProblemException e) {
        recover();
      }
    }
  }
};

4.8.1节给出了enum类的一些例外。

4.1.3 空块:可以用简洁版本

一个空的块状结构里什么也不包含,大括号可以简洁地写成{},不需要换行。例外:如果它是一个多块语句的一部分(if/else 或 try/catch/finally) ,即使大括号内没内容,右大括号也要换行。

示例:

void doNothing() {}

4.2 块缩进:2个空格

每当开始一个新的块,缩进增加2个空格,当块结束时,缩进返回先前的缩进级别。缩进级别适用于代码和注释。(见4.1.2节中的代码示例)

4.3 一行一个语句

每个语句后要换行。

4.4 列限制:80或100

一个项目可以选择一行80个字符或100个字符的列限制,除了下述例外,任何一行如果超过这个字符数限制,必须自动换行。

例外:

  1. 不可能满足列限制的行(例如,Javadoc中的一个长URL,或是一个长的JSNI方法参考)。
  2. packageimport语句(见3.2节和3.3节)。
  3. 注释中那些可能被剪切并粘贴到shell中的命令行。

4.5 自动换行

术语说明:一般情况下,一行长代码为了避免超出列限制(80或100个字符)而被分为多行,我们称之为自动换行(line-wrapping)。

我们并没有全面,确定性的准则来决定在每一种情况下如何自动换行。很多时候,对于同一段代码会有好几种有效的自动换行方式。

Tip: 提取方法或局部变量可以在不换行的情况下解决代码过长的问题(是合理缩短命名长度吧)

4.5.1 从哪里断开

自动换行的基本准则是:更倾向于在更高的语法级别处断开。

  1. 如果在非赋值运算符处断开,那么在该符号前断开(比如+,它将位于下一行)。注意:这一点与Google其它语言的编程风格不同(如C++和JavaScript)。 这条规则也适用于以下“类运算符”符号:点分隔符(.),类型界限中的&(<T extends Foo & Bar>),catch块中的管道符号(catch (FooException | BarException e)
  2. 如果在赋值运算符处断开,通常的做法是在该符号后断开(比如=,它与前面的内容留在同一行)。这条规则也适用于foreach语句中的分号。
  3. 方法名或构造函数名与左括号留在同一行。
  4. 逗号(,)与其前面的内容留在同一行。

4.5.2 自动换行时缩进至少+4个空格

自动换行时,第一行后的每一行至少比第一行多缩进4个空格(注意:制表符不用于缩进。见2.3.1节)。

当存在连续自动换行时,缩进可能会多缩进不只4个空格(语法元素存在多级时)。一般而言,两个连续行使用相同的缩进当且仅当它们开始于同级语法元素。

第4.6.3水平对齐一节中指出,不鼓励使用可变数目的空格来对齐前面行的符号。

4.6 空白

4.6.1 垂直空白

以下情况需要使用一个空行:

  1. 类内连续的成员之间:字段,构造函数,方法,嵌套类,静态初始化块,实例初始化块。
    • 例外:两个连续字段之间的空行是可选的,用于字段的空行主要用来对字段进行逻辑分组。
  2. 在函数体内,语句的逻辑分组间使用空行。
  3. 类内的第一个成员前或最后一个成员后的空行是可选的(既不鼓励也不反对这样做,视个人喜好而定)。
  4. 要满足本文档中其他节的空行要求(比如3.3节:import语句)

多个连续的空行是允许的,但没有必要这样做(我们也不鼓励这样做)。

4.6.2 水平空白

除了语言需求和其它规则,并且除了文字,注释和Javadoc用到单个空格,单个ASCII空格也出现在以下几个地方:

  1. 分隔任何保留字与紧随其后的左括号(()(如if, for catch等)。
  2. 分隔任何保留字与其前面的右大括号(})(如else, catch)。
  3. 在任何左大括号前({),两个例外:
    • @SomeAnnotation({a, b})(不使用空格)。
    • String[][] x = foo;(大括号间没有空格,见下面的Note)。
  4. 在任何二元或三元运算符的两侧。这也适用于以下“类运算符”符号:
    • 类型界限中的&(<T extends Foo & Bar>)。
    • catch块中的管道符号(catch (FooException | BarException e)。
    • foreach语句中的分号。
  5. , : ;及右括号())后
  6. 如果在一条语句后做注释,则双斜杠(//)两边都要空格。这里可以允许多个空格,但没有必要。
  7. 类型和变量之间:List list。
  8. 数组初始化中,大括号内的空格是可选的,即new int[] {5, 6}new int[] { 5, 6 }都是可以的。

Note:这个规则并不要求或禁止一行的开关或结尾需要额外的空格,只对内部空格做要求。

4.6.3 水平对齐:不做要求

术语说明:水平对齐指的是通过增加可变数量的空格来使某一行的字符与上一行的相应字符对齐。

这是允许的(而且在不少地方可以看到这样的代码),但Google编程风格对此不做要求。即使对于已经使用水平对齐的代码,我们也不需要去保持这种风格。

以下示例先展示未对齐的代码,然后是对齐的代码:

private int x; // this is fine
private Color color; // this too

private int   x;      // permitted, but future edits
private Color color;  // may leave it unaligned

Tip:对齐可增加代码可读性,但它为日后的维护带来问题。考虑未来某个时候,我们需要修改一堆对齐的代码中的一行。 这可能导致原本很漂亮的对齐代码变得错位。很可能它会提示你调整周围代码的空白来使这一堆代码重新水平对齐(比如程序员想保持这种水平对齐的风格), 这就会让你做许多的无用功,增加了reviewer的工作并且可能导致更多的合并冲突。

4.7 用小括号来限定组:推荐

除非作者和reviewer都认为去掉小括号也不会使代码被误解,或是去掉小括号能让代码更易于阅读,否则我们不应该去掉小括号。 我们没有理由假设读者能记住整个Java运算符优先级表。

4.8 具体结构

4.8.1 枚举类

枚举常量间用逗号隔开,换行可选。

没有方法和文档的枚举类可写成数组初始化的格式:

private enum Suit { CLUBS, HEARTS, SPADES, DIAMONDS }

由于枚举类也是一个类,因此所有适用于其它类的格式规则也适用于枚举类。

4.8.2 变量声明

4.8.2.1 每次只声明一个变量

不要使用组合声明,比如int a, b;

4.8.2.2 需要时才声明,并尽快进行初始化

不要在一个代码块的开头把局部变量一次性都声明了(这是c语言的做法),而是在第一次需要使用它时才声明。 局部变量在声明时最好就进行初始化,或者声明后尽快进行初始化。

4.8.3 数组

4.8.3.1 数组初始化:可写成块状结构

数组初始化可以写成块状结构,比如,下面的写法都是OK的:

new int[] {
  0, 1, 2, 3 
}

new int[] {
  0,
  1,
  2,
  3
}

new int[] {
  0, 1,
  2, 3
}

new int[]
    {0, 1, 2, 3}
4.8.3.2 非C风格的数组声明

中括号是类型的一部分:String[] args, 而非String args[]

4.8.4 switch语句

术语说明:switch块的大括号内是一个或多个语句组。每个语句组包含一个或多个switch标签(case FOO:default:),后面跟着一条或多条语句。

4.8.4.1 缩进

与其它块状结构一致,switch块中的内容缩进为2个空格。

每个switch标签后新起一行,再缩进2个空格,写下一条或多条语句。

4.8.4.2 Fall-through:注释

在一个switch块内,每个语句组要么通过break, continue, return或抛出异常来终止,要么通过一条注释来说明程序将继续执行到下一个语句组, 任何能表达这个意思的注释都是OK的(典型的是用// fall through)。这个特殊的注释并不需要在最后一个语句组(一般是default)中出现。示例:

switch (input) {
  case 1:
  case 2:
    prepareOneOrTwo();
    // fall through
  case 3:
    handleOneTwoOrThree();
    break;
  default:
    handleLargeNumber(input);
}
4.8.4.3 default的情况要写出来

每个switch语句都包含一个default语句组,即使它什么代码也不包含。

4.8.5 注解(Annotations)

注解紧跟在文档块后面,应用于类、方法和构造函数,一个注解独占一行。这些换行不属于自动换行(第4.5节,自动换行),因此缩进级别不变。例如:

@Override
@Nullable
public String getNameIfPresent() { ... }

例外:单个的注解可以和签名的第一行出现在同一行。例如:

@Override public int hashCode() { ... }

应用于字段的注解紧随文档块出现,应用于字段的多个注解允许与字段出现在同一行。例如:

@Partial @Mock DataLoader loader;

参数和局部变量注解没有特定规则。

4.8.6 注释

4.8.6.1 块注释风格

块注释与其周围的代码在同一缩进级别。它们可以是/* ... */风格,也可以是// ...风格。对于多行的/* ... */注释,后续行必须从*开始, 并且与前一行的*对齐。以下示例注释都是OK的。

/*
 * This is          // And so           /* Or you can
 * okay.            // is this.          * even do this. */
 */

注释不要封闭在由星号或其它字符绘制的框架里。

Tip:在写多行注释时,如果你希望在必要时能重新换行(即注释像段落风格一样),那么使用/* ... */

4.8.7 Modifiers

类和成员的modifiers如果存在,则按Java语言规范中推荐的顺序出现。

public protected private abstract static final transient volatile synchronized native strictfp

命名约定

5.1 对所有标识符都通用的规则

标识符只能使用ASCII字母和数字,因此每个有效的标识符名称都能匹配正则表达式\w+

在Google其它编程语言风格中使用的特殊前缀或后缀,如name_mNames_namekName,在Java编程风格中都不再使用。

5.2 标识符类型的规则

5.2.1 包名

包名全部小写,连续的单词只是简单地连接起来,不使用下划线。

5.2.2 类名

类名都以UpperCamelCase风格编写。

类名通常是名词或名词短语,接口名称有时可能是形容词或形容词短语。现在还没有特定的规则或行之有效的约定来命名注解类型。

测试类的命名以它要测试的类的名称开始,以Test结束。例如,HashTestHashIntegrationTest

5.2.3 方法名

方法名都以lowerCamelCase风格编写。

方法名通常是动词或动词短语。

下划线可能出现在JUnit测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是:test<MethodUnderTest>_<state>,例如testPop_emptyStack。 并不存在唯一正确的方式来命名测试方法。

5.2.4 常量名

常量名命名模式为CONSTANT_CASE,全部字母大写,用下划线分隔单词。那,到底什么算是一个常量?

每个常量都是一个静态final字段,但不是所有静态final字段都是常量。在决定一个字段是否是一个常量时, 考虑它是否真的感觉像是一个常量。例如,如果任何一个该实例的观测状态是可变的,则它几乎肯定不会是一个常量。 只是永远不打算改变对象一般是不够的,它要真的一直不变才能将它示为常量。

// Constants
static final int NUMBER = 5;
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann");
static final Joiner COMMA_JOINER = Joiner.on(',');  // because Joiner is immutable
static final SomeMutableType[] EMPTY_ARRAY = {};
enum SomeEnum { ENUM_CONSTANT }

// Not constants
static String nonFinal = "non-final";
final String nonStatic = "non-static";
static final Set<String> mutableCollection = new HashSet<String>();
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable);
static final Logger logger = Logger.getLogger(MyClass.getName());
static final String[] nonEmptyArray = {"these", "can", "change"};

这些名字通常是名词或名词短语。

5.2.5 非常量字段名

非常量字段名以lowerCamelCase风格编写。

这些名字通常是名词或名词短语。

5.2.6 参数名

参数名以lowerCamelCase风格编写。

参数应该避免用单个字符命名。

5.2.7 局部变量名

局部变量名以lowerCamelCase风格编写,比起其它类型的名称,局部变量名可以有更为宽松的缩写。

虽然缩写更宽松,但还是要避免用单字符进行命名,除了临时变量和循环变量。

即使局部变量是final和不可改变的,也不应该把它示为常量,自然也不能用常量的规则去命名它。

5.2.8 类型变量名

类型变量可用以下两种风格之一进行命名:

  • 单个的大写字母,后面可以跟一个数字(如:E, T, X, T2)。
  • 以类命名方式(5.2.2节),后面加个大写的T(如:RequestT, FooBarT)。

5.3 驼峰式命名法(CamelCase)

驼峰式命名法分大驼峰式命名法(UpperCamelCase)和小驼峰式命名法(lowerCamelCase)。 有时,我们有不只一种合理的方式将一个英语词组转换成驼峰形式,如缩略语或不寻常的结构(例如”IPv6″或”iOS”)。Google指定了以下的转换方案。

名字从散文形式(prose form)开始:

  1. 把短语转换为纯ASCII码,并且移除任何单引号。例如:”Müller’s algorithm”将变成”Muellers algorithm”。
  2. 把这个结果切分成单词,在空格或其它标点符号(通常是连字符)处分割开。
    • 推荐:如果某个单词已经有了常用的驼峰表示形式,按它的组成将它分割开(如”AdWords”将分割成”ad words”)。 需要注意的是”iOS”并不是一个真正的驼峰表示形式,因此该推荐对它并不适用。
  3. 现在将所有字母都小写(包括缩写),然后将单词的第一个字母大写:
    • 每个单词的第一个字母都大写,来得到大驼峰式命名。
    • 除了第一个单词,每个单词的第一个字母都大写,来得到小驼峰式命名。
  4. 最后将所有的单词连接起来得到一个标识符。

示例:

Prose form                Correct               Incorrect
------------------------------------------------------------------
"XML HTTP request"        XmlHttpRequest        XMLHTTPRequest
"new customer ID"         newCustomerId         newCustomerID
"inner stopwatch"         innerStopwatch        innerStopWatch
"supports IPv6 on iOS?"   supportsIpv6OnIos     supportsIPv6OnIOS
"YouTube importer"        YouTubeImporter
                          YoutubeImporter*

加星号处表示可以,但不推荐。

Note:在英语中,某些带有连字符的单词形式不唯一。例如:”nonempty”和”non-empty”都是正确的,因此方法名checkNonemptycheckNonEmpty也都是正确的。

编程实践

6.1 @Override:能用则用

只要是合法的,就把@Override注解给用上。

6.2 捕获的异常:不能忽视

除了下面的例子,对捕获的异常不做响应是极少正确的。(典型的响应方式是打印日志,或者如果它被认为是不可能的,则把它当作一个AssertionError重新抛出。)

如果它确实是不需要在catch块中做任何响应,需要做注释加以说明(如下面的例子)。

try {
  int i = Integer.parseInt(response);
  return handleNumericResponse(i);
} catch (NumberFormatException ok) {
  // it's not numeric; that's fine, just continue
}
return handleTextResponse(response);

例外:在测试中,如果一个捕获的异常被命名为expected,则它可以被不加注释地忽略。下面是一种非常常见的情形,用以确保所测试的方法会抛出一个期望中的异常, 因此在这里就没有必要加注释。

try {
  emptyStack.pop();
  fail();
} catch (NoSuchElementException expected) {
}

6.3 静态成员:使用类进行调用

使用类名调用静态的类成员,而不是具体某个对象或表达式。

Foo aFoo = ...;
Foo.aStaticMethod(); // good
aFoo.aStaticMethod(); // bad
somethingThatYieldsAFoo().aStaticMethod(); // very bad

6.4 Finalizers: 禁用

极少会去重载Object.finalize

Tip:不要使用finalize。如果你非要使用它,请先仔细阅读和理解Effective Java 第7条款:“Avoid Finalizers”,然后不要使用它。

Javadoc

7.1 格式

7.1.1 一般形式

Javadoc块的基本格式如下所示:

/**
 * Multiple lines of Javadoc text are written here,
 * wrapped normally...
 */
public int method(String p1) { ... }

或者是以下单行形式:

/** An especially short bit of Javadoc. */

基本格式总是OK的。当整个Javadoc块能容纳于一行时(且没有Javadoc标记@XXX),可以使用单行形式。

7.1.2 段落

空行(即,只包含最左侧星号的行)会出现在段落之间和Javadoc标记(@XXX)之前(如果有的话)。 除了第一个段落,每个段落第一个单词前都有标签<p>,并且它和第一个单词间没有空格。

7.1.3 Javadoc标记

标准的Javadoc标记按以下顺序出现:@param@return@throws@deprecated, 前面这4种标记如果出现,描述都不能为空。 当描述无法在一行中容纳,连续行需要至少再缩进4个空格。

7.2 摘要片段

每个类或成员的Javadoc以一个简短的摘要片段开始。这个片段是非常重要的,在某些情况下,它是唯一出现的文本,比如在类和方法索引中。

这只是一个小片段,可以是一个名词短语或动词短语,但不是一个完整的句子。它不会以A {@code Foo} is a...This method returns...开头, 它也不会是一个完整的祈使句,如Save the record...。然而,由于开头大写及被加了标点,它看起来就像是个完整的句子。

Tip:一个常见的错误是把简单的Javadoc写成/** @return the customer ID */,这是不正确的。它应该写成/** Returns the customer ID. */

7.3 哪里需要使用Javadoc

至少在每个public类及它的每个public和protected成员处使用Javadoc,以下是一些例外:

7.3.1 例外:不言自明的方法

对于简单明显的方法如getFoo,Javadoc是可选的(即,是可以不写的)。这种情况下除了写“Returns the foo”,确实也没有什么值得写了。

单元测试类中的测试方法可能是不言自明的最常见例子了,我们通常可以从这些方法的描述性命名中知道它是干什么的,因此不需要额外的文档说明。

Tip:如果有一些相关信息是需要读者了解的,那么以上的例外不应作为忽视这些信息的理由。例如,对于方法名getCanonicalName, 就不应该忽视文档说明,因为读者很可能不知道词语canonical name指的是什么。

7.3.2 例外:重载

如果一个方法重载了超类中的方法,那么Javadoc并非必需的。

7.3.3 可选的Javadoc

对于包外不可见的类和方法,如有需要,也是要使用Javadoc的。如果一个注释是用来定义一个类,方法,字段的整体目的或行为, 那么这个注释应该写成Javadoc,这样更统一更友好。

后记

本文档翻译自Google Java Style, 作者@Hawstein

如何在Linux下统计高速网络中的流量

http://www.geekfan.net/5558/

本文由 极客范 – 彭秦进 翻译自 Dan Nanni。欢迎加入极客翻译小组,同我们一道翻译与分享。转载请参见文章末尾处的要求。

nethogs2

在Linux中有很多的流量监控工具,它们可以监控、分类网络流量,以花哨的图形用户界面提供实时流量分析报告。大多数这些工具(例如:ntopng  iftop )都是基于libpcap 库的 ,这个函数库是用来截取流经网卡的数据包的,可在用户空间用来监视分析网络流量。尽管这些工具功能齐全,然而基于libpcap库的流量监控工具无法处理高速(Gb以上)的网络接口,原因是由于在用户空间做数据包截取的系统开销过高所致。

在本文中我们介绍一种简单的Shell 脚本,它可以监控网络流量而且不依赖于缓慢的libpcap库。这些脚本支持Gb以上规模的高速网络接口,如果你对“汇聚型”的网络流量感兴趣的话,它们可统计每个网络接口上的流量。

脚本主要是基于sysfs虚拟文件系统,这是由内核用来将设备或驱动相关的信息输出到用户空间的一种机制。网络接口的相关分析数据会通过“/sys/class/net/<ethX>/statistics”输出。

举个例子,eth0的网口上分析报告会输出到这些文件中:

  • /sys/class/net/eth0/statistics/rx_packets: 收到的数据包数据
  • /sys/class/net/eth0/statistics/tx_packets: 传输的数据包数量
  • /sys/class/net/eth0/statistics/rx_bytes: 接收的字节数
  • /sys/class/net/eth0/statistics/tx_bytes: 传输的字节数
  • /sys/class/net/eth0/statistics/rx_dropped: 当收到包数据包下降的数据量
  • /sys/class/net/eth0/statistics/tx_dropped: 传输包数据包下降的数据量

这些数据会根据内核数据发生变更的时候自动刷新。因此,你可以编写一系列的脚本进行分析并计算流量统计。下面就是这样的脚本(感谢 joemiller 提供)。第一个脚本是统计每秒数据量,包含接收(RX)或发送(TX)。而后面的则是一个描述网络传输中的接收(RX)发送(TX)带宽。这些脚本中安装不需要任何的工具。

测量网口每秒数据包:

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
#!/bin/bash
INTERVAL=”1″  # update interval in seconds
if [ -z “$1” ]; then
        echo
        echo usage: $0 [network-interface]
        echo
        echo e.g. $0 eth0
        echo
        echo shows packets-per-second
        exit
fi
IF=$1
while true
do
        R1=`cat /sys/class/net/$1/statistics/rx_packets`
        T1=`cat /sys/class/net/$1/statistics/tx_packets`
        sleep $INTERVAL
        R2=`cat /sys/class/net/$1/statistics/rx_packets`
        T2=`cat /sys/class/net/$1/statistics/tx_packets`
        TXPPS=`expr $T2 – $T1`
        RXPPS=`expr $R2 – $R1`
        echo “TX $1: $TXPPS pkts/s RX $1: $RXPPS pkts/s”
done

网络带宽测量

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
#!/bin/bash
INTERVAL=”1″  # update interval in seconds
if [ -z “$1” ]; then
        echo
        echo usage: $0 [network-interface]
        echo
        echo e.g. $0 eth0
        echo
        exit
fi
IF=$1
while true
do
        R1=`cat /sys/class/net/$1/statistics/rx_bytes`
        T1=`cat /sys/class/net/$1/statistics/tx_bytes`
        sleep $INTERVAL
        R2=`cat /sys/class/net/$1/statistics/rx_bytes`
        T2=`cat /sys/class/net/$1/statistics/tx_bytes`
        TBPS=`expr $T2 – $T1`
        RBPS=`expr $R2 – $R1`
        TKBPS=`expr $TBPS / 1024`
        RKBPS=`expr $RBPS / 1024`
        echo “TX $1: $TKBPS kb/s RX $1: $RKBPS kb/s”
done

下面的屏幕截图显示了上面的两个脚本的输出。

10个用来处理键盘事件的JQuery插件和JS类库

http://www.gbtags.com/gb/share/2612.htm

10个用来处理键盘事件的JQuery插件和JS类库

申请达人,去除赞助商链接

通常在web应用或者网站中,我们使用鼠标来控制元素或者执行导航,相对于桌面应用来说,使用web应用的快捷键次数可能会相对比较少,但是对于熟练的专业人员来说,使用键盘可能更加容易并且更加快速,在今天这篇文章中,我们收集了10个jQuery的插件,帮助你创建各种基于键盘事件的web应用,相信大家会喜欢的!

1. Mousetrap

Mousetrap是一个超简单的处理键盘快捷键的类库,压缩有只有1.6kb大小,并且不依赖任何的外部类库。你使用的主要就是绑定方法。它会帮助你绑定指定的键盘命令到一个callback方法中。并且拥有第三个参数来制定监听的事件类型。 可以是keypress,keydown或者keyup。任何被空格分隔的key会被认为是连续的。如果你你连续的输入key,最后一个输入key会触发callback。

支持浏览器:

  • IE6+
  • Safari
  • Firefox
  • Chrome

2. Jwerty

jwerty是一个JS类库帮助你针对元素和事件来绑定,触发和声明输入键组合。它将难于使用的标准api生成更加清晰并且容易使用的格式。所有的jwerty事件都要求jwertycode。jwertycode可以以字符串或者数组传递,使用字符串可能是最简单的方式来生成组合。这个类库非常小,压缩后1.5kb,gzipped大概3kb。不依赖任何类库。兼容jQuery,zepto或者Ender。

3. Keypress

Keypress是一个输入捕捉类库,拥有一些特殊的特性。非常容易上手和使用,大概9kb,不依赖任何类库。可以开发非常简单或者高级的应用。这个类库针对keyup和keydown拥有一些回调函数。并且拥有选项来捕捉单次输入或者其它。

4. KeyboardJS

keyboardjs是一个标准的JS类库,处理键盘输入帮助我们理解按键输入并且生成行为。这个类库支持简单的组合按键并且支持不同LOCALE。针对press和release事件拥有回调函数

5. Keymaster.js

Keymaster是一个简单的迷你类库,用来定义和生成web应用中的键盘快捷键。不依赖任何类库。和其它类库同时使用不会有任何冲突。

6. Kibo

Kibo是一个简单的JS类库,用来处理键盘事件。没有任何依赖。Kibo的构建器拥有一个可选选项,一个用来定义事件句柄的HTML元素。

7. Keymage

Keyimage是一个简单的类库,用来处理键盘绑定。书写这个类库的目的是没有其它类库支持整合所有的特性,并且方便大家书写一个新的类库。

8. Keycode.js

这个类库标准化JS键盘码以便支持浏览器兼容。这个类库支持key对象,这些对象是js对象,用来记录键盘码是否被其它操作修改。使用hot_key()接受类似的对象,并且返回一个适合jQuery hotkey插件或者Binny VA’s short.js类库

9. Open JS

OpenJS允许你添加Keyboard快捷键到你的JS应用中

10. JavaScript Shortcuts Library

一个帮助你快速创建快捷键的类库

via codegeekz.

超实用的JavaScript技巧及最佳实践(上)

http://www.csdn.net/article/2013-12-27/2817938-45-Useful-JavaScript-Tips

摘要:JavaScript是一门非常流行的编程语言,许多开发者都会把JavaScript选为入门语言,本文向大家分享JavaScript开发的小技巧、最佳实践等非常实用的内容。

众所周知,JavaScript是一门非常流行的编程语言,开发者用它不仅可以开发出炫丽的Web程序,还可以用它来开发一些移动应用程序(如PhoneGap或Appcelerator),它还有一些服务端实现,比如NodeJS、Wakanda以及其它实现。此外,许多开发者都会把JavaScript选为入门语言,使用它来做一些弹出窗口等小东西。

在这篇文章中,作者将会向大家分享JavaScript开发的小技巧、最佳实践等非常实用的内容,不管你是前端开发者还是服务端开发者,都应该来看看这些小技巧,它们绝对会让你受益的。

文中所提供的代码片段都已经过最新版的Chrome 30测试,该浏览器使用V8 JavaScript引擎(V8 3.20.17.15)。

1.第一次给变量赋值时,别忘记var关键字

给一个未声明的变量赋值,该变量会被自动创建为全局变量,在JS开发中,应该避免使用全局变量。

2.使用===替换==

并且永远不要使用=或!=。

 

  1. [10] === 10    // is false
  2. [10]  == 10    // is true
  3. ’10’ == 10     // is true
  4. ’10’ === 10    // is false
  5.  []   == 0     // is true
  6.  [] ===  0     // is false
  7.  ” == false   // is true but true == “a” is false
  8.  ” ===   false // is false

3.使用分号来作为行终止字符

在行终止的地方使用分号是一个很好的习惯,即使开发人员忘记加分号,编译器也不会有任何提示,因为在大多数情况下,JavaScript解析器会自动加上。

4.创建构造函数

 

  1. function Person(firstName, lastName){
  2.     this.firstName =  firstName;
  3.     this.lastName = lastName;
  4. }
  5. var Saad = new Person(“Saad”, “Mousliki”);

5.应当小心使用typeof、instanceof和constructor

 

  1. var arr = [“a”, “b”, “c”];
  2. typeof arr;   // return “object”
  3. arr  instanceof Array // true
  4. arr.constructor();  //[]

6.创建一个Self-calling函数

这通常会被称为自我调用的匿名函数或立即调用函数表达式(LLFE)。当函数被创建的时候就会自动执行,好比下面这个:

 

  1. (function(){
  2.     // some private code that will be executed automatically
  3. })();
  4. (function(a,b){
  5.     var result = a+b;
  6.     return result;
  7. })(10,20)

7.给数组创建一个随机项

  1. var items = [12, 548 , ‘a’ , 2 , 5478 , ‘foo’ , 8852, , ‘Doe’ , 2145 , 119];
  2. var  randomItem = items[Math.floor(Math.random() * items.length)];

8.在特定范围里获得一个随机数

下面这段代码非常通用,当你需要生成一个假的数据用来测试时,比如在最低工资和最高之前获取一个随机值。

 

  1. var x = Math.floor(Math.random() * (max – min + 1)) + min;

9.在数字0和最大数之间生成一组随机数

  1. var numbersArray = [] , max = 100;
  2. for( var i=1; numbersArray.push(i++) < max;);  // numbers = [0,1,2,3 … 100]

10.生成一组随机的字母数字字符

 

  1. function generateRandomAlphaNum(len) {
  2.     var rdmstring = “”;
  3.     for( ; rdmString.length < len; rdmString  += Math.random().toString(36).substr(2));
  4.     return  rdmString.substr(0, len);
  5. }

11.打乱数字数组

 

  1. var numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411];
  2. numbers = numbers.sort(function(){ return Math.random() – 0.5});
  3. /* the array numbers will be equal for example to [120, 5, 228, -215, 400, 458, -85411, 122205]  */

12.字符串tim函数

trim函数可以删除字符串两端的空白字符,可以用在Java、C#、PHP等多门语言里。

 

 

  1. String.prototype.trim = function(){return this.replace(/^\s+|\s+$/g, “”);};

13.数组追加

 

  1. var array1 = [12 , “foo” , {name “Joe”} , -2458];
  2. var array2 = [“Doe” , 555 , 100];
  3. Array.prototype.push.apply(array1, array2);
  4. /* array1 will be equal to  [12 , “foo” , {name “Joe”} , -2458 , “Doe” , 555 , 100] */

14.将参数对象转换为数组 
 

  1. var argArray = Array.prototype.slice.call(arguments);

15.验证一个给定参数是否为数字

 

 

 

 

 

  1. function isNumber(n){
  2.     return !isNaN(parseFloat(n)) && isFinite(n);
  3. }

16.验证一个给定的参数为数组

 

  1. function isArray(obj){
  2.     return Object.prototype.toString.call(obj) === ‘[object Array]’ ;
  3. }

注意,如果toString()方法被重写了,你将不会得到预期结果。

 

或者你可以这样写:

 

  1. Array.isArray(obj); // its a new Array method

同样,如果你使用多个frames,你可以使用instancesof,如果内容太多,结果同样会出错。
 

  1. var myFrame = document.createElement(‘iframe’);
  2. document.body.appendChild(myFrame);
  3. var myArray = window.frames[window.frames.length-1].Array;
  4. var arr = new myArray(a,b,10); // [a,b,10]
  5. // instanceof will not work correctly, myArray loses his constructor
  6. // constructor is not shared between frames
  7. arr instanceof Array; // false

 

17.从数字数组中获得最大值和最小值

 

  1. var  numbers = [5, 458 , 120 , -215 , 228 , 400 , 122205, -85411];
  2. var maxInNumbers = Math.max.apply(Math, numbers);
  3. var minInNumbers = Math.min.apply(Math, numbers);

18.清空数组

 

  1. var myArray = [12 , 222 , 1000 ];
  2. myArray.length = 0; // myArray will be equal to [].

19.不要用delete从数组中删除项目

开发者可以使用split来代替使用delete来删除数组项。与其删除数组中未定义项目,还不如使用delete来替代。

 

  1. var items = [12, 548 ,’a’ , 2 , 5478 , ‘foo’ , 8852, , ‘Doe’ ,2154 , 119 ];
  2. items.length; // return 11
  3. delete items[3]; // return true
  4. items.length; // return 11
  5. /* items will be equal to [12, 548, “a”, undefined × 1, 5478, “foo”, 8852, undefined × 1, “Doe”, 2154,       119]   */

也可以……

 

  1. var items = [12, 548 ,’a’ , 2 , 5478 , ‘foo’ , 8852, , ‘Doe’ ,2154 , 119 ];
  2. items.length; // return 11
  3. items.splice(3,1) ;
  4. items.length; // return 10
  5. /* items will be equal to [12, 548, “a”, 5478, “foo”, 8852, undefined × 1, “Doe”, 2154,       119]   */

delete方法应该删除一个对象属性。

 
20.使用length属性缩短数组

如上文提到的清空数组,开发者还可以使用length属性缩短数组。

 

  1. var myArray = [12 , 222 , 1000 , 124 , 98 , 10 ];
  2. myArray.length = 4; // myArray will be equal to [12 , 222 , 1000 , 124].

如果你所定义的数组长度值过高,那么数组的长度将会改变,并且会填充一些未定义的值到数组里,数组的length属性不是只读的。
 

  1. myArray.length = 10; // the new array length is 10
  2. myArray[myArray.length – 1] ; // undefined

 

来自: flippinawesome

超实用的JavaScript技巧及最佳实践(下)

http://www.csdn.net/article/2014-01-06/2818025-Useful-JavaScript-Tips-Best-Practices

摘要:JavaScript是一门非常流行的编程语言,许多开发者都会把JavaScript选为入门语言,本文向大家分享JavaScript开发的小技巧、最佳实践等非常实用的内容。

在前段时间,CSDN研发频道发表了超实用的JavaScript技巧及最佳实践(上),很多开发者都觉得里面所提到的技巧非常实用,基于此,我们再向大家推荐超实用的JavaScript技巧及最佳实践(下),希望对大家有所帮助。

文中所提供的代码片段都已经过最新版的Chrome 30测试,该浏览器使用V8 JavaScript引擎(V8 3.20.17.15)。

1.使用逻辑符号&&或者||进行条件判断

 

  1. var foo = 10;
  2. foo == 10 && doSomething(); // is the same thing as if (foo == 10) doSomething();
  3. foo == 5 || doSomething(); // is the same thing as if (foo != 5) doSomething();

||也可以用来设置函数参数的默认值

  1. Function doSomething(arg1){
  2.     Arg1 = arg1 || 10; // arg1 will have 10 as a default value if it’s not already set
  3. }

2.使用map()方法来遍历数组 

 

  1. var squares = [1,2,3,4].map(function (val) {
  2.     return val * val;
  3. });
  4. // squares will be equal to [1, 4, 9, 16]

3.舍入小数位数 

 

  1. var num =2.443242342;
  2. num = num.toFixed(4);  // num will be equal to 2.4432

4.浮点数问题 

 

  1. 0.1 + 0.2 === 0.3 // is false
  2. 9007199254740992 + 1 // is equal to 9007199254740992
  3. 9007199254740992 + 2 // is equal to 9007199254740994

0.1+0.2等于0.30000000000000004,为什么会发生这种情况?根据IEEE754标准,你需要知道的是所有JavaScript数字在64位二进制内的都表示浮点数。开发者可以使用toFixed()和toPrecision()方法来解决这个问题。

5.使用for-in loop检查遍历对象属性 

下面这段代码主要是为了避免遍历对象属性。

 

  1. for (var name in object) {
  2.     if (object.hasOwnProperty(name)) {
  3.         // do something with name
  4.     }
  5. }

6.逗号操作符 

 

  1. var a = 0;
  2. var b = ( a++, 99 );
  3. console.log(a);  // a will be equal to 1
  4. console.log(b);  // b is equal to 99

7.计算或查询缓存变量 

在使用jQuery选择器的情况下,开发者可以缓存DOM元素

 

  1. var navright = document.querySelector(‘#right’);
  2. var navleft = document.querySelector(‘#left’);
  3. var navup = document.querySelector(‘#up’);
  4. var navdown = document.querySelector(‘#down’);

8.在将参数传递到isFinite()之前进行验证 

 

  1. isFinite(0/0) ; // false
  2. isFinite(“foo”); // false
  3. isFinite(“10”); // true
  4. isFinite(10);   // true
  5. isFinite(undifined);  // false
  6. isFinite();   // false
  7. isFinite(null);  // true  !!!

9.在数组中避免负向索引 

 

  1. var numbersArray = [1,2,3,4,5];
  2. var from = numbersArray.indexOf(“foo”) ;  // from is equal to -1
  3. numbersArray.splice(from,2);    // will return [5]

确保参数传递到indexOf()方法里是非负向的。

10.(使用JSON)序列化和反序列化 

 

  1. var person = {name :’Saad’, age : 26, department : {ID : 15, name : “R&D”} };
  2. var stringFromPerson = JSON.stringify(person);
  3. /* stringFromPerson is equal to “{“name”:”Saad”,”age”:26,”department”:{“ID”:15,”name”:”R&D”}}”   */
  4. var personFromString = JSON.parse(stringFromPerson);
  5. /* personFromString is equal to person object  */

11.避免使用eval()或Function构造函数 

eval()和Function构造函数被称为脚本引擎,每次执行它们的时候都必须把源码转换成可执行的代码,这是非常昂贵的操作。

 

  1. var func1 = new Function(functionCode);
  2. var func2 = eval(functionCode);

12.避免使用with()方法 

如果在全局区域里使用with()插入变量,那么,万一有一个变量名字和它名字一样,就很容易混淆和重写。

13.避免在数组里使用for-in loop

而不是这样用:

 

  1. var sum = 0;
  2. for (var i in arrayNumbers) {
  3.     sum += arrayNumbers[i];
  4. }

这样会更好: 

 

  1. var sum = 0;
  2. for (var i = 0, len = arrayNumbers.length; i < len; i++) {
  3.     sum += arrayNumbers[i];
  4. }

因为i和len是循环中的第一个语句,所以每次实例化都会执行一次,这样执行起来就会比下面这个更快:

 

 

  1. for (var i = 0; i < arrayNumbers.length; i++)

为什么?数组长度arraynNumbers在每次loop迭代时都会被重新计算。 

14.不要向setTimeout()和setInterval()方法里传递字符串

如果在这两个方法里传递字符串,那么字符串会像eval那样重新计算,这样速度就会变慢,而不是这样使用:

 

  1. setInterval(‘doSomethingPeriodically()’, 1000);
  2. setTimeOut(‘doSomethingAfterFiveSeconds()’, 5000);

相反,应该这样用: 

 

  1. setInterval(doSomethingPeriodically, 1000);
  2. setTimeOut(doSomethingAfterFiveSeconds, 5000);

15.使用switch/case语句代替较长的if/else语句 

 

如果有超过2个以上的case,那么使用switch/case速度会快很多,而且代码看起来更加优雅。

16.遇到数值范围时,可以选用switch/casne 

 

  1. function getCategory(age) {
  2.     var category = “”;
  3.     switch (true) {
  4.         case isNaN(age):
  5.             category = “not an age”;
  6.             break;
  7.         case (age >= 50):
  8.             category = “Old”;
  9.             break;
  10.         case (age <= 20):
  11.             category = “Baby”;
  12.             break;
  13.         default:
  14.             category = “Young”;
  15.             break;
  16.     };
  17.     return category;
  18. }
  19. getCategory(5);  // will return “Baby”

17.创建一个对象,该对象的属性是一个给定的对象 

可以编写一个这样的函数,创建一个对象,该对象属性是一个给定的对象,好比这样:

 

  1. function clone(object) {
  2.     function OneShotConstructor(){};
  3.     OneShotConstructor.prototype= object;
  4.     return new OneShotConstructor();
  5. }
  6. clone(Array).prototype ;  // []

18.一个HTML escaper函数 

 

  1. function escapeHTML(text) {
  2.     var replacements= {“<“: “<“, “>”: “>”,”&”: “&”, “\””: “””};
  3.     return text.replace(/[<>&”]/g, function(character) {
  4.         return replacements[character];
  5.     });
  6. }

19.在一个loop里避免使用try-catch-finally 

try-catch-finally在当前范围里运行时会创建一个新的变量,在执行catch时,捕获异常对象会赋值给变量。

不要这样使用:

 

  1. var object = [‘foo’, ‘bar’], i;
  2. for (i = 0, len = object.length; i <len; i++) {
  3.     try {
  4.         // do something that throws an exception
  5.     }
  6.     catch (e) {
  7.         // handle exception
  8.     }
  9. }

应该这样使用: 

 

  1. var object = [‘foo’, ‘bar’], i;
  2. try {
  3.     for (i = 0, len = object.length; i <len; i++) {
  4.         // do something that throws an exception
  5.     }
  6. }
  7. catch (e) {
  8.     // handle exception
  9. }

20.给XMLHttpRequests设置timeouts  

如果一个XHR需要花费太长时间,你可以终止链接(例如网络问题),通过给XHR使用setTimeout()解决。

 

  1. var xhr = new XMLHttpRequest ();
  2. xhr.onreadystatechange = function () {
  3.     if (this.readyState == 4) {
  4.         clearTimeout(timeout);
  5.         // do something with response data
  6.     }
  7. }
  8. var timeout = setTimeout( function () {
  9.     xhr.abort(); // call error callback
  10. }, 60*1000 /* timeout after a minute */ );
  11. xhr.open(‘GET’, url, true);
  12. xhr.send();

此外,通常你应该完全避免同步Ajax调用。 

21.处理WebSocket超时

一般来说,当创建一个WebSocket链接时,服务器可能在闲置30秒后链接超时,在闲置一段时间后,防火墙也可能会链接超时。

为了解决这种超时问题,你可以定期地向服务器发送空信息,在代码里添加两个函数:一个函数用来保持链接一直是活的,另一个用来取消链接是活的,使用这种方法,你将控制超时问题。

添加一个timeID……

 

  1. var timerID = 0;
  2. function keepAlive() {
  3.     var timeout = 15000;
  4.     if (webSocket.readyState == webSocket.OPEN) {
  5.         webSocket.send(”);
  6.     }
  7.     timerId = setTimeout(keepAlive, timeout);
  8. }
  9. function cancelKeepAlive() {
  10.     if (timerId) {
  11.         cancelTimeout(timerId);
  12.     }
  13. }

keepAlive()方法应该添加在WebSocket链接方法onOpen()的末端,cancelKeepAlive()方法放在onClose()方法下面。
 

22.记住,最原始的操作要比函数调用快

对于简单的任务,最好使用基本操作方式来实现,而不是使用函数调用实现。

例如

 

  1. var min = Math.min(a,b);
  2. A.push(v);

基本操作方式: 

 

  1. var min = a < b ? a b;
  2. A[A.length] = v;

23.编码时注意代码的美观、可读 

JavaScript是一门非常好的语言,尤其对于前端工程师来说,JavaScript也非常重要,点击 这里可以访问更多优秀的JavaScript资源。

来自: flippinawesome.org

直接拿来用!最火的Android开源项目(一)

http://www.csdn.net/article/2013-05-03/2815127-android-open-source-projects

摘要:对于开发者而言,了解当下比较流行的开源项目很是必要。利用这些项目,有时能够让你达到事半功倍的效果。为此,CSDN特整理了GitHub上最受欢迎的Android及iOS开源项目,本文详细介绍了20个Android开源项目。

GitHub在中国的火爆程度无需多言,越来越多的开源项目迁移到GitHub平台上。更何况,基于不要重复造轮子的原则,了解当下比较流行的Android与iOS开源项目很是必要。利用这些项目,有时能够让你达到事半功倍的效果。为此,CSDN特整理了在GitHub平台上最受欢迎的Android及iOS开源项目,以飨开发者。

下面,就让我们一起来看看,在GitHub平台上,究竟有哪些Android开源项目最火,也最受开发者欢迎。

1. ActionBarSherlock

ActionBarSherlock应该算得上是GitHub上最火的Android开源项目了,它是一个独立的库,通过一个API和主题,开发者就可以很方便地使用所有版本的Android动作栏的设计模式。

对于Android 4.0及更高版本,ActionBarSherlock可以自动使用本地ActionBar实现,而对于之前没有ActionBar功能的版本,基于Ice Cream Sandwich的自定义动作栏实现将自动围绕布局。能够让开发者轻松开发一款带动作栏(Action bar)的应用,并且适用于Android 2.x及其以上所有版本。

详情请参考:ActionBarSherlock

2. facebook-android-sdk

Facebook SDK for Android是一个开源库,允许开发者将Facebook集成到所开发的Android应用中。

如果想要获取更多关于示例、文档、将SDK集成到App中、源代码等信息,可直接登陆Facebook Developers查看。

3. SlidingMenuSlidingMenu Demos

SlidingMenu是一个开源的Android库,能够让开发者轻松开发一款应用,实现类似于Google+、Youtube和Facebook应用中非常流行的滑动式菜单。

  

使用SlidingMenu的Android应用:

 

 

4. cocos2d-x

在移动开发领域,将Cocos2D-X用于主流iOS/Android游戏开发的公司、开发团队多不胜数。cocos2d-x是一个开源的支持多平台的2D游戏框架,使用C++开发,基于cocos2d-iphone,在MIT许可证下发布。主分支在GitHub上使用OpenGL ES 2.0渲染,而旧版gles11分支则使用OpenGL ES 1.1渲染。

支持iOS、Android、Windows Phone 8、Bada、BlackBerry、Marmalade、Windows、Linux等多个平台。支持C++、Lua、JavaScript编程语言。

5. android

GitHub Android App是GitHub开源的Android客户端,支持Issues、Gists,并集成了新闻Feed,能够让你及时跟进组织及关注的开发者、库等。同时,该应用还提供了一个用户快速访问你所创建、监控及发布issue的面板,可查看并将问题加入到收藏夹,可对标签、里程碑和任务进行过滤配置。

android资源库包含了GitHub Android App的所有源代码。

6. Android-ViewPagerIndicator

ViewPager指针项目,在使用ViewPager的时候能够指示ViewPager所在的位置,就像Google Play中切换的效果一样,还能使用在应用初始化的介绍页面。

兼容Android支持库的ViewPager及ActionBarSherlock,最初是基于Patrik Åkerfeldt的ViewFlow,开发者可以直接登陆Google Play下载该项目的演示应用。

7. MonoGame

MonoGame是一个Microsoft XNA 4.x Framework的开源跨平台实现。用于让XNA开发者将他们在Xbox 360、Windows & Windows Phone上开发的游戏移植到iOS、Android、Mac OS X、Linux及Windows 8 Metro上,目前,PlayStation Mobile & Raspberry PI的开发正在进行中。

详情请参考:MonoGame

8. Android-PullToRefresh

该项目用于为Android提供一个可重用的下拉刷新部件。它最初来源于Johan Nilsson的库(主要是图形、字符串和动画),但这些后来都已被取代。

9. android-async-http

android-async-http是Android上的一个异步、基于回调的HTTP客户端开发包,建立在Apache的HttpClient库上。

10. Android-Universal-Image-Loader

Android上最让人头疼的莫过于从网络获取图片、显示、回收,任何一个环节有问题都可能直接OOM,这个项目或许能帮到你。

Universal Image Loader for Android的目的是为了实现异步的网络图片加载、缓存及显示,支持多线程异步加载。它最初来源于Fedor Vlasov的项目,且自此之后,经过大规模的重构和改进。

11. GreenDroid

GreenDroid最初是由Cyril Mottier发起,是一个Android的UI开发类库,能够让UI开发更加简便,并且在应用中始终保持一致。

详情请参考:Cyril Mottier’s Blog

12. Anki-Android

AnkiDroid是一个免费、开源的Android的闪存应用,可直接从Google Play进行下载。

详情请参考:ankidroid

13. android-actionbar

Action bar是一个标识应用程序和用户位置的窗口功能,并且给用户提供操作和导航模式。在大多数的情况下,当开发者需要突出展现用户行为或在全局导航的activity中使用action bar,因为action bar能够使应用程序给用户提供一致的界面,且系统能够很好地根据不同的屏幕配置来适应操作栏的外观。

Action bar的主要目的:

 

  • 提供一个用于识别应用程序的标示和用户的位置的专用空间。
  • 在不同的应用程序之间提供一致的导航和视觉体验。
  • 突出Activity的关键操作,并且在可预见的方法内给用户提供快捷的访问。

 

14. android-viewflow

android-viewflow是Android平台上的一个视图切换的效果库,ViewFlow相当于Android UI部件提供水平滚动的ViewGroup,使用Adapter进行条目绑定。

 

15. android-mapviewballoons

当使用Android地图外部库(com.google.android.maps)时,android-mapviewballoons会提供一个简单的方式来对地图覆盖进行标注,就是一个简单的信息气泡。

它由BalloonOverlayView组成,是一个代表显示你的MapView及BalloonItemizedOverlay的气泡的视图,BalloonItemizedOverlay是ItemizedOverlay的一个抽象扩展。

16. PushSharp

一个向iOS(iPhone/iPad APNS)、Android(C2DM和GCM)、Windows Phone和Windows 8设备发送推送通知的服务器端库。

17. androidannotations

Android Annotations是一个开源的框架,用于加速 Android应用的开发,可以让你把重点放在功能的实现上,简化了代码,提升了可维护性。

18. HockeyKit

Hockey是一个iOS Ad-Hoc自动更新框架。苹果App Store中的所有App都可以使用它,它能够显著地提高Beta测试的整个过程,分为两部分:服务器和客户端框架。服务器组件需要所有脚本,但在没有客户端库的情况下,也可以单独工作。它提供一个Web接口,Beta测试者可以使用它来安装最新的AdHoc配置文件,也可以直接在设备上通过Safari安装最新的Beta版本。

 

  • 只需在服务器上安装一次服务端,就可以处理包标识符不同的多个应用程序(有开发者强烈建议对Debug、AdHoc Beta和AppStore发布版使用不同的包标识符)。
  • 默认当App启动或唤醒时,客户端会从服务器检测更新,用户可以在设置对话框中进行修改:一天一次或手动检查更新。
  • 除了支持iOS,HokeyKit也支持Android平台,不过Android版还处在Alpha阶段,支持OTA及应用内更新。
  • 为HockeyKit用户提供服务器托管服务。

 

19. android-menudrawer

Android上的菜单展示风格各异,其中用得最多且体验最好的莫过于左右滑动来显示隐藏的菜单,android-menudrawer是一个滑动式菜单实现,允许用户在应用当中实现无缝导航。该项目具有多种菜单展示效果,其中最常见的就是通过屏幕边缘拖动或点击动作栏的“向上”按钮显示。

 

实现功能:

 

  • 菜单可以沿着四个边放置。
  • 支持附加一个始终可见、不可拖动的菜单。
  • 菜单的内容和整个窗口都可以隐藏。
  • 可用于XML布局。
  • 显示当前可见屏幕的指示器。

 

20. android-flip

Aphid FlipView是一个能够实现Flipboard翻页效果的UI组件。

以上为GitHub上最受欢迎的Android开源项目TOP20,敬请期待“GitHub上最受欢迎的Android开源项目(二)”。

 

最常用的Java库一览

http://www.importnew.com/7530.html

本文由 ImportNew – 邢 敏 翻译自 programcreek。如需转载本文,请先参见文章末尾处的转载要求。

写在前面:

1) 本文列出的名单是根据我自己的调查,并结合个人的经验。有可能是它们不恰恰是最流行的,但至少众所周知的。

2) 我会不断更新这个列表,使之更加完整和准确。感谢您的意见。

一个典型的Java项目依赖于第三方库。本文总结的Java库适用于各种应用,比较流行并且广泛使用。其中一些还提供简单的示例(来自ProgramCreek)。

Java SDK 肯定是使用最广的库,所以本文的名单焦点是流行的第三方库。该列表可能并不完善,所以如果你觉得有什么应该出现在列表中的,请留下您的评论。非常感谢!

1、核心库

  • Apache Commons Lang:来自Apache的核心库,为java.lang API补充了许多常用的工具类,如字符串操作、对象的创建等。
  • Google Guava:来自谷歌的核心库,包括集合(Collection)、缓存(Caching)、支持原语(Primitives)等。(示例)

2、HTML、XML Parser

  • Jsoup:一个简化了的 HTML操作的库。(示例)
  • STaX:一组可以高效处理 XML的API。 (示例)

3、Web框架

  • Spring:Java平台上众所周知的开源框架和依赖注入容器。(示例)
  • Struts2:来自Apache的流行Web框架。 (示例)
  • Google Web Toolkit:Google提供的开发工具库,主要用于构建和优化复杂的Web程序用。 (示例)
  • Strips:使用最新Java技术构建的Web程序框架,推荐使用。
  • Tapestry:面向组件的框架,用于使用Java创建动态、健壮、扩展性高的Web应用程序。

请猛击这里 查看以上面框架之间的比较。

4、图表、报表、图像

  • JFreeChart:用于创建如条形图、折线图、饼图等图表。
  • JFreeReport:创建于输出PDF格式的报表。
  • JGraphT:创建图像,其中只包含由线段连接的点集。

5、窗口

SWT与Swing的比较

6.、GUI框架

7、自然语言处理

  • OpenNLP:来自Apache的自然语言处理库。 (示例)
  • Stanford Parser:斯坦福大学提供的自然语言处理库。(示例)

如果你是一名NLP专家,请猛击这里 查看更多工具库介绍。

8、静态分析

  • Eclipse JDT:由IBM提供的静态分析库,可以操作Java源代码。(示例)
  • WALA:可以处理jar包文件(即字节码)的工具库。(示例)

9、JSON

  • Jackson: 用于处理JSON数据格式的多用途的Java库。Jackson 旨在快速、准确、轻量、对开人员友好之间找到最好的平衡点。
  • XStream:一个简单用于对象和XML互相转换的库。
  • Google Gson:一个专门用于Java对象和Json对象相互转换的工具库。(示例)
  • JSON-lib:用于 beans、maps、collections、java arrays、XML 和 JSON 之间相互转换操作的工具库。

10、数学

  • Apache Commons Math:提供数学计算和数值统计需函数的工具库。

11、日志

  • Apache Log4j:风行一时的日志记录操作库。 (示例)
  • Logback:当前流行的log4j项目的继任者。
  • SLF4J(The Simple Logging Facade for Java): 各种日志框架的一个简单的外观或抽象(如java.util.logging 、logback、log4j等),允许用户在部署时加入需要的日志框架。

12、Office

  • Apache POI:利用其提供的APIs,可以使用纯Java代码操作各种基于微软OLE2合成文档格式的文档。
  • Docx4j:一个用于创建、操作微软公开的XML文件的库(支持Word docx、 Powerpoint pptx和Excel xlsx)。

13、日期和时间

  • Joda-Time:如有质量问题包退包换的Java日期和时间类。

14、数据库

  • Hibernate、EclipseLink、JPA
  • JDO
  • jOOQ
  • SpringJDBC、Spring Data
  • Apache DbUtils

15、开发工具

  • Lambok: 旨在减少代码编写的Java开发库。
« 较早的 文章 较新的 文章 »

Copyright © 2024 优大网 浙ICP备13002865号

回到顶部 ↑