introdução do mout js

<b> MOUT </b> ou utilitários modulares é uma coleção de utilitários JavaScript modulares. Ele fornece muitos métodos auxiliares semelhantes aos encontrados nas bibliotecas padrão de outras linguagens. Considere-o como uma biblioteca padrão de JavaScript para vários navegadores.

<b> Metas de moutjs </b>

aumentar a reutilização de código;
Seja claro (o código deve ser limpo / legível);
Seja fácil de depurar;
Seja fácil de manter;
Siga as melhores práticas;
Siga os padrões quando possível;
Não converta JavaScript em outra linguagem!
Ser compatível com outros frameworks;
Seja modular;
Ter testes de unidade para todos os módulos;
Trabalhe em vários ambientes (IE7 +, navegadores modernos, node.js);

Para obter a documentação completa, visite: http://moutjs.com/

<b> Chamando um método ou módulo </b>

No mout, você pode exigir apenas um único método, um pacote inteiro ou a biblioteca inteira:

// a single method
var append = require('mout/array/append');
var foo = ['a', 'b'], bar = ['b', 'd']; 
append(foo, bar); // ['a', 'b', 'b', 'd']

// a single package
var stringUtils = require('mout/string');
stringUtils.camelCase('Foo Bar'); // "fooBar"

// the whole lib
var mout = require('mout');
console.log( mout.math.clamp(17, 0, 10) ); // 10

mout contém os seguintes pacotes:
<i> array, collection, date, function, lang, math, number, object, queryString, random, string e time. </i>

Aqui estão alguns dos métodos úteis nesses pacotes. Esses métodos são alguns dos meus favoritos, e não uma lista extensa. Para a duplicação completa, visite: http://moutjs.com/docs/

<b> matriz </b>

anexar (arr1, arr2): Array

var foo = ['a', 'b'], bar = ['b', 'd'];
append(foo, bar); // ['a', 'b', 'b', 'd']

combinar (arr1, arr2): Array

var foo = ['a', 'b'], bar = ['b', 'd'];
combine(foo, bar); // ['a', 'b', 'd']

contém (arr, valor): Booleano

var arr = [1, 2, 3];
contains(arr, 2);      // true

cada (arr, retorno de chamada, [thisObj]): Matriz #

var items = [1, 'foo', 'bar'];
every(items, isString);   // false
every(items, function(val, key, arr){
    return val != null;
}); // true

filtro (arr, callback, [thisObj]): Array

var nums = [1, 2, 3, 4, 5, 6];
var oddNumbers = filter(nums, function(val, key, arr){
    return (val % 2) !== 0;
});
// > [1, 3, 5]

find (arr, callback, [thisObj]): *

vavar users = [
    {name:'steven', surname:'martin'},
    {name:'james', surname:'martin'}
];
// first item that matches name steven
find(arr, {name:'steven'}); // {name:'steven', surnname:'martin'}

forEach (arr, callback, [thisObj]): void

var items = ['foo', 'bar'];
forEach(items, function(val, key, arr){
    console.log(key +' : '+ val);
});

inserir (arr, … itens): Número

var arr = ['a', 'b'];
insert(arr, 'a');       // 2 : ['a', 'b']

junção (arr, [separador]): String

join(['a', 'b', 'c']); // 'abc'

map (arr, callback, [thisObj]]): Array

var src = ['lorem', 'ipsum', 'foo', 'amet'];
var lengths = map(src, 'length'); // [5, 5, 3, 4]

max (arr, [iterador], [thisObj]): *

max([10, 2, 7]); // 10

min (arr, [iterador], [thisObj]): *

min([10, 2, 7]); // 2

pick (arr, [nItems]): *

var arr = [1, 2, 3, 4, 5, 6];
var item1 = pick(arr); // 4, it picks a random value
var item2 = pick(arr); // 1, it picks a random value

arrancar (arr, propName): Array

var users = [{name : 'John', age: 21}, {name: 'Jane', age : 27}];
var names = pluck(users, 'name'); // ["John", "Jane"]

remover (arr, item): void

var foo = [1, 2, 3, 4];
remove(foo, 2); // [1, 3, 4]

removeAll (arr, item): void

var foo = [1, 2, 3, 4, 2, 2];
removeAll(foo, 2); // [1, 3, 4];

shuffle (arr): Array

var arr = ['a', 'b', 'c', 'd', 'e'];
shuffle(arr); // ['b', 'd', 'e', 'c', 'a']

fatia (arr, [início], [fim]): Matriz

slice([1, 2, 3, 4], 1, 2); // [2, 3]

some (arr, callback, [thisObj]): Array

var items = [1, 'foo', 'bar'];
some(items, isString);   // true

sort (arr, [compareFn]): Array

sort([187, 23, 47, 987, 12, 59]); // [12, 23, 47, 59, 187, 987]
sort(['a', 'z', 'c', 'b']); // ['a', 'b', 'c', 'z']

união (… arrs): Array

var a = [1, 2], b = [3, 4];  // note: removes duplicates
union(a, b); // [1, 2, 3, 4]

<b> data </b>

dayOfTheYear (data): Número

dayOfTheYear(new Date(2013, 0, 1)); // 1

diff (data1, data2, [nome da unidade]): Número #

var d1 = new Date(2012, 4, 5);
var d2 = new Date(2013, 4, 8);
diff(d1, d2);          // 31795200000
diff(d1, d2, 'hour');  // 8832
diff(d1, d2, 'week');  // 52.57142857142857

isSame (date1, date2 [, period]): Boolean #

var date1 = new Date(2013, 1, 3);
var date2 = new Date(2013, 2, 9);
isSame(date1, date2);          // false
isSame(date1, date2, 'day');   // false
isSame(date1, date2, 'year');  // true

parseIso (str): Número #

parseIso('2000-01-02T20:10+04:00') // 946829400000

trimestre (data): Número

quarter(new Date(2013, 1, 19)); // 1
quarter(new Date(2013, 4, 12)); // 2

strftime (data, formato, [l10n]): String

var date = new Date(2013, 3, 8, 9, 2, 4);
strftime(date, '%Y-%m-%d'); // "2013-04-08" check docs for format

totalDaysInMonth (fullYear, monthIndex): Number

totalDaysInMonth(2008, 1); // 29 (leap year)
totalDaysInMonth(2009, 1); // 28

totalDaysInYear (fullYear): Número

totalDaysInYear(2009); // 365

weekOfTheYear (date, [firstDayOfWeek]): Número

weekOfTheYear( new Date(2013,0,9) ); // 1

<b> função </b>

awaitDelay (fn, delay): Função

var callback = after(onLoaded, 1000);
loadImages(callback);
function onLoaded(){
    console.log('loaded');
}

func (nome): Função

// will call the method `getName()` for each `user`
var names = map(users, func('getName'));

<b> objeto </b>

contém (obj, valor): Booleano

var obj = {
    a: 1,
    c: 2
};
contains(obj, 2);      // true

todo (obj, retorno de chamada, [thisObj]): Booleano

var obj = {
    a: 1,
    d: 'string'
};

every(obj, isNumber); // false

find (obj, callback, [thisObj])

var obj = {
    a: 'foo',
    b: 12
};

find(obj, isNumber); // 12

forIn (obj, callback [, thisObj])

function Foo(){
    this.foo = 1;
    this.bar = 2;
}

var obj = new Foo();
var result = 0, keys = [];

forIn(obj, function(val, key, o){
    result += val;
});

console.log(result); // 3

funções (obj): Array

var obj = {
    foo : function(){},
    bar : 'baz'
};
functions(obj); // ['foo']

get (obj, propName): *

var lorem = {
        ipsum : {
            dolor : {
                sit : 'amet'
            }
        }
    };

get(lorem, 'ipsum.dolor.sit'); // "amet"
get(lorem, 'foo.bar');         // undefined

has (obj, propName): Booleano

var animal = {
        cat : {
            claws : true
        }
    };

has(animal, 'cat');   // true

chaves (obj): Array

var obj = {
    foo : 1,
    bar : 2,
    lorem : 3
};
keys(obj); // ['foo', 'bar', 'lorem']

pick (obj, … keys): Object

var user = {
    firstName : 'John',
    lastName : 'Doe',
    gender : 'male'
};
// single or multiple paramaters     
pick(user, 'firstName', 'lastName'); // {firstName:"John", lastName: "Doe"}

arrancar (obj, propName): Objeto

var users = {
    first: {
        name : 'John',
        age : 21
    },
    second: {
        name : 'Mary',
        age : 25
    }
};

pluck(users, 'age');  // {first: 21, second: 25} );

valores (obj): Array

var obj = {
    foo : 1,
    bar : 2,
    lorem : 3
};
values(obj); // [1, 2, 3]

<b> string </b>

camelCase (str): String

camelCase('lorem-ipsum-dolor'); // "loremIpsumDolor"

contém (str, substring, [fromIndex]): Booleano

contains('lorem', 'or');  // true

crop (str, maxChars, [append]): String

crop('lorem ipsum dolor', 10);      // "lorem..."

endsWith (str, sufixo): Booleano

endsWith('lorem ipsum', 'lorem'); // false

escapeHtml (str): String

escapeHtml('lorem & "ipsum"'); // "lorem & "ipsum""

unescapeHtml (str): String

unescapeHtml('lorem & "ipsum"'); // 'lorem & "ipsum"'

escapeUnicode (str [, shouldEscapePrintable]): String

escapeUnicode('føo bår'); // > "fu00f8o bu00e5r"

unescapeUnicode (str): String

unescapeUnicode('\u0066\u00f8\u006f\u0020\u0062\u00e5\u0072'); // > 'føo bår'

insert (str, index, parcial): String

insert('foo', 100, 'bar'); // "foobar"

lpad (str, minLength [, char]): String
rpad (str, minLength [, char]): String

lpad('a', 5);        // "    a"
lpad('a', 5, '-');   // "----a"

ltrim (str, [chars]): String
rtrim (str, [chars]): String

ltrim('--lorem ipsum--', ['-']); // "lorem ipsum--"

makePath (… args): String

makePath('foo///bar/'); // "foo/bar/"

ownCase (str): String

properCase('loRem iPSum'); // "Lorem Ipsum"

removeNonASCII (str): String

removeNonASCII('äÄçÇéÉêlorem-ipsumöÖÐþúÚ'); // "lorem-ipsum"

removeNonWord (str): String

removeNonWord('lorem ~!@#><., ipsum'); // "lorem - ipsum"

repetir (str, n): String

repeat('a', 3);  // "aaa"

stripHtmlTags (str): String

stripHtmlTags('<p><em>lorem</em> <strong>ipsum</strong></p>'); // "lorem ipsum"

startWith (str, prefix): Boolean

startsWith('lorem ipsum', 'lorem'); // true

slugify (str [, delimeter]): String

var str = 'loremIpsum dolor spéçïãl chârs';
slugify(str, '_'); // "loremipsum_dolor_special_chars"

trim (str, [chars]): String

trim('   lorem ipsum   '); // "lorem ipsum"

truncate (str, maxChars, [append], [onlyFullWords]): String

truncate('lorem ipsum dolor', 11);             // "lorem ip..."

<b> queryString </b>

contém (url, paramName): Boolen

var url = 'example.com/?lorem=ipsum';
contains(url, 'lorem'); // true

decodificar (queryStr [, shouldTypecast]): Objeto

var query = '?foo=bar&lorem=123';
decode(query);        // {foo: "bar", lorem: 123}

encode (obj): String

encode({foo: