With the introduction of Object Spread and Rest in TS 2.1, a new way is now available:

let myExample: Example = {name: "apple", type: "fruit"}

let { name, ...modified } = myExample;

As a result, the modified object will contain all properties except for "name".

Another method to consider:

It has been noted in previous responses that it is impossible to completely avoid runtime actions; TypeScript transpires into JavaScript, primarily by discarding interface/type definitions, annotations, and assertions. The type system becomes erased, leaving your MyInterface absent from the runtime code where it is needed.

Thus, a solution involves creating an array of keys that should be retained in the reduced object:

const myTestKeys = ["test"] as const;

This approach is delicate since any modifications to MyInterface may go unnoticed by your code. To mitigate this issue, you can establish type alias definitions that trigger a compiler error if myTestKeys does not align with keyof MyInterface:

// An error will be thrown if myTestKeys contains entries not present in keyof MyInterface:
type ExtraTestKeysWarning<T extends never =
  Exclude<typeof myTestKeys[number], keyof MyInterface>> = void;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type 'UNION_OF_EXTRA_KEY_NAMES_HERE' does not satisfy the constraint 'never'

// An error will be thrown if myTestKeys lacks entries from keyof MyInterface:
type MissingTestKeysWarning<T extends never =
  Exclude<keyof MyInterface, typeof myTestKeys[number]>> = void;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Type 'UNION_OF_MISSING_KEY_NAMES_HERE' does not satisfy the constraint 'never'

While this approach may lack elegance, modifying MyInterface triggers an error in one or both of the above lines, prompting developers to adjust myTestKeys.

Though methods exist to broaden the scope or reduce intrusiveness, TypeScript's primary function is to alert you via compiler warnings when changes occur unexpectedly within an interface; actual runtime behavior adjustments are rare.

With the desired keys defined, you can create a pick() function to extract specific properties from an object:

function pick<T, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K> {
  return keys.reduce((o, k) => (o[k] = obj[k], o), {} as Pick<T, K>);
}

Applying this function to your test object generates reduced:

var test: MyTest = { test: "hello", newTest: "world" }

const reduced: MyInterface = pick(test, ...myTestKeys);

console.log(JSON.stringify(reduced)); // {"test": "hello;"}

Success!

Link to Play around with the code

Are you looking to only assign properties from an interface? TypeScript does not have built-in functionality for this, but it is easy to create a function that can achieve this.

interface IPerson {
    name: string;
}

class Person implements IPerson {
name: string = '';
}
class Staff implements IPerson {
name: string = '';
    position: string = '';
}

var jimStaff: Staff = {
    name: 'Jim',
    position: 'Programmer'
};

var jim: Person = new Person();
limitedAssign(jimStaff, jim);
console.log(jim);

function limitedAssign<T,S>(source: T, destination: S): void {
    for (var prop in destination) {
        if (source[prop] && destination.hasOwnProperty(prop)) {
            destination[prop] = source[prop];
        }
    }
}

The newTest property mentioned in your example will not be accessible through the reduced variable, highlighting the importance of using types. TypeScript provides type checking functionality rather than directly manipulating object properties.

Upon encountering an issue with the accepted answer provided by @wal, I discovered that it only caters to flat object use cases and may not be suitable for nested fields. To address this, I utilized a helpful package named Joi (https://www.npmjs.com/package/joi). Apart from effortlessly removing unexpected fields, Joi offers robust validation capabilities. This ensures not only sanitized data but also validation against expected criteria, triggering errors if any required field is absent or of an invalid type. Moreover, you can define intricate schemas according to your needs.

Here's a quick example:

import Joi from 'joi';
const schema = Joi.object({
    name: Joi.string().required(),
    items: Joi.array()
      .items(Joi.object({ id: Joi.string().required() }))
      .required(),
  });

  const result = Joi.attempt(
    {
      name: 'test',
      weirdField: 'bla bla bla',
      items: [{ id: '1', weirdField: 234 }],
    },
    schema,
    { stripUnknown: true },
  );

  console.log(result);

{ name: 'test', items: [ { id: '1' } ] }

How can you ensure that the 'reduced' variable only includes properties declared in the 'MyInterface' interface?

Since TypeScript follows a structural typing system, any object with matching properties is considered type compatible and can be assigned to another.

In the upcoming release of TypeScript 1.6, there will be a feature called freshness which will help identify potential typos more easily (only applicable to object literals):

// ERROR : `newText` does not exist on `MyInterface`
var reduced: MyInterface = {test: "hello", newTest: "world"}; 

Simple illustration:

const all_cars = { sedan: 'Toyota', SUV: 'Jeep', truck: 'Ford' };
const { sedan, ...other_cars } = all_cars;
console.log(sedan); // Toyota

To address this issue, consider utilizing a class instead of an interface and implementing a factory method. By creating a public static member function that returns a new object of its type, you can ensure that the model is the sole entity where permitted properties are defined. This prevents accidental updates to properties when changes occur within the model.

class MyClass {
  test: string;

  public static from(myClass: MyClass): MyClass {
    return {test: myClass.test};
  }
}

For instance:

class MyTest extends MyClass {
  test: string;
  newTest: string;
}

const myTest: MyTest = {test: 'foo', newTest: 'bar'};
const myClass: MyClass = MyClass.from(myTest);