1. Apache Spark

2. 스파크 구조

3. RDD (Resilient Distributed Dataset)

3.1 RDD란 ? 

그림 설명 :

3.2 RDD의 활용

3.3 파티션된 데이터셋의 처리과정

4. RDD 생성방법 

hdfsData = sc.textFile("hdfs://data.txt")

5. Spark에서 I/O 지원

6. RDD Transformation

6.1 Single RDD Transformation

  male1, male2, female1 --> female1

2, 5, 6 --> 4, 25, 36

my name is ray --> my, name, is ray

apple, apple, banana --> apple, banana

apple, banana, guava --> banana, apple

6.2 Multiple RDD Transformation

A Set :
  apple, orange, banana
B Set :
  guava, banana, pear

  apple, orange, banana, guava, banana, pear

banana

apple, orange

(apple, guava), (apple, banana), ...

name : age
joe     : 12
sara   : 31
sara   : 40
juan   : 85

myRDD.groupByKey()

joe     : [12]
sara   : [31, 40]
juan   : [85]

7. Laziness Concept

8. RDD Actions

9. Persistence

10. The Lineage Concept (혈통, 계보)

11. Accumulator

12. Broadcast Variables

13. StatsCounter(통계 카운터)

14. DataFrames

15. YARN-based Architecture

16. Tuning with SparkConf

cons = new SparkConf()
conf.set(“spark.executor.memory”, “1g”)
sc = SparkContext(conf)

17. MLib를 이용한 Machine Learning

model = LinearRegressionWithSGC.train(data, iterations = 100, intercept = True)

18. Spark SQL

hiveCtx = HiveContext(sc)
allData = hiveCtx.jsonFile(filein)
allData.registerTempTable(“customers”)
query1 = hiveCtx.sql(“SELECT last, first FROM customers ORDER BY last LIMIT 50”)

19. GraphX Example (PageRank)

graph = GraphLoader.edgeListFile(sc, “followers.txt”)
ranks = graph.pageRank(precision).vertices

20. Spark Streaming

lines = sac.socketTextStream(host, port)
words = lines.flatMap(lambda line: line.split(“ “))
pairs = words.map(lambda word: (word, 1))
wc = pairs.reduceByKey(lambada x, y: x + y)
wc.pprint()
ssc.start()
ssc.awaitTermination()

Apache Spark Install Guide 

1. 스파크 다운로드 및 구성요소 

1. Apache-Spark 다운로드

2. 다운로드 버젼 설정 

3. 다운로드 받은 파일 압축 풀기. 

txr -xvf spark-1.6.1-bin-without-hadoop.tgz
ln -s spark-1.6.1-bin-without-hadoop spark

vim ~/.bash_profile

export SPARK_HOME=/Users/KIDO/Documents/00.TOOLS/spark
export PATH=$JAVA_HOME:$MYSQL_HOME:$ACTIVATOR_HOME:$SPARK_HOME/bin:$PATH

source .bash_profile

4. 스파크 디렉토리 둘러보기

2. Spark Standalone Mode 

1. 클러스터 수동 실행 

./sbin/start-master.sh

./sbin/start-slave.sh <master-spark-URL>

2. 클러스터 런치 스크립트 

• sbin/start-master.sh - 마스터 인스턴스를 실행한다. 
• sbin/start-slaves.sh - conf/slaves 파일에 지정된 머신에 슬레이브를 실행한다. 
• sbin/start-slave.sh - 머신내에 슬레이브 인스턴스를 실행한다. 
• sbin/start-all.sh - 상단에 기술한 모든 마스터와 슬레이브를 실행한다. 
• sbin/stop-master.sh - bin/start-master.sh스크립트를 통해 실행한 마스터 인스턴스를 종료한다. 
• sbin/stop-slaves.sh - conf/slaves파일에 지정된 머신에서 슬레이브를 종료시킨다. 
• sbin/stop-all.sh - 마스터와 슬레이브 모두 종료한다. 

3. 어플리케이션에서 Cluster로 커넥팅 하기

./bin/spark-shell --master spark://IP:PORT

4. Spark Application들 런칭하기. 

./bin/spark-class org.apache.spark.deploy.client kill <master url> <driver ID>

5. Resource Scheduling 

val conf = new SparkConf()
            .setMaster(...)
            .setAppName(...)
            .set("spark.cores.max", "10")
val sc = new SparkContext(conf)

export SPARK_MASTER_OPTS="-Dspark.deploy.defaultCores=<value>"

6. Monitoring and Logging

7. Running Alongside Hadoop

8. Configuring Ports for Network Security

9. High Availability

10. Standby Masters with ZooKeeper

11. Single-Node Recovery with Local File System

• This solution can be used in tandem with a process monitor/manager like monit, or just to enable manual recovery via restart.
• While filesystem recovery seems straightforwardly better than not doing any recovery at all, this mode may be suboptimal for certain development or experimental purposes. In particular, killing a master via stop-master.sh does not clean up its recovery state, so whenever you start a new Master, it will enter recovery mode. This could increase the startup time by up to 1 minute if it needs to wait for all previously-registered Workers/clients to timeout.
• While it’s not officially supported, you could mount an NFS directory as the recovery directory. If the original Master node dies completely, you could then start a Master on a different node, which would correctly recover all previously registered Workers/applications (equivalent to ZooKeeper recovery). Future applications will have to be able to find the new Master, however, in order to register.

Mac에서 ssh기능 실행하기.

1. Mac에서 ssh기능 실행하기. 

2. 인증키 생성하기. 

2.1 인증키 생성하기. 

ssh-keygen -t rsa

Enter file in which to save the key (/Users/KIDO/.ssh/id_rsa):

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

The key's randomart image is:
+---[RSA 2048]----+
|o.  .oo=oo       |
|o. o oo ++       |
| oo =   o+.      |
|o  oooo.E.=      |
|. . .+  .. o     |
|   o  ... .      |
|  .   ...o       |
+----[SHA256]-----+

-rw-------   1 KIDO  staff  1766  5 13 22:57 id_rsa
-rw-r--r--   1 KIDO  staff   404  5 13 22:57 id_rsa.pub

2.2 인증 퍼미션 설정하기. 

chomd 700 .ssh
chmod 600 .ssh/id_rsa
chmod 644 .ssh/id_rsa.pub

2.3 클라이언트용 공개키항목에 추가하기 

cat id_rsa.pub >> authorized_keys

Spark Quick Start

Interactive Analysis with the Spark Shell

기본 : 

./bin/pyspark

>>> textFile = sc.textFile("README.md")

>>> textFile.count()       # 이 RDD에서 아이템의 총 개수를 센다.
126
>>> textFile.first()          # 이 RDD에서 첫번째 아이템을 출력한다.
u'# Apache Spark'

>>> linesWithSpark = textFile.filter(lambda line: "Spark" in line)

>>> textFile.filter(lambda line: "Spark" in line).count()   # "Spark"를 포함하는 라인이 몇개인가?
15

RDD 연산 더보기 

>>> textFile.map(lambda line: len(line.split())).reduce(lambda a, b: a if (a > b) else b)
15

>>> def max(a, b) :
...            if a > b:
...                return a
...            else:
...                return b
>>> textFile.map(lambda line: len(line.split())).reduce(max)
15

>>> wordCounts = textFile.flatMap(lambda line: line.split()).map(lambda word: (word, 1)).reduceByKey(lambda a, b: a+b)

>>> wordCounts.collect()
[[(u'and', 9), (u'A', 1), (u'webpage', 1), (u'README', 1), (u'Note', 1), (u'"local"', 1), (u'variable', 1), ...]

Caching

>>> linesWithSpark.cache()
>>> linesWithSpark.count()
19
>>> linesWithSpark.count()
19

Self-Contained Applications

"""SimpleApp.py"""
from pyspark import SparkContext
logFile = "YOU_SPARK_HOME/README.md"
sc = SparkContext("local", "Simple App")
logData = sc.textFile(logFile).cache()
numAs = logData.filter(lambda s: 'a' in s).count()
numBs = logData.filter(lambda s: 'b' in s).count()
print("Lines with a: %i, lines with b: %i" % (numAs, numBs))

Cluster Mode Overview

Components

Cluster manager Types

Submitting Applications

Monitoring

Job Scheduling

Glossary

Spark Programming Guide

개요 : 

bin/pyspark 

Linking with Spark

from pyspark import SparkContext, SparkConf

$ PYSPARK_PYTHON=python3.4 bin/pyspark
$ PYSPARK_PYTHON=/opt/pypy-2.5/bin/pypy bin/spark-submit examples/src/main/python.pi.py

Initializing Spark

conf = SparkConf().setAppName(appName).setMaster(master)
sc = SparkContext(conf=conf)

Using the Shell

$./bin/pyspark --master local[4]

$./bin/pyspark --master local[4] --py-files code.py

$PYSPARK_DRIVER_PYTHON=ipython ./bin/pyspark

$PYSPARK_DRIVER_PYTHON=ipython PYSPARK_DRIVER_PYTHON_OPTS="notebook" ./bin/pyspark

Resilient Distributed Datasets(RDDs)

Parallelized Collections

data = [1, 2, 3, 4, 5]
distData = sc.parallelize(data)

sc.parallelize(data, 10)

External Datasets

>>> distFile = sc.textFile("data.txt")

distFile.map(lambda s : len(s)).reduce(lambda a, b : a + b)

textFile("/my/directory")
textFile("/my/directory/*.txt")
textFile("/my/directory/*.gz")

>>> rdd = sc.parallelize(range(1, 4)).map(lambda x : (x, "a" * x))
>>> rdd.saveAsSequenceFile("path/to/file")
>>> sorted(sc.sequenceFile("path/to/file").collect())
[(1, u'a'), (2, u'aa'), (3, u'aaa')]

$ SPARK_CLASSPATH=/path/to/elasticsearch-hadoop.jar ./bin/pyspark
>>> conf = {"es.resource" : "index/type"}  #참고 elasticsearch가 로컬에 수행되고 있다고 가정
>>> rdd = sc.newAPIHadoopRDD("org.elasticsearch.hadoop.mr.EsInputFormat", \
            "org.apache.hadoop.io.NullWritable", "org.elasticsearch.hadoop.mr.LinkedMapWritable", conf=conf)
>>> rdd.first() # 결과는 MapWritable이며 이는 Python dict로 변환된다.
(u'Elasticsearch ID',
    {u'field1' : True,
      u'field2' : u'Some Text',
      u'field3' : 12345} )

RDD Operations

Basis

lines = sc.textFile("data.txt")
lineLength = lines.map(lambda s : len(s))
totalLength = lineLengths.reduce(lambda a, b : a + b)

lineLengths.persist()

Passing Functions to Spark

"""MyScript.py"""
if __name__ == "__main__" :
    def myFunc(s) :
        words = s.split("")
        return len(words)
    sc = SparkContext(...)
    sc.textFile("file.txt").map(myFunc)

class MyClass(object) :
    def func(self, s) :
        return s
    def doStuff(self, rdd) :
        return rdd.map(self.func)

class MyClass(object) :
    def __init__(self) :
        self.field = "Hello"
    def doStuff(self, rdd) :
        return rdd.map(lambda s : self.field + s)

def doStuff(self, rdd) :
    field = self.field
    return rdd.map(lambda s : field + s)

Understanding closures

counter = 0
rdd = sc.parallelize(data)
# 오류 : 이렇게 하지말라.
def increment_counter(x)
    global counter
    counter += x
rdd.foreach(increment_counter)
print("Counter value: ", counter)

Printing elements of an RDD

Apache Spark Examples

RDD API Examples

Word Count

1. Python 버젼 : 

text_file = sc.textFile("hdfs://...")
counts = text_file.flatMap(lambda line: line.split("")) \
.map(lambda word: (word, 1)) \
.reduceByKey(lambda a, b : a + b)
counts.saveAsTextFile("hdfs://...")

2. Scala 버젼 : 

val textFile = sc.textFile("hdfs://...")
val counts = textFile.flatMap(line => line.split(""))
        .map(word => (word, 1))
        .reduceByKey(_ + _)
counts.saveAsTextFile("hdfs://...")

3. Java 버젼 : 

JavaRDD<String> textFile = sc.textFile("hdfs://...");
JavaRDD<String> words = textFile.flatMap(new FlatMapFunction<String, String>() {
    public Iterable<String> call(String s) { return Arrays.asList(s.split("")); }
});
JavaPairRDD<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {
    public Tuple2<String, Integer> call(String s) { return new Tuple2<String, String>(s, 1); }
});
JavaPairRDD<String, Integer> counts = pairs.reduceByKey(new Function2<Integer, Integer, Integer>(){
    public Integer call(Integer a, Integer b) {return a + b;}
});
counts.saveAsTextFile("hdfs://...");

Pi Estimation

1. Python 버전 : 

def sample(p) :
    x, y = random(), random()
    return 1 if x*x + y*y < 1 else 0
count = sc.parallelize(xrange(0, NUM_SAMPLES)).map(sample) \
        .reduce(lambda a, b: a + b)
print "Pi is roughly %f" % (4.0 * count / NUM_SAMPLES)

2. Scala 버젼 : 

val count = sc.parallelize(1 to NUM_SAMPLES).map{ i =>
    val x = Math.random()
    val y = Math.random()
    if (x*x + y*y < 1) 1 else 0
}.reduce(_ + _)
println("Pi is roughly " + 4.0 * count / NUM_SAMPLES)

3. Java 버젼 :

List<Integer> l = new ArrayList<Integer>(NUM_SAMPLES);
for (int i = 0; i < NUM_SAMPLES; i++) {
    l.add(i);
}
long count = sc.parallelize(l).filter(new Function<Integer, Boolean>() {
    public Boolean call(Integer i) {
        double x = Math.random();
        double y = Math.random();
        return x * x + y * y < 1;
    }
}).count();
System.out.println("Pi is roughly " + 4.0 * count / NUM_SAMPLES);

DataFrame API Examples

Text Search

1. Python 버젼 

textFile = sc.textFile("hdfs://...")
# Creates a DataFrame having a single column named "line"
df = textFile.map(lambda r : Row(r)).toDF(["line"])
errors = df.filter(col("line").like("%ERROR%"))
# Counts all the errors
errors.count()
# Counts errors mentioning MySQL
errors.filter(col("line").like("%MySQL%")).count()
# Fetches the MySQL errors as an array of strings
errors.filter(col("line").like("%MySQL%")).count()

2. Scala 버젼 

val textFile = sc.textFile("hdfs://...")
// Creates a DataFrame having a single column named "line"
val df = textFile.toDF("line")
val errors = df.filter(col("line").like("%ERROR%"))
// Counts all the errors
errors.count()
// Counts errors mentioning MySQL
errors.filter(col("line").like("%MySQL%")).count()
// Fetches the MySQL errors as an array of Strings
errors.filter(col("line").like("%MySQL%")).collect()

3. Java 버젼

Simple Data Operations

1. Python 버젼

# Creates a DataFrame based on a table named "people"
# stored in a MySQL database
url = \
    "jdbc:mysql://yourIP:yourPort/test?user=yourUsername;password=yourPassword"
df = sqlContext \
    .read \
    .format("jdbc") \
    .option("url", url) \
    .option("dbtable", "people") \
    .load()
# Looks the schema of this DataFrame
df.printSchema()
# Counts people by age
countsByAge = df.groupBy("age").count()
countsByAge.show()
# Save countsByAge to S3 in the JSON format.
countsByAge.write.format("json").save("s3a://...")

2. Scala 버젼

3. Java 버젼 

Machine Learning Example

Prediction with Learning Example

1. Python 버젼

2. Scala 버젼

3. Java 버젼

필수사항 : 

{
  "name": "test-package",
  "version": "1.0.0"
}

package.json 생성하기

// 대화형식으로 물어보면서 package.json 파일을 생성한다.
npm init

KIDOui-iMac:~ KIDO$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (KIDO) test-package
version: (1.0.0)
description: my_test_package
git repository:
author: test_author
license: (ISC) ISC
About to write to /Users/KIDO/package.json:
{
  "name": "test-package",
  "version": "1.0.0",
  "description": "my_test_package",
  "main": "index.js",
  "dependencies": {
    "connect": "^3.4.1"
  },
  "devDependencies": {},
  "scripts": {
    "test": "echo \"Error: no test specified\"&& exit 1"
  },
  "keywords": [],
  "author": "test_author",
  "license": "ISC"
}

Is this ok? (yes) yes 

// 디폴트 값을 이용하여 package.json파일을 생성한다.
npm --yes
npm -y

KIDOui-iMac:~ KIDO$ cat package.json
{
  "name": "KIDO",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "dependencies": {
    "connect": "^3.4.1"
  },
  "devDependencies": {},
  "scripts": {
    "test": "echo \"Error: no test specified\"&& exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
} 

필드 설명 : 

> npm set init.author.email "wombat@npmjs.com"
> npm set init.author.name "ag_dubs"
> npm set init.license "MIT"

패키지 의존성 지정하기. 

수동으로 의존성 지정하기. 

{
  "name": "my_package",
  "version": "1.0.0",
  "dependencies": {
    "my_dep": "^1.0.0"
  },
  "devDependencies" : {
    "my_test_framework": "^3.1.0"
  }
}

자동으로 의존성 지정하기.

npm install <package_name> --save

npm install <package_name> --save-dev

NPM 

npm install --save handlebars

require('handlebars');

require('handlebars/runtime');

Bower

bower install --save handlebars 

Manual Download

CDN

• cdnjs
• jsDelivr. Advanced usage, such as version aliasing & concocting, is available.

Getting Started handlebars

Getting Started

<div class="entry">
  <h1>{{title}}</h1>
  <div class="body">
    {{body}}
  </div>
</div>

<script id="entry-template" type="text/x-handlebars-template">
  <div class="entry">
    <h1>{{title}}</h1>
    <div class="body">
      {{body}}
    </div>
  </div>
</script>

var source   = $("#entry-template").html();
var template = Handlebars.compile(source); 

var context = {title: "My New Post", body: "This is my first post!"};
var html    = template(context);

<div class="entry">
  <h1>My New Post</h1>
  <div class="body">
    This is my first post!
  </div>
</div>

HTML Escaping

<div class="entry">
  <h1>{{title}}</h1>
  <div class="body">
    {{{body}}}
  </div>
</div>

{
  title: "All about <p> Tags",
  body: "<p>This is a post about &lt;p&gt; tags</p>"
}

<div class="entry">
  <h1>All About &lt;p&gt; Tags</h1>
  <div class="body">
    <p>This is a post about &lt;p&gt; tags</p>
  </div>
</div>

Handlebars.registerHelper('link', function(text, url) {
  text = Handlebars.Utils.escapeExpression(text);
  url  = Handlebars.Utils.escapeExpression(url);
  var result = '<a href="' + url + '">' + text + '</a>';
  return new Handlebars.SafeString(result);
});

Block Expressions

{{#list people}}{{firstName}} {{lastName}}{{/list}}

Handlebars.registerHelper('list', function(items, options) {
  var out = "<ul>";
  for(var i=0, l=items.length; i<l; i++) {
    out = out + "<li>" + options.fn(items[i]) + "</li>";
  }
  return out + "</ul>";
});

<ul>
  <li>Yehuda Katz</li>
  <li>Carl Lerche</li>
  <li>Alan Johnson</li>
</ul> 

Handlebars Paths

<p>{{name}}</p>

<div class="entry">
  <h1>{{title}}</h1>
  <h2>By {{author.name}}</h2>
  <div class="body">
    {{body}}
  </div>
</div>

var context = {
  title: "My First Blog Post!",
  author: {
    id: 47,
    name: "Yehuda Katz"
  },
  body: "My first post. Wheeeee!"
};

<h1>Comments</h1>
<div id="comments">
  {{#each comments}}
  <h2><a href="/posts/{{../permalink}}#{{id}}">{{title}}</a></h2>
  <div>{{body}}</div>
  {{/each}}
</div>

{{permalink}}
{{#each comments}}
  {{../permalink}}
  {{#if title}}
    {{../permalink}}
  {{/if}}
{{/each}}

<p>{{./name}} or {{this/name}} or {{this.name}}</p>

Template comments with {{!-- --}} or {{! }}.

<div class="entry">
  {{! This comment will not be in the output }}
  <!-- This comment will be in the output -->
</div>

Helpers

<div class="post">
  <h1>By {{fullName author}}</h1>
  <div class="body">{{body}}</div>
  <h1>Comments</h1>
  {{#each comments}}
  <h2>By {{fullName author}}</h2>
  <div class="body">{{body}}</div>
  {{/each}}
</div>

var context = {
  author: {firstName: "Alan", lastName: "Johnson"},
  body: "I Love Handlebars",
  comments: [{
    author: {firstName: "Yehuda", lastName: "Katz"},
    body: "Me too!"
  }]
};
Handlebars.registerHelper('fullName', function(person) {
  return person.firstName + "" + person.lastName;
});

<div class="post">
  <h1>By Alan Johnson</h1>
  <div class="body">I Love Handlebars</div>
  <h1>Comments</h1>
  <h2>By Yehuda Katz</h2>
  <div class="body">Me Too!</div>
</div>

<ul>
  {{#each items}}
  <li>{{agree_button}}</li>
  {{/each}}
</ul>

var context = {
  items: [
    {name: "Handlebars", emotion: "love"},
    {name: "Mustache", emotion: "enjoy"},
    {name: "Ember", emotion: "want to learn"}
  ]
};
Handlebars.registerHelper('agree_button', function() {
  var emotion = Handlebars.escapeExpression(this.emotion),
      name = Handlebars.escapeExpression(this.name);
  return new Handlebars.SafeString(
    "<button>I agree. I " + emotion + "" + name + "</button>"
  );
});

<ul>
  <li><button>I agree. I love Handlebars</button></li>
  <li><button>I agree. I enjoy Mustache</button></li>
  <li><button>I agree. I want to learn Ember</button></li>
</ul> 

Literals

{{agree_button "My Text" class="my-class" visible=true counter=4}}

Partials

<div class="post">
  {{> userMessage tagName="h1" }}
  <h1>Comments</h1>
  {{#each comments}}
    {{> userMessage tagName="h2" }}
  {{/each}}
</div>

Handlebars.registerPartial('userMessage',
    '<{{tagName}}>By {{author.firstName}} {{author.lastName}}</{{tagName}}>'
    + '<div class="body">{{body}}</div>');
var context = {
  author: {firstName: "Alan", lastName: "Johnson"},
  body: "I Love Handlebars",
  comments: [{
    author: {firstName: "Yehuda", lastName: "Katz"},
    body: "Me too!"
  }]
};

<div class="post">
  <h1>By Alan Johnson</h1>
  <div class="body">I Love Handlebars</div>
  <h1>Comments</h1>
  <h2>By Yehuda Katz</h2>
  <div class="body">Me Too!</div>
</div>

1. handlebars 설치

기본사용법 : 

<h1>{{title}}</h1>

<h1>{{article.title}}</h1>

<h1>{{article/title}}</h1>

{{#each articles.[10].[#comments]}}
    <h1>{{subject}}</h1>
    <div>
        {{body}}
    </div>
{{/each}}

articles[10]['#comments']

{{{foo}}}

Helpers

Handlebars.registerHelper('link', function(object) {
    var url = Handlebars.escapeExpression(object.url),
        text = Handlebars.escapeExpression(object.text);
    return new Handlebars.SafeString(
        "<a href='" + url +"'>" + text + "</a>"
    );
 });

{{{lilnk "See more..."" story.url}}

Handlebars.registerHelper('link', function(text, url) {
    url = Handlebars.escapeExpression(url);
    text = Handlebars.escapeExpression(text);
    return new Handlebars.SafeString(
        "<a href='" + url + '''>" + text + "</a>"
    );
});

{{{link story.text story.url}}}

{{{link "See more..." href-story.url class="story"}}}

Handlebars.registerHelper('link', function(text, options) {
    var attrs = [];
    for(var prop in options.hash) {
        attrs.push(
            Handlebars.escapeExpression(prod) + '="' + Handlebars.escapeExpression(options.hash[prop]) + '"');
    }
 
    return new Handlebars.SafeString (
        "<a " + attrs.join("") + ">" + Handlebars.escapeExpression(text) + "</a>"
    );
});

Subexpressions

{{outer-helper (inner-helper 'abc') 'def' }}

Whitespace Control

{{#each nav ~}}
    <a href="{{ur}}">
        {{~#if test}}
            {{~title}}
        {{~^~}}
            Empty
        {{~/if~}}
    </a>
{{~/each}}

<a href="foo">bar</a><a href="bar">Empty</a>

{{#each nav}}
    <a href="{{url}}">
        {{#if test}}
            {{title}}
        {{^}}
            Empty
        {{/if}}
    </a>
{{~/each}}

<a href="foo">
    bar
</a>
<a href="bar">
    Empty
</a>

Escaping

\{{escaped}}
{{{{raw}}}}
    {{escaped}}
{{{{/raw}}}}

Getting Started

$ brew install node

$ npm install handlebars -g

$handlebars <input> -f <output>

Handlebars.templates.person(context, options);

<script src="/libs/handlebars.runtime.js"></script>

Optimizations

handlebars <input> -f <output> - each -k if -k unless

Usage

Basic Blocks

Handlebars.registerHelper('noop', function(options) {
    return options.fn(this);
});

{{./noop}}

Basic block Variation

<div class="entry">
    <h1>{{title}}</h1>
    <div class="body">
        {{#bold}}{{body}}{{/bold}}
    </div>
</div>

Handlebars.registerHelper('bold', function(options) {
    return new Handlebars.SafeString(
        '<div class="mybole">'
        + options.fn(this)
        + '</div>');
});

The with helper

<div class="entry">
    <h1>{{title}}</h1>
    {{#with story}}
        <div class="intro">{{{intro}}}</div>
        <div class="body">{{{body}}}</div>
    {{/with}}
</div>

{
    title: "First Post",
    story: {
        intro: "Before the jump"
        body: "After the jump"
    }
}

handlebars.registerHelper('with', function(context, options) {
    return options.fn(context);
});

Simple Iterators

<div class="entry">
    <h1>{{title}}</h1>
    {{#with story}}
        <div class="intro">{{{intro}}}</div>
        <div class="body">{{{body}}}</div>
    {{/with}}
</div>
<div class="comments">
    {{#each comments}}
        <div class="comment">
            <h2>{{subject}}</h2>
            {{{body}}}
        </div>
    {{/each}}
</div>

Handlebars.registerhelper('each', function(context, options) {
    var ret = '';
    for (var i=0, j=context.length; i<j; i++) {
        ret = ret + options.fn(context[i]);
    }
    return ret;
});

{{#list nav}}
    <a href="{{url}}">{{title}}</a>
{{/list}}

{
    nav: [
        {url: "http://www.yehudakatz.com", title: "Katz Got Your Tongue" },
        {url: "http://www.sproutcore.com/block", title: "SproutCore Blog" },
    ]
}

Handlebars.registerHelper('list', function(context, options) {
    var ret = "<ul>";
    for (var i=0, j=context.length; i<j; i++) {
        ret = ret + "<li>" + options.fn(context[i]) + "</li>";
    }
    return ret + "</ul>";
});

Handlebars.registerHelper('list', function(context, options) {
    return "<ul>" + context.map(function(function(item) {
        return "<li>" + options.fn(item) + "</li>";
    }).join("\n") + "</ul>";
});

Conditionals

{{#if isActive}}
    <img src="start.gif" alt="Active">
{{/if}}

Handlebars.registerHelper('if', function(conditional, options) {
    if (conditional) {
        return options.fn(this);
    }
});

Basic Partials

Handlebars.registerPartial('myPartial', '{{name}}')

{{> myPartial }}

Dynamic Partials

{{> (whichPartial) }}

{{> (lookup . 'myVariable') }}

Partial Contexts 

{{> myPartial myOtherContext }} 

Partial Parameters

{{> myPartial parameter=value }}

{{> myPartial name=../name }}

Partial Blocks 

{{#> myPartial }}
    Failover content
{{/myPartial}}

{{#> layout }}
    My Content
{{/layout}}

Site Content
{{> @partial-block }}

Site Content
My Content

{{#each children as |child|}}
    {{#> childEntry}}
        {{child.value}}
    {{/childEntry}}
{{/each}}

{{#*inline "myPartial"}}
    MyContent
{{/inline}}
{{#each children}}
    {{> myPartial}}
{{/each}}

{{#> layout}}
    {{#*inline "nav"}}
        My Nav
    {{/inline}}
    {{#*inline "content"}}
        My Content
    {{/inline}}
{{/layout}}

<div class="nav">
    {{> nav}}
</div>
<div class="content">
    {{> content}}
</div>

The if block helper

<div class="entry">
    {{#if author}}
        <h1>{{firstName}} {{lastName}}</h1>
    {{/if}}
</div>

<div class="entry">
</div>

<div class="entry">
    {{#if author}}
        <h1>{{firstName}} {{lastName}}</h1>
    {{else}}
        <h1>Unknown Author</h1>
    {{/if}}
</div>

The unless block helper

<div class="entry">
    {{#unless license}}
    <h3 class="warning">WARNING: This entry does not have a license!</h3>
    {{/unless}
</div>

The each block helper

<ul class="people_list">
    {{#each people}}
        <li>{{this}}</li>
    {{/each}}
</ul>

{
    people: [
        "Yehuda Katz",
        "Alan Johnson",
        "Charles Jolley"
    ]
}

<ul class="people_list">
    <li>Yehuda Katz</li>
    <li>Alan Johnson</li>
    <li>Charles Jolley</li>
</ul>

{{#each paragraphs}}
    <p>{{this}}</p>
{{else}}
    <p class="empty">No content</p>
{{/each}}

{{#each object}}
    {{@key}}: {{this}}
{{/each}}

{{#each array as |value key|}}
    {{#each child as |childValue childKey|}}
        {{key}} - {{childKey}}. {{childValue}}
    {{/each}}
{{/each}}

The with Block Helper

var source = "<p>{{lastName}}, {{firstName}}</p>";
var template = Handlebars.compile(source);
template({firstName: "Alan", lastName: "Johnson"});

<p>Johnson, Alan</p>

<div class="entry">
    <h1>{{title}}</h1>
    {{#with author}}
        <h2>By {{firstName}} {{lastName}}</h2>
    {{/with}}
</div>

{
    title: "My first post!",
    author: {
        firstName: "Charles",
        lastName: "Jolley"
    }
}

<div class="entry">
    <h1>My first post!</h1>
    <h2>By Charles Jolley</h2>
</div>

<div class="entry">
    <h1>{{title}}</h1>
    {{#with author as |myAuthor|}}
        <h2>By {{myAuthor.firstName}} {{myAuthor.lastName}}</h2>
    {{/with}}
</div>

{{#with author}}
    <p>{{name}}</p>
{{else}}
    <p class="empty">No content</p>
{{/with}}

The lookup helper

{{#each bar}}
    {{lookup ../foo @index}}
{{/each}}

The log block helper

{{log "Look at me!"}}

{{log "This is logged" foo "And so is this"}}

{{log "Log!" level="error"}}

The blockHelperMissing helper

{{#foo}}{{/foo}}

Handlebars.registerHelper('blockHelperMissing', function(context, options) {
    throw new Handlebars.Exception('Only if or each is allowed');
});

The helperMissing helper

{{foo}}
{{foo bar}}
{{#foo}}{{/foo}}

Handlebars.registerHelper('helperMissing', function(/* [args, ] options */) {
    var options = arguments[arguments.length - 1];
    throws new Handlebars.Exception('Unknown field: ' + options.name);
});

Tabata의 역사 : 

• 매주 5일 운동, 6주간 수행
• 평이한 강도의 운동
• 매 운동은 1시간 수행

• 매주 4일 운동, 6주간 수행
• 고강도 운동
• 매 운동은 4분동안 수행하며 20초 운동 10초 휴식을 반복.

• 에어로빅 시스템 향상 (cardiovascular 심폐)
• 비 에어로빅 시스템 (muscle 근육)은 작거나 변화 없음

• 첫번재 그룹보다 더 향상된 에어로빅 시스템
• 비 에어로빅 시스템 28% 향상

Tabata 프로그램

• 20초동안 고강도로 운동
• 10분 휴식
• 8라운드 반복

1. Push-ups (4분)
2. Bodyweight Squats (4분)
3. Burpeets (4분)
4. Mountain Climbers (4분)

Tabata Workouts and Exercises 샘플 : 

• 30-Minute Bodyweight Tabata Workout
• 20-Minute Tabata Core Workout
• 30-Minute Kettlebell Tabata Workout
• 30-Minute Medicine Ball Tabata Workout
• 11 Butt Kicking Tabata Exercises
• Tabata for Beginners

Base

from : http://handlebarsjs.com/reference.html

Handlebars.compile(template, options)

var template = Handlebars.compile('{{foo}}');
template({});

• template :를 수행할때 어떻게 수행할지에 대한 다양한 옵션들이 다음과 같이 있다. 
• data : false로 설정하면 @data 트래킹을 disable한다. 
• compat : true로 설정하면 recursive 필드 룩업을 수행한다. 
• knownHelpers : Hash로 헬퍼의 리스트를 포함하고 있다. 이는 템플릿이 실행되는 타임에 존재하는지 파악하게 된다. 이때 이 값을 전달하면 옵티마이즈된 결과로 컴파일러가 컴파일한다. 내부 헬퍼는 자동적으로 포함되어진다. 값을 false로 설정하는 것으로 제거 할 수 있다. 
• knownHelpersOnly : true로 설정하면 알려진 헬퍼의 리스트를 기반으로 최적화 한다. 
• noEscape : true로 설정하면 어떠한 내용도 escape하지 않는다. 
• strict : strict모드로 실행한다. 이 모드에서는 템플릿은 유실된 필드에 대해서 무시하지 않고 오류를 던진다. 이것은 {{^foo}}{{/foo}} 와 같은 inverse오퍼레이션을 disable하는 사이드 이펙트가 있다. 그렇지 않으면 소스 객체내에서 명시적으로 포함된다. 
• assumeObjects : path를 트래버싱 할때 체크된 객체를 제거한다. 이는 strict모드의 서브셋이며, 데이터 입력들이 안전하다고 판단되면 옵티마이즈된 템플릿을 생성한다. 
• preventIndent : 기본적으로 인덴트된 partial콜을 수행한다. 이는  pre태그를 patial이 작성할때 기대하지 않는 행동을 하는 것을 막아준다. 이 옵션을 true로 지정하면 auto-indent 기능이 disable된다. 
• ignoreStandalone : true로 지정하면 standalone태그를 제거하는 작업을 disable하게 한다. block과 partial에 설정하면 이는 해당 라인에서 공백을 제거하지 않는다. 
• explicitPartialContext : partial을 위한 컨텍스트를 disable한다. enabled된 경우 partial은 컨텍스트 값이 전달되지 않으며 비어있는 객체로 실행이 된다. 

Handlebars.precompile(template, options) 

var templateSpec = Handlebars.precompile('{{foo}}');

• srcName : 입력 파일을 위한 소스 맵을 생성하기 위해 전달한다. 이 방법으로 수행이 되면 반환되는 구조는 {code, map}으로 code에는 템플릿 정의가, map에는 소스 맵이 들어간다. 
• destName : 선택적인 파라미터로 srcName과 결합된다. 이는 소스 맵을 생성할때 목적지 파일 이름을 제공한다. 

Handlebars.template(templateSpec)

var template = Handlebars.template(templateSpec);
template({});

Handlebars.registerPartial(name, partial)

Handlebars.registerPartial('foo', partial);

Handlebars.registerPartial({
    foo: partial,
    bar: partial
});

Handlebars.unregisterpartial(name)

Handlebars.unregisterPartial('foo');

Handlebars.registerHelper(name, helper)

Handlebars.registerHelper('foo', function() {
});

Handlebars.registerHelper({
    foo: function() {
    },
    bar: function() {
    }
});

Handlebars.unregisterHelper(name)

Handlebars.unregisterHelper('foo');

Handlebars.registerDecorator(name, helper)

Handlebars.registerDecorator('foo', function() {
});

Handlebars.registerDecorator({
    foo: function() {
    },
    bar: function() {
    }
});

Handlebars.unregisterDecorator(name)

Handlebars.unregisterDecorator('foo');

Handlebars.SafeString(string)

new Handlebars.SafeString('<div>HTML Content!</div>')

Handlebars.escapeExpression(string)

 Handlebars.Utils.escapeExpression(string)

Handlebars.createFrame(data)

if (options.data) {
    var data = Handlebars.createFrame(options.data);
    data.foo = 'bar';
    options.data = data;
}

Handlebars.create()

var OtherHandlebars = Handlebars.create();

Handlebars.noConflict()

var myHandlebars = Handlebars.noConflict();

Handlebars.log(level, message)

Utilities

Handlebars.Utils.isEmpty(value)

Handlebars.Utils.isEmpty(value)

• 길이가 0인 배열
• false성격의 값이나 0

Handlebars.Utils.extend(obj, value)

Handlebars.Utils.extend(foo, {bar: true})

Handlebars.Utils.toString(obj)

Handlebars.Utils.isArray(obj)

Handlebars.Utils.isFunction(obj)

@data Variable

@root

{{#each array}}
    {{@root.foo}}
{{/each}}

@first

{{#each array}}
    {{#if @first}}
        First!
    {{/if}}
{{/each}}

@index

{{#each array}}
    {{@index}}
{{/each}}

@key

{{#each array}}
    {{@key}}
{{/each}}

@last

{{#each array}}
    {{#if @last}}
        Last :(
    {{/if}}
{{/each}}

@level

template({}, {data: {level: Handlebars.logger.WARN}})

• Handlebars.logger.DEBUG
• Handlebars.logger.INFO
• Handlebars.logger.WARN
• Handlebars.logger.ERROR

Install Babel Syntext Package on Sublime Text

• Sublime React
• Babel Sublime

Sublime Text에서 패키지 Controller 설치하기. 

import urllib.request,os,hashlib; h = '2915d1851351e5ee549c20394736b442' + '8bc59f460fa1548d1514676163dafc88'; pf = 'Package Control.sublime-package'; ipp = sublime.installed_packages_path(); urllib.request.install_opener( urllib.request.build_opener( urllib.request.ProxyHandler()) ); by = urllib.request.urlopen( 'http://packagecontrol.io/' + pf.replace('', '%20')).read(); dh = hashlib.sha256(by).hexdigest(); print('Error validating download (got %s instead of %s), please try manual install' % (dh, h)) if dh != h else open(os.path.join( ipp, pf), 'wb' ).write(by)

import urllib2,os,hashlib; h = '2915d1851351e5ee549c20394736b442' + '8bc59f460fa1548d1514676163dafc88'; pf = 'Package Control.sublime-package'; ipp = sublime.installed_packages_path(); os.makedirs( ipp ) if not os.path.exists(ipp) else None; urllib2.install_opener( urllib2.build_opener( urllib2.ProxyHandler()) ); by = urllib2.urlopen( 'http://packagecontrol.io/' + pf.replace('', '%20')).read(); dh = hashlib.sha256(by).hexdigest(); open( os.path.join( ipp, pf), 'wb' ).write(by) if dh == h else None; print('Error validating download (got %s instead of %s), please try manual install' % (dh, h) if dh != h else 'Please restart Sublime Text to finish installation')

Babel Sublime 설치하기. 

InttlliJ 정적 Import 설정 

org.hamcrest.Matchers
org.hamcrest.CoreMatchers
org.junit
org.junit.Assert
org.junit.Assume
org.junit.matchers.JUnitMatchers

설정방법 : 

Static Import

double r = Math.cos(Math.PI * theta);

import static java.lang.Math.PI;

import static java.lang.Math.*;

double r = cos(PI * theta);