let numbers1 = [2, 3, 4, 5];
let numbers2 = [4, 3, 3, 1];
console.log(numbers1.reduce(function(result, value, index){ return result + value * numbers2[index]}, 0));
34

This example demonstrates the use of a "functional" approach rather than an "imperative" one when calculating the dot product of two vectors. The functional approach, known for its brevity, is favored for simple function implementations like what the OP requested.

let numbers1 = [1,2,3,4,5];
let numbers2 = [5,4,3,2,1];

numbers1.map(function(num, index){ //num represents numbers1[index]
 return numbers2[index] + num 
});

=>[6,6,6,6,6]

//To sum the elements of an array:

numbers1.reduce(function(num1, num2){
 return num1 + num2
});

=>15

To learn more about Array.map, click here. For information on Array.reduce, visit here

While there are probably more efficient solutions, I'll offer a recursive perspective for the sake of variety (it's particularly elegant in certain other programming languages). Please note that this function assumes both arrays are of equal length; you didn't specify what to do if they're not.

function calculateProductSum(arr1, arr2) {
    if(arr1.length)
        return arr1.pop() * arr2.pop() + calculateProductSum(arr1, arr2);

    return 0;
}

Edit:

katspaugh recommended swapping the order of returns for slightly improved efficiency (eliminates the need to check array length).

let nums1 = [2,3,4,5];
let nums2 = [4,3,3,1];


let total = 0;
for (let j=0; j < nums1.length; j++) {
  total += (nums1[j] * nums2[j]);
}

alert(total);

Give it a try here: http://jsfiddle.net/VQKPt/

let result = 0;
for(let j = 0; j < arr1.length; j++)
    result += arr1[j]*arr2[j];
console.log(result);

It's important to note that if arr2 is shorter than arr1, it will result in an error. However, since you mentioned they have equal lengths, I did not include a check for this scenario.

The most straightforward way to write this would have to be using a simple for loop:

var index, sum = 0;
for (index = 0; index < array1.length && index < array2.length; index++) {
    sum += array1[index] * array2[index];
}

function multiplyArrays (arrayOne, arrayTwo) {
    var newArray = (arrayOne,arrayTwo).map(x => x * x)
    return newArray
}

var firstArray = [3,6,9]
var secondArray = [3,6,9]
console.log(multiplyArrays(firstArray,secondArray))

Here is an example:

let total = 0;
for (let x=0, size = array1.length; x < size; x++) { // improved iteration
   total += array1[x] * array2[x];
}

This appears to be quite simple and easy for me

let sum = 0;
for (let index = 0; index < array1.length; index++){
    sum += array1[index] * array2[index];   
}

Here's a concise ES6 solution that utilizes the .reduce() function:

const calculateTotal = array1.reduce((total, value, index) => total + (value * array2[index]), 0)

Create functions that will perform the desired operations.

var sum      = function(a, b){ return a + b; };
var subtract = function(a, b){ return a - b; };
var multiply = function(a, b){ return a * b; };
var divide   = function(a, b){ return a / b; };

This allows for a clear and concise way to manipulate two arrays like so:

var array1 = [1,2,3];
var array2 = [2,4,8];

operateArrays(array1, array2, sum);      //[3, 6, 11]
operateArrays(array1, array2, subtract); //[-1, -2, -5]
operateArrays(array1, array2, multiply); //[2, 8, 24]
operateArrays(array1, array2, divide);   //[0.5, 0.5, 0.375]

This function is utilized here:

/**
* Divide each number of an array of numbers by another array of numbers
* @param  {Array}    arrayA  The array of numbers
* @param  {Array}    arrayB  The array of numbers
* @param  {Function} fn      Function that performs an operation
* @return {Array}            The resulting array
* @author Victor N. www.vitim.us
*/
function operateArrays(arrayA, arrayB, fn){
    if(arrayA.length!==arrayB.length) throw new Error("Cannot operate arrays of different lengths");
    return arrayB.map(function(b, i){
        return fn(arrayA[i], b);
    });
}

let numbers = [5,6,7,8];
let nums = [9,9,9,10];

You have the option to use:

let total = numbers.concat(nums).reduce((sum,num)=>sum+num);

or:

let total = numbers.map((n, i) => n + nums[i]).reduce((sum,num) => sum+num);

console.log(total);

Below are 3 different methods that achieve the same outcome. They are presented in order of increasing modern JavaScript syntax.

The initial method utilizes fundamental language features that have been in existence since the early days. This method is compatible with extremely old browsers like IE6.

The second method incorporates features from ECMASScript 5, which was introduced around 2009 and functions on IE9+.

The third method relies on ECMASScript 2015 arrow functions and is not supported on any version of IE, including IE 11 unless a build-step tool like Babel or Typescript is used for transpilation to ES5.

/**
 * Multiplies corresponding values of two arrays and then calculates the sum.
 * Compatible with all legacy browsers
 * @param {number[]} arr1 The first array
 * @param {number[]} arr2 The second array
 **/
function sumOfProductsECMAScript4(arr1, arr2) {
    var total = 0;
    for(var i = 0; i < arr1.length; i += 1) {
        total += arr1[i] * arr2[i];
    }
}

/**
 * Multiplies corresponding values of two arrays and then calculates the sum.
 * Compatible with all mainstream browsers except IE 8 and older.
 * @param {number[]} arr1 The first array
 * @param {number[]} arr2 The second array
 **/
function sumOfProductsECMAScript5(arr1, arr2) {
    // The map function creates a new array by multiplying values of arr1 and arr2
    // The reduce function sums up these products
    return arr1
        .map(function (value, index) { return value * arr2[index]; })
        .reduce(function (sum, current) { return sum + current; }, 0);
}

/**
 * Multiplies corresponding values of two arrays and then calculates the sum.
 * Compatible with all mainstream browsers except IE.
 * @param {number[]} arr1 The first array
 * @param {number[]} arr2 The second array
 **/
function sumOfProductsECMAScript2015(arr1, arr2) {
    // The map function creates a new array by multiplying values of arr1 and arr2
    // The reduce function sums up these products
    return arr1
        .map((v, i) => v * arr2[i])
        .reduce((sum, v) => sum + v, 0);
}



// Define your arrays
let arr1 = [2,3,4,5];
let arr2 = [4,3,3,1];

// Usage
let answer = sumOfProductsECMAScript4(arr1, arr2);
let answer2 = sumOfProductsECMAScript5(arr1, arr2);
let answer3 = sumOfProductsECMAScript2015(arr1, arr2);

When dealing with tasks similar to this, it is often recommended to leverage a library such as mathjs:

const array1 = [2, 3, 4, 5];
const array2 = [4, 3, 3, 1];
const results = math.dot(array1, array2);

Transform it using map and reduce functions

let numbers1 = [6,9,8,4];
let numbers2 = [5,6,7,8];

let finalResult = numbers1.map((value,index) => value * numbers2[index]).reduce((a, b) => a + b, 0)

console.log(finalResult)