Markdown快速入门手册

本文用于快速掌握Markdown语法,并用于备查。

为什么用Markdown

Markdown的优点

  • 写作中添加简单符号即完成排版,所见即所得。让你专注于文字而不是排版。
  • 格式转换方便,Markdown 的文本你可以轻松转换为 html、pdf等。
  • 可以保存称纯文本

Markdown简要规则

标题

用1~6位递增的’#’,定义一段文字为标题

# 标题一 H1 
## 标题二 H2
### 标题三 H3
#### 标题四 H4
##### 标题五 H5
###### 标题六 H6

列表

用‘*’ ‘+’或‘-’,定义一段文字为无序列表

用‘1. ’‘2. ’…‘n. ’,定义一段文字为有序列表

分割线

用3位以上的‘*’ ‘+’或‘-’,定义一行分割线


未完待续。。。

Mac下office 2016 15.13.1版本自签名后闪退崩溃问题修复

问题背景

Mac下office 2016可以通过自签名的方法完成“激活”。但是如果用过其它的“激活”方法的话,会损坏文件的完整性,office 2016会频繁崩溃闪退。

解决思路

重新安装office 2016,覆盖原安装文件;重新自签名“激活”。

解决步骤

1. 微软官网下载office2016 15.13.1 更新包

地址:https://support.microsoft.com/zh-cn/kb/3082420

2. 分别安装Word、Excel、PowerPoint、Outlook

3. 安装自签名的方法重新“激活”

解决完成!现在可以畅快地享受office 2016了。

Axure RP移动APP应用原型设计技巧

移动素材库

工欲善其事必先利其器,素材库则是我们必不可少的利器。Axure RP本身源自Web设计,针对移动应用设计的支持并不完美。所以合理使用第三方开发的素材库(Widget Library),可以节省我们重新绘制APP基础部件的时间,提高产品设计的专注度及效率。 以下是收集整理的一些第三方付费素材库:

移动APP设计尺寸

看到一张空白画布,我们就开始考虑APP的尺寸应该是多少?以下以几款主流iPhone为例,可以根据个人兴趣选择机型对应的Points列作为设计稿尺寸:

为什么不是Android?没有其他原因,就是不喜欢。这里可以写一篇《为什么喜欢iOS而不是Android》

Device Retina Asset Resolution Portrait (px) Points
iPhone 6+ Retina HD @3x 1080 x 1920 414 x 736
iPhone 6 Retina @2x 750 x 1334 375 x 667
iPhone 55, 5S, 5C Retina @2x 640 x 1136 320 x 568

  建议:以iPhone 6为标准 ,尺寸为375 x 667。演示时仅需要根据不同机型可调整Initial scale:

  • iPhone 5s:Initial scale 0.583
  • iPhone 6:Initial scale 1.0
  • iPhone 6 Plus:Initial scale 1.104
小技巧:按住Ctrl从标尺处拖拽全局参考线至横轴375、纵轴667,即可确定单页设计区域

APP设计规范

现在主流两大手机系统:iOS和Android,官方都对APP设计的指导文档:

以iPhone 6为,以下是一些常用的layout规范:

  • Status Bar(状态栏) 宽100%、高20pt
  • Navigation Bar(导航栏 )Toolbar(工具栏)宽100%、高44pt
  • Tab Bar(标签栏)宽100%、高49pt
  • Search Bar(搜索栏)宽100%、高43pt

PC上演示APP原型

写到此处,肚子微饿
  1. 创建一个Page叫做“iPhone Frame for Desktop View”,排序置顶
  2. 从第三方部件库中拖拽一个iPhone 6 的Body到当前Page
  3. 从default部件库拖拽Inline Frame到Body中心,设置weight:375 height:667,并调整位置至Body的屏幕位置
  4. 选中Inline Frame编辑Widget Properties的Frame Target属性为APP入口页,Frame Scrollbars为Never Show
  5. 在浏览器中预览当前页即可,APP会显示在iPhone 6 的body中

移动设备上演示APP原型

首先设置Preview Options里的Mobile/Device,勾选Include Viewport Tag,以便适配移动设备。再根据不同的iPhone 设备设置Initial Scale,这样即可在不同的设备上都完美适配。 Axure在移动设备上演示提供了两种方式:

  • 导出Html文件,通过手机浏览器本地或远程查看
  • 发布至Axure Share,通过下载AxShare应用或URL链接链接查看

建议:共享至Axure Share,手机通过AxShare应用查看。AxShare可以在线查看Cloud项目,也可以缓存到Local本地,同时满足实时预览及离线演示的需求。

如果基于公司信息安全的考虑,还是选择导出Html内网或下载至手机本地查看

参考资料:

The iOS Design Guidelines http://iosdesign.ivomynttinen.com/

Docker入门

关注Docker这项技术差不多一年多了,最近关于Docker的使用案例越来越多,于是就想动手实验下这项技术。自己整理了一个入门手册,分享给大家。

Docker是什么

Docker是一种容器技术,它可以将应用和环境等进行打包,形成一个独立的,类似于iOS的APP形式的“应用”,这个应用可以直接被分发到任意一个支持Docker的环境中,通过简单的命令即可启动运行。Docker是一种最流行的容器化实现方案。和虚拟化技术类似,它极大的方便了应用服务的部署;又与虚拟化技术不同,它以一种更轻量的方式实现了应用服务的打包。使用Docker可以让每个应用彼此相互隔离,在同一台机器上同时运行多个应用,不过他们彼此之间共享同一个操作系统。Docker的优势在于,它可以在更细的粒度上进行资源的管理,也比虚拟化技术更加节约资源。

vm-vs-docker-architecture虚拟化和Docker架构对比,来自Docker官网

基本概念

开始试验Docker之前,我们先来了解一下Docker的几个基本概念:

镜像:我们可以理解为一个预配置的系统光盘,这个光盘插入电脑后就可以启动一个操作系统。当然由于是光盘,所以你无法修改它或者保存数据,每次重启都是一个原样全新的系统。Docker里面镜像基本上和这个差不多。

容器:同样一个镜像,我们可以同时启动运行多个,运行期间的产生的这个实例就是容器。把容器内的操作和启动它的镜像进行合并,就可以产生一个新的镜像。

开始

Docker基于LXC技术实现,依赖于Linux内核,所以Docker目前只能在Linux以原生方式运行。目前主要的Linux发行版在他们的软件仓库中内置了Docker:

Ubuntu:

  • Ubuntu Trusty 14.04 (LTS)
  • Ubuntu Precise 12.04 (LTS)
  • Ubuntu Saucy 13.10

CentOS:

  • CentOS 7

Docker要求64位环境,这些操作系统下可以直接通过命令安装Docker,老一些操作系统Docker官方也提供了安装方案。下面的实验基于CentOS 7进行。关于其他版本操作系统上Docker的安装,请参考官方文档:https://docs.docker.com/installation/

在CentOS 7上安装Docker

使用yum从软件仓库安装Docker:

首先启动Docker的守护进程:

如果想要Docker在系统启动时运行,执行:

Docker在CentOS上好像和防火墙有冲突,应用防火墙规则后可能导致Docker无法联网,重启Docker可以解决。

Docker仓库

Docker使用类似git的方式管理镜像。通过基本的镜像可以定制创建出来不同种应用的Docker镜像。Docker Hub是Docker官方提供的镜像中心。在这里可以很方便地找到各类应用、环境的镜像。

由于Docker使用联合文件系统,所以镜像就像是夹心饼干一样一层层构成,相同底层的镜像可以共享。所以Docker还是相当节约磁盘空间的。要使用一个镜像,需要先从远程的镜像注册中心拉取,这点非常类似git。

我们很容易就能从Docker Hub镜像注册中心下载一个最新版本的ubuntu镜像到本地。国内网络可能会稍慢,DaoCloud提供了Docker Hub的国内加速服务,可以尝试配置使用。

运行一个容器

使用Docker最关键的一步就是从镜像创建容器。有两种方式可以创建一个容器:使用docker create命令创建容器,或者使用docker run命令运行一个新容器。两个命令并没有太大差别,只是前者创建后并不会立即启动容器。

以ubuntu为例,我们启动一个新容器,并将ubuntu的Shell作为入口:

这时候我们成功创建了一个Ubuntu的容器,并将当前终端连接为这个Ubuntu的bash shell。这时候就可以愉快地使用Ubuntu的相关命令了~可以快速体验一下。

参数-i表示这是一个交互容器,会把当前标准输入重定向到容器的标准输入中,而不是终止程序运行。-t指为这个容器分配一个终端。

好了,按Ctrl+D可以退出这个容器了。

在容器运行期间,我们可以通过docker ps命令看到所有当前正在运行的容器。添加-a参数可以看到所有创建的容器:

每个容器都有一个唯一的ID标识,通过ID可以对这个容器进行管理和操作。在创建容器时,我们可以通过–name参数指定一个容器名称,如果没有指定系统将会分配一个,就像这里的“trusting_morse”(什么鬼。。)。

当我们按Ctrl+D退出容器时,命令执行完了,所以容器也就退出了。要重新启动这个容器,可以使用docker start命令:

同样,-i参数表示需要交互式支持。

注意:每次执行docker run命令都会创建新的容器,建议一次创建后,使用docker start/stop来启动和停用容器。

存储

在Docker容器运行期间,对文件系统的所有修改都会以增量的方式反映在容器使用的联合文件系统中,并不是真正的对只读层数据信息修改。每次运行容器对它的修改,都可以理解成对夹心饼干又添加了一层奶油。这层奶油仅供当前容器使用。当删除Docker容器,或通过该镜像重新启动时,之前的更改将会丢失。这样做并不便于我们持久化和共享数据。Docker的数据卷这个东西可以帮到我们。

在创建容器时,通过-v参数可以指定将容器内的某个目录作为数据卷加载:

在容器中会多一个/home/www挂载点,在这个挂载点存储数据会绕过联合文件系统。我们可以通过下面的命令来找到这个数据卷在主机上真正的存储位置:

你会看到输出了一个指向到/var/lib/docker/vfs/dir/…的目录。cd进入后你会发现在容器中对/home/www的读写创建,都会反映到这儿。事实上,/home/www就是挂载自这个位置。

有时候,我们需要将本地的文件目录挂载到容器内的位置,同样是使用数据卷这一个特性,-v参数格式为:

host_dir是主机的目录,container_dir是容器的目录。

容器和容器之间是可以共享数据卷的,我们可以单独创建一些容器,存放如数据库持久化存储、配置文件一类的东西,然而这些容器并不需要运行。

在需要使用这个数据容器的容器创建时–volumes-from [容器名]的方式来使用这个数据共享容器。

网络

Docker容器内的系统工作起来就像是一个虚拟机,容器内开放的端口并不会真正开放在主机上。可以使我们的容器更加安全,而且不会产生容器间端口的争用。想要将Docker容器的端口开放到主机上,可以使用类似端口映射的方式。

在Docker容器创建时,通过指定-p参数可以暴露容器的端口在主机上:

现在我们就将容器的22端口开放在了主机上,注意主机上对应端口是自动分配的。如果想要指定某个端口,可以通过-p [主机端口]:[容器端口]参数指定。

容器和容器之间想要网络通讯,可以直接使用–link参数将两个容器连接起来。例如WordPress容器对some-mysql的连接:

环境变量

通过Docker打包的应用,对外就像是一个密闭的exe可执行文件。有时候我们希望Docker能够使用一些外部的参数来使用容器,这时候参数可以通过环境变量传递进去,通常情况下用来传递比如MySQL数据库连接这种的东西。环境变量通过-e参数向容器传递:

关于Docker到现在就有了一个基本的认识了。接下来我会给大家介绍如何创建镜像,以及如何利用公有云直接发布的基于Docker的应用。

创建镜像

Docker强大的威力在于可以把自己开发的应用随同各种依赖环境一起打包、分发、运行。要创建一个新的Docker镜像,通常基于一个已有的Docker镜像来创建。Docker提供了两种方式来创建镜像:把容器创建为一个新的镜像、使用Dockerfile创建镜像。

将容器创建为镜像

为了创建一个新的镜像,我们先创建一个新的容器作为基底:

现在我们可以对这个容器进行修改了,例如我们可以配置PHP环境、将我们的项目代码部署在里面等:

当执行完操作之后,我们按Ctrl+D退出容器,接下来使用docker ps -a来查找我们刚刚创建的容器ID:

可以看到我们最后操作的那个ubuntu容器。这时候只需要使用docker commit即可把这个容器变为一个镜像了:

这时候docker容器会被创建为一个新的Ubuntu镜像,版本名称为myubuntu。以后我们可以随时使用这个镜像来创建容器了,新的容器将自动包含上面对容器的操作。

如果我们要在另外一台机器上使用这个镜像,可以将一个镜像导出:

现在我们可以把刚才创建的镜像打包为一个文件分发和迁移了。要在一台机器上导入镜像,只需要:

这样在新机器上就拥有了这个镜像。

注意:通过导入导出的方式分发镜像并不是Docker的最佳实践,因为我们有Docker Hub。

Docker Hub提供了类似GitHub的镜像存管服务。一个镜像发布到Docker Hub不仅可以供更多人使用,而且便于镜像的版本管理。关于Docker Hub的使用,之后我会单独写一篇文章展开介绍。另外,在一个企业内部可以通过自建Docker Registry的方式来统一管理和发布镜像。将Docker Registry集成到版本管理和上线发布的工作流之中,还有许多工作要做,在我整理出最佳实践后会第一时间分享。

使用Dockerfile创建镜像

使用命令行的方式创建Docker镜像通常难以自动化操作。在更多的时候,我们使用Dockerfile来创建Docker镜像。Dockerfile是一个纯文本文件,它记载了从一个镜像创建另一个新镜像的步骤。撰写好Dockerfile文件之后,我们就可以轻而易举的使用docker build命令来创建镜像了。

Dockerfile非常简单,仅有以下命令在Dockerfile中常被使用:

命令 参数 说明
# 注释说明
FROM <image>[:<tag>] 从一个已有镜像创建,例如ubuntu:latest
MAINTAINER Author <some-one@example.com> 镜像作者名字,如Max Liu <some-one@example.com>
RUN <cmd>或者[‘cmd1’, ‘cmd2’…] 在镜像创建用的临时容器里执行单行命令
ADD <src> <dest> 将本地的<src>添加到镜像容器中的<dest>位置
VOLUME <path>或者[‘/var’, ‘home’] 将指定的路径挂载为数据卷
EXPOSE <port> [<port>…] 将指定的端口暴露给主机
ENV <key> <value> 或者 <key> = <value> 指定环境变量值
CMD [“executable”,”param1″,”param2″] 容器启动时默认执行的命令。注意一个Dockerfile中只有最后一个CMD生效。
ENTRYPOINT [“executable”, “param1″, “param2″] 容器的进入点。

下面是一个Dockerfile的例子:

这里其他命令都比较好理解,唯独CMD和ENTRYPOINT我需要特殊说明一下。CMD命令可用指定Docker容器启动时默认的命令,例如我们上面例子提到的docker run -it ubuntu:latest sh -c ‘/bin/bash’。其中sh -c ‘/bin/bash’就是通过手工指定传入的CMD。如果我们不加这个参数,那么容器将会默认使用CMD指定的命令启动。ENTRYPOINT是什么呢?从字面看是进入点。没错,它就是进入点。ENTRYPOINT用来指定特定的可执行文件、Shell脚本,并把启动参数或CMD指定的默认值,当作附加参数传递给ENTRYPOINT。

不好理解是吧?我们举一个例子:

假设这个镜像内已经准备好了mysql-client,那么通过这个镜像,不加任何额外参数启动容器,将会给我们一个mysql的控制台,默认连接到192.168.100.128这个主机。然而我们也可以通过指定参数,来连接别的主机。但是不管无论如何,我们都无法启动一个除了mysql客户端以外的程序。因为这个容器的ENTRYPOINT就限定了我们只能在mysql这个客户端内做事情。这下是不是明白了~

因此,我们在使用Dockerfile创建文件的时候,可以创建一个entrypoint.sh脚本,作为系统入口。在这个文件里面,我们可以进行一些基础性的自举操作,比如检查环境变量,根据需要初始化数据库等等。下面两个文件是我在SimpleOA项目中添加的Dockerfile和entrypoint.sh,仅供参考:

https://github.com/starlight36/SimpleOA/blob/master/Dockerfile
https://github.com/starlight36/SimpleOA/blob/master/docker-entrypoint.sh

在准备好Dockerfile之后,我们就可以创建镜像了:

关于Dockerfile的更详细说明,请参考https://docs.docker.com/reference/builder/

杂项和最佳实践

在产品构建的生命周期里使用Docker,最佳实践是把Docker集成到现有的构建发布流程里面。这个过程并不复杂,可以在持续集成系统构建测试完成后,将打包的步骤改为docker build,持续集成服务将会自动将构建相应的Docker镜像。打包完成后,可以由持续集成系统自动将镜像推送到Docker Registry中。生产服务器可以直接Pull最新版本的镜像,更新容器即可很快地实现更新上线。目前Atlassian Bamboo已经支持Docker的构建了。

由于Docker使用联合文件系统,所以并不用担心多次发布的版本会占用更多的磁盘资源,相同的镜像只存储一份。所以最佳实践是在不同层次上构建Docker镜像。比如应用服务器依赖于PHP+Nginx环境,那么可以把定制好的这个PHP环境作为一个镜像,应用服务器从这个镜像构建镜像。这样做的好处是,如果PHP环境要升级,更新了这个镜像后,重新构建应用镜像即可完成升级,而不需要每个应用项目分别升级PHP环境。

新手经常会有疑问的是关于Docker打包的粒度,比如MySQL要不要放在镜像中?最佳实践是根据应用的规模和可预见的扩展性来确定Docker打包的粒度。例如某小型项目管理系统使用LAMP环境,由于团队规模和使用人数并不会有太大的变化(可预计的团队规模范围是几人到几千人),数据库也不会承受无法承载的记录数(生命周期内可能一个表最多会有数十万条记录),并且客户最关心的是快速部署使用。那么这时候把MySQL作为依赖放在镜像里是一种不错的选择。当然如果你在为一个互联网产品打包,那最好就是把MySQL独立出来,因为MySQL很可能会单独做优化做集群等。

使用公有云构建发布运行Docker也是个不错的选择。国内DaoCloud提供了从构建到发布到运行的全生命周期服务。特别适合像微擎这种微信公众平台、或者中小型企业CRM系统。上线周期更短,比使用IAAS、PAAS的云服务更具有优势。

参考资料:

深入理解Docker Volume http://dockone.io/article/128
WordPress https://registry.hub.docker.com/_/wordpress/
Docker学习—镜像导出 http://www.sxt.cn/u/756/blog/5339
Dockerfile Reference https://docs.docker.com/reference/builder/
关于Dockerfile http://blog.tankywoo.com/docker/2014/05/08/docker-2-dockerfile.html

该文转自starlight36.com

从 LAMP 到 MEAN 构建现代Web应用

从 LAMP 到 MEAN

MEAN 不仅仅是一次首字母缩写的简单重新安排与技术升级。将基础平台从操作系统 (Linux) 转变为 JavaScript 运行时 (Node.js) 让操作系统变得独立:Node.js 在 Windows® 与 OS X 上的运行情况和在 Linux 上一样优秀。 

Node.js 同样取代了 LAMP 堆栈中的 Apache。但 Node.js 远远不止是一种简单的 Web 服务器。事实上,用户不会将完成后的应用程序部署到单机的 Web 服务器上;相反,Web 服务器已经包含在应用程序中,并已在 MEAN 堆栈中自动安装。结果,部署过程得到了极大简化,因为所需的 Web 服务器版本已经与余下的运行时依赖关系一起得到了明确定义。 

不仅是 MEAN

尽管本系列文章重点讲述的是 MEAN 太阳系中的四大行星,但也会介绍 MEAN 堆栈中的一些较小的(但并非不重要的)卫星类技术: 

  • Yeoman:一种功能强大的命令行开发工具组合,用于基架 (Yo)、编译脚本 (Grunt) 与客户端依赖关性管理 (Bower)。
  • Bootstrap:一个 CSS 库,支持开箱即用的移动端 响应式 Web 设计
  • 测试库:除了 Mocha、Jasmine 和 Karma 以外,还有大量测试库可用于模拟 Ajax 调用 (Chai),显示测试范围 (Istanbul),以及自动完成功能测试,以便在实际的浏览器中 运行它们(Protractor)。

从传统数据库(如 MySQL)到 NoSQL,再到无架构的、以文档为导向的持久存储(如 MongoDB),这些代表着持久化策略发生了根本性的转变。用户花费在编写 SQL 上的时间将会减少,将会有更多的时间编写 JavaScript 中的映射/化简功能。用户还能省掉大量的转换逻辑,因为 MongoDB 可以在本地运行 JavaScript Object Notation (JSON)。因此,编写 RESTful Web 服务变得前所未有的容易。 

但从 LAMP 到 MEAN 的最大转变在于从传统的服务器端页面生成变为客户端 单页面应用程序 (SPA)。借助 Express 仍然可以处理服务器端的路由与页面生成,但目前的重点在客户端视图上,而 AngularJS 可以实现这一点。这种变化并不仅仅是将 模型-视图-控制器 (MVC) 工件从服务器转移到客户端。用户还要尝试从习惯的同步方式转而使用基本由事件驱动的、实质上为异步的方式。或许最重要的一点是,您将从以页面为中心的应用程序视图转到面向组件的视图。 

MEAN 堆栈并非以移动为中心,AngularJS 在桌面电脑、笔记本电脑、智能手机、平板电脑和甚至是智能电视上的运行效果都一样,但它不会把移动设备当作二等公民对待。而且测试事后不再是问题:借助世界级的测试框架,比如MochaJSJasmineJS 和 KarmaJS,您可以为自己的 MEAN 应用程序编写深入而又全面的测试套件。 

准备好获得 MEAN 了吗?

 

安装 Node.js

您需要安装 Node.js,以便在本系列中的示例应用程序上工作,如果尚未安装它,那就立刻开始安装吧。 

如果使用 UNIX® 风格的操作系统(Linux、Mac OS X 等),我推荐使用 Node Version Manager (NVM)。(否则,在 Node.js 主页上单击Install,下载适合您操作系统的安装程序,然后接受默认选项即可。)借助 NVM,您可以轻松下载 Node.js,并从命令行切换各种版本。这可以帮助您从一个版本的 Node.js 无缝转移到下一版本,就像我从一个客户项目转到下一个客户项目一样。 

NVM 安装完毕后,请输入命令 nvm ls-remote 查看哪些 Node.js 版本可用于安装,如清单 1 中所示。 

清单 1. 使用 NVM 列出可用的 Node.js 版本
$ nvm ls-remote

v0.10.20

v0.10.21
v0.10.22
v0.10.23
v0.10.24
v0.10.25
v0.10.26
v0.10.27
v0.10.28

输入 nvm ls 命令可以显示本地已经安装的 Node.js 版本,以及目前正在使用中的版本。

在撰写本文之际,Node 网站推荐 v0.10.28 是最新的稳定版本。输入 nvm install v0.10.28 命令在本地安装它。 

安装 Node.js 后(通过 NVM 或平台特定的安装程序均可),可以输入 node --version 命令来确认当前使用的版本:

$ node --version

v0.10.28
 

什么是 Node.js?

Node.js 是一种 headless JavaScript 运行时。它与运行在 Google Chrome 内的 JavaScript 引擎(名叫 V8)是一样的,但使用 Node.js 可以从命令行(而非浏览器)运行 JavaScript。 

访问浏览器的开发人员工具

熟悉自己所选浏览器中的开发人员工具。我将在整个系列中通篇使用 Google Chrome,但用户可以自行选择使用 Firefox、Safari 或者甚至是 Internet Explorer。 

  • 在 Google Chrome 中,单击 Tools > JavaScript Console
  • 在 Firefox 中,单击 Tools > Web Developer > Browser Console
  • 在 Safari 中,单击 Develop > Show Error Console。(如果看不到 Develop 菜单,可以在 Advanced preferences 页面上单击 Show Develop menu in menu bar。) 
  • 在 Internet Explorer 中,单击 Developer Tools > Script > Console

我曾有些学生嘲笑过从命令行运行 JavaScript 的主意:“如果没有要控制的 HTML,那 JavaScript 还有什么好处呢?” JavaScript 是在浏览器(Netscape Navigator 2.0)中来到这个世界的,因此那些反对者的短视和天真是可以原谅的。 

事实上,JavaScript 编程语言并未针对 文档对象模型 (DOM) 操作或形成 Ajax 请求提供本地功能。该浏览器提供了 DOM API,可以方便用户使用 JavaScript 来完成这类工作,但在浏览器之外的地方,JavaScript 不具备这些功能。 

下面给出了一个例子。在浏览器中打开一个 JavaScript 控制台(参见 访问浏览器的开发人员工具)。输入 navigator.appName。获得响应后,请输入 navigator.appVersion。得到的结果类似于图 1 中所示。 

 

 

 

 

图 1. 在 Web 浏览器中使用 JavaScript navigator 对象

在 Web 浏览器中使用 navigator JavaScript 对象的屏幕截图

在图 1 中,Netscape 是对 navigator.appName 的响应,而对 navigator.appVersion 的响应则是经验丰富的 Web 开发人员已经熟知但爱恨不一的、神秘的开发人员代理字符串。在图 1 中(截自 OS X 上的 Chrome 浏览器),该字符串是 5.0 (Macintosh; Intel Mac OS X 10_9_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.153 Safari/537.36

现在,我们要创建一个名为 test.js 的文件。在文件中输入同样的命令,并将每个命令包含在 console.log() 调用中: 

console.log(navigator.appName);
console.log(navigator.appVersion);

保存文件并输入 node test.js 来运行它,如清单 2 中所示。 

清单 2. 查看 Node.js 中的 navigator is not defined 错误
$ node test.js

/test.js:1
ion (exports, require, module, __filename, __dirname) { console.log(navigator.
                                                                    ^
ReferenceError: navigator is not defined
    at Object.<anonymous> (/test.js:1:75)
    at Module._compile (module.js:456:26)
    at Object.Module._extensions..js (module.js:474:10)
    at Module.load (module.js:356:32)
    at Function.Module._load (module.js:312:12)
    at Function.Module.runMain (module.js:497:10)
    at startup (node.js:119:16)
    at node.js:902:3

正如您看到的那样,navigator 在浏览器中可用,但在 Node.js 中不可用。(不好意思,让您的第一个 Node.js 脚本失败了,但我想确保让您相信,在浏览器中运行 JavaScript 与在 Node.js 中运行它是不同的。) 

根据堆栈跟踪的情况,正确的 Module 没有得到加载。(Modules 是在浏览器中运行 JavaScript 与在 Node.js 中运行它之间的另一主要区别。我们将立刻讲述 Modules 的更多相关内容。)为了从 Node.js 获得类似的信息,请将 test.js 的内容修改为: 

console.log(process.versions)
console.log(process.arch)
console.log(process.platform)

再次输入 node test.js,可以看到类似于清单 3 中的输出。 

清单 3. 在 Node.js 中使用过程模块
$ node test.js
 
{ http_parser: '1.0',
  node: '0.10.28',
  v8: '3.14.5.9',
  ares: '1.9.0-DEV',
  uv: '0.10.27',
  zlib: '1.2.3',

  modules: '11',
  openssl: '1.0.1g' }
x64
darwin

在 Node.js 中成功运行第一个脚本之后,我们将接触下一个主要概念:模块。 

 

什么是模块?

可以在 JavaScript 中创建单一功能的函数,但与在 Java、Ruby 或 Perl 中不同,无法将多个函数打包到一个能够导入导出的内聚模块或 ”包“ 中。当然,使用 <script> 元素可以包含任意 JavaScript 源代码文件,但这种历史悠久的方法在两个关键方面缺少正确的模块声明。 

首先,使用 <script> 元素包含的任意 JavaScript 将被加载到全局命名空间中。使用模块可以导入的函数被封装在一个局部命名的变量中。其次,同时更为关键的是,可以使用模块显式地声明依赖关系,而使用 <script> 元素则做不到这一点。结果,导入 Module A 时也会同时导入依赖的 Modules B 和 C。当应用程序变得复杂时,传递依赖关系管理很快将成为一种关键需求。 

CommonJS

顾名思义,CommonJS 项目定义了一种通用的模块格式(包括其他浏览器之外的 JavaScript 规范)。Node.js 属于众多非官方的 CommonJS 实现之一。RingoJS (类似于 Node.js 的一种应用服务器,运行在 JDK 上的 Rhino/Nashorn JavaScript 运行时之上) 基于 CommonJS,流行的 NoSQL 持久存储 CouchDB 和 MongoDB 也是如此。

模块是用户衷心期盼的下一 JavaScript 主要版本 (ECMAScript 6) 的功能,但直到该版本被广泛接受之前,Node.js 目前使用的是它自己基于 CommonJS 规范的模块版本。 

使用 require 关键字可以在脚本中包含 CommonJS 模块。例如,清单 4 是对 Node.js 主页上的 Hello World 脚本稍微进行修改后的版本。创建一个名为 example.js 的文件,并将清单 4 中的代码复制到其中。 

清单 4. Node.js 中的 Hello World
var http = require('http');
var port = 9090;
http.createServer(responseHandler).listen(port);
console.log('Server running at http://127.0.0.1:' + port + '/');

function responseHandler(req, res){
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end('<html><body><h1>Hello World</h1></body></html>');
}

输入 node example.js 命令运行新的 Web 服务器,然后在 Web 浏览器中访问 http://127.0.0.1:9090。 

看一看清单 4 中的头两行。您很可能写过几百次(或几千次)像 var port = 9090; 这样的简单语句。这条语句定义了一个名为 port 的变量,并将数字 9090 赋值给它。第一行 (var http = require('http');) 用于导入一个 CommonJS 模块。它引入 http 模块并将它指派给一个局部变量。 and assigns it to a local variable. All of the corresponding modules that http 依赖的所有对应模块也同时被 require 语句导入。 

example.js 后面的代码行:

  1. 创建一个新的 HTTP 服务器。
  2. 指定一个函数来处理响应。
  3. 开始监听指定端口上进入的 HTTP 请求。

这样通过寥寥几行 JavaScript 代码,就可以在 Node.js 中创建了一个简单的 Web 服务器。在本系列随后的文章中您会看到,Express 将这个简单的例子被扩展用于处理更为复杂的路由,同时还将提供静态与动态生成的资源。 

http 模块是 Node.js 安装的标准组件之一。其他标准的 Node.js 模块还支持文件 I/O,读取来自用户的命令行输入,处理底层的 TCP 和 UDP 请求等等。访问 Node.js 文档的 Modules 部分,查看标准模块的完整列表并了解它们的功能。 

尽管模块列表内容十分丰富,但与可用的第三方模块列表相比,仍然是小巫见大巫。要访问它们,您需要熟悉另一个命令行实用工具:NPM。 

 

什么是 NPM?

NPM 是 Node Packaged Modules 的简写。要查看包含超过 75,000 个公用第三方 Node 模块的清单,请访问 NPM 网站。在网站上搜索 yo 模块。图 2 显示了搜索结果。 

图 2. yo 模块的详细情况

显示了 yo 模块的详细信息的 NPM 搜索结果的屏幕截图

结果页面简要介绍了该模块(搭建 Yeoman 项目的 CLI 工具),并显示它在过去一天、一周和一月内被下载的次数、编写该模块的作者、它依赖于哪些其他的模块(如果存在)等内容。最重要的是,结果页面给出了安装该模块的命令行语法。 

要从命令行获取关于 yo 模块的类似信息,请输入 npm info yo 命令。(如果您还不知道模块的官方名称,可以输入 npm search yo 来搜索名称中包含字符串 yo 的所有模块。)npm info 命令显示模块的 package.json 文件的内容。 

了解 package.json

每个 Node.js 模块都必须关联一个格式良好的 package.json 文件,因此,熟悉此文件的内容是值得的。清单 5、清单 6 和清单 7 分三部分显示了 yo 模块的 package.json 文件的内容。 

如清单 5 中所示,第一个元素通常是 namedescription 和一个可用 versions 的 JSON 数组。 

清单 5. package.json,第 1 部分
$ npm info yo

{ name: 'yo',
  description: 'CLI tool for scaffolding out Yeoman projects',
  'dist-tags': { latest: '1.1.2' },
  versions:
   [
     '1.0.0',
     '1.1.0',
     '1.1.1',
     '1.1.2' ],

要安装一个模块的最新版本,请输入 npm install package 命令。输入 npm install package@version 可以安装一个特定的版本。 

如清单 6 中所示,接下来将显示作者、维护者和可以直接查找源文件的 GitHub 库。

清单 6. package.json,第 2 部分
author: 'Chrome Developer Relations',
repository:
 { type: 'git',
   url: 'git://github.com/yeoman/yo' },
homepage: 'http://yeoman.io',
keywords:
 [ 'front-end',
   'development',
   'dev',
   'build',
   'web',
   'tool',
   'cli',
   'scaffold',
   'stack' ],

在这个例子中,还可以看到一个指向项目主页的链接和一个相关关键字的 JSON 数组。并非所有 package.json 文件中都会出现所有这些字段,但用户很少会抱怨与一个项目相关的元数据太多。 

最后,清单 7 中列出了附有显式版本号的依赖关系。这些版本号符合主版本.次版本.补丁版本的常用模式,被称为 SemVer(语义版本控制)。 

清单 7. package.json,第 3 部分
engines: { node: '>=0.8.0', npm: '>=1.2.10' },
dependencies:
 { 'yeoman-generator': '~0.16.0',
   nopt: '~2.1.1',
   lodash: '~2.4.1',
   'update-notifier': '~0.1.3',
   insight: '~0.3.0',
   'sudo-block': '~0.3.0',
   async: '~0.2.9',
   open: '0.0.4',
   chalk: '~0.4.0',
   findup: '~0.1.3',
   shelljs: '~0.2.6' },
peerDependencies:
 { 'grunt-cli': '~0.1.7',
   bower: '>=0.9.0' },
devDependencies:
 { grunt: '~0.4.2',
   mockery: '~1.4.0',
   'grunt-contrib-jshint': '~0.8.0',
   'grunt-contrib-watch': '~0.5.3',
   'grunt-mocha-test': '~0.8.1' },

这个 package.json 文件表明,它必须安装在 0.8.0 或更高版本的 Node.js 实例上。如果试图使用 npm install 命令安装一个不受支持的版本,那么安装将会失败。 

SemVer 的快捷语法

在 清单 7 中,您会注意到,很多依赖关系版本中都有一个波浪符号 (~)。这个符号相当于 1.0.x(也属于有效语法),意思是 ”主版本必须是 1,次版本必须是 0,但您可以安装所能找到的最新补丁版本“。SemVer 中的这种隐含表达法意味着,补丁版本绝不会 对 API 做出重大修改(通常是对现有功能的缺陷修复),而次版本会在不打破现有功能的情况下引入另外的功能(比如新的函数调用)。 

除了平台要求之外,这个 package.json 文件还提供几个依赖关系列表:

  • dependencies 部分列出了运行时的依赖关系。
  • devDependencies 部分列出了开发过程中需要的模块。
  • peerDependencies 部分支持作者定义项目之间的 ”对等“ 关系。这种功能通常用于指定基础项目与其插件之间的关系,但在这个例子中,它指出了包含 Yeoman 项目与 Yo 的其他两个项目(Grunt 与 Bower)。

如果在不指定模块名的情况下输入 npm install 命令,那么 npm 会访问当前目录中的 package.json 文件,并安装我刚刚讨论过的三部分内容中列出的所有依赖关系。 

安装一个能正常工作的 MEAN 堆栈,下一步是安装 Yeoman 与相应的 Yeoman-MEAN 生成器。 

 

安装 Yeoman

作为一名 Java 开发人员,我无法想象在没有诸如 Ant 或 Maven 这样的编译系统的情况下如何启动一个新项目。类似地,Groovy 和 Grails 开发人员依靠的是 Gant(Ant 的一种 Groovy 实现)或 Gradle。这些工具可以搭建起一个新的目录结构,动态下载依赖关系,并准备好将项目发布。 

在纯粹的 Web 开发环境中,Yeoman 可以满足这种需要。Yeoman 是三种 Node.js 工具的集合,包括用于搭建的纯 JavaScript 工具 Yo,管理客户端依赖关系的 Bower,以及准备项目发布的 Grunt。通过分析 清单 7 可以得出这样的结论:安装 Yo 时也会安装它对等的 Grunt 和 Bower,这要感谢 package.json 中的 peerDependencies 部分。 

通常,输入 npm install yo --save 命令可以安装 yo 模块并更新 package.json 文件中的 dependencies 部分。(npm install yo --save-dev 用于更新 devDependencies 部分。)但这三个对等的 Yeoman 模块算不上是特定于项目的模块,它们是命令行实用工具,而非运行时依赖关系。要全局安装一个 NPM 包,需要在 install 命令后增加一个 -g 标志。 

在系统上安装 Yeoman:

npm install -g yo

在完成包安装后,输入 yo --version 命令来验证它已经在运行中。 

Yeoman 与基础架构的所有余下部分都准备就绪后,便可以开始安装 MEAN 堆栈了。 

 

安装 MeanJS

您可以手动安装 MEAN 堆栈的每一部分,但需要十分小心。谢天谢地,Yeoman 通过其 generators(生成器) 提供了一种更轻松的安装方式。 

Yeoman 生成器就是引导一个新 Web 项目更轻松的方式。该生成器提供了基础包及其所有依赖关系。此外,它通常还会包含一个工作的编译脚本及其所有相关插件。通常,该生成器还包含一个示例应用程序,包括测试在内。 

Yeoman 团队构建和维护了几个 “官方的” Yeoman 生成器社区驱动的 Yeoman 生成器(超过 800 个)远远超过官方生成器的数量。 

您将用于引导第一个 MEAN 应用程序的社区生成器被称为 MEAN.JS,这也在意料之中。

在 MEAN.JS 主页上,单击 Yo Generator 菜单选项或者直接访问 Generator 页面,图 3 中显示了其中的一部分。 

图 3. MEAN.JS Yeoman 生成器

MEAN.JS Yeoman 生成器页面的屏幕截图

该页面上的说明指出要首先 Yeoman,这一点您已经完成。

还需要安装bower和grunt-cli

npm install -g bower
npm install -g grunt-cli
 

下一步是全局安装 MEAN.JS 生成器: 

npm install -g generator-meanjs

生成器准备就绪后,便可以开始创建您的第一个 MEAN 应用程序了。创建一个名为 test 的目录,使用 cd 命令进入它,然后输入 yo meanjs命令生成应用程序。回答最后两个问题,如清单 8 中所示。(您可以为开始四个问题提供自己的答案。) 

清单 8. 使用 MEAN.JS Yeoman generator
$ mkdir test
$ cd test
$ sudo yo meanjs


     _-----_
    |       |
    |--(o)--|   .--------------------------.
   `---------�  |    Welcome to Yeoman,    |
    ( _�U`_ )   |   ladies and gentlemen!  |
    /___A___\   '__________________________'
     |  ~  |
   __'.___.'__
 �   `  |� � Y `

You're using the official MEAN.JS generator.
[?] What would you like to call your application?
Test
[?] How would you describe your application?
Full-Stack JavaScript with MongoDB, Express, AngularJS, and Node.js
[?] How would you describe your application in comma separated key words?
MongoDB, Express, AngularJS, Node.js
[?] What is your company/author name?
Scott Davis
[?] Would you like to generate the article example CRUD module?
Yes
[?] Which AngularJS modules would you like to include?
ngCookies, ngAnimate, ngTouch, ngSanitize

在回答最后一个问题后,您会看到一系列行为,这是 NPM 在下载所有服务器端的依赖关系(包括 Express)。NPM 完成后,Bower 将下载所有客户端的依赖关系(包括 AngularJS、Bootstrap 和 jQuery)。 

至此,您已经安装了 EAN 堆栈(Express、AngularJS 和 Node.js) — 目前只缺少 M (MongoDB)。如果现在输入 grunt 命令,在没有安装 MongoDB 的情况下启动应用程序,您会看到类似于清单 9 中的一条错误消息。 

清单 9. 试图在没有 MongoDB 的情况下启动 MeanJS
events.js:72
        throw er; // Unhandled 'error' event
              ^
Error: failed to connect to [localhost:27017]
    at null.<anonymous>
(/test/node_modules/mongoose/node_modules/mongodb/lib/mongodb/connection/server.js:546:74)

[nodemon] app crashed - waiting for file changes before starting...

如果启动应用程序时看到这条错误消息,请按下 Ctrl+C 键停止应用程序。 

为了使用新的 MEAN 应用程序,现在需要安装 MongoDB。 

 

安装 MongoDB

MongoDB 是一种 NoSQL 持久性存储。它不是使用 JavaScript 编写的,也不是 NPM 包。必须单独安装它才能完成 MEAN 堆栈的安装。 

访问 MongoDB 主页,下载平台特定的安装程序,并在安装 MongoDB 时接受所有默认选项。 

安装完成时,输入 mongod 命令启动 MongoDB 守护程序。 

MeanJS Yeoman 生成器已经安装了一个名为 Mongoose 的 MongoDB 客户端模块,您可以检查 package.json 文件来确认这一点。我将在后续的文章中详细介绍 MongoDB 和 Mongoose。 

安装并运行 MongoDB 后,最终您可以运行您的 MEAN 应用程序并观察使用效果了。 

 

运行 MEAN 应用程序

要启动新安装的 MEAN 应用程序,在运行 MeanJS Yeoman 生成器之前,一定要位于您创建的 test 目录中。在输入 grunt 命令时,输出内容应该如清单 10 中所示。

清单 10. 启动 MEAN.JS 应用程序
$ grunt

Running "jshint:all" (jshint) task
>> 46 files lint free.

Running "csslint:all" (csslint) task
>> 2 files lint free.

Running "concurrent:default" (concurrent) task
Running "watch" task
Waiting...
Running "nodemon:dev" (nodemon) task
[nodemon] v1.0.20
[nodemon] to restart at any time, enter `rs`
[nodemon] watching: app/views/**/*.* gruntfile.js server.js config/**/*.js app/**/*.js
[nodemon] starting `node --debug server.js`
debugger listening on port 5858

 NODE_ENV is not defined! Using default development environment

MEAN.JS application started on port 3000

jshint 和 csslint 模块(均由生成器进行安装)可以确保源代码在句法和语体上是正确的。nodemon 包监控文件系统中的代码修改情况,并在检测到有的情况下自动重启服务器,当开发人员需要快速而频繁地修改代码基础时,这可以极大地提高他们的效率。(nodemon 包只在开发阶段运行,要监测生产环境的变化,必须重新部署应用程序并重启 Node.js。) 

按照控制台输出的提示,访问 http://localhost:3000 并运行您的新 MEAN 应用程序。 

图 4 显示了 MEAN.JS 示例应用程序的主页。

图 4. MEAN.JS 示例应用程序的主页

MEAN.JS 主页的屏幕截图

在菜单栏中单击 Signup 创建一个新的用户账号。现在填写 Sign-up 页面上的所有字段(如图 5 中所示),然后单击 Sign up。在后续的指南中,您可以通过 Facebook、Twitter 等启用 OAuth 登录 

图 5. MEAN.JS 示例应用程序的 Sign-up 页面

MEAN.JS 示例应用程序的 Sign-up 页面的屏幕截图

现在,您的本地 MongoDB 实例中已经保存了一组用户证书,您可以开始撰写新的文章了。单击 Articles 菜单选项(当您登录之后才会显示出来),并创建一些示例文章。图 6 显示了 Articles 页面。 

图 6. MeanJS 的文章页面

MeanJS 文章页面的屏幕截图

您已经创建了自己的第一个 MEAN 应用程序。欢迎加入! 

结束语

在这篇指南中,您完成相当多的内容。安装 Node.js 并编写了第一个 Node.js 脚本。学习了模块并使用 NPM 安装了几个第三方模块。安装 Yeoman 并将它作为可靠的 Web 开发平台,其中包含一个搭建实用工具 (Yo),一个编译脚本 (Grunt),以及一个管理客户端依赖关系的实用工具 (Bower)。安装 MeanJS Yeoman 生成器,并使用它来创建第一个 MEAN 应用程序。安装 MongoDB 与 Node.js 客户端库 Mongoose。最后运行您的首个 MEAN 应用程序。 

下一次,我们会详细了解示例应用程序的源代码,从而了解 MEAN 太阳系中的所有四颗行星 (MongoDB、Express、AngularJS 和 Node.js)是如何相互作用的。

【两性】谈恋爱

身边有个朋友一直都想找对象,本人也天天用着各种社交软件。

所幸的是,我已成功通过QQ附近的人找到了我的人生伴侣,就是我现在的老婆。

于是乎,苦思冥想一个问题:怎么才能谈恋爱?

昨天在卫生间顿悟,两个人在一起,一定要一起做事儿!比如:一起上课,一起工作,一起泡吧,一起参加日语角,一起做公益活动,总之呢,要先干一件事儿,然后慢慢的就发现两个人在一起合适,就成功牵手了。

或许会有人说:相亲成功的怎么讲?

我觉得相亲,包括社交软件等,只是增加了两人碰撞的机会,并不会改变两人在一起的条件。如果没有共同的爱好,没有能一起做的事情,走在一起概率太低了。然后,这样的方式却能帮助有相同点的两人增加机会。

所以呀,想要找对象,还是多去做自己喜欢做的事情,总会找到自己喜欢的!

Scala开发环境配置

  1. 安装IntelliJ IDEA
  2. 安装Scala Plugin
  3. 下载Scala包
  4. 添加Scala的bin目录到PATH
  5. 运行scala检测
  6. 下载Lift包
  7. 选择进入lift目录,如lift-basic
  8. 运行./sbt,自动下载依赖包
  9. 在sbt控制台下运行gen-idea,生成IDEA的项目文件
  10. 用IDEA打开当前文件夹,载入项目
  11. 在sbt控制台下运行container:start,启动项目
  12. http://127.0.0.1:8080查看项目

Lambada表达式

xxx(输入参数)=>(lambda操作符)xxx(表达式或者语句块)

//x的类型省略了,编译器可以根据上下文推断出来,后面跟着的是表达式

x => x+1
delegate(int x){return x+1;}

//后面跟着的是语句块

x=>{return x+1;}
delegate(int x){return x+1;}

//输入参数也可以带类型,带类型后别忘记小括号哦

(int x) => x+1
delegate(int x){return x+1;}

 

//也可以多个输入参数,逗号分隔,别忘记小括号

(x,y) => x+y
delegate(int x,int y){return x+y;}

//无参的也行

() => 1
delegate(){return 1;}