Prototype JavaScript framework - Object

toHTML

2007-11-08T01:39:00Z

toHTML(obj) -> String

Returns the return value of obj’s toHTML method if it exists, else runs obj through String.interpret.

Examples


var Bookmark = Class.create({
  initialize: function(name, url) {
    this.name = name;
    this.url = url;
  },

  toHTML: function() {
    return '<a href="#{url}">#{name}</a>'.interpolate(this);
  }
});

var api = new Bookmark('Prototype API', 'http://prototypejs.org/api');

Object.toHTML(api);
//-> '<a href="http://prototypejs.org/api">Prototype API</a>'

Object.toHTML("Hello world!");
//-> "Hello world!"

Object.toHTML();
//-> ""

Object.toHTML(null);
//-> ""

Object.toHTML(undefined);
//-> ""

Object.toHTML(true);
//-> "true"

Object.toHTML(false);
//-> "false"

Object.toHTML(123);
//-> "123"

isFunction

2007-11-08T01:36:00Z

isFunction(obj) -> Boolean

Returns true if obj is of type function, false otherwise.

Examples


Object.isFunction($);
//-> true

Object.isFunction(123);
//-> false

isNumber

2007-11-08T01:33:00Z

isNumber(obj) -> Boolean

Returns true if obj is of type number, false otherwise.

Examples


Object.isNumber(0);
//-> true

Object.isNumber(1.2);
//-> true

Object.isNumber("foo");
//-> false

isString

2007-11-08T01:31:00Z

isString(obj) -> Boolean

Returns true if obj is of type string, false otherwise.

Examples


Object.isString("foo");
//-> true

Object.isString("");
//-> true

Object.isString(123);
//-> false

isUndefined

2007-11-08T01:28:00Z

isUndefined(obj) -> Boolean

Returns true if obj is of type undefined, false otherwise.

Examples


Object.isUndefined();
//-> true

Object.isUndefined(undefined);
//-> true

Object.isUndefined(null);
//-> false

Object.isUndefined(0);
//-> false

Object.isUndefined("");
//-> false

isHash

2007-11-08T01:24:00Z

isHash(obj) -> Boolean

Returns true if obj is an instance of the Hash class, false otherwise.

Examples


Object.isHash(new Hash({ }));
//-> true

Object.isHash($H({ }));
//-> true

Object.isHash({ });
//-> false

isArray

2007-11-08T01:22:00Z

isArray(obj) -> Boolean

Returns true if obj is an array, false otherwise.

Examples


Object.isArray([]);
//-> true

Object.isArray($w());
//-> true

Object.isArray({ });
//-> false

isElement

2007-11-08T01:16:00Z

isElement(obj) -> Boolean

Returns true if obj is a DOM node of type 1, false otherwise.

Examples


Object.isElement(new Element('div'));
//-> true

Object.isElement(document.createElement('div'));
//-> true

Object.isElement($('id_of_an_exiting_element'));
//-> true

Object.isElement(document.createTextNode('foo'));
//-> false

toQueryString

2007-11-07T21:01:00Z

toQueryString(obj) -> String

Turns an object into its URL-encoded query string representation.

This is a form of serialization, and is mostly useful to provide complex parameter sets for stuff such as objects in the Ajax namespace (e.g. Ajax.Request).

Undefined-value pairs will be serialized as if empty-valued. Array-valued pairs will get serialized with one name/value pair per array element. All values get URI-encoded using JavaScript’s native encodeURIComponent function.

The order of pairs in the serialized form is not guaranteed (and mostly irrelevant anyway), except for array-based parts, which are serialized in array order.

Examples

Object.toQueryString({ action: 'ship', order_id: 123, fees: ['f1', 'f2'], 'label': 'a demo' })
// -> 'action=ship&order_id=123&fees=f1&fees=f2&label=a%20demo'

toJSON

2007-03-10T00:57:00Z

toJSON(obj) -> String

Returns a JSON string.

For more information on Prototype’s JSON encoder, hop to our tutorial.

Example


var data = {name: 'Violet', occupation: 'character', age: 25, pets: ['frog', 'rabbit']};
Object.toJSON(data);
//-> '{"name": "Violet", "occupation": "character", "age": 25, "pets": ["frog","rabbit"]}'

values

2007-01-08T18:14:00Z

Object.values(obj) -> Array

Treats any object as a Hash and fetches the list of its property values.

Note that the order of the resulting Array is browser-dependent (it relies on the for…in loop), and is therefore not guaranteed to follow either declaration or lexicographical order. Also, remember that while property names are unique, property values have no constraint whatsoever.

Examples


Object.values()
// -> []

Object.values({ name: 'Prototype', version: 1.5 }).sort()
// -> [1.5, 'Prototype']

keys

2007-01-08T18:13:00Z

Object.keys(obj) -> [String...]

Treats any object as a Hash and fetches the list of its property names.

Examples


Object.keys()
// -> []

Object.keys({ name: 'Prototype', version: 1.5 }).sort()
// -> ['name', 'version']

clone

2007-01-08T18:03:00Z

Object.clone(obj) -> Object

Clones the passed object using shallow copy (copies all the original’s properties to the result).

Do note that this is shallow copy, not deep copy.

Examples


var o = { name: 'Prototype', version: 1.5, authors: ['sam', 'contributors'] };
var o2 = Object.clone(o);

o2.version = '1.5 weird';
o2.authors.pop();

o.version
// -> 1.5

o2.version
// -> '1.5 weird'

o.authors
// -> ['sam'] // Ouch!  Shallow copy!

extend

2007-01-08T18:03:00Z

Object.extend(dest, src) -> alteredDest

Copies all properties from the source to the destination object. Used by Prototype to simulate inheritance (rather statically) by copying to prototypes.

Documentation should soon become available that describes how Prototype implements OOP, where you will find further details on how Prototype uses Object.extend and Class.create (something that may well change in version 2.0). It will be linked from here.

Do not mistake this method with its quasi-namesake Element.extend, which implements Prototype’s (much more complex) DOM extension mechanism.

inspect

2007-01-08T17:02:00Z

Object.inspect(obj) -> String

Returns the debug-oriented string representation of the object.

undefined and null are represented as such.
Other types are looked up for a inspect method: if there is one, it is used, otherwise, it reverts to the toString method.

Prototype provides inspect methods for many types, both built-in and library-defined, such as in String, Array, Enumerable and Hash, which attempt to provide most-useful string representations (from a developer’s standpoint) for their respective types.

Examples


Object.inspect()
// -> 'undefined'

Object.inspect(null)
// -> 'null'

Object.inspect(false)
// -> 'false'

Object.inspect([1, 2, 3])
// -> '[1, 2, 3]'

Object.inspect('hello')
// -> "'hello'"