¿Como puedo hacer para que aparezcan las primeras letras de las palabras en mayusculas?

cadena="hello world"
'-------------SEPARAMOS LAS PALABRAS
cadenaArr=split(cadena, " ")
'-------------RECORREMOS EL ARRAY RESULTANTE
for i=0 to ubound(cadenaArr)
palabra=cadenaArr(i)
palabra=ucase(left(palabra,1)) & lcase(right(palabra, len(palabra)-1))
cadenaFinal=cadenaFinal & palabra & " "
next
response.write cadenaFinal '---(Hello World)

const first_letter_uppercase_word = str => {
  return str.toLowerCase().replace(/b[a-z]/g, c => c.toUpperCase())
}

first_letter_uppercase_word("HELLO worlD")

Example: Hello World

Viendo las respuesta dada, te daré una solución sin usar regex.

Características de la función:

• Puedes pasar una sola palabra o una cadena completa
• Respeta los tildes y los diéresis
• No usamos regex

function capitalizarPalabras( val ) {
  
  return val.toLowerCase()
            .trim()
            .split(' ')
            .map( v => v[0].toUpperCase() + v.substr(1) )
            .join(' ');  
}

console.log( capitalizarPalabras( 'hola' ) );
console.log( capitalizarPalabras( ' hola' ) ); // Empieza con un espacio
console.log( capitalizarPalabras( 'hola mundo ' ) );
console.log( capitalizarPalabras( 'ñoño óle' ) );
console.log( capitalizarPalabras( '1 ñoño óle' ) );
console.log( capitalizarPalabras( ' über öll mi au' ) );
console.log( capitalizarPalabras( 'algun texto sin sentido. y este aún menos. ' ) );

Hagamos una solución en castellano con expresiones regulares.

Sobre las letras del español:
Para las expresiones regulares en JavaScript, la ñ y los acentos no son caracteres de palabra¹.
_{1: No están incluidos en w, y por ende b los toma mal}

En JavaScript², tenemos que hacer que coincida con el caracter previo (o el inicio del string) e incluirlo en el reemplazo, seguido de una letra en minúsculas.
_{2: Porque en JavaScript no hay inspecciones hacia atrás (lookbehinds), como sí hay en otros dialectos de regex.}

Para capitalizar las minúsculas al inicio de cada palabra:

const re = /(^|[^A-Za-zÁÉÍÓÚÜÑáéíóúüñ])([a-záéíóúüñ])/g;
texto.replace(re, function(match, caracterPrevio, minuscula) {
    return caracterPrevio + minuscula.toLocaleUpperCase(['es', 'gl', 'ca', 'pt', 'en']);
});

Y, además, podemos llevar a minúsculas todo el resto, haciendo:

• que tambíen coincida con mayúsculas iniciales (para no reemplazar),
• y con mayúsculas intermedias (para llevar a minúsculas).

Solución:

function titleCase(texto) {
    const re = /(^|[^A-Za-zÁÉÍÓÚÜÑáéíóúüñ])(?:([a-záéíóúüñ])|([A-ZÁÉÍÓÚÜÑ]))|([A-ZÁÉÍÓÚÜÑ]+)/gu;
    return texto.replace(re,
        (m, caracterPrevio, minuscInicial, mayuscInicial, mayuscIntermedias) => {
            const locale = ['es', 'gl', 'ca', 'pt', 'en'];
            if (mayuscIntermedias)
                return mayuscIntermedias.toLocaleLowerCase(locale);
            return caracterPrevio
                 + (minuscInicial ? minuscInicial.toLocaleUpperCase(locale) : mayuscInicial);
        }
    );
}

Descripción:

/(^|[^A-Za-zÁÉÍÓÚÜÑáéíóúüñ])(?:([a-záéíóúüñ])|([A-ZÁÉÍÓÚÜÑ]))|([A-ZÁÉÍÓÚÜÑ]+)/gu

Son 2 alternativas en un OR: /1|2/gu

1. (^|[^A-Za-zÁÉÍÓÚÜÑáéíóúüñ])(?:([a-záéíóúüñ])|([A-ZÁÉÍÓÚÜÑ])) - LETRA INICIAL.

   • (^|[^A-Za-zÁÉÍÓÚÜÑáéíóúüñ]) - Inicio del texto o cualquier caracter que no sea alfabético.
     Es el primer grupo => se pasa al callback en la variable caracterPrevio.
   • (?:([a-záéíóúüñ])|([A-ZÁÉÍÓÚÜÑ])) - La primera letra de la palabra, ya sea:
     ([a-záéíóúüñ]) - letra en minúscula => se pasa como la variable minuscInicial, o
     ([A-ZÁÉÍÓÚÜÑ]) - letra en mayúscula => se pasa como la variable mayuscInicial.

2. ([A-ZÁÉÍÓÚÜÑ]+) - MAYÚSCULAS INTERMEDIAS
   Cuando coincide con esta parte, significa que no coincidió con la primera. Por lo tanto, sabemos que no es una letra al inicio de una palabra, sino una letra intermedia.

   • [A-ZÁÉÍÓÚÜÑ]+ coincide con 1 o más letras en mayúsculas (no iniciales), de modo que podemos llevarlas a minúsculas.
     Es el cuarto grupo => se pasa como la variable mayuscIntermedias.

Demo:

//Leva a mayúsculas la primera letra de cada palabra
function titleCase(texto) {
    const re = /(^|[^A-Za-zÁÉÍÓÚÜÑáéíóúüñ])(?:([a-záéíóúüñ])|([A-ZÁÉÍÓÚÜÑ]))|([A-ZÁÉÍÓÚÜÑ]+)/gu;
    return texto.replace(re,
        (m, caracterPrevio, minuscInicial, mayuscInicial, mayuscIntermedias) => {
            const locale = ['es', 'gl', 'ca', 'pt', 'en'];
            //Son letras mayúsculas en el medio de la palabra
            // => llevar a minúsculas.
            if (mayuscIntermedias)
                return mayuscIntermedias.toLocaleLowerCase(locale);
            //Es la letra inicial de la palabra
            // => dejar el caracter previo como está.
            // => si la primera letra es minúscula, capitalizar
            //    sino, dejar como está.
            return caracterPrevio
                 + (minuscInicial ? minuscInicial.toLocaleUpperCase(locale) : mayuscInicial);
        }
    );
}

//Evento para mostrar el resultado cada vez que se ingresa un caracter
document.getElementById('ingreso')
    .addEventListener('input',
        event => {
            document.getElementById('resultado')
                .innerText = titleCase(event.target.value);
        }
    );

<input type="text"
       id="ingreso"
       placeholder="Escribí texto para llevar a mayúsculas la primera letra de cada palabra"
       style="width:100%">
<pre id="resultado">

Usando, replace(), expresiones regulares y funciones flecha de ES6

console.log('kdz stack overflow'.replace(/b[a-z]/g,c=>c.toUpperCase()));

La implementación más corta para capitalizar palabras dentro de una cadena es la siguiente utilizando las funciones Arrow de ES6:

'your string'.replace(/bw/g, l => l.toUpperCase())
// => 'Your String'

Implementación compatible con ES5:

'your string'.replace(/bw/g, function(l){ return l.toUpperCase() })
// => 'Your String'

La expresión regular coincide con la primera letra de cada palabra dentro de la cadena dada y transforma solo esa letra en mayúscula:

b coincide con un límite de palabra (el comienzo o el final de la palabra);
w coincide con el siguiente metacaracteres [a-zA-Z0-9].