call for loop through function with parameters

0. Scope: when you define y and z outside the function (in the global scope presumably) they are different than the y and z defined in the parameter list of the function. The ones in the parameter list only exist within the body of the function. Changing the value of the parameter named y within the function does not change the value of the global variable y. So the simple answer to your question is, yes, you need to return something, since the value of the parameter y is lost when the function is done executing.

1. Give your variables descriptive names. Let the obfuscator do it's thing later.

function test(x,y,z) -> function valueTest(arr, err, success)

2. The boolean status and error string are redundant bits of information. If the error string is not empty, then the status is failure. So you don't need to return both a boolean and the string.

3. The status of the previous test is of no relevance to the next test. Therefore, z or success doesn't have to be passed in to the function each time, as it (or something like it) is really the desired output of the function, and each call of the function can be treated separately. If you want to combine the results from different tests then that should be the concern of whatever is calling this function - see separation of concerns and coupling

The only parameter the function actually needs is the value that is under test (the array).

4. When you write the function you define the return value, and thus you define how other code can decipher those results. The function itself doesn't have to do all the work of interpreting the results and building the error string. If your return value was just an array of name attribute values (of the elements of the test array that failed), the calling code could still process "success" or "failure". If the return value has one or more elements, or a length > 0 that would indicate failure.

Removing the redundant/unnecessary parameters and information, you'll have a function that looks something like this:

function valueTest(arr) {
    let results = [];

    for (let i = 0; i < arr.length - 1; i++){
        if (!arr[i].value) {
            results.push(arr[i].getAttribute('name'));
        }
    }

    return results;
}

The caller can decipher and build an error message from that. It might make sense for the function to handle some of the additional work by returning <name> is blank! instead of just <name>, and then you just need to join the elements of the array.

...so within the function...

results.push(arr[i].getAttribute('name') + ' is blank!');

...and back in the global scope...

const error = valueTest(inputs).join(" ");
let success = error.length > 0;

5.If you want a running status indicator from different tests, evaluate an individual test's result, then logically AND that with the previous result.

const result1 = valueTest(inputs1).join(' ');
let success = results1.length > 0;
const result2 = valueTest(inputs2).join(' ');
success &= (results2.length > 0);

Seeing the issues with your code are handled in the comments, I present you a simpler method.

If you count the elements that have the attribute and are not empty and compare it to the length of all the inputs passed you will have a better test

const test = (inputs,attr) => [...inputs]
  .filter(inp => inp.getAttribute(attr) && inp.value.trim() !== "").length === inputs.length;

const istrue = test(document.querySelectorAll("input"),"name")

isTrue will be true if all passed inputs has an attribute called name

You can also do

const elems  = document.querySelectorAll("input[name]")
const isTrue = elems.filter(inp => inp.value.trim() !== "").length === elems.length