Reimplementation of call() method in JavaScript
Review

To be quick I will just add comments to the code with some alternatives

// if you add to a built in prototype use Object.defineProperty or Object.defineProperties
// using the default settings
// Function.prototype.myCall = function(...args){ // use 2 parameters
Function.prototype.myCall = function(name, ...args){ 

  // var param = args.slice(1),  // is now second parameter 

  // Should be a constant
  //    paramLength = param.length, 
  const  paramLength = args.length;

  // not really a param string. Rather its a eval function
  //  paramString = "JSONarg.myFun(";
  var evaledFunc = "JSONarg.myFun(";

  // The variable if defined in the loop should be let
  // Now starts at index 0  
  //for(var i = 1; i &lt;= paramLength; i++){ 
  for (let i = 0; i &lt; paramLength; i++) {  // add space for ( and ) {

    evaledFunc += "args[" + i + "],";  // use spaces between operators
  }
  evaledFunc += ")";

  // This function is a prototype of Function. You would have to go hard 
  // to have the next statement be true. Just let the native exception 
  // generate the error
  /*if(typeof this != 'function'){
    throw new Error(this + " is not a Function");
  }*/

  // Does not change, thus should be a const
  // var JSONarg =  {
  const JSONarg =  {  // would be best defined at the top of the function

  // args[0] is now the param name
  //  ...args[0],
      ...name,
    myFun: this 
  // }  // there should be a ; here
  };
  return eval(evaledFunc);
}


Removing the comments and some minor mods we get...

function myCaller(name, ...args) { 
    const JSONarg =  {...name, myFun: this};
    var func = "JSONarg.myFun(";
    for (let i = 0; i &lt; args.length; i++) {
        func += "args[" + i + "],"; 
    }
    func += ")";
    return eval(func);
}


Rather than eval you could also have use new Function

Object.defineProperty

To prevent problems (myCall showing up in strange places) and as it is in a very often used native type.( All functions get the new property). enumerable = true can slow every function call just a little depending on JS engine and version.

Add to prototype safely using Object.defineProperty. Default accessor configurable, enumerable, writable are false

if (! Function.prototype.myCall) {
    Object.defineProperty(Function.prototype, myCall, {value: myCaller});
}


Function.bind

With all that said there is a much easier way to do the same. Function.bind will bind a functions with an object (sets the functions this)

function printName(location, district){
    alert(this.name + ", " + this.version + ", " + location + ", " + district);
}
printName.bind({...name})( "Chrome", "browser");

// or just use original name obj

printName.bind(name)( "Chrome", "browser");


The bound function is a new reference, the original function remains unbound

const printNameBound = printName.bind(name);

printNameBound("Chrome", "browser");

printName("Chrome", "browser"); // will fail as not bound to name object


Function.call or Function.apply

You can also use Function.call or Function.apply to do the same. In this case there is no new reference to the function created. The binding is temporary.

printName.call(name, "Chrome", "browser"); 

// or

printName.apply(name, ["Chrome", "browser"]); // args as array