Question

所以我有一个像这样的JavaScript对象：

foo = {
  "one": "some",
  "two": "thing",
  "three": "else"
};

我可以这样循环：

for (var i in foo) {
  if (foo.hasOwnProperty(i)) {
    // do something
  }
}

将以one＆gt;的顺序遍历属性。 two＆gt; three。

然而，有时我需要以相反的顺序进行，所以我想做同样的循环，但是three＆gt; two＆gt; one。

问题：
是否存在“对象反转”功能。如果它是一个数组，我可以使用unshift反转或构建一个新数组，但是当我需要反向循环它的属性时，我迷失了对象的处理方式。有什么想法吗？

谢谢！

Answer 1

Javascript对象没有保证的固有顺序，因此不存在“反向”顺序。

4.3.3对象对象是Object类型的成员。它是一个无序集合属性，每个属性都包含一个基元价值，对象或功能。存储在属性中的函数对象称为方法。

浏览器似乎确实以与添加到对象相同的顺序返回属性，但由于这不是标准，因此您可能不应该依赖此行为。

一个简单的函数，它以与浏览器for..in给出的顺序相反的顺序调用每个属性的函数，是这样的：

// f is a function that has the obj as 'this' and the property name as first parameter
function reverseForIn(obj, f) {
  var arr = [];
  for (var key in obj) {
    // add hasOwnPropertyCheck if needed
    arr.push(key);
  }
  for (var i=arr.length-1; i>=0; i--) {
    f.call(obj, arr[i]);
  }
}

//usage
reverseForIn(obj, function(key){ console.log('KEY:', key, 'VALUE:', this[key]); });

工作JsBin：http://jsbin.com/aPoBAbE/1/edit

我再次说for..in的顺序不能保证，所以不保证相反的顺序。请谨慎使用！

Answer 2

没有办法向后循环一个对象，但是如果你以相反的顺序重新创建对象，那么你就是金色！但要注意的是，没有任何东西可以说对象的顺序会随着它的变化保持不变，所以这可能会产生一些有趣的结果，但是大多数情况下它都有效......

function ReverseObject(Obj){
    var TempArr = [];
    var NewObj = [];
    for (var Key in Obj){
        TempArr.push(Key);
    }
    for (var i = TempArr.length-1; i >= 0; i--){
        NewObj[TempArr[i]] = [];
    }
    return NewObj;
}

就像这样 - 你的对象交换 -

MyObject = ReverseObject(MyObject);

循环看起来像这样 -

for (var KeysAreNowBackwards in MyObject){
    alert(MyObject[KeysAreNowBackwards]);
}

Answer 3

为什么没有人提到 Object.keys() ？

您可以按原样获得 Array 对象的属性，然后可以使用Array方法对其进行逆向或过滤。

let foo = {
  "one": "some",
  "two": "thing",
  "three": "else"
};

// Get REVERSED Array of Propirties
let properties = Object.keys(foo).reverse();
// "three"
// "two"
// "one"

// Then you could use .forEach / .map
properties.forEach(prop => console.log(`PropertyName: ${prop}, its Value: ${foo[prop]}`));

// PropertyName: three, its Value: else
// PropertyName: two, its Value: thing
// PropertyName: one, its Value: some

Answer 4

只需使用Object.keys（）

此功能将为您解决：

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.seed.kotlintest"
        minSdkVersion 15
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.0'
}

示例对象：

function loopObject(obj, reverse, logic){
    let keys = reverse? Object.keys(obj).reverse() : Object.keys(obj)
    for(let i=0;i<keys.length;i++){
        logic(obj[keys[i]])
    }
}

按顺序循环：

let my_object = {
    one: 'one',
    two: 'two',
    three: 'three'
}

反向循环：

loopObject(my_object, false, val => {
    console.log(val) // Insert your logic here.
})

// "one"
// "two"
// "three"

Answer 5

此答案与其他几个答案相似，但是一些用户可能会发现下面的代码更易于复制粘贴以供自己使用：

Object.keys(foo).reverse().forEach(function(key) { console.log(foo[key]) });

对于问题中所述的对象“ foo”，此代码将以相反的顺序输出对象元素：“ else”，“ thing”，“ some”

我可以以相反的顺序循环浏览javascript对象吗？

5 个答案: