Discussion :

[francortes]

Bonjour,

Je rencontre des problèmes pour utiliser correctement les génériquezs de TypeScript sur des types de base tels que les Maps ES2015 ou des types personnalisés comme des classes. Je précise que j'utilise TYpeScript dansune application Vite (vanilla TS)

Si j'écris:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
const m: Map <number, number> = new Map()
 
// le compilateur laisse passer cela:
m.set('abcd', 'efgh')

Peut être y'a til une option de tsconfig.json mal positionnée ?

Le pire vient quand je tente d'encapsuler une liste d'items portant des données et ayant un UID (string 5 caractères alphanumériques minuscule + '_' = 37 valeurs possibles) avec un Map de lookup:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
import { MWCRand } from './MWCRand.ts'
import { TDRUID, key2values, values2key  } from 'TDRUID.ts'
import { TDataBlock } from './TDataBlock.ts'
 
export class DataBlocksRepo <T> {
    // PNRG
    protected _generator = new MWCRand')
 
    // liste pouir le stockage d'items et les filtrages/map/reduce
    protected _entries: TBataBlock<T>[] = []
 
    // table d'accès en O(1) sur les items
    protected _lokkups: Map <TDRUID, TBataBlock<T>> = new Map()
 
    constructor () { 
        this._generator = new MWCRand({
            multiplier: 34567,
            modulus: 37,
            length: 5
        })
 
        this._generator.init([3, 4, 5, 6, 7])
 
// ou...
//        this._generator.init(key2values('_uid_'))
    }
 
    add (datum: T): TDRUID {
        let uid: TDRUID
        let block: TDataBlock <T>
 
        do {
            // tant que le générateur génçre une collision 
            // on calcule un autre UID
 
            // MWC produit 93% de valeurs distinctes quand on l'applique  1M fois
            // nombre de clés possibles = Math.pow(37, 5) ~ 69M
 
            uid = values2key(this._generator.step())
        } while (this._lookups.has(uid))
 
        block = {
            uid, datum, marked: false
        }
 
        this._entries.push(block)
        this._lookups.set(uid, block)
 
    console.log('add:', datum, 'typeof', typeof datum)
 
        return uid
    }
 
    get (uid: TDRUID): T {
        const block = this._lookups.get(uid)
 
        console.log({ block })
 
        return block.datum
    }    
}

Et quand on fait invoque tout cela cela ne fonctionne pas bien non plus:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
type TData = {
    [key: string]: string
}
 
const dbr: DataBlocksRepo <TData> = new TDataBlocksRepo()
 
// cela fonctionne
const uid0 = dbr.add({ 'abcd', 'efgh' })
 
// cela fonctionne aussi, MAIS cela ne drait pas le faire
const uid1 = dbr.add({ 'xyzw', null })
const uid2 = dbr.add(null)

Comment cela se fait-il que les génériques ne semblent pas faire leur travail correctement, en bloquant le projet à laz phase de compilation de TypeSCript ?

[francortes]

en regardant de plus près le package.json du projet, dans la section "scripts":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
  "scripts": {
    "dev": "vite",
    "build": "tsc && vite build",
    "serve": "vite preview"
  },

c'est très clair: la vérification de types n'est effectuée qu'au build. Donc "npm run build" est la bonne réponse...

que renvoie "npm run dev" quand on lui passe un ensemble de sources TS ? probablement du JS compilé en dégageant les déclarations de type... puisque (aux erreurs logiques près) cela marche dans la console du navigateur !!!

ET la tada !!! mes génériques sont bien vérifiés, et il y a pas mal d'erreurs à fixer.