Groovy

nodemon安装

npm@6.12.0 /usr/local/node-v12.13.0-x64/lib/node_modules/npm
hairongchen@192 ~ % npm i -g nodemon
/usr/local/node-v12.13.0-x64/bin/nodemon -> /usr/local/node-v12.13.0-x64/lib/node_modules/nodemon/bin/nodemon.js
+ nodemon@2.0.20

nodemon exec: nodemon category/*.groovy
nodemon src/jenkins.groovy

# .bashrc
# mysql
PATH=$PATH:/usr/local/mysql/bin
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/mysql/lib
export LD_LIBRARY_PATH
# groovy
export PATH=$PATH:/usr/local/groovy-4.0.9/bin
#jdk
JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-19.0.2.jdk/Contents/Home
PATH=$JAVA_HOME/bin:$PATH

#node
export PATH=$PATH:/usr/local/node-v12.13.0-x64/bin 

hairongchen@192 groovy % source /Users/hairongchen/.bashrc 
hairongchen@192 groovy % nodemon src/jenkins.groovy 

//https://github.com/zhan9dong/groovy-learning/blob/master/SUMMARY.md

/*
groovyConsole groovy自带的IDE
groovyc 自带的编译工具,使用它可以拿到编译过后的java文件
groovysh 自带的shell类似于python,node这些脚本语言
groovydoc 自带的文档生成工具

*/
import org.apache.tools.ant.types.resources.selectors.Date

def a = "quator"
println("a=${a},b=$a")

//list
def list = [1, 2]
list.leftShift(3)
list.push(0)
list.add("abc")
//groovy中的<<可以对list数据类型的作用添加值，在数字类型时是位运算操作
list << "<<号";
list += "加上+="
println(list)
list.forEach({ println(it)})

//map
def map = [a: 2, b: new Date()];

//写入
map.put("aaaa","bbb")
println(map)
//写入
map.a = "a value"
//println(map)

//100.times {println("hi")}

//list = ['foo', 'bar']
//def newList = []
//list.collect(newList){
//    it.toUpperCase()
//}

//println newList

//IntelliJ IDEA 自动导入包 快捷方式,必须自己手动Alt+Enter设置

import groovy.transform.ToString
import groovy.transform.EqualsAndHashCode
import groovy.transform.TupleConstructor
import groovy.transform.Canonical

//Equals, Hashcode ,toString 更多的简化
//使用@ToString可以帮助用户提供运行时的数据信息
//@EqualsAndHashCode注解可以使equals相等的两个对象的hashCode也相等
// TupleConstructor 元构造器注解可以在传javabeans的数据时，免去传入key，而直接传value

//@TupleConstructor //@TupleConstructor 元构造器注解
@Canonical //@Canonical 注解是 前面三个注解的合体
public class Person {
    String name
    String address
}
def person = new Person("name":"richard","address":"my address")
println person

person1 = new Person("name":"richard","address":"my address")
person2 = new Person("name":"richard","address":"my address")
println person1.equals(person2)
println person1.hashCode() == person2.hashCode() && person2

//正则表达式
def email = "909253305@qq.com"
def isEmail = email ==~ /[\w.]+@[\w.]+/
println(isEmail);
email = 'mailto:adam@email.com'
def mr = email =~ /([\w.]+)@[\w.]+/;
if (mr.find()){
    println mr.group();
    println mr.group(1)//分组结果
}

//在默认情况下groovy会把空字符串，0,null地if条件语句下转成false，其它都转成true
//这个特性，有点像javascript语言

//map 语法糖
//groovy应许我们把一个变量当成map的key和value，这个跟es6有点像,
def foo = 1
def bar = 2
def map = [(foo): bar]
println map  //[1:2]

//属性操作，也可以用set,get（map-like）风格的， 如
class myWizards {
    def list = [];
    String toString() {
        "${list}"
    }
    def setAt(it) {
        list.add(it)
    }
}
def wiz = new myWizards();
wiz['at'] = 'richardgong';
println wiz;

//groovy curry(咖哩) 方法
//把一个多参数的函数转换为一个嵌套的单参数函数的过程，它要求使用部分参数时返回一个新的函数，
//在真正运行之前等待外部提供剩余参数，当参数准备完备后执行最初的多参数函数

//通过curry方法，可以预计一些参数值，如
//def concat = { x, y -> return x + y }
//def burn = concat.curry("burn");
//println burn('wood')

// Closure
def concat = { x, y -> return x + y }
def burn = concat.curry("burn")
// burn = {y -> return 'burn' + y}
def inate = concat.curry("inate")
// inate = { y-> return 'inate' + y}

// Closure 复合
def composition = { f, g, x -> return f(g(x)) }

def burninate = composition.curry(burn, inate)
// burninate = {x -> burn(inate(x)) }

def trogdor = burninate(' all the people')
// trogdor = burn(inate(' all the people')) ->
// rogdor = burn('inate all the people') ->
// rogdor = 'burninate all the people'

println "Trogdor: ${trogdor}" //Trogdor: burninate all the people


//def　multiply　=　{　x,　y　->　return　x　*　y }　　　
////　closure　
//def　triple　=　multiply.curry(3)　　　　　　　
////　triple　=　{　y　->　return　3　*　y　}　
//def　quadruple　=　multiply.curry(4)　
////　quadruple　=　{　y　->　return　4　*　y　}　
//def　composition　=　{　f,　g,　x　->　return　f(g(x))　}　
//def　twelveTimes　=　composition.curry(triple,　quadruple)　
//def　threeDozen　=　twelveTimes(3)　
//println　"threeDozen:　${threeDozen}"　　
////　threeDozen:　36　

//https://github.com/zhan9dong/groovy-learning/blob/master/SUMMARY.md

/*
groovyConsole groovy自带的IDE
groovyc 自带的编译工具,使用它可以拿到编译过后的java文件
groovysh 自带的shell类似于python,node这些脚本语言
groovydoc 自带的文档生成工具

*/
import org.apache.tools.ant.types.resources.selectors.Date

def a = "quator"
println("a=${a},b=$a")

//list
def list = [1, 2]
list.leftShift(3)
list.push(0)
list.add("abc")
//groovy中的<<可以对list数据类型的作用添加值，在数字类型时是位运算操作
list << "<<号";
list += "加上+="
println(list)
list.forEach({ println(it)})

//map
def map = [a: 2, b: new Date()];

//写入
map.put("aaaa","bbb")
println(map)
//写入
map.a = "a value"
//println(map)

//100.times {println("hi")}

//list = ['foo', 'bar']
//def newList = []
//list.collect(newList){
//    it.toUpperCase()
//}

//println newList

//https://github.com/zhan9dong/groovy-learning/blob/master/SUMMARY.md

/*
groovyConsole groovy自带的IDE
groovyc 自带的编译工具,使用它可以拿到编译过后的java文件
groovysh 自带的shell类似于python,node这些脚本语言
groovydoc 自带的文档生成工具

*/
import org.apache.tools.ant.types.resources.selectors.Date

def a = "quator"
println("a=${a},b=$a")

//list
def list = [1, 2]
list.leftShift(3)
list.push(0)
list.add("abc")
//groovy中的<<可以对list数据类型的作用添加值，在数字类型时是位运算操作
list << "<<号";
list += "加上+="
println(list)
list.forEach({ println(it)})

//map
def map = [a: 2, b: new Date()];

//写入
map.put("aaaa","bbb")
println(map)
//写入
map.a = "a value"
//println(map)

//100.times {println("hi")}

//list = ['foo', 'bar']
//def newList = []
//list.collect(newList){
//    it.toUpperCase()
//}

//println newList

String.metaClass.uppers = { -> toUpperCase() };
println "aaa".uppers()

Integer.metaClass.say = { -> "I am Interger" }
def i = new Integer(100);
println i.say()

def person;
String name = person?.getName();//先判断person是否为不为null,然后，再调用getName方法
println(name)

def lst = [13, 12, 15, 14];
def newlst = lst.sort();//默认排序
println newlst; //[12, 13, 14, 15]

//自定义处理
def newlist2 = lst.sort {
    a, b -> a - b ? -1 : 1
}
println newlist2; //   [15, 14, 13, 12]

lst = [13, 12, 15, 14,0,-1];
newlst = lst.findAll();//[13, 12, 15, 14, -1]
println newlst;//

def newlst2 = lst.findAll {
    value -> value < 13
};
println newlst2;//[12, 0, -1]

//collect 返回 一个新的list,它可以接收1个闭包作为参数，或者，无参数，
lst = [13, 12, 15, 14, 0, -1];
newlst = [];
newlst = lst.collect {
    it * it
}
println newlst //[169, 144, 225, 196, 0, 1]


//inject 一个累积的过程方法（有点像js的reduce），传入inject方法的'I'作为sum的初始值，在遍历collection的过程中，将处理结果("$sum $elem ")保存到sum中
def list = ["love", "you"]
def aa = list.inject('I') { sum, elem ->
    "$sum $elem "
}
println aa
println newlst //[169, 144, 225, 196, 0, 1]

//eachWithIndex 用法和each一样，唯一的不同是，eachWithIndex的传入的闭包，有两个参数，第一个是值，第二个是索引
list = ["a", "b", "c"]
list.eachWithIndex {
    String v, int index ->
        print (index)
        println(v)
}

//通配符 （*） 可以很方便用来访问集合对象所有属性
class Car {
    String make
    String model
}
def cars = [
        new Car(make: 'Peugeot', model: '508'),
        new Car(make: 'Renault', model: 'Clio')]
def makes = cars*.make
makes.each {
    println it
}

println((1..10)*.multiply(2))
println (['Denver', 'Cheyenne', 'Reno', 'Sacramento']*.toUpperCase())

def listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22]]
println(listOfMaps.a);// [11, 21]



listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22]]
println(listOfMaps.a);// [11, 21]


//GPath 像XPath一样，可以轻松的访问多层的集合对象
listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22], null]
println(listOfMaps*.a)
assert listOfMaps*.a == listOfMaps.collect { it?.a }
assert listOfMaps.a == [11,21]

//file
//读取一个文件内容
new File("book.txt").text = "richard zhisui";

//写入一个文件内容
//创建文件，并写入
println new File("book.txt").text

//也可以通过字节方式写入
//先手动创建data文件
byte[] data = new File("book.txt").bytes;
//把data的数据写入book2.txt
new File("book2.txt").bytes = data;
//创建 dragons.txt 写入内容后，并读取dragons.txt内容
new File('book2.txt').eachLine { line-> println(line)  }


//如果需要用InputStream,Reader,OutputStream,Writer这些对象进行操作。groovy也提供类似的方法
//输入流InputStream操作
Properties properties = new Properties()
File propertiesFile = new File('book2.txt')
propertiesFile.withInputStream {
    properties.load(it)
}
println properties.name
println properties.url

//Reader操作
def lineNo = 1
def line = 1;
new File("book.txt").withReader { reader ->
    while ((line = reader.readLine())!=null) {
        println "第${lineNo}行内容: ${line}"
        lineNo++
    }
}

//OutputStream操作 如：文件复制
def srcFile = new File("book.txt")
def targetFile = new File("book_bak.txt")
targetFile.withOutputStream {
    outputStream ->
        srcFile.withInputStream {
            inputStream ->
                outputStream << inputStream
        }
}

//写入Writer操作
//写入
new File('book.txt').withWriter('utf-8', {
    writer -> writer.writeLine 'Hello World'
});

//精简版
new File('mywithWriter.txt') << '''Into the ancient pond
    A frog jumps
    Water’s sound!'''


//极简的URLs操作.数据抓取
//URL url = new URL("https://www.baidu.com");
//InputStream input = (InputStream) url.getContent();
//ByteArrayOutputStream out = new ByteArrayOutputStream();
//
//int n = 0;
//byte[] arr = new byte[1024];
//while (-1 != (n = input.read(arr)))
//    out.write(arr, 0, n);
//System.out.println(new String(out.toByteArray()));

//史上最简易的抓取网页代码
//println "https://www.baidu.com".toURL().text;

// 范围运算，可以用在循环，switch,字符串截取中
//1..10 - 包含范围的示例
//1 .. <10 - 独占范围的示例
//'a'..'x' - 范围也可以由字符组成
//10..1 - 范围也可以按降序排列
//'x'..'a' - 范围也可以由字符组成并按降序排列。

(1..10).each { println(it)}
//for (def i in 1..100){
//    println(i)
//}
def text = 'learning gr，oovy'
println text[0..4]
println text[0..4, 8..-1]
list = ['hank', 'john', 'fred']
println list[0..1] //[hank, john]
(1..<5).each { println(it) }

//ConfigSlurper工具用于读取配置文件非常的方便
def config = new ConfigSlurper().parse('''
     app.date = new Date()
     app.age = 42
     app {
      name = "Test${this.age}"  
    }''')
properties = config.toProperties()
println(properties."app.date")
println(properties."app.age")
println(properties."app.name")

//Expando
//Expando类是Groovy语言中的一个相当有趣的类，
//它的作用类似于GroovyBean类，
//但比GroovyBean类更加灵活；
//同时，它还更类似于Map类，
//但也比Map类更加灵活
//1.
def expando = new Expando()
expando.name = { -> "abc" }
expando.say = { String s -> "${expando.name} says: ${s}" }
println expando.say('hello')
//2.
def person = new Expando()
person.name = 'Alice'
person.age = 18
person.description = {
    println """
               ----------description---------
                  name: ${delegate.name}
                  age:  ${delegate.age}
               ------------------------------
             """
}
person.description()


//可以对 ObservableList/Map/Set的变化添加监听
list = new ObservableList()
def printer = { e -> println e.class }
list.addPropertyChangeListener(printer)
list.add 'Harry Potter'
list.add 'Hermione Granger'
list.remove(0)

{
  "restartable": "rs",
  "ignore": [
    ".git",
    "node_modules/**/node_modules"
  ],
  "verbose": true,
  "execMap": {
    "":"groovy",
    "groovy": "groovy"
  },
  "watch": ["src/*.*"],
  "env": {
    "NODE_ENV": "development"
  },
  "ext": "js,json"
}