发表于 | 分类于 | | 阅读次数:

在Kotlin，一切皆对象，我们可以在任何变量上调用成员函数和属性。有些类型是内置的，因为它们的实现是经过优化的，但是对于用户来说，它们看起来就像普通的类。本节描述这些类型中的大多数： numbers, characters, booleans and arrays.

阅读全文 »

发表于 | 分类于 | | 阅读次数:

数据类

1
data class Customer(val name: String, val email: String)

Customer提供了以下方法：

  • getters，如果成员变量使用var定义那么还默认提供setters
  • equals()
  • hashCode()
  • toString()
  • copy()
  • component1(), component2() …

这跟Scala的case class基本上差不多，一般在做数据交互/传输时用

函数默认值

1
fun foo(a: Int = 0, b: String = "") { ... }

列表过滤

1
val positives = list.filter { x -> x > 0 }

或者更短一点

1
val positives = list.filter { it > 0 }

默认使用it来接收单个的参数

字符串插值

1
println("Name $name")

对象检查

1
2
3
4
5
when (x) {
    is Foo -> ...
    is Bar -> ...
    else   -> ...
}

非常精简，再也不要写Java那个烦人的instanceof

遍历映射/列表

1
2
3
for ((k, v) in map) {
    println("$k -> $v")
}

k, v分别是map的key和value，是list的index和value

使用范围

1
2
3
4
5
for (i in 1..100) { ... }  // closed range: includes 100
for (i in 1 until 100) { ... } // half-open range: does not include 100
for (x in 2..10 step 2) { ... }
for (x in 10 downTo 1) { ... }
if (x in 1..10) { ... }

只读映射/列表

1
2
val list = listOf("a", "b", "c")
val map = mapOf("a" to 1, "b" to 2, "c" to 3)

如果是集合是不是还有setOf，命名的统一性也是Kotlin的一个亮点，如果你使用过php的话，感觉函数总是记不住。

映射访问

1
2
println(map["key"])
map["key"] = value

懒值(Lazy)

1
2
3
val p: String by lazy {
    // compute the string
}

这段代码在定义的时候是不会执行变量的值的，只有在使用这个变量的时候才会求值

扩展

这是Kotlin一个非常强大的功能，可以对原来已经存在的类添加一系列的新方法，扩展别人的包非常方便

1
2
3
fun String.spaceToCamelCase() { ... }
"Convert this to camelcase".spaceToCamelCase()

单例

做Java是不是会经常被问单例模式是怎么实现的，Kotlin直接使用object来定义，直白得不要不要的，这和Scala也是一样的

1
2
3
object Resource {
    val name = "Name"
}

null值检查

1
2
3
val files = File("Test").listFiles()
println(files?.size)
println(files?.size ?: "empty")

相比Java的if (files != null)优雅太多了。files如果是空值，新手写代码如果不做Null检查，就会碰到最常见的NullException。Kotlin使用问号来检查，并且null值会一值传递到最后。

1
2
val data = ...
val email = data["email"] ?: throw IllegalStateException("Email is missing!")

Kotlin使用?:也是非常的简洁，如果data["email"]有值，直接使用，如果没有就抛出异常。如果想只有在有值的情况下

1
2
3
4
5
val data = ...
data?.let {
    ... // execute this block if not null
}

映射空值检查

1
2
3
val data = ...
val mapped = data?.let { transformData(it) } ?: defaultValueIfDataIsNull

when表达式作为返回值

Kotlin是基于表达式，而不是基于语句的。也就是说任何的语言结构都是有返回值的，这也是和Scala是一样的。

1
2
3
4
5
6
7
8
fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

这里when是一个表达式，表达式是有值的，如果color是Green，那么这个when的值就是2

try/catch

同样try/catch也是有值的

1
2
3
4
5
6
7
8
9
fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }
    // Working with result
}

if

if也是表达式，也是有值的

1
2
3
4
5
6
7
8
9
fun foo(param: Int) {
    val result = if (param == 1) {
        "one"
    } else if (param == 2) {
        "two"
    } else {
        "three"
    }
}

如果上面最后那个else没有写的话，编译是通不过的，如果if作为一个表达式，那么必须覆盖所有的情况。

使用with调用多个方法

这个特性也比较酷，结构跟python的差不多：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}
val myTurtle = Turtle()
with(myTurtle) { //draw a 100 pix square
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

Java 7的try-with-resources语句

在Java 7的写法如下

1
2
3
try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
}

在Kotlin写法更加直观

1
2
3
4
val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
    println(reader.readText())
}

泛型

1
2
3
4
5
6
//  public final class Gson {
//     ...
//     public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException {
//     ...
inline fun <reified T: Any> Gson.fromJson(json): T = this.fromJson(json, T::class.java)

可空布尔类型使用

1
2
3
4
5
6
val b: Boolean? = ...
if (b == true) {
    ...
} else {
    // `b` is false or null
}

发表于 | | 阅读次数:

solr7搭建运行非常简单，首先下载压缩包，然后解压，到解压出来的目录执行：bin/solr start即可启动solr。以这种方式启动的solr是single core的模式。推荐部署cloud模式，可以有更好的伸缩性与扩展性，使用：bin/solr start -c可以启动cloud模式。下面主要针对cloud模式介绍solr7.2.1的搭建与查询。

阅读全文 »

发表于 | | 阅读次数:

0. Elasticsearch的版本是2.3.4

首先你得有自己的一Analyzer和Tokenizer，可以参考前面的一篇文章

1. pom.xml

使用maven来构建项目，需要包含elasticsearch的依赖，否则编译不了

1
2
3
4
5
6
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>2.3.4</version>
    <scope>provided</scope>
</dependency>

然后es的plugin需要一个描述文件plugin-descriptor.properties，把这个文件放在src/main/resources这个目录，打包后安装到es里面就会出现在插件目录下了。这个文件需要写入下面的内容：

1
2
3
4
5
6
7
8
description=${project.description}
version=${project.version}
name=${elasticsearch.plugin.name}
site=${elasticsearch.plugin.site}
jvm=${elasticsearch.plugin.jvm}
classname=${elasticsearch.plugin.classname}
java.version=${elasticsearch.plugin.java.version}
elasticsearch.version=${elasticsearch.version}

这些才使用了maven在pom.xml定义的内容，直接定义在pom.xml的根路径下：

1
2
3
4
5
6
7
8
9
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <elasticsearch.plugin.name>elasticsearch-analysis-demo</elasticsearch.plugin.name>
    <elasticsearch.plugin.site>false</elasticsearch.plugin.site>
    <elasticsearch.plugin.jvm>true</elasticsearch.plugin.jvm>
    <elasticsearch.plugin.java.version>1.8</elasticsearch.plugin.java.version>
    <elasticsearch.version>2.3.4</elasticsearch.version>
    <elasticsearch.plugin.classname>org.elasticsearch.plugin.AnalysisDemoPlugin</elasticsearch.plugin.classname>
</properties>

最重要的就是plugin-descriptor.properties里面的classname，也就是pom.xml定义的elasticsearch.plugin.classname节点里面的类名，这个类就是es加载plugin的入口。

2. 继承Plugin

现在来看Java代码，分词插件入口类需要继承org.elasticsearch.plugins.Plugin类，并实现三个方法：

  1. public String name() 返回插件名字
  2. public String description 返回插件的描述
  3. public void onModule(AnalysisModule model) 可以使用model这个AnalysisModule对象添加自定义的分词器

上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package org.elasticsearch.plugin;
import com.lexiscn.elasticsearch.hylanda.HylandaAnalysisBinderProcessor;
import org.elasticsearch.index.analysis.AnalysisModule;
import org.elasticsearch.plugins.Plugin;
public class AnalysisDemoPlugin extends Plugin {
	public static String PLUGIN_NAME = "elasticsearch-analysis-demo";
    @Override
    public String name() {
        return PLUGIN_NAME;
    }
    @Override
    public String description() {
        return PLUGIN_NAME;
    }
    public void onModule(AnalysisModule model) {
        model.addProcessor(new HylandaAnalysisBinderProcessor());
    }
}

在model.addProcessor这个方法调用的时候，需要一个org.elasticsearch.index.analysis.AnalysisModule.AnalysisBinderProcessor对象。所以还需要实现一个继承处AnalysisBinderProcessor的类：

2. 实现AnalysisBinderProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package org.elasticsearch.demo;
import org.elasticsearch.index.analysis.AnalysisModule;
public class DemoAnalysisBinderProcessor extends AnalysisModule.AnalysisBinderProcessor {
    @Override
    public void processAnalyzers(AnalyzersBindings analyzersBindings) {
        analyzersBindings.processAnalyzer("hylanda_analyzer", DemoAnalyzerProvider.class);
    }
    @Override
    public void processTokenizers(TokenizersBindings tokenizersBindings) {
        tokenizersBindings.processTokenizer("hylanda_tokenizer", DemoTokenizerFactory.class);
    }
}

这个继承自AnalysisBinderprocessor的类根据需要实现processAnalyzers和processTokenizers方法。一个添加analyzer，一个是添加tokenizer，第一个参数就是analyzer或者tokenizer的名字。这里就可以添加自己的分词器了，不过还需要一点点努力。如果是Analyzer还需要一个继承自org.elasticsearch.index.analysis.AbstractIndexAnalyzerProvider的类；如果是Tokenizer还需要一个继承自org.elasticsearch.index.analysis.AbstractTokenizerFactory的类。

3. 实现AbstractTokenizerFactory

先来看继承自AbstractTokenizerFactory的Tokenizer的工厂类:

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
package org.elasticsearch.demo;
import org.apache.lucene.analysis.Tokenizer;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.inject.assistedinject.Assisted;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.index.Index;
import org.elasticsearch.index.analysis.AbstractTokenizerFactory;
import org.elasticsearch.index.settings.IndexSettingsService;
public class DemoTokenizerFactory extends AbstractTokenizerFactory {
    public DemoTokenizerFactory(Index index, Settings indexSettings, String name, Settings settings) {
        super(index, indexSettings, name, settings);
    }
    /**
     * 必须实现此方法，而且需要标记为@Inject
     *
     * @param index
     * @param indexSettingsService
     * @param name
     * @param settings
     */
    @Inject
    public DemoTokenizerFactory(
            Index index, IndexSettingsService indexSettingsService,
            @Assisted String name, @Assisted Settings settings) {
        super(index, indexSettingsService.getSettings(), name, settings);
    }
    @Override
    public Tokenizer create() {
        return new DemoTokenizer();
    }
}

在2.3.4的es版本里面使用的是Guice依赖注入框架，所以必须实现上面标注了@Inject的构造方法。还要实现public Tokenizer create()方法，然后在create方法里面new自己的Tokenizer即可。

4. 实现AbstractIndexAnalyzerProvider

再来看看Analyzer的Provider：

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
package org.elasticsearch.demo;
import org.apache.lucene.analysis.Analyzer;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.inject.assistedinject.Assisted;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.env.Environment;
import org.elasticsearch.index.Index;
import org.elasticsearch.index.analysis.AbstractIndexAnalyzerProvider;
import org.elasticsearch.index.settings.IndexSettingsService;
public class DemoAnalyzerProvider extends AbstractIndexAnalyzerProvider {
    public DemoAnalyzerProvider(Index index, Settings indexSettings, String name, Settings settings) {
        super(index, indexSettings, name, settings);
    }
    /**
     * 必须实现此方法，而且需要标记为@Inject
     *
     * @param index
     * @param indexSettingsService
     * @param env
     * @param name
     * @param settings
     */
    @Inject
    public DemoAnalyzerProvider(Index index, IndexSettingsService indexSettingsService, Environment env,
                                @Assisted String name, @Assisted Settings settings) {
        super(index, indexSettingsService.getSettings(), name, settings);
    }
    @Override
    public Analyzer get() {
        return new DemoAnalyzer();
    }
}

跟上面的Tokenizer一样，必须实现上面代码标注了@Inject的构造方法，然后就需要实现public Analyzer get()方法，在这个get方法里面可以new自己的Analyzer

5. package

这需要使用到maven的assembly插件来对代码以及相应的资源打包，这样就可以使用es提供的plugin命令行工具进行安装了。

首先需要在pom.xml添加assembly插件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<plugin>
	<artifactId>maven-assembly-plugin</artifactId>
	<configuration>
		<outputDirectory>${project.build.directory}/releases/</outputDirectory>
		<descriptors>
			<descriptor>${basedir}/src/main/assembly/plugin.xml</descriptor>
		</descriptors>
	</configuration>
	<executions>
		<execution>
			<phase>package</phase>
			<goals>
				<goal>single</goal>
			</goals>
		</execution>
	</executions>
</plugin>

然后添加src/main/assembly/plugin.xml，这个文件也可以放到其他地方，主要是上面的descriptor节点指定

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
<?xml version="1.0"?>
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>release</id>
    <formats>
        <format>jar</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <fileSets>
        <fileSet>
            <directory>${project.basedir}/src/main/plugin-metadata</directory>
            <outputDirectory>/</outputDirectory>
        </fileSet>
        <fileSet>
            <directory>${project.basedir}/lib</directory>
            <outputDirectory>/</outputDirectory>
        </fileSet>
    </fileSets>
    <files>
        <file>
            <source>${project.basedir}/src/main/resources/plugin-descriptor.properties</source>
            <filtered>true</filtered>
            <outputDirectory>/</outputDirectory>
        </file>
    </files>
    <dependencySets>
        <dependencySet>
            <outputDirectory>/</outputDirectory>
            <useProjectArtifact>true</useProjectArtifact>
            <excludes>
                <exclude>org.elasticsearch:elasticsearch</exclude>
                <exclude>org.apache.lucene:lucene*</exclude>
                <exclude>com.spatial4j:spatial4j</exclude>
            </excludes>
        </dependencySet>
    </dependencySets>
</assembly>

根据自己需要做相应修改。基本上就是上面一些东西，这些坑都填平了，其他就就可以进行打包安装了

6. 打包安装

在source根目录下使用mvn clean install。然后到ES根目录使用下面的命令进行插件的安装:

./bin/plugin install file:///absolute/path/to/source/target/release/xxxx.jar

Windows使用：

.\bin\plugin.bat install file:///C:/absolute/path/to/source/target/release/xxxx.jar
`

好了。

发表于 | | 阅读次数:

0、先定义一下分词的结果

从最简单的做起，把输入的内容按一个字一个字进行切分。这里只是为了说明自定义的Analyzer以及Tokenizer如何写。Analyzer需要一个Tokenizer来进行切词，所以还需要定义一个自己的Tokenizer。

1、先从Analyzer开始

Lucene版本为5.5以上

定义自己的Analyzer需要继承org.apache.lucene.analysis.Analyzer，并且实现TokenStreamComponents createComponents(String s)方法。咱们的Analyzer名字叫DemoAnalyzer。上代码：

import org.apache.lucene.analysis.Analyzer;

public class DemoAnalyzer extends Analyzer {
    @Override
    protected TokenStreamComponents createComponents(String s) {
        return new TokenStreamComponents(
                new DemoTokenizer()
        );
    }
}

在createComponents方法里面直接new一个TokenStreamComponents对象，对象里面包含的是咱们自定义的DemoTokenizer对象。

2、定义Tokenizer

自定义的Tokenizer需要继承org.apache.lucene.analysis.Tokenizer，并且实现boolean incrementToken()方法。这个方法比较特殊：

  1. 此方法并不是一次性调用，而是进行的迭代调用，也就是说一次是读取一个分词，第二次再读取下一个分词，依次类推。

  2. 需要一系列的Attribute来存放对应的一个分词（也就是term）的信息，包括词本身、类型（type），位置，词的始末偏移量等等。这个是通过调用addAttribute方法实现的。

  3. input这个Reader并不需要自己传入，这个就是输入的需要分词的文本在父类已经实现了setReader(Reader input)方法，Lucene自己会调用此方法传入文本

上代码：

import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
import org.apache.lucene.analysis.tokenattributes.TypeAttribute;

import java.io.IOException;

public class DemoTokenizer extends Tokenizer {

    private int position = 0;

    protected CharTermAttribute charAttr =
            addAttribute(CharTermAttribute.class);
    protected TypeAttribute typeAttr = addAttribute(TypeAttribute.class);
    private final PositionIncrementAttribute positionAttr =
            addAttribute(PositionIncrementAttribute.class);
    private final OffsetAttribute offsetAtt = addAttribute(OffsetAttribute.class);

    @Override
    public boolean incrementToken() throws IOException {
        clearAttributes();

        char[] c = new char[1];

        int count = this.input.read(c, this.position, 1);

        // 返回false代表读完了
        if (count == -1) {
            return false;
        }

        charAttr.append(c[0]);
        typeAttr.setType("Char");
        positionAttr.setPositionIncrement(position+1);
        offsetAtt.setOffset(correctOffset(position), correctOffset(position+1));

        return true;
    }

    @Override
    public void reset() throws IOException {
        super.reset();
        this.position = 0;
    }
}

首先在类的内容需要几个存放Attribute的属性，比如CharTermAttribute charAttr，在调用incrementToken的时候需要先清空再append进charAttr。

这里只是一个字一个字的进行切分，所以在incrementToken里面只需要读一个字符即可this.input.read(c, this.position, 1)，然后append到charAttr里面。

这个方法的返回值需要注意，返回false表示已经读完的input里面的内容，后面没有文本了。返回true表示后面还有文本需要切分。

最后是reset方法，这里我们使用了position这个成员变量在存放每次读取下一个字符的开始位置，在Lucene调用reset的时候应该把position归零。

-1、Ok

这样就实现了自定义的Analyzer，如果想做其他方法的分词，就可以套用这个外壳了。

发表于 | 分类于 | | 阅读次数:

0. …

clojure和clojurescript不像ruby on rails和django那样all in one的模式，只需要很少的配置就可以建立项目开始开发。clojure系的东西都是library，什么用着顺手就把什么加进来，然后稍做配置再使用。这跟emacs一样，完全私人定制，每个人都有自己的喜欢的extension，这应该是lisp系的习惯吧。所以在使用lisp系的东西的时候没有什么框架能一桶江湖。不过在clojurescript的开发当中figwheel还是少不了的，代码热加载功能太赞了，边写代码边看效果，不需要刷新浏览器，这就是传说的living coding。另外使用集成的IDE工具后，所有东西都有提示，敲两个字母就自动补全了，对于学习一门语言来说的确不是什么好事。闲话不多说，下面来配置一下livind coding的环境，使用spacemacs加上cider，info-clojure两个扩展。

了解更多figwheel请查看其github

1. 配置emacs

在spacemacs的配置文件.spacemacs的dotspacemacs-configuration-layers添加clojure

dotspacemacs-configuration-layers '(clojure)

另外还需要inf-clojure，由于这个扩展不在spacemacs的layer列表里面，需要另外添加，在dotspacemacs-additional-packages添加即可

dotspacemacs-additional-packages '(inf-clojure)

重启spacemacs或者按SPC-f-e-R执行dotspacemacs/sync-configuration-layers

然后还需要添加一个个启动figwheel的函数，在.spacemacs后面添加下面的函数

(defun figwheel-repl ()
  (interactive)
  (run-clojure "lein figwheel"))

在后面按c-x c-e执行上面函数的定义

2. 建立项目，修改project.clj

现在新建一个项目叫hello

lein new app hello

修改project.clj为如下内容

(defproject hello "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.8.0"]]
  :plugins [[lein-figwheel "0.5.6"]]  ;(1)
  :main ^:skip-aot hello.core
  :target-path "target/%s"

  ;;(2)
  :cljsbuild {:builds [{:id "dev"
                        :source-paths ["src/cljs"]
                        :figwheel true
                        :compiler {:main "hello.core"
                                   :asset-path "js/out"
                                   :output-to "resources/public/js/app.js"
                                   :output-dir "resources/public/js/out"}}]}

  :profiles {:uberjar {:aot :all}})

添加了两处：
(1) 添加figwheel的支持
(2) 添加cljsbuild配置，这里需要注意的就是:figwheel true这一行，这是在编译的js文件里面添加figwheel的支持。还有:asset-path "js/out"这一行，不然加载google closure library会找不到对应的路径。

3. 添加html

有了编译配置文件，还需要一个html页面来展示效果，添加一个index.html到resources/public目录

<html>
  <body>
    <script src="js/app.js"></script>
  </body>
</html>

4. core.cljs

添加cljs源代码，需要在src目录下面新建一个目录cljs，由于上面的project.clj指定的:main是hello.core，所以还需要在src/cljs目录下面建一个hello目录以跟包名匹配。然后在src/cljs/hello目录下建一个core.cljs文件，内容如下：

(ns hello.core)

(enable-console-print!)

(println "Hello World!")

5. run

用emacs打开hello下面的clj或者cljs文件，然后M-x figwheel-repl RET，会出来一个*inf-clojure*的buffer，稍微等待一会就会看到下面的内容

Figwheel: Cutting some fruit, just a sec ...
Figwheel: Validating the configuration found in project.clj
Figwheel: Configuration Valid :)
Figwheel: Starting server at http://0.0.0.0:3449
Figwheel: Watching build - dev
Compiling "resources/public/js/app.js" from ["src/cljs"]...
Successfully compiled "resources/public/js/app.js" in 6.043 seconds.
Launching ClojureScript REPL for build: dev
Figwheel Controls:
          (stop-autobuild)                ;; stops Figwheel autobuilder
          (start-autobuild [id ...])      ;; starts autobuilder focused on optional ids
          (switch-to-build id ...)        ;; switches autobuilder to different build
          (reset-autobuild)               ;; stops, cleans, and starts autobuilder
          (reload-config)                 ;; reloads build config and resets autobuild
          (build-once [id ...])           ;; builds source one time
          (clean-builds [id ..])          ;; deletes compiled cljs target files
          (print-config [id ...])         ;; prints out build configurations
          (fig-status)                    ;; displays current state of system
  Switch REPL build focus:
          :cljs/quit                      ;; allows you to switch REPL to another build
    Docs: (doc function-name-here)
    Exit: Control+C or :cljs/quit
 Results: Stored in vars *1, *2, *3, *e holds last exception object
Prompt will show when Figwheel connects to your application

然后启动浏览器，打开http://localhost:3499/index.html，把浏览器的console打开就会看到有Hello World!的打印输出。*inf-clojure*的后面会输出：

To quit, type: :cljs/quit
cljs.user=>

输入一个(js/alert "Hello World!")试试看…

如果不是在emacs使用的话，在命令行使用下面的命令启动figwheel

lein figwheel

QQ: 380800878, 微信: kittenll

发表于 | | 阅读次数:

有的时候vagrant官网提供的boxes可能并不是想要的，有些包含了太多东西，有些box又没有需要的。如果你的开发团队需要这样的一个box，那么你就应该自己动手创建一个。其实创建的过程挺简单的，只要每个步骤操作正确。

Follow下面步骤：

1、安装vagrant

2、安装virtualbox

3、在virtualbox创建一个linux (centos)，假设名字叫centos

4、创建好centos后，还需要安装virtualbox的guest增强插件。安装之前需要在centos安装一些必须的工具：

# yum install kernel-devel gcc perl
# ln -s /usr/src/kernels/2.6.18-164.15.1.el5-i686 /usr/src/linux

上面第二行请把版本号换成你自己安装的centos的内核版本号，你可以通过uname -a查看，或者直接到/user/src/kernels目录查看即可

5、还需要创建一个vagrant账号，密码也是vagrant。注意请把root密码也设置成vagrant

# groupadd vagrant
# useradd -g vagrant vagrant
# passwd vagrant

另外还需要设置sudo，因为vagrant默认会使用vagrant账号挂载工作目录到/vagrant。还需要设置tty，用root账号输入visudo，修改centos里面的/etc/sudoers注释下面两行

#Defaults    requiretty
#Defaults   !visiblepw

添加下面一行到root ALL=(ALL) ALL下面

vagrant ALL=(ALL)       ALL

6、检查guest******.iso是否加载，如果没有加载的话，请添加一个光驱，并且加载这个iso文件，一般这个iso文件在virtualbox的安装目录可以找到

7、连接上终端，输入下面的命令：

mount /dev/cdrom /media/cdrom
cd /media/cdrom
./VBoxLinuxAdditions.run

如果没有error说明安装成功，如果有关于X的错误，有可能是你没有安装X环境，如果只是使用命令行，这个也不用管

8、打包

vagrant package --base centos --output centos.box

vagrant package就是vagrant用来打包的命令，--base指定你创建的虚拟机的名字，后面--output指定导出的box的位置和名字

9、打好包后，自己可以建立一个新的环境测试一下：

vagrant box add base centos.box
cd your vagrant workspace dir
vagrant init base

10、这里要注意的一点是，由于没有找到使用publickey登录的方式，所以必须要在Vagrantfile的最后添加用户名和密码登录

Vagrant.configure("2") do |config|
  # 添加下面两行使用用户名密码登录
  config.ssh.username = "root"
  config.ssh.password = "vagrant"
end

11、启动

vagrant up

发表于 | | 阅读次数:

QQ: 380800878, 微信: kittenll

如果还不熟悉正则表达式的可以先查看正则表达式30分钟入门教程，非常经典的入门教程。

Scala提供的正则表达式功能是通过类Regex来实现，函数签名为：

1
Regex(regex: String, groupNames: String*)

第一个参数为正则表达式的字符串，后面是可变参数列表，是给regex里面的分组起一个名字。Scala的正则表达式的功能非常强大，这要得益于Scala本身特别的设计，尤其是pattern match，是其他编程语言很难超越的。

先来看第一个例子，匹配小写英文字母（如下代码中单独一行的=>表示接下来是结果）:

1
2
3
4
5
6
7
import scala.util.matching.Regex
val str = "abc"
val regex = new Regex("[a-z]+")
println(regex.findAllIn(str).toList)
=>
List(abc)

可以结果看到是一个元素的的List，匹配到字符串abc。如果要匹配到大写和小写，正则表达式需要修改成[a-zA-Z]，还有另外一个办法就是为正则表达式添加选项，让[a-z]可以直接匹配到大写和小写字母，正则表达式就需要写成(?i)[a-z]+

1
2
3
4
5
6
7
import scala.util.matching.Regex
val str = "abcEFGhijk"
val regex = new Regex("(?i)[a-z]+")
println(regex.findAllIn(str).toList)
=>
List(abcEFGhijk)

所以在Scala添加选项的正确姿势就是在正则表达式的前面用使用括号问号+选项字母，这与PHP的正则完全不同，PHP使用如下的方式，使用相同的字符来做开头和结尾，这里就是/，其实在PHP里面使用%, |这些字符也是完全可以的，然后在后面的分割符后面加上选项字母

1
/[a-z]+/i

匹配简单的电话号码：

1
2
3
4
5
6
7
import scala.util.matching.Regex
val str = "13907461234"
val regex = new Regex("""^1[358]\d{9}$""")
println(regex.findAllIn(str).toList)
=>
List(13907461234)

这里使用了"""raw string，三个双引号括起来的内容不需要做转义，正则表达式本身就比较难看，如果再加上转义就更难于阅读和理解。

匹配简单的电子邮件：

1
2
3
4
5
6
val str = "email: abc@xyz.com"
val regex = new Regex("""(?i)[a-z0-9._-]+@[a-z0-9._-]+(\.[a-z0-9._-]+)+""")
println(regex.findAllIn(str).toList)
=>
List(abc@xyz.com)

Scala的正则表达式还有一个非常有用的功能，那就是模式匹配（pattern match），不仅可以查找所有匹配的的字符串，还可以直接提取分组的内容，请看下面api手册的例子：

1
2
3
4
5
6
7
val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r //可以直接使用.r生成一个Regex对象
"2004-01-20" match {
  case date(year, month, day) => s"$year was a good year for PLs."
}
=>
2004 was a good year for PLs.

可以看到上面的例子直接把年份的分组提取了出来，month, day同样也可以提取出来。

1
2
3
4
5
6
7
import scala.util.matching.Regex
"2004-01-20" match {
  case date(_*) => "It's a date!"
}
=>
It's a data!

可以忽略匹配到的参数。

上面仅当字符串为XXXX-XX-XX的时候才可以使用，如果一个字符串不仅仅是只是一个年份，模式匹配是否也可以提取呢？答案是Yes，使用unanchored就可以做到，看下面的例子：

1
2
3
4
5
6
7
8
val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
val embeddedDate = date.unanchored
"Date: 2004-01-20 17:25:18 GMT (10 years, 28 weeks, 5 days, 17 hours and 51 minutes ago)" match {
  case embeddedDate("2004", "01", "20") => "A Scala is born."
}
=>
A Scala is born.

给正则表达式的分组命名：

1
2
3
4
5
6
7
8
import scala.util.matching.Regex
val str = "2016-08-23"
val date = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day")
val matches = date.findAllIn(str)
println("year: " + matches.group("year"))
=>
year: 2016

Scala的正则表达式默认使用单行模式去匹配文本内容

1
2
3
4
5
6
7
import scala.util.matching.Regex
val str = "abc\nefg"
val regex = new Regex("^[a-z].*")
println(regex.findAllIn(str).toList)
=>
List(abc)

只是匹配到了abc，把正则表达式加上s选项那么.就可以匹配到换行符。结果就abc\nefg可以全部匹配到。如果想以多选的方式匹配一段文本内容，那么就需要使用m选项：

1
2
3
4
5
6
7
import scala.util.matching.Regex
val str = "abc\nefg"
val regex = new Regex("(?m)^[a-z].*")
println(regex.findAllIn(str).toList)
=>
List(abc, efg)

测试一个字符串是否匹配一个模式：

1
2
3
4
5
6
val str = "abc123"
val pattern = "[a-z]{3}[0-9]{3}"
println(str.matches(pattern))
=>
true

发表于 | | 阅读次数:

学习一门编程语言就像新出来的婴儿一样，一个裸体可以看清全部。学习编程语言也是一样的，一开始不可以使用任何一个工具。

ClojureScript继承了Clojure简单和富有表现力的语法，编译后的代码可以运行在浏览器和Node.js上面。

编写hello world程序。新建一个目录cljs_first_project，然后还需要建立存放源代码的目录。下载编译器{:target=”_blank”}，目录结构如下：

cljs_first_project
|- build.clj
|- cljs.jar
|- src
    |- cljs_first_project
        |- core.cljs

在core.cljs写入如下内容：

1
2
(ns cljs-first-project.core)
(js/alert "Hello world!")

这段代码定义一个命名空间，然后是一个javascript里面的alert弹出框。另外还需要写一个clojure文件来对源代码进行编译，在根目录下新建一个build.clj文件，内容如下：

1
2
(require 'cljs.build.api)
(cljs.build.api/build "src" {:output-to "out/main.js"})

包含cljs.build.api命名空间，然后调整build函数，此函数接受两个参数，第一个是ClojureScript源代码目录，第二个是是一个map数据结果，这里指定了输出编译后的js的路径。现在使用前面下载的编译器进行编译：

Windows下编译

java -cp "cljs.jar;src" clojure.main build.clj

*nix下编译

java -cp cljs.jar:src clojure.main build.clj

编译完成后会在out目录生成main.js，同时还有其他一些目录。要运行main.js还需要一个greet.html，内容如下：

1
2
3
4
5
6
7
8
9
<html>
  <body>
    <script type="text/javascript" src="out/goog/base.js"></script>
    <script type="text/javascript" src="out/main.js"></script>
    <script type="text/javascript">
      goog.require("cljs_first_project.core")
    </script>
  </body>
</html>

用浏览器打开greet.html就可以看到alert框了。第一个ClojureScript编写编译完成！

再来一点高级功能，把goog/base.js依赖从html去掉，把goog.require("cljs_first_project")也从html里面去掉，只需要包含main.js就可以让程序跑起来。只需要对build.clj修改一下，内容修改如下：

1
2
3
4
5
(require 'cljs.build.api)
(cljs.build.api/build
  "src"
  {:main 'cljs-first-project.core
  :output-to "out/main.js"})

greet.html的内容如下：

1
2
3
4
5
<html>
  <body>
    <script type="text/javascript" src="out/main.js"></script>
  </body>
</html>

打开greet.html，效果跟之前一样。

另外一个高级功能是当编辑源代码的时候不需要手动多次编译，另外在根目录下再写一个watch.clj文件，内容如下：

1
2
3
4
5
(require 'cljs.build.api)
(cljs.build.api/watch
  "src"
  {:main 'cljs-first-project.core
  :output-to "out/main.js"})

只是把调用build的地方改成调用watch函数即可。运行java -cp "cljs.jar;src" clojure.main watch.clj（*nix运行java -cp cljs.jar:src clojure.main watch.clj），此时若修改源文件core.cljs，编译器会自动检测到文件的修改，然后自动进行编译，自动编译后在浏览器刷新即可看到效果。

既然是lisp系，怎么可以少得了REPL(Read-Eval-Print-Loop)。REPL可以让我们直接把代码片段推送到浏览器运行，只需要在REPL里面写上代码，然后立马可以在浏览器看到效果，这个Live Codiing的基础。

同样的要想运行repl也需要clojure的支持，在根目录下新建一个repl.clj，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(require 'cljs.repl)
(require 'cljs.build.api)
(require 'cljs.repl.browser)
    
(cljs.build.api/build
  "src"
  {:main 'cljs-first-project.core
   :output-to "out/main.js"
   :verbose true})
    
(cljs.repl/repl
  (cljs.repl.browser/repl-env)
  :watch "src"
  :output-dir "out")

调整的build函数还是没有变，后面添加一个cljs.repl/repl函数调用。·cljs.repl.browser/repl-env·这个函数定义了一些默认配置，比如打开一个9000端口作为http的服务端口。cljs.repl/repl函数作了下面几件事情：

  1. 监听源代码的修改
  2. 编译修改的源代码
  3. 监听9000端口提供http服务
  4. 打开一个prompt等待输入

修改core.cljs内容如下：

1
2
3
4
5
6
7
(ns cljs-first-project.core
  (:require [clojure.browser.repl :as repl]))
    
(defonce conn
  (repl/connect "http://localhost:9000/repl"))
    
(js/alert "Hello world!")

可以看到这里初始化了一个connection，连接到9000端口的/repl，这里使用defonce是只初始化一次，之后的每次修改都不再连接服务端的REPL。

Ok再来运行repl.clj

java -cp "cljs.jar;src" clojure.main repl.clj

*unix

java -cp cljs.jar:src clojure.main repl.clj

第一编译需要等待一小会，因为需要编译源代码启动http服务，最后会输出等待浏览器连接的提示：

Waiting for browser to connect ...

现在用浏览器打开http://localhost:9000/greet.html，浏览器会显示一个Hello world!的弹出框。这时候命令行会出现一个输入的提示符，如下：

Watch compilation log available at: out\watch.log
To quit, type: :cljs/quit
cljs.user=>

输入(js/alert "Hello World From REPL!")回车，浏览器就是看到这段代码的效果。