Mam obiekt JavaScript, czy istnieje wbudowany lub przyjęty najlepszy sposób, aby uzyskać długość tego obiektu?

const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;
2733
Gareth Simpson 7 sierpień 2008, 23:42

29 odpowiedzi

Najlepsza odpowiedź

Najbardziej solidna odpowiedź (tj. To oddaje intencję tego, co próbujesz zrobić, powodując, co najmniej błędów) byłoby:

Object.size = function(obj) {
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

// Get the size of an object
var size = Object.size(myObj);

Istnieje rodzaj konwencji w JavaScript, że ty Nie dodawaj rzeczy do obiektu.Prototyp, ponieważ Może przełamać wyliczenia w różnych bibliotekach. Jednak dodanie metod do obiektu jest zazwyczaj bezpieczne.


Oto aktualizacja na dzień 2016 i powszechne wdrażanie ES5 i poza nią. dla IE9 + i wszystkich innych nowoczesnych przeglądarek zdolnych ES5 +, możesz użyć Object.keys(), więc powyższy kod staje się:

var size = Object.keys(myObj).length;

Nie musi modyfikować żadnego istniejącego prototypu, ponieważ jest teraz wbudowany Object.keys().

Edytuj : Obiekty mogą mieć właściwości symboliczne, które nie mogą być zwracane przez metodę obiekt.key. Więc odpowiedź byłaby niekompletna, nie wspominając o nich.

Typ symbolu został dodany do języka, aby utworzyć unikalne identyfikatory właściwości obiektu. Główną korzyścią typu symbolu jest zapobieganie nadpisywaniom.

Object.keys lub Object.getOwnPropertyNames nie działa dla właściwości symbolicznych. Aby przywrócić je, musisz użyć Object.getOwnPropertySymbols.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.log(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.log(propSymb.length); // 2
2764
double-beep 9 styczeń 2021, 17:19

Jeśli wiesz, że nie musisz się martwić o czeków {x0}}, możesz to zrobić bardzo proste:

Object.keys(myArray).length
1800
Jarod Moser 21 czerwiec 2017, 20:12

Zaktualizowany : Jeśli używasz underderscore.js (zalecane, to lekkie!), To możesz po prostu robić

_.size({one : 1, two : 2, three : 3});
=> 3

Jeśli nie , i nie chcesz zepsuć się z właściwościami obiektów z jakiegokolwiek powodu i już używają jQuery, wtyczka jest równie dostępna:

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};
292
ripper234 8 lipiec 2012, 10:30

Oto najbardziej rozwiązanie przeglądarki.

Jest to lepsze niż zaakceptowana odpowiedź, ponieważ używa natywnego obiektu.keys, jeśli istnieje. W ten sposób jest najszybszy dla wszystkich nowoczesnych przeglądarek.

if (!Object.keys) {
    Object.keys = function (obj) {
        var arr = [],
            key;
        for (key in obj) {
            if (obj.hasOwnProperty(key)) {
                arr.push(key);
            }
        }
        return arr;
    };
}

Object.keys(obj).length;
59
Joon 1 wrzesień 2013, 16:12

Nie jestem ekspertem JavaScript, ale wygląda na to, że musiałbyś pętli przez elementy i policzyć je, ponieważ obiekt nie ma metody długości:

var element_count = 0;
for (e in myArray) {  if (myArray.hasOwnProperty(e)) element_count++; }

@Palmsey: W uczciwości na op, Dokumentacja JavaScriptowa faktycznie odnosi się do stosowania zmiennych obiektu typu w ten sposób jako "tablice stowarzyszeń".

36
Peter Mortensen 17 wrzesień 2016, 18:27

Ta metoda pobiera wszystkie nazwy właściwości obiektu w tablicy, dzięki czemu można uzyskać długość tej tablicy, która jest równa długości kluczy obiektu.

Object.getOwnPropertyNames({"hi":"Hi","msg":"Message"}).length; // => 2
30
Patrick Roberts 6 luty 2015, 19:43

Wystarczy użyć tego, aby uzyskać length:

Object.keys(myObject).length
29
Barry Michael Doyle 4 kwiecień 2018, 08:27

Aby nie bałagan z prototypem lub innym kodem, możesz zbudować i rozszerzyć własny obiekt:

function Hash(){
    var length=0;
    this.add = function(key, val){
         if(this[key] == undefined)
         {
           length++;
         }
         this[key]=val;
    }; 
    this.length = function(){
        return length;
    };
}

myArray = new Hash();
myArray.add("lastname", "Simpson");
myArray.add("age", 21);
alert(myArray.length()); // will alert 2

Jeśli zawsze używasz metody Add, właściwość Długość będzie poprawna. Jeśli martwisz się, że ty lub inni zapominasz o użyciu go, możesz dodać licznik nieruchomości, który inni opublikowali również metodę długości.

Oczywiście można zawsze nadpisać metody. Ale nawet jeśli tak, twój kod prawdopodobnie nie powiedzie się zauważalnie, ułatwiając debugowanie. ;)

24
Pang 8 sierpień 2015, 01:37

Oto jak i nie zapomnij sprawdzić, czy nieruchomość nie znajduje się na łańcuchu prototypowym:

var element_count = 0;
for(var e in myArray)
    if(myArray.hasOwnProperty(e))
        element_count++;
20
Kev 23 maj 2012, 23:28

Możemy znaleźć długość obiektu, używając:

Object.values(myObject).length
20
costaparas 9 styczeń 2021, 13:45

Oto zupełnie inne rozwiązanie, które będzie działać tylko w bardziej nowoczesnych przeglądarkach (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Zobacz jsfiddle

Skonfiguruj swoją tablicę asocjacyjną

/**
 * @constructor
 */
AssociativeArray = function () {};

// Make the length property work
Object.defineProperty(AssociativeArray.prototype, "length", {
    get: function () {
        var count = 0;
        for (var key in this) {
            if (this.hasOwnProperty(key))
                count++;
        }
        return count;
    }
});

Teraz możesz użyć tego kodu w następujący sposób ...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);
17
Peter Mortensen 10 lipiec 2020, 18:37
<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);
</script>

<p id="myObj">The number of <b>keys</b> in <b>myObj</b> are: <script>document.write(size)</script></p>

To działa dla mnie:

var size = Object.keys(myObj).length;
16
RAGINROSE 22 marzec 2019, 13:20

W przypadku niektórych przypadków lepiej jest przechowywać rozmiar w oddzielnej zmiennej. Szczególnie, jeśli dodasz do tablicy przez jeden element w jednym miejscu i może łatwo zwiększyć rozmiar. Najwyraźniej działa znacznie szybciej, jeśli często musisz sprawdzić rozmiar.

15
Jānis Elmeris 29 lipiec 2011, 13:41

Posługiwać się:

var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
obj = Object.keys(myArray).length;
console.log(obj)
15
Peter Mortensen 17 wrzesień 2016, 18:36

Najprostszy sposób jest taki

Object.keys(myobject).length

Gdzie myObject jest przedmiotem tego, co chcesz długości

15
Peter Mortensen 10 lipiec 2020, 18:50

Jeśli potrzebujesz asocjacyjnej struktury danych, która ujawnia jego rozmiar, lepiej użyj mapy zamiast obiektu.

const myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3
15
kabirbaidhya 24 wrzesień 2020, 14:52

@palmsey: W uczciwości do OP, dokumenty JavaScript faktycznie odnoszą wyraźnie do stosowania zmiennych obiektu typu w ten sposób jako "tablice stowarzyszeniowe".

I w uczciwości na @palmsey był całkiem poprawny, nie są one skojarzone tablicami, są zdecydowanie przedmiotami :) - wykonywanie pracy tablicy stowarzyszonej. Ale w odniesieniu do szerszego punktu, który zdecydowanie wydają się mieć prawo do tego w zależności od tego raczej dobrego artykułu, które znalazłem:

JavaScript "Miejsce asocjacyjne" uważane za szkodliwe

Ale według tego wszystkiego nie jest to Akceptowana odpowiedź sama praktyka?

Określ funkcję rozmiaru prototypu () dla obiektu

Jeśli coś innego zostało dodane do obiektu .prototypu, a następnie sugerowany kod zostanie niepowodzenie:

<script type="text/javascript">
Object.prototype.size = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
Object.prototype.size2 = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
alert("age is " + myArray["age"]);
alert("length is " + myArray.size());
</script>

Nie sądzę, że odpowiedź powinna być zaakceptowana, ponieważ nie może być zaufana do pracy, jeśli masz jakiś inny kod działa w tym samym kontekście wykonania. Aby to zrobić w solidnym modzie, na pewno trzeba będzie zdefiniować metodę rozmiaru w bębenach i sprawdzić typ członków, jak iwracujesz przez nich.

14
Peter Mortensen 10 lipiec 2020, 18:34

Co z czymś takiego -

function keyValuePairs() {
    this.length = 0;
    function add(key, value) { this[key] = value; this.length++; }
    function remove(key) { if (this.hasOwnProperty(key)) { delete this[key]; this.length--; }}
}
11
Jerry 24 sierpień 2011, 14:26

Jeśli mamy hash

Hash = {"A": "B", "C": "D"};

Możemy uzyskać długość za pomocą długości klawiszy, które jest długością Hash:

Klucze (Hash).

11
Peter Mortensen 17 wrzesień 2016, 18:28
var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;
  1. Obiekt.Values (myObject).
  2. Object.entries (myObject).
  3. Obiekt.keys (myObject) .length
11
tdjprog 5 kwiecień 2018, 23:45
const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

console.log(Object.keys(myObject).length)

// o/p 3
11
Soura Sankar Ghosh 11 styczeń 2020, 12:54

Użyj Object.keys(myObject).length, aby uzyskać długość obiektu / tablicy

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

console.log(Object.keys(myObject).length); //3
11
double-beep 9 styczeń 2021, 17:08

Jeśli nie dbasz o wspieranie programu Internet Explorer 8 lub niżej, można łatwo uzyskać liczbę właściwości w obiekcie, stosując następujące dwa kroki:

  1. Uruchom albo Object.keys() , aby uzyskać tablicę, która zawiera nazwy tylko tych właściwości, które są łączny lub {X1}} Jeśli chcesz również zawierać nazwy właściwości, które nie są nieliceniowe.
  2. Zdobądź .length właściwość tej tablicy.

Jeśli chcesz to zrobić więcej niż raz, możesz owinąć tę logikę w funkcji:

function size(obj, enumerablesOnly) {
    return enumerablesOnly === false ?
        Object.getOwnPropertyNames(obj).length :
        Object.keys(obj).length;
}

Jak korzystać z tej konkretnej funkcji:

var myObj = Object.create({}, {
    getFoo: {},
    setFoo: {}
});
myObj.Foo = 12;

var myArr = [1,2,5,4,8,15];

console.log(size(myObj));        // Output : 1
console.log(size(myObj, true));  // Output : 1
console.log(size(myObj, false)); // Output : 3
console.log(size(myArr));        // Output : 6
console.log(size(myArr, true));  // Output : 6
console.log(size(myArr, false)); // Output : 7

Zobacz także To bawi się dla demo.

8
John Slegers 18 wrzesień 2016, 00:19

Odmiana niektórych z powyższych jest:

var objLength = function(obj){    
    var key,len=0;
    for(key in obj){
        len += Number( obj.hasOwnProperty(key) );
    }
    return len;
};

Jest to nieco bardziej elegancki sposób na integrację Hasownprop.

7
Peter Mortensen 7 październik 2014, 10:54

Oto inna wersja odpowiedzi James Cogana. Zamiast przekazywać argument, po prostu prototypuj klasę obiektów i dokonać środka czyszczącego.

Object.prototype.size = function () {
    var size = 0,
        key;
    for (key in this) {
        if (this.hasOwnProperty(key)) size++;
    }
    return size;
};

var x = {
    one: 1,
    two: 2,
    three: 3
};

x.size() === 3;

JSFiddle Przykład: http://jsfiddle.net/qar4j/1/

6
Sherzod 26 czerwiec 2013, 23:47

Możesz po prostu użyć Object.keys(obj).length na dowolnym obiekcie, aby uzyskać jej długość. Obiekt.keys zwraca tablicę zawierającą wszystkie klawisze obiektowe (właściwości), które mogą przydać się do znalezienia długości tego obiektu za pomocą długości odpowiedniej tablicy. Możesz nawet napisać funkcję dla tego. Uzyskajmy kreatywne i napisz metodę dla niego również (wraz z bardziej connentient Getter Neight):

function objLength(obj)
{
  return Object.keys(obj).length;
}

console.log(objLength({a:1, b:"summit", c:"nonsense"}));

// Works perfectly fine
var obj = new Object();
obj['fish'] = 30;
obj['nullified content'] = null;
console.log(objLength(obj));

// It also works your way, which is creating it using the Object constructor
Object.prototype.getLength = function() {
   return Object.keys(this).length;
}
console.log(obj.getLength());

// You can also write it as a method, which is more efficient as done so above

Object.defineProperty(Object.prototype, "length", {get:function(){
    return Object.keys(this).length;
}});
console.log(obj.length);

// probably the most effictive approach is done so and demonstrated above which sets a getter property called "length" for objects which returns the equivalent value of getLength(this) or this.getLength()
5
Mystical 12 październik 2016, 02:09

Zawsze możesz zrobić Object.getOwnPropertyNames(myObject).length, aby uzyskać taki sam wynik, jak [].length zapewniłoby normalną tablicę.

5
Pian0_M4n 27 wrzesień 2017, 09:05

Trochę późno do gry, ale miły sposób na to, aby to osiągnąć (TYLKO IE9 +) jest zdefiniowanie magii Getter na nieruchomości:

Object.defineProperty(Object.prototype, "length", {
    get: function () {
        return Object.keys(this).length;
    }
});

I możesz po prostu użyć go jak:

var myObj = { 'key': 'value' };
myObj.length;

Dałoby 1.

4
Peter Mortensen 10 lipiec 2020, 18:53

Poniżej znajduje się wersja odpowiedzi James Coglan w CoffeScript dla tych, którzy opuszczyli Prosto JavaScript :)

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size
3
Eric Anderson 6 październik 2014, 19:44