MDN wants to learn about developers like you: https://qsurvey.mozilla.com/s3/MDN-dev-survey

Ky përkthim është i paplotë. Ju lutemi, ndihmoni të përkthehet ky artikull nga Anglishtja.

Metoda Object.create() krijon nje objekt te ri me vecori dhe prototipin e objektit baze qe i kalohet si parameter i pare.

Sintaksa

Object.create(proto[, propertiesObject])

Parametra

proto
Objekti prototip nga te cilate do te krijohet objekti.
propertiesObject
Opsional. Nje objekte me ane te se cilit specifikojme vecorit e reja te objektit te ri, dhe per cdo vecori mund te speficikohet nese keto jane te shkrueshme apo vetem te lexim. Nese specifikohet dhe nuk eshte undefined,  duhet te jete nje objekt.

Vlera e kthyer

Nje objekt i ri me metodat qe ka objeti proto dhe vecorit e mundshme nga propertiesObject

Përjashtim

Një TypeError përjashtim hidhet nese parametri propertiesObject nuk është një null ose një objekt.

Shembuj

Trashëgimi klassike me Object.create()

Më poshtë kemi një shembull si të përdorim Object.create() për të bërë një trashëgimi klasike në Javascript:

// Shape - superclass
function Shape() {
  this.x = 0;
  this.y = 0;
}

// superclass method
Shape.prototype.move = function(x, y) {
  this.x += x;
  this.y += y;
  console.info('Shape moved.');
};

// Rectangle - subclass
function Rectangle() {
  Shape.call(this); // call super constructor.
}

// subclass extends superclass
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log('Is rect an instance of Rectangle?',
  rect instanceof Rectangle); // true
console.log('Is rect an instance of Shape?',
  rect instanceof Shape); // true
rect.move(1, 1); // Outputs, 'Shape moved.'

Nëse duam të trashëgojmë nga më shumë objekte mund të përdorim një përzierje të objekte të ndryshëm:

function MyClass() {
  SuperClass.call(this);
  OtherSuperClass.call(this);
}

// inherit one class
MyClass.prototype = Object.create(SuperClass.prototype);
// mixin another
Object.assign(MyClass.prototype, OtherSuperClass.prototype);

MyClass.prototype.myMethod = function() {
  // do a thing
};

Object.assign kopion vecorit nga prototipi OtherSuperClass tek prototipi MyClass , duke bërë të disponueshme në objeketet e krijuara nga MyClass. Object.assign u fut me ES6 dhe mund të përmbushet manualisht nese brouzeri nuk e ka këtë funksion. Nëse duhet të përdorni këtë metodë ne shfletuesit e vjetër atëherë mund të përdorni, jQuery.extend() ose _.assign().

Përdorimi i propertiesObject me Object.create()

var o;

// create an object with null as prototype
o = Object.create(null);


o = {};
// is equivalent to:
o = Object.create(Object.prototype);


// Example where we create an object with a couple of
// sample properties. (Note that the second parameter
// maps keys to *property descriptors*.)
o = Object.create(Object.prototype, {
  // foo is a regular 'value property'
  foo: {
    writable: true,
    configurable: true,
    value: 'hello'
  },
  // bar is a getter-and-setter (accessor) property
  bar: {
    configurable: false,
    get: function() { return 10; },
    set: function(value) {
      console.log('Setting `o.bar` to', value);
    }
/* with ES5 Accessors our code can look like this
    get function() { return 10; },
    set function(value) {
      console.log('Setting `o.bar` to', value);
    } */
  }
});


function Constructor() {}
o = new Constructor();
// is equivalent to:
o = Object.create(Constructor.prototype);
// Of course, if there is actual initialization code
// in the Constructor function, 
// the Object.create() cannot reflect it


// Create a new object whose prototype is a new, empty
// object and add a single property 'p', with value 42.
o = Object.create({}, { p: { value: 42 } });

// by default properties ARE NOT writable,
// enumerable or configurable:
o.p = 24;
o.p;
// 42

o.q = 12;
for (var prop in o) {
  console.log(prop);
}
// 'q'

delete o.p;
// false

// to specify an ES3 property
o2 = Object.create({}, {
  p: {
    value: 42,
    writable: true,
    enumerable: true,
    configurable: true
  }
});

Përmbushje

Kjo përmbushje mbulon rastin kryesor kur duam të krijojmë një objekt të ri nga një prototip i caktuar. Kjo përmbushje nuk mbështet parametrin e dytë të funksionit origjinal (propertiesObject)

Kjo përmbushje nuk pranon null si vleren e parametrit të parë.

if (typeof Object.create != 'function') {
  Object.create = (function(undefined) {
    var Temp = function() {};
    return function (prototype, propertiesObject) {
      if(prototype !== Object(prototype)) {
        throw TypeError(
          'Argument must be an object, or null'
        );
      }
      Temp.prototype = prototype || {};
      var result = new Temp();
      Temp.prototype = null;
      if (propertiesObject !== undefined) {
        Object.defineProperties(result, propertiesObject); 
      } 
      
      // to imitate the case of Object.create(null)
      if(prototype === null) {
         result.__proto__ = null;
      } 
      return result;
    };
  })();
}

Specifikat

Specification Status Comment
ECMAScript 5.1 (ECMA-262)
The definition of 'Object.create' in that specification.
Standard Initial definition. Implemented in JavaScript 1.8.5.
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'Object.create' in that specification.
Standard  
ECMAScript Latest Draft (ECMA-262)
The definition of 'Object.create' in that specification.
Draft  

Shfletuesit e pajtuar

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support 5 4.0 (2) 9 11.60 5
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Yes) (Yes) 4.0 (2) (Yes) 11.5 (Yes)

Shiko edhe

Etiketa dhe Kontribues Dokumentesh

 Kontributorë te kjo faqe: albanx
 Përditësuar së fundi nga: albanx,