ARTS 第二十周（2019.8.12~2019.8.18）

[catcuts]

ARTS 第二十周（2019.8.12~2019.8.18）

• Algorithm 反转链表
• Review 软件开发遇到瓶颈，问问如下三个问题
• Tip 一种支持多语言的错误基类实现
• Share [极客专栏] 分布式系统架构的冰与火

Algorithm 反转链表

题目：

反转链表

代码（迭代法）

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    if (!head) return head;  // 对空链表直接返回
    let lastNode = null,
        curNode = head;
    while (true) {
        // 记住当前节点的下一个节点
        let nextNode = curNode.next;
        // 设置当前节点的下一个节点为上一个节点
        curNode.next = lastNode;
        // 设置上一个节点为当前节点，预备循环下一轮
        lastNode = curNode;
        // 如果下一个节点为 null 则停止循环，因为已经到了最后一个节点
        if (!nextNode) break;
        // 否则设置当前节点为下一个节点，开始循环下一轮
        curNode = nextNode;
    }
    return curNode;  // 最后返回当前节点，即最后一个节点
};

代码（递归法）

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head, beforeHead) {
    // 对空节点直接返回
    if (!head) return head || beforeHead || null;

    // 记住当前节点的下一个节点
    let afterHead = head.next;

    // 设置当前节点的下一个节点为前一个节点
    head.next = beforeHead;

    // 如果当前节点的下一个节点为 null 则停止递归，因为这是最后一个节点
    if (!afterHead) return head;
    // 记住下一个节点
    let next = afterHead.next;
    // 设置下一个节点
    afterHead.next = head;

    // 递归
    return reverseList(next, afterHead);
};

思路：
思路见注释。
一次迭代/递归，故时间复杂度 = O(n)；
不占用额外空间，故空间复杂度 = O(1)。

对比：
与高分对比：
本代码运行 27 个测试用例花费约 80ms，平均一个测试用例约 0.3ms；
高分代码运行 27 个测试用例花费约 80ms，平均一个测试用例约 0.3ms。

思路一致代码如下：

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    if (head === null || head.next == null) return head
    let pre = head
    let cur = head.next
    let next = null
    while (pre && cur) {
        next = cur.next
        cur.next = pre
        pre = cur
        cur = next
    }
    if (cur === null) {
        head.next = null
    }
    head = pre
    return head
};

Review 软件开发遇到瓶颈，问问如下三个问题

阅读：
Three Questions to Ask When Figuring Out Software Development Bottlenecks

点评：
速度缓慢，延期交付，这意味着软件开发的进度遇到了瓶颈。

从表明看原因在于，超额的工作量以及不与之相匹配的产出。

故常见解决之道是，增加人手——但这往往只会让问题更严重。

为了寻求根本原因，我们可以通过提出三个问题并尝试解决：

1. 开发人员都在做什么？
2. 程序架构的特性如何？
3. 谁是决策真正制定者？

首先是明确开发人员的职责及其边界，这不仅能减小开发者之间的依赖，而且有助于定量评估工作和跟踪进度。

然后是评估程序架构的特性是否合理：

1. 数据结构是否具备可成长性？
2. 开发和运行的配置是否过于繁琐，自动化程度如何？
   太僵硬或太灵活的程序架构都有可能拖累开发速度，如果评估程序架构不合理，则该推倒重来还是要推倒重来。

最后是确定项目开发中各项决策的拍板人，目的是让开发者在明确的需求和明确的技术点或路线上进行开发，减小不确定性和犹豫带来的进度拖延。

Tip 一种支持多语言的错误基类实现

/*
    一种支持多语言的错误基类实现

    const verror = new VError('error doing {x}: {e}');

    // get original message
    verror.message

    // get translated message
    verror.message.translate(Function translator)
    or
    verror.message.translate(String language)
 */
function format(string, params) {
    if (typeof params === "object") {
        for (let name in params) {
            string = string.replace(new RegExp(`{${name}}`, 'g'), params[name]);
        }
    } else {
        let i = 0;
        for (let match of string.match(ParamRegExp) || []) {
            if (i < arguments.length) {
                string = string.replace(match, arguments[i]);
                i += 1;
            }
        }
    }
    return string;
}

class Message extends String {
    constructor(t, ...args) {
        super(...args);
        this.translate = t;
    }
}

class VError extends Error {
    constructor(message, params = {}) {
        super();
        this.rootTranslations = VError.translations;
        this.translations = this.constructor.translations;
        this.template = message;
        this.params = params;
        if (!params.hasOwnProperty('message')) params.message = message;
        this.message = new Message(this.translate.bind(this), format(this.template, this.params));;
    }

    static get translations() {  // 定义翻译
        return {
            'zh-cn': {
                // 'TEST': '测试'
            }
        };
    }

    translate(t) {
        if (typeof t === 'function'/*翻译函数*/) {
            return format(
                t(this.template),  // 翻译后的模板
                this._translatedParamsByTranslator(t)  // 翻译后的参数
            );
        } else if (typeof t === 'string'/*指定语言*/) {
            t = t.toLowerCase();
            return format(
                this._translated(this.template, t),  // 翻译后的模板
                this._translatedParamsByTranslation(t)  // 翻译后的参数
            );
        } else {
            return format(
                this.template,  // 原始模板
                this.params  // 原始参数
            );
        }
    }

    _translated(text, language) {
        if (text.translate) return text.translate(language);
        let rootTranslations = this.rootTranslations[language], translations = this.translations[language];
        if (!rootTranslations && !translations) return text;
        return (translations || {})[text] || (rootTranslations || {})[text] || text;
    }

    _translatedParamsByTranslator(translator) {
        let _params = {}, params = this.params;
        for (let key in params) _params[key] = translator(params[key]);
        return _params;
    }

    _translatedParamsByTranslation(language) {
        let _params = {}, params = this.params;
        for (let key in params) _params[key] = this._translated(params[key], language);
        return _params;
    }
}

module.exports = VError;

Share [极客专栏] 分布式系统架构的冰与火

分享一篇极客“左耳听风”专栏文章（据说可限10位免费阅读哦）
21 | 分布式系统架构的冰与火