_.assign only if property exists in target object

Question

My need is to do something like an _.assign, but only if the target object already has the property being assigned. Think of it like the source objects may have some properties to contribute, but also some properties that I don't want to mix in.

I haven't ever used _.assign's callback mechanism, but tried the following. It 'worked', but it still assigned the property to the dest object (as undefined). I don't want it to assign at all.

_.assign(options, defaults, initial, function (destVal, sourceVal) {
  return typeof destVal == 'undefined' ? undefined : sourceVal;
});

I wrote the following function to do this, but wondering if lodash already has something baked in that is more elegant.

function softMerge (dest, source) {
    return Object.keys(dest).reduce(function (dest, key) {
      var sourceVal = source[key];

      if (!_.isUndefined(sourceVal)) {
        dest[key] = sourceVal;
      }

      return dest;
    }, dest);
}

Answer 1

Here is a immutable deep version, I call it "merge that retains the shape", in TypeScript that uses lodash:

function _mergeKeepShapeArray(dest: Array<any>, source: Array<any>) {
    if (source.length != dest.length) {
        return dest;
    }
    let ret = [];
    dest.forEach((v, i) => {
        ret[i] = _mergeKeepShape(v, source[i]);
    });
    return ret;
}

function _mergeKeepShapeObject(dest: Object, source: Object) {
    let ret = {};
    Object.keys(dest).forEach((key) => {
        let sourceValue = source[key];
        if (typeof sourceValue !== "undefined") {
            ret[key] = _mergeKeepShape(dest[key], sourceValue);
        } else {
            ret[key] = dest[key];
        }
    });
    return ret;
}

function _mergeKeepShape(dest, source) {
    // else if order matters here, because _.isObject is true for arrays also
    if (_.isArray(dest)) {
        if (!_.isArray(source)) {
            return dest;
        }
        return _mergeKeepShapeArray(dest, source);
    } else if (_.isObject(dest)) {
        if (!_.isObject(source)) {
            return dest;
        }
        return _mergeKeepShapeObject(dest, source);
    } else {
        return source;
    }
}

/**
 * Immutable merge that retains the shape of the `existingValue`
 */
export const mergeKeepShape = <T>(existingValue: T, extendingValue): T => {
    return _mergeKeepShape(existingValue, extendingValue);
}

And a simple test to see how I vision such merge should work:

let newObject = mergeKeepShape(
    {
        a : 5,
        // b is not here
        c : 33,
        d : {
            e : 5,
            // f is not here
            g : [1,1,1],
            h : [2,2,2],
            i : [4,4,4],
        }
    },
    {
        a : 123,
        b : 444,
        // c is not here
        d : {
            e : 321,
            f : 432,
            // g is not here
            h : [3,3,3],
            i : [1,2],
        }
    }
);
expect(newObject).toEqual({
    a : 123,
    // b is not here
    c : 33,
    d : {
        e : 321,
        // f is not here,
        g : [1,1,1],
        h : [3,3,3],
        i : [4,4,4]
    }
});

I used seamless-immutable myself in the test, but didn't see a need to put it in this answer.

I hereby place this in the Public Domain.

Answer 2

Another way to accomplish this is by combining _.mapObject with _.has

_.mapObject(object1, function(v, k) {
    return _.has(object2, k) ? object2[k] : v;
});

Explanation:

1. Traverse all key/value pairs of object1 using _.mapObject
2. Using _.has, check if property name k also exists in object2.
3. If it does, copy the value assigned to key object2's k back to object1, else, just return the existing value of object1 (v).

Plunkr

Answer 3

Following @svarog's answer I came up with this (lodash version 4.17.15):

const mergeExistingProps = (target, source) => _.mapValues(target, (value, prop) => _.get(source, prop, value));

Answer 4

I recently have the same need in my personal project, I need to fill the value from one object(SOURCE) to another object(TARGET) but don't expand its property. Also, some additional requirements should be met:

1. Any property with a null value in the source will not update to the target;
2. Any value from the source can be updated into target if such property in target has null value.
3. The property that holds an array in the target will be loaded based on data from the source, but all entries of the array will remain the same as the target array (so an empty array in the target will not get any data since the item has no property)
4. Property of the target holding a 2-d array (array has another array as its item) will not be updated, since the meaning of merging two 2-d arrays with a different shape is not clear to me.

Below is an example (Detailed explained in the code):

Assume you have a resume object holding all the data about you, you want to fill the data into the company's application form (also an object). You want the result to have the identical shape of the application form since the company doesn't care about other things, then you can think your resume is SOURCE and the application form is TARGET.

Note that the "additional" field in TARGET is null, which means anything can be updated here based on SOURCE data (As rule #2)

The console output is in JSON format, copy it to some JSON to JS-OBJ converter such as https://www.convertsimple.com/convert-json-to-javascript/ to have a better view

const applicationForm = {
  name: 'Your Name',
  gender: 'Your Gender',
  email: '[email protected]',
  birth: 0,
  experience: [       // employer want you list all your experience
    {
      company: 'Some Company',
      salary: 0,
      city: ['', '', ''],      // list all city worked for each company
    }
  ],
  language: {        // employer only care about 2 language skills
    english: {
      read: false,
      write: false,
      speak: 'Speak Level'
    },
    chinese: {
      read: false,
      write: false,
      speak: 'Speak Level'
    }
  },
  additional: null   // add anything you want the employer to know
}

const resume = {
  name: 'Yunfan',
  gender: 'Male',
  birth: 1995,
  phone: '1234567',
  email: '[email protected]',
  experience: [
    {
      company: 'Company A',
      salary: 100,
      city: ['New York', 'Chicago', 'Beijing'],
      id: '0001',
      department: 'R&D'
    },
    {
      company: 'Company B',
      salary: 200,
      city: ['New York'],
      id: '0002',
      department: 'HR'
    },
    {
      company: 'Company C',
      salary: 300,
      city: ['Tokyo'],
      id: '0003',
    }
  ],
  language: {
    english: {
      read: true,
      write: true,
      speak: 'Native Speaker'
    },
    chinese: {
      read: true,
      write: false,
      speak: 'HSK Level 3'
    },
    spanish: {
      read: true,
      write: true,
      speak: 'Native Speaker'
    }
  },
  additional: {
    music: 'Piano',
    hometown: 'China',
    interest: ['Cooking', 'Swimming']
  }
}


function safeMerge(source, target) {
  // traverse the keys in the source object, if key not found in target or with different type, drop it, otherwise:
  // 1. Use object merge if the value is an object (Can go deeper inside the object and apply same rule on all its properties)
  // 2. Use array merge if value is array (Extend the array item from source, but keep the obj format of target)
  // 3. Assign the value in other case (For other type, no need go deeper, assign directly)

  for (const key in source) {
    let value = source[key]
    const targetValueType = typeof target[key]
    const sourceValueType = typeof value

    // if key not found in target or type not match
    if (targetValueType === 'undefined' || targetValueType !== sourceValueType) {
      continue   // property not found in target or type not match
    }
    // for both type in object, need additional check
    else if (targetValueType === 'object' && sourceValueType === 'object') {
      // if value in target is null, assign any value from source to target, ignore format
      if (target[key] === null) {
        target[key] = source[key]
      }
      // if value in target is array, merge the item in source to target using the format of target only if source value is array
      else if (Array.isArray(target[key]) && Array.isArray(value)) {
        target[key] = mergeArray(value, target[key])
        
      }
      // if value in target is 'real' object (not null or array)', use object merge to do recurring merge, keep target format
      else if (!Array.isArray(target[key])){
        if (!Array.isArray(value) && value !== null) {
          safeMerge(value, target[key])
        }
      }
    }
    // if target value and source value has same type but not object, assign directly
    else if (targetValueType === sourceValueType) {
      target[key] = value
    }
  }
}

function mergeArray(sourceArray, targetArray) {
  // the rule of array merge need additional declare, assume the target already have values or objects in save format in the property<Array>, 
  // otherwise will not merge item from source to target since cannot add item property, 
  // NOTE: the item in target array will be totally overwrite instead of append on the tail, only the format will be keep, 
  // so the lenth of this property will same as source, below is a example:

  // target = [{a: 1, b: 2}, {a: 3, b: 4}] // Must in same format, otherwise the first one will be standard
  // source = [{a: 5, b: 6, c: 7}]
  // mergeArray(source, target) => [{a: 5, b: 6}]  // use format of target, but data from source

  // double check both of values are array
  if (!Array.isArray(sourceArray) || !Array.isArray(targetArray)) {
    return
  }
  // if target array is empty, don't push data in, since format is empty
  if (targetArray.length === 0) {
    return
  }

  let resultArray = []   // array to save the result
  let targetFormat = targetArray[0]
  let targetArrayType = typeof targetArray[0]
  

  // assign value from source to target, if item in target array is not object
  if (targetArrayType !== 'object'){
    sourceArray.forEach((value) => {
      // assign value directly if the type matched
      if (targetArrayType === typeof value) {
        resultArray.push(value)
      }
    })
  }
  // if the item in target is null, push anything in source to target (accept any format)
  else if (targetArray[0] === null) {
    sourceArray.forEach((value) => {
      resultArray.push(value)
    })
  }
  // if the item in target is array, drop it (the meaning of merge 2-d array to a 2-d array is not clear, so skip the situation)
  else if (!Array.isArray(targetArray[0])){
    // the item is a 'real' object, do object merge based on format of first item of target array
    sourceArray.forEach((value) => {
      safeMerge(value, targetFormat)   // data in targetFormat keep changing, so need to save a independent copy to the result
      resultArray.push(JSON.parse(JSON.stringify(targetFormat)))
    })
  }
  else {
    console.log('2-d array will be skipped')
  }

  // replace the value of target with newly built array (Assign result to target array will not work, must assign outside)
  return resultArray
}

safeMerge(resume, applicationForm)
console.log(JSON.stringify(applicationForm))