Solving for equilibrium index in an array

Correctness:

Your code has a few syntax points that are bad form, and your indentation and spacing is incorrect in more than a few places (for example, the massive amount of extraneous lines)

You should consider using a code cleaner, like JSFiddle's TidyUp to tidy your code up, and you can inspect the changes made to learn to improve, but a few major ones are as follows:

for loop:

var arrLen = A.length;

var i = 0;



for(i = 0; i < arrLen; i++){

A for loop has the built-in feature to define variables, and not just more than one, in which case, this can be converted to the following: (Additionally, you shouldn't sacrifice readability for a few characters, arrLen is fine as arrayLen or arrayLength)

for(var i = 0, length = A.length; i < length; i++){

Clarity of variables:

function solution

solution is unclear, consider improving that with something like: equiSolution or equi. secSum is a bit ugly unclear, and for sakes of readability, a few characters won't hurt.

Getting Chunks:

Similarly to the for loop point above: you shouldn't need to define lenJ, or manually define j:

for (var j = 0, length = i + 1; j < length; j++){
    firstSum += A[j];
}

for(var j = i + 2, length = A.length; j < length; j++){
    secondSum += A[j];
}

console.log:

Instead of blind commented-out logs everywhere, use a debug variable with a helper function:

function log(string){
    var debug = true;
    if (debug) console.log(string);
}

// ...
log("firstChink: " + j); //<-- also spelling mistake here

With that helper function in place you can just change the debug variable if you want them not to be logged. Ideally, you would keep that debug variable as a constant at the top of the program, but for a small script like this, probably not necessary.

Returning -1:

In the case that there is no equilibrium in the array, -1 is supposed to be returned, however, instead you're returning arrLen (the length of the array). Returning the array length will cause test failure in those cases.

Performance:

\$O(n^2)\$ solution:

Your solution is currently \$O(n^2)\$, meaning the operation is processed however many elements there are squared, while the Codility page explains how an \$O(n)\$ solution can be attained:

Instead of using a solution where you check the sums of both sides relative, use the following rule:

\$S_R\$ = sum of right side, \$S_L\$ = sum of left side, \$S_T\$ = total sum, \$A[i]\$ = the current element

$$S_R = S_T - S_L - A[i]$$ $$S_L = S_T - S_R - A[i]$$

So, simply use sums alongside the following algorithm, which has actually been supplied by Codility in their Equi blog post, you'll be able to achieve \$O(n)\$:

long long sum_left = 0;    
for(i=0;i<n;i++) {
    long long sum_right = sum - sum_left - (long long) arr[i];
    if (sum_left == sum_right) return i;
    sum_left += (long long) arr[i];
}

One major downside:

JavaScript is not made to handle the long or long long types, so arrays with larger sums will not be able to handle this as well.

This is a language feature; however third party libraries can supply the type, if you so wish. See this Stack Overflow answer for more information on the subject.

Quill's answer does a good job explaining the performance problems of your approach.

I thought I'd add a working javascript solution that is fairly concise, with explanations inline as comments. Note that this function returns an array of all equilibrium indexes, or the empty array if none are found:

function eqIndexes(arr) {
    // start the right hand sum as the sum of the whole array
    var rightSum = arr.reduce(function(m,c) { return m+c }, 0),
        leftSum = 0,
        isEndPoint;

    // Here we use reduce to build up an array of all
    // indexes which have an equilibrium
    return arr.reduce(function(answer,cur,i) {
        rightSum -= cur;
        isEndPoint = i == 0 || i == arr.size -1
        // If we're at the beginning or the end of the array,
        // just return the answer we already have.  This will 
        // be the empty array we started with when i == 0, and 
        // it will be our final answer when we're at the last elm.
        if (isEndPoint) return answer;

        leftSum += arr[i-1];
        if (leftSum == rightSum) answer.push(i);
        return answer;
    },[]);
}

Just my 2 cents. I got the pseudocode for this from http://www.geeksforgeeks.org/equilibrium-index-of-an-array/.

The concept is to first get the total sum of the array, then run a loop. For each iteration of the loop, we first subtract the element at that index from the total sum (or right sum), then we compare with the value of the left sum. If there's a match we push that index position onto an output array. If no match, we increment the left sum by the value of the array element at the current index and run the loop again.

Of course we test for edge cases where the input array is a null array or single element array. The following solution whic followed the concept above scored 100%.

function equil(A) {
  var
    output = [],
    len = A.length,
    i;
  if(A.length === 0) {
    return -1;
  }
  if(A.length === 1) {
    return 0;
  }
  var
    rSum = A.reduce(function (i,j) {
      return i + j;
    }),
    lSum = 0;
  for(i = 0; i < len; i++) {
    rSum -= A[i];
    if(lSum === rSum) {
      output.push(i)
    }
    lSum += A[i];
  }
  if(output.length === 0) {
    return -1
  }
  return output[0];
}

My initial 'naive attempt' scored 54% i believe...

function solution(A) {
    // write your code in JavaScript (Node.js 4.0.0)
  if(A.length === 0) {
    return -1;
  }
  if(A.length === 1) {
    return 0;
  }
  else {
      var raw = A.map(function (el, indx, arr) {
        var
          sumL = 0,
          sumH = 0,
          len = arr.length,
          candidate = arr[indx];
        for(i = 0; i < indx; i++) {
          sumL += arr[i];
        }
        for(i = (indx + 1); i < len; i++) {
          sumH += arr[i];
        }
        if(sumL === sumH) {
          return indx;
        }
      }).filter(function (el) {
          return el;
        });
      if(raw.length === 0) {
        return -1;
      }
    return raw[0];
  }
}