ZebraJS

// select an element by ID
  var element = $('#foo');

  // select element by class name
  var elements = $('.foo');

  // select elements by using JavaScript
  var elements = $(document.querySelectorAll('.foo'));

  // use CSS selectors
  var elements = $(input[type=text]);

  // create elements
  var element = $('<div>').addClass('foo').appendTo($('body'));

  

Methods

$.ajax(urlopt, options)

Source:

• zebra.src.js, line 477

Example

$.ajax({
     url: 'http://mydomain.com/index.html',
     method: 'GET',
     data: {
         foo: 'baz',
         bar: 'bax'
     },
     error: function() {
         alert('error!');
     },
     success: function() {
         alert('success!');
     }
 });

 

Parameters:

$.each(callback) → {undefined}

Source:

• zebra.src.js, line 623

Example

$.each([1, 2, 3, 4], function(index, value) {
     console.log(index + ': ' + value);
 });

 var obj = {
     prop1:  'value1',
     prop2:  'value2'
 };
 $.each(obj, function(index, value) {
     console.log(index + ': ' + value);
 });

 

Parameters:

Returns:

Type

undefined

$.extend(target) → {object}

Source:

• zebra.src.js, line 669

Example

// merge the properties of the last 2 objects into the first one
 $.extend({}, {foo:  'baz'}, {bar: 'biz'});

 // the result
 // {foo: 'baz', bar: 'biz'}

 

Parameters:

Returns:

Type

object

$.inArray(value, array) → {integer}

Source:

• zebra.src.js, line 730

Example

// returns 4
 $.inArray(5, [1, 2, 3, 4, 5, 6, 7]);

 

Parameters:

Returns:

Type

integer

$.isArray(object) → {bool}

Source:

• zebra.src.js, line 757

Example

// returns TRUE
 $.isArray([1, 2, 3, 4, 5, 6, 7]);

 

Parameters:

Returns:

Type

bool

addClass(class_name) → {ZebraJS}

Source:

• zebra.src.js, line 791

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // add a single class
 elements.addClass('foo');

 // add multiple classes
 elements.addClass('foo baz');

 // chaining
 elements.addClass('foo baz').css('display', 'none');

 

Parameters:

Returns:

Type

ZebraJS

after(content) → {ZebraJS}

Source:

• zebra.src.js, line 843

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var target = $('#selector');

 // insert a div that we create on the fly
 target.after($('<div>').text('hello'));

 // same thing as above
 target.after($('<div>hello</div>'));

 // inserting elements already existing on the page
 target.after($('ul'));

 // insert a string (which will be transformed in HTML)
 target.after('<div>hello</div>');

 // chaining
 target.append($('div')).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

animate(properties, durationopt, easingopt, callbackopt) → {ZebraJS}

Source:

• zebra.src.js, line 902

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // fade out
 elements.animate({
     opacity: 0
 }, 250, function() {
     console.log('Animation is complete!');
 });

 

Parameters:

Returns:

Type

ZebraJS

append(content) → {ZebraJS}

Source:

• zebra.src.js, line 1014

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var parent = $('#selector');

 // append a div that we create on the fly
 parent.append($('<div>').text('hello'));

 // same thing as above
 parent.append($('<div>hello</div>'));

 // append one or more elements that already exist on the page
 // if "parent" is a single element than the list will be moved inside the parent element
 // if "parent" is a collection of elements, clones of the list element will be created for
 // each target except for the last one; for the last target, the original list will be moved
 parent.append($('ul'));

 // append a string (which will be transformed in HTML)
 // this is more efficient memory wise
 parent.append('<div>hello</div>');

 // chaining
 parent.append($('div')).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

appendTo(parent) → {ZebraJS}

Source:

• zebra.src.js, line 1061

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var parent = $('#selector');

 // append a div that we create on the fly
 $('<div>').text('hello').appendTo(parent);

 // same thing as above
 $('<div>hello</div>').appendTo(parent);

 // append one or more elements that already exist on the page
 // if "parent" is a single element than the list will be moved inside the parent element
 // if "parent" is a collection of elements, clones of the list element will be created for
 // each target except for the last one; for the last target, the original list will be moved
 $('ul').appendTo(parent);

 

Parameters:

Returns:

Type

ZebraJS

attr(attribute, valueopt) → {ZebraJS|mixed}

Source:

• zebra.src.js, line 1121

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // get the value of an attribute for the first
 // element in the set of matched elements
 elements.attr('id');

 // set a single attribute
 elements.attr('title', 'title');

 // set multiple attributes
 elements.attr({
     title: 'title',
     href: 'href'
 });

 // remove an attribute
 elements.attr('title', false);

 // chaining
 elements.attr('title', 'title').removeClass('foo');

 

Parameters:

Returns:

Type

ZebraJS | mixed

before(content) → {ZebraJS}

Source:

• zebra.src.js, line 1217

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var target = $('#selector');

 // insert a div that we create on the fly
 target.before($('<div>').text('hello'));

 // same thing as above
 target.before($('<div>hello</div>'));

 // use one or more elements that already exist on the page
 // if "target" is a single element than the list will be moved before the target element
 // if "parent" is a collection of elements, clones of the list element will be created before
 // each target, except for the last one; the original list will be moved before the last target
 target.before($('ul'));

 // insert a string (which will be transformed in HTML)
 // this is more efficient memory wise
 target.append('<div>hello</div>');

 // chaining
 target.append($('div')).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

children(selector) → {ZebraJS}

Source:

• zebra.src.js, line 1251

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get all the element's children
 var children_all = element.children();

 // get all the "div" children of the element
 var children_filtered = element.children('div');

 // chaining
 element.children('div').addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

clone(with_data_and_events, deep_with_data_and_events) → {ZebraJS}

Source:

• zebra.src.js, line 1297

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // clone element with data and events, including data and events of children
 var clones = element.clone(true, true)

 // chaining - clone and insert into the body element
 element.clone(true, true).appendTo($('body'));

 

Parameters:

Returns:

Type

ZebraJS

closest(selector) → {ZebraJS}

Source:

• zebra.src.js, line 1379

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get the first parent that is a div
 var closest = element.closest('div');

 // chaining
 element.closest('div').addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

css(property, valueopt) → {ZebraJS|mixed}

Source:

• zebra.src.js, line 1464

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // get the value of a computed style property
 // for the first element in the set of matched elements
 elements.css('width');

 // set a single CSS property
 elements.css('position', 'absolute');

 // set multiple CSS properties
 elements.css({
     position: 'absolute',
     left: 0,
     top: 0
 });

 // remove a property
 elements.attr('position', false);

 // chaining
 elements.css('position', 'absolute').removeClass('foo');

 

Parameters:

Returns:

Type

ZebraJS | mixed

data(name, value) → {ZebraJS|mixed}

Source:

• zebra.src.js, line 1567

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // set some data
 elements.data('foo', 'baz');

 // retrieve previously set data
 elements.data('foo');

 // set an object as data
 elements.data('foo', {bar: 'baz', qux: 2});

 

Parameters:

Returns:

Type

ZebraJS | mixed

detach() → {ZebraJS}

Source:

• zebra.src.js, line 1659

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // remove elements from the DOM
 var detached = element.detach();

 // add them back, together with data and events,
 // to the end of the body element
 $('body').insert(detached);

 

Returns:

Type

ZebraJS

each(callback) → {undefined}

Source:

• zebra.src.js, line 1709

Example

$('selector').each(function(index) {

     // show the element's index in the set
     console.log(index);

     // remember, inside the callback, the "this" keyword refers to the DOM element
     $(this).css('display', 'none');

 });

 

Parameters:

Returns:

Type

undefined

eq(index) → {ZebraJS}

Source:

• zebra.src.js, line 1741

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('.selector');

 // assuming there are 6 elements in the set of matched elements
 // add the "foo" class to the 5th element
 elements.eq(4).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

find(selector) → {ZebraJS}

Source:

• zebra.src.js, line 1777

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // find the element's div descendants
 var target = element.find('div');

 // this is equivalent with the above
 var target = $('div', element);

 // chaining
 element.find('div').addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

first() → {ZebraJS}

Source:

• zebra.src.js, line 1836

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // returns the first element from the list of matched elements, as a ZebraJS object
 var first = elements.first();

 

Returns:

Type

ZebraJS

get(index)

Source:

• zebra.src.js, line 1862

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // this gets the second DOM element from the list of matched elements
 elements.get(1);

 

Parameters:

hasClass(class_name) → {boolean}

Source:

• zebra.src.js, line 1893

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // check if matched elements have a certain class
 var class_exists = elements.hasClass('foo');

 // chaining
 elements.toggleClass('foo');

 

Parameters:

Returns:

Type

boolean

height(heightopt) → {ZebraJS|float}

Source:

• zebra.src.js, line 1951

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // returns the current computed inner height of the first element in the set of matched elements
 elements.height();

 // sets the "height" CSS property of all elements in the set to 200px
 elements.height(200);
 elements.height('200');
 elements.height('200px');

 // sets the "height" CSS property of all elements in the set to 5em
 elements.height('5em');

 // chaining
 elements.height(200).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS | float

html(contentopt) → {ZebraJS|string}

Source:

• zebra.src.js, line 2020

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // set the HTML content for all the matched elements
 elements.html('<p>Hello</p>');

 // get the HTML content of the first
 // element in the set of matched elements
 var content = elements.html();

 // chaining
 elements.html('<p>Hello</p>').addClass('foo');
 

Parameters:

Returns:

Type

ZebraJS | string

insertAfter(target) → {ZebraJS}

Source:

• zebra.src.js, line 2143

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var target = $('#selector');

 // insert a div that we create on the fly
 $('<div>').text('hello').insertAfter(target);

 // same thing as above
 $('<div>hello</div>').insertAfter(target);

 // use one or more elements that already exist on the page
 // if "target" is a single element than the list will be moved after the target element
 // if "parent" is a collection of elements, clones of the list element will be created after
 // each target, except for the last one; the original list will be moved after the last target
 $('ul').insertAfter(target);

 

Parameters:

Returns:

Type

ZebraJS

insertBefore(target) → {ZebraJS}

Source:

• zebra.src.js, line 2190

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var target = $('#selector');

 // insert a div that we create on the fly
 $('<div>').text('hello').insertBefore(target);

 // same thing as above
 $('<div>hello</div>').insertBefore(target);

 // use one or more elements that already exist on the page
 // if "target" is a single element than the list will be moved before the target element
 // if "parent" is a collection of elements, clones of the list element will be created before
 // each target, except for the last one; the original list will be moved before the last target
 $('ul').insertBefore(target);

 

Parameters:

Returns:

Type

ZebraJS

is(selector) → {boolean}

Source:

• zebra.src.js, line 2067

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // returns true if the element is a "select" element
 console.log(element.is('select'))

 

Parameters:

Returns:

Type

boolean

next(selector) → {ZebraJS}

Source:

• zebra.src.js, line 2226

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get the next sibling
 var next = element.next();

 // get the following sibling only if it matches the selector
 var next = element.next('div');

 // chaining
 element.next().addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

not(selector)

Source:

• zebra.src.js, line 2254

Example

// find all elements having class ".foo" but not ".bar"
 $('.foo').not('.bar');

 

Parameters:

off(event_type, callback) → {ZebraJS}

Source:

• zebra.src.js, line 2314

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // create a function
 var callback = function(e) {
     console.log('clicked!');
 }

 // handle clicks on element using the function created above
 element.on('click', callback);

 // remove that particular click event
 element.off('click', callback);

 // remove *all* the click events
 element.off('click');

 // remove *only* the click events that were namespaced
 element.off('click.namespace');

 

Parameters:

Returns:

Type

ZebraJS

offset() → {object}

Source:

• zebra.src.js, line 2399

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get the element's position, relative to the offset parent
 var offset = element.offset()

 

Returns:

Type

object

on(event_type, selectoropt, callback) → {ZebraJS}

Source:

• zebra.src.js, line 2472

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // create a function
 var callback = function(e) {
     console.log('clicked!');
 }

 // handle clicks on element using the function created above
 element.on('click', callback);

 // handle clicks on element using an anonymous function
 element.on('click', function(e) {
     console.log('clicked!');
 });

 // namespacing, so that you can remove only certain events
 element.on('click.namespace', function(e) {
     console.log('clicked!');
 });

 // using delegation
 // handle clicks on all the "div" elements
 // that are children of the element
 element.on('click', 'div', function(e) {
     console.log('clicked!');
 });

 // chaining
 element.on('click', function() {
     console.log('clicked!');
 }).addClass('foo');

 // multiple events
 element.on({
     mouseenter: function() { ... },
     mouseleave: function() { ... }
 });

 

Parameters:

Returns:

Type

ZebraJS

one(event_type, selectoropt, callback) → {ZebraJS}

Source:

• zebra.src.js, line 2631

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // create a function
 var callback = function(e) {
     console.log('clicked!');
 }

 // handle clicks on element using the function created above
 // (the callback will be executed only once)
 element.one('click', callback);

 // handle clicks on element using an anonymous function
 // (the callback will be executed only once)
 element.one('click', function(e) {
     console.log('clicked!');
 });

 // namespacing, so that you can remove only certain events
 // (the callback will be executed only once)
 element.one('click.namespace', function(e) {
     console.log('clicked!');
 });

 // using delegation
 // handle clicks on all the "div" elements
 // that are children of the element
 // (the callback will be executed only once for each matched element)
 element.one('click', 'div', function(e) {
     console.log('clicked!');
 });

 // chaining
 element.one('click', function() {
     console.log('clicked!');
 }).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

outerHeight(include_marginsopt) → {float}

Source:

• zebra.src.js, line 2664

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('selector');

 // get the element's outer height
 var height = element.outerHeight();

 

Parameters:

Returns:

Type

float

outerWidth(include_marginsopt) → {float}

Source:

• zebra.src.js, line 2705

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('selector');

 // get the element's outer width
 var height = element.outerWidth();

 

Parameters:

Returns:

Type

float

parent(selector) → {ZebraJS}

Source:

• zebra.src.js, line 2751

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get the element's parent
 var parent = element.parent();

 // get the element's parent *only* if it is a div
 var parent = element.parent('div');

 // chaining
 element.parent().addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

parents(selector) → {ZebraJS}

Source:

• zebra.src.js, line 2804

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get *all* the element's parent
 var parents = element.parents();

 // get all the element's parent until the first div (including also that first div)
 var parents = element.parents('div');

 // chaining
 element.parents('div').addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

position() → {object}

Source:

• zebra.src.js, line 2853

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get the element's position, relative to the offset parent
 var position = element.position()

 

Returns:

Type

object

prepend(content) → {ZebraJS}

Source:

• zebra.src.js, line 2911

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var parent = $('#selector');

 // append a div that we create on the fly
 parent.prepend($('<div>').text('hello'));

 // same thing as above
 parent.prepend($('<div>hello</div>'));

 // prepend one or more elements that already exist on the page
 // if "parent" is a single element than the list will be moved inside the parent element
 // if "parent" is a collection of elements, clones of the list element will be created for
 // each target except for the last one; for the last target, the original list will be moved
 parent.prepend($('ul'));

 // prepend a string (which will be transformed in HTML)
 // this is more efficient memory wise
 parent.prepend('<div>hello</div>');

 // chaining
 parent.prepend($('div')).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

prependTo(parent) → {ZebraJS}

Source:

• zebra.src.js, line 2958

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var parent = $('#selector');

 // prepend a div that we create on the fly
 $('<div>').text('hello').prependTo(parent);

 // same thing as above
 $('<div>hello</div>').prependTo(parent);

 // prepend one or more elements that already exist on the page
 // if "parent" is a single element than the list will be moved inside the parent element
 // if "parent" is a collection of elements, clones of the list element will be created for
 // each target except for the last one; for the last target, the original list will be moved
 $('ul').appendTo(parent);

 

Parameters:

Returns:

Type

ZebraJS

prev(selector) → {ZebraJS}

Source:

• zebra.src.js, line 2994

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get the previous sibling
 var prev = element.prev();

 // get the previous sibling only if it matches the selector
 var prev = element.prev('div');

 // since this method returns a ZebraJS object
 element.prev().addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

ready(callback) → {ZebraJS}

Source:

• zebra.src.js, line 3019

Example

$(document).ready(function() {
     // code to be executed when the DOM is ready
 });

 

Parameters:

Returns:

Type

ZebraJS

remove() → {ZebraJS}

Source:

• zebra.src.js, line 3056

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // remove the element, its children, and all attached event
 // handlers and data attributes associated with the elements
 element.remove();

 

Returns:

Type

ZebraJS

removeClass(class_name) → {ZebraJS}

Source:

• zebra.src.js, line 3126

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // remove a single class
 elements.removeClass('foo');

 // remove multiple classes
 elements.removeClass('foo baz');

 // since this method returns the set of matched elements
 elements.removeClass('foo baz').css('display', 'none');

 

Parameters:

Returns:

Type

ZebraJS

replaceWith(element) → {ZebraJS}

Source:

• zebra.src.js, line 3165

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // wrap element in a div
 element.replaceWith('<div id="replacement"></div>');

 // *exactly* the same thing as above
 element.replaceWith($('<div id="replacement"></div>'));

 // using an existing element as the wrapper
 element.replaceWith($('#element-from-the-page'));

 

Parameters:

Returns:

Type

ZebraJS

scrollLeft(valueopt) → {ZebraJS|integer}

Source:

• zebra.src.js, line 3204

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var body = $('body');

 // get the horizontal scroll of the body
 body.scrollLeft();

 // set the horizontal scroll of the body
 body.scrollLeft(250);

 // chaining
 elements.scrollLeft(250).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS | integer

scrollTop(valueopt) → {ZebraJS|integer}

Source:

• zebra.src.js, line 3252

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var body = $('body');

 // get the vertical scroll of the body
 body.scrollTop();

 // set the vertical scroll of the body
 body.scrollTop(250);

 // chaining
 elements.scrollTop(250).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS | integer

serialize() → {string}

Source:

• zebra.src.js, line 3294

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var form = $('#form');

 // serialize form's elements and their values
 var serialized = form.serialize();

 

Returns:

Type

string

siblings(selector) → {ZebraJS}

Source:

• zebra.src.js, line 3358

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // get all the siblings of the element
 var siblings_all = element.siblings();

 // get all the "div" siblings of the element
 var siblings_filtered = element.siblings('div');

 // since this method returns a ZebraJS object
 element.siblings('div').addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

text(contentopt) → {ZebraJS|string}

Source:

• zebra.src.js, line 3397

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // set the text content for all the matched elements
 elements.text('Hello');

 // get the text content of the first element in the
 // set of matched elements (including its descendants)
 var content = elements.text();

 // chaining
 elements.text('Hello').addClass('foo');
 

Parameters:

Returns:

Type

ZebraJS | string

toggleClass(class_name) → {ZebraJS}

Source:

• zebra.src.js, line 3449

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // set a random class
 elements.addClass('foo');

 // toggle classes
 // the result will be that "foo" will be removed from the matched elements while the "baz" will be added
 elements.toggleClass('foo baz');

 // chaining
 elements.toggleClass('foo').css('display', 'none');

 

Parameters:

Returns:

Type

ZebraJS

trigger(event_type, data) → {ZebraJS}

Source:

• zebra.src.js, line 3494

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // handle clicks on element
 element.on('click', function(e) {

     // will return "undefined" when element is clicked
     // but will return "baz" when triggered manually
     console.log(e.foo)

 });

 // manually trigger the click event
 element.trigger('click', {foo: 'baz'});

 // chaining
 element.trigger('click', {foo: 'baz'}).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS

unwrap(selector) → {ZebraJS}

Source:

• zebra.src.js, line 3554

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // unwrap the element, whatever its parent may be
 element.unwrap();

 // unwrap only if the element's parent is a div
 element.unwrap('div');

 

Parameters:

Returns:

Type

ZebraJS

val(valueopt) → {ZebraJS|mixed}

Source:

• zebra.src.js, line 3601

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('selector');

 // get the value of the first element in the list of matched elements
 // (if "element" was a select box with multiple selections allowed,
 // the returned value would be an array)
 var value = element.val();

 // set the element's value
 element.val('foo');

 // setting multiple values for multi-selects and checkboxes
 element.val(['option1', 'option2']);

 

Parameters:

Returns:

Type

ZebraJS | mixed

width(widthopt) → {ZebraJS|float}

Source:

• zebra.src.js, line 3706

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var elements = $('selector');

 // returns the current computed inner width of the first element in the set of matched elements
 elements.width();

 // sets the "width" CSS property of all elements in the set to 200px
 elements.width(200);
 elements.width('200');
 elements.width('200px');

 // sets the "width" CSS property of all elements in the set to 5em
 elements.width('5em');

 // chaining
 elements.width(200).addClass('foo');

 

Parameters:

Returns:

Type

ZebraJS | float

wrap(element) → {ZebraJS}

Source:

• zebra.src.js, line 3771

Example

// always cache selectors
 // to avoid DOM scanning over and over again
 var element = $('#selector');

 // wrap element in a div
 element.wrap('<div id="container"></div>');

 // *exactly* the same thing as above
 element.wrap($('<div id="container"></div>'));

 // using an existing element as the wrapper
 element.wrap($('#element-from-the-page'));

 

Parameters:

Returns:

Type

ZebraJS