24 Group Step
有时，所运行的实际路径或当前运行位置不是计算的最终输出，而是遍历的一些其他表示。group()步骤（map / sideEffect）是根据对象的某些功能组织对象的一个方法。
比如：
gremlin> g.V().group().by(label)
==>[software:[v[3],v[5]],person:[v[1],v[2],v[4],v[6]]]
gremlin> g.V().group().by(label).by('name')
==>[software:[lop,ripple],person:[marko,vadas,josh,peter]]
gremlin> g.V().group().by(label).by(count())
==>[software:2,person:4]
25 GroupCount Step
groupCount()分组统计，是（map/sideEffect）类型的步骤。
gremlin> g.V().hasLabel('person').values('age').groupCount() //
==>[32:1,35:1,27:1,29:1]
gremlin> g.V().hasLabel('person').groupCount().by('age') //
==>[32:1,35:1,27:1,29:1]
注意不能使用以下方式：
~~gremlin> g.V().hasLabel('person').by('age').groupCount()~~
26 Has Step
可以使用has()步骤（filter）根据其属性来过滤顶点，边和顶点属性。 它有很多变体，包括：
has(key,value)
has(label, key, value)
has(key,predicate)
hasLabel(labels…)
hasId(ids…)
hasKey(keys…)
hasValue(values…)
has(key)
hasNot(key)
has(key, traversal)
27 Id Step
id()步骤（map）取一个Element并从中提取它的标识符。
gremlin> g.V().id() //所有顶底的ID
gremlin> g.V(1).outE().id() // 节点1发出的所有边的ID
gremlin> g.V(1).properties().id() //节点1的所有属性的ID
28 Inject Step
inject()步骤（sideEffect）使得可以将对象任意插入到遍历流中。
gremlin> g.V(4).out().values('name')
==>ripple
==>lop
gremlin> g.V(4).out().values('name').inject('daniel')
==>daniel
==>ripple
==>lop
gremlin> g.V(4).out().values('name')
==>ripple
==>lop
29 Is Step
可以使用is()步骤（filter）来过滤标量值。
gremlin> g.V().values('age').is(32)
==>32
gremlin> g.V().values('age').is(lte(30))
==>29
==>27
30 Label Step
label()步骤（map）取一个Element并从中提取它的标签。
gremlin> g.V().label() //所有顶点的标签
gremlin> g.V(1).outE().label() //节点1出发的所有边的标签
gremlin> g.V(1).properties().label() //节点1的所有属性的标签
31 Key Step
key()步骤（map）取一个Property并从中提取该键。
gremlin> g.V(1).properties().key() //节点1的所有属性的key
gremlin> g.V(1).properties().properties().key() //节点1的所有元属性的key
32 Limit Step
limit() 步骤类似于range()步骤下限范围设置为0的情况。
gremlin> g.V().limit(2)
==>v[1]
==>v[2]
gremlin> g.V().range(0, 2)
==>v[1]
==>v[2]
limit()也可以应用于 ，在这种情况下，它会对传入的集合进行操作。
gremlin> g.V().valueMap().limit(local, 1) //对集合的操作
==>[name:[marko]]
==>[name:[vadas]]
==>[name:[lop]]
==>[name:[josh]]
==>[name:[ripple]]
==>[name:[peter]]
gremlin> g.V().valueMap().limit(1) //只取一个值
==>[name:[marko],age:[29]]
Note
注意，上述 local是静态引入的Scope.local。
33 Local Step
GraphTraversal对连续的对象流进行操作。在许多情况下，重要的是在该流中的单个元素上进行操作。要做这样的对象局部遍历计算，local()步骤（branch）因此而生。
比较以下遍历：
gremlin> g.V().as('person').
properties('location').order().by('startTime',incr).limit(2).value().as('location').
select('person','location').by('name').by()
==>[person:daniel,location:spremberg]
==>[person:stephen,location:centreville]
gremlin> g.V().as('person').
local(properties('location').order().by('startTime',incr).limit(2)).value().as('location').
select('person','location').by('name').by()
==>[person:marko,location:san diego]
==>[person:marko,location:santa cruz]
==>[person:stephen,location:centreville]
==>[person:stephen,location:dulles]
==>[person:matthias,location:bremen]
==>[person:matthias,location:baltimore]
==>[person:daniel,location:spremberg]
==>[person:daniel,location:kaiserslautern]
上面的遍历，根据最具历史地理位置的开始时间，获取前两个人及其各自的位置。
下面的遍历，对于每一个人来说，都有两个历史最悠久的地方。
上述遍历使用Crew图，该图结构如下所示：
local()与flatMap()
local()步骤在功能上与flatMap()步骤非常相似，通常可能会使其混淆。local()通过内部遍历传播遍历器，而不会拆分/克隆它。因此，它在本地处理“全局遍历”。
gremlin> g.V().both().barrier().flatMap(groupCount().by("name"))
==>[lop:1]
==>[lop:1]
==>[lop:1]
==>[vadas:1]
==>[josh:1]
==>[josh:1]
==>[josh:1]
==>[marko:1]
==>[marko:1]
==>[marko:1]
==>[peter:1]
==>[ripple:1]
gremlin> g.V().both().barrier().local(groupCount().by("name"))
==>[lop:3]
==>[vadas:1]
==>[josh:3]
==>[marko:3]
==>[peter:1]
==>[ripple:1]
34 Loops Step
loops()步骤（map）提取Traverser经过当前循环的次数。
35 Match Step
match()步骤（map）基于模式匹配的概念提供了一种更具声明性的图形查询形式。
"Who created a project named 'lop' that was also created by someone who is 29 years old? Return the two creators."
gremlin> g.V().match(
__.as('creators').out('created').has('name', 'lop').as('projects'), //1
__.as('projects').in('created').has('age', 29).as('cocreators')). //2
select('creators','cocreators').by('name') //3
==>[creators:marko,cocreators:marko]
==>[creators:josh,cocreators:marko]
==>[creators:peter,cocreators:marko]
1: 找到创建了其他节点的节点，并将这些节点标记为“creators”，然后找出由“creators”创建的名为“lop”的节点，并将这些顶点匹配为“projects”。
2: 从这些“projects”顶点找出创建它们的节点，并过滤出其中年龄为29岁的节点，并将其记作“cocreators”。
3: 返回“creators”和“cocreators”的名称。
使用where
Match通常与select()和where()（在此呈现）结合使用。 where()步骤允许用户进一步限制由match()提供的结果集。
如使用where去掉creators和cocreators相同的元素：
g.V().match(
__.as('creators').out('created').has('name', 'lop').as('projects'),
__.as('projects').in('created').has('age', 29).as('cocreators')).
where('creators',neq('cocreators')).
select('creators','cocreators').by('name')
36 Max Step
max()步骤（map）对数字流进行操作，并确定流中最大的数字。
gremlin> g.V().values('age').max()
==>35
37 Mean Step
mean() 步骤（map）对数字流进行操作，并确定这些数字的平均值。
gremlin> g.V().values('age').mean()
==>30.75
38 Min Step
min()步骤（map）对数字流进行操作，并确定流中最小的数字。
gremlin> g.V().values('age').min()
==>27
39 Not Step
取反操作，属于filter步骤。
示例：
gremlin> g.V().not(hasLabel('person')).valueMap()
==>[name:[lop],lang:[java]]
==>[name:[ripple],lang:[java]]
40 Option Step
branch() or choose()的选项。参考相应的遍历步骤。
41 Optional Step
optional()步骤（map）在遍历产生一个结果时返回相应结果，否则返回调用元素。
如下：
gremlin> g.V(1).optional(out('knows')) //1
==>v[2]
==>v[4]
gremlin> g.V(2).optional(out('knows')) //2
==>v[2]
1：当节点1具有向外的边“knows”，则返回向外的边指向的元素；
2：当节点2没有向外的边“knows”，则 返回节点2本身；
42 Or Step
or()步骤(filter)确保至少一个所提供的遍历产生结果。
比如，只要符合具有发出“created”边 或者 有进入“created”边且进入边的总数大于1 这两个条件之一的遍历结果就可以返回：
gremlin> g.V().or(
__.outE('created'), //有发出“created”边
__.inE('created').count().is(gt(1))). //有进入“created”边且进入边的总数大于1
values('name')
==>marko //符合第1个条件
==>lop //符合第2个条件
==>josh //符合第1个条件
==>peter //符合第1个条件
需要注意的是，若遍历对象流符合or()步骤中的多个条件，那么结果并不会重复。如下：
gremlin> g.V().or(
__.outE('created'),
__.hasLabel('person')).
values('name')
==>marko
==>vadas
==>josh
==>peter
都不符合提供的条件时，不返回结果。如下：
gremlin> g.V().or(
__.outE('created-err'),
__.inE('created-err').count().is(gt(1))).
values('name')
43 Order Step
当遍历流的对象需要排序时，可以利用order()步骤（map）。
gremlin> g.V().values('name') //不指定排序
==>marko
==>vadas
==>lop
==>josh
==>ripple
==>peter
gremlin> g.V().values('name').order() //默认升序
==>josh
==>lop
==>marko
==>peter
==>ripple
==>vadas
gremlin> g.V().values('name').order().by(decr) //声明为降序
==>vadas
==>ripple
==>peter
==>marko
==>lop
==>josh
gremlin> g.V().values('name').order().by(shuffle) //乱序
==>ripple
==>marko
==>peter
==>vadas
==>lop
==>josh
gremlin> g.V().values('name').order().by(shuffle) //乱序
==>josh
==>ripple
==>vadas
==>lop
==>peter
==>marko
Note
shuffle来自静态引入的Order.shuffle。
可在by()中指定排序的元素，如：
gremlin> g.V().order().by('name',decr).values('name')
==>vadas
==>ripple
==>peter
==>marko
==>lop
==>josh
44 PageRank Step
pageRank()步骤（map/sideEffect）使用PageRankVertexProgram计算PageRank。
如下，计算Modern图中的各节点的PageRank值：
gremlin> graph = TinkerFactory.createModern()
==>tinkergraph[vertices:6 edges:6]
gremlin> g = graph.traversal().withComputer()
==>graphtraversalsource[tinkergraph[vertices:6 edges:6], graphcomputer]
gremlin> g.V().pageRank().by('pageRank').valueMap('name','pageRank')
==>[name:[josh],pageRank:[0.19250000000000003]]
==>[name:[lop],pageRank:[0.4018125]]
==>[name:[vadas],pageRank:[0.19250000000000003]]
==>[name:[marko],pageRank:[0.15000000000000002]]
==>[name:[ripple],pageRank:[0.23181250000000003]]
==>[name:[peter],pageRank:[0.15000000000000002]]
Note:
pageRank()步骤是一个VertexComputing步骤，因此只能用于支持GraphComputer（OLAP）的图形。
45 Path Step
path()步骤用来（map）检查遍历器的历史路径。
如发现
gremlin> g.V().out().out().values('name')
==>ripple
==>lop
gremlin> g.V().out().out().values('name').path()
==>[v[1],v[4],v[5],ripple]
==>[v[1],v[4],v[3],lop]
如果路径中需要边缘，那么请确保明确地遍历这些边。
gremlin> g.V().outE().inV().outE().inV().path()
==>[v[1],e[8][1-knows->4],v[4],e[10][4-created->5],v[5]]
==>[v[1],e[8][1-knows->4],v[4],e[11][4-created->3],v[3]]
Note
注意out()与outV()区别。g.V().out()直接指向“箭头指向的节点”，而outV()则是“发出箭头的节点”。如：
gremlin> g.V(1).outE().outV().values('name')
==>marko
==>marko
==>marko
gremlin> g.V(1).out().out().values('name')
==>lop
==>ripple
//以下语法效果是相等的
gremlin> g.V(1).out('knows').values('name')
==>vadas
==>josh
gremlin> g.V(1).outE('knows').inV().values('name')
==>josh
==>vadas
46 PeerPressure Step
peerPressure()步骤（map/sideEffect）使用PeerPressureVertexProgram对顶点进行聚类。
gremlin> g.V().peerPressure().by('cluster').group().by('cluster').by('name')
==>[1:[marko,vadas,lop,josh,ripple],6:[peter]]
Note
peerPressure()步骤是一个VertexComputing步骤，因此只能用于支持GraphComputer（OLAP）的图。
47 Profile Step
profile()步骤（sideEffect）允许开发人员对其遍历进行剖析，以确定统计信息，如步骤运行时间，计数等。
gremlin> g.V().out().out().has('name','lop').values('name').profile()
==>Traversal Metrics
Step Count Traversers Time (ms) % Dur
=============================================================================================================
GraphStep(vertex,[]) 6 6 0.057 59.90
VertexStep(OUT,vertex) 6 4 0.019 20.88
VertexStep(OUT,vertex) 2 2 0.009 9.48
HasStep([name.eq(lop)]) 1 1 0.006 6.75
PropertiesStep([name],value) 1 1 0.002 2.99
>TOTAL - - 0.095 -
该步骤生成包含以下信息的TraversalMetrics sideEffect对象：
- 步骤（Step）：遍历内的一个步骤。
- 计数（Count）：通过步骤的表示的遍历器的数量。
- 遍历（Traversers）：遍历步骤的遍历数。
- 时间（Time/ms）：步骤主动执行其行为的总时间。
- ％Dur：在步骤中花费的总时间的百分比。
当第一次遍历加入条件‘knows’，情况就不相同，注意Count与Traversers的值：
gremlin> g.V().out('knows').out().has('name','lop').values('name').profile()
==>Traversal Metrics
Step Count Traversers Time (ms) % Dur
=============================================================================================================
GraphStep(vertex,[]) 6 6 0.024 42.90
VertexStep(OUT,[knows],vertex) 2 2 0.015 27.27
VertexStep(OUT,vertex) 2 2 0.013 24.46
HasStep([name.eq(lop)]) 1 1 0.001 2.95
PropertiesStep([name],value) 1 1 0.001 2.42
>TOTAL - - 0.056 -
注意Count与Traversers的区别：
- 遍历器可以合并，因此当两个遍历器“相同”时，它们可以聚合成单个遍历器。
- 新的遍历器具有Traverser.bulk()，它是两个遍历器的总和。
- Count表示所有Traverser.bulk()结果的总和，因此展现的是“呈现（represented）”（非枚举（not enumerated））遍历器的数量。
- Traversers总是小于Count。
Note
Count与Traversers的区别需要更多的了解。