Object

Parse. Object

Creates a new model with defined attributes.

You won't normally call this method directly. It is recommended that you use a subclass of Parse.Object instead, created by calling extend.

However, if you don't want to use a subclass, or aren't sure which subclass is appropriate, you can use this form:

    var object = new Parse.Object("ClassName");
That is basically equivalent to:
    var MyClass = Parse.Object.extend("ClassName");
    var object = new MyClass();

Constructor

new Object(className, attributes, options)

Parameters:
Name Type Description
className String

The class name for the object

attributes Object

The initial set of data to store in the object.

options Object

The options for this object instance.

Members

attributes

Prototype getters / setters

createdAt :Date

The first time this object was saved on the server.

Properties:
Name Type Description
createdAt
Type:
  • Date

updatedAt :Date

The last time this object was updated on the server.

Properties:
Name Type Description
updatedAt
Type:
  • Date

Methods

(static) _clearAllState()

Static methods

(static) createWithoutData(id) → {Parse.Object}

Creates a reference to a subclass of Parse.Object with the given id. This does not exist on Parse.Object, only on subclasses.

A shortcut for:

 var Foo = Parse.Object.extend("Foo");
 var pointerToFoo = new Foo();
 pointerToFoo.id = "myObjectId";

Parameters:
Name Type Description
id String

The ID of the object to create a reference to.

Returns:
Type:
Parse.Object

A Parse.Object reference.

(static) destroyAll(list, options) → {Promise}

Destroy the given list of models on the server if it was already persisted.

Unlike saveAll, if an error occurs while deleting an individual model, this method will continue trying to delete the rest of the models if possible, except in the case of a fatal error like a connection error.

In particular, the Parse.Error object returned in the case of error may be one of two types:

  • A Parse.Error.AGGREGATE_ERROR. This object's "errors" property is an array of other Parse.Error objects. Each error object in this array has an "object" property that references the object that could not be deleted (for instance, because that object could not be found).
  • A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).
  Parse.Object.destroyAll([object1, object2, ...])
   .then((list) => {
     // All the objects were deleted.
   }, (error) => {
     // An error occurred while deleting one or more of the objects.
     // If this is an aggregate error, then we can inspect each error
     // object individually to determine the reason why a particular
     // object was not deleted.
     if (error.code === Parse.Error.AGGREGATE_ERROR) {
       for (var i = 0; i < error.errors.length; i++) {
         console.log("Couldn't delete " + error.errors[i].object.id +
           "due to " + error.errors[i].message);
       }
     } else {
       console.log("Delete aborted because of " + error.message);
     }
  });
Parameters:
Name Type Description
list Array

A list of Parse.Object.

options Object
Returns:
Type:
Promise

A promise that is fulfilled when the destroyAll completes.

(static) disableSingleInstance()

Disable single instance objects, where any local objects with the same Id share the same attributes, and stay synchronized with each other. When disabled, you can have two instances of the same object in memory without them sharing attributes.

(static) enableSingleInstance()

Enable single instance objects, where any local objects with the same Id share the same attributes, and stay synchronized with each other. This is disabled by default in server environments, since it can lead to security issues.

(static) extend(className, protoProps, classProps) → {Class}

Creates a new subclass of Parse.Object for the given Parse class name.

Every extension of a Parse class will inherit from the most recent previous extension of that class. When a Parse.Object is automatically created by parsing JSON, it will use the most recent extension of that class.

You should call either:

    var MyClass = Parse.Object.extend("MyClass", {
        Instance methods,
        initialize: function(attrs, options) {
            this.someInstanceProperty = [],
            Other instance properties
        }
    }, {
        Class properties
    });
or, for Backbone compatibility:
    var MyClass = Parse.Object.extend({
        className: "MyClass",
        Instance methods,
        initialize: function(attrs, options) {
            this.someInstanceProperty = [],
            Other instance properties
        }
    }, {
        Class properties
    });

Parameters:
Name Type Description
className String

The name of the Parse class backing this model.

protoProps Object

Instance properties to add to instances of the class returned from this method.

classProps Object

Class properties to add the class returned from this method.

Returns:
Type:
Class

A new subclass of Parse.Object.

(static) fetchAll(list, options)

Fetches the given list of Parse.Object. If any error is encountered, stops and calls the error handler.

  Parse.Object.fetchAll([object1, object2, ...])
   .then((list) => {
     // All the objects were fetched.
   }, (error) => {
     // An error occurred while fetching one of the objects.
   });
Parameters:
Name Type Description
list Array

A list of Parse.Object.

options Object

Valid options are:

  • useMasterKey: In Cloud Code and Node only, causes the Master Key to be used for this request.
  • sessionToken: A valid session token, used for making a request on behalf of a specific user.
  • include: The name(s) of the key(s) to include. Can be a string, an array of strings, or an array of array of strings.

(static) fetchAllIfNeeded(list, options)

Fetches the given list of Parse.Object if needed. If any error is encountered, stops and calls the error handler.

  Parse.Object.fetchAllIfNeeded([object1, ...])
   .then((list) => {
     // Objects were fetched and updated.
   }, (error) => {
     // An error occurred while fetching one of the objects.
   });
Parameters:
Name Type Description
list Array

A list of Parse.Object.

options Object

(static) fetchAllWithInclude(list, keys, options)

Fetches the given list of Parse.Object.

Includes nested Parse.Objects for the provided key. You can use dot notation to specify which fields in the included object are also fetched.

If any error is encountered, stops and calls the error handler.

  Parse.Object.fetchAllWithInclude([object1, object2, ...], [pointer1, pointer2, ...])
   .then((list) => {
     // All the objects were fetched.
   }, (error) => {
     // An error occurred while fetching one of the objects.
   });
Parameters:
Name Type Description
list Array

A list of Parse.Object.

keys String | Array.<(string|Array.<string>)>

The name(s) of the key(s) to include.

options Object

Valid options are:

  • useMasterKey: In Cloud Code and Node only, causes the Master Key to be used for this request.
  • sessionToken: A valid session token, used for making a request on behalf of a specific user.

(static) fromJSON(json, override) → {Parse.Object}

Creates a new instance of a Parse Object from a JSON representation.

Parameters:
Name Type Description
json Object

The JSON map of the Object's data

override boolean

In single instance mode, all old server data is overwritten if this is set to true

Returns:
Type:
Parse.Object

A Parse.Object reference

(static) registerSubclass(className, constructor)

Registers a subclass of Parse.Object with a specific class name. When objects of that class are retrieved from a query, they will be instantiated with this subclass. This is only necessary when using ES6 subclassing.

Parameters:
Name Type Description
className String

The class name of the subclass

constructor Class

The subclass

(static) saveAll(list, options)

Saves the given list of Parse.Object. If any error is encountered, stops and calls the error handler.

  Parse.Object.saveAll([object1, object2, ...])
   .then((list) => {
      // All the objects were saved.
   }, (error) => {
      // An error occurred while saving one of the objects.
   });
Parameters:
Name Type Description
list Array

A list of Parse.Object.

options Object

_clearPendingOps(keysToClearopt)

Parameters:
Name Type Attributes Description
keysToClear Array.<string> <optional>

if specified, only ops matching these fields will be cleared

_getId()

Returns a local or server Id used uniquely identify this object

_getStateIdentifier()

Returns a unique identifier used to pull data from the State Controller.

add(attr, item) → {ParseObject|Boolean}

Atomically add an object to the end of the array associated with a given key.

Parameters:
Name Type Description
attr String

The key.

item

The item to add.

Returns:
Type:
ParseObject | Boolean

addAll(attr, items)

Atomically add the objects to the end of the array associated with a given key.

Parameters:
Name Type Description
attr String

The key.

items Array.<Object>

The items to add.

addAllUnique(attr, items)

Atomically add the objects to the array associated with a given key, only if it is not already present in the array. The position of the insert is not guaranteed.

Parameters:
Name Type Description
attr String

The key.

items Array.<Object>

The objects to add.

addUnique(attr, item)

Atomically add an object to the array associated with a given key, only if it is not already present in the array. The position of the insert is not guaranteed.

Parameters:
Name Type Description
attr String

The key.

item

The object to add.

clear() → {ParseObject|boolean}

Clears all attributes on a model

Returns:
Type:
ParseObject | boolean

clone() → {Parse.Object}

Creates a new model with identical attributes to this one.

Returns:
Type:
Parse.Object

destroy(options) → {Promise}

Destroy this model on the server if it was already persisted.

Parameters:
Name Type Description
options Object

Valid options are:

  • useMasterKey: In Cloud Code and Node only, causes the Master Key to be used for this request.
  • sessionToken: A valid session token, used for making a request on behalf of a specific user.

Returns:
Type:
Promise

A promise that is fulfilled when the destroy completes.

dirty(attr) → {Boolean}

Returns true if this object has been modified since its last save/refresh. If an attribute is specified, it returns true only if that particular attribute has been modified since the last save/refresh.

Parameters:
Name Type Description
attr String

An attribute name (optional).

Returns:
Type:
Boolean

dirtyKeys() → {Array.<String>}

Returns an array of keys that have been modified since last save/refresh

Returns:
Type:
Array.<String>

equals(other) → {Boolean}

Determines whether this ParseObject is equal to another ParseObject

Parameters:
Name Type Description
other Object

An other object ot compare

Returns:
Type:
Boolean

escape(attr)

Gets the HTML-escaped value of an attribute.

Parameters:
Name Type Description
attr String

The string name of an attribute.

existed() → {Boolean}

Returns true if this object was created by the Parse server when the object might have already been there (e.g. in the case of a Facebook login)

Returns:
Type:
Boolean

fetch(options) → {Promise}

Fetch the model from the server. If the server's representation of the model differs from its current attributes, they will be overriden.

Parameters:
Name Type Description
options Object

Valid options are:

  • useMasterKey: In Cloud Code and Node only, causes the Master Key to be used for this request.
  • sessionToken: A valid session token, used for making a request on behalf of a specific user.
  • include: The name(s) of the key(s) to include. Can be a string, an array of strings, or an array of array of strings.

Returns:
Type:
Promise

A promise that is fulfilled when the fetch completes.

fetchWithInclude(keys, options) → {Promise}

Fetch the model from the server. If the server's representation of the model differs from its current attributes, they will be overriden.

Includes nested Parse.Objects for the provided key. You can use dot notation to specify which fields in the included object are also fetched.

Parameters:
Name Type Description
keys String | Array.<(string|Array.<string>)>

The name(s) of the key(s) to include.

options Object

Valid options are:

  • useMasterKey: In Cloud Code and Node only, causes the Master Key to be used for this request.
  • sessionToken: A valid session token, used for making a request on behalf of a specific user.

Returns:
Type:
Promise

A promise that is fulfilled when the fetch completes.

get(attr)

Gets the value of an attribute.

Parameters:
Name Type Description
attr String

The string name of an attribute.

getACL() → {Parse.ACL}

Returns the ACL for this object.

See:
Returns:
Type:
Parse.ACL

An instance of Parse.ACL.

has(attr) → {Boolean}

Returns true if the attribute contains a value that is not null or undefined.

Parameters:
Name Type Description
attr String

The string name of the attribute.

Returns:
Type:
Boolean

increment(attr, amount)

Atomically increments the value of the given attribute the next time the object is saved. If no amount is specified, 1 is used by default.

Parameters:
Name Type Description
attr String

The key.

amount Number

The amount to increment by (optional).

initialize()

Public methods

isNew() → {Boolean}

Returns true if this object has never been saved to Parse.

Returns:
Type:
Boolean

isValid() → {Boolean}

Checks if the model is currently in a valid state.

Returns:
Type:
Boolean

newInstance() → {Parse.Object}

Creates a new instance of this object. Not to be confused with clone()

Returns:
Type:
Parse.Object

op(attr) → {Parse.Op}

Returns an instance of a subclass of Parse.Op describing what kind of modification has been performed on this field since the last time it was saved. For example, after calling object.increment("x"), calling object.op("x") would return an instance of Parse.Op.Increment.

Parameters:
Name Type Description
attr String

The key.

Returns:
Type:
Parse.Op

The operation, or undefined if none.

relation(String) → {Parse.Relation}

Gets a relation on the given class for the attribute.

Parameters:
Name Type Description
String

attr The attribute to get the relation for.

Returns:
Type:
Parse.Relation

remove(attr, item)

Atomically remove all instances of an object from the array associated with a given key.

Parameters:
Name Type Description
attr String

The key.

item

The object to remove.

removeAll(attr, items)

Atomically remove all instances of the objects from the array associated with a given key.

Parameters:
Name Type Description
attr String

The key.

items Array.<Object>

The object to remove.

revert(…keysopt)

Clears any (or specific) changes to this object made since the last call to save()

Parameters:
Name Type Attributes Description
keys string <optional>
<repeatable>

specify which fields to revert

save(options) → {Promise}

Set a hash of model attributes, and save the model to the server. updatedAt will be updated when the request returns. You can either call it as:

  object.save();
or
  object.save(null, options);
or
  object.save(attrs, options);
or
  object.save(key, value, options);

For example,

  gameTurn.save({
    player: "Jake Cutter",
    diceRoll: 2
  }).then(function(gameTurnAgain) {
    // The save was successful.
  }, function(error) {
    // The save failed.  Error is an instance of Parse.Error.
  });

Parameters:
Name Type Description
options Object

Valid options are:

  • useMasterKey: In Cloud Code and Node only, causes the Master Key to be used for this request.
  • sessionToken: A valid session token, used for making a request on behalf of a specific user.

Returns:
Type:
Promise

A promise that is fulfilled when the save completes.

set(key, value, options) → {Boolean}

Sets a hash of model attributes on the object.

You can call it with an object containing keys and values, or with one key and value. For example:

  gameTurn.set({
    player: player1,
    diceRoll: 2
  }, {
    error: function(gameTurnAgain, error) {
      // The set failed validation.
    }
  });

  game.set("currentPlayer", player2, {
    error: function(gameTurnAgain, error) {
      // The set failed validation.
    }
  });

  game.set("finished", true);

Parameters:
Name Type Description
key String

The key to set.

value

The value to give it.

options Object

A set of options for the set. The only supported option is error.

Returns:
Type:
Boolean

true if the set succeeded.

setACL(acl, options) → {Boolean}

Sets the ACL to be used for this object.

See:
Parameters:
Name Type Description
acl Parse.ACL

An instance of Parse.ACL.

options Object
Returns:
Type:
Boolean

Whether the set passed validation.

toJSON() → {Object}

Returns a JSON version of the object suitable for saving to Parse.

Returns:
Type:
Object

toPointer() → {Pointer}

Gets a Pointer referencing this Object.

Returns:
Type:
Pointer

unset(attr)

Remove an attribute from the model. This is a noop if the attribute doesn't exist.

Parameters:
Name Type Description
attr String

The string name of an attribute.

validate(attrs)

You should not call this function directly unless you subclass Parse.Object, in which case you can override this method to provide additional validation on set and save. Your implementation should return

See:
Parameters:
Name Type Description
attrs Object

The current data to validate.

Returns:

False if the data is valid. An error object otherwise.