One place for hosting & domains

      JavaScript

      Использование объектных методов в JavaScript


      Введение

      Объекты в JavaScript представляют собой наборы пар ключ/значение. Значения могут состоять из свойств и методов и содержать все другие типы данных JavaScript, в том числе строки, числа и логические операторы.

      Все объекты JavaScript происходят из родительского конструктора Object. Объект имеет множество полезных встроенных методов, позволяющих получать доступ к отдельным объектам и работать с ними напрямую. В отличие от используемых для экземпляров массивов методов прототипа Array, таких как sort() и reverse(), методы объекта используются напрямую в конструкторе Object, и используют в качестве параметра экземпляр объекта. Такие методы называются статическими.

      В этом обучающем модуле мы изучим все важные методы встроенных объектов, при этом каждый из разделов ниже относится к конкретному методу и включает пример использования.

      Предварительные требования

      Для эффективного усвоения этого обучающего модуля вы должны быть знакомы с принципами создания и изменения объектов и работы с объектами. Подробнее об этих принципах можно узнать из статьи «Понимание объектов в JavaScript».

      Дополнительные указания по работе с JavaScript можно найти в серии статей «Программирование на JavaScript».

      Object.create()

      Метод Object.create() используется для создания новых объектов и их привязки к прототипу существующего объекта.

      Мы можем создать экземпляр объекта job и расширить его до конкретного объекта.

      // Initialize an object with properties and methods
      const job = {
          position: 'cashier',
          type: 'hourly',
          isAvailable: true,
          showDetails() {
              const accepting = this.isAvailable ? 'is accepting applications' : "is not currently accepting applications";
      
              console.log(`The ${this.position} position is ${this.type} and ${accepting}.`);
          }
      };
      
      // Use Object.create to pass properties
      const barista = Object.create(job);
      
      barista.position = "barista";
      barista.showDetails();
      

      Output

      The barista position is hourly and is accepting applications.

      Сейчас объект barista имеет только одно свойство position, но все остальные свойства и метода объекта job доступны через прототип. Метод Object.create() полезен для сокращения кода за счет минимального дублирования.

      Object.keys()

      Метод Object.keys() создает массив, содержащий ключи объекта.

      Мы можем создать объект и распечатать массив ключей.

      // Initialize an object
      const employees = {
          boss: 'Michael',
          secretary: 'Pam',
          sales: 'Jim',
          accountant: 'Oscar'
      };
      
      // Get the keys of the object
      const keys = Object.keys(employees);
      
      console.log(keys);
      

      Output

      ["boss", "secretary", "sales", "accountant"]

      Метод Object.keys можно использовать для итерации ключей и значений объекта.

      // Iterate through the keys
      Object.keys(employees).forEach(key => {
          let value = employees[key];
      
           console.log(`${key}: ${value}`);
      });
      

      Output

      boss: Michael secretary: Pam sales: Jim accountant: Oscar

      Также метод Object.keys полезен для проверки длины объекта.

      // Get the length of the keys
      const length = Object.keys(employees).length;
      
      console.log(length);
      

      Output

      4

      С помощью свойства length мы можем подсчитать 4 свойства сотрудников.

      Object.values()

      Метод Object.values() создает массив, содержащий значения объекта.

      // Initialize an object
      const session = {
          id: 1,
          time: `26-July-2018`,
          device: 'mobile',
          browser: 'Chrome'
      };
      
      // Get all values of the object
      const values = Object.values(session);
      
      console.log(values);
      

      Output

      [1, "26-July-2018", "mobile", "Chrome"]

      Object.keys() и Object.values() позволяют получить данные объекта.

      Object.entries()

      Метод Object.entries() создает вложенный массив пар ключ-значение для объекта.

      // Initialize an object
      const operatingSystem = {
          name: 'Ubuntu',
          version: 18.04,
          license: 'Open Source'
      };
      
      // Get the object key/value pairs
      const entries = Object.entries(operatingSystem);
      
      console.log(entries);
      

      Output

      [ ["name", "Ubuntu"] ["version", 18.04] ["license", "Open Source"] ]

      После создания массивов с парами ключ-значение мы можем использовать метод forEach() для обработки результатов и работы с ними.

      // Loop through the results
      entries.forEach(entry => {
          let key = entry[0];
          let value = entry[1];
      
          console.log(`${key}: ${value}`);
      });
      

      Output

      name: Ubuntu version: 18.04 license: Open Source

      Метод Object.entries() возвращает только собственные свойства экземпляра объекта, а не свойства, унаследованные от прототипа.

      Object.assign()

      Метод Object.assign() используется для копирования значений одного объекта в другой объект.

      С помощью метода Object.assign() мы можем создать два объекта и объединить их.

      // Initialize an object
      const name = {
          firstName: 'Philip',
          lastName: 'Fry'
      };
      
      // Initialize another object
      const details = {
          job: 'Delivery Boy',
          employer: 'Planet Express'
      };
      
      // Merge the objects
      const character = Object.assign(name, details);
      
      console.log(character);
      

      Output

      {firstName: "Philip", lastName: "Fry", job: "Delivery Boy", employer: "Planet Express"}

      Также для этой задачи можно использовать оператор spread (...). В приведенном ниже примере кода мы изменим способ декларации объекта character, объединив объекты name и details.

      // Initialize an object
      const name = {
          firstName: 'Philip',
          lastName: 'Fry'
      };
      
      // Initialize another object
      const details = {
          job: 'Delivery Boy',
          employer: 'Planet Express'
      };
      
      // Merge the object with the spread operator
      const character = {...name, ...details}
      
      console.log(character);
      

      Output

      {firstName: "Philip", lastName: "Fry", job: "Delivery Boy", employer: "Planet Express"}

      Такой синтаксис оператора spread в буквальных константах объекта также называется неглубоким клонированием.

      Object.freeze()

      Метод Object.freeze() предотвращает изменение свойств и значений объекта, а также добавление или удаление свойств объекта.

      // Initialize an object
      const user = {
          username: 'AzureDiamond',
          password: 'hunter2'
      };
      
      // Freeze the object
      const newUser = Object.freeze(user);
      
      newUser.password = '*******';
      newUser.active = true;
      
      console.log(newUser);
      

      Output

      {username: "AzureDiamond", password: "hunter2"}

      В приведенном выше примере мы попытались заменить пароль hunter2 на *******, однако свойство password не изменилось. Также мы попытались добавить новое свойство active, но оно не было добавлено.

      Свойство Object.isFrozen() позволяет определить, заморожен ли объект, и возвращает логическое значение.

      Object.seal()

      Метод Object.seal() предотвращает добавление новых свойств к объекту, но допускает изменение существующих свойств. Этот метод похож на метод Object.freeze(). Чтобы избежать ошибок, обновите консоль перед добавлением приведенного ниже кода.

      // Initialize an object
      const user = {
          username: 'AzureDiamond',
          password: 'hunter2'
      };
      
      // Seal the object
      const newUser = Object.seal(user);
      
      newUser.password = '*******';
      newUser.active = true;
      
      console.log(newUser);
      

      Output

      {username: "AzureDiamond", password: "*******"}

      Новое свойство active не было добавлено к запечатанному объекту, но свойство password было успешно изменено.

      Object.getPrototypeOf()

      Метод Object.getPrototypeOf() используется для получения внутреннего скрытого свойства [[Prototype]] объекта, которое также доступно через свойство __proto__.

      В этом примере мы создадим массив, имеющий доступ к прототипу Array.

      const employees = ['Ron', 'April', 'Andy', 'Leslie'];
      
      Object.getPrototypeOf(employees);
      

      Output

      [constructor: ƒ, concat: ƒ, find: ƒ, findIndex: ƒ, pop: ƒ, …]

      В результатах мы видим, что прототип массива employees имеет доступ к методам pop, find и другим методам прототипа Array. Для проверки мы протестируем прототип employees с прототипом Array.prototype.

      Object.getPrototypeOf(employees) === Array.prototype;
      

      Output

      true

      Этот метод может быть полезен для получения дополнительной информации об объекте или обеспечения доступа к прототипу другого объекта.

      Связанный метод Object.setPrototypeOf() добавляет прототип к другому объекту. Вместо него рекомендуется использовать более быстрый и производительный метод Object.create().

      Заключение

      Объекты имеют много полезных методов, которые можно использовать для их изменения, защиты и итерации. В этом обучающем модуле мы научились создавать и назначать новые объекты, итеративно просматривать ключи и/или значения объекта, а также замораживать и запечатывать объекты.

      Если вам нужно узнать больше об объектах JavaScript, прочитайте статью «Понимание концепции объектов в JavaScript». Если вы хотите узнать больше о цепочке прототипов, прочитайте статью «Понимание концепций прототипов и наследования в JavaScript».



      Source link

      Понимание понятия классов в JavaScript


      Введение

      JavaScript — это язык на базе прототипов, и каждый объект JavaScript имеет скрытое внутреннее свойство [[Prototype]], которое можно использовать для расширения свойств и методов объекта. Вы можете узнать больше о прототипах из нашего обучающего модуля Понимание принципов прототипов и наследования в JavaScript.

      До недавнего времени промышленные разработчики использовали функции конструктора для имитации объектно-ориентированного шаблона в JavaScript. Языковая спецификация ECMAScript 2015 (часто называемая ES6) ввела в язык JavaScript понятие классов. Классы в JavaScript не добавляют дополнительные функции, и представляют собой способ упростить синтаксис при использовании прототипов и наследования и сделать его более элегантным. Поскольку в других языках программирования также используются классы, синтаксис классов в JavaScript упрощает работу для разработчиков, владеющих другими языками.

      Классы — это функции

      Класс JavaScript — это вид функции. Для декларирования классов используется ключевое слово class. Мы используем синтаксис выражения функции для инициализации функции и синтаксис выражения класса для инициализации класса.

      // Initializing a function with a function expression
      const x = function() {}
      
      // Initializing a class with a class expression
      const y = class {}
      

      Мы можем получить доступ к [[Prototype]] объекта с помощью метода Object.getPrototypeOf(). Давайте протестируем созданную нами пустую функцию.

      Object.getPrototypeOf(x);
      

      Output

      ƒ () { [native code] }

      Также мы можем использовать этот метод для только что созданного нами класса.

      Object.getPrototypeOf(y);
      

      Output

      ƒ () { [native code] }

      Программный код, декларированный с помощью function и class, возвращает функцию [[Prototype]]. При использовании прототипов любую функцию можно превратить в экземпляр конструктора с помощью ключевого слова new.

      const x = function() {}
      
      // Initialize a constructor from a function
      const constructorFromFunction = new x();
      
      console.log(constructorFromFunction);
      

      Output

      x {} constructor: ƒ ()

      Это также относится и к классам.

      const y = class {}
      
      // Initialize a constructor from a class
      const constructorFromClass = new y();
      
      console.log(constructorFromClass);
      

      Output

      y {} constructor: class

      Эти примеры конструктора прототипов пустые, но вы видите, как оба метода позволяют добиться одинакового результата вне зависимости от синтаксиса.

      Определение класса

      В обучающем модуле Прототипы и наследование мы создали пример, основанный на создании персонажа в текстовой ролевой игре. На этом же примере мы рассмотрим, как обновлять синтаксис от функций к классам.

      Функция конструктора инициализируется с рядом параметров, которые назначаются как свойства this, относящиеся к самой функции. Согласно правилам, первая буква идентификатора будет преобразована в заглавную.

      constructor.js

      // Initializing a constructor function
      function Hero(name, level) {
          this.name = name;
          this.level = level;
      }
      

      При трансляции в синтаксис класса, как показано ниже, структура будет очень похожей.

      class.js

      // Initializing a class definition
      class Hero {
          constructor(name, level) {
              this.name = name;
              this.level = level;
          }
      }
      

      Мы знаем, что функция конструктора является планом объекта благодаря тому, что первая буква инициализатора (необязательно) заглавная, и потому что мы знакомы с синтаксисом. Ключевое слово class показывает назначение нашей функции более прямо.

      Единственная разница в синтаксисе инициализации заключается в использовании ключевого слова class вместо function, и в том, что свойства назначаются внутри метода constructor().

      Определение методов

      При использовании функций конструктора методы обычно назначаются непосредственно в prototype вместо инициализации, как показано ниже на примере метода greet().

      constructor.js

      function Hero(name, level) {
          this.name = name;
          this.level = level;
      }
      
      // Adding a method to the constructor
      Hero.prototype.greet = function() {
          return `${this.name} says hello.`;
      }
      

      При использовании классов этот синтаксис упрощается, и метод можно добавить напрямую в класс. Благодаря концепции заблаговременного определения методов, введенной в ES6, определение методов стало еще более быстрой процедурой.

      class.js

      class Hero {
          constructor(name, level) {
              this.name = name;
              this.level = level;
          }
      
          // Adding a method to the constructor
          greet() {
              return `${this.name} says hello.`;
          }
      }
      

      Давайте посмотрим на эти свойства и методы в действии. Мы создадим новый экземпляр Hero, используя ключевое слово new, и присвоим некоторые значения.

      const hero1 = new Hero('Varg', 1);
      

      Если мы распечатаем дополнительную информацию о нашем новом объекте с помощью команды console.log(hero1), мы более подробно увидим. что происходит при инициализации класса.

      Output

      Hero {name: "Varg", level: 1} __proto__: ▶ constructor: class Hero ▶ greet: ƒ greet()

      В результатах мы видим, что функции constructor() и greet() functions были применены к прототипу __proto__ или [[Prototype]] объекта hero1, а непосредственно к объекту hero1 как к методу. Хотя при создании функций конструктора это очевидно, при создании классов дело обстоит по другому. Классы позволяют использовать более простой и сжатый синтаксис, но при этом немного теряется понятность процесса.

      Расширение класса

      Функции конструктора и классы можно расширять на новые планы объекта на основе родительского экземпляра. Это позволяет не повторять код для похожих объектов, для которых нужно просто добавить дополнительные или более детальные характеристики.

      Новые функции конструктора можно создавать на основе родительского экземпляра с помощью метода call(). В примере ниже мы создадим более конкретный класс персонажа Mage и присвоим ему свойства Hero с помощью метода call(), а также добавим дополнительное свойство.

      constructor.js

      // Creating a new constructor from the parent
      function Mage(name, level, spell) {
          // Chain constructor with call
          Hero.call(this, name, level);
      
          this.spell = spell;
      }
      

      Сейчас мы можем создать новый экземпляр Mage, используя те же свойства, что и Hero ,а также добавленное свойство.

      const hero2 = new Mage('Lejon', 2, 'Magic Missile');
      

      Отправив на консоль команду hero2, мы увидим, что создали новый экземпляр Mage на базе конструктора.

      Output

      Mage {name: "Lejon", level: 2, spell: "Magic Missile"} __proto__: ▶ constructor: ƒ Mage(name, level, spell)

      Для классов ES6 ключевое слово super используется вместо call для доступа к родительским функциям. Мы будем использовать extends для обозначения родительского класса.

      class.js

      // Creating a new class from the parent
      class Mage extends Hero {
          constructor(name, level, spell) {
              // Chain constructor with super
              super(name, level);
      
              // Add a new property
              this.spell = spell;
          }
      }
      

      Теперь мы можем точно так же создать новый экземпляр Mage.

      const hero2 = new Mage('Lejon', 2, 'Magic Missile');
      

      Распечатаем hero2 на консоли и посмотрим результат.

      Output

      Mage {name: "Lejon", level: 2, spell: "Magic Missile"} __proto__: Hero ▶ constructor: class Mage

      Результат практически такой же, но в конструкции класса прототип [[Prototype]] связан с родительским объектом, в данном случае Hero.

      Ниже приводится полное сравнение процесса инициализации, добавления методов и наследования между функцией конструктора и классом.

      constructor.js

      function Hero(name, level) {
          this.name = name;
          this.level = level;
      }
      
      // Adding a method to the constructor
      Hero.prototype.greet = function() {
          return `${this.name} says hello.`;
      }
      
      // Creating a new constructor from the parent
      function Mage(name, level, spell) {
          // Chain constructor with call
          Hero.call(this, name, level);
      
          this.spell = spell;
      }
      

      class.js

      // Initializing a class
      class Hero {
          constructor(name, level) {
              this.name = name;
              this.level = level;
          }
      
          // Adding a method to the constructor
          greet() {
              return `${this.name} says hello.`;
          }
      }
      
      // Creating a new class from the parent
      class Mage extends Hero {
          constructor(name, level, spell) {
              // Chain constructor with super
              super(name, level);
      
              // Add a new property
              this.spell = spell;
          }
      }
      

      Хотя синтаксис различается, конечный результат для обоих методов практически одинаковый. Классы дают более краткий способ создания шаблонов объектов, а функции конструктора более точно описывают конкретную механику.

      Заключение

      В этом обучающем модуле мы узнали о сходствах и различиях между функциями конструктора JavaScript и классами ES6. Классы и конструкторы имитируют объектно-ориентированную модель наследования в JavaScript, который представляет собой язык наследования на основе прототипов.

      Понимание принципов наследования прототипов очень важно, если вы хотите стать эффективным разработчиком на JavaScript. Знакомство с классами очень полезно, потому что популярные библиотеки JavaScript, такие как React, часто используют синтаксис class.



      Source link

      Como usar métodos Object no JavaScript


      Introdução

      Os Objetos no JavaScript são coleções de pares chave/valor. Os valores podem consistir em propriedades e métodos e podem conter todos os outros tipos de dados do JavaScript, como strings, números e Booleans.

      Todos os objetos no JavaScript descendem do construtor pai ](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)Object[. Object tem muitos métodos embutidos úteis que podemos usar e acessar para tornar o trabalho com objetos individuais em algo simplificado. Diferentemente de métodos protótipos Array como o sort() e o reverse(), que são usados na instância do array, os métodos Object são usados diretamente no construtor Object e utilizam a instância de objeto como um parâmetro. Isso é conhecido como um método estático.

      Este tutorial irá analisar importantes métodos de objetos embutidos, com cada seção abaixo tratando de um método específico e fornecendo um exemplo de uso.

      Pré-requisitos

      Para aproveitar esse tutorial ao máximo, você deve estar familiarizado em criar, modificar e trabalhar com objetos, que pode ser revisto no artigo “Entendendo objetos no JavaScript”.

      Para mais orientação com o JavaScript no geral, você pode rever nossa série Como programar em JavaScript.

      Object.create()

      O método Object.create() é usado para criar um novo objeto e conectá-lo ao protótipo de um objeto existente.

      Podemos criar uma instância de objeto job e estendê-la para um objeto mais específico.

      // Initialize an object with properties and methods
      const job = {
          position: 'cashier',
          type: 'hourly',
          isAvailable: true,
          showDetails() {
              const accepting = this.isAvailable ? 'is accepting applications' : "is not currently accepting applications";
      
              console.log(`The ${this.position} position is ${this.type} and ${accepting}.`);
          }
      };
      
      // Use Object.create to pass properties
      const barista = Object.create(job);
      
      barista.position = "barista";
      barista.showDetails();
      

      Output

      The barista position is hourly and is accepting applications.

      Agora, o objeto barista tem uma propriedade — position — mas todas as outras propriedades e métodos do job estão disponíveis pelo protótipo.Object.create()é útil para manter o código DRY minimizando a duplicação.

      Object.keys()

      O Object.keys() cria um array que contém as chaves de um objeto.

      Podemos criar um objeto e imprimir o array de chaves.

      // Initialize an object
      const employees = {
          boss: 'Michael',
          secretary: 'Pam',
          sales: 'Jim',
          accountant: 'Oscar'
      };
      
      // Get the keys of the object
      const keys = Object.keys(employees);
      
      console.log(keys);
      

      Output

      ["boss", "secretary", "sales", "accountant"]

      O Object.keys pode ser usado para iterar através das chaves e valores de um objeto.

      // Iterate through the keys
      Object.keys(employees).forEach(key => {
          let value = employees[key];
      
           console.log(`${key}: ${value}`);
      });
      

      Output

      boss: Michael secretary: Pam sales: Jim accountant: Oscar

      O Object.keys também é útil para verificar o comprimento de um objeto.

      // Get the length of the keys
      const length = Object.keys(employees).length;
      
      console.log(length);
      

      Output

      4

      Ao usar a propriedade length, conseguimos contar as 4 propriedades de employees.

      Object.values()

      O Object.values() cria uma array que contém os valores de um objeto.

      // Initialize an object
      const session = {
          id: 1,
          time: `26-July-2018`,
          device: 'mobile',
          browser: 'Chrome'
      };
      
      // Get all values of the object
      const values = Object.values(session);
      
      console.log(values);
      

      Output

      [1, "26-July-2018", "mobile", "Chrome"]

      O Object.keys() e o Object.values() permitem que você retorne dados de um objeto.

      Object.entries()

      O Object.entries() cria um array aninhado dos pares chave/valor de um objeto.

      // Initialize an object
      const operatingSystem = {
          name: 'Ubuntu',
          version: 18.04,
          license: 'Open Source'
      };
      
      // Get the object key/value pairs
      const entries = Object.entries(operatingSystem);
      
      console.log(entries);
      

      Output

      [ ["name", "Ubuntu"] ["version", 18.04] ["license", "Open Source"] ]

      Assim que tivermos os arrays de pares chave/valor, podemos usar o método forEach() para percorrer e trabalhar com os resultados.

      // Loop through the results
      entries.forEach(entry => {
          let key = entry[0];
          let value = entry[1];
      
          console.log(`${key}: ${value}`);
      });
      

      Output

      name: Ubuntu version: 18.04 license: Open Source

      O método Object.entries() irá retornar apenas as propriedades próprias da instância do objeto e não quaisquer propriedades que possam ser herdadas por meio do seu protótipo.

      Object.assign()

      O Object.assign() é usado para copiar valores de um objeto para outro.

      Podemos criar dois objetos e fundi-los com o Object.assign().

      // Initialize an object
      const name = {
          firstName: 'Philip',
          lastName: 'Fry'
      };
      
      // Initialize another object
      const details = {
          job: 'Delivery Boy',
          employer: 'Planet Express'
      };
      
      // Merge the objects
      const character = Object.assign(name, details);
      
      console.log(character);
      

      Output

      {firstName: "Philip", lastName: "Fry", job: "Delivery Boy", employer: "Planet Express"}

      Também é possível usar o operador de propagação (...) para realizar a mesma tarefa. No código abaixo, vamos modificar como declaramos o character através da fusão dos objetos name e details.

      // Initialize an object
      const name = {
          firstName: 'Philip',
          lastName: 'Fry'
      };
      
      // Initialize another object
      const details = {
          job: 'Delivery Boy',
          employer: 'Planet Express'
      };
      
      // Merge the object with the spread operator
      const character = {...name, ...details}
      
      console.log(character);
      

      Output

      {firstName: "Philip", lastName: "Fry", job: "Delivery Boy", employer: "Planet Express"}

      Essa sintaxe de propagação em literais de objeto também é conhecida como clonagem superficial (shallow-cloning).

      Object.freeze()

      O Object.freeze() impede a modificação de propriedades e valores de um objeto e impede que as propriedades sejam adicionadas ou removidas de um objeto.

      // Initialize an object
      const user = {
          username: 'AzureDiamond',
          password: 'hunter2'
      };
      
      // Freeze the object
      const newUser = Object.freeze(user);
      
      newUser.password = '*******';
      newUser.active = true;
      
      console.log(newUser);
      

      Output

      {username: "AzureDiamond", password: "hunter2"}

      No exemplo acima, tentamos substituir a senha hunter2 por *******, mas a propriedade password permaneceu a mesma. Também tentamos adicionar uma nova propriedade, active, mas ela não foi adicionada.

      O Object.isFrozen() está disponível para determinar se um objeto foi congelado ou não e retorna um Boolean.

      Object.seal()

      O Object.seal() impede que novas propriedades sejam adicionadas a um objeto, mas permite a modificação de propriedades existentes. Este método é semelhante ao Object.freeze(). Recarregue seu console antes de implementar o código abaixo para evitar um erro.

      // Initialize an object
      const user = {
          username: 'AzureDiamond',
          password: 'hunter2'
      };
      
      // Seal the object
      const newUser = Object.seal(user);
      
      newUser.password = '*******';
      newUser.active = true;
      
      console.log(newUser);
      

      Output

      {username: "AzureDiamond", password: "*******"}

      A nova propriedade active não foi adicionada ao objeto selado, mas a propriedade password foi alterada com sucesso.

      Object.getPrototypeOf()

      O Object.getPrototypeOf() é usado para obter o [[Prototype]] interno oculto de um objeto, também acessível através da propriedade __proto__.

      Neste exemplo, podemos criar um array, que tenha acesso ao protótipo Array.

      const employees = ['Ron', 'April', 'Andy', 'Leslie'];
      
      Object.getPrototypeOf(employees);
      

      Output

      [constructor: ƒ, concat: ƒ, find: ƒ, findIndex: ƒ, pop: ƒ, …]

      Podemos ver no resultado que o protótipo do array employees tem acesso aos métodos de protótipo Array pop, find, entre outros. Podemos confirmar isso testando o protótipo employees contra o Array.prototype.

      Object.getPrototypeOf(employees) === Array.prototype;
      

      Output

      true

      Este método pode ser útil para obter mais informações sobre um objeto ou garantir que ele tenha acesso ao protótipo de outro objeto.

      Também há um método Object.setPrototypeOf() relacionado que adicionará um protótipo a outro objeto. Ao invés disso, é recomendável que você utilize o Object.create() uma vez que ele é mais rápido e tem maior desempenho.

      Conclusão

      Os objetos têm muitos métodos úteis que nos ajudam a modificar, proteger e iterar através deles. Neste tutorial, vimos novamente como criar e atribuir novos objetos, iterar através das chaves e/ou valores de um objeto, e congelar ou selar um objeto.

      Se você precisar revisar os objetos do JavaScript, leia “Entendendo objetos no JavaScript”. Se quiser se familiarizar com a cadeia de protótipos, você pode olhar “Entendendo protótipos e herança no JavaScript”.



      Source link