题解 | #字符串字符统计#

function count(str) {
    let o = {};
    for(let c of str) {
        if(c === ' ') continue;
        if(o[c]) {
            o[c]++;
        } else {
            o[c] = 1;
        }
    }
    return o;
}

let k of 用于遍历数组或其他可迭代对象（如字符串），返回每个元素的值。它的语法如下：

for (let k of iterable) {
  // ...
}

其中，iterable 是一个可迭代对象，例如数组或字符串。在每次循环中，变量 k 会依次赋值为 iterable 中的每个元素的值。

例如，下面的代码使用 let k of 遍历数组中的元素：

const arr = [1, 2, 3];
for (let k of arr) {
  console.log(k);
}
// 输出：
// 1
// 2
// 3

let k in 用于遍历对象的可枚举属性，返回每个属性的键名。它的语法如下：

for (let k in object) {
  // ...
}

其中，object 是一个对象。在每次循环中，变量 k 会依次赋值为 object 中的每个可枚举属性的键名。

例如，下面的代码使用 let k in 遍历对象中的属性：

const obj = {a: 1, b: 2, c: 3};
for (let k in obj) {
  console.log(k + ': ' + obj[k]);
}
// 输出：
// a: 1
// b: 2
// c: 3

需要注意的是，let k in 遍历的是对象的可枚举属性，包括对象原型链中的属性，而且返回的是属性名而不是属性值。如果只需要遍历对象自身的属性，可以使用 Object.hasOwnProperty() 方法来过滤掉原型链中的属性，例如：

const obj = {a: 1, b: 2, c: 3};
Object.prototype.d = 4;

for (let k in obj) {
  console.log(k + ': ' + obj[k]);
}
// 输出：a: 1, b: 2, c: 3, d: 4

for (let k in obj) {
  if (obj.hasOwnProperty(k)) {
    console.log(k + ': ' + obj[k]);
  }
}
// 输出：a: 1, b: 2, c: 3

== 和 === 都是 JavaScript 中用于比较两个值的运算符，但它们的比较规则和行为有所不同。

== 运算符是非严格相等运算符，它会将两个操作数进行类型转换，然后再进行比较。具体规则如下：

1. 如果两个操作数类型相同，则直接比较它们的值，返回比较结果。
2. 如果两个操作数类型不同，则将它们转换为相同的类型，然后再比较。
3. 如果一个操作数为 null，另一个操作数为 undefined，则它们相等。
4. 如果一个操作数为数字，另一个操作数为字符串，则将字符串转换为数字，然后再比较。
5. 如果一个操作数为布尔值，另一个操作数为非布尔值，则将布尔值转换为数字（true 转换为 1，false 转换为 0），然后再比较。
6. 如果一个操作数为对象，另一个操作数为数字或字符串，则将对象转换为原始值，然后再比较。

例如，下面的表达式都返回 true：

1 == '1'  // true，字符串 '1' 被转换为数字 1
true == 1 // true，布尔值 true 被转换为数字 1
null == undefined // true，它们都是空值

但是，== 运算符也存在一些问题，因为它会进行类型转换，可能导致一些不符合预期的结果。例如：

'' == 0 // true，空字符串被转换为数字 0
[] == '' // true，空数组被转换为字符串，再与空字符串比较
[] == 0  // true，空数组被转换为数字 0

因此，建议在比较值时，优先使用 === 运算符。

=== 运算符是严格相等运算符，它会比较两个操作数的类型和值，只有当两者都相同时才返回 true，否则返回 false。例如：

1 === '1' // false，类型不同
true === 1 // false，类型和值都不同
null === undefined // false，类型相同但值不同

总之，使用 === 运算符比 == 运算符更可靠，因为它不会进行类型转换，可以避免一些潜在的问题。