先说结论： 第一段代码中 A = 1 试图修改自由变量 A的值，但没有生效！

(function A() {
    console.log(A); // [Function A]
    A = 1;
    console.log(window.A); // undefined
    console.log(A); // [Function A]
}())

这是一个立即执行的函数表达式（Immediately-invoked function expression, IIFE），更特殊的，该函数表达式是一个具名函数表达式（Named function expression, NFE）。

NFE 有两个好玩的特性：

• 作为函数名的标识符（在这里是 A ）只能从函数体内部访问，在函数外部访问不到 (IE9+)。（kangax
  有一篇 博客 详细讨论了 NFE 以及 IE6~8 的 JScript bug，推荐阅读！） ES5 Section
  13 特别提及了这一点：

The Identifier in a FunctionExpression can be referenced from inside the FunctionExpression's FunctionBody to allow the function to call itself recursively. However, unlike in a FunctionDeclaration, the Identifier in a FunctionExpression cannot be referenced from and does not affect the scope enclosing the FunctionExpression.

• 绑定为函数名的标识符（在这里是A）不能再绑定为其它值，即该标识符绑定是不可更改的（immutable），所以在 NFE 函数体内对 A 重新赋值是无效的。ES5 Section 13 详细描述了创建 NFE 的机制：

The production FunctionExpression : function Identifier (
FormalParameterListopt ) { FunctionBody }
is evaluated as follows:

1. Let funcEnv be the result of calling NewDeclarativeEnvironment passing the running execution context’s Lexical Environment as the argument
2. Let envRec be funcEnv’s environment record.
3. Call the CreateImmutableBinding concrete method of envRec passing the String value of Identifier as the argument.
4. Let closure be the result of creating a new Function object as specified in 13.2 with parameters specified by FormalParameterListopt and body specified by FunctionBody. Pass in funcEnv as the Scope. Pass in true as the Strict flag if the FunctionExpression is contained in strict code or if its FunctionBody is strict code.
5. Call the InitializeImmutableBinding concrete method of envRec passing the String value of Identifier and closure as the arguments.
6. Return closure.

注意步骤 3 和 5，分别调用了 createImmutableBinding 和 InitializeImmutableBinding 内部方法，创建的是不可更改的绑定。

要理解这两个特性，最重要的是搞清楚标识符 A的绑定记录保存在哪里。让我们问自己几个问题：

1. 标识符 A 与 该 NFE 是什么关系？ 两层关系：首先，该 NFE 的 name 属性是 字符串 'A'；更重要的是，A是该 NFE 的一个自由变量。在函数体内部，我们引用了 A，但 A 既不是该 NFE 的形参，又不是它的局部变量，那它不是自由变量是什么！解析自由变量，要从函数的 [[scope]] 内部属性所保存的词法环境 (Lexical Environment) 中查找变量的绑定记录。

2. 标识符 A 保存在全局执行环境（Global Execution Context）的词法环境(Lexical Environment)中吗？ 答案是否。如果你仔细看过 ES5 Section 13 这一节，会发现创建 NFE 比创建 匿名函数表达式 （Anonymous Function Expression, AFE） 和 函数声明 (Function Declaration) 的过程要复杂得多：

对于 创建 AFE 和 FD, 步骤是这样：

The production
FunctionDeclaration : function Identifier ( FormalParameterListopt ) { FunctionBody }
is instantiated as follows during Declaration Binding instantiation (10.5):

Return the result of creating a new Function object as specified in 13.2 with parameters specified by FormalParameterListopt, and body specified by FunctionBody. Pass in the VariableEnvironment of the running execution context as the Scope. Pass in true as the Strict flag if the FunctionDeclaration is contained in strict code or if its FunctionBody is strict code.

The production
FunctionExpression : function ( FormalParameterListopt ) { FunctionBody }
is evaluated as follows:

Return the result of creating a new Function object as specified in 13.2 with parameters specified by FormalParameterListopt and body specified by FunctionBody. Pass in the LexicalEnvironment of the running execution context as the Scope. Pass in true as the Strict flag if the FunctionExpression is contained in strict code or if its FunctionBody is strict code.

比创建 NFE 简单多了有木有？那为么子创建 NFE 要搞得那么复杂呢？就是为了实现 NFE 的只能从函数内部访问A，而不能从外部访问这一特性！咋实现的？ 创建 NFE 时，创建了一个专门的词法环境用于保存 A 的绑定记录(见上面步骤 1~3)！对于 NFE, 有如下关系：

A.[[scope]] --->  Lexical Environment {'environment record': {A: function ...}, outer: --}----> Lexical Environment of Global Context {'environment record': {...}, outer --}---> null

可见，A 的绑定记录不在全局执行上下文的词法环境中，故不能从外部访问！

如果你使用了Apollo系列框架，则apollo-upload-client是可以实现文件上传的，具体可见此包的readme

第一点，你match的是_id，正常情况下应该是只会查询到一条文档的，怎么会返回多条呢？

假设你的_id是非unique的，你想要给每条文档新增一个index属性，这也是很奇怪的想法，因为如果还有后续的聚合操作的话，文档顺序总是改变的，加index完全没必要；如果没有后续聚合了，那么返回的文档进行一次map操作手动添加即可

1. 你的t.students.push(s);写法是不对的，应该是t.students.push(s._id);
2. 把1000个学生给老师，那就是循环1000次，然后在进行数据库的存储操作，可以采用异步方式进行避免堵塞

你的第三个代码块里写的是user.comparePassword(...)，这里的user是你在第二个代码块里导出的mongoose.model，问题就在这了。方法是需要添加给schema而不是model，具体如下：

下面是方法定义：

newSchema.methods.comparePassword_thisIsDoc = function(cb) {
    // 这里的this指代的是`Document`对象
}
newSchema.statics.comparePassword_thisIsModel = function(pwd, cb) {
    // 这里的this指代的是`Model`对象
}

下面是具体使用：

user.find({email: ctx.request.body.email}, (err, res) => {
    const doc = res[0];
    if(doc!==null) {
        // 下面是使用查询到的document判断
        doc.comparePassword_thisIsDoc(cb)
        // 下面是使用model判断
        // user.comparePassword_thisIsModel(pwd, cb);
    }
      return res
}); 

PS: 你上述写的let results = await user.find(...)是无效的写法，正确应该这么写：

// 同步式写法
let results = await user.find(...).exec();

// 回调式写法 [err总位于参数第一位]
user.find(..., function(err, docs) {
    
})

typescript作为类型语言，就是为了可以提供尽可能严格的类型检测，所以办法无非就是你上述提到的两种：要不判断，要不加!

typescript写起来真的会让人感觉很麻烦，这也算是typescript的优点带来的“缺点”吧，但为了高可维护可预测的代码，我们必须选择妥协，不然还是用js写吧。

除了使用上面的亲提到的 采用中间件来处理 express路由过程中的error外，为了避免仍有未捕获到的异常导致应用垮掉，可考虑加入以下的全局错误监听：

process.on('uncaughtException', (err) => {
    console.log('这里有个未捕获的同步错误', err);
})
process.on('unhandledRejection', (err) => {
    console.log('这里有个未处理的异步错误', err)
})

Formlat组件可改写为如下：

import React from 'react';
class Formlat extends React.Component{
    render (){
        return (
            <div style={this.props.style}>
                ...
            </div>
        )
    }
}
export default Formlat;

使用方法：

<Formlat style={{background: 'blue'}} />
<Formlat />

你的代码是使用class的方式，思想是一样的，把传递style变成传递class就ok啦！