Wählen Sie eine zufällige Eigenschaft aus einem Javascript-Objekt aus

Angenommen, Sie haben ein Javascript-Objekt wie {'cat': 'meow', 'dog': 'woof' ...}. Gibt es eine präzisere Möglichkeit, eine zufällige Eigenschaft aus dem Objekt auszuwählen, als diese langwierige Methode, die ich mir ausgedacht habe? ::

function pickRandomProperty(obj) {
    var prop, len = 0, randomPos, pos = 0;
    for (prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            len += 1;
        }
    }
    randomPos = Math.floor(Math.random() * len);
    for (prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            if (pos === randomPos) {
                return prop;
            }
            pos += 1;
        }
    }       
}

Die gewählte Antwort wird gut funktionieren. Diese Antwort wird jedoch schneller ausgeführt:

var randomProperty = function (obj) {
    var keys = Object.keys(obj);
    return obj[keys[ keys.length * Math.random() << 0]];
};

Auswählen eines zufälligen Elements aus einem Stream

function pickRandomProperty(obj) {
    var result;
    var count = 0;
    for (var prop in obj)
        if (Math.random() < 1/++count)
           result = prop;
    return result;
}

Ich fand keines der Beispiele verwirrend genug, daher ist hier ein wirklich schwer zu lesendes Beispiel, das dasselbe tut.

Bearbeiten: Sie sollten dies wahrscheinlich nicht tun, es sei denn, Sie möchten, dass Ihre Mitarbeiter Sie hassen.

var animals = {
    'cat': 'meow',
    'dog': 'woof',
    'cow': 'moo',
    'sheep': 'baaah',
    'bird': 'tweet'
};

// Random Key
console.log(Object.keys(animals)[Math.floor(Math.random()*Object.keys(animals).length)]);

// Random Value
console.log(animals[Object.keys(animals)[Math.floor(Math.random()*Object.keys(animals).length)]]);

Erläuterung:

// gets an array of keys in the animals object.
Object.keys(animals) 

// This is a number between 0 and the length of the number of keys in the animals object
Math.floor(Math.random()*Object.keys(animals).length)

// Thus this will return a random key
// Object.keys(animals)[0], Object.keys(animals)[1], etc
Object.keys(animals)[Math.floor(Math.random()*Object.keys(animals).length)]

// Then of course you can use the random key to get a random value
// animals['cat'], animals['dog'], animals['cow'], etc
animals[Object.keys(animals)[Math.floor(Math.random()*Object.keys(animals).length)]]

Lange Hand, weniger verwirrend:

var animalArray  = Object.keys(animals);
var randomNumber = Math.random();
var animalIndex  = Math.floor(randomNumber * animalArray.length);

var randomKey    = animalArray[animalIndex];
// This will course this will return the value of the randomKey
// instead of a fresh random value
var randomValue  = animals[randomKey]; 

Sie können einfach eine Reihe von Schlüsseln erstellen, während Sie durch das Objekt gehen.

var keys = [];
for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) {
        keys.push(prop);
    }
}

Wählen Sie dann zufällig ein Element aus den Tasten aus:

return keys[keys.length * Math.random() << 0];

Wenn Sie in der Lage sind, Bibliotheken zu verwenden, finden Sie möglicherweise, dass die Lo-Dash JS-Bibliothek viele sehr nützliche Methoden für solche Fälle bietet. In diesem Fall überprüfen Sie dies _.sample().

(Hinweis Die Lo-Dash-Konvention benennt das Bibliotheksobjekt _. Vergessen Sie nicht, die Installation auf derselben Seite zu überprüfen, um es für Ihr Projekt einzurichten.)

_.sample([1, 2, 3, 4]);
// → 2

In Ihrem Fall verwenden Sie:

_.sample({
    cat: 'meow',
    dog: 'woof',
    mouse: 'squeak'
});
// → "woof"

Wenn Sie underscore.js verwenden , können Sie Folgendes tun:

_.sample(Object.keys(animals));

Extra:

Wenn Sie mehrere zufällige Eigenschaften benötigen, fügen Sie eine Zahl hinzu:

_.sample(Object.keys(animals), 3);

Wenn Sie ein neues Objekt mit nur diesen zufälligen Eigenschaften benötigen:

const props = _.sample(Object.keys(animals), 3);
const newObject = _.pick(animals, (val, key) => props.indexOf(key) > -1);

Eine andere einfache Möglichkeit, dies zu tun, wäre das Definieren einer Funktion, die eine Funktion anwendet Math.random().

Diese Funktion gibt eine zufällige Ganzzahl zurück, die von 'min' reicht.

function getRandomArbitrary(min, max) {
  return Math.floor(Math.random() * (max - min) + min);
}

Extrahieren Sie dann jedes Mal, wenn Sie die obige Funktion als Parameter angeben, entweder einen 'Schlüssel' oder einen 'Wert' oder 'beides' aus Ihrem Javascript-Objekt.

var randNum = getRandomArbitrary(0, 7);
var index = randNum;
return Object.key(index); // Returns a random key
return Object.values(index); //Returns the corresponding value.

In einem JSON-Objekt müssen Sie Folgendes platzieren:

var object={
  "Random": function() {
    var result;
    var count = 0;
    for (var prop in this){
      if (Math.random() < 1 / ++count&&prop!="Random"){
        result = this[prop];
      }
    }
    return result;
  }
}

Diese Funktion gibt das Innere einer zufälligen Eigenschaft zurück.

Mit dem folgenden Code können Sie eine zufällige Eigenschaft aus einem JavaScript-Objekt auswählen:

function randomobj(obj) {
var objkeys = Object.keys(obj)
return objkeys[Math.floor(Math.random() * objkeys.length)]
}
var example = {foo:"bar",hi:"hello"}
var randomval = example[randomobj(example)] // will return to value
// do something