Question

我的练习用于...输入以打印出对象中的所有键，打印出嵌套对象的键。但我不检查nameValue的值是否为对象

我尝试使用for ... in，但是值检查的结果未定义

// My Exercises 
var apartment = {
  bedroom: {
    area: 20,
    bed: {
      type: 'twin-bed',
      price: 100
    }
  }
};

// Tried
function checkObj(objs) {
  for (var obj in objs) {
    console.log(obj);
    var check = objs['obj'];
    console.log(check);
  }
}
checkObj(apartment);

Answer 1

在JavaScript typeof null，typeof []和typeof {}中将返回'object'。

您可以检查constructor.name中的object是否等于'Object'

function checkObj(objs) {
    for (var obj in objs) {
        var isObj = objs[obj] && objs[obj].constructor.name === 'Object';
        console.log('is Object:', isObj);
    }
}

checkObj(apartment);

如@ZivBen或注释中所建议，您也可以像这样检查它

Object.prototype.toString.call(obj[key]) === "[object Object]"

Answer 2

您可以使用此功能来确定该值是否为对象？

function isObject (item) {
  return (typeof item === "object" && !Array.isArray(item) && item !== null);
}

因为typeof []也是object

var apartment = {
    bedroom: {
        area: 20,
        bed: {
        type: 'twin-bed',
        price: 100
        },
        test:[1,2,3]
    }
};

function isObject (item) {
  return (typeof item === "object" && !Array.isArray(item) && item !== null);
}

function checkObj(objs) {
    for (var obj in objs) {
        console.log(obj);
        var check = isObject(objs[obj]);
        console.log(check);
    }
}
checkObj(apartment);

Reference

Answer 3

通过检查铲斗级别是否为对象来打印所有键和值。

objs[obj] !== null && typeof objs[obj] === 'object' && objs[obj].constructor !== Array

这是识别对象的方式。

已更新以验证null和array。

// My Exercises 
var apartment = {
    bedroom: {
        area: 20,
        bed: {
        type: 'twin-bed',
        price: 100
        }
    },
    bedroom1: null,
    bedroom2: [],
    bedroom3: {}
};

// Tried
function checkObj(objs) {
    for (var obj in objs) {
     if (objs[obj] !== null && typeof objs[obj] === 'object' && objs[obj].constructor !== Array) {
      checkObj(objs[obj]);
     } else {
      console.log(obj, ':', objs[obj]);
     }
    }
}
checkObj(apartment);

Answer 4

在JavaScript中，基本上所有东西都是对象。尝试使用此方法来将更宽泛的Object prototype与对象of key/value pairs ({}).区分开。我也附加了您的代码。

var apartment = {
    bedroom: {
        area: 20,
        bed: {
        type: 'twin-bed',
        price: 100
        }
    }
};

var isPlainObject = function (obj) {
	return Object.prototype.toString.call(obj) === '[object Object]';
};

console.log(isPlainObject(apartment));

console.log(isPlainObject(apartment.bedroom));
console.log(isPlainObject(apartment.bedroom.bed));


// Returns false
console.log(isPlainObject(['wolverine', 'magneto', 'cyclops']))
// returns false
console.log(isPlainObject(null))


// Your code

function checkObj(objs) {
    for (var obj in objs) {
      
        var check = isPlainObject(objs[obj]);
        console.log("your code",check); // this returns true
    }
}
checkObj(apartment);

Answer 5

这是在对象键上运行的递归函数，如果属性的值为object，它将再次调用该函数。我用Object.prototype.toString.call(obj[key]) === "[object Object]"而不是typeof obj[key] === 'object'来检查属性是对象上的一个对象，而不是Array或function

的对象

var apartment = {
    bedroom: {
        area: 20,
        bed: {
            type: "twin-bed",
            price: 100,
            array: [1,2,3],
            method: function(){}
        }
    }
}

function printObjectKeys(obj) {
    for (var key in obj) {
        console.log(key);
        if (Object.prototype.toString.call(obj[key]) === "[object Object]") {
            printObjectKeys(obj[key]);
        }
    }
}
console.log(printObjectKeys(apartment));

如何检查对象中的键是一个对象

5 个答案: