我读过很多关于JavaScript中字符串相等的文章，并认为它在TypeScript中也是一样的，但我对这个问题感到困惑。我有两个完全相同的字符串，但在==和===操作符中却有不相等的结果。
这是密码：

this.cl_applied_filts.forEach (
                                    filt => {
                                        console.log (`[cl-filts]`);
                                        store.getState()._cl_filters.forEach(
                                            f => {
                                                const af : string = filt.name;
                                                const lf : string = f.name;
                                                let sa : String = new String(af);
                                                let sf : String = new String(lf);
                                                console.log (`[cl-filts] String '${af}' and '${lf}'
equal (af == lf)  ${(af == lf)} not equal (af != lf) ${(af != lf)}
buffers:
applied af ${JSON.stringify(filt)}
           lengths ${filt.name.length} length ${af.length}.
db      lf ${JSON.stringify(f)}
           lengths ${f.name.length} length ${lf.length}.
normalized af '${sa.normalize()}'
           lf '${sf.normalize()}'
`);
                                                let equal : boolean = true;
                                                for (let i = 0; i < af.length; ++i) {
                                                    let afc = sa.charCodeAt(i);
                                                    let lfc = sf.charCodeAt(i);
                                                    if (afc != lfc) {
                                                        console.log (`!!! both nums aren't equal !!!`);
                                                        equal = false;
                                                    }
                                                    console.log (`${i} ${sa.charCodeAt(i)} ${sf.charCodeAt(i)}`);
                                                }
                                                if (equal) {
                                                    console.log (`** both strings are equal **`);
                                                }
                                                if (store.string_eq(filt.name, f.name)) {
                                                    f.checked = true;
                                                    console.log (`[cl-filts] checked ${f.checked}`);
                                                }
                                            }
                                        );
                                    });

这是Firefox控制台的输出：

[cl-filts] String 'BURNLEY' and 'BURNLEY'
equal (af == lf)  false not equal (af != lf) true
buffers:
applied af {"checked":true,"name":{"type":"Buffer","data":[66,85,82,78,76,69,89]}}
           lengths 7 length 7.
db      lf {"checked":0,"name":{"type":"Buffer","data":[66,85,82,78,76,69,89]}}
           lengths 7 length 7.
normalized af 'BURNLEY'
           lf 'BURNLEY'
control-lines.component.ts:56:56
0 66 66 control-lines.component.ts:74:60
1 85 85 control-lines.component.ts:74:60
2 82 82 control-lines.component.ts:74:60
3 78 78 control-lines.component.ts:74:60
4 76 76 control-lines.component.ts:74:60
5 69 69 control-lines.component.ts:74:60
6 89 89 control-lines.component.ts:74:60
** both strings are equal ** control-lines.component.ts:77:60
[cl-filts] checked true control-lines.component.ts:81:60

对象声明：

export class Filter
{
    checked : boolean = false;
    name : string = '';
}

我们可以看到两个字符串是相同的，甚至是字节，但是它们给出了不相等的结果，为什么呢？，我创建了一个函数，用来比较两个字符串，和charCodeAt函数，以避免浪费更多的时间，但是我想知道这里发生了什么。
编辑：我已经按照评论修改，以显示没有区别。