更改函数的值还是与原型保持相同？

Question

如果设置了参数，如何更改对象的值，如果设置了则不更改

示例：

//parameter is a object
var Main = function(parameter)
{
    this.num = 1;
    this.string = "this"
}

Main.prototype.constructor = Main;

//source is an object
Main.prototype.copy = function(source)
{
    Main.prototype.copy.call(this, source);

    this.num = source.num;
    this.string = source.string;


    return this;
}

//set sub2 to have num is 4 instead of 1
var sub2 = new Main({num:4});

我想知道如何设置一个原型，如果一个参数是et，则可以允许更改原始对象，但如果没有设置参数，则使用 Main 函数中的默认值，或者我会使用一个函数来设置如果参数为空，则将值设置为默认值，如果为空，则设置为参数对象？

谢谢

Answer 1

我发现花了一段时间，我决定查看三个 js 代码以查看属性是如何设置的，我发现要设置属性我需要遍历对象并获取键并设置键对象：这是一个创建行星的例子

    /* parameters = {
    radius : <float>
    tilt : <float>
    distance : <float>
    days : <float>
    years : <float>
    diffuse : <texture>
    specular : <texture>
    normal : <texture>
    bump : <texture>
}
*/
var CelestialObject = function (parameters) {
    var toRadians = 180 / Math.PI;

    this.radius = 1;
    this.tilt = 23.5;
    this.distance = 0;
    this.days = 1;
    this.years = 1;
    this.orbitEccentricity = 0;
    this.diffuse = null;
    this.specular = null;
    this.normal = null;
    this.bump = null;


    var material = new THREE.MeshPhongMaterial();//mesh material
    var geometry = new THREE.SphereGeometry(this.radius, 64, 64);//sphere geometry
    var mesh = new THREE.Mesh(geometry, material);//mesh

    //Apply Textures
    if (this.diffuse = null)
        material.map = this.diffuse;
    else
        material.color = new THREE.Color(0x777777);
    if (this.specular = null)
        material.map = this.specular;
    if (this.normal = null)
        material.normalMap = this.diffuse;
    if (this.bump = null)
        material.bumpMap = this.bump;

    //Set Tilt
    this.SetTilt = function () {
        mesh.rotateZ(this.tilt * toRadians);
    }

    //Rotate 
    var Rotate = function (mesh) {

        requestAnimationFrame(Rotate);

        var hoursInDay = 24;
        var angle = (360 / (this.days * hoursInDay)) * toRadians;

        mesh.rotateY(angle);
    }

    //Revolve
    var Revolve = function (mesh) {

        requestAnimationFrame(Revolve);

        var time = new Date().getTime();
        var hoursInYears = this.years * 365 * 24;

        time += 360 / hoursInYears;

        var xPos = Math.cos(time) * this.distance;
        var zPos = Math.sin(time) * this.distance * this.orbitEccentricity;


        mesh.position.set(xPos, 0, zPos);
    }

    //set mesh
    this.setMesh = function (customMesh, meshURL) {
        var jsonLoader = new THREE.JSONLoader();
        if (!customMesh)
            mesh = new THREE.Mesh(new THREE.SphereGeometry(this.radius, 64, 64), new THREE.MeshPhongMaterial({ color: 0x777777 }));//sphere
        else
            mesh = jsonLoader.load(meshURL);
    }

    //set values
     for (var key in parameters) {
            var newValue = parameters[key];
            this[key] = newValue;
     }


    Rotate(mesh);
    Revolve(mesh);

    return this;
};
//create new planets here with different values
var earth = new CelestialObject();//use default parameters
var mars = new CelestialObject({radius:.4,tilt:25,distance:141,days:1.5,years:2});//uses new parameters

Answer 2

唯一的区别在于命名法：

// So if you declare object as
var obj1 = {param1: "value1"};

// there is absolutely no difference if you declare it as
var obj2 = new Object({param2: "value2"});

// Its because every object inherits from Object,
// no matter which way is defined.

// Test
console.log(typeof obj1);
console.log(typeof obj2);

console.log(obj1 instanceof Object);
console.log(obj2 instanceof Object);

// Reaction to your comment below:
// Its as complicated as confusing. In this case 'var obj = {}' you are
// creating object and curly brackets delimit object definition.
// But in this case 'var obj2 = function() {}' you are creating function
// and curly brackets represents 'code block', not object literal.
// But ... function is object also...

var myFunction = function() {};
console.log(myFunction instanceof Object);

// And while this 'var obj = function(){para: 1}' is valid but meaningless 
// code, this 'var obj = function(){this.para: 1}' is as valid as 
// well as frequently used expression to create ... object. But object in 
// another sense... Its really confusing.

但第一个表达式，称为“对象文字表达式”，是创建对象的首选且安全的方式。因为一些恶意代码可以覆盖对象行为。因此，如果您将对象创建为 new Object()，则可以创建一些意想不到的东西。但是对象字面量表达式不能被覆盖。