TypeScript - (七) TypeScript中泛型的使用以及一个迷你版Map

简介:

     泛型是一种约定，可以约定类的类型以及类中属性，方法返回值，参数等类型。

内容:

     根据编写一个泛型Map了解泛型的作用和使用。

1.定义一个泛型的Node

// <>里的K,和V就是我们定义的泛型，至于是什么类型，我们也不知道。但是当创建之后，key和value对应的类型就会更改成定义的类型。
class Node<K,V>{
    key:K;
    value:V;
}

2.定义一个泛型的Map

export class Map<K,V> {
    
    // 声明一个Node的泛型数组，Node的类型根据HashMap的类型变化
    private nodes:Node<K,V> [] = [];
    
    // 新增到nodes里
    public put(key:K,value:V){
        let node:Node<K,V> = this.getNodeByKey(key);
        // null 就是当前数组里没有这个key的元素，反之就是有
        if(null == node){
            node = new Node<K, V>();
            node.key = key;
            node.value = value;
            this.nodes[this.nodes.length] = node;
        }else{
            // 当前nodes的value覆盖
            this.nodes[this.nodes.indexOf(node)].value = value;
        }
    }
    
    // 查询全部数据
    public queryAll(){
        return this.nodes;
    };
    
    // 根据key判断是否包含元素
    public containKey(key:K): boolean{
        let node = this.getNodeByKey(key);
        if(null == node){
            return false;
        }
        return true;
    };
    
    // 根据value获取key
    public getKey(value:V){
        let node = this.getNodeByValue(value);
        return node.key;
    }
    
    // 根据key获取value
    public getValue(key:K){
        let node = this.getNodeByKey(key);
        return node.value;
    }
    
    // 根据key获取node
    private getNodeByKey(key:K): Node<K,V>{
        let currentNodes = this.nodes;
        for (let i = 0; i < currentNodes.length; i++) {
            if(currentNodes[i].key == key){
                return currentNodes[i];
            }
        }
        return null;
    };
    
    // 根据value查询node
    private getNodeByValue(value:V): Node<K,V>{
        let currentNodes = this.nodes;
        for (let i = 0; i < currentNodes.length; i++) {
            if(currentNodes[i].value == value){
                return currentNodes[i];
            }
        }
        return null;
    };
    
    // 根据key移除元素
    public remove(key:K){
        let node = this.getNodeByKey(key);
        if(null != node){
            this.nodes.splice(this.nodes.indexOf(node),1);
        }
    }
    
}

3. 测试下效果

import {Map} from "./Map";

// 定义了一个key是string,value是string的map
let map: Map<string,string> = new Map();
// 新增一个key = a ,value = ccc
map.put('a','ccc');
// 打印新增一个key = a  [ Node { key: 'a', value: 'ccc' } ]
console.log('新增一个key = a ', map.queryAll());

// 新增一个value不是string的试试
// Error:(11, 13) TS2345: Argument of type '1' is not assignable to parameter of type 'string'.
// 果然，value不是string的，直接提示错误了。
// map.put('a',1);
// 新增一个key不是string的试试
// Error:(15, 9) TS2345: Argument of type '1' is not assignable to parameter of type 'string'.
// 果然，key，直接提示错误了。
// map.put(1,'ss');

// 新增一个key = a ,value = bbbb
map.put('a','bbbb');
// 打印 新增一个key = a ,value = bbbb, 看看是不是覆盖掉了:  [ Node { key: 'a', value: 'bbbb' } ]
console.log('新增一个key = a ,value = bbbb, 看看是不是覆盖掉了: ', map.queryAll());

// 新增一个key = b ,value =bbbccb
map.put('b','bbbccb');
/*
* 打印:  新增一个key = b ,value =bbbccb:  [ Node { key: 'a', value: 'bbbb' },
        Node { key: 'b', value: 'bbbccb' } ]
* */
console.log('新增一个key = b ,value =bbbccb: ', map.queryAll());

// 是否包含key
// 是否包含key=a: true
console.log('是否包含key=a:', map.containKey('a'));
//  是否包含key=c: false
console.log('是否包含key=c:', map.containKey('c'));

// 移除key = a
map.remove('a');
// 移除一个存在的key = a之后: [ Node { key: 'b', value: 'bbbccb' } ]
console.log('移除一个存在的key = a之后:',map.queryAll());

// 尝试移除一个不存在的key
map.remove('c');
//  尝试移除一个不存在的key=c之后: [ Node { key: 'b', value: 'bbbccb' } ]
console.log('尝试移除一个不存在的key=c之后:',map.queryAll());

 附:

    系列链接: https://blog.csdn.net/qq_36255237/article/category/9168635

    GitHub的Demo地址: https://github.com/chenrui123456/TypeScript-Demo