• 
  Konstruktor obiektu ogólnego w JavaScript - constructor

  Gdzie jest zapisany konstruktor obiektu ogólnego?

• 
  Przekształcanie obiektu na tekst - toString

  W jaki sposób przekształcić obiekt na prosty tekst?

• 
  Przekształcanie obiektu na rodzimy tekst - toLocaleString

  W jaki sposób przekształcić obiekt na tekst zapisany w rodzimym języku użytkownika?

• 
  Przekształcanie obiektu na wartość prostą - valueOf

  Jak przekształcić złożony obiekt na wartość prostą (logiczną, liczbę, tekst)?

• 
  Sprawdzanie posiadania właściwości obiektu - hasOwnProperty

  W jaki sposób sprawdzić, czy obiekt posiada właściwość o podanej nazwie?

• 
  Sprawdzanie prototypu obiektu - isPrototypeOf

  W jaki sposób sprawdzić, czy podany obiekt jest prototypem określonej instancji obiektu?

• 
  Sprawdzanie dostępności właściwości w pętli - propertyIsEnumerable

  Jak sprawdzić, czy podana właściwość będzie dostępna w pętli?

Object.prototype.constructor

Wartość:

Function - konstruktor obiektu

Zawiera konstruktor wbudowanego obiektu ogólnego Object.

Przykład Object.prototype.constructor

Object.prototype.constructor === Object;  // true
new Object().constructor === Object;      // true
Object.prototype.constructor === Boolean; // false
Object.prototype.constructor === Number;  // false
Object.prototype.constructor === String;  // false
Object.prototype.constructor === Array;   // false

Object.prototype.toString()

Wartość:

String - wartość będąca połączeniem tekstów: "[object " + nazwa klasy + "]"

Funkcja toString jest wywoływana automatycznie zawsze wtedy, gdy oczekiwana jest wartość tekstowa, a przekazano obiekt.

Przykład Object.prototype.toString

new Object().toString();                            // "[object Object]"
new Object() + "";                                  // "[object Object]"
 
Object.prototype.toString.call(undefined);          // "[object Undefined]"
Object.prototype.toString.call(null);               // "[object Null]"
Object.prototype.toString.call(new Boolean(true));  // "[object Boolean]"
Object.prototype.toString.call(new Number(1));      // "[object Number]"
Object.prototype.toString.call(new String("test")); // "[object String]"
Object.prototype.toString.call(new Array());        // "[object Array]"
 
Object.prototype.toString.call(true);               // "[object Boolean]"
Object.prototype.toString.call(1.2);                // "[object Number]"
Object.prototype.toString.call("test");             // "[object String]"
 
var Cls = function () {};
new Cls() + "";                                     // "[object Object]"
Object.prototype.toString.call(new Cls());          // "[object Object]"
Cls.prototype.toString = function () {
    return "[object Cls]";
};
new Cls() + "";                                     // "[object Cls]"

Object.prototype.toLocaleString()

Wartość:

String - wartość wywołania metody toString

Wyjątki:

TypeError - obiekt nie posiada metody toString

Ta funkcja została wprowadzona, aby dostarczyć wszystkim obiektom spójnego interfejsu do konwersji na tekst w rodzimym języku użytkownika.

Przykład Object.prototype.toLocaleString

new Object().toLocaleString();                   // "[object Object]"
 
Object.prototype.toLocaleString.call(true);      // "true"
Object.prototype.toLocaleString.call(1.2);       // "1.2"
Object.prototype.toLocaleString.call("test");    // "test"
 
Object.prototype.toLocaleString.call(undefined); // TypeError
Object.prototype.toLocaleString.call(null);      // TypeError

Object.prototype.valueOf()

Wartość:

wartość przekazana do konstruktora albo sam niezmieniony obiekt

Wszystkie typy proste (wartość logiczna, liczba, tekst) mają swój odpowiednik obiektowy. Aby skonwertować prostą wartość na obiekt, używamy globalnej funkcji Object. Czasami potrzebujemy wykonać konwersję w drugą stronę - tzn. z typu obiektowego na prosty. Do tego właśnie została przeznaczona funkcja Object.prototype.valueOf. Jeżeli obiekt nie ma jej zaimplementowanej, zwracana jest po prostu nietknięta instancja.

Przykład Object.prototype.valueOf

Object(true).valueOf();   // true
Object(1).valueOf();      // 1
Object("test").valueOf(); // "test"
 
var obj = {};
obj.valueOf() === obj;    // true

Object.prototype.hasOwnProperty(V)

Parametry:

String V - nazwa właściwości

Wartość:

Boolean - czy obiekt posiada podaną właściwość

Sprawdza, czy obiekt posiada właściwość o podanej nazwie. Nie uwzględnia właściwości przejętych z prototypu, a jedynie bezpośrednio przypisane do obiektu.

Przykład Object.prototype.hasOwnProperty

var obj = {test: 1, x: undefined};
obj.m = function () {};
 
obj.hasOwnProperty("test"); // true
obj.hasOwnProperty("x");    // true
obj.hasOwnProperty("m");    // true
obj.hasOwnProperty("p");    // false
 
delete obj.x;
obj.hasOwnProperty("x");    // false
 
var Cls = function () {
    this.p = 1;
};
Cls.prototype.m = function () {};
obj = new Cls();
obj.hasOwnProperty("p");    // true
obj.hasOwnProperty("m");    // false

Object.prototype.isPrototypeOf(V)

Parametry:

V - instancja obiektu

Wartość:

Boolean - czy obiekt jest prototypem podanej instancji

Sprawdza, czy obiekt bieżący jest prototypem podanej instancji obiektu. Sprawdzany jest przy tym cały łańcuch prototypów, wynikający z dziedziczenia.

Przykład Object.prototype.isPrototypeOf

var Device = function () {};
 
var Computer = function () {};
Computer.prototype = Object.create(Device.prototype);
 
var Laptop = function () {};
Laptop.prototype = Object.create(Computer.prototype);
 
Device.prototype.isPrototypeOf(new Device());   // true
Device.prototype.isPrototypeOf(new Computer()); // true
Device.prototype.isPrototypeOf(new Laptop());   // true
Computer.prototype.isPrototypeOf(new Laptop()); // true
Object.prototype.isPrototypeOf(new Laptop());   // true
Object.prototype.isPrototypeOf({});             // true
 
Computer.prototype.isPrototypeOf(new Device()); // false
Object.prototype.isPrototypeOf(true);           // false
Object.prototype.isPrototypeOf(1);              // false
Object.prototype.isPrototypeOf("test");         // false
Object.prototype.isPrototypeOf(null);           // false

Object.prototype.propertyIsEnumerable(V)

Parametry:

String V - nazwa właściwości

Wartość:

Boolean - czy podana właściwość obiektu będzie dostępna w pętli for-in

Sprawdza, czy obiekt posiada właściwość o podanej nazwie, która będzie dostępna w pętli for-in [zobacz: Object.defineProperty - enumerable].

Przykład Object.prototype.propertyIsEnumerable

var obj = {test: undefined};
Object.defineProperty(obj, "p", {enumerable: false});
 
obj.propertyIsEnumerable("test"); // true
obj.propertyIsEnumerable("p");    // false
obj.propertyIsEnumerable("x");    // false