magic-api magic-api
首页
  • 快速入门
  • 基础教程
  • 权限配置
  • 高级应用
  • 开发插件
  • 模块
  • 函数
  • 扩展
  • Gitee (opens new window)
  • Github (opens new window)
  • 演示 (opens new window)
  • SpringBoot配置
  • 编辑器配置
  • 2.x更新日志
  • 1.x更新日志
  • 0.x更新日志
常见问题
💖支持
交流群
首页
  • 快速入门
  • 基础教程
  • 权限配置
  • 高级应用
  • 开发插件
  • 模块
  • 函数
  • 扩展
  • Gitee (opens new window)
  • Github (opens new window)
  • 演示 (opens new window)
  • SpringBoot配置
  • 编辑器配置
  • 2.x更新日志
  • 1.x更新日志
  • 0.x更新日志
常见问题
💖支持
交流群
  • 快速入门

    • 简介
    • 快速开始
    • 请求参数获取
    • 增删改查
    • 单表crud接口
    • 分页
  • 基础教程

    • 界面简介
    • 脚本语法
    • 配置多数据源
    • 统一请求响应
    • 统一异常处理
    • 参数校验
    • 脚本调用Java
    • Java调用接口
    • 异步调用
    • 接口发布
    • Lambda
      • Linq
      • 从1.x迁移
    • 权限配置

      • UI鉴权登录
      • UI操作鉴权
      • 接口鉴权
    • 高级应用

      • 自定义拦截器
      • 自定义SQL拦截器
      • 自定义单表API拦截器
      • 自定义SQL缓存
      • 自定义模块
      • 自定义函数
      • 自定义类型扩展
      • 自定义接口存储
      • 自定义数据库方言
      • 自定义列名转换
      • 自定义脚本语言
    • 插件

      • 插件开发
      • 集群插件
      • 定时任务插件
      • Redis插件
      • Mongo插件
      • ElasticSearch插件
      • Swagger插件
      • Git插件
    • 指南
    • 基础教程
    mxd
    2022-01-30
    目录

    Lambda

    # 映射(map)

    var list = [
        {sex : 0,name : '小明',age : 19},
        {sex : 1,name : '小花',age : 18}
    ];
    var getAge = (age) => age > 18 ? '成人' : '未成年'
    // 利用map函数对list进行过滤
    return list.map(item => {
        age : getAge(item.age),
        sex : item.sex == 0 ? '男' : '女',
        name : item.name
    });
    
    
    /*结果
    [{
        "sex": "男",
        "name": "小明",
        "age": "成人"
    },{
        "sex": "女",
        "name": "小花",
        "age": "未成年"
    }]
    */
    

    ​ 等价于以下Linq代码。

     return 
        select 
            t.age > 18 ? '成人' : '未成年' age,
            t.sex == 0 ? '男' : '女' sex,
            t.name
        from list t;
    

    # 过滤(filter)

    var list = [
        {sex : 0,name : '小明'},
        {sex : 1,name : '小花'}
    ]
    // 利用map函数对list进行过滤
    return list.filter(item => item.sex == 0);
    // 以上代码可以使用linq代替
    return select * from list t where t.sex = 0
    /* 结果
    [{
        "sex": 0,
        "name": "小明"
    }]
    */
    

    # 过滤+映射(filter + map)

    var list = [
        {sex : 0,name : '小明'},
        {sex : 1,name : '小花'}
    ]
    // 对list进行过滤,然后进行映射
    return list.filter(item => item.sex == 0).map(item => {
        sex : item.sex == 0 ? '男' : '女',
        name : item.name
    });
    
    /* 结果
    [{
        "sex": "男",
        "name": "小明"
    }]
    */
    

    ​ 等价于以下Linq代码。

    return select t.sex ==0 ? '男' : '女' sex ,t.name from list t where t.sex = 0
    

    # 分组(group)

    ​ 默认聚合为List

    // List<Map<String,Object>>
    var result = [
        { xxx : 1, yyy : 2, value : 11},
        { xxx : 1, yyy : 2, value : 22},
        { xxx : 2, yyy : 2, value : 33}
    ];
    
    
    return result.group(item => item.xxx + '_' + item.yyy)
    /*
    Map<Object,List<Object>>
    {
        "1_2": [
                {"yyy": 2, "xxx": 1, "value": 11},
                {"yyy": 2, "xxx": 1, "value": 22}
        ],
        "2_2": [{"yyy": 2, "xxx": 2, "value": 33 }]
    }
    */
    

    ​ 自定义聚合对象。

    
    return result.group(item => item.xxx + '_' + item.yyy,list => {
        count : list.size(),
        sum : list.map(v=>v.value).sum(),
        avg : list.map(v=>v.value).avg()
    })
    /*
    Map<Object,Object>
    {
        "1_2": { "avg": 16.5, "count": 2, "sum": 33 },
        "2_2": { "avg": 33,   "count": 1, "sum": 33 }
    }
    */
    

    # 关联(join)

    var year2019 = [
        { "pt":2019, "item_code":"code_1", "sum_price":2234 },
        { "pt":2019, "item_code":"code_2", "sum_price":234 },
        { "pt":2019, "item_code":"code_3", "sum_price":12340 },
        { "pt":2019, "item_code":"code_4", "sum_price":2344 }
    ];
    var year2018 = [
        { "pt":2018, "item_code":"code_1", "sum_price":1234.0 },
        { "pt":2018, "item_code":"code_4", "sum_price":1234.0 }
    ];
    return year2019.join(year2018, (left, right) => left.item_code == right.item_code,  (left ,right) => {
       '年份' : left.pt,
       '编号' : left.item_code,
       '今年' : left.sum_price,
       '去年' : right == null ? 'unknow' : right.sum_price,
       '环比去年增长' : right == null ? '-': (((left.sum_price - right.sum_price) / right.sum_price * 100) + "%")
    });
    
    /*
    [
        {"年份": 2019, "今年": 2234, "去年": 1234, "环比去年增长": "81.03728%", "编号": "code_1"},
        {"年份": 2019, "今年": 234, "去年": "unknow", "环比去年增长": "-", "编号": "code_2"},
        {"年份": 2019, "今年": 12340,"去年": "unknow","环比去年增长": "-","编号": "code_3"},
        {"年份": 2019, "今年": 2344, "去年": 1234, "环比去年增长": "89.95138%", "编号": "code_4"}
    ]
    */
    

    ​ 等价于以下Linq代码:

    return 
        select 
            t.pt 年份,
            t.item_code 编号,
            t.sum_price 今年,
            ifnull(t1.sum_price,'unknow') 去年,
            // ifnull 会对参数进行计算,会报错 所以这里采用三元运算符
            t1.sum_price == null ? '-' : ((t.sum_price - t1.sum_price) / t1.sum_price).asPercent(2) 环比去年增长 
        from year2019 t
        left join year2018 t1 on t.item_code = t1.item_code
    
    上次更新: 2022-08-28 08:18:19
    接口发布
    Linq

    ← 接口发布 Linq→

    Theme by Vdoing | Copyright © 2020-2023 ssssssss.org | MIT License
    • 跟随系统
    • 浅色模式
    • 深色模式
    • 阅读模式
    ×