leenty

leenty 查看完整档案

杭州编辑  |  填写毕业院校  |  填写所在公司/组织 www.leenty.com 编辑
编辑

一只小前端

个人动态

leenty 关注了用户 · 2020-09-29

WASM中文社区 @xiage

关注 45

leenty 收藏了文章 · 2020-07-31

AssemblyScript 入门指南

作者:Danny Guo

翻译:疯狂的技术宅

原文:https://blog.logrocket.com/th...

未经允许严禁转载

WebAssembly(Wasm)是 Web 浏览器中相对较新的功能,但它地扩展了把 Web 作为服务应用平台的功能潜力。

对于 Web 开发人员来说,学习使用 WebAssembly 可能会有一个艰难的过程,但是 AssemblyScript 提供了一种解决方法。首先让我们看一下为什么 WebAssembly 是一项很有前途的技术,然后再看怎样 AssemblyScript 挖掘潜力。

WebAssembly

WebAssembly 是浏览器的低级语言,为开发人员提供了除 JavaScript 之外的 Web 编译目标。它使网站代码可以在安全的沙盒环境中以接近本机的速度运行。

它是根据所有主流浏览器(Chrome,Firefox,Safari 和 Edge)所代表的意见开发的,他们达成了设计共识,这些浏览器现在都支持 WebAssembly。

WebAssembly 以二进制格式交付,这意味着与 JavaScript 相比,WebAssembly 在大小和加载时间上都具有优势。但是它也有易于理解的文本表示形式

当 WebAssembly 首次发布时,一些开发人员认为它有可能最终取代 JavaScript 作为 Web 的主要语言。但是最好把 WebAssembly 看作是与现有 Web 平台良好集成的新工具,这是它的高级目标

WebAssembly 并没有取代 JavaScript 现有的用例,而是吸引了更多人,因为它引入了新的用例。 目前 WebAssembly 还不能直接访问 DOM,大多数网站都希望使用 JavaScript,经过多年的优化,JavaScript 已经相当快了。以下 WebAssembly 可能的使用案例列表的示例:

  • 游戏
  • 科学的可视化和模拟
  • CAD应用
  • 图像/视频编辑

这些应用共同特点是,它们通常会被看作是桌面应用。通过为 CPU 密集型任务提供接近本机的性能,WebAssembly 使得将这些程序迁移至 Web 成为可行。

现有网站也可以从 WebAssembly 中受益。 Figma(https://www.figma.com/) 提供了一个真实的例子,它通过使用 WebAssembly 大大缩短了其加载时间。如果网站使用进行大量计算的代码,则可以将其替换为 WebAssembly 以提高性能。

也许现在你对怎样使用 WebAssembly 感兴趣。你可以学习语言本身并直接编写,但实际上它打算成为其他语言的编译目标。它被设计为对 C 和 C++ 具有良好的支持,Go语言在 version 1.11 中增加了实验性支持的版本中,Rust 也对其进行了大量投入

但是也许你并不想为了使用 WebAssembly 而学习或使用其中某种语言。这就是 AssemblyScript 存在的意义。

AssemblyScript

AssemblyScript 是一个把 TypeScript 转换到 WebAssembly 的编译器。由微软开发的 TypeScript 将类型添加到了 JavaScript 中。它已经变得相当受欢迎,即使对于不熟悉它的人,AssemblyScript 只允许 TypeScript 的有限功能子集,因此不需要花太多时间就可以上手。。

因为它与 JavaScript 非常相似,所以 AssemblyScript 使 Web 开发人员可以轻松地将 WebAssembly 整合到他们的网站中,而不必使用完全不同的语言。

试用

让我们编写第一个 AssemblyScript 模块(以下所有代码均可在 GitHub 上找到)。我们需要 Node.js 的最低版本为 8 才能得到 WebAssembly 的支持

转到一个空目录,创建一个 package.json 文件,然后安装 AssemblyScript。请注意,我们需要直接从它的 GitHub 存储库安装。它尚未在 npm 上发布,因为 AssemblyScript 开发人员还没有考虑编译器是否已经准备好能够支持广泛使用。

mkdir assemblyscript-demo
cd assemblyscript-demo
npm init
npm install --save-dev github:AssemblyScript/assemblyscript

使用 asinit 命令生成脚手架文件:

npx asinit .

我们的 package.json 现在应该包含以下脚本:

{
  "scripts": {
    "asbuild:untouched": "asc assembly/index.ts -b build/untouched.wasm -t build/untouched.wat --sourceMap --validate --debug",
    "asbuild:optimized": "asc assembly/index.ts -b build/optimized.wasm -t build/optimized.wat --sourceMap --validate --optimize",
    "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized"
  }
}

顶层的 index.js 看起来像这样:

const fs = require("fs");
const compiled = new WebAssembly.Module(fs.readFileSync(__dirname + "/build/optimized.wasm"));
const imports = {
  env: {
    abort(_msg, _file, line, column) {
       console.error("abort called at index.ts:" + line + ":" + column);
    }
  }
};
Object.defineProperty(module, "exports", {
  get: () => new WebAssembly.Instance(compiled, imports).exports
});

它使我们能够像使用普通的 JavaScript 模块一样轻松地 require WebAssembly 模块。

assembly 目录中包含我们的 AssemblyScript 源代码。生成的示例是一个简单的加法函数。

export function add(a: i32, b: i32): i32 {
  return a + b;
}

函数签名就像在 TypeScript 中那样,它之所以使用 i32 的原因是 AssemblyScript 使用了 WebAssembly 的特定整数和浮点类型,而不是 TypeScript 的通用 number 类型

让我们来构建示例。

npm run asbuild

build 目录现在应包含以下文件:

optimized.wasm
optimized.wasm.map
optimized.wat
untouched.wasm
untouched.wasm.map
untouched.wat

我们得到了构建的普通版本和优化版本。对于每个构建版本,都有一个 .wasm 二进制文件,一个 .wasm.map源码映射,以及二进制文件的 .wat 文本表示形式。文本表示形式是为了供人阅读,但现在我们无需阅读或理解它——使用 AssemblyScript 的目的之一就是我们不需要使用原始 WebAssembly。

启动 Node 并像其他模块一样使用编译模块。

$ node
Welcome to Node.js v12.10.0.
Type ".help" for more information.
> const add = require('./index').add;
undefined
> add(3, 5)
8

这就是从 Node 调用 WebAssembly 所需要的全部!

添加监视脚本

为了便于开发,我建议你在每次更改源代码时都用 onchange 自动重建模块,因为 AssemblyScript 尚不包括监视模式

npm install --save-dev onchange

package.json 中添加一个 asbuild:watch 脚本。包含 -iflag,即可在运行命令后立即运行初始构建。

{
  "scripts": {
    "asbuild:untouched": "asc assembly/index.ts -b build/untouched.wasm -t build/untouched.wat --sourceMap --validate --debug",
    "asbuild:optimized": "asc assembly/index.ts -b build/optimized.wasm -t build/optimized.wat --sourceMap --validate --optimize",
    "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized",
    "asbuild:watch": "onchange -i 'assembly/**/*' -- npm run asbuild"
  }
}

现在你可以运行 asbuild:watch,而不必不断地重新运行 asbuild

性能

让我们写一个基本的基准测试,用来了解究竟可以获得什么样的性能提升。 WebAssembly 的专长是处理诸如数字计算之类的 CPU 密集型任务,所以我们用一个函数来确定整数是否为质数。

我们的参考实现如下所示。这是一种幼稚的暴力解决方案,因为我们的目标是执行大量计算。

function isPrime(x) {
    if (x < 2) {
        return false;
    }

    for (let i = 2; i < x; i++) {
        if (x % i === 0) {
            return false;
        }
    }

    return true;
}

等效的 AssemblyScript 版本仅需要一些类型注释:

function isPrime(x: u32): bool {
    if (x < 2) {
        return false;
    }

    for (let i: u32 = 2; i < x; i++) {
        if (x % i === 0) {
            return false;
        }
    }

    return true;
}

我们将使用 Benchmark.js

npm install --save-dev benchmark

创建benchmark.js

const Benchmark = require('benchmark');

const assemblyScriptIsPrime = require('./index').isPrime;

function isPrime(x) {
    for (let i = 2; i < x; i++) {
        if (x % i === 0) {
            return false;
        }
    }

    return true;
}

const suite = new Benchmark.Suite;
const startNumber = 2;
const stopNumber = 10000;

suite.add('AssemblyScript isPrime', function () {
    for (let i = startNumber; i < stopNumber; i++) {
        assemblyScriptIsPrime(i);
    }
}).add('JavaScript isPrime', function () {
    for (let i = startNumber; i < stopNumber; i++) {
        isPrime(i);
    }
}).on('cycle', function (event) {
    console.log(String(event.target));
}).on('complete', function () {
    const fastest = this.filter('fastest');
    const slowest = this.filter('slowest');
    const difference = (fastest.map('hz') - slowest.map('hz')) / slowest.map('hz') * 100;
    console.log(`${fastest.map('name')} is ~${difference.toFixed(1)}% faster.`);
}).run();

在我的机器上,运行 node benchmark 时得到了以下结果:

AssemblyScript isPrime x 74.00 ops/sec ±0.43% (76 runs sampled)
JavaScript isPrime x 61.56 ops/sec ±0.30% (64 runs sampled)
AssemblyScript isPrime is ~20.2% faster.

请注意,这个测试是一个 microbenchmark,我们应该谨慎阅读。

对于一些更多的 AssemblyScript 基准测试,我建议你查看 WasmBoy 基准测试波动方程式基准测试

加载模块

接下来,在网站中使用我们的模块。

先创建 index.html

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>AssemblyScript isPrime demo</title>
    </head>
    <body>
        <form id="prime-checker">
            <label for="number">Enter a number to check if it is prime:</label>
            <input name="number" type="number" />
            <button type="submit">Submit</button>
        </form>

        <p id="result"></p>

        <script data-original="demo.js"></script>
    </body>
</html>

再创建 demo.js。加载 WebAssembly 模块有多种方式,但是最有效的方法是通过使用 WebAssembly.instantiateStreaming 函数以流的方式编译和实例化。请注意,如果 assertion 失败的话,我们需要提供 abort 函数

(async () => {
    const importObject = {
        env: {
            abort(_msg, _file, line, column) {
                console.error("abort called at index.ts:" + line + ":" + column);
            }
        }
    };
    const module = await WebAssembly.instantiateStreaming(
        fetch("build/optimized.wasm"),
        importObject
    );
    const isPrime = module.instance.exports.isPrime;

    const result = document.querySelector("#result");
    document.querySelector("#prime-checker").addEventListener("submit", event => {
        event.preventDefault();
        result.innerText = "";
        const number = event.target.elements.number.value;
        result.innerText = `${number} is ${isPrime(number) ? '' : 'not '}prime.`;
    });
})();

现在安装 static-server。因为要使用WebAssembly.instantiateStreaming,我们需要创建服务,该模块需要使用 MIME typeapplication/wasm

npm install --save-dev static-server

将脚本添加到 package.json 中。

{
  "scripts": {
    "serve-demo": "static-server"
  }
}

运行 npm run serve-demo 并在浏览器中打开 localhost URL。提交表单中的数字,你将收到一条消息,指出该数字是否为素数。现在,我们已经实现了从用 AssemblyScript 编码到在网站中实际使用的整个过程。

结论

WebAssembly 以及通过 AssemblyScript 的扩展,不会使每个网站都神奇地变得更快,但是这并不重要。 WebAssembly 之所以令人兴奋,是因为它可以使更多的应用在 Web 变得中可行。

类似地,AssemblyScript 使更多开发人员可以使用 WebAssembly,这使我们很容易默认使用 JavaScript,但是当需要大量运算工作时,可以用 WebAssembly。


本文首发微信公众号:前端先锋

欢迎扫描二维码关注公众号,每天都给你推送新鲜的前端技术文章

欢迎扫描二维码关注公众号,每天都给你推送新鲜的前端技术文章


欢迎继续阅读本专栏其它高赞文章:


查看原文

leenty 收藏了文章 · 2020-07-29

学 Rust,免费拿树莓派

如果你对 WebAssembly 有兴趣,欢迎至文末添加小助手微信,加入 WebAssembly 中文交流群

创建并发布一个高性能 Node.js 应用程序。开始在个人项目或公司项目中使用”当红炸子鸡“ Rust 吧!

学习 Node.js、Rust、与 WebAssembly 的基础知识,参与活动,你将得到免费的树莓派套件(价值25美元)以及一个非常 cool 的证书。

本活动由 WebAssembly 中文社区与 Second State 联合主办,奖品由 Second State 赞助提供,欢迎在 GitHub 上了解Second State 的开源项目

关于树莓派与Rust、WebAssembly 的结合,下面这篇文章可以帮助你了解更多:

活动规则

获得免费的树莓派和证书,只需要你动点心思,自己写一段 Rust 函数。

具体步骤如下:

  1. 按照 《入门文档:在 node.js 中调用 Rust 函数》 中的示例创建一个简单的 Rust 函数,并在 Node.js app 内运行这个函数
  2. 在 GitHub 上 fork 模板项目并更改其中的 Rust 函数,下面是几个参考示例,或许可以给你带来灵感:

1 数学教育 web app
2 作为 web 服务的图像识别
3 机器学习和可视化

就这个应用写一个小结,描述你做了什么,并将你的项目分享到在朋友圈、公司技术论坛、开发者社区如思否、掘金、V2ex、CSDN、开源中国等。

到这里你已经基本完成啦,接下来只需要告诉我们你的成果!

  1. 在2020年8月31日前填写该表单
  2. 根据你所在的城市,我们可能会直接安排发货或请你从电商网站购买套件,我们会给您报销这部分的花费金(最多25美金)。

拿到树莓派后,就可以在树莓派设备上运行 Node.js 服务器和 Rust 函数啦 !

除了树莓派套件外,您还将获得基于区块链的证书,该证书将永久展示您的成就和开源贡献。证书如下图:

还在等什么呢?现在就开始吧!

如果你有任何问题,可以通过 GitHub issues 或添加小助手微信:h0923xw 与我们联系。

入群.jpeg

查看原文

leenty 收藏了文章 · 2020-07-15

Elastic Search快速上手(2):将数据存入ES

前言

在上手使用前,需要先了解一些基本的概念。

推荐
可以到 https://www.elastic.co/guide/... 阅读《Elastic Search 权威指南》,有非常详细和全面的说明。

ES中的一些概念

index(索引)

相当于mysql中的数据库

type(类型)

相当于mysql中的一张表

document(文档)

相当于mysql中的一行(一条记录)

field(域)

相当于mysql中的一列(一个字段)

节点

一个服务器,由一个名字来标识

集群

一个或多个节点组织在一起

分片

将一份数据划分为多小份的能力,允许水平分割和扩展容量。多个分片可以响应请求,提高性能和吞吐量。

副本

复制数据,一个节点出问题时,其余节点可以顶上。

倒排索引

可参考https://www.elastic.co/guide/...

索引&类型

对索引的基本操作

创建索引

通过以下命令可创建一个索引:

PUT job
{
  "settings":{
    "index":{
      "number_of_shards":5,
      "number_of_replicas":1
    }
  }
}

返回:

{
  "acknowledged": true,
  "shards_acknowledged": true
}

Elasticsearch 是利用分片将数据分发到集群内各处的。分片是数据的容器,文档保存在分片内,分片又被分配到集群内的各个节点里。
当你的集群规模扩大或者缩小时, Elasticsearch 会自动的在各节点中迁移分片,使得数据仍然均匀分布在集群里。

一个分片可以是 主 分片或者 副本 分片。 索引内任意一个文档都归属于一个主分片,所以主分片的数目决定着索引能够保存的最大数据量。

一个副本分片只是一个主分片的拷贝。 副本分片作为硬件故障时保护数据不丢失的冗余备份,并为搜索和返回文档等读操作提供服务。

在上面例子中,主分片为5,副本分片为1.

查看索引的信息

GET job

查看job这个索引的信息:

{
  "job": {
    "aliases": {},
    "mappings": {},
    "settings": {
      "index": {
        "creation_date": "1502342603160",
        "number_of_shards": "5",
        "number_of_replicas": "1",
        "uuid": "LGalsb3eRKeGb5SbWCxO8w",
        "version": {
          "created": "5010199"
        },
        "provided_name": "job"
      }
    }
  }
}

可以只查看某一项信息:

GET job/_settings

可以查看job这个索引的settings信息:

{
  "job": {
    "settings": {
      "index": {
        "creation_date": "1502342603160",
        "number_of_shards": "5",
        "number_of_replicas": "1",
        "uuid": "LGalsb3eRKeGb5SbWCxO8w",
        "version": {
          "created": "5010199"
        },
        "provided_name": "job"
      }
    }
  }
}

修改索引信息

例如,将副本分片数量修改为2:

PUT job/_settings
{
  "number_of_replicas":2
}

映射

在创建索引时,我们可以预先设定映射,规定好各个字段及其数据类型,便于es更好地进行管理。比如说,以文章库为例 ,一篇文章的关键词字段应当作为完整的词语,而文章的正文字段必须通过中文分词器进行分词。

通过设置映射mapping,可以告知es这些字段的规则。

更详细文档参见:https://www.elastic.co/guide/...

数据类型

Elasticsearch支持如下类型:

字符串: text, keyword(注:5之前的版本里有string类型,5之后不再支持此类型)
数字: byte, short, integer, long, float, double
布尔型:boolean
日期: date
复杂类型:如object, nested等

查看映射

输入

GET job/_mapping

可以查看job索引下的所有映射。

默认映射

在创建索引存入数据时,如果不指定类型,es会自动根据实际数据为其添加类型。
例如,通过下面的语句插入文档:

PUT job/type1/1
{
  "title":"abc",
  "words":123,
  "date":"2017-01-01",
  "isok":true
}

然后查看映射,结果为:

{
  "job": {
    "mappings": {
      "type1": {
        "properties": {
          "date": {
            "type": "date"
          },
          "isok": {
            "type": "boolean"
          },
          "title": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "words": {
            "type": "long"
          }
        }
      }
    }
  }
}

可见,es自动根据类型对字段进行了映射。

设置映射

在创建索引时,可以设置映射规则,具体格式形如上面查看映射时的返回结果。

PUT job
{
  "mappings":{
    "type2":{
      "properties":{
        "title":{
          "type":"keyword"
        },
        "salary":{
          "type":"integer"
        },
        "desc":{
          "type":"text",
          "analyzer": "ik_max_word"
        },
        "date":{
          "type":"date",
          "format":"yyyy-MM-dd"
        }
      }
    }
  }
}

注意,在上面为desc字段指定了analyzer,就是一个自定义分词器。在es-rtf中,默认给安装了ik_smart和ik_max_word两个分词器,区别在于后者会分出更多的词。
为text类型的字段会被进行分词,然后索引,而keyword字段不会被分词。

自动转换

创建索引和映射后,插入文档时,字段会自动转换成映射中规定的类型。比如,插入"123"到integer字段,会自动尝试对字符串进行类型转换。如果无法转换,则会报错,无法插入。

文档

一个“文档”即所谓的一条记录。可对文档进行增删改操作。

插入文档

可以指定文档id,即 PUT index_name/type_name/id。

PUT job/type2/1
{
  "title":"Python工程师",
  "salary":1000,
  "desc":"1. 参与devops相关系统开发,包括云资源管理平台,cmdb平台、资源申请流程、基础支撑平台开发;2. 参与公司业务系统及自动化运维平台的开发;3. 积累并规范化系统开发的最佳实践并文档化;4. 完善并遵守团队的编码规范,编写高质量、结构清晰、易读、易维护的代码。",
  "date":"2017-08-08"
}

返回:

{
  "_index": "job",
  "_type": "type2",
  "_id": "1",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "created": true
}

也可不指定id,则会自动分配id。注意这里要使用POST方式

POST job/type2/
{
  "title":"Python工程师2",
  "salary":1000,
  "desc":"1. 参与devops相关系统开发,包括云资源管理平台,cmdb平台、资源申请流程、基础支撑平台开发;2. 参与公司业务系统及自动化运维平台的开发;3. 积累并规范化系统开发的最佳实践并文档化;4. 完善并遵守团队的编码规范,编写高质量、结构清晰、易读、易维护的代码。",
  "date":"2017-08-08"
}

查看文档

只需通过GET方式查看,

GET job/type2/1

返回文档信息:

{
  "_index": "job",
  "_type": "type2",
  "_id": "1",
  "_version": 3,
  "found": true,
  "_source": {
    "title": "Java",
    "salary": 2000,
    "desc": "易维护的代码",
    "date": "2017-08-08"
  }
}

可以只查看_source中的部分字段:

GET job/type2/1?_source=title,salary

返回:

{
  "_index": "job",
  "_type": "type2",
  "_id": "1",
  "_version": 3,
  "found": true,
  "_source": {
    "title": "Java",
    "salary": 2000
  }
}

修改文档

一种是通过PUT的全覆盖方式,旧数据将被删除,以新的代替。

PUT job/type2/1
{
  "title":"Java",
  "salary":1400,
  "desc":"易维护的代码",
  "date":"2017-08-08"
}

另一种是通过POST方式,只对部分字段进行修改。

POST job/type2/1/_update
{
  "doc":{
    "salary":2000
  }
}

删除文档

通过DELETE方式可删除文档:

DELETE job/type2/1

mget取回多个文档

可参考:https://www.elastic.co/guide/...

通过将查询合并,可以减少连接次数,提高效率。

GET _mget
{
   "docs" : [
      {
         "_index" : "job",
         "_type" :  "type2",
         "_id" :    1
      },
      {
         "_index" : "job",
         "_type" :  "type2",
         "_id" :    2,
         "_source": "salary"
      }
   ]
}

返回两个文档:

{
  "docs": [
    {
      "_index": "job",
      "_type": "type2",
      "_id": "1",
      "_version": 3,
      "found": true,
      "_source": {
        "title": "Java",
        "salary": 2000,
        "desc": "易维护的代码",
        "date": "2017-08-08"
      }
    },
    {
      "_index": "job",
      "_type": "type2",
      "_id": "2",
      "found": false
    }
  ]
}

还可进行简写,比如,index和type都相同,查找两个id,可以写作:

GET job/type2/_mget
{
  "ids":["1", "2"]
    
  }
}

bulk批量操作

bulk API 允许在单个步骤中进行多次 create 、 index 、 update 或 delete 请求。

详细参考:https://www.elastic.co/guide/...

bulk批量操作的请求比较特殊,格式为:

{ action: { metadata }}n
{ request body }n
{ action: { metadata }}n
{ request body }n ...

一般两行为一条请求,第一行说明操作和元数据,第二行是操作数据。不过delete请求只有一行。

POST _bulk
{ "delete": { "_index": "website", "_type": "blog", "_id": "123" }} 
{ "create": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "title":    "My first blog post" }
{ "index":  { "_index": "website", "_type": "blog" }}
{ "title":    "My second blog post" }
{ "update": { "_index": "website", "_type": "blog", "_id": "123", "_retry_on_conflict" : 3} }
{ "doc" : {"title" : "My updated blog post"} }

返回结果会列出每个请求的处理状态。

{
   "took": 4,
   "errors": false, 
   "items": [
      {  "delete": {
            "_index":   "website",
            "_type":    "blog",
            "_id":      "123",
            "_version": 2,
            "status":   200,
            "found":    true
      }},
      {  "create": {
            "_index":   "website",
            "_type":    "blog",
            "_id":      "123",
            "_version": 3,
            "status":   201
      }},
      {  "create": {
            "_index":   "website",
            "_type":    "blog",
            "_id":      "EiwfApScQiiy7TIKFxRCTw",
            "_version": 1,
            "status":   201
      }},
      {  "update": {
            "_index":   "website",
            "_type":    "blog",
            "_id":      "123",
            "_version": 4,
            "status":   200
      }}
   ]
}


通过以上操作,可以将数据以一定的组织方式,写入到es中。下一篇将总结如何进行搜索和查找。

查看原文

leenty 收藏了文章 · 2019-12-19

egg-shell-decorators 给你的蛋蛋加个壳

图片描述

Egg.js 路由装饰器,让你的开发更敏捷~

【PS:文末有本人联系方式,欢迎技术交流~】

egg-shell-decorators 是一个 Egg.js 的插件,它提供了一系列的 Decorator 装饰 Controller,让我们先来看一个例子:

// app/controller/user
import { Controller } from 'egg';
import { Get, Message } from 'egg-shell-decorators';

export default class UserController extends Controller {

  @Get('/detail/:id')
  @Message('so great !')
  public async get({ params: { id } }) {
    return await this.service.user.getById(id)
  }

}

上面是一个简单的控制器例子,如果是 egg.js 的默认开发方式,那么你得在 router 文件对相应的路由进行映射,而使用 egg-shell-decorators 之后,再也不用在 router 文件进行任何路由匹配了。因为 egg-shell-decorators 的路由解析会自动对路由进行解析,像上面这个例子会自动解析成 [get] 全局前缀 + /user/detail/:id,这样我们开发者就不用再去操心映射的问题了,而且在 Controller 里我们就可以知道每一个函数对应的请求信息。

也许你会疑惑上面的@Message还有为什么直接把查询到的数据 return 了是怎么回事,现在我将系统的向你介绍该插件的使用:

Installation

$ npm install egg-shell-decorators -S

如果不是采用 TypeScript 脚手架,则需执行以下脚本安装相关的 Babel 插件:

$ npm install babel-register babel-plugin-transform-decorators-legacy -D

Usage

示范代码均采用 TypeScript
// app/router.ts
import { Application } from 'egg';
import { EggShell } from 'egg-shell-decorators';

export default (app: Application) => {
  EggShell(app, { prefix: '/', quickStart: true });
};

配置参数:

prefix: string // 全局前缀
quickStart: boolean // 开启QuickStart

如果不是采用 TypeScript 脚手架,则需在入口注册 Bable 插件使其支持 Decorator:

// app.js
'use strict';
require('babel-register')({
  plugins: [
    'transform-decorators-legacy',
  ],
});

Specialty

路由解析是 egg-shell-decorators 最大的特点,使用 Decorator 装饰的路由,则会被自动解析成对应的路由:

  • 文件路径:app/controller/home.ts

    • @Get('/detail/:id')
    • @Post('/')
  • 解析路由:

    • [get] 全局前缀 + /home + /detail/:id
    • [post] 全局前缀 + /home + /

这里的 全局前缀 指的是你在 EggShell 里配置的 prefix,路由解析支持多层级解析噢~

Member

  • Http相关

    • ✅Get
    • ✅Post
    • ✅Put
    • ✅Delete
    • ✅Patch
    • ✅Options
    • ✅Head
    • 🔲Header
  • 中间件相关

    • ✅Before
    • ✅After
    • ✅BeforeAll
    • ✅AfterAll
  • Swagger相关

    • 🔲敬请期待下一个版本
  • 其他

    • ✅Prefix
    • ✅Message
    • ✅IgnoreJwt
    • ✅IgnoreJwtAll

Prefix

如果你不喜欢路由解析给你的路径,那么你可以自定义解析的路径:

// app/controller/user
import { Controller } from 'egg';
import { Get, Message, Prefix } from 'egg-shell-decorators';

@Prefix('/super2god')
export default class UserController extends Controller {

  @Get('/detail/:id')
  @Message('so great !')
  public async get({ params: { id } }) {
    return await this.service.user.getById(id)
  }

}

这样解析出来的路由就是:全局前缀 + /super2god/detail/:id,而不是全局前缀 + /user/detail/:id

QuickStart

在 EggShell 里配置 quickStart 为 true 即可开启 QuickStart 模式,QuickStart 模式会自动处理响应体:

import { Controller } from 'egg';
import { Get, Message, Error, StatusError } from 'egg-shell-decorators';

export default class UserController extends Controller {

  /**
   status: 200
   {
     success: true,
     message: '棒棒哒',
     data: {
       id: '123',
       name: 'super2god'
     },
   }
   */
  @Get('/:id')
  @Message('棒棒哒')
  public async get({ params: { id } }) {
    return await this.service.user.getById(id)
  }

  /**
   status: 200
   {
     success: false,
     message: '故意的'
   }
   */
  @Post('/:id')
  public post() {
    throw Error('故意的')
  }

  /**
   status: 403
   {
     success: false,
     message: '权限不足'
   }
   */
  @Post('/:id')
  public post() {
    // StatusError 的第二个参数默认值为500
    throw StatusError('权限不足', 403)
  }

}

RESTful

让我们用 egg-shell-decorators 快速写一套 RESTful 风格的接口(QuickStart 模式):

import { Controller } from 'egg';
import { Get, Post, Put, Delete } from 'egg-shell-decorators';

export default class SubOrderController extends Controller {

  @Get('/:id')
  public get({ params: { id }, query: { keyword } }) {
    return `resuful get : ${id}, ${keyword}`;
  }

  @Post('/:id')
  public post({ params: { id }, request: { body: { keyword } } }) {
    return `resuful post : ${id}, ${keyword}`;
  }

  @Put('/:id')
  public put({ params: { id }, request: { body: { keyword } } }) {
    return `resuful put : ${id}, ${keyword}`;
  }

  @Delete('/:id')
  public delete({ params: { id }, request: { body: { keyword } } }) {
    return `resuful delete : ${id}, ${keyword}`;
  }

}

由于 egg-shell-decorators 内置把 ctx 对象传进 Controller 的函数里了,所以我们直接结构就可以获取到请求参数了,美滋滋~

当然,除了这四个常用的请求方法,egg-shell-decorators 还提供了其他比较常用的请求方法,具体请看上面的Http请求方法

Jwt

Jwt是目前比较流行的身份认证机制,所以 egg-shell-decorators 提供了相关的 Decorator。如果你使用了 egg-jwt,那默认所以路由都需要进行身份校验,而有时我们想让部分路由不用校验,那么你只需那么做:

import { Controller } from 'egg';
import { Get, IgnoreJwt } from 'egg-shell-decorators';

export default class HomeController extends Controller {

  @IgnoreJwt
  @Get('/')
  public async index() {
    return 'hi, egg';
  }

}

是不是很简单呢,如果你想对整个 Controller 都进行校验忽略,那也很简单:


import { Controller } from 'egg';
import { Get, Post, IgnoreJwtAll } from 'egg-shell-decorators';

@IgnoreJwtAll
export default class HomeController extends Controller {

  @Get('/')
  public async get() {
    return 'get';
  }

  @Post('/')
  public async post() {
    return 'post';
  }

}

MiddleWare

egg-shell-decorators 提供了四个中间件相关的 Decorator,让你使用中间件更简单:

import { Controller } from 'egg';
import { Get, IgnoreJwtAll, Before, After, BeforeAll, AfterAll } from 'egg-shell-decorators';

const Before1 = require('egg-shell-decorators/test/middlewares/before-1');
const Before2 = require('egg-shell-decorators/test/middlewares/before-2');
const Before3 = require('egg-shell-decorators/test/middlewares/before-3');
const Before4 = require('egg-shell-decorators/test/middlewares/before-4');

const After1 = require('egg-shell-decorators/test/middlewares/after-1');
const After2 = require('egg-shell-decorators/test/middlewares/after-2');
const After3 = require('egg-shell-decorators/test/middlewares/after-3');
const After4 = require('egg-shell-decorators/test/middlewares/after-4');

@BeforeAll([ Before1, Before2 ])
@AfterAll([ After1, After2 ])
@IgnoreJwtAll
export default class HomeController extends Controller {

  /**
   before middleware => 1
   before middleware => 2
   before middleware => 3
   before middleware => 4
   主业务...
   after middleware => 1
   after middleware => 2
   after middleware => 3
   after middleware => 4
   */
  @Before([ Before3, Before4 ])
  @After([ After3, After4 ])
  @Get('/')
  public async index() {
    return 'hi, egg';
  }

}

egg-shell-decorators 的用法都已经介绍完毕了,如果你是一名 Noder 或者热爱 Egg.js 的小伙伴,那么可以加我微信进行技术交流,让我们一起变得更优秀:

查看原文

leenty 关注了标签 · 2019-09-04

react.js

React (sometimes styled React.js or ReactJS) is an open-source JavaScript library for creating user interfaces that aims to address challenges encountered in developing single-page applications. It is maintained by Facebook, Instagram and a community of individual developers and corporations.

关注 69540

leenty 关注了问题 · 2019-08-31

webp图片失真及体积变大

又拍云上部分使用webp后缀图片体积会比png的原图大,或者会比png的原图模糊,有人遇到过一样的情况或知道是什么原因么?

关注 1 回答 0

leenty 收藏了文章 · 2018-10-08

Java 11 正式发布,这 8 个逆天新特性教你写出更牛逼的代码

美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本。

为什么说是长期版本,看下面的官方发布的支持路线图表。

image

可以看出 Java 8 扩展支持到 2025 年,而 Java 11 扩展支持到 2026 年。

现在大部分都在用 Java 8,Java 9 和 10 目前很少有人在用,至少我没有发现有公司在生产环境应用的,那就是找死。

现在 Java 11 长期支持,也已经包含了 9 和 10 的全部功能,9 和 10 自然就活到头了。。

那么我们来看下 从 Java 9 - 11 都有哪些重要的新特性呢?

1、本地变量类型推断

这个博主已经写过一篇文章,详细的介绍了 Java 10 带来的这个新特性。

什么是局部变量类型推断?

var javastack = "javastack";
System.out.println(javastack);

大家看出来了,局部变量类型推断就是左边的类型直接使用 var 定义,而不用写具体的类型,编译器能根据右边的表达式自动推断类型,如上面的 String

var javastack = "javastack";

就等于:

String javastack = "javastack";

更多使用详情请参考这篇文章《Java 10 实战第 1 篇:局部变量类型推断》,这里不再重复了。

2、字符串加强

Java 11 增加了一系列的字符串处理方法,如以下所示。

// 判断字符串是否为空白
" ".isBlank();                // true

// 去除首尾空格
" Javastack ".strip();          // "Javastack"

// 去除尾部空格 
" Javastack ".stripTrailing();  // " Javastack"

// 去除首部空格 
" Javastack ".stripLeading();   // "Javastack "

// 复制字符串
"Java".repeat(3);             // "JavaJavaJava"

// 行数统计
"A\nB\nC".lines().count();    // 3

3、集合加强

自 Java 9 开始,Jdk 里面为集合(List/ Set/ Map)都添加了 ofcopyOf 方法,它们两个都用来创建不可变的集合,来看下它们的使用和区别。

示例1:

var list = List.of("Java", "Python", "C");
var copy = List.copyOf(list);
System.out.println(list == copy);   // true

示例2:

var list = new ArrayList<String>();
var copy = List.copyOf(list);
System.out.println(list == copy);   // false

示例1和2代码差不多,为什么一个为true,一个为false?

来看下它们的源码:

static <E> List<E> of(E... elements) {
    switch (elements.length) { // implicit null check of elements
        case 0:
            return ImmutableCollections.emptyList();
        case 1:
            return new ImmutableCollections.List12<>(elements[0]);
        case 2:
            return new ImmutableCollections.List12<>(elements[0], elements[1]);
        default:
            return new ImmutableCollections.ListN<>(elements);
    }
}

static <E> List<E> copyOf(Collection<? extends E> coll) {
    return ImmutableCollections.listCopy(coll);
}

static <E> List<E> listCopy(Collection<? extends E> coll) {
    if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {
        return (List<E>)coll;
    } else {
        return (List<E>)List.of(coll.toArray());
    }
}

可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的,如果是,就直接返回,如果不是,则调用 of 创建一个新的集合。

示例2因为用的 new 创建的集合,不属于不可变 AbstractImmutableList 类的子类,所以 copyOf 方法又创建了一个新的实例,所以为false.

注意:使用 of 和 copyOf 创建的集合为不可变集合,不能进行添加、删除、替换、排序等操作,不然会报 java.lang.UnsupportedOperationException 异常。

上面演示了 List 的 of 和 copyOf 方法,Set 和 Map 接口都有。

4、Stream 加强

Stream 是 Java 8 中的新特性,Java 9 开始对 Stream 增加了以下 4 个新方法。

1) 增加单个参数构造方法,可为null

Stream.ofNullable(null).count(); // 0

2) 增加 takeWhile 和 dropWhile 方法

Stream.of(1, 2, 3, 2, 1)
    .takeWhile(n -> n < 3)
    .collect(Collectors.toList());  // [1, 2]

从开始计算,当 n < 3 时就截止。

Stream.of(1, 2, 3, 2, 1)
    .dropWhile(n -> n < 3)
    .collect(Collectors.toList());  // [3, 2, 1]

这个和上面的相反,一旦 n < 3 不成立就开始计算。

3)iterate重载

这个 iterate 方法的新重载方法,可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

如果你对 JDK 8 中的 Stream 还不熟悉,可以看之前分享的这一系列教程。

5、Optional 加强

Opthonal 也增加了几个非常酷的方法,现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

Optional.of("javastack").orElseThrow();     // javastack
Optional.of("javastack").stream().count();  // 1
Optional.ofNullable(null)
    .or(() -> Optional.of("javastack"))
    .get();   // javastack

6、InputStream 加强

InputStream 终于有了一个非常有用的方法:transferTo,可以用来将数据直接传输到 OutputStream,这是在处理原始数据流时非常常见的一种用法,如下示例。

var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("javastack.txt");
var javastack = File.createTempFile("javastack2", "txt");
try (var outputStream = new FileOutputStream(javastack)) {
    inputStream.transferTo(outputStream);
}

7、HTTP Client API

这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API,该 API 支持同步和异步,而在 Java 11 中已经为正式可用状态,你可以在 java.net 包中找到这个 API。

来看一下 HTTP Client 的用法:

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://javastack.cn"))
    .GET()
    .build();
var client = HttpClient.newHttpClient();

// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

上面的 .GET() 可以省略,默认请求方式为 Get!

更多使用示例可以看这个 API,后续有机会再做演示。

现在 Java 自带了这个 HTTP Client API,我们以后还有必要用 Apache 的 HttpClient 工具包吗?

8、化繁为简,一个命令编译运行源代码

看下面的代码。

// 编译
javac Javastack.java

// 运行
java Javastack

在我们的认知里面,要运行一个 Java 源代码必须先编译,再运行,两步执行动作。而在未来的 Java 11 版本中,通过一个 java 命令就直接搞定了,如以下所示。

java Javastack.java

更多新特性

  • Flow API for reactive programming
  • Java Module System
  • Application Class Data Sharing
  • Dynamic Class-File Constants
  • Java REPL (JShell)
  • Flight Recorder
  • Unicode 10
  • G1: Full Parallel Garbage Collector
  • ZGC: Scalable Low-Latency Garbage Collector
  • Epsilon: No-Op Garbage Collector
  • Deprecate the Nashorn JavaScript Engine
  • ...

历史新特性文章

  • Java 11 要来了,编译运行一个命令搞定
  • JDK 11 发布计划来了,已确定 3个 新特性
  • Java 10 实战第 1 篇:局部变量类型推断
  • JDK 5 ~ 10 新特性倾情整理
  • JDK 10 的 10 个新特性
  • JDK 10 最重要的 5 个新特性
  • JDK 9 的 9 个新特性
  • JDK 9 新特性实战:简化流关闭新姿势
  • JDK 8 的排序大法
  • JDK 8 新特性之 Lambda 表达式
  • JDK 8 新特性之函数式接口
  • JDK 8 新特性之方法引用
  • JDK 8 新特性之接口默认方法与静态方法
  • JDK 8 新特性之 Optional
  • JDK 8 新特性之重复注解
  • JDK 8 新特性之 Stream 流
  • JDK 8 新特性之 Stream 流(一)基础体验
  • JDK 8 新特性之 Stream 流(二)关键知识点
  • JDK 8 新特性之 Stream 流(三)缩减操作
  • JDK 8 新特性之 Stream 流(四)并行流
  • JDK 8 新特性之 Stream 流(五)映射
  • JDK 8 新特性之 Stream 流(六)收集缩
  • JDK 8 新特性之 Stream 流(七)流与迭代器
  • JDK 8 新特性之扩展篇

更多新特性、新玩法,可以在 "Java技术栈" 微信公众号后台回复关键字:java,获取以上所有新特性文章。

结束语

现在许多人还在使用 Java 8 或者 7,不过 8 在 2019 年初就会结束免费更新。现在 11 是长期支持版本,正是学习和上手 11 的好时机,写这篇文章希望能对你有所启发。

如果你喜欢的我的文章,对你有帮助,点赞转发支持一下吧~


更多干货推荐

1.史上最强 Java 中高级面试题整理

2.史上最强 Spring Boot & Cloud 教程整理

3.史上最强架构设计分布式技术干货整理

更多请扫描下方的二维码关注我们的微信公众号,干货每日推送!

Java技术栈

查看原文

leenty 赞了文章 · 2018-10-08

Java 11 正式发布,这 8 个逆天新特性教你写出更牛逼的代码

美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本。

为什么说是长期版本,看下面的官方发布的支持路线图表。

image

可以看出 Java 8 扩展支持到 2025 年,而 Java 11 扩展支持到 2026 年。

现在大部分都在用 Java 8,Java 9 和 10 目前很少有人在用,至少我没有发现有公司在生产环境应用的,那就是找死。

现在 Java 11 长期支持,也已经包含了 9 和 10 的全部功能,9 和 10 自然就活到头了。。

那么我们来看下 从 Java 9 - 11 都有哪些重要的新特性呢?

1、本地变量类型推断

这个博主已经写过一篇文章,详细的介绍了 Java 10 带来的这个新特性。

什么是局部变量类型推断?

var javastack = "javastack";
System.out.println(javastack);

大家看出来了,局部变量类型推断就是左边的类型直接使用 var 定义,而不用写具体的类型,编译器能根据右边的表达式自动推断类型,如上面的 String

var javastack = "javastack";

就等于:

String javastack = "javastack";

更多使用详情请参考这篇文章《Java 10 实战第 1 篇:局部变量类型推断》,这里不再重复了。

2、字符串加强

Java 11 增加了一系列的字符串处理方法,如以下所示。

// 判断字符串是否为空白
" ".isBlank();                // true

// 去除首尾空格
" Javastack ".strip();          // "Javastack"

// 去除尾部空格 
" Javastack ".stripTrailing();  // " Javastack"

// 去除首部空格 
" Javastack ".stripLeading();   // "Javastack "

// 复制字符串
"Java".repeat(3);             // "JavaJavaJava"

// 行数统计
"A\nB\nC".lines().count();    // 3

3、集合加强

自 Java 9 开始,Jdk 里面为集合(List/ Set/ Map)都添加了 ofcopyOf 方法,它们两个都用来创建不可变的集合,来看下它们的使用和区别。

示例1:

var list = List.of("Java", "Python", "C");
var copy = List.copyOf(list);
System.out.println(list == copy);   // true

示例2:

var list = new ArrayList<String>();
var copy = List.copyOf(list);
System.out.println(list == copy);   // false

示例1和2代码差不多,为什么一个为true,一个为false?

来看下它们的源码:

static <E> List<E> of(E... elements) {
    switch (elements.length) { // implicit null check of elements
        case 0:
            return ImmutableCollections.emptyList();
        case 1:
            return new ImmutableCollections.List12<>(elements[0]);
        case 2:
            return new ImmutableCollections.List12<>(elements[0], elements[1]);
        default:
            return new ImmutableCollections.ListN<>(elements);
    }
}

static <E> List<E> copyOf(Collection<? extends E> coll) {
    return ImmutableCollections.listCopy(coll);
}

static <E> List<E> listCopy(Collection<? extends E> coll) {
    if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {
        return (List<E>)coll;
    } else {
        return (List<E>)List.of(coll.toArray());
    }
}

可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的,如果是,就直接返回,如果不是,则调用 of 创建一个新的集合。

示例2因为用的 new 创建的集合,不属于不可变 AbstractImmutableList 类的子类,所以 copyOf 方法又创建了一个新的实例,所以为false.

注意:使用 of 和 copyOf 创建的集合为不可变集合,不能进行添加、删除、替换、排序等操作,不然会报 java.lang.UnsupportedOperationException 异常。

上面演示了 List 的 of 和 copyOf 方法,Set 和 Map 接口都有。

4、Stream 加强

Stream 是 Java 8 中的新特性,Java 9 开始对 Stream 增加了以下 4 个新方法。

1) 增加单个参数构造方法,可为null

Stream.ofNullable(null).count(); // 0

2) 增加 takeWhile 和 dropWhile 方法

Stream.of(1, 2, 3, 2, 1)
    .takeWhile(n -> n < 3)
    .collect(Collectors.toList());  // [1, 2]

从开始计算,当 n < 3 时就截止。

Stream.of(1, 2, 3, 2, 1)
    .dropWhile(n -> n < 3)
    .collect(Collectors.toList());  // [3, 2, 1]

这个和上面的相反,一旦 n < 3 不成立就开始计算。

3)iterate重载

这个 iterate 方法的新重载方法,可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

如果你对 JDK 8 中的 Stream 还不熟悉,可以看之前分享的这一系列教程。

5、Optional 加强

Opthonal 也增加了几个非常酷的方法,现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

Optional.of("javastack").orElseThrow();     // javastack
Optional.of("javastack").stream().count();  // 1
Optional.ofNullable(null)
    .or(() -> Optional.of("javastack"))
    .get();   // javastack

6、InputStream 加强

InputStream 终于有了一个非常有用的方法:transferTo,可以用来将数据直接传输到 OutputStream,这是在处理原始数据流时非常常见的一种用法,如下示例。

var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("javastack.txt");
var javastack = File.createTempFile("javastack2", "txt");
try (var outputStream = new FileOutputStream(javastack)) {
    inputStream.transferTo(outputStream);
}

7、HTTP Client API

这是 Java 9 开始引入的一个处理 HTTP 请求的的孵化 HTTP Client API,该 API 支持同步和异步,而在 Java 11 中已经为正式可用状态,你可以在 java.net 包中找到这个 API。

来看一下 HTTP Client 的用法:

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://javastack.cn"))
    .GET()
    .build();
var client = HttpClient.newHttpClient();

// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

上面的 .GET() 可以省略,默认请求方式为 Get!

更多使用示例可以看这个 API,后续有机会再做演示。

现在 Java 自带了这个 HTTP Client API,我们以后还有必要用 Apache 的 HttpClient 工具包吗?

8、化繁为简,一个命令编译运行源代码

看下面的代码。

// 编译
javac Javastack.java

// 运行
java Javastack

在我们的认知里面,要运行一个 Java 源代码必须先编译,再运行,两步执行动作。而在未来的 Java 11 版本中,通过一个 java 命令就直接搞定了,如以下所示。

java Javastack.java

更多新特性

  • Flow API for reactive programming
  • Java Module System
  • Application Class Data Sharing
  • Dynamic Class-File Constants
  • Java REPL (JShell)
  • Flight Recorder
  • Unicode 10
  • G1: Full Parallel Garbage Collector
  • ZGC: Scalable Low-Latency Garbage Collector
  • Epsilon: No-Op Garbage Collector
  • Deprecate the Nashorn JavaScript Engine
  • ...

历史新特性文章

  • Java 11 要来了,编译运行一个命令搞定
  • JDK 11 发布计划来了,已确定 3个 新特性
  • Java 10 实战第 1 篇:局部变量类型推断
  • JDK 5 ~ 10 新特性倾情整理
  • JDK 10 的 10 个新特性
  • JDK 10 最重要的 5 个新特性
  • JDK 9 的 9 个新特性
  • JDK 9 新特性实战:简化流关闭新姿势
  • JDK 8 的排序大法
  • JDK 8 新特性之 Lambda 表达式
  • JDK 8 新特性之函数式接口
  • JDK 8 新特性之方法引用
  • JDK 8 新特性之接口默认方法与静态方法
  • JDK 8 新特性之 Optional
  • JDK 8 新特性之重复注解
  • JDK 8 新特性之 Stream 流
  • JDK 8 新特性之 Stream 流(一)基础体验
  • JDK 8 新特性之 Stream 流(二)关键知识点
  • JDK 8 新特性之 Stream 流(三)缩减操作
  • JDK 8 新特性之 Stream 流(四)并行流
  • JDK 8 新特性之 Stream 流(五)映射
  • JDK 8 新特性之 Stream 流(六)收集缩
  • JDK 8 新特性之 Stream 流(七)流与迭代器
  • JDK 8 新特性之扩展篇

更多新特性、新玩法,可以在 "Java技术栈" 微信公众号后台回复关键字:java,获取以上所有新特性文章。

结束语

现在许多人还在使用 Java 8 或者 7,不过 8 在 2019 年初就会结束免费更新。现在 11 是长期支持版本,正是学习和上手 11 的好时机,写这篇文章希望能对你有所启发。

如果你喜欢的我的文章,对你有帮助,点赞转发支持一下吧~


更多干货推荐

1.史上最强 Java 中高级面试题整理

2.史上最强 Spring Boot & Cloud 教程整理

3.史上最强架构设计分布式技术干货整理

更多请扫描下方的二维码关注我们的微信公众号,干货每日推送!

Java技术栈

查看原文

赞 101 收藏 71 评论 12

leenty 收藏了文章 · 2018-04-09

[译] react-css-modules

原文地址:react-css-modules
阅读本文前建议了解 CSS Modules 的知识。墙裂推荐阅读 Cam 的文章 CSS Modules详解及React中实践

React CSS Modules 实现了自动化映射 CSS modules。每个 CSS 类都被赋予了一个带有全局唯一名字的本地标识符。 CSS Modules 实现了模块化和复用性。(https://github.com/minooo/React-Study/tree/master/step-02

CSS Modules

CSS Mosules 碉堡了。如果你对 CSS Modules 还不够熟悉,那么没关系,它只是一个使用 webpack 之类的模块打包机加载 CSS 作用于特定文档的概念。CSS module loader 将为每一个 CSS 类在加载 CSS 文档(确切的说,这个文档就是Interoperable CSS)的时候生成一个唯一的名字。你可以来看下这个 CSS Modules 实践例子——webpack-demo

在React语法环境中,CSS Modules 看起来是这样子的:

import React from 'react';
import styles from './table.css';

export default class Table extends React.Component {
    render () {
        return <div className={styles.table}>
            <div className={styles.row}>
                <div className={styles.cell}>A0</div>
                <div className={styles.cell}>B0</div>
            </div>
        </div>;

组件渲染出来后会生成类似于这样的一个标记:

<div class="table__table___32osj">
    <div class="table__row___2w27N">
        <div class="table__cell___2w27N">A0</div>
        <div class="table__cell___1oVw5">B0</div>
    </div>
</div>

同时也会生成对应的匹配那些CSS类的CSS文件,是不是碉堡了?!

webpack css-loader

CSS Modules 是一个可以被多种方法实现的规范。react-css-modules 利用 webpack css-loader 所提供的功能启用了现有的 CSS Modules 的集成。

现有的问题

webpack 的 css-loader 本身有几处劣势:

  • 你必须使用驼峰式类名。

  • 无论何时构建一个 className 你都必须使用 style 对象。

  • 混合类模块以及全局 CSS 类不够灵活。

  • 引用一个未定义的 CSS 模块时解析结果为 undefined ,但并无相关警告提示。

React CSS Modules 组件自动加载应用了 styleName 特性的 CSS Modules ,例如:

import React from 'react';
import CSSModules from 'react-css-modules';
import styles from './table.css';

class Table extends React.Component {
    render () {
        return <div styleName='table'>
            <div styleName='row'>
                <div styleName='cell'>A0</div>
                <div styleName='cell'>B0</div>
            </div>
        </div>;
    }
}

export default CSSModules(Table, styles);

使用 react-css-modules 好处多多:

  • 你不用再被强制使用驼峰式命名规则

  • 你不必每次使用一个 CSS 模块时还要引用 styles 对象。

  • 有一个明显的区别在全局 CSS 和 CSS Modules 之间,示例如下:

    <div className='global-css' styleName='local-module'></div>
  • styleName 引用一个为定义的 CSS Module 时,你会得到一个警告信息。(errorWhenNotFound 选项)

  • 你可以为每一个 ReactElement 只使用单独的 CSS Module。(allowMultiple 选项)。

实现

react-css-modules 扩展了目标组件的 render 方法。它将根据 styleName 的值在关联的 style 对象中查找对应的 CSS Modules,并为 ReactElement className 属性值添加相匹配的独一无二的 CSS 类名。

碉堡了!

你可以参照下这个例子进一步加深印象,react-css-modules-examples

用法

设置包括:

  • 设置一个 module bundler 加载 Interoperable CSS

  • 使用 react-css-modules 修整你的组件。

如何设置一个 module bundler呢?

webpack

开发模式

开发环境下,若你想启用 Sourcemaps,并要使用 webpack 的 Hot Module Replacement (HMR,热替换)。style-loader 已经支持 HMR。因此,Hot Module Replacement 开箱即用。

设置步骤:

  • 安装 style-loader

  • 安装 css-loader

  • 设置 /.css$/ 加载器,如下:

{
    test: /\.css$/,
    loaders: [
        'style?sourceMap',
        'css?modules&importLoaders=1&localIdentName=[path]___[name]__[local]___[hash:base64:5]'
    ]
}

生产模式

在生产环境中,如果你想把CSS单独提取出来的话,你需要了解这样做的好处和坏处。

优点:

  • 更少的样式标签

  • CSS SourceMap

  • CSS 并行请求

  • CSS 缓存分离

  • 页面渲染更快(更少的代码以及更少的 DOM 操作)

缺点:

  • 额外的 HTTP 请求

  • 较长的编译时间

  • 较复杂的配置

  • 不支持变更运行环境公共路径

  • 不支持 Hot Module Replacement

extract-text-webpack-plugin

设置步骤:

  • 安装 style-loader

  • 安装 css-loader

  • 使用 extract-text-webpack-plugin 提取 CSS 到一个单独的样式表。

  • 设置 /.css$/ 加载器:

    {
        test: /\.css$/,
        loader: ExtractTextPlugin.extract('style', 'css?modules&importLoaders=1&localIdentName=[name]__[local]___[hash:base64:5]')
    }
  • 设置 extract-text-webpack-plugin 插件:

    new ExtractTextPlugin('app.css', {
        allChunks: true
    })

完整实例请参照 webpack-demo 或者 react-css-modules-examples

Browserify(如果你是使用这个构建工具的话)

请参考 css-modulesify

扩展组件样式

使用 styles 属性重写默认的组件样式。

示例如下:

import React from 'react';
import CSSModules from 'react-css-modules';
import styles from './table.css';

class Table extends React.Component {
    render () {
        return <div styleName='table'>
            <div styleName='row'>
                <div styleName='cell'>A0</div>
                <div styleName='cell'>B0</div>
            </div>
        </div>;
    }
}

export default CSSModules(Table, styles);

在这个例子中,CSSModules 被用来美化 Table 组件通过引用 ./table.css CSS 模块。当 Table 组件渲染完毕,它将使用 styles 对象的属性构建 className 的值。

使用 styles 属性你可以覆盖组件默认的 styles 对象。例如:

import customStyles from './table-custom-styles.css';

<Table styles={customStyles} />;

Interoperable CSS 可以扩展其他 ICSS。利用这个功能可以扩展默认样式,例如:

/* table-custom-styles.css */
.table {
    composes: table from './table.css';
}

.row {
    composes: row from './table.css';
}

/* .cell {
    composes: cell from './table.css';
} */

.table {
    width: 400px;
}

.cell {
    float: left; width: 154px; background: #eee; padding: 10px; margin: 10px 0 10px 10px;
}

在这个例子中,table-custom-styles.css 有选择的扩展了 table.css (Table 组件的默认样式)。
这里是一个更直观的实践例子:UsingStylesProperty example`

style 属性

包装过的组件继承了 styles 属性,该属性描述了 CSS 模块和 CSS 类之间的映射关系。

class extends React.Component {
    render () {
        <div>
            <p styleName='foo'></p>
            <p className={this.props.styles.foo}></p>
        </div>;
    }
}

在上面示例中,styleName='foo'className={this.props.styles.foo} 是等价的。
styles 属性是为 Loops and Child Components 实现组件包装而特意设计的!

Loops and Child Components

styleName 不能去定义一个由其他组件生成的 React元素的样式 。例如:

import React from 'react';
import CSSModules from 'react-css-modules';
import List from './List';
import styles from './table.css';

class CustomList extends React.Component {
    render () {
        let itemTemplate;

        itemTemplate = (name) => {
            return <li styleName='item-template'>{name}</li>;
        };

        return <List itemTemplate={itemTemplate} />;
    }
}

export default CSSModules(CustomList, styles);

上面的实例将不会工作。CSSModules 被用来包装 CustomList 组件。然而,它是呈现 itemTemplage 的列表组件。

为了解决这个问题,包装过的组件继承了样式属性,这样你可以将它作为一个常规的 CSS 模块对象来使用。
因此,前面的例子可以改写为这样:

import React from 'react';
import CSSModules from 'react-css-modules';
import List from './List';
import styles from './table.css';

class CustomList extends React.Component {
    render () {
        let itemTemplate;

        itemTemplate = (name) => {
            return <li className={this.props.styles['item-template']}>{name}</li>;
        };

        return <List itemTemplate={itemTemplate} />;
    }
}

export default CSSModules(CustomList, styles);

在把子组件传递给渲染组件之前,如果你使用了 CSSMmodules 包装这个子组件,那么你就可以在这个子组件内使用 styleName 属性了。例如:

import React from 'react';
import CSSModules from 'react-css-modules';
import List from './List';
import styles from './table.css';

class CustomList extends React.Component {
    render () {
        let itemTemplate;

        itemTemplate = (name) => {
            return <li styleName='item-template'>{name}</li>;
        };

        itemTemplate = CSSModules(itemTemplate, this.props.styles);

        return <List itemTemplate={itemTemplate} />;
    }
}

export default CSSModules(CustomList, styles);

包装

/**
 * @typedef CSSModules~Options
 * @see {@link https://github.com/gajus/react-css-modules#options}
 * @property {Boolean} allowMultiple
 * @property {Boolean} errorWhenNotFound
 */

/**
 * @param {Function} Component
 * @param {Object} defaultStyles CSS Modules class map.
 * @param {CSSModules~Options} options
 * @return {Function}
 */

你需要用 react-css-modules 包装你的组件,例如:

import React from 'react';
import CSSModules from 'react-css-modules';
import styles from './table.css';

class Table extends React.Component {
    render () {
        return <div styleName='table'>
            <div styleName='row'>
                <div styleName='cell'>A0</div>
                <div styleName='cell'>B0</div>
            </div>
        </div>;
    }
}

export default CSSModules(Table, styles);

就这么简单!

顾名思义,react-css-modulesES7 decorators 语法是兼容的。例如:

import React from 'react';
import CSSModules from 'react-css-modules';
import styles from './table.css';

@CSSModules(styles)
export default class extends React.Component {
    render () {
        return <div styleName='table'>
            <div styleName='row'>
                <div styleName='cell'>A0</div>
                <div styleName='cell'>B0</div>
            </div>
        </div>;
    }
}

简直碉堡了!

这里有一个用 webpack 构建的示例,你可以看下 react-css-modules-examples

Options

CSSModules 函数提供了一些选项在第三个参数的位置上。

CSSModules(Component, styles, options);

或者作为第二个参数:

@CSSModules(styles, options);

allowMultiple

默认:false
允许多个样式模块名字。
false,以下会引起一个错误。

<div styleName='foo bar' />

errorWhenNotFound

默认:true
styleName 不能匹配到一个未定义的 CSS Module 时将抛出一个错误。

SASS, SCSS, LESS 以及其他 CSS 预处理器

Interoperable CSS 和 CSS 预处理器是兼容的。使用预处理器,你只需添加这个预处理器到 loaders 的数组中即可。例如在这个 webpack 的例子中,它就像安装 sass-loader 一样简单,添加 !sassstyle-loader 加载器查询的末尾(加载器是从右到左被依次执行的):

{
    test: /\.scss$/,
    loaders: [
        'style',
        'css?modules&importLoaders=1&localIdentName=[path]___[name]__[local]___[hash:base64:5]',
        'resolve-url',
        'sass'
    ]
}

开启 Sourcemaps

开启 CSS Source maps,需要在 css-loadersass-loader 中添加参数 sourceMap

{
    test: /\.scss$/,
    loaders: [
        'style?sourceMap',
        'css?modules&importLoaders=1&localIdentName=[path]___[name]__[local]___[hash:base64:5]',
        'resolve-url',
        'sass?sourceMap'
    ]
}

类组合

CSS Mosules 促进了类组合模式,也就是说,每一个用在组件里的 CSS Module 应该定义描述一个元素所需的全部属性。如:

.box {
    width: 100px;
    height: 100px;
}

.empty {
    composes: box;

    background: #4CAF50;
}

.full {
    composes: box;

    background: #F44336;
}

类组合促进了标记和语义化样式更好的分离,如果没有 CSS Modules,这点将难以实现。

因为 CSS Module 中的类名是本地的,允许你使用诸如 'empty' 或 'full' 这些通用的类名,而无需再加上'box-' 前缀,简直完美!!

想学更多的类组合规则?我建议你读下 Glen Maddern 的关于 CSS Modules 的文章,还有官方文档 spec of the CSS Modules

类组合解决了什么问题?

设想下有这么个例子:

.box {
    width: 100px;
    height: 100px;
}

.box-empty {
    background: #4CAF50;
}

.box-full {
    background: #F44336;
}
<div class='box box-empty'></div>

这是标准的 OOCSS 模式,这种模式最大的问题就是,如果你想改变样式,你几乎每次还要修改 HTML。

类组合也可以使用 CSS 预处理器

接下来是一个学习实践,以加深对类组合本质的理解。CSS Modules 支持一个本机方法,该方法是要组合的 CSS Mosules 使用 composes 关键字实现的。CSS 预处理不是必须的。

在 SCSS 中你可以使用 @extend 关键字,和使用 Mixin Directives去写组合,例如:

使用 @extend :

%box {
    width: 100px;
    height: 100px;
}

.box-empty {
    @extend %box;

    background: #4CAF50;
}

.box-full {
    @extend %box;

    background: #F44336;
}

编译后,得到:

.box-empty,
.box-full {
    width: 100px;
    height: 100px;
}

.box-empty {
    background: #4CAF50;
}

.box-full {
    background: #F44336;
}

使用 mixins:

@mixin box {
    width: 100px;
    height: 100px;
}

.box-empty {
    @include box;

    background: #4CAF50;
}

.box-full {
    @include box;

    background: #F44336;
}

编译后,得到:

.box-empty {
    width: 100px;
    height: 100px;
    background: #4CAF50;
}

.box-full {
    width: 100px;
    height: 100px;
    background: #F44336;
}

全局样式

CSS Modules 不会限制你使用全局 CSS。用法如下:

:global .foo {

}

但是呢,还是请你谨慎使用全局样式。在使用 CSS Modules 过程中,只有少数情况下才会用到全局样式,例如:normalization

多个 CSS Modules

避免使用多个 CSS Modules 去描述单个元素。详见本文档前面的 类组合 部分介绍。

但是如果你非要使用多个 CSS Modules 去描述一个元素,那么就开启 allowMultiple 选项。(参见文档前面 选项 部分)。当多个 CSS Modules 被用来描述一个元素时,react-css-modules 将会为每一个在 styleName 声明中匹配的 CSS Module 附加一个独一无二的类名。如:


.button {

}

.active {

}
<div styleName='button active'></div>

这会把Interoperable CSS 和 CSS class 都映射到目标元素上。

查看原文

认证与成就

  • 获得 74 次点赞
  • 获得 19 枚徽章 获得 0 枚金徽章, 获得 3 枚银徽章, 获得 16 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2016-03-19
个人主页被 1.7k 人浏览