Undefined value in return but correct in the function

If you want to use the data from the call ajaxyou should do it with Promiseinstead of the classic success/error.

And it is that it ajaxreturns one Promisethat you can wait for it to be resolved and propagate.

function ajaxCall(dni_a_verificar)
{
    return $.ajax({
            type: 'POST',
            url: 'validacion.php',
            data: 'dni_existe=' + dni_a_verificar
    });
}

Here the call is made to ajax. Without the properties successnor error, since the answers will be expected from outside.

function existe_dni(dni_a_verificar) {
    return ajaxCall(dni_a_verificar)
            .then(html => {
                var validacion = $.parseJSON(html);
                console.log("DNI: " + dni_a_verificar + " (" + typeof(dni_a_verificar) + ")");
                console.log("Validacion: " + validacion + " (" + typeof(validacion) + ")");
                console.log("");
                return validacion;
            })
            .catch(e => e);
}

This function calls the previous ajaxCall. Inside the function thenwill be the response without errors. The catchwill be invoked in case the call had some kind of error.
This function existe_dniwill also return a Promise. The result of this will be the variable validacionin case the call ajaxwas successful. On error, it just raises the exception up.

Finally,

// ...
else {
    existe_dni(dni)
        .then(existe_el_dni => {
            console.log("(if) DNI: " + dni + " (" + typeof(dni) + ")");
            console.log("(if) Existe? " + existe_el_dni);
        })
        .catch(e => {
            console.error(e);
            dni_ctl.style.borderColor = "red";
            errores_personal_cnt++;
            errores_personal += "\t- el D.N.I. ya existe\n";
        })
}

Here again, we will call existe_dnibut subscribe to the response. The response will obviously be the variable validaciónin case it went well, and the error will be obtained within the function catch.

This can be refactored in a thousand more elegant ways. But I think this, to begin with, is an easy way to understand it.

Edit
With use of async/awaitit would look like this.

async function existe_dni(dni_a_verificar)
{
    try {
        const html = await $.ajax({
            type: 'POST',
            url: 'validacion.php',
            data: 'dni_existe=' + dni_a_verificar
        });

        var validacion = $.parseJSON(html);
        console.log("DNI: " + dni_a_verificar + " (" + typeof(dni_a_verificar) + ")");
        console.log("Validacion: " + validacion + " (" + typeof(validacion) + ")");
        console.log("");
        return validacion;
    } catch (e) {
        throw e;
    }
}

The call to existe_dniwould remain the same, with the methods thenand catch.

Edit II

Why did other calls to ajaxwork and this particular one didn't?

The subtle difference is in how you treat the response and what you do with it. Let us suppose the following case.

const ajaxCall = data => {
    $.ajax({
        type: `POST`,
        url: `http://example.com`,
        data,
        success: console.log,
        error: console.error
    });
}

This call makes a request for ajaxand all it does is print the response once it gets it, or print the error, if any.
If we call this function

ajaxCall(`some data`);

Print the result of the request some time later. Suppose the result is the following

AJAX result

What if we expect you to return something to us?

const r = ajaxCall(`some data`);
console.log(r);

const r = ajaxCall(`some data`);
console.log(r);

// undefined
// AJAX result

The function returns undefined(well, it's not strange because we don't have any returnin the function ajaxCall). But we see that first the has returned undefinedand then the has been called console.logwith the answer.

We are going to put a returnto the function once we have the data.

const ajaxCall = data => {
    $.ajax({
        type: `POST`,
        url: `http://example.com`,
        data,
        success: response => {
            return response;
        },
        error: console.error
    });
}

const r = ajaxCall(`some data`);
console.log(r);

// undefined

And it returns exactly the same thing, a undefined.

The successobject property that we pass as an argument to the function ajaxis a function, a callback . This function will be executed once ajaxyou have finished your work.
Important, again, is a function . So the returninside of this function affects the function itself, not the function ajaxCall.
The function has no ajaxCall explicitreturn .

With the following example,

const fn = () => {
    const innerFn = n => {
        return n * 2;
    }

    const r = innerFn(3);
    return r * 2;
}

const r = fn();
console.log(r); // 12

... this is obvious. The returnwithin innerFnaffects innerFn, not fn.

When a function doesn't have a return, Javascript interprets it as an return undefined;implicit.

const fn1 = () => {
    console.log(`Calling fn ...`);
    return;
}

const fn2 = () => {
    console.log(`Calling fn ...`);
}

fn1and fn2they are exactly the same.

In short, why is one call different ajaxfrom another?
It will depend on whether or not that function returns values. If everything you do with the response of ajaxis done in the response itself success, you don't need to implement any pattern of Promise(although implicitly ajaxyou do it inside).
If you need that function to return something, as was your case, you must implement Promiseso that from the outside you can also wait for that response.

So that nothing is left untied, to emulate the calls ajaxI have used the following.

const delay = millis => 
    new Promise(resolve => {
        setTimeout(resolve, millis);
    });

const ajax = async ({ type, url, data, success, error }) => {
    try {
        await delay(1000);
        success(`AJAX result`);
    } catch (e) {
        error(e);
    }
}

const $ = { ajax };

I consider the question answered. If you have other doubts or errors, I suggest you write a different question.
I also encourage you to read the documentation and some interesting articles about asynchronicity in Javascript.

• DocumentationPromise
• Differences between callback andPromise
• A great video about asynchrony in Javascript . The call stack and the event loop .
• The best Javascript book I've ever had the pleasure of reading.

I hope it works.