js elimina un cierto campo en el objeto

 // 以下方法不改变原来对象
      let item = {
        name:'张三',
        age:'18',
        gender:'男'
      };
      console.log(item) // {age: "18",gender: "男",name: "张三"}


     let { age,...params } = item;
      console.log(item) // {age: "18",gender: "男",name: "张三"}
      console.log(typeof params.age) // undefined
      console.log(params) // {gender: "男",name: "张三"}

      // 以下方法会直接改变对象
      let item1 = {
        name:'张三',
        age:'18',
        gender:'男'
      };
      console.log(item1) // {age: "18",gender: "男",name: "张三"}
      delete item1.name;
      console.log(typeof item1.name) // undefined
      console.log(item1) // // {age: "18",gender: "男"}

Contrariamente a la creencia común, los deleteoperadores están relacionados con la liberación directa de memoria 无关. La gestión de la memoria se realiza de forma indirecta rompiendo referencias, consulte 内存管理.

deleteEl operador elimina el atributo especificado de un objeto. Devuelve verdadero cuando se elimina correctamente; de ​​lo contrario, devuelve falso.

Sin embargo, se deben considerar las siguientes situaciones:

Si la propiedad que está intentando eliminar no existe, deleteno tendrá ningún efecto, pero seguirá regresando. true
Si hay una propiedad en la cadena de prototipos del objeto con el mismo nombre que la propiedad que se va a eliminar, después Al eliminar la propiedad, el objeto usará el de la propiedad de la cadena del prototipo (es decir, deletela operación solo funcionará en su propia propiedad).
Cualquier uso de la vardeclaración de propiedad no se puede eliminar del alcance o función del alcance global.
En este caso, la deleteoperación no puede eliminar ninguna función en el alcance global (independientemente de si la función proviene de una declaración de función o expresión de función).
Además de la función en el alcance global, la función no se puede eliminar. La función en el object ( object) se puede utilizar deleteOperación eliminada.
Cualquier atributo declarado con leto consno se puede eliminar del ámbito en el que se declara.
Los Non-configurableatributos no configurables ( ) no se pueden eliminar. Esto significa que, al igual que Math, Array, Objectpropiedades, y utilizan el objeto incorporado Object.defineProperty()métodos a la propiedad no se ha establecido no se puede eliminar.
El siguiente bloque de código ofrece un ejemplo sencillo:

var Employee = {
  age: 28,
  name: 'abc',
  designation: 'developer'
}

console.log(delete Employee.name);   // returns true
console.log(delete Employee.age);    // returns true

// 当试着删除一个不存在的属性时
// 同样会返回true
console.log(delete Employee.salary); // returns true

Atributos no configurables

Cuando un atributo se establece como no configurable, la deleteoperación no tendrá ningún efecto y volverá false. Se lanzará un error de sintaxis ( SyntaxError) en modo estricto .

var Employee = {};
Object.defineProperty(Employee, 'name', {configurable: false});

console.log(delete Employee.name);  // returns false

var, letY la constpropiedad no está configurada no se puede crear deleteoperando eliminar.

var nameOther = 'XYZ';

// 通过以下方法获取全局属性:
Object.getOwnPropertyDescriptor(window, 'nameOther');

// 输出: Object {value: "XYZ",
//                  writable: true,
//                  enumerable: true,
//                  configurable: false}

// 因为“nameOther”使用var关键词添加，
// 它被设置为不可设置（non-configurable）
delete nameOther;   // return false

En modo estricto, dicha operación generará una excepción.

Comparación de modo estricto y modo no estricto

En modo estricto, si usa la operación de eliminación en una referencia directa a una variable, un parámetro de función o un nombre de función, se lanzará un SyntaxError. Por lo tanto, para evitar errores de sintaxis en modo estricto, el operador de eliminación debe usarse en la forma de eliminar objeto.propiedad o eliminar objeto ['propiedad'].

Object.defineProperty(globalThis, 'variable1', { value: 10, configurable: true, });
Object.defineProperty(globalThis, 'variable2', { value: 10, configurable: false, });

console.log(delete variable1); // true

// SyntaxError in strict mode.
console.log(delete variable2); // false

function func(param) {
  // SyntaxError in strict mode.
  console.log(delete param); // false
}

// SyntaxError in strict mode.
console.log(delete func); // false

Cualquier variable declarada con var se marcará como no configurable. En el siguiente ejemplo, el salario no se puede configurar y no se puede eliminar. En modo no estricto, la operación de eliminación a continuación devolverá falso.

function Employee() {
  delete salary;
  var salary;
}

Employee();

Veamos cómo se comporta el mismo código en modo estricto. Lanzará un SyntaxError en lugar de devolver falso.

"use strict";

function Employee() {
  delete salary;  // SyntaxError
  var salary;
}

// 相似的，任何对任何函数
// 直接使用delete操作将会抛出语法错误。

function DemoFunction() {
  //some code
}

delete DemoFunction; // SyntaxError

Ejemplo

// 在全局作用域创建 adminName 属性
adminName = 'xyz';

// 在全局作用域创建 empCount 属性
// 因为我们使用了 var，它会标记为不可配置。同样 let 或 const 也是不可配置的。
var empCount = 43;

EmployeeDetails = {
  name: 'xyz',
  age: 5,
  designation: 'Developer'
};

// adminName 是全局作用域的一个属性。
// 因为它不是用 var 创建的，所在可以删除。
// 因此，它是可配置的。
delete adminName;       // 返回 true

// 相反，empCount 是不可配置的，
// 因为创建它时使用了 var。
delete empCount;       // 返回 false

// delete 可用于删除对象的属性
delete EmployeeDetails.name; // 返回 true

// 甚至属性不存在，它也会返回 "true"
delete EmployeeDetails.salary; // 返回 true

// delete 对内建静态属性不起作用
delete Math.PI; // 返回 false

// EmployeeDetails 是全局作用域的一个属性。
// 因为定义它的时候没有使用 "var"，它被标记为可配置。
delete EmployeeDetails;   // 返回 true

function f() {
  var z = 44;

  // delete 对局部变量名不起作用
  delete z;     // 返回 false
}

cadena de eliminación y prototipo

En el siguiente ejemplo, eliminamos las propiedades propias de un objeto y las propiedades con el mismo nombre en la cadena del prototipo están disponibles:

function Foo() {
  this.bar = 10;
}

Foo.prototype.bar = 42;

var foo = new Foo();

// 返回 true，因为删除的是 foo 对象的自身属性
delete foo.bar;

// foo.bar 仍然可用，因为它在原型链上可用。
console.log(foo.bar);   //42

// 从原型上删除属性
delete Foo.prototype.bar; //true

// 由于已删除“ bar”属性，因此不能再从Foo继承它。
console.log(foo.bar);    //undefined

Eliminar elementos de la matriz

Cuando elimina un elemento de la matriz, la longitud de la matriz no se ve afectada. Incluso si elimina el último elemento de la matriz.

Cuando se utiliza el operador de eliminación para eliminar un elemento de la matriz, el elemento eliminado ya no pertenece a la matriz. El siguiente ejemplo utiliza delete para eliminar árboles [3].

var trees = ["redwood","bay","cedar","oak","maple"];
delete trees[3];
if (3 in trees) {
   // 这里不会执行
}

Si desea que un elemento de matriz continúe existiendo pero su valor no está definido, puede asignar indefinido a este elemento en lugar de eliminarlo. En el siguiente ejemplo, a los árboles [3] se le asigna el valor indefinido, pero el elemento aún existe.

var trees = ["redwood","bay","cedar","oak","maple"];
trees[3] = undefined;
if (3 in trees) {
   // 这里会被执行
}

Si desea eliminar un elemento de la matriz cambiando el contenido de la matriz, use el método splice (). En el siguiente ejemplo, los árboles [3] se eliminan de la matriz utilizando splice ().

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);
console.log(trees); // ["redwood", "bay", "cedar", "maple"]