容器最佳实践

管理你的集群

让你的集群更加安全

保持您进群稳定

深度建议

主题

内容介绍：

• 支持 SQL/JSON path
• 支持 Generated Columns
• CTE 支持 Inlined With Queries
• 新增 Pluggable Table Storage Interface
• 分区表性能大辐提升
• 在线重建索引(Reindex Concurrently)

讲师介绍：

digoal
PostgreSQL中文社区发起人之一，生态常委

直播地址：

扫码入群 限时免费看直播

直播时间：

直播海报

分享海报到朋友圈可领取回放免费劵
领取方式：入群联系sf小姐姐，提供朋友圈截图即可

• Kafka 是如何进行复制的
• Kafka 是如何处理来自生产者和消费者的请求的
• Kafka 的存储细节是怎样的

集群成员间的关系

• 如果你要启动另外一个具有相同 ID 的 broker，那么就会得到一个错误 —— 新的 broker 会试着进行注册，但不会成功，因为 ZooKeeper 里面已经有一个相同 ID 的 broker。
• 在 broker 停机、出现分区或者长时间垃圾回收停顿时，broker 会从 ZooKeeper 上断开连接，此时 broker 在启动时创建的临时节点会从 ZooKeeper 中移除。监听 broker 列表的 Kafka 组件会被告知该 broker 已移除。
• 在关闭 broker 时，它对应的节点也会消失，不过它的 ID 会继续存在其他数据结构中，例如主题的副本列表中，副本列表复制我们下面再说。在完全关闭一个 broker 之后，如果使用相同的 ID 启动另一个全新的 broker，它会立刻加入集群，并拥有一个与旧 broker 相同的分区和主题。

Broker Controller 的作用

控制器的选举

控制器的作用

• 控制器相当于部门（集群）中的部门经理（broker controller），用于管理部门中的部门成员（broker）
• 控制器是所有 broker 的一个监视器，用于监控 broker 的上线和下线
• 在 broker 宕机后，控制器能够选举新的分区 Leader
• 控制器能够和 broker 新选取的 Leader 发送消息

• 主题管理 : Kafka Controller 可以帮助我们完成对 Kafka 主题创建、删除和增加分区的操作，简而言之就是对分区拥有最高行使权。

• 分区重分配: 分区重分配主要是指，kafka-reassign-partitions 脚本提供的对已有主题分区进行细粒度的分配功能。这部分功能也是控制器实现的。
• Prefered 领导者选举 : Preferred 领导者选举主要是 Kafka 为了避免部分 Broker 负载过重而提供的一种换 Leader 的方案。
• 集群成员管理: 主要管理 新增 broker、broker 关闭、broker 宕机
• 数据服务: 控制器的最后一大类工作，就是向其他 broker 提供数据服务。控制器上保存了最全的集群元数据信息，其他所有 broker 会定期接收控制器发来的元数据更新请求，从而更新其内存中的缓存数据。这些数据我们会在下面讨论

broker controller 数据存储

• broker 上的所有信息，包括 broker 中的所有分区，broker 所有分区副本，当前都有哪些运行中的 broker，哪些正在关闭中的 broker 。
• 所有主题信息，包括具体的分区信息，比如领导者副本是谁，ISR 集合中有哪些副本等。
• 所有涉及运维任务的分区。包括当前正在进行 Preferred 领导者选举以及分区重分配的分区列表。

broker controller 故障转移

broker controller 存在的问题

• controller 状态的更改由不同的监听器并罚执行，因此需要进行很复杂的同步，并且容易出错而且难以调试。
• 状态传播不同步，broker 可能在时间不确定的情况下出现多种状态，这会导致不必要的额外的数据丢失
• controller 控制器还会为主题删除创建额外的 I/O 线程，导致性能损耗
• controller 的多线程设计还会访问共享数据，我们知道，多线程访问共享数据是线程同步最麻烦的地方，为了保护数据安全性，控制器不得不在代码中大量使用ReentrantLock 同步机制，这就进一步拖慢了整个控制器的处理速度。

broker controller 内部设计原理

副本机制

Leader 副本

Follower 副本

• Kafka 中，Follower 副本也就是追随者副本是不对外提供服务的。这就是说，任何一个追随者副本都不能响应消费者和生产者的请求。所有的请求都是由领导者副本来处理。或者说，所有的请求都必须发送到 Leader 副本所在的 broker 中，Follower 副本只是用做数据拉取，采用异步拉取的方式，并写入到自己的提交日志中，从而实现与 Leader 的同步
• 当 Leader 副本所在的 broker 宕机后，Kafka 依托于 ZooKeeper 提供的监控功能能够实时感知到，并开启新一轮的选举，从追随者副本中选一个作为 Leader。如果宕机的 broker 重启完成后，该分区的副本会作为 Follower 重新加入。

• 能够立刻看到写入的消息，就是你使用生产者 API 成功向分区写入消息后，马上使用消费者就能读取刚才写入的消息
• 能够实现消息的幂等性，啥意思呢？就是对于生产者产生的消息，在消费者进行消费的时候，它每次都会看到消息存在，并不会存在消息不存在的情况

同步复制和异步复制

• producer 通知 ZooKeeper 识别领导者
• producer 向领导者写入消息
• 领导者收到消息后会把消息写入到本地 log
• 跟随者会从领导者那里拉取消息
• 跟随者向本地写入 log
• 跟随者向领导者发送写入成功的消息
• 领导者会收到所有的跟随者发送的消息
• 领导者向 producer 发送写入成功的消息

ISR

Unclean 领导者选举

Kafka 请求处理流程

响应式模型

• Request type （也就是 API Key）
• Request version（broker 可以处理不同版本的客户端请求，并根据客户版本做出不同的响应）
• Correlation ID --- 一个具有唯一性的数字，用于标示请求消息，同时也会出现在响应消息和错误日志中（用于诊断问题）
• Client ID --- 用于标示发送请求的客户端

请求类型

Kafka 重平衡流程

• 消费者订阅的任何主题发生变化
• 消费者数量发生变化
• 分区数量发生变化
• 如果你订阅了一个还尚未创建的主题，那么重平衡在该主题创建时发生。如果你订阅的主题发生删除那么也会发生重平衡
• 消费者被群组协调器认为是 DEAD 状态，这可能是由于消费者崩溃或者长时间处于运行状态下发生的，这意味着在配置合理时间的范围内，消费者没有向群组协调器发送任何心跳，这也会导致重平衡的发生。

在了解重平衡之前，你需要知道这两个角色

在了解重平衡之前，你需要知道状态机是什么

了解了这些状态的含义之后，下面我们用几条路径来表示一下消费者状态的轮转

重平衡流程

从消费者看重平衡

从协调者来看重平衡

• 新成员加入组
• 组成员主动离开
• 组成员崩溃离开
• 组成员提交位移

新成员加入组

组成员离开

组成员崩溃

重平衡时提交位移

性能

指针压缩

优化高阶内建

const charCodeAt = Function.prototype.call.bind(String.prototype.charCodeAt);

charCodeAt(string, 8);

string.charCodeAt(8);

JavaScript

可选链

// Error prone-version, could throw.const nameLength = db.user.name.length;// Less error-prone, but harder to read.let nameLength;if (db && db.user && db.user.name)  nameLength = db.user.name.length;

// Still checks for errors and is much more readable.const nameLength = db?.user?.name?.length;

null 合并

function Component(props) {  const enable = props.enabled || true;  // …}

function Component(props) {  const enable = props.enabled ?? true;  // …}

function Component(props) {  const enable = props?.enabled ?? true;  // …}

V8 应用程序接口

前言

面试问题

1. Java 里面有了 == 运算符，为什么还需要 equals ？

public boolean equals(Object obj) {
    return (this == obj);
}

@Override
public boolean equals(Object obj) {
    //重写逻辑
}

@Override
public boolean equals(Object obj) {
    return 品牌相等 && 尺寸相等 && 配置相等
}

2. equals相等 和 hashcode 相等问题

• 两个对象 equals 相等，那他们 hashCode 相等吗？
• 两个对象 hashCode 相等，那他们 equals 相等吗？

public native int hashCode();

继续查看该方法的注释，明确写明关于该方法的约束

3. 重写 equals 有哪些约束？

关于重写 equals 方法的约束，同样在该方法的注释中写的很清楚了，我在这里再说明一下:

4. 什么时候需要我们重写 hashCode？

public class Student {

    private String name;

    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}

Student student1 = new Student();
student1.setName("日拱一兵");
student1.setAge(18);

Student student2 = new Student();
student2.setName("日拱一兵");
student2.setAge(18);

System.out.println("student1.equals(student2)的结果是：" + student1.equals(student2));

Set<Student> students = new HashSet<Student>();
students.add(student1);
students.add(student2);
System.out.println("Student Set 集合长度是：" + students.size());

Map<Student, java.lang.String> map = new HashMap<Student, java.lang.String>();
map.put(student1, "student1");
map.put(student2, "student2");
System.out.println("Student Map 集合长度是：" + map.keySet().size());

student1.equals(student2)的结果是：true
Student Set 集合长度是：2
Student Map 集合长度是：2

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

student1.equals(student2)的结果是：true
Student Set 集合长度是：1
Student Map 集合长度是：1

• 如果你在使用 Lombok，不知道你是否注意到 Lombok 只有一个 @EqualsAndHashCode 注解，而没有拆分成 @Equals 和 @HashCode 两个注解，想了解更多 Lombok 的内容，也可以查看我之前写的文章 Lomok 使用详解
• 另外通过 IDE 快捷键生成重写方法时，你也会看到这两个方法放在一起，而不是像 getter 和 setter 那样分开

5. 重写 hashCode 为什么总有 31 这个数字？

public static int hashCode(Object a[]) {
    if (a == null)
        return 0;

    int result = 1;

    for (Object element : a)
        result = 31 * result + (element == null ? 0 : element.hashCode());

    return result;
}

private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
            new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);

@Override
public boolean equals(Object other) {
    if (this == other) {
        return true;
    }
    if (!(other instanceof MethodParameter)) {
        return false;
    }
    MethodParameter otherParam = (MethodParameter) other;
    return (this.parameterIndex == otherParam.parameterIndex && getMember().equals(otherParam.getMember()));
}

@Override
public int hashCode() {
    return (getMember().hashCode() * 31 + this.parameterIndex);
}

总结

灵魂追问

1. Thread 类就没有重写 equals 方法，你还知道哪些情况没必要重写 equals 方法吗？
2. 从上面 HandlerMethodArgumentResolverComposite 类中定义的 Map 成员变量，你注意到哪些知识点，比如 final，ConcurrentHashMap，初识容量，为什么要这样写？你能解释出原因吗？

{ configurable: true, enumerable: true, writable: true, value: app }

module.exports = serveStatic
function serveStatic (root, options) {
    return serveStatic(req,res,next) {
    ...
     if (path === '/' && originalUrl.pathname.substr(-1) !== '/') {
      path = ''
    }
    var stream = send(req, path, opts)
    stream.on('directory', onDirectory)
    if (setHeaders) {
      stream.on('headers', setHeaders)
    }
    if (fallthrough) {
      stream.on('file', function onFile () {
        forwardError = true
      })
    }
    stream.on('error', function error (err) {
      if (forwardError || !(err.statusCode < 500)) {
        next(err)
        return
      }
      next()
    })
    // pipe
    stream.pipe(res)
    }
}

 
function send (req, path, options) {
  return new SendStream(req, path, options)
}

function SendStream(){
  Stream.call(this)
  ../若干代码
}

SendStream.prototype.pipe = function pipe (res) {
  //..中间很多容错处理 头部处理等
   var path = decode(this.path)
   //若干代码
   this.sendFile(path)
}

 fs.stat(path, function onstat (err, stat) {
  if (err && err.code === 'ENOENT' && !extname(path) && path[path.length - 1] !== sep) {
    // not found, check extensions
    return next(err)
  }
  if (err) return self.onStatError(err)
  if (stat.isDirectory()) return self.redirect(path)
  self.emit('file', path, stat)
  self.send(path, stat)
})

https://github.com/JinJieTan/util-static-server

app.use = function use(fn) {
var offset = 0;
var path = '/';
var fns = flatten(slice.call(arguments, offset));
this.lazyrouter();
var router = this._router;

fns.forEach(function (fn) {
  router.use(path, function mounted_app(req, res, next) {
    var orig = req.app;
    fn.handle(req, res, function (err) {
      setPrototypeOf(req, orig.request)
      setPrototypeOf(res, orig.response)
      next(err);
    });
  });
  fn.emit('mount', this);
}, this);

return this;
};

app.lazyrouter = function lazyrouter() {
  if (!this._router) {
    this._router = new Router({
      caseSensitive: this.enabled('case sensitive routing'),
      strict: this.enabled('strict routing')
    });

    this._router.use(query(this.get('query parser fn')));
    this._router.use(middleware.init(this));
  }
};

function flattenForever (array, result) {
  for (var i = 0; i < array.length; i++) {
    var value = array[i]

    if (Array.isArray(value)) {
      flattenForever(value, result)
    } else {
      result.push(value)
    }
  }

  return result
}

app.handle = function handle(req, res, callback) {
  var router = this._router;

  // final handler
  var done = callback || finalhandler(req, res, {
    env: this.get('env'),
    onerror: logerror.bind(this)
  });
  // no routes
  if (!router) {
    debug('no routes defined on app');
    done();
    return;
  }

  router.handle(req, res, done);};

while (match !== true && idx < stack.length) {
  layer = stack[idx++];
  match = matchLayer(layer, path);
  route = layer.route;
  //...若干d代码
  trim_prefix(layer, layerError, layerPath, path);
   function trim_prefix(layer, layerError, layerPath, path) {
    if (layerPath.length !== 0) {
  // Validate path breaks on a path separator
  var c = path[layerPath.length]
  if (c && c !== '/' && c !== '.') return next(layerError)

  // Trim off the part of the url that matches the route
  // middleware (.use stuff) needs to have the path stripped
  debug('trim prefix (%s) from url %s', layerPath, req.url);
  removed = layerPath;
  req.url = protohost + req.url.substr(protohost.length + removed.length);

  // Ensure leading slash
  if (!protohost && req.url[0] !== '/') {
    req.url = '/' + req.url;
    slashAdded = true;
  }

  // Setup base URL (no trailing slash)
  req.baseUrl = parentUrl + (removed[removed.length - 1] === '/'
    ? removed.substring(0, removed.length - 1)
    : removed);
}

debug('%s %s : %s', layer.name, layerPath, req.originalUrl);

if (layerError) {
  layer.handle_error(layerError, req, res, next);
} else {
  layer.handle_request(req, res, next);
}
}
  
}

 Layer.prototype.handle_request = function handle(req, res, next) {
  var fn = this.handle;

  if (fn.length > 3) {
    // not a standard request handler
    return next();
  }

  try {
    fn(req, res, next);
  } catch (err) {
    next(err);
  }
};

if (isFinished(req)) {
  write()
  return
}

  function write () {
  // response body
  var body = createHtmlDocument(message)

  // response status
  res.statusCode = status
  res.statusMessage = statuses[status]

  // response headers
  setHeaders(res, headers)

  // security headers
  res.setHeader('Content-Security-Policy', "default-src 'none'")
  res.setHeader('X-Content-Type-Options', 'nosniff')

  // standard headers
  res.setHeader('Content-Type', 'text/html; charset=utf-8')
  res.setHeader('Content-Length', Buffer.byteLength(body, 'utf8'))

  if (req.method === 'HEAD') {
    res.end()
    return
  }
  res.end(body, 'utf8')
}

function isFinished(msg) {
  var socket = msg.socket
  if (typeof msg.finished === 'boolean') {
    // OutgoingMessage
    return Boolean(msg.finished || (socket && !socket.writable))
  }

  if (typeof msg.complete === 'boolean') {
    // IncomingMessage
    return Boolean(msg.upgrade || !socket || !socket.readable || (msg.complete && !msg.readable))
  }
  // don't know
  return undefined
}

 function createHtmlDocument (message) {
  var body = escapeHtml(message)
    .replace(NEWLINE_REGEXP, '<br>')
    .replace(DOUBLE_SPACE_REGEXP, ' &nbsp;')

  return '<!DOCTYPE html>\n' +
    '<html lang="en">\n' +
    '<head>\n' +
    '<meta charset="utf-8">\n' +
    '<title>Error</title>\n' +
    '</head>\n' +
    '<body>\n' +
    '<pre>' + body + '</pre>\n' +
    '</body>\n' +
    '</html>\n'
}

一、Code Review的好处

1、互相学习，彼此成就

2、知识共享，自动互备

3、统一风格，提升质量

二、推动Code Review落地执行

1、选定工具

• Gerrit

• GitLab家族

• Gerrit VS GitLab 综合对比

2、制定开发规范

• 工程规范（工程结构，分层方式及命名等等）
• 命名规范（接口、类、方法名、变量名等）
• 代码格式（括号、空格、换行、缩进等）
• 注释规范（规定必要的注释）
• 日志规范（合理的记录必要的日志）
• 各种推荐与不推荐的代码示例

3、制定流程规范

• 确定Code Review实施环节

• 制定角色行为规范

1. 控制提交Code Review的代码的粒度
2. 控制单次Code Review的时间
3. 提升Commit/MergeRequest描述的质量，减少沟通成本

3、分享与统计

• 定期分享

• 数据统计

1. Developer控制提交Code Review的粒度，或者控制每个Commit的粒度
2. Developer要准确清晰的描述所提交的代码
3. Reviewer&Approver要在规定时间内完成Code Review

1. 每人每周Code Review所消耗的时间
2. 每人每周被Code Review所消耗的平均时间
3. 超过规定时间的Code Review情况
4. 代码提交描述字数过少的情况
5. 等等（根据自己的需要来）

三、保证Code Review质量的关键

1、工程师对研发规范的认真学习

2、资深工程师的认真对待

四、备注

附录

• Java开发手册：https://github.com/alibaba/p3c
• 基于GitLab的CodeReview教程：https://ken.io/note/gitlab-co...
• Google代码风格指南：https://zh-google-styleguide....
• Jenkins+Sonar执行代码扫描：https://ken.io/note/jenkins-m...

Fetch API 不香吗？

fetch('https://example.org/foo', {
    method: 'POST',
    mode: 'cors',
    headers: {
        'content-type': 'application/json'
    },
    credentials: 'include',
    redirect: 'follow',
    body: JSON.stringify({ foo: 'bar' })
}).then(res => res.json()).then(...)

const res = await fetch('https://example.org/foo', { ... });
const data = await res.json();

Fetch API 真香吗？

1. 如何中断一个请求？XMLHttpRequest 对象上有一个 abort() 方法，调用这个方法即可中断一个请求。此外 XHR 还有 onabort 事件，可以监听请求的中断并做出响应。
   
2. 如何超时中断一个请求？XMLHttpRequest 对象上有一个 timeout 属性，为其赋值后若在指定时间请求还未完成，请求就会自动中断。此外 XHR 还有 ontimeout 事件，可以监听请求的超时中断并做出响应。
   
3. 如何获取请求的传输进度？
   在异步请求一个比较大的文件时，由于可能比较耗时，展示文件的下载进度在 UI 上会更友好。XMLHttpRequest 提供了 onprogress 事件，所以使用 XHR 可以很方便地实现这个功能。
   

   const xhr = new XMLHttpRequest();
   xhr.open('GET', '/foo');
   xhr.addEventListener('progress', (event) => {
       const { lengthComputable, loaded, total } = event;
       if (lengthComputable) {
           console.log(`Downloaded ${loaded} of ${total} (${(loaded / total * 100).toFixed(2)}%)`);
       } else {
           console.log(`Downloaded ${loaded}`);
       }
   });
   xhr.send();

const controller = new AbortController();
const { signal } = controller;
fetch('/foo', { signal }).then(...);
signal.onabort = () => { ... };
controller.abort();

Streams API 能做什么？

const input = fs.createReadStream(null, {
    fd, start, end, autoClose: false
});
const output = fs.createWriteStream(outputPath + name);
// 可以从流中直接读取数据
input.on('data', (chunk) => { ... });
// 或者直接将流引向另一个流
input.pipe(zlib.createInflateRaw()).pipe(output);

ReadableStream

• locked
• cancel()
• pipeThrough()
• pipeTo()
• tee()
• getReader()

从 ReadableStream 中读取数据

• closed
• cancel()
• read()
• releaseLock()

const reader = stream.getReader();
let bytesReceived = 0;
const processData = (result) => {
    if (result.done) {
        console.log(`complete, total size: ${bytesReceived}`);
        return;
    }
    const value = result.value; // Uint8Array
    const length = value.length;
    console.log(`got ${length} bytes data:`, value);
    bytesReceived += length;
    // 读取下一个文件片段，重复处理步骤
    return reader.read().then(processData);
};
reader.read().then(processData);

let total = null;
let loaded = 0;
const logProgress = (reader) => {
    return reader.read().then(({ value, done }) => {
        if (done) {
            console.log('Download completed');
            return;
        }
        loaded += value.length;
        if (total === null) {
            console.log(`Downloaded ${loaded}`);
        } else {
            console.log(`Downloaded ${loaded} of ${total} (${(loaded / total * 100).toFixed(2)}%)`);
        }
        return logProgress(reader);
    });
};
fetch('/foo').then((res) => {
    total = res.headers.get('content-length');
    return res.body.getReader();
}).then(logProgress);

let text = '';
const logProcess = (res) => {
    const reader = res.body.getReader();
    const decoder = new TextDecoder('utf-8');
    const push = ({ value, done }) => {
        if (done) return JSON.parse(text);
        text += decoder.decode(value, { stream: true });
        // ...
        return reader.read().then(push);
    };
    return reader.read().then(push);
};
fetch('/foo').then(logProgress).then((res) => { ... });

构造一个 ReadableStream

const stream = new ReadableStream({
    start(controller) {
        // start 方法会在实例创建时立刻执行，并传入一个流控制器
        controller.desiredSize
            // 填满队列所需字节数
        controller.close()
            // 关闭当前流
        controller.enqueue(chunk)
            // 将片段传入流的队列
        controller.error(reason)
            // 对流触发一个错误
    },
    pull(controller) {
        // 将会在流的队列没有满载时重复调用，直至其达到高水位线
    },
    cancel(reason) {
        // 将会在流将被取消时调用
    }
}, queuingStrategy); // { highWaterMark: 1 }

const response = new Response(source, init);

const logProgress = (res) => {
    const total = res.headers.get('content-length');
    let loaded = 0;
    const reader = res.body.getReader();
    const stream = new ReadableStream({
        start(controller) {
            const push = () => {
                reader.read().then(({ value, done }) => {
                    if (done) {
                        controller.close();
                        return;
                    }
                    loaded += value.length;
                    if (total === null) {
                        console.log(`Downloaded ${loaded}`);
                    } else {
                        console.log(`Downloaded ${loaded} of ${total} (${(loaded / total * 100).toFixed(2)}%)`);
                    }
                    controller.enqueue(value);
                    push();
                });
            };
            push();
        }
    });
    return new Response(stream, { headers: res.headers });
};
fetch('/foo').then(logProgress).then(res => res.json()).then((data) => { ... });

分流一个 ReadableStream

const logProgress = (res) => {
    const total = res.headers.get('content-length');
    let loaded = 0;
    const [progressStream, returnStream] = res.body.tee();
    const reader = progressStream.getReader();
    const log = () => {
        reader.read().then(({ value, done }) => {
            if (done) return;
            // 省略输出进度
            log();
        });
    };
    log();
    return new Response(returnStream, { headers: res.headers });
};
fetch('/foo').then(logProgress).then(res => res.json()).then((data) => { ... });

中断一个 ReadableStream

let aborter = null;
const abortHandler = (res) => {
    const reader = res.body.getReader();
    const stream = new ReadableStream({
        start(controller) {
            let aborted = false;
            const push = () => {
                reader.read().then(({ value, done }) => {
                    if (done) {
                        if (!aborted) controller.close();
                        return;
                    }
                    controller.enqueue(value);
                    push();
                });
            };
            aborter = () => {
                reader.cancel();
                controller.error(new Error('Fetch aborted'));
                aborted = true;
            };
            push();
        }
    });
    return new Response(stream, { headers: res.headers });
};
fetch('/foo').then(abortHandler).then(res => res.json()).then((data) => { ... });
aborter();

流的锁机制

let aborter = null;
const abortHandler = (res) => {
    aborter = () => res.body.cancel();
    return res;
};
fetch('/foo').then(abortHandler).then(res => res.json()).then((data) => { ... });
aborter();

TypeError: Failed to execute 'cancel' on 'ReadableStream': Cannot cancel a locked stream

let aborter = null;
const abortHandler = (res) => {
    aborter = () => res.body.getReader().cancel();
    return res;
};
fetch('/foo').then(abortHandler).then(res => res.json()).then((data) => { ... });
aborter();

TypeError: Failed to execute 'getReader' on 'ReadableStream': ReadableStreamReader constructor can only accept readable streams that are not yet locked to a reader

reader.closed.then(() => {
  console.log('reader closed');
});
reader.releaseLock();

示例：断点续传

1. 发起请求
2. 从响应头中拿到 Content-Length 属性
3. 在响应过程中拿到正在下载的数据
4. 终止下载
5. 重新下载，但是此时根据已经拿到的数据设置 Range 请求头
6. 重复步骤 3-5，直至下载完成
7. 下载完成，将已拿到的数据拼接成完整的

let chunks = [];
const xhr = new XMLHttpRequest();
xhr.open('GET', '/foo');
xhr.responseType = 'moz-chunked-arraybuffer';
xhr.addEventListener('progress', (event) => {
    chunks.push(xhr.response);
});
xhr.addEventListener('abort', () => {
    const blob = new Blob(chunks);
});
xhr.send();

const chunks = [];
let length = 0;
const chunkCache = (res) => {
    const reader = res.body.getReader();
    const stream = new ReadableStream({
        start(controller) {
            const push = () => {
                reader.read().then(({ value, done }) => {
                    if (done) {
                        let chunk;
                        while (chunk = chunks.shift()) {
                            controller.enqueue(chunk);
                        }
                        controller.close();
                        return;
                    }
                    chunks.push(value);
                    length += value.length;
                    push();
                });
            };
            push();
        }
    });
    return new Response(stream, { headers: res.headers });
};
const controller = new AbortController();
fetch('/foo', {
    headers: {
        'Range': `bytes=${length}-`
    },
    signal: controller.signal
}).then(chunkCache).then(...);
// 请求中断后再次执行上述 fetch() 方法

管道

var reader = response.body
    .pipeThrough(new TextDecoder()).getReader();
reader.read().then(result => {
    // result.value will be a string
});

fetch('/index.html').then((res) => {
    const decoder = new TextDecoderStream('gbk', { ignoreBOM: true });
    const textStream = res.body.pipeThrough(decoder);
    const reader = textStream.getReader();
    const findMatched = () => reader.read().then(({ value, done }) => {
        if (done) {
            return false;
        }
        if (value.indexOf('It works!') >= 0) {
            reader.cancel();
            return true;
        }
        return findMatched();
    });
    return findMatched();
}).then((isMatched) => { ... });

const encoder = new VideoEncoder({
    input: 'gif', output: 'h264'
});
const media = new MediaStream();
const video = document.createElement('video');
fetch('/sample.gif').then((res) => {
    response.body.pipeThrough(encoder).pipeTo(media);
    video.srcObject = media;
});

WritableStream

• locked
• abort()
• getWriter()

• closed
• desiredSize
• ready
• abort()
• close()
• write()
• releaseLock()

const stream = new WritableStream({
    start(controller) {
        // 将会在对象创建时立刻执行，并传入一个流控制器
        controller.error(reason)
            // 对流抛出一个错误
    },
    write(chunk, controller) {
        // 将会在一个新的数据片段写入时调用，可以获取到写入的片段
    },
    close(controller) {
        // 将会在流写入完成时调用
    },
    abort(reason) {
        // 将会在流强制关闭时调用，此时流会进入一个错误状态，不能再写入
    }
}, queuingStrategy); // { highWaterMark: 1 }

const stream = new WritableStream({
    write(chunk) {
        return new Promise((resolve) => {
            console.log('got chunk:', chunk);
            // 在这里对数据进行处理
            resolve();
        });
    },
    close() {
        console.log('stream closed');
    },
    abort() {
        console.log('stream aborted');
    }
});
const writer = stream.getWriter();
// 将数据逐一写入 stream
data.forEach((chunk) => {
    // 待前一个数据写入完成后再写入
    writer.ready.then(() => {
        writer.write(chunk);
    });
});
// 在关闭 writer 前先保证所有的数据已经被写入
writer.ready.then(() => {
    writer.close();
});

TransformStream

• readable: ReadableStream
• writable: WritableStream

const stream = new TransformStream({
    start(controller) {
        // 将会在对象创建时立刻执行，并传入一个流控制器
        controller.desiredSize
            // 填满队列所需字节数
        controller.enqueue(chunk)
            // 向可读取的一端传入数据片段
        controller.error(reason)
            // 同时向可读取与可写入的两侧触发一个错误
        controller.terminate()
            // 关闭可读取的一侧，同时向可写入的一侧触发错误
    },
    transform(chunk, controller) {
        // 将会在一个新的数据片段传入可写入的一侧时调用
    },
    flush(controller) {
        // 当可写入的一端得到的所有的片段完全传入 transform() 方法处理后，在可写入的一端即将关闭时调用
    }
}, queuingStrategy); // { highWaterMark: 1 }

const tes = {
    start() { this.encoder = new TextEncoder() },
    transform(chunk, controller) {
        controller.enqueue(this.encoder.encode(chunk))
    }
}
let _jstes_wm = new WeakMap(); /* info holder */
class JSTextEncoderStream extends TransformStream {
    constructor() {
        let t = { ...tes }
        super(t)
        _jstes_wm.set(this, t)
    }
    get encoding() { return _jstes_wm.get(this).encoder.encoding }
}

const tes = {
    start() {
        this.decoder = new TextDecoder(this.encoding, this.options)
    },
    transform(chunk, controller) {
        controller.enqueue(this.decoder.decode(chunk))
    }
}
let _jstds_wm = new WeakMap(); /* info holder */
class JSTextDecoderStream extends TransformStream {
    constructor(encoding = 'utf-8', { ...options } = {}) {
        let t = { ...tds, encoding, options }
        super(t)
        _jstes_wm.set(this, t)
    }
    get encoding() { return _jstds_wm.get(this).decoder.encoding }
    get fatal() { return _jstds_wm.get(this).decoder.fatal }
    get ignoreBOM() { return _jstds_wm.get(this).decoder.ignoreBOM }
}

在 Service Worker 中使用 Streams API

控制请求的响应速度

addEventListener('fetch', (fetchEvent) => {
    fetchEvent.clientId
    fetchEvent.preloadResponse
    fetchEvent.replacesClientId
    fetchEvent.resultingClientId
    fetchEvent.request
        // 浏览器原本需要发起请求的 Request 对象
    fetchEvent.respondWith()
        // 阻止浏览器默认的 fetch 请求处理，自己提供一个返回结果的 Promise
    fetchEvent.waitUntil()
        // 延长事件的生命周期，例如在返回数据后再做一些事情
});

globalThis.addEventListener('fetch', (event) => {
    event.respondWith((async () => {
        const response = await fetch(event.request);
        const { body } = response;
        const reader = body.getReader();
        const stream = new ReadableStream({
            start(controller) {
                const sleep = time => new Promise(resolve => setTimeout(resolve, time));
                const pushSlowly = () => {
                    reader.read().then(async ({ value, done }) => {
                        if (done) {
                            controller.close();
                            return;
                        }
                        const length = value.length;
                        for (let i = 0; i < length; i++) {
                            await sleep(30);
                            controller.enqueue(value.slice(i, i + 1));
                        }
                        pushSlowly();
                    });
                };
                pushSlowly();
            }
        });
        return new Response(stream, { headers: response.headers });
    })());
});

下载一个前端生成的大文件

const a = document.createElement('a');
const blob = new Blob(chunk, options);
const url = URL.createObjectURL(blob);
a.href = url;
a.download = 'filename';
const event = new MouseEvent('click');
a.dispatchEvent(event);
setTimeout(() => {
    URL.revokeObjectURL(url);
    if (blob.close) blob.close();
}, 1e3);

总结

• Streams API 允许我们以流的形式实时处理数据，每次只需要处理数据的一小部分
• 可以使用 pipeTo()、pipeThrough() 方法方便地将多个流连接起来
• ReadableStream 是可读取的流，WritableStream 是可写入的流，TransformStream 是既可写入又可读取的流
• Fetch API 的返回值是一个 Response 对象，它的 body 属性是一个 ReadableStream
• 借助 Streams API 我们可以实现中断 fetch 请求或者计算 fetch 请求的下载速度，甚至可以直接对返回的数据进行修改
• 我们学习了如何构造一个流，并将其作为 fetch 请求的返回值
• 在 Service Worker 里也可以使用 Streams API，使用 onfetch 事件可以监听所有的请求，并对请求进行篡改
• 顺带了解了如何中断一个 fetch 请求，使用 download 属性下载文件，Blob 对象，MessageChannel 双向通信……

参考答案

1. 试试看将上面的 fetch 请求用原生 XMLHttpRequest 实现一遍，看看你还记得多少知识？
   

   const xhr = new XMLHttpRequest();
   xhr.open('POST', 'https://example.org/foo');
   xhr.setRequestHeader('Content-Type', 'application/json');
   xhr.responseType = 'json';
   xhr.withCredentials = true;
   xhr.addEventListener('load', () => {
       const data = xhr.response;
       // ...
   });
   xhr.send(JSON.stringify({ foo: 'bar' }))

   在使用 XHR 初始化请求时会有较多的配置项，虽然这些配置项可以发出更复杂的请求，但是或许你也注意到了，发送请求时既有方法的调用，又有参数的赋值，看下来还是不如 Fetch API 那样直接传入一个对象作为请求参数那么简洁的。此外，如果需要兼容比较早的不支持 XHR 2 的浏览器，你可能还需要改成使用 onreadystatechange 事件并手动解析 xhr.responseText。
   
2. 如果我们调用了流的 tee() 方法得到了两个流，但我们只读取了其中一个流，另一个流在之后读取，会发生什么吗？
   使用 tee() 方法分流出来的两个流之间是相互独立的，所以被读取的流会实时读取到传递的数据，过一段时间读取另一个流，拿到的数据也是完全一样的。不过由于另一个流没有被读取，克隆的数据可能会被浏览器放在一个缓冲区里，即便后续被读取可能也无法被浏览器即时 GC。
   

   const file = document.querySelector('input[type="file"]').files[0];
   const stream = file.stream();
   const readStream = (stream) => {
       let total = 0;
       const reader = stream.getReader();
       const read = () => reader.read().then(({ value, done }) => {
           if (done) return;
           total += value.length;
           console.log(total);
           read();
       });
       read();
   };
   
   const [s1, s2] = stream.tee();
   readStream(s1);
   readStream(s2);

   例如在上述代码中选择一个 200MB 的文件，然后直接调用 readStream(stream)，在 Chrome 浏览器下没有较大的内存起伏；如果调用 stream.tee() 后得到两个流 s1 和 s2，如果同时对两个流调用 readStream() 方法，在 Chrome 浏览器下同样没有较大的内存起伏，最终输出的文件大小也是一致的；如果只对 s1 调用的话，会发现执行结束后 Chrome 浏览器下内存占用多了约 200MB，此时再对 s2 调用，最终得到的文件大小虽然一致，但是内存并没有及时被 GC 回收，此时浏览器的内存占用还是之前的 200MB。
   可能你会好奇，之前我们尝试过使用 tee() 方法得到两段流，一个流直接返回另一个流用于输出下载进度，会有这样的资源占用问题吗？会不会出现两个流速度不一致的情况？其实计算下载进度的代码并不会非常耗时，数据计算完成后也不会再有多余的引用，浏览器可以迅速 GC。此外计算的速度是大于网络传输本身的速度的，所以并不会造成瓶颈，可以认为两个流最终的速度是基本一样的。
   
3. 如果不调用 controller.error() 抛出错误强制中断流，而是继续之前的流程调用 controller.close() 关闭流，会发生什么事吗？从上面的结果来看，当我们调用 aborter() 方法时，请求被成功中止了。不过如果不调用 controller.error() 这个方法抛出错误的话，由于我们主动关闭了 fetch 请求返回的流，循环调用的 reader.read() 方法会接收到 done = true，然后会调用 controller.close()。这就意味着这个流是被正常关闭的，此时 Promise 链的后续操作不会被中断，而是会收到已经传输的不完整数据。
   如果没有做特殊的逻辑处理的话，直接返回不完整的数据可能会导致错误。不过如果能好好利用上的话，或许可以做更多事情——比如断点续传的另一种实现，这就有点像 Firefox 的私有实现 moz-chunked-arraybuffer 了。
   
4. StreamSaver.js 在不支持 TransformStream 的浏览器下其实是可以正常工作的，这是怎么实现的呢？记得我们之前提到过构造一个 ReadableSteam 然后包装成 Response 对象返回的实现吧？我们最终的目的是需要构造一个流并返回给浏览器，这样传入的数据可以立即被下载，并且没有多余引用而迅速 GC。所以对于不支持 TransformStream 甚至 WritableStream 的浏览器，StreamSaver.js 封装了一个模拟 WritableStream 实现的 polyfill。当 polyfill 得到数据时，会将得到的数据片段通过 MessageChannel 直接传递给 Service Worker。Service Worker 发现这不是一个流，会构造出一个 ReadableStream 实例，并将数据通过 controller.enqueue() 方法传递进流。后续的流程估计你已经猜到了，和当前的后续流程是一样的，同样是生成一个随机 URL 并跳转，然后返回封装了这个流的 Response 对象。
   事实上，现在的 Firefox Send 就使用了这样的实现，当用户下载文件时会发出请求，Service Worker 接收到下载请求后会建立真实的 fetch 请求连接服务器，将返回的数据实时解密后直接下载到用户的设备上。这样的直观效果是，浏览器直接下载了文件，文件会显示在浏览器的下载列表中，同时页面上还会有下载进度：
   
   

参考资料

• MDN web docs - Streams API
• Streams Living Standard
• 2016 - the year of web streams

JavaScript 是什么？

2019 年 JavaScript 现状调查报告

No time to read? Here's our no.1 pick when it comes to the best overall POS system in the market:

🏁 Our pick:

Although it’s not the most advanced CRM software on the market, HubSpot has managed to establish itself as the overall best CRM software option for numerous businesses and sales teams. Instead of focusing on enterprise-level capabilities, HubSpot’s secret has been maintaining a favorable balance between customer relationship management features, ease of use, and pricing.
The cost here is zero. Hubspot CRM then goes ahead and sets itself apart from the rest of the free CRM software solutions by providing full customer relationship management experience. Small to medium-sized businesses get the benefit of using an intuitive well-designed user interface, coupled with tools for sales management, lead management, pipeline management, sales tracking, marketing campaign management, social media marketing, plus AI insights.

Setting up the system is extremely simple even for beginners, and you can bet HubSpot CRM will handle a huge chunk of the CRM processes for you. All the customer interactions, for instance, are tracked automatically to generate valuable insights.
You can also expect to have your sales and marketing processes integrated and streamlined accordingly through the HubSpot CRM platform.
Overall rating: 10/10

💰 Budget pick:

In all honesty, HubSpot CRM happens to also be a serious contender for our best CRM software budget pick since it’s completely free of charge. But, considering we’ve selected it as the ultimate best CRM software, I guess we could choose the next best budget option.
And yes, just like Hubspot CRM, Zoho CRM is an elegantly-designed solution that allows you to run automated campaigns for free.
Now, to be more precise, Zoho CRM is a lightweight CRM software that’s specially optimized for marketing and sales automation, help desk and customer support, reporting and customer analytics, inventory management, etc. You get to run campaigns on channels like email, social media, live chat, phone calls, web conferencing, and self-service customer portals.

That said, the Zoho CRM free plan offers a document library, plus tools for team collaboration, web forms, marketing automation, basic reports and analytics, workflow management, product customization, and sales force automation. You can leverage it as a team of up to three members.
Then if you choose to upgrade your package, Zoho CRM grants you advanced CRM functionalities on a budget. You can, for example, take advantage of its gamification feature to gamify your entire sales framework and subsequently reward high-performing workers.
Overall rating: 7/10

• Sugar Market:

WASM WTF

WebAssembly and Docker

If WASM+WASI existed in 2008, we wouldn't have needed to created Docker. That's how important it is. Webassembly on the server is the future of computing. A standardized system interface was the missing link. Let's hope WASI is up to the task! https://t.co/wnXQg4kwa4
— Solomon Hykes (@solomonstre) March 27, 2019
After all that explanation of what WebAssembly is and how it works in the browser, here we are throwing you a curveball: You can also run WebAssembly on the server. This may feel strange, but if Wasm is so awesome, why let the browsers have all the fun? Whereas Node.js solved this problem by bringing the JavaScript runtime environment to the server, Wasm built an environment and invited everyone to it.
The character that allows this plot twist is the WebAssembly System Interface (WASI). Because WebAssembly provides a fast and scalable way to run the same code across multiple machines, developers are pushing it beyond the browser, and that’s where the WASI comes in: Code outside of a browser needs a way to talk to the system. WebAssembly doesn’t need to talk to any single operating system, but rather, it needs an interface that lets it talk to a “conceptual operating system.” By introducing this layer of abstraction, WebAssembly can be run across all different OSs.
All of this probably doesn’t mean that Docker is doomed, but it might mean that Wasm containers start becoming increasingly common. Perhaps this layer of abstraction will allow Wasm to be the ubiquitous runtime for all applications regardless of language. Time will tell, but the foundations of this approach have been inviting promising solutions.

Atwood’s Law

It may seem odd at first glance, but I would like to close this article with some meditations on how WebAssembly relates to Atwood’s Law. The quote known as “Atwood’s Law” goes like this:
“Any application that can be written in JavaScript, will eventually be written in JavaScript.”
— Jeff Atwood, Author, Entrepreneur, Cofounder of StackOverflow
There are many misinterpretations of this quote, and however tempting it might be for snarky JavaScript developers to tout it as some evidence of divine authority, the actual source text was called “The Principle of Least Power” and it did not prophesize the subjugation of the internet by Angular, React, or Vue overlords. The actual message of that article was one that resonates deeply within all of us — within life itself, I would posit. In a nutshell, it says that there is real power in achieving more with less. This is as true with the evolution of life as it is with the internet and the formats that it uses to exchange data. If you can represent your data more simply, with less effort, then that representation will have an advantage over more complex and heady alternatives.
This is the subtle river that has been running through this saga from the beginning, and that’s where this story’s Rhinegold treasure truly lies: All of technology, WebAssembly included, attempts to disperse information, and its chances of survival are helped or hindered by how efficiently it succeeds at that task.
When viewed in this way, Atwood’s Law and its mention of JavaScript can be understood to mean a vote not necessarily for JavaScript explicitly, but an acknowledgement that simpler solutions will always prevail. JavaScript owes its ubiquity not to an arsenal of powerful things that it can do, but specifically to the calculated limitations that dictate what it cannot do. WebAssembly may be the next step forward in that evolution because it offers to do less than other alternatives. It even stores its instructions in plain old readable text instead of as unreadable binary, and this seems very much in keeping with the expansive goal of sharing data in the simplest means possible. It embodies the triumph of the bazaar over the cathedral, because exposing everything to the widest possible audience ensures that it can evolve, and this philosophy is to thank for much of Wasm’s success to date.
Nobody can guarantee the future, and it is absolutely possible that Wasm won’t fulfill all of our expectations. JavaScript founder Brendan Eich, who has been an advocate for WebAssembly, is concerned that conflicting competitive interests might end up splintering the Wasm project. Time will tell, of course, but WebAssembly is a technology that I definitely want to keep watching.

Need to generate Docx, HTML, RTF or PDF documents in your Xamarin App? Telerik UI for Xamarin has a solution for you - our new WordsProcessing library.

It has never been easier to generate, modify and export a document in your mobile application! The RadWordsProcessing library enables you to easily generate and export documents in various formats, including:

• PDF
• Docx
• RTF
• HTML
• Plain text

The library comes in handy all cases where document or PDF generation is needed, such as PDF invoice generation for an e-commerce app, or to serve the user with a filled application form in Docx format.

With our document processing library you can quickly access each element in a given document, modify, remove it or add a new one. Additionally, the generated content can be saved as a stream, file, or send to the client browser.

In this blog post, we will familiarize you with the RadWordsProcessing structure and the features it provides.

WordsProcessing Structure

• Sections that can be customized using the properties exposed by the corresponding class. Headers, footers, and watermarks for a section can be customized as well.
• Paragraphs whose properties and methods enable you to change its collection of inlines and appearance.
• Tables equipped with an API, allowing you to easily insert, edit, and remove from the document. Their rows, cells, appearance, and content are also flexible, with various changes and manipulations possible.
• Inlines, including Runs, Images, as well as inline and floating images, Fields, Breaks, Bookmarks, Hyperlinks and Tab stops.
• Styles: the documents processing model includes a repository of Style objects containing sets of character, paragraph or table style properties. Additionally, you can create custom styles and use them throughout the document.

Supported Formats

In addition to the smooth creation, modification, import and export of files, RadWordsProcessing gives you the ability to convert between variety of formats - convert Docx to PDF or HTML to Docx in your Xamarin apps. The currently supported formats are Docx, RTF, HTML, PDF and plain text.

Features

• Inline & floating images: support for inline & floating images for the most popular formats, including support for working with image properties such as Source, Size, Flip, Rotation, AspectRatio, etc.
• Bookmarks & hyperlinks: enable your users to easily navigate a document with bookmarks and hyperlinks
• Watermarks: identify document status or mark it as confidential with watermarks
• Create documents in different file formats, for example:
  
  
  

private RadFlowDocument CreateDocument()
{
    RadFlowDocument document = new RadFlowDocument();
    RadFlowDocumentEditor editor = new RadFlowDocumentEditor(document);
    editor.ParagraphFormatting.TextAlignment.LocalValue = Alignment.Justified;
 
    editor.InsertLine("Dear Telerik User,");
    editor.InsertText("We’re happy to introduce the new Telerik RadWordsProcessing component for Xamarin Forms. High performance library that enables you to read, write and manipulate documents in DOCX, RTF and plain text format. The document model is independent from UI and ");
    Run run = editor.InsertText("does not require");
    run.Underline.Pattern = UnderlinePattern.Single;
    editor.InsertLine(" Microsoft Office.");
 
    editor.InsertText("The current community preview version comes with full rich-text capabilities including ");
    editor.InsertText("bold, ").FontWeight = FontWeights.Bold;
    editor.InsertText("italic, ").FontStyle = FontStyles.Italic;
    editor.InsertText("underline,").Underline.Pattern = UnderlinePattern.Single;
    editor.InsertText(" font sizes and ").FontSize = 20;
    editor.InsertText("colors ").ForegroundColor = GreenColor;
 
    editor.InsertLine("as well as text alignment and indentation. Other options include tables, hyperlinks, inline and floating images. Even more sweetness is added by the built-in styles and themes.");
 
    editor.InsertText("Here at Telerik we strive to provide the best services possible and fulfill all needs you as a customer may have. We would appreciate any feedback you send our way through the ");
    editor.InsertHyperlink("public forums", "http://www.telerik.com/forums", false, "Telerik Forums");
    editor.InsertLine(" or support ticketing system.");
 
    editor.InsertLine("We hope you’ll enjoy RadWordsProcessing as much as we do. Happy coding!");
    editor.InsertParagraph();
    editor.InsertText("Kind regards,");
 
    return document;
}

• Easily Find all instances of a string And Replace it with another through the ReplaceText() method of the RadFlowDocumentEditor.

private void ReplaceText()
{
    if (string.IsNullOrEmpty(this.findWhat))
    {
        return;
    }
 
    RadFlowDocumentEditor editor = new RadFlowDocumentEditor(this.replacedDocument);
 
    if (this.useRegex)
    {
        Regex oldTextRegex = new Regex(this.findWhat);
        editor.ReplaceText(oldTextRegex, this.replaceWith);
    }
    else
    {
        editor.ReplaceText(this.findWhat, this.replaceWith, this.matchCase, this.matchWholeWord);
    }
}

The full demo project can be found here.

• Insert Documents at a Specific Position using the InsertDocument() method.
• Merge two RadFlowDocument instance using the Merge() method.

RadFlowDocument target = new RadFlowDocument();
RadFlowDocument source = new RadFlowDocument();
//...
// target will contain merged content and styles.
target.Merge(source);

Tell Us What You Think

Happy coding with our controls!

Blazor has entered official support phase and so applications will need to be ready for the world. This includes localization and translation into multiple languages - the ability to convert the text in the UI so that all your users can understand them in their native (or preferred) language.
As of the 2.4.0 release, the Telerik UI for Blazor components let you do that by exposing a service interface that you can implement to return the desired localized texts. If you don’t provide such a service implementation, we quietly fall back to the default English texts. 

We follow the general .NET Core approach for relying on Dependency Injection (DI) to get work done in an app. There are so many ways you can implement this service, that I won’t even try to guess – databases, static resources (such as resx files), generated static classes, third party services, you name it – the world is your oyster and you can do whatever you need and reuse whatever you already have.
We will take a closer look at one approach that may let you reuse a lot of code/logic, especially if you have created other (Telerik-based) .NET apps. It is .resx files. In UI for Blazor we use the same resources as the UI for ASP.NET MVC suite, so you can carry over translations you’ve already made and use tools you’re already familiar with.

The WASM Flavor

Finally, Code Time

• Code examples: https://github.com/telerik/blazor-ui/tree/master/common/localization/
• Documentation for more details on the localization service implementation: https://docs.telerik.com/blazor-ui/globalization/localization

What’s Next

Download Telerik UI for Blazor 2.4.0

新闻

1. 首期Feature Drops未提及的Pixel新功能：支持双频GNSS 定位更快更精准
   
2. Android 开源项目 (AOSP) 代码搜索工具正式发布
   
3. 当搜索某些短语时 Android版Google Search应用会崩溃
   
4. [图]P站2019年度报告：48%的Android流量来自于Pie
   
5. Google Translate离线翻译功能获大量改进：准确率提升12%
   
6. [图]Play商城被爆“隐藏BUG”：搜索结果中不显示对应App和游戏
   

视频

1. 用 Android vitals 提升稳定性与性能表现 | AndroidDevSummit 中文字幕视频
   
2. 在应用里使用分享功能 | AndroidDevSummit 中文字幕视频
   
3. 在 Android 上测试协程 | AndroidDevSummit 中文字幕视频
   
4. Demystify the Data in Android Studio Profilers
   

教程

1. Systrace 基础知识 - CPU
   

作者：伍迪.艾伦

作者：黑井千次

深阅读

• How quickly your users can interact with visual content after your site renders it
• How quickly your users get a response after interacting with visual content
• How code-level elements of your site affect user interaction across device type, browser, or browser version

新鲜货

设计

产品及其它

项目背景：

编译提速目标：

1. 全量编译从15min+降至3min内
2. 低侵入性，尽量不改造工程结构，保证工程稳定
3. 方案稳定可靠，不能影响业务同学的开发效率
4. 易于扩展，可以灵活对接各种已有系统
5. 方便管理，尽可能保证低廉的学习理解成本，方便大家上手

全量编译提效核心——EnjoyDependence

Chicago Police Department confirmed that 13 people had been shot on Sunday morning.

• This article was modified on 22 December to reflect more accurately the shooting statistics for Chicago.