String.prototype.trim = function(chars) {
	chars = chars == undefined ? "\\s" : chars
	var r = new RegExp("^[" + chars + "]+|[" + chars + "]+$", "g")
	return this.replace(r,"")
//	return this.replace(/^str+|str+$/g, "")  // versão simples
}

String.prototype.trimLeft = function(chars) {
	chars = chars == undefined ? "\\s" : chars
	var r = new RegExp("^[" + chars + "]+", "g")
	return this.replace(r,"")
//	return this.replace(/^\s+/g, "") // versão simples
}

String.prototype.trimRight = function(chars) {
	chars = chars == undefined ? "\\s" : chars
	var r = new RegExp("[" + chars + "]+$", "g")
	return this.replace(r,"")
//	return this.replace(/\s+$/g, "") // versão simples
}

/*
retorna a instância da string "multiplicada"/repetida pelo parâmetro
@return string
*/
String.prototype.repeat = function(multiplier){
	var count = parseInt(multiplier);
	if (isNaN(count)) throw new Error('O argumento tem que ser um inteiro');
	else if (count < 0) throw new Error('O argumento tem que ser maior ou igual a zero');
	
	var result = '';
	for (; count > 0;count--){
		result += this;
	}
	
	return result;
}

/*
faz uma comparação case-insensitive entre a instância da string e qualquer outro tipo de dado
@return boolean true se forem iguais e false se forem diferentes
*/
String.prototype.cmp = function(toCmp){
	var strToCmp = String(toCmp);
	if (this.length != strToCmp.length) return false;
	
	return this.toLowerCase() == strToCmp.toLowerCase();
}

/*
segue a lógica da função strcasecmp do php
@return int Retorna < 0 se a string parâmetro(toCmp) é maior; > 0 se a string parâmetro(toCmp) é menor, e 0 se forem iguais
*/
String.prototype.caseCmpDiff = function(toCmp){
	var strToCmp = String(toCmp);
	var fim = (this.length < strToCmp.length) ?this.length :strToCmp.length;
	
	for(var i = 0; i < fim; i++){
		var diferenca = this.charCodeAt(i) -strToCmp.charCodeAt(i);
		if (diferenca != 0) { return diferenca; }
	}
	
	return this.length - strToCmp.length;
}


// search substring 
String.prototype.substrOf = function(substr, start){
	var index = ""
	if ((index = this.indexOf(String(substr), start)) === -1) { return index; }
	return this.substr(index);
}

String.prototype.lastSubstrOf = function(substr, start){
	var index = ""
	if ((index = this.lastIndexOf(String(substr), start)) === -1) { return index; }
	return this.substr(index);
}

String.prototype.substrOf = function(substr, start){
	var index = ""
	if ((index = this.indexOf(String(substr), start)) === -1) { return index; }
	return this.substr(0, index);
}

String.prototype.lastSubstrOf = function(substr, start){
	return (index = this.lastIndexOf(String(substr), start)) === -1 ? index : this.substr(0, index)
/*	var index = ""
	if ((index = this.lastIndexOf(String(substr), start)) === -1) { return index; }
	return this.substr(0, index);*/
}
/*

fazer uma funcao:
- q retorna uma string comecando na primeira ocorrencia d um conjunto d chars ateh o final c um offset opcional
- q retorna uma string comecando na ultima ocorrencia d um conjunto d chars ateh o final
- q retorna uma string comcando no indece 0 ateh a primeira ocorrencia d um conjunto d chars
- q retorna uma string comcando no indece 0 ateh a ultima ocorrencia d um conjunto d chars

fazer a classe TokenIterator.
*/

/*
String.prototype.pbrk = function(chars){
	chars = chars == undefined ? "\\s" : chars
	var r = new RegExp("^[" + chars + "]+|[" + chars + "]+$", "g")
	return this.replace(r,"")
}


/* SUGESTÃO DE FUNÇÕES
- str_repeat
strtok - Tokenize string
strpbrk
str_shuffle
ucfirst - Make a string's first character uppercase
ucwords - Uppercase the first character of each word in a string 
strrev - Reverse a string
strspn - Find length of initial segment matching mask 
wordwrap - Wraps a string to a given number of characters using a string break character 
str_rot13
str_pad
strpos - Find position of first occurrence of a string 
strstr - Find first occurrence of a string
strrchr - Find the last occurrence of a character in a string 
strripos - Find position of last occurrence of a case-insensitive string in a string 
strrpos - Find position of last occurrence of a char in a string 
*/

String.prototype.pad = function(pad_length, pad_string){
	var length = parseInt(pad_length);
	if (isNaN(length) || length > this.length) return this;
		
	if (typeof pad_string != 'string') pad_string = ' ';
	
	return true;
}

String.prototype.padLeft = function(pad_length, pad_string){
	var length = parseInt(pad_length);
	if (isNaN(length) || length <= this.length) return String(this);
	
// este codigo vai seguir o php? pq se um objeto tiver toString ele vai pegar a string q este metodo retorna
//	var padString = ' ';
//	if (typeof pad_string == 'string' || pad_string instanceof Object && typeof pad_string.toString == 'function') padString = pad_string.toString();
	var padString = String(pad_string);
	
	length -= this.length;
	var repeatedPad = padString.repeat(Math.ceil( length /padString.length ));
	var leftPad = repeatedPad.substr(0, length);
	return String(leftPad +this);
}

/*
String.token = { strTokens : undefined };
String.prototype.tokenize = function(tokens) {
	if (this.token == undefined){
alert(this.token);
		this.token = String.token;
	}
	
	var strTokens = String(tokens);
	if (this.token.strTokens != strTokens) {
		this.token.strTokens = strTokens;
		
		this.token.regExpBeginToken = new RegExp("^[" +this.token.strTokens +"]+");
		this.token.regExpNotToken = new RegExp("([^" +this.token.strTokens +"]+)[" +this.token.strTokens+"]*(.*)");
		this.token.startAt = 0;
	}
	
	var strToTokenize = this.slice(this.token.startAt);
	var len = strToTokenize.length;
	
	strToTokenize = strToTokenize.replace(this.token.regExpBeginToken,'');
	len -= strToTokenize.length;
	
	var result = strToTokenize.match(this.token.regExpNotToken);
	if (result instanceof Array && result.length >= 2) {
		this.token.startAt += result[1].length +len;
		return result[1];
	}
	
	return false;
}

String.prototype.tokenize = function(tokens) {
	if (this.token_strTokens == undefined) {
		this.token_strTokens = undefined;
	}
	
	var strTokens = String(tokens);
alert('"' +this.token_strTokens +'"');
	if (this.token_strTokens != strTokens) {
		this.token_strTokens = strTokens;
		
		this.token_regExpBeginToken = new RegExp("^[" +this.token_strTokens +"]+");
		this.token_regExpNotToken = new RegExp("([^" +this.token_strTokens +"]+)[" +this.token_strTokens+"]*(.*)");
		this.token_startAt = 0;
	}
	
	var strToTokenize = this.slice(this.token_startAt);
	var len = strToTokenize.length;
	
	strToTokenize = strToTokenize.replace(this.token_regExpBeginToken,'');
	len -= strToTokenize.length;
	
	var result = strToTokenize.match(this.token_regExpNotToken);
	if (result instanceof Array && result.length >= 2) {
		this.token_startAt += result[1].length +len;
		return result[1];
	}
	
	return false;
}
*/