nightfury7 / universalbasics.js

src/ub.strings.find.index.js

/** global: UB */

var stringFuncs = {
	
	
	// primary search functions
	indexOf: function(search, startAt = null){
		return this.smartIndexOf(search, true, true, startAt);
	},
	indexOfCI: function(search, startAt = null){
		return this.smartIndexOf(search, false, true, startAt);
	},
	smartIndexOf: function(search, caseSensitive = true, first = true, startAt = null, substringIsLower = false, wholeWords = false){
		var text = this;
		
		// temps
		var sl = search.length;
		var ml = (text.length - sl);
		
		// quick checks
		if (ml < sl) {
			return -1;
		}
		
		// only check equality of both strings of equal length
		if (ml == sl) {
			if (caseSensitive && !wholeWords) {
				return (text == search) ? 0 : -1;
			}
			return text.isEqual(search, caseSensitive, false, substringIsLower) ? 0 : -1;
		}
		
		
		// default start at
		if (first) {
			if (startAt == null) {
				startAt = 0;
			}
		} else {
			if (startAt == null) {
				startAt = ml - sl;
			}
		}
		
		
		// if using whole words, slower version is used
		if (wholeWords) {
			var regex = UB.regex.New(search, wholeWords, caseSensitive, true);
			if (first) {
				var i = startAt === 0 ? text.search(regex) : text.substring(startAt).search(regex);
			} else {
				/*var i:int = startAt == (ml - sl) ? text.search(regex) : text.substring(startAt).search(regex);*/
				/// unsupported
				i = -1;
			}
			return i;
		}
		
		
		
		if (first) {
			
			// FIRST INDEX
			
			// CASE INSENSITIVE
			if (!caseSensitive) {
				
				// very fast CI comparison
				return text._indexOfCI(search, startAt, substringIsLower, sl, ml);
				
				// much faster than this:
				//return text.toUpperCase().indexOf(search.toUpperCase(), startAt);
			}
			
			// CASE SENSITIVE
			return text.indexOf(search, startAt);
			
		}
		
		
		// LAST INDEX
		
		// CASE INSENSITIVE
		if (!caseSensitive) {
			
			// very fast CI comparison
			return text._lastIndexOfCI(search, startAt, substringIsLower, sl);
			
			// much faster than this:
			//return text.toUpperCase().lastIndexOf(search.toUpperCase(), startAt);
		}
		
		// CASE SENSITIVE
		return text.lastIndexOf(search, startAt);
	},

	_indexOfCI: function(search, startAt, substringIsLower, sl, ml){
		var text = this;

		// init casing tables
		if (UB.UTF_lowerToUpper == null){
			UB.initCasing();
		}
		
		// per main char
		for (var m = startAt;m <= ml;m++){
							
							
			// per substring char
			var match = true;
			for (var s = 0;s<sl;s++){
				
				var c1 = text.charCodeAt(m + s);
				var c2 = search.charCodeAt(s);
				
				// CI
				if (c1 <= UB.UTF_casingTablesMax){ /// CI
					c1 = UB.UTF_upperToLower[c1];
				}
				if (!substringIsLower){
					if (c2 <= UB.UTF_casingTablesMax){ /// CI
						c2 = UB.UTF_upperToLower[c2];
					}
				}
				
				if (c1 != c2) {
					match = false;
					break;
				}
				
			}
			
			if (match){
				return m;
			}
			
		}

		return -1;
	},

	_lastIndexOfCI: function(search, startAt, substringIsLower, sl){
		var text = this;
		
		// init casing tables
		if (UB.UTF_lowerToUpper == null){
			UB.initCasing();
		}
		
		// per main char
		for (var m = startAt;m >= 0;m--){
			
			
			// per substring char
			match = true;
			for (var s = 0;s<sl;s++){
				
				c1 = text.charCodeAt(m + s);
				c2 = search.charCodeAt(s);
				
				// CI
				if (c1 <= UB.UTF_casingTablesMax){ /// CI
					c1 = UB.UTF_upperToLower[c1];
				}
				if (!substringIsLower){
					if (c2 <= UB.UTF_casingTablesMax){ /// CI
						c2 = UB.UTF_upperToLower[c2];
					}
				}
				
				if (c1 != c2) {
					match = false;
					break;
				}
				
			}
			
			if (match){
				return m;
			}
			
		}
		
		return -1;
	},

	countOf: function(find, caseSensitive = true){
		var text = this;
		
		// use regex method for case insensitive comparison
		if (!caseSensitive){
			var char = UB.regex.Escape(find);
			var flags = 'ig';
			return parseInt(text.match(new RegExp(char, flags)).length);
		}
		
		// use faster method for case sensitive comparison
		var count = 0;
		var index = 0;
		var len = find.length;
		while ((index = text.indexOf(find, index)) > -1) {
			count++;
			index += len;
		}
		return count;
	},
	
	/** searches for all the given terms, collects their char indexes (S.IndexOf), and returns the smallest/largest index (depending on `first`) */
	indexOfAny: function(searchFor, first = true, caseSensitive = true, startAt = null){
		var str = this;

		// index of first
		if (first) {
			return str.indexOfFirstAny(searchFor, caseSensitive, startAt);
		}

		// index of last
		if (startAt == null) {
			startAt = 0;
		}
		return str.indexOfLastAny(searchFor, caseSensitive, startAt);
	},
	/** searches for all the given terms, collects their char indexes (S.IndexOf), and returns the largest index */
	indexOfLastAny: function(searchFor, caseSensitive = true, startAt = null){
		var str = this;
		
		// case insensitive if wanted
		if (!caseSensitive){
			str = str.toLowerCase();
		}
		
		// per search term
		var indices = [];
		for (var s = 0, sl = searchFor.length;s<sl;s++){
			var sWord = searchFor[s];
			
			// case insensitive if wanted
			if (!caseSensitive){
				sWord = sWord.toLowerCase();
			}
			
			// check where found
			indices[s] = str.lastIndexOf(sWord, startAt);
		}
		
		// return last found term
		return indices.max();
	},
	/** searches for all the given terms, collects their char indexes (S.IndexOf), and returns the smallest index */
	indexOfFirstAny: function(searchFor, caseSensitive = true, startAt = 0){
		var str = this;
		
		// case insensitive if wanted
		if (!caseSensitive){
			str = str.toLowerCase();
		}
		
		// per search term
		var indices = [];
		for (var s = 0, sl = searchFor.length;s<sl;s++){
			var sWord = searchFor[s];
			
			// case insensitive if wanted
			if (!caseSensitive){
				sWord = sWord.toLowerCase();
			}
			
			// check where found
			indices[s] = str.indexOf(sWord, startAt);
			
			// change -1 otherwise looks like first found term
			if (indices[s] === -1) {
				indices[s] = UB.intMaxValue;
			}
		}
		
		// return first found term
		return indices.min();
	},
	endIndexOfLastAny: function(searchFor, caseSensitive = true){
		var str = this;
		
		// case insensitive if wanted
		if (!caseSensitive){
			str = str.toLowerCase();
		}
		
		// per search term
		var indices = [];
		for (var s = 0, sl = searchFor.length;s<sl;s++){
			var sWord = searchFor[s];
			
			// case insensitive if wanted
			if (!caseSensitive){
				sWord = sWord.toLowerCase();
			}
			
			// check where found
			indices[s] = str.endIndexOfLast(sWord);
		}
		
		// return last found term
		return indices.max();
	},
	endIndexOfFirstAny: function(searchFor, caseSensitive = true){
		var str = this;
		
		// case insensitive if wanted
		if (!caseSensitive){
			str = str.toLowerCase();
		}
		
		// per search term
		var indices = [];
		for (var s = 0, sl = searchFor.length;s<sl;s++){
			var sWord = searchFor[s];
			
			// case insensitive if wanted
			if (!caseSensitive){
				sWord = sWord.toLowerCase();
			}
			
			// check where found
			indices[s] = str.endIndexOfFirst(sWord);
			
			// change -1 otherwise looks like first found term
			if (indices[s] === -1) {
				indices[s] = UB.intMaxValue;
			}
		}
		
		// return first found term
		return indices.min();
	},
	endIndexOfFirst: function(find){
		var str = this;
		var pos = str.indexOf(find);
		if (pos === -1) return -1;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

		return pos + find.length;
	},
	endIndexOfLast: function(find){
		var str = this;
		var pos = str.lastIndexOf(find);
		if (pos === -1) return -1;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

		return pos + find.length;
	},
	indexOfNumber: function(startAt = 0, not = false, lenIfNotFound = false){
		var str = this;
		for (var c = (startAt>0?startAt:0), cl = str.length;c<cl;c++){
			var char = str.charAt(c);
			if (char.isNumber() != not) {
				return c;
			}
		}
		return lenIfNotFound ? str.length : -1;
	},
	indexOfAlphaNumeric: function(startAt = 0, not = false, lenIfNotFound = false){
		var str = this;
		for (var c = (startAt>0?startAt:0), cl = str.length;c<cl;c++){
			var char = str.charAt(c);
			if (char.isAlphaNumeric() != not) {
				return c;
			}
		}
		return lenIfNotFound ? str.length : -1;
	},
	
	indexOfMany: function(find, startAt = 0){
		var str = this;
		
		// returns the index, of the FIRST FOUND item in the string
		
		var found = -1;
		for (var f = 0, fl = find.length;f<fl;f++){
			var at = str.indexOf(find[f], startAt);
			if (at != -1 && (at < found || found === -1)) {
				found = at;
			}
		}
		return found;
	},
	
	
	indexOfAll: function(find, caseSensitive = true, startAt = 0, wholeWords = false){
		var str = this;
		var indices = [];
		
		var len = str.length;
		var c = startAt;
		while (c < len) {
			c = str.smartIndexOf(find, caseSensitive, true, c, false, wholeWords);
			if (c === -1) {
				break;
			}
			indices.push(c);
			c += find.length;
		}
		
		return indices;
	},

	findAll: function(find){
		var str = this.toString();
		var matches = [];

		// if regex return all matches
		if (find.isRegex()){
			do {
				var match = find.exec(str);
				if (match) {
					matches.push(match);
				}
			} while (match);
		}

		// if string find and return all matches
		if (find.isString()){
			var indices = str.indexOfAll();
			for (var i=0; i<indices.length; i++){
				var index = indices[i];
				var match = {startIndex:index, endIndex:index+find.length, text:find};
			}
		}

		return matches;
	},

	indexOfNth(search, nth, wholeWords = false, matchCase = true) {
		var text = this.toString();

		// quickly test if text contains wanted var
		if (!matchCase || text.contains(search)) {

			// create regex to find
			var regex = UB.regex.New(search, wholeWords, matchCase);
			

			// find and return index if found
			var match = null;
			for (var n = 0; n < nth; n++) {
				match = regex.exec(text);
				if (match == null || match < 0) {
					return -1;
				} else {
					//startAt = match + 1;
				}
			}
			return match == null ? -1 : match;
		}

		return -1;
	},

	
	none:null
};

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