nodejs之koa学习笔记(1)

矫情吗；* 2022-06-13 13:36 211阅读 0赞

**新特性**  
1. classes - 各种 ‘类’，再也无需用 CoffeeScript 的语法糖写类了  
2. typed arrays － 类型数组  
3. generators - 未来的.js 代码中将有无数生成器，不学一点就看不懂 JS 代码了哦  
4. collections － 集合、映射、弱集合、弱映射  
5. arrow functions － 箭向函数  
6. block scoping － 使用 let 、const 作用域，块辖域  
7. template strings － 模板字串  
8. promises － 用标准化了的方法进行延迟和异步计算  
9. symbols － 唯一的、不可修改的数据

**classes**

先声明后使用，未知可随意

class Qinzhao{ 
    
    }
    或者
    var Qinzhao = class{ 
    
    }

构造函数

1 var Ptthon = class{               
      2         constructor(height,width){   
      3                 this.height = height;
      4                 this.width=width;
      5         }
      6                                                                                                                                                          
      7 }

set以及get的方法

继承extends:

class Animal{ 
      2        
      3         constructor(name){
      4                 this.name = name;
      5         }
      6        
      7        
      8         say(){
      9         
     10         console.log(this.name+" try to say something...");
     11         }
     12 }      
     13        
     14 class Dog extends Animal{ 
     15        
     16         say(){
     17                 super.say();
     18                 console.log(this.name+"barking...");
     19         }
     20 }
     21  
     22  
     23 var dog = new Dog;
     24 dog.name="dog ";
     25  
     26 console.log(dog.say());

**静态成员函数**

class Point(){
      constructor(x, y){
          this.x = x;
          this.y = y;
      }
      static distance(a, b){
          constant dx = a.x - b.x;
          constant dy = a.y - b.y;
          return Math.sqrt(dx * dx + dy * dy);
      }
    }

**Generator的基本写法**

function* helloworld(){
        yield "Hello";
        return "World!";
    }
    
    func = helloworld();
    func.next();//return { value: 'Hello', done: false }
    func.next();//return { value: 'World!', done: true }
    func.next();//return { value: '', done: true }

next方法参数
    
    function* f(){                                                                                                                                           
      2         for (var i = 0;true;i++){
      3                 var reset = yield i;
      4                 if(reset){
      5                         i = -1;
      6                 }
      7         }
      8  
      9 }
     10  
     11 var g = f();
     12  
     13  
     14 console.log(g.next());
     15 console.log(g.next());
     16 console.log(g.next());
     17 console.log(g.next());
     18 console.log(g.next());
     19 console.log(g.next());
     20 console.log(g.next());
     21 console.log(g.next());
     22 console.log(g.next());
     23 console.log(g.next());
     24 console.log(g.next());
     25 console.log(g.next());
     26 console.log(g.next());
     27 console.log(g.next());

for…of循环

function* loopThroughInt(){ 
        for (let index = 0; index < 100; index++){
            yield index;
        }
        return 100;
    }
    for (let v of loopThroughInt()){
        console.log(v); //output 0...99
    }

如果在Generator函数内部需要调用另外一个Generator函数，那么对目标函数的调用就需要使用yield\*，以下是一个简单的例子

function* objects(){ 
      2         yield "cat";
      3         yield "dog";
      4         yield "duck";
      5  
      6  
      7  
      8 }
      9        
     10        
     11 function* say(){ 
     12        
     13         yield* objects();
     14         yield " say node js";
     15 }      
     16        
     17 var f =say();
     18        
     19 console.log(f.next());
     20 console.log(f.next());
     21 console.log(f.next());
     22 console.log(f.next());
     23 console.log(f.next());
     { value: 'cat', done: false }
    { value: 'dog', done: false }
    { value: 'duck', done: false }
    { value: ' say node js', done: false }
    { value: undefined, done: true }

创建Symbol实例

# 第一种方法直接使用Symbol构造函数
    var s1 = Symbol();
    # 为创建的Symbol对象指定一个名称
    var s2 = Symbol("test");
    # 使用这种方法，每次创建出来的Symbol对象都是不一样的
    # console.log(s2==s3)将返回false
    var s3 = Symbol("test");
    
    # 第二种方法，使用Symbol.for方法来创建Symbol实例
    # 使用Symbol.for方法来创建一个Symbol实例的时候，
    # 系统首先会在一个全局的注册表中查找是否有相同Key名称的Symbol被创建了，如果找到，就返回已经存在的对象
    # 否则，将创建一个全新的对象
    s1 = Symbol.for("test")
    s2 = Symbol.for("test")
    console.log(s1 == s2) //will return true
    console.log(s1 == s3) // will return false，因为s3是通过Symbol调用产生的

因为Symbol对象不是一个字符串，所以原先的Object.getOwnPropertyNames()方法并不会返回它们，你需要使用专门的Object.getOwnPropertySymbols()方法来访问它们。

ar a = {};
    var s1 = Symbol("test");
    var s2 = Symbol("testfunc");
    a[s1] = "hello world!";
    a[s2] = function(){ 
        console.log("Test function");
    };
    //below code will return []
    console.log(Object.getOwnPropertyNames(a));
    //below code will return [Symbol(test), Symbol(testfunc)]
    console.log(Object.getOwnPropertySymbols(a));

引用实例2 — 消除魔术字符串

# 引入Symbol前的代码
    # 在这个代码中es, ch就是魔术字符串
    # 当你在调用这个函数的时候，必须确保输入的参数是一个有效的魔术值
    function getHello(country){ 
        switch(country){
            case "es":
                return "Holla";
            case "ch":
                return "你好";
            default:
                return "Hello";
        }
    }
    console.log(getHello("es"));
    console.log(getHello("ch"));

# 引入Symbol之后的代码
    # 在这个代码中es, ch不再是一个具体的字符串
    # 因此不管在COUNTRY_CODE中如何修改es, ch的定义，调用方的代码都不需要修改
    const COUNTRY_CODE= {
        es: Symbol(),
        ch: Symbol()
    }
    function getHello(country){ 
        switch(country){
            case COUNTRY_CODE.es:
                return "Holla";
            case COUNTRY_CODE.ch:
                return "你好"
            default:
                return "Hello"
        }
    }
    console.log(getHello(COUNTRY_CODE.es));
    console.log(getHello(COUNTRY_CODE.ch));

Symbol.unscopables

# when Test has no Symbol.unscopables
    class Test{ 
    saySomething() { return "abc"; }
    }
    var saySomething = function() { return "123"; }
    with(Test.prototype){
    saySomething(); // return "abc"
    }
    # when Test has Symbole.unscopables
    class Test{ 
    saySomething() { return "abc"; }
    get [Symbol.unscopables] {
        return {
       saySomething: true};
    }
    }
    with(Test.prototype){
    saySomething(); // now return "123"
    }