Use filter() to remove values below zero and then check if the length of resulting array is greater than or equal to two

const twoGreaterThanZero = arr => arr.filter(x => x > 0).length >= 2;

console.log(twoGreaterThanZero([9, 1, 0])) //true
console.log(twoGreaterThanZero([0, 0, 0])) //false
console.log(twoGreaterThanZero([5, 0, 0])) //false

forEach ignores the return value and executes for all the elements. So it would be both easier and more performant to use some() (docs here) instead, e.g.

const exists = this.Sort.some(s => s.of === 12.2 && s.groups.length > 0);

If you want to use forEach anyway, you could place your boolean value outside of the loop with initial value of false, and then set it's value to true only if the element exists, e.g.

let exists = false;
this.Sort.forEach(e => {
  if (e.of === 12.2 && e.groups.length > 0) {
    exists = true;
  }
});

You can iterate through the object:

var count = 0;
for (var group in $scope.selected) {
   if ($scope.selected.hasOwnProperty(group) && group.values.length > 0) 
      count++;
}

if (count > 1)
   console.log("More than one group with values");

Is there any difference between checking an array's length as a truthy value vs checking that it's > 0?

Since the value of arr.length can only be 0 or larger and since 0 is the only number that evaluates to false, there is no difference.

In general, Boolean(n) and Boolean(n > 0) yield different results for n < 0.

In other words is there any reason to use one of these statements over the other

Only reasons related to code readability and understanding, not behavior.

No, the length of an array is a non-negative integer. From the spec:

Every Array has a non-configurable "length" property whose value is always a non-negative integral Number whose mathematical value is less than 2^³².

(my emphasis)

So either check is perfectly fine, and both will have the same result for all arrays.

You may find people arguing for === 0 over < 1 on the grounds of performance, because the IsStrictlyEqual algorithm would take fewer steps than the IsLessThan algorithm. Granted that's true, but I'm aware of no evidence that either is faster than the other in this use-case (and I've tested it; sadly the jsPerf test is gone now). (Or others may argue that < will do type conversion and === won't, but that's irrelevant here; both types are the same.) But even if it were that one was minutely faster than the other, you'd have to be doing the comparison literally billions of times to see even the smallest real-world impact.

You want to do the check for undefined first. If you do it the other way round, it will generate an error if the array is undefined.

if (array === undefined || array.length == 0) {
    // array does not exist or is empty
}

Update

This answer is getting a fair amount of attention, so I'd like to point out that my original answer, more than anything else, addressed the wrong order of the conditions being evaluated in the question. In this sense, it fails to address several scenarios, such as null values, other types of objects with a length property, etc. It is also not very idiomatic JavaScript.

The foolproof approach
Taking some inspiration from the comments, below is what I currently consider to be the foolproof way to check whether an array is empty or does not exist. It also takes into account that the variable might not refer to an array, but to some other type of object with a length property.

if (!Array.isArray(array) || !array.length) {
  // array does not exist, is not an array, or is empty
  // ⇒ do not attempt to process array
}

To break it down:

1. Array.isArray(), unsurprisingly, checks whether its argument is an array. This weeds out values like null, undefined and anything else that is not an array.
   Note that this will also eliminate array-like objects, such as the arguments object and DOM NodeList objects. Depending on your situation, this might not be the behavior you're after.

2. The array.length condition checks whether the variable's length property evaluates to a truthy value. Because the previous condition already established that we are indeed dealing with an array, more strict comparisons like array.length != 0 or array.length !== 0 are not required here.

The pragmatic approach
In a lot of cases, the above might seem like overkill. Maybe you're using a higher order language like TypeScript that does most of the type-checking for you at compile-time, or you really don't care whether the object is actually an array, or just array-like.

In those cases, I tend to go for the following, more idiomatic JavaScript:

if (!array || !array.length) {
    // array or array.length are falsy
    // ⇒ do not attempt to process array
}

Or, more frequently, its inverse:

if (array && array.length) {
    // array and array.length are truthy
    // ⇒ probably OK to process array
}

With the introduction of the optional chaining operator (Elvis operator) in ECMAScript 2020, this can be shortened even further:

if (!array?.length) {
    // array or array.length are falsy
    // ⇒ do not attempt to process array
}

Or the opposite:

if (array?.length) {
    // array and array.length are truthy
    // ⇒ probably OK to process array
}

Array.forEach can take three arguments:

element, index, array

Try getting in the array as well and check for its length like below:

var myItems = o.getAggregation("ooo")[0].getItems();
myItems.forEach(function(item, index, array){
    if(array.length > 1) {/*do whatever*/}
})

Here's the reference and the first example shows you taking in an array argument.

Updating with an example:

function demo(data) {
  data.forEach(function(item, index, array){
    if(array.length === 1) {
      console.log("Array with one element: ", array);
    } else {
      console.log("Array with three elements, so gets called thrice: ", array);
    }
  });
}

var myItems = ["1"];
demo(myItems);
myItems = ["1","2","3"];
demo(myItems);

And here's how the output looks like:

Array with one element:  [ '1' ]
Array with three elements, so gets called thrice:  [ '1', '2', '3' ]
Array with three elements, so gets called thrice:  [ '1', '2', '3' ]
Array with three elements, so gets called thrice:  [ '1', '2', '3' ]