TypeScript 哈希表

已于 2024-03-05 07:09:11 修改
阅读量819 收藏 20
点赞数 17
分类专栏： 数据结构与算法 文章标签： typescript 散列表 哈希 数据结构 前端
于 2024-03-05 07:08:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43220213/article/details/136467697
版权

文章目录

概念

哈希表通常底层实现是一个数组，它的特点就是弥补了数组查找、插入、删除慢的缺点。哈希表它就是最终存放数据的数组。但我们平时说哈希表，确切说是一种操作数组的方式，一种算法。

哈希表巧妙的地方就在于转换了思维角度。
之前搜索一个东西，我们不知道它位置，所有要一个一个找，为啥不知道位置？因为放的时候是随机放的。而哈希表是放的时候不允许随机放，直接就规定了位置，那去找的时候，不就按位置直接去拿即可。比如你知道苹果一定放第三个格子，现在你要找苹果，就会直奔第三个格子，而不是从第一个格子找起。

哈希化

那怎么确定苹果就是放第三个格子呢？
这就需要哈希函数来映射了，这个过程称为哈希化。

image.png

理想情况三个水果，算出来就放在三个对应的格子里，但现实很骨感。哈希函数的映射算法没这么完美，会出现只有三个水果，但算出来一个水果要放在第1000个格子的情况，因此中间会出现很多空格子浪费了。优化哈希算法，使之不要这么浪费是衡量哈希算法优劣的一个重要指标。

冲突

那会不会出现哈希函数设计不好，算出来苹果和梨都被放到第三个格子的情况呢？
存在的，通常有两种方式解决这个问题。

链地址法

可以在第三个格子里保存一个链表或数组，然后把苹果和梨都挂在链表上。这种方式称为链地址法。当然挂一个数组也可以，如果重复的数据实在太多，还可以挂一个二叉树。

套娃的这个链表或者数组，我们通常称为打水的吊桶 bucket。

有个误区要注意：设计哈希表的时候要明白，存储过程不是这个位置本是没内容的，然后放进一个内容，直到此处出现了冲突，这个位置才开始挂一个桶，然后新旧内容一起都放桶里。而是哈希表生成的时候，确实没内容，为 undefined，但第一个元素放进去的时候，此处就会生成一个桶存放数据，不用等到发生冲突才开始换成桶。

image.png

开放地址法

还可以让重复的元素去后面找空白的位置坐下，后面还有空位，老弟往后走。这是开发地址法。

至于怎么找后面的空位，又有三种方式：

  1. 线性探测：一个一个往后找
  2. 二次探测：也是线性探测，但是不是一个一个找，而是步长为 2，2、4、8… 跳着找。
  3. 再次hash

经过前人的验证，总的来说，链地址法效率是更高的，所以链地址法也用的最多。

装填因子（loadFactor）

装填因子是数据量与哈希表数组容量的比值，也就是哈希表装的满不满。
整这么个概念，主要是为哈希表的性能优化做一个指标以及作为是否自动扩容的依据。

我们知道完美的哈希表，装填因子应该是 1，三个水果，就放三个格子，没浪费没冲突。

但冲突和浪费都不可避免，开发地址法装填因子不会超过1，虽然它很好的利用了格子，可是多了找新地址的计算。
链地址法装填因子可能超过 1，装的数据比哈希表数组长度还多，因为它可以在里面挂一个超长的链。当然挂太多，效率肯定不高。

  • 一般装填因子小于 0.25 需要缩容，大于 0.75 需要扩容。

效率对比

下面的等式显示了线性探测时，探测序列§和填装因子(L)的关系。公式来自于Knuth(算法分析领域的专家，现代计算机的先驱人物)。

线性探测二次探测和再哈希化链地址法

经过上面的比较我们可以发现，链地址法相对来说效率是好于开放地址法的。

所以在真实开发中，使用链地址法的情况较多。因为它不会因为添加了某元素后性能急剧下降。比如在Java的HashMap中使用的就是链地址法。

哈希函数

说白了哈希化，也就是哈希函数的功能就是将字符串转成对应的数组下标，也就是数字。

那具体怎么做呢？

字符串转数字算法 —— 幂的连乘

现在我们需要设计一种方案，可以将单词转成适当的下标值：
 其实计算机中有很多的编码方案就是用数字代替单词的字符。就是字符编码。(常见的字符编码？)
 比如ASCII编码：a是97，b是98，依次类推122代表z
 我们也可以设计一个自己的编码系统，比如a是1，b是2，c是3，依次类推，z是26。
 当然我们可以加上空格用0代替，就是27个字符(不考虑大写问题)
 但是，有了编码系统后，一个单词如何转成数字呢？

方案一：数字相加
 一种转换单词的简单方案就是把单词每个字符的编码求和。
 例如单词cats转成数字：3+1+20+19=43，那么43就作为cats单词的下标存在数组中。

◼ 问题：按照这种方案有一个很明显的问题就是很多单词最终的下标可能都是43。
 比如was/tin/give/tend/moan/tick等等。
 我们知道数组中一个下标值位置只能存储一个数据
 如果存入后来的数据，必然会造成数据的覆盖。
 一个下标存储这么多单词显然是不合理的。
 虽然后面的方案也会出现，但是要尽量避免。

方案二：幂的连乘
 现在，我们想通过一种算法，让cats转成数字后不那么普通。
 数字相加的方案就有些过于普通了。
 有一种方案就是使用幂的连乘，什么是幂的连乘呢？
 其实我们平时使用的大于10的数字，可以用一种幂的连乘来表示它的唯一性：比如：7654 = 710³+610²+510+4
 我们的单词也可以使用这种方案来表示：比如 cats = 327³+127²+2027+17= 60337
 这样得到的数字可以基本保证它的唯一性，不会和别的单词重复。

两种方案总结：
 第一种方案(把数字相加求和)产生的数组下标太少。
 第二种方案(与27的幂相乘求和)产生的数组下标又太多。

第一种方案缺陷无解，第二种方案，我们可以采用数字压缩算法缓解。

压缩数字范围 —— 取余

除以几，就能把数字压缩到[0，这个数字 - 1]的范围。比如除以 10，就压缩到了 [0, 9] 的范围。

优秀哈希算法的优点

两点：

  1. 快速的计算：计算 hashcode 要快。
    • 提高速度的一个办法就是让哈希函数中尽量少的有乘法和除法。因为它们的性能是比较低的。
  2. 分布均匀，也就是冲突少。

前面我们已经知道，幂的连乘 和 取余操作实现哈希算法。但这还不够，还可以继续优化。

快速计算：霍纳法则

霍纳法则可以减少多项式中的乘法，转换成加法。

做法就是一直在提取公因式，提到不能再提为止。

以 abc 为例：
原本公式：a的编码 * 31^2 + b的编码 * 31^1 + c的编码 * 31^0

公因式就是幂底：31

霍纳法则：

  1. 31*(a*31 + b) + c
  2. 31*(31*(31*0 + a) + b) + c

上面提取到第二次已经无法再提了，用语言描述就是 hashcode 从 0 开始与幂底的积再加上字符串第一个字符的编码的和作为下一次的 hashcode，继续乘幂底与第二个字符的编码的和再次作为 hashcode 进入下一轮循环，直到加完所有的字符。

可以见到一个循环即可完成霍纳算法对多项式的计算。

const POWER_BASE = 31;
let hashcode = 0;
// 霍纳法则，计算hash值
for (let i = 0; i < key.length; i++) {
  hashcode = hashcode * POWER_BASE + key.charCodeAt(i);
}

霍纳法则

image.png

均匀分布 —— 质数

在设计哈希表时，我们已经有办法处理映射到相同下标值的情况：链地址法或者开放地址法。但是无论哪种方案，为了提供效率，最好的情况还是让数据在哈希表中均匀分布。

因此，我们需要在使用常量的地方，尽量使用质数。

质数的使用：

  • 哈希表的长度。
  • N次幂的底数(我们之前使用的是27)

为什么他们使用质数，会让哈希表分布更加均匀呢？
 质数和其他数相乘的结果相比于其他数字更容易产生唯一性的结果，减少哈希冲突。
 Java中的N次幂的底数选择的是31，是经过长期观察分布结果得出的；

Java 中的 HashMap

◼ Java中的哈希表采用的是链地址法。

◼ HashMap的初始长度是16，每次自动扩展，长度必须是2的次幂。
 这是为了服务于从Key映射到index的算法。60000000 % 100 = 数字。下标值

◼ HashMap中为了提高效率，采用了位运算的方式。
 HashMap中index的计算公式：index = HashCode(Key) & (Length - 1)
 比如计算book的hashcode，结果为十进制的3029737，二进制的101110001110101110 1001
 假定HashMap长度是默认的16，计算Length-1的结果为十进制的15，二进制的1111
 把以上两个结果做与运算，101110001110101110 1001 & 1111 = 1001，十进制是9，所以 index=9

为什么 Java hashmap 中使用的数组长度不是质数，因为它使用了位运算，而不是取模。

N次幂的底数

◼ 这里采用质数的原因是为了产生的数据不按照某种规律递增。
 比如我们这里有一组数据是按照4进行递增的：0 4 8 12 16，将其映射到长度为8的哈希表中。
 它们的位置是多少呢？0 - 4 - 0 - 4，依次类推。
 如果我们哈希表本身不是质数，而我们递增的数量可以使用质数，比如5，那么 0 5 10 15 20
 它们的位置是多少呢？0 - 5 - 2 - 7 - 4，依次类推。也可以尽量让数据均匀的分布。
 我们之前使用的是27，这次可以使用一个接近的数，比如31/37/41等等。一个比较常用的数是31或37。

◼ 总之，质数是一个非常神奇的数字。

◼ 这里建议两处都使用质数：
 哈希表中数组的长度。
 N次幂的底数。

实现

哈希函数

/**
 * 哈希函数, 将key映射成index
 * @param key 转换的key
 * @param capacity 容量 (数组的长度)
 * @returns index 索引值
 */
export function hashFun(key: string, capacity: number): number {
    const POWER_BASE = 31;
    let hashcode = 0;
    // 霍纳法则，计算hash值
    for (let i = 0; i < key.length; i++) {
        hashcode = hashcode * POWER_BASE + key.charCodeAt(i);
    }
    // 取余压缩范围
    return hashcode % capacity;
}

哈希表

export class HashTable<T = any> {
    // 哈希主表数组，采用拉链法，元素本是链表，这里以数组代替，并且元素类型为元祖，便于将 key 和 value 都存一起。
    // 简言之数组元素还是数组，这个元素数组里元素为元祖类型。
    private store: [string, T][][] = [];

    // 装填因子：自动扩容依据
    
    // 容量
    private capacity: number = 7;
    // 装载数
    private count: number = 0;


    // 哈希函数
    private hashFun(key: string, capacity: number): number {
        const POWER_BASE = 31;
        let hashcode = 0;
        // 霍纳法则，计算hash值
        for (let i = 0; i < key.length; i++) {
            hashcode = hashcode * POWER_BASE + key.charCodeAt(i);
        }
        // 取余压缩范围
        return hashcode % capacity;
    }
}

插入/更新操作

哈希表的插入和修改操作是同一个函数：
 因为，当使用者传入一个<Key，Value>时
 如果原来不存该key，那么就是插入操作。
 如果已经存在该key，那么就是修改操作。

// 插入/更新
put(key: string, value: T) {
    const index = this.hashFun(key, this.capacity);
    // 获取对应下标的数组
    const bucket = this.store[index];

    if (!bucket) {
        // 插入
        this.store[index] = [[key, value]];
        this.count++;
    } else {
        for (let i = 0; i < bucket.length; i++) {
            const tuple = bucket[i];
            if (tuple[0] === key) {
                // 更新
                tuple[1] = value;
                return;
            }
        }
      	// 插入
        bucket.push([key, value]);
        this.count++;
    }
}

获取

// 获取值
get(key: string): T | null {
    const index = this.hashFun(key, this.capacity);
    const bucket = this.store[index];

    if (bucket) {
        for (let i = 0; i < bucket.length; i++) {
            const tuple = bucket[i];
            if (tuple[0] === key) {
                return tuple[1];
            }
        }
    }
    return null;
}

删除

// 删除
remove(key: string): T | null {
    const index = this.hashFun(key, this.capacity);
    const bucket = this.store[index];

    if (bucket) {
        for (let i = 0; i < bucket.length; i++) {
            const tuple = bucket[i];
            if (tuple[0] === key) {
                bucket.splice(i, 1);
                this.count--;
                return tuple[1];
            }
        }
    }
    return null;
}

扩容、缩容

修改容量有两步操作：

  1. 修改容量
  2. 把之前的数据再次哈希化计算一次，放进新数组
private MIN_CAPACITY = 7;
private MIN_LOAD_FACTOR = 0.25;
private MAX_LOAD_FACTOR = 0.75;
private capacity: number = this.MIN_CAPACITY;

private resize(newCapacity: number) {
    
    const oldStore = this.store;

    // 1. 构建新数组
    this.store = [];
    this.capacity = newCapacity < this.MIN_CAPACITY ? this.MIN_CAPACITY : newCapacity;
    this.count = 0;

    // 2. 旧数据哈希化放入新数组
    oldStore.forEach(bucket => {
        if (bucket) {
            for (let i = 0; i < bucket.length; i++) {
                const tuple = bucket[i];
                this.put(tuple[0], tuple[1]);
            }
        }
    });
}

修改插入和删除方法：

// 插入/更新
put(key: string, value: T): void {
    const index = this.hashFun(key, this.capacity);
    // 获取对应下标的数组
    const bucket = this.store[index];

    if (!bucket) {
        // 插入
        this.store[index] = [[key, value]];
        this.count++;
    } else {
        for (let i = 0; i < bucket.length; i++) {
            const tuple = bucket[i];
            if (tuple[0] === key) {
                // 更新
                tuple[1] = value;
                return;
            }
        }
        bucket.push([key, value]);
        this.count++;
    }

    // 自动扩容
    if (this.loadFactor > this.MAX_LOAD_FACTOR) this.resize(this.capacity * 2);
}

// 删除
remove(key: string): T | null {
    const index = this.hashFun(key, this.capacity);
    const bucket = this.store[index];

    if (bucket) {
        for (let i = 0; i < bucket.length; i++) {
            const tuple = bucket[i];
            if (tuple[0] === key) {
                bucket.splice(i, 1);
                this.count--;
                // 缩容
                if (this.loadFactor < this.MIN_LOAD_FACTOR && this.capacity > this.MIN_CAPACITY) {
                    this.resize(Math.floor(this.capacity / 2));
                }
                return tuple[1];
            }
        }
    }
    return null;
}

但现在有个问题，扩容和缩容都是按照 2 倍来做的，那容量不就不是质数了吗，这不利于保证元素均匀分布呀？
是的，因此容量不能简单设为 2 倍，而是应该通过一个算法找附近的质数。

判断一个数是否为质数

质数表示大于1的自然数中，只能被1和自己整除的数。
因此让这个数字 n 从 2 开始除，一直除到小于根号 n 的最大整数即可。如果除尽了，说明 n 不是质数。

怎么判断除没除尽？
用取余，有余数说明没除尽。

/**
 * 判断数字是否为质数
 * @param num 
 * @returns boolean
 */
export function isPrime(num: number) {
    if (num < 2) return false;
    for (let i = 2; i <= Math.sqrt(num); i++) {
        if (num % i === 0) return false;
    }
    return true;
}

保证容量为质数，并且当缩容后的容量小于最小容量时，保持最小容量：

// 判断质数
private isPrime(num: number) {
    if (num < 2) return false;
    for (let i = 2; i <= Math.sqrt(num); i++) {
        if (num % i === 0) return false;
    }
    return true;
}

// 获取质数
private getPrime(num: number) {
    while (!this.isPrime(num)) {
        num++;
    }
    return num;
}

private resize(newCapacity: number) {
    const primeCapacity = this.getPrime(newCapacity);

    const oldStore = this.store;

    this.store = [];
    // 最小容量为底线
    this.capacity = primeCapacity < this.MIN_CAPACITY ? this.MIN_CAPACITY : primeCapacity;
    this.count = 0;

    ...
}

完整代码

  • 注：数组实现的 bucket，并非链表。
export class HashTable<T = any> {
    // 哈希主表数组，采用拉链法，元素本是链表，这里以数组代替，并且元素类型为元祖，便于将 key 和 value 都存一起。
    // 简言之数组元素还是数组，这个元素数组里元素为元祖类型。
    private store: [string, T][][] = [];
    // 容量
    private MIN_CAPACITY = 7;
    private MIN_LOAD_FACTOR = 0.25;
    private MAX_LOAD_FACTOR = 0.75;
    private capacity: number = this.MIN_CAPACITY;
    // 装载数
    private count: number = 0;

    // 装填因子：自动扩容依据
    private get loadFactor() {
        return this.count / this.capacity;
    }

    // 哈希函数
    private hashFun(key: string, capacity: number): number {
        const POWER_BASE = 31;
        let hashcode = 0;
        // 霍纳法则，计算hash值
        for (let i = 0; i < key.length; i++) {
            hashcode = hashcode * POWER_BASE + key.charCodeAt(i);
        }
        // 取余压缩范围
        return hashcode % capacity;
    }

    // 判断质数
    private isPrime(num: number) {
        if (num < 2) return false;
        for (let i = 2; i <= Math.sqrt(num); i++) {
            if (num % i === 0) return false;
        }
        return true;
    }

    // 获取质数
    private getPrime(num: number) {
        while (!this.isPrime(num)) {
            num++;
        }
        return num;
    }

    private resize(newCapacity: number) {
        const primeCapacity = this.getPrime(newCapacity);

        const oldStore = this.store;

        // 1. 构建新数组
        this.store = [];
        this.capacity = primeCapacity < this.MIN_CAPACITY ? this.MIN_CAPACITY : primeCapacity;
        this.count = 0;

        // 2. 旧数据哈希化放入新数组
        oldStore.forEach(bucket => {
            if (bucket) {
                for (let i = 0; i < bucket.length; i++) {
                    const tuple = bucket[i];
                    this.put(tuple[0], tuple[1]);
                }
            }
        });
    }

    // 插入/更新
    put(key: string, value: T): void {
        const index = this.hashFun(key, this.capacity);
        // 获取对应下标的数组
        const bucket = this.store[index];

        if (!bucket) {
            // 插入
            this.store[index] = [[key, value]];
            this.count++;
        } else {
            for (let i = 0; i < bucket.length; i++) {
                const tuple = bucket[i];
                if (tuple[0] === key) {
                    // 更新
                    tuple[1] = value;
                    return;
                }
            }
            bucket.push([key, value]);
            this.count++;
        }

        // 自动扩容
        if (this.loadFactor > this.MAX_LOAD_FACTOR) this.resize(this.capacity * 2);
    }

    // 获取值
    get(key: string): T | null {
        const index = this.hashFun(key, this.capacity);
        const bucket = this.store[index];

        if (bucket) {
            for (let i = 0; i < bucket.length; i++) {
                const tuple = bucket[i];
                if (tuple[0] === key) {
                    return tuple[1];
                }
            }
        }
        return null;
    }

    // 删除
    remove(key: string): T | null {
        const index = this.hashFun(key, this.capacity);
        const bucket = this.store[index];

        if (bucket) {
            for (let i = 0; i < bucket.length; i++) {
                const tuple = bucket[i];
                if (tuple[0] === key) {
                    bucket.splice(i, 1);
                    this.count--;
                    // 缩容
                    if (this.loadFactor < this.MIN_LOAD_FACTOR && this.capacity > this.MIN_CAPACITY) {
                        this.resize(Math.floor(this.capacity / 2));
                    }
                    return tuple[1];
                }
            }
        }
        return null;
    }
}
卡列尼娜翠花
关注
  • 17
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TypeScriptHashMap:TypeScriptHashMap
05-20
HashMap TypeScript版本 HashMap TypeScript版本 用法 var map = new HashMap ( ) ; map . put ( "key1" , "Value1" ) ; map . put ( "key2" , "Value2" ) ; map . put ( "key3" , "Value3" ) ; map . put ( "key4" , "Value4" ) ; map . put ( "key5" , "Value5" ) ; console . log ( "size:" + map . size ( ) + " key1:" + map . get ( "key1" ) ) ; map . remove ( "key1" ) ; map . put ( "key3" , "newValue" ) ; var va
caojiawenn#getOffer#哈希表1
07-25
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1
TypeScript使用HashMap
tedeum
01-20 2787
我不知道大家是怎么使用索引类型的，我是一次想实现HashMap时接触到了索引类型。索引类型大约是这样的： { [idx: string|number]:any } 方括号里面是索引的类型，类似于hashmap里面的key，支持两种索引签名：字符串和数字。 可以同时使用两种类型的索引，但是数字索引的返回值必须是字符串索引返回值类型的子类型。 这是因为当使用 number来索引...
【数据结构与算法——TypeScript】哈希表
羊羊羊羊羊羊羊的博客
08-08 966
- 哈希表是一种非常重要的数据结构，但是很多学习编程的人一直搞不懂哈希表到底是如何实现的。 - 口 在这一章节中，我门就一点点来实现一个自己的哈希表。 - 通过实现来理解哈希表背后的原理和它的优势。 - 几乎所有的编程语言都有直接或者间接的应用这种数据结构。 - 哈希表通常是**基于数组**进行实现的，但是相对于数组，它也很多的优势： - 口 它可以提供非常快速的插入-甽除-查找操作： - 口 无论多少数据，插入和删除值都接近常量的时间：即O(1)的时间与杂度。实际上，只需要几个机器指令即可
Typescript实现java的hashCode函数
林贻民的博客
06-06 1761
Typescript实现java的hashCode函数 import * as int from 'int32' function hashCode(str: string): number { let hash = 0; if (hash == 0 &amp;&amp; str.length &gt; 0) { for (let i = 0; i &lt; str.leng...
typescript的Hashmap的简单实现
wch1618的博客
11-29 334
export class Hashmap<V>{ public map: { [index: string]: V } = {}; public put(key: string, value: V) { this.map[key] = value; } public get(key: string): V { return this.map[key]; } public remove(key: string) { delete this.map[key]; }
react-typescript-stopwatch:使用React和Typescript构建的秒表
03-22
生成被最小化，并且文件名包括哈希值。您的应用已准备好进行部署！ 有关更多信息，请参见关于的部分。 yarn eject 注意：这是单向操作。 eject ，您将无法返回！ 如果您对构建工具和配置选择不满意，则可以随时eject...
algorithms:使用TypeScript实现的流行算法
04-01
4. **搜索算法**：线性搜索、二分搜索、哈希查找、深度优先搜索（DFS）、广度优先搜索（BFS）等。 5. **图算法**：深度优先遍历、广度优先遍历、最短路径算法（Dijkstra、Floyd-Warshall）、最小生成树（Prim、...
nlp100-typescript:使用TypeScript进行100种语言处理的记录
04-13
每种技术都可能涉及特定的数据结构和算法，比如哈希表用于存储词频，图数据结构用于表示句法分析结果，机器学习模型用于预测情感或进行分类等。TypeScript的高级特性如泛型、装饰器和异步操作等，都能帮助优化这些...
数据结构和算法TS：以TypeScript（完整）实现的数据结构和算法
02-05
哈希表 堆栈 s列 链表 树木 图表 演算法 递归 动态编程 比较排序 合并排序 快速排序 正在搜寻 线性搜寻 二元搜寻 BFS和DFS 环境 迪诺1.2.1 V8 8.5.216 打字稿3.9.2 资源资源 策划文章
HashMap.ts cocoscreatorhashmap插件
06-07
ts版hashmap插件，完美配合cocoscreator使用，喜欢的拿去。
TypeScript_算法复杂度-哈希表
雪急飞绪博客
08-31 442
长度不够会动态扩容，
typescript实现个HashTable
09-08 497
type Entry = { key: string, value: any } type ListNode = { value: Entry, next?: ListNode } class HashTable { private table: Array<ListNode | undefined> = [] private size = 8 //! 哈希函数 - 计算哈希值必须是一个稳定的函数，同一个值计算出同一个结果 //! 哈希函数 - 可以写多个，.
map转list_TypeScript实现Map与HashMap
weixin_39831239的博客
12-04 937
前言字典(Map)与散列表(HashMap)是一种采用[键(key)，值(value)]对的形式来存储数据的数据结构。本文将详细讲解字典与散列表的实现思路并使用TypeScript将其实现，欢迎各位感兴趣的前端开发者阅读本文。实现思路字典与散列表存储数据的方式是键值对的形式来存储，因此我们可以使用JavaScript中的对象来实现。字典的实现字典通过键值对的形式来存储数据，它的键是字符串...
鸿蒙项目实战，TypeScript系列教程九《类型转换，hashmap面试题
最新发布
qq_58071132的博客
04-09 648
=======
TypeScript 实现 Map 与 HashMap
qq_14965517的博客
09-08 1845
前言 字典(Map)与散列表(HashMap)是一种采用[键(key)，值(value)]对的形式来存储数据的数据结构。 本文将详细讲解字典与散列表的实现思路并使用TypeScript将其实现，欢迎各位感兴趣的前端开发者阅读本文。 实现思路 字典与散列表存储数据的方式是键值对的形式来存储，因此我们可以使用JavaScript中的对象来实现。 字典的实现 字典通过键值对的形式来存储数据，它的键是字符串类型，调用者传的key是什么，它的键就是什么。 一个完整的字典类需要具备：判断一个键是否在字典中、向字典中添.
typescript 使用教程详解（一）
热门推荐
marendu的博客
10-25 1万+
typescript 使用教程详解 方便于学习使用，我们先搭建一个ts的转换demo，方便一下学习 一、安装 npm install -g typescript 浏览器无法识别 ts 文件的代码，所以需要转换成js 二、编译 tsc xxx.ts 这样比较麻烦所以我们要配置自动编译 三、自动编译 1. vscode tsc --init 生成tsconfig.json 修改输出地址， "o...
关于typescript的疑问
博客转至https://chengyanzhao.github.io，CSDN不再更新。
01-12 835
1.typescript是否完全cover ES6？待解决。 2.使用es6开发形成的ts模块怎么用webpack打包？3.使用typescript开发形成的ts文件在webpack中如何处理？是否与es6处理方式相同？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值