how to optimize code in javascript

Question

I think the code(below) is optimized (just use less variables than my initial version of the same logic).

1. How do I really know if its properly optimized ?

2. What factors should I consider during optimization ?

Here is the code ( also on jsfiddle )

function process(arr){
  var processed = [];
  for(var i=0,len=arr.length;i<len;i++){
      if(processed.indexOf(arr[i]) < 0){
          var nodes = findIndexes(arr,arr[i]);
          if(nodes.length > 1){
              for(var j=0,jlen=nodes.length;j<jlen;j++){
                arr[nodes[j]] = arr[nodes[j]] + '(' + ( j + 1 ) + ')';
            }
          }
          processed.push(arr[i]);
      }
   }
   return arr;
 }

function findIndexes(arr,val){
  var node = [];
  for(var i=0,len=arr.length;i<len;i++){
      if(arr[i] === val){
          node.push(i);
      }
  }
  return node;
}

// input
var arr = ['aa','bb','bb','aa','cc','dd','cc','ff']

console.log(process(arr));
//output: ["aa(1)", "bb(1)", "bb(2)", "aa(2)", "cc(1)", "dd", "cc(2)", "ff"]

Here is the explanation of the code. 'process' function looks for the same values inside array and for every same values it changes the value by post pending a number to that values, "number" indicates the count of the value as it found in array.
for example arr = ["x","x","y","z"] will return ["x(1)","x(2)","y","z"] "y" and "z" are unchanged because they appeared only once.

To optimize I have used an array named as processed that is used to hold values that are just processed inside main for loop, so in next iterations it can be determined that the new iteration value is already processed or not by checking through the array.indexOf method, if the value is already processed then it can safely skip the underlying logic (if/for statements).

Now I have no idea how to further optimize it other than changing the whole process logic.

Answer 1

Optimizations in a broad sense will involve simplifying code, precomputing results which are repeatedly reused, and organizing code so more results can be reused.

Your fiddle code produced following result on analysis.

Logical LOC: 26
Mean parameter count: 3
Cyclomatic complexity: 7
Cyclomatic complexity density: 27%
Maintainability index: 104

Lines of Code (LOC)– Indicates the approximate number of lines in the code. The count is based on the IL code and is therefore not the exact number of lines in the source code file. A very high count might indicate that a type or method is trying to do too much work and should be split up. It might also indicate that the type or method might be hard to maintain.

Maintainability Index – Calculates an index value between 0 and 100 that represents the relative ease of maintaining the code. A high value means better maintainability. Color coded ratings can be used to quickly identify trouble spots in your code. A green rating is between 20 and 100 and indicates that the code has good maintainability. A yellow rating is between 10 and 19 and indicates that the code is moderately maintainable. A red rating is a rating between 0 and 9 and indicates low maintainability.

Cyclomatic Complexity – Measures the structural complexity of the code. It is created by calculating the number of different code paths in the flow of the program. A program that has complex control flow will require more tests to achieve good code coverage and will be less maintainable.

Check code complexities using online tool for your javascript code.

Reference : Link1,Link 2

Javascript optimiser page

Reference(Provides you with different techniques that you should keep in mind while optimising)