I want to better write this JavaScript procedure

[Jamin2112]

As you may have figured out, I'm obsessed with spending exorbitant amounts of time making optimizations to my code. Can anyone help me cut down on the number of comparisons in the following text2words function? The intent of the function should be easy to figure out from the comments.

		function is_letter(c)
		{
		    /* Returns whether a character c is in the set {'a', 'b', ..., 'z', 'A', 'B', ..., 'Z'} 
		    */
		    return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
		    
		}
		
		function text2words(S)
		{
		    /* Given a string S, return an array A of all the words
		       in S, a word being defined as a sequence of consecutive
		       characters in the set {'a', 'b', ..., 'z', 'A', 'B', ..., 'Z'}.
		    */
		    var A = new Array();
		    var thisword = new String();
		    var i = 0, j = S.length;
		    while (i < j)
		    {
		       if (is_letter(S[i]))
		       {
		           while (i < j && is_letter(S[i]))
                        thisword += S[i++];
		           A.push(thisword);
		           thisword = "";
		       }
		       else
		       {
		           ++i;
		       }
		    }
		    return A;
		}

 

[phinds]

Intellectually, this kind of optimization can be interesting, but in practical terms, unless this code is going to run on ZILLIONS of records, ever night and needs to be done by 6am, you are wasting time optimizing it, given the speed of modern computers. I used to do exactly the same thing just on general principles 'cause I grew up with computers when they were slow, but I gave it up years ago as a waste of time.

 

[AlephZero]

I agree optimizing code can be rather pointless, but the best trick is to learn to write reasonably optimal code first time around. Most programmers of a certain age learned to do that from necessity!

Adding characters to the string "thisword" one at a time could be slow, and hammer dynamic memory allocation if the implementation isn't very clever. It doesn't complicate the code much to search for the end of the word and then deal with the substring of S[] just once.

If your isletter() function is only working on 8-bit characters, the quickest way is to set up an array of true/false flags with 256 elements, instead of doing a function call, up to 4 comparisons, and some logical operations.

If you are reading Unicode text, your isletter function is completely broken anyway. There are of "letters" that are not encoded in 7-bit ascii, even in European languages.

 

[Jamin2112]

Adding characters to the string "thisword" one at a time could be slow

What faster way is there of adding characters to the end of a string? JavaScript's string class doesn't have any kind of push() function.

 

[Mark44]

concat() - See http://www.w3schools.com/jsref/jsref_concat_string.asp

 

[gmar]

Is this homework?

If not then nothing you can write in JS will outperform the built-ins.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split

I am not fully familiar with JS but it looks like you want a set, or a failing that, a standard dict (i.e. hashmap) to store the words i.e. check for duplicates. Javascript does have a dict() and I'm sure you can build a class that hashes a string and stuffs it into a dict.

 

[Jamin2112]

concat() - See http://www.w3schools.com/jsref/jsref_concat_string.asp

That accomplishes the same task, but why is it more efficient than string addition? Is the implementation different?

 

[AlephZero]

That accomplishes the same task, but why is it more efficient than string addition? Is the implementation different?

Javascript strings are effectively immutable (I say "effectively" because pedants might jump on a definition of "immutable" which doesn't quite apply to Javascriot.)

So every time you add one character to a string, you actually create a new string. For short strings, you lose because allocating the new memory area is expensive compared with copying a few bytes of data. For long strings, you lose because you are repeatedly copying large amounts of data, which not only eats up CPU clock cycles, but also eats up the CPU's fast memory cache.