Javascript 计算对象和所有子对象中的字符串总数

我有一个对象，它可能包含对象（反过来可能包含对象，也可能不包含对象，等等，直到无穷大），并抛出字符串，如下所示：

var obj = {
    "foo": "hello",
    "bar": "hi",
    "test": {
        "foo": "foo"
        "bar": {
            "test": "hi",
            "hello": "howdy"
        }
    }
}

我要做的是计算整个

obj

对象及其子对象中的字符串数。在本例中，正确答案为5

这个网站上关于计算对象中的键的众多主题都建议使用

.hasOwnProperty

循环，或者使用新的

对象.keys（obj）

方法，但这两种方法都不是递归的，它们都会计算子对象本身

---

实现这一点的最佳方法是什么？

您可以创建递归函数，该函数将循环嵌套对象并返回计数

var obj={
“foo”：“你好”，
“酒吧”：“你好”，
“测试”：{
“foo”：“foo”，
“酒吧”：{
“测试”：“嗨”，
“你好”：“你好”
}
}
}
函数计数（数据）{
var c=0；
用于（数据中的var i）{
如果（数据类型[i]=“对象”）c+=计数（数据[i]）；
如果（数据类型[i]='string'）c+=1
}
返回c；
}
log（countS（obj））

使用您提到的任一方法循环

大概是这样的：

var obj={
“foo”：“你好”，
“酒吧”：“你好”，
“测试”：{
“foo”：“foo”，
“酒吧”：{
“测试”：“嗨”，
“你好”：“你好”
}
}
}
函数计数_字符串（obj）{
var计数=0；
var keys=Object.keys（obj）；
对于（var i=0，l=keys.length；i这里是函数编程风格的ES6函数：


函数计数原语（obj）{
返回+（对象（obj）！==obj）|
Object.keys（obj）.reduce（（cnt，key）=>cnt+countPrimitives（obj[key]），0）；
}
var obj={
“foo”：“你好”，
“酒吧”：“你好”，
“测试”：{
“foo”：“foo”，
“酒吧”：{
“测试”：“嗨”，
“你好”：“你好”
}
}
};
console.log（countPrimitives（obj））；
这也是我的50美分

function checkString(str){
  var count = 0;
  if(typeof str  === 'string'){
    return 1;
  }
  Object.keys(str).forEach(function(v){
    console.log(str[v]);
    if(typeof str[v] === 'object') count = count + checkString(str[v])
    else count ++;
  })
  return count;
}

var obj = {
    "foo": "hello",
    "bar": "hi",
    "test": {
        "foo": "foo"
        "bar": {
            "test": "hi",
            "hello": "howdy"
        }
    }
};
console.log(checkString(obj));

您可以使用它来迭代键并检查对象


函数getCount（对象）{
返回Object.keys（Object）.reduce（函数r，k）{
返回r+（object[k]&&typeof object[k]=“object”？getCount（object[k]）：1；
}, 0);
}
var obj={foo:“你好”，bar:“你好”，test:{foo:“foo”，bar:{test:“你好”，hello:“你好”}，
计数=获取计数（obj）；
console.log（count）；
如果我们是ES6ish，你可以使用
Object.values
Object.values
不是ES6的一部分，但是在下一个EcmaScript版本的草稿中。你知道我没有意识到这一点吗。（可能没有太大的不同，因为它可能需要传输！）