agile

Agile.js

Like Underscore, but with zero callbacks and really more fun, v0.0.2

• Get Started
• Collection
  • add
  • after
  • afterWhere
  • before
  • beforeWhere
  • contains
  • countBy
  • defaults
  • every
  • filter
  • find
  • findIndex
  • findLast
  • findLastIndex
  • first
  • flatten
  • groupBy
  • last
  • map
  • max
  • min
  • omit
  • orderBy
  • remove
  • reverse
  • some
  • sortBy
  • sum
  • pick
  • pluck
  • unique
  • xor
• Object
  • keys
  • toArray
  • parse
• String
  • endsWith
  • ltrim
  • repeat
  • rtrim
  • reverse
  • slugify
  • startsWith
  • stringular
  • stripTags
  • trim
  • truncate
  • ucfirst
  • wrap
• Utils
  • copy
  • dictionary
  • equals
  • extend
  • identity
  • forEach
  • lowercase
  • uppercase
  • noop
  • toJson
• Boolean
  • isArray
  • isDate
  • isDefined
  • isUndefined
  • isString
  • isObject
  • isNumber
  • isFunction
  • isEmpty

Get Started

(1) You can install agile.js using 3 different methods:

• clone & build this repository
• via Bower: by running $ bower install agile from your terminal
• via npm: by running $ npm install agile from your terminal
• soon, cdnjs will be one of the options

(2) Add to your project:
For the Browser:
Include agile.js (or agile.min.js) in your index.html.

<script src="bower_components/agile/dist/agile.js"></script>

For Node Apps:

var _ = require('agile');

(3) Start Playing with agile.js:

var orders = [
  { id: 21, customer: { id: 2, name: 'John P.' }, product: { price: 21.12 }  },
  { id: 22, customer: { id: 1, name: 'Cati P.' }, product: { price: 89.21 }  },
  { id: 23, customer: { id: 1, name: 'Cati P.' }, product: { price: 49.00 }  },
  { id: 24, customer: { id: 3, name: 'Poul S.' }, product: { price: 10.22 }  },
  { id: 25, customer: { id: 4, name: 'Erik L.' }, product: { price: 11.31 }  },
  { id: 26, customer: { id: 4, name: 'Erik L.' }, product: { price: 90.99 }  },
  { id: 27, customer: { id: 2, name: 'Cati P.' }, product: { price: 88.99 }  }
];
_(orders)               // ArrayWrapper
  .map('product.price') // [21.12, 89.21, 49, 10.22, 11.31, 90.99, 88.99]
  .sum()                // 360.84
  .round()              // 361
  .add(10)              // 371
  .value();             // get the value;

Collection

after

get a collection and specified count, and returns all of the items in the collection after the specified count.
Usage: _.after(array, count)

var users = [
    { name: 'foo' },
    { name: 'bar' },
    { name: 'baz' },
    { name: 'zap' }
];
 
_.after(users, 2);
// → [ { name: 'baz' }, { name: 'zap' } ]

afterWhere

get a collection and expression/callback, and returns all of the items in the collection after the first that return true, include it.
Usage: _.afterWhere(array, expression/callback)

var orders = [
    { id: 1, date: 'Tue Jul 15 2014' },
    { id: 2, date: 'Tue Jul 16 2014' },
    { id: 3, date: 'Tue Jul 17 2014' },
    { id: 4, date: 'Tue Jul 18 2014' },
    { id: 5, date: 'Tue Jul 19 2014' }
];
 
_.afterWhere(orders, 'date == "Tue Jul 17 2014"');
// → [ orders[2], orders[3], orders[4] ]
 
_.afterWhere(orders, 'id > 3');
// → [ orders[3], orders[4] ]
 
_.afterWhere(orders, function(e) { 
    return e.id > 3;
});
// → [ orders[3], orders[4] ]

add

add is similar to Array.push, but can get a multiple arguments, and return the array instead of the value.
Usage: _.add(array, args)

_.add([1,2,3], 4,5,6); // → [1, 2, 3, 4, 5, 6]

before

get a collection and specified count, and returns all of the items in the collection before the specified count.
Usage: _.before(array, count)

var users = [
    { name: 'foo' },
    { name: 'bar' },
    { name: 'baz' },
    { name: 'zap' }
];
 
_.before(users, 2);
// → [ { name: 'foo' }, { name: 'bar' } ]

beforeWhere

get a collection and expression/callback, and returns all of the items in the collection before the first that return true, including it.
Usage: _.beforeWhere(array, expression/callback)

var orders = [
    { id: 1, date: 'Tue Jul 15 2014' },
    { id: 2, date: 'Tue Jul 16 2014' },
    { id: 3, date: 'Tue Jul 17 2014' },
    { id: 4, date: 'Tue Jul 18 2014' },
    { id: 5, date: 'Tue Jul 19 2014' }
];
 
_.beforeWhere(orders, 'date == "Tue Jul 17 2014"');
// → [ orders[0], orders[1], orders[2] ]
 
_.beforeWhere(orders, 'id < 3');
// → [ orders[0], orders[1] ]
 
_.beforeWhere(orders, function(e) { 
    return e.id < 3;
});
// → [ orders[0], orders[1] ]

contains

Checks if given expression(or value) is present in one or more object in the array.
Usage: _.contains(array, expression/callback/value)
Aliases: _.some

var nums = [1,2,3,4];
_.contains(num, 2); 
// → true
 
var users = [
  { user: { id: 2, name: 'foo' } },
  { user: { id: 4, name: 'bar' } },
  { user: { id: 6, name: 'baz' } }
];
_.some(users, '!(user.id % 2)');
// → true
_.some(users, '(user.id > 5)');
// → false

countBy

Create an object composed of keys generated from the result of the running expression, each key is the count of objects in each group.
Usage: _.countBy(array, expression/callback)

var players = [
  {name: 'Gene',    team: { name: 'alpha' } },
  {name: 'George',  team: { name: 'beta'  } },
  {name: 'Steve',   team: { name: 'gamma' } },
  {name: 'Paula',   team: { name: 'beta'  } },
  {name: 'Scruath', team: { name: 'gamma' } }
];
_.countBy(players, 'team.name');
// → { alpha: 1, beta:  2, gamma:2 }

defaults

defaults allows to specify a default fallback value for properties that resolve to undefined.
Usage: _.defaults(array, object)

var orders = [
      { id:1, destination: { zip: 21908 }, name: 'Ariel M' },
      { id:2, name: 'John F' },
      { id:3, destination: { zip: 45841 } },
      { id:4, destination: { zip: 78612 }, name: 'Danno L' }
  ];
var fallback = {
      name: 'Customer name not available',
      destination: { zip: 'Pickup' }
  };
_.defaults(orders, fallback);
// Results:
// [{ id: 1, destination: { zip: 21908 }, name: 'Ariel M' },
// { id: 2, destination: { zip: 'Pickup' }, name: 'John F'  },
// { id: 3, destination: { zip: 45841 }, name: 'Customer name not available' },
// { id: 4, destination: { zip: 78612 }, name: 'Danno L' }]

every

Checks if given expression/callback is present in all members in the array.
Usage: _.every(array, expression/callback)

var nums = [1,2,3,4];
_.every(num, 2); 
// → false
 
var users = [
  { id: 2, name: 'bob' } },
  { id: 4, name: 'bar' } },
  { id: 6, name: 'baz' } }
];
_.every(users, '!(id % 2)');
// → true
_.every(users, 'name.indexOf("ba") != -1');
// → false

filter

filter by expression/callback return all elements that return true, avoid the rest.
Usage: _.filter(array, expression/callback) Aliases: _.pick

var users = [
  { id: 1, user: { name: 'foo', isAdmin: true  } },
  { id: 2, user: { name: 'bar', isAdmin: false } },
  { id: 3, user: { name: 'baz', isAdmin: true  } }
];
_.pick(users, 'user.isAdmin');
// → [ users[0], users[2] ]

find

Iterate over the given array and return the first member that the expression returns truthy for.
Usage: _.find(array, expression/callback)

var orders = [
  { id: 21, product: { price: 21.12 }, auth: ['3s!sa0'] },
  { id: 22, product: { price: 89.21 }, auth: ['@3dRg1'] },
  { id: 23, product: { price: 49.00 }, auth: ['a44Fy+'] },
  { id: 24, product: { price: 10.22 }, auth: ['WS4%a0'] },
  { id: 25, product: { price: 11.31 }, auth: ['7Y#d_1'] }
];
_.find(orders, 'product.price > 50'); 
// → { id: 22, product: { price: 89.21 }, auth: ['@3dRg1'] }
 
_.find(orders, 'auth.indexOf("7Y#d_1") !== -1');
// → { id: 25, product: { price: 11.31 }, auth: ['7Y#d_1'] }
 
_.find(orders, '!(id%2)');
// → { id: 22, product: { price: 89.21 }, auth: ['@3dRg1'] }

findLast

Iterate over the given array and return the last member that the expression returns truthy for.
Usage: _.findLast(array, expression/callback)

var orders = [
  { id: 21, product: { price: 21.12 }, auth: ['3s!sa0'] },
  { id: 22, product: { price: 89.21 }, auth: ['@3dRg1'] },
  { id: 23, product: { price: 49.00 }, auth: ['7Y#d_1'] },
  { id: 24, product: { price: 10.22 }, auth: ['WS4%a0'] },
  { id: 25, product: { price: 91.31 }, auth: ['7Y#d_1'] }
];
_.findLast(orders, 'product.price > 50'); 
// → { id: 25, product: { price: 91.31 }, auth: ['7Y#d_1'] }
 
_.findLast(orders, 'auth.indexOf("7Y#d_1") !== -1');
// → { id: 25, product: { price: 91.31 }, auth: ['7Y#d_1'] }
 
_.findLast(orders, '!(id%2)');
// → { id: 24, product: { price: 10.22 }, auth: ['WS4%a0'] }

findIndex

Iterate over the given array and return the index of the first member that the expression returns truthy for.
Usage: _.findIndex(array, expression/callback)

var orders = [
  { id: 21, product: { price: 21.12 }, auth: ['3s!sa0'] },
  { id: 22, product: { price: 89.21 }, auth: ['@3dRg1'] },
  { id: 23, product: { price: 49.00 }, auth: ['a44Fy+'] },
  { id: 24, product: { price: 10.22 }, auth: ['WS4%a0'] },
  { id: 25, product: { price: 11.31 }, auth: ['7Y#d_1'] }
];
_.findIndex(orders, 'product.price > 50');            // → 1
_.findIndex(orders, 'auth.indexOf("7Y#d_1") !== -1'); // → 4

findLastIndex

Iterate over the given array and return the index of the last member that the expression returns truthy for.
Usage: _.findLastIndex(array, expression/callback)

var orders = [
  { id: 21, product: { price: 21.12 }, auth: ['3s!sa0'] },
  { id: 22, product: { price: 89.21 }, auth: ['@3dRg1'] },
  { id: 23, product: { price: 49.00 }, auth: ['a44Fy+'] },
  { id: 24, product: { price: 90.22 }, auth: ['a44Fy+'] },
  { id: 25, product: { price: 11.31 }, auth: ['7Y#d_1'] }
];
_.findLastIndex(orders, 'product.price > 50');             // → 3
_.findLastIndex(orders, 'auth.indexOf("a44Fy+") !== -1');  // → 3

first

Gets the first element or first n elements of an array.
if expression is provided, is returns as long the expression return truthy.
Usage: See below

var users = [
  { id: 1, user: { name: 'foo', isAdmin: true  } },
  { id: 2, user: { name: 'bar', isAdmin: false } },
  { id: 3, user: { name: 'baz', isAdmin: true  } }
];
// Returns the first user
_.first(users);
// → { id: 1, user: { name: 'foo', isAdmin: true  } }
 
// Return the first user whose not `admin`
_.first(users, '!user.isAdmin');
// → [{ id: 2, user: { name: 'bar', isAdmin: false } }]
 
// Returns the first 2 users
_.first(users, 2);
// → [users[0], users[1]]
 
// Returns the first 2 `admin` users 
_.first(users, 2, 'user.isAdmin');
// → [users[0], users[2]]

flatten

Flattens a nested array (the nesting can be to any depth).
if shallow set to true, the array will only be flattened a one level. Usage: _.flatten(array, shallow[optional])

_.flatten(['out', ['out', ['in']], ['out', 'out', ['in', 'in']], ['out', 'out']], true);
// → ['out', 'out', ['in'], 'out', 'out', ['in', 'in'], 'out', 'out']
 
_.flatten([[], 1, 2, 3, [4, 5, 6, [7, 8, 9, [10, 11, [12, [[[[[13], [[[[14, 15]]]]]]]]]]]]]));
// → [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

groupBy

Get a collection, expression/callback and return an object composed of keys generated from the result of running each members in the collection on the expression.
each key is an array contains the results members.
Usage: _.groupBy(array, expression)

var players = [
  {name: 'Gene',    team: { name: 'alpha' } },
  {name: 'George',  team: { name: 'beta'  } },
  {name: 'Steve',   team: { name: 'gamma' } },
  {name: 'Paula',   team: { name: 'beta'  } },
  {name: 'Scruath', team: { name: 'gamma' } }
];
_.groupBy(players, 'team.name');
// { 
//  alpha: [{name: 'Gene',    team: { name: 'alpha' } }],
//  betta: [{name: 'George',  team: { name: 'beta'  } }, {name: 'Paula',   team: { name: 'beta'  } }],
//  gamma: [{name: 'Steve',   team: { name: 'gamma' } }, {name: 'Scruath', team: { name: 'gamma' } }]
// }

last

Gets the last element or last n elements of an array.
if expression is provided, is returns as long the expression return truthy.
Usage: See below

var users = [
  { id: 1, user: { name: 'foo', isAdmin: true  } },
  { id: 2, user: { name: 'bar', isAdmin: false } },
  { id: 3, user: { name: 'baz', isAdmin: false } },
  { id: 4, user: { name: 'zak', isAdmin: true  } }
];
// Returns the last user
_.last(users);
// → { id: 4, user: { name: 'zak', isAdmin: true  } }
 
// Return the last user whose not `admin`
_.last(users, '!user.isAdmin');
// → [{ id: 3, user: { name: 'baz', isAdmin: false } }]
 
// Returns the last 2 users
_.last(users, 2);
// → [users[2], users[3]]
 
// Returns the last 2 `admin` users 
_.last(users, 2, 'user.isAdmin');
// → [users[0], users[3]]

map

Returns a new Array with the results of each expression execution.
Usage: _.map(array, expression)
Aliases: _.pluck

var users = [
  { id:1, user: { name: 'Foo' } },
  { id:2, user: { name: 'Bar' } },
  { id:3, user: { name: 'Baz' } }
];
_.map(users, 'user.name');
// → ['Foo', 'Bar', 'Baz']
 
_.map(users, 'id <= 2 ? id : 0')
// → [1, 2, 0]

max

Find and return the largest number in a given array.
if an expression is provided, will return max value by expression.
Usage: _.max(array)

_.max([1,2,3,4,7,8,9]) // → 9
 
//By expression
var users = [
  { name: 'foo', score: 89 },
  { name: 'bar', score: 32 },
  { name: 'baz', score: 49 }
];
_.max(users, 'score'); // → { name: 'foo', score: 89 }
 
//Chaining example
var users = [
  { player: { ... }, score: 891 },
  { player: { ... }, score: 121 },
  { player: { ... }, score: 641 },
  { player: { ... }, score: 491 }
]
_(users)
  .map('score')
  .max()
  .value() // → 891

min

Find and return the lowest number in a given array.
if an expression is provided, will return min value by expression.
Usage: _.min(array)

_.min([1,2,3,4,7,8,9]) // → 1
 
//By expression
var users = [
  { user: { score: 197 } },
  { user: { score: 212 } },
  { user: { score: 978 } },
  { user: { score: 121 } }
];
_.min(users, 'user.score') // → { user: { score: 121 } }
 
//Chaining example
var users = [
  { player: { ... }, score: 891 },
  { player: { ... }, score: 121 },
  { player: { ... }, score: 641 },
  { player: { ... }, score: 491 }
]
_(users)
  .map('score')
  .min()
  .value() // → 121

omit

Get an array, and return a new array without the omitted members(by expression).
Usage: _.omit(array, expression)

var users = [
  { id: 1, name: 'foo' },
  { id: 2, name: 'bar' },
  { id: 3, name: 'baz' }
];
_.omit(users, 'id > 2 && !name.indexOf("ba")');
// → [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }]

orderBy

Orders a specified array by the expression predicate.
It is ordered alphabetically for strings and numerically for numbers.
Usage: _.orderBy(array, expression/callback, reverse[optional])
Aliases: _.sortBy

var orders = [
  { id: 1, product: { price: 21.12 }, date: new Date('01/01/2014') },
  { id: 2, product: { price: 99.21 }, date: new Date('01/01/2014') },
  { id: 3, product: { price: 99.90 }, date: new Date('01/01/2013') },
  { id: 4, product: { price: 99.99 }, date: new Date('01/01/1970') }
];
 
_.orderBy(orders, 'date');
// → [orders[3], orders[2], orders[1], orders[0]];
 
_.orderBy(orders, '+product.price');
// → [orders[0], orders[1], orders[2], orders[3]];
 
_.orderBy(orders, '-product.price');
// → [orders[3], orders[2], orders[1], orders[0]]
 
_.orderBy(orders, ['-date', '-id']);
// → [orders[1], orders[0], orders[2], orders[3]]
 
_.orderBy([5,1,4,3,2]);           // → [1, 2, 3, 4, 5]
_.orderBy([5,1,4,3,2], '-');      // → [5, 4, 3, 2, 1]
.orderBy([5,1,4,3,2], '-', true); // → [1, 2, 3, 4, 5]
 
// sort by multiple arguments
_.orderBy([{a:1, b:10}, {a:1, b:4}, {a:0, b:5}], ['a', 'b']);
// → [{ a:0, b:5 }, { a:1, b:4 }, { a:1, b:10 }]

remove

remove specific members from array by equality.
Usage: _.remove(array, args)

var collection = [
  { name: 'bar' },
  { name: 'foo' },
  null, 1
];
_.remove(collection, { name: 'foo' }, null, 1);
// → [{ name: 'bar' }]

reverse

Reverses a string or array(doesn't change the source array).
Usage: _.reverse(array/string)

_.reverse([1,2,3]) // → [3, 2, 1]
_.reverse('agile') // → eliga

sum

Sum up all values within an array.
Usage: _.sum(array)

_.sum([1,2,3,4,5]) // → 15
 
//Chainig example
var scores = [
  { player: { ... }, score: 891 },
  { player: { ... }, score: 121 },
  { player: { ... }, score: 641 },
  { player: { ... }, score: 491 }
];
_(scores)
  .map('score')
  .sum()
  .value(); // → 2144

unique

Get an array and filter duplicate members.
if expression is provided it's filters by this expression as unique identifier.
Usage: _.unique(array, expression[optional])
Aliases: uniq

_.unique([12,3,4,12,4,5,6]) 
// → [12, 3, 4, 5, 6]
 
var orders = [
  { id:1, customer: { name: 'John',    id: 10 } },
  { id:2, customer: { name: 'William', id: 20 } },
  { id:3, customer: { name: 'John',    id: 10 } },
  { id:4, customer: { name: 'William', id: 20 } },
  { id:5, customer: { name: 'Clive',   id: 30 } }
];
_.unique(orders, 'customer.id');
// Results:
// [{ id:1, customer: { name: 'John',    id: 10 } },
//  { id:2, customer: { name: 'William', id: 20 } },
//  { id:5, customer: { name: 'Clive',   id: 30 } }]
 
//Chaining Example:
_(orders)
  .unique('customer.id')
  .map('customer.name')
  .join(', ')
  .value(); // → John, William, Clive

xor

Exclusive or filter by expression.
Usage: _.xor(arr1, arr2, expression[optional])

_.xor([2,3,4], [3,4,5]);
// → [2, 5]
 
//Example with expression:
var users1 = [
  { id: 0, details: { first_name: 'foo', last_name: 'bar' } }, 
  { id: 1, details: { first_name: 'foo', last_name: 'baz' } },
  { id: 2, details: { first_name: 'foo', last_name: 'bag' } }
];
var users2 = [
  { id: 3, details: { first_name: 'foo', last_name: 'bar' } },
  { id: 4, details: { first_name: 'foo', last_name: 'baz' } }
];
_.xor(users1, users2, 'details.last_name');
// → [{ id: 2, details: { first_name: 'foo', last_name: 'bag' } }]

Object

toArray

Convert objects into stable arrays.
if addKey set to true,the filter also attaches a new property $key to the value containing the original key that was used in the object we are iterating over to reference the property.
Usage: _.toArray(object, boolean[optional])

var users = {
  0: { name: 'Ariel', age: 25 },
  1: { name: 'Dan',   age: 21 },
  2: { name: 'John',  age: 31 }
};
_.toArray(users);
// → [{name:'Ariel', age:25}, {name:'Dan', age:21}, {name:'John', age:31}]
 
//Chaining example
_({
  Ariel: { age: 25 },
  Dan  : { age: 21 },
  John : { age: 31 }
}).toArray(true)
  .value(); // → [{$key:'Ariel', age:25}, {$key:'Dan', age:21}, {$key:'John', age:31}]

keys

Creates an array composed of the own enumerable property names of an object.
if nested set to true, it will return the properties in a recursively nested style(used mainly with parse.setter, parse.getter).
Usage: _.keys(object, nested[optional])

var user = { 
  name: 'Ariel M', 
  age: 26, 
  permissions: { isAdmin: true }, 
  details: { address: { city: 'Tel Aviv', zip: 61019 } }
};
_.keys(user); 
// → ['name', 'age', 'permissions', 'details']
 
_.keys(user, true);
// → ['name', 'age', 'permissions.isAdmin', 'details.address.city', 'details.address.zip']

parse

Convert expression into function.
Usage: _.parse(expression)
Returns: Function(context, local)
context: an object against which any expressions embedded in the strings are evaluated against.
local: local variables context object, useful for overriding values in context.
Note: The returned function also has the following properties:
literal : whether the expression's top-level node is a JavaScript literal.
constant: whether the expression is made entirely of JavaScript constant literals.
assign : {?function(context, value)} – if the expression is assignable, this will be set to a function to change its value on the given context.

//Simple getter / setter functions
var user = { 
  name: 'Ariel M.', 
  age : 26, 
  details: { address: { city: 'Tel Aviv', zip: 61019 } }
};
var nameGetter = _.parse('name');
var nameSetter = nameGetter.assign;
 
nameGetter(user); // → 'Ariel M.'
nameSetter(user, 'Dan T.');
nameGetter(user); // → 'Dan T.'
 
//Example use local(override) object
var local = {
  age: 50,
  sayHello: function(name, age) { 
    return 'Hello ' + name + ' I\'m '+ age + ' years old.' 
  }
};
_.parse('sayHello(name, age)')(user, local);
// → Hello Ariel M. I'm 50 years old.
 
_.parse('[1,2]').literal    // → true
_.parse('[1 + 1]').constant // → true
_.parse('[x + 1]').constant // → false

String

endsWith

return whether string ends with the ends parameter.
Usage: _.endsWith(string, end, case-sensitive[optional])

_.endsWith('image.JPG', '.jpg'); // → true
 
_.endsWith('image.JPG', '.jpg', true); // → false

ltrim

Left trim. Similar to trim, but only for left side.
Usage: _.ltrim(string, chars[optional])

_.ltrim('   foo   ') // → 'foo   '
_.ltrim('barfoobar', 'bar') // → 'foobar'

rtrim

Reft trim. Similar to trim, but only for right side.
Usage: _.rtrim(string, chars[optional])

_.rtrim('   foo   ') // → '   foo'
_.rtrim('barfoobar', 'bar') // → 'barfoo'

repeat

Repeats a string n times(fast).
Usage: _.repeat(string, n)

_.repeat('*',10); // → '**********'
_.repeat('foo');  // → 'foo'

slugify

Transform text into a URL slug. Replaces whitespaces, with dash("-") or given argument.
Usage: _.slugify(input, sub[optional])

_.slugify('Some string with spaces'); // → 'some-string-with-spaces'
_.slugify('Some string with hashtags', '#'); // → 'some#string#with#hashtags'

startsWith

return whether string starts with the starts parameter.
Usage: _.startsWith(str, case-sensitive[optional])

_.startsWith('Lorem ipsum', 'Lor'); // → true
 
//Chaining example:
_('Lorem ipsum')
  .startsWith('lor', true); // → false

stringular

get string with {n} and replace matches with enumeration values.
Usage: _.stringular(str, args...)

_.stringular('lorem {0} dolor {1} amet', 'ipsum', 'sit'); 
// → 'lorem ipsum dolor sit amet'
 
_.stringular('{3} {0} dolor {1} amet', 'ipsum', 'sit', null, 'lorem');
// → 'lorem ipsum dolor sit amet'

stripTags

strip out html tags from string.
Usage: _.stripTags(string)

_.stripTags('<div id="fr" class="paragraph">foo<br/></div>');
// → 'foo'
 
//Chaining example
_('<p class="paragraph">Lorem Ipsum...</p>')
  .stripTags()
  .value(); // → 'Lorem Ipsum...'

trim

Strip whitespace (or other characters) from the beginning and end of a string.
Usage: _.trim(string, chars[optional])

_.trim('foobarfoo', 'foo'); // → 'bar'
_.trim('   foo   '); // → 'foo'

truncate

truncates a string given a specified length, providing a custom string to denote an omission.
Usage: _.truncate(str, length, suffix[optional], preserve[optinal])

var text = 'lorem ipsum dolor sit amet';
 
_.truncate(text, 13, '...', true); // → 'lorem ipsum dolor...'
_.truncate(text, 13, '...');       // → 'lorem ipsum d...'
_.truncate(text, 50, '...');       // → 'lorem ipsum dolor sit amet'

ucfirst

upper case first char.
Usage: _.ucfirst(string)

_.ucfirst('ariel mashraki'); // → 'Ariel Mashraki'
 
//Chaining example
_(['ariel', 'dan', 'john'])
  .join(', ')
  .ucfirst()
  .value(); // → 'Ariel, Dan, John'

wrap

Wrap a string with another string.
Usage: _.wrap(string, start, end[optional])

_.wrap('foo', 'bar');          // → 'barfoobar'
_.wrap('text', '<p>', '</p>'); // → '<p>text</p>'
 
//Chaining example:
_(['ariel', 'dan', 'john'])
  .join(', ')
  .ucfirst()
  .wrap('Team members: ', ' ')
  .value(); // → 'Team members: Ariel, Dan, John'

Utils

copy

Creates a recursive copy of source object into dest object, could be an object or an array.
Usage: _.copy(src, dst)

var a = [1,2,3, { a: 1, b: 2 }];
var b;
_.copy(a, b);
 
//Test result
_.equals(a, b); // → true

dictionary

Creates a new object without a prototype.
Usage: _.dictionary()

var map = _.dictionary();
console.log(map.toString); // → undefined

equals

Determines if two objects or two values are equivalent.
Usage: _.equals(o1, o2)

_.equals({}, {});                   // → true
_.equals(new Date(), new Date());   // → true
_.equals(/\//g, new RegExp(/\//g)); // → true

extend

Extends the destination object dst by copying own enumerable properties from the src object(s) to dst. You can specify multiple src objects.
Usage: _.extend(dst, arg...)

_.extend({a:1}, {b:2}, {a:3, c: 4}); // → {a: 3, b: 2, c: 4}

identity

identity function returns its first argument.
Usage: _.identity(val)

_.identity(1); // → 1

forEach

Invokes an iterator function once for each member in a collection(object, array).
The iterator function is invoked with (value, key/index, obj/array).
Usage: _.forEach(collection, iteratorFn, context[optional]);

noop

A function that performs no operations.
Usage: _.noop()

function fn(cb) {
 //...
 return (cb || _.noop)(args);
}