nightfury7 / universalbasics.js

src/ub.strings.find.asserts.js

/** global: UB */

var stringFuncs = {
	
	
	beginsWith: function(prefix, length = 0){
		return this.smartStartsWith(prefix, length, true);
	},
	beginsWithCI: function(prefix, length = 0){
		return this.smartStartsWith(prefix, length, false);
	},
	startsWith: function(prefix, length = 0){
		return this.smartStartsWith(prefix, length, true);
	},
	startsWithCI: function(prefix, length = 0){
		return this.smartStartsWith(prefix, length, false);
	},
	smartBeginsWith: function(prefix, length = 0, caseSensitive = true, trimAndCheck = false){
		return this.smartStartsWith(prefix, length, caseSensitive, trimAndCheck);
	},
	smartStartsWith: function(prefix, length = 0, caseSensitive = true, trimAndCheck = false){
		var text = this;
	
		// trim and check if needed
		if (trimAndCheck) {
			text = text.replace(UB.regex.Trim, '');
		}
		
		// "starts with any"
		if (prefix.constructor == Array){
			
			// per search term
			for (var s = 0, sl = prefix.length;s<sl;s++){
				var pre = prefix[s];
				
				// ends with one
				if (text.smartStartsWith(pre, length, caseSensitive)) {
					return true;
				}
			}
			
			// doesnt end with any given
			return false;
		}


		// JS startsWith() API support
		if (length > 0 && prefix.length > length){
			prefix = prefix.substr(0, length);
		}

		// "starts with"
		var l1 = text.length;
		var l2 = prefix.length;
		
		// check quickly if same/less length
		if (l1 < l2) {
			return false;
		}
		if (l1 == l2) {
			if (caseSensitive) {
				return text == prefix;
			}
			return text.toLowerCase() == prefix.toLowerCase();
		}
		
		// check using substring if main string longer
		if (caseSensitive) {
			//return text.substr(0, l2) == prefix;
			return text.lastIndexOf(prefix, 0) === 0;
		}
		return text.substr(0, l2).toLowerCase() == prefix.toLowerCase();
	},
	endsWith: function(postfix, length = 0){
		return this.smartEndsWith(postfix, length, true);
	},
	endsWithCI: function(postfix, length = 0){
		return this.smartEndsWith(postfix, length, false);
	},
	smartEndsWith: function(postfix, length = 0, caseSensitive = true, trimAndCheck = false){
		var text = this;
	

		// trim and check if needed
		if (trimAndCheck) {
			text = text.replace(UB.regex.Trim, '');
		}
		
		// "ends with any"
		if (postfix.constructor == Array){
			
			// per search term
			for (var s = 0, sl = postfix.length;s<sl;s++){
				var post = postfix[s];
				
				// ends with one
				if (text.smartEndsWith(post, length, caseSensitive)) {
					return true;
				}
			}
			
			// doesnt end with any given
			return false;
		}

		// JS endsWith() API support
		if (length > 0 && postfix.length > length){
			postfix = postfix.substr(0, length);
		}

		// "ends with"
		var l1 = text.length;
		var l2 = postfix.length;
		
		// check quickly if same/less length
		if (l1 < l2) {
			return false;
		}
		if (l1 == l2) {
			if (caseSensitive) {
				return text == postfix;
			}
			return text.toLowerCase() == postfix.toLowerCase();
		}
		
		// check using substring if main string longer
		if (caseSensitive) {
			//return text.substr(l1 - l2, l2) == postfix;
			var index = l1 - l2;
			return text.indexOf(postfix, index) == index;
		}
		return text.substr(l1 - l2, l2).toLowerCase() == postfix.toLowerCase();
	},
	contains: function(substring){
		return this.smartContains(substring, true);
	},
	containsCI: function(substring){
		return this.smartContains(substring, false);
	},
	smartContains: function(substring, caseSensitive = true, substringIsLower = false, wholeWords = false){
		var text = this;
		
		// "contains any"
		if (substring.constructor == Array){
			
			// per search term
			for (var s = 0, sl = substring.length;s<sl;s++){
				var sub = substring[s];
				
				// ends with one
				if (text.smartContains(sub, caseSensitive, substringIsLower, wholeWords)) {
					return true;
				}
			}
			
			// doesnt end with any given
			return false;
		}

		// "contains"
		if (wholeWords) {
			return text.match(UB.regex.New(substring, wholeWords, caseSensitive, true)).length > 0;
		}
		if (caseSensitive) {
			return text.indexOf(substring) != -1;
		}
		/*
		text = text.toLowerCase();
		substring = substring.toLowerCase();
		
		return text.indexOf(substring) != -1;*/
		
		
		// quick checks
		if (text.length < substring.length) {
			return false;
		}
		
		//temps
		var sl = substring.length;

The variable sl already seems to be declared on line 147. Consider using another variable name or omitting the var keyword.

		var ml = (text.length - sl);
		
		// very fast CI comparison
		return text._indexOfCI(substring, 0, substringIsLower, sl, ml) > -1;

		// much faster than this:
		/*return text.toLowerCase().indexOf(substring.toLowerCase()) != -1;*/
	},
	beginningOf: function(text, caseSensitive = true){
		var prefix = this;
		return text.startsWith(prefix, caseSensitive);
	},
	endingOf: function(text, caseSensitive = true){
		var postfix = this;
		return text.endsWith(postfix, caseSensitive);
	},
	containedIn: function(text, caseSensitive = true, substringIsLower = false){
		var substring = this;
		return text.contains(substring, caseSensitive, substringIsLower);
	},
	
	// contains
	containsAll: function(checkPerWord, searchFor, caseSensitive = true){
		var str = this;
		
		// split haystack into words
		var words = checkPerWord?str.split(" "):[str];
		
		// compare each word of needle seperately
		var matched = 0;
		for (var w = 0, wl = words.length;w<wl;w++){
			
			var word = words[w];
			
			// return true if any haystack S.Contains the needle
			for (var s = 0, sl = searchFor.length; s < sl; s++) {
				var sWord = searchFor[s];
				if (word.smartContains(sWord, caseSensitive)) {
					matched++;
				}
			}
		}
		
		return matched == searchFor.length;
	},
	containsNumber: function(){
		var str = this;
		for (var c = 0, cl = str.length;c<cl;c++){
			var char = str.charAt(c);
			if (char.isNumber()) {
				return true;
			}
		}
		return false;
	},
	containsAlphaNumeric: function(){
		var str = this;
		for (var c = 0, cl = str.length;c<cl;c++){
			var char = str.charAt(c);
			if (char.isAlphaNumeric()) {
				return true;
			}
		}
		return false;
	},
	
	
	endsWithAny_Index: function(searchFor, caseSensitive = true, trimAndCheck = false){
		var str = this;
		
		// trim and check if needed
		if (trimAndCheck) {
			str = str.replace(UB.regex.Trim, '');
		}
		
		// per search term
		var indices = [];

The variable indices seems to be never used. Consider removing it.

		for (var s = 0, sl = searchFor.length;s<sl;s++){
			var sWord = searchFor[s];
			
			// ends with one
			if (str.endsWith(sWord, caseSensitive)) {
				return s;
			}
		}
		
		// doesnt end with any given
		return -1;
	},
	/** checks if the string begins with any of the given terms, and returns the char index of the first found term */
	beginsWithAny_Index: function(searchFor, caseSensitive = true, trimAndCheck = false){
		return this.startsWithAny_Index(searchFor, caseSensitive, trimAndCheck);
	},
	/** checks if the string begins with any of the given terms, and returns the char index of the first found term */
	startsWithAny_Index: function(searchFor, caseSensitive = true, trimAndCheck = false){
		var str = this;
		
		// trim and check if needed
		if (trimAndCheck) {
			str = str.replace(UB.regex.Trim, '');
		}
		
		// per search term
		var indices = [];

The variable indices seems to be never used. Consider removing it.

		for (var s = 0, sl = searchFor.length;s<sl;s++){
			var sWord = searchFor[s];
			
			// ends with one
			if (str.startsWith(sWord, caseSensitive)) {
				return s;
			}
		}
		
		// doesnt end with any given
		return -1;
	},
	
	/** checks if the string contains any of the given terms
	 * @param	searchFor		an array of search terms
	 */
	containsAny_Index: function(searchFor, caseSensitive = true){
		var str = this;
		
		// return index if found
		for (var s = 0, sl = searchFor.length; s < sl; s++) {
			var sWord = searchFor[s];
			var i = str.smartIndexOf(sWord, caseSensitive);
			if (i > -1){
				return i;
			}
		}
		
		return -1;
	},
	
	none:null
};

// register funcs
UB.registerFuncs(String.prototype, stringFuncs);