Как использовать Proxy в JavaScript?
год назад·6 мин. на чтение
Раскрываем возможности прокси (Proxy) JavaScript, погружаемся в кастомизацию операций с объектами
Введение
В мире JavaScript разработчики постоянно ищут способы повысить мощность и гибкость своего кода. Прокси в JavaScript, представленный в ECMAScript 6 (ES6), стал замечательной фичей, позволяющей разработчикам перехватывать и настраивать основные операции над объектами. Выступая в качестве посредника, прокси открывают множество возможностей, позволяя разработчикам с легкостью изменять поведение объектов, проверять входные данные и защищать их. В этой статье мы углубимся во внутреннюю работу JavaScript Proxy. Мы рассмотрим его фундаментальное использование, концепцию ловушек, определяющих поведение прокси, и различные типы доступных ловушек. Кроме того, мы узнаем, как прокси можно использовать для валидации значений, проверки безопасности и защиты данных, а также для устранения ограничений, совместимости браузеров и соображений производительности. Итак, давайте отправимся в это путешествие открытий и разгадаем секреты JavaScript Proxy!Базовое использование прокси JavaScript
При работе с JavaScript Proxy первым шагом является создание прокси-объекта с использованием нового синтаксисаnew Proxy()
Этот синтаксис позволяет определить целевой объект и объект обработчика, содержащий ловушки. Эти ловушки представляют собой специальные методы, которые перехватывают операции на прокси и позволяют нам настраивать их поведение.
Например, get
перехватывает доступ к свойству прокси-объекта. Определив эту ловушку, мы можем настроить реакцию прокси при доступе к свойству. Точно так же set
перехватывает присвоение свойства, позволяя нам проверить или изменить присвоенное значение.
Таким образом, ловушки в контексте прокси JavaScript — это специальные методы, которые действуют как посредники, перехватывая и позволяя настраивать операции объекта, такие как доступ к свойствам и назначение прокси-объекта. Они предоставляют разработчикам детальный контроль над поведением прокси, позволяя настраивать и манипулировать по мере необходимости.
В приведенном выше примере мы создаем прокси-объект, который является оболочкойconst target = { name: 'John', age: 20 }; const handler = { get(target, property) { console.log(`Getting property: ${property}`); return target[property]; }, set(target, property, value) { console.log(`Setting property: ${property} = ${value}`); target[property] = value; } }; const proxy = new Proxy(target, handler); console.log(proxy.name); // Output: Getting property: name, John proxy.age = 30; // Output: Setting property: age = 20 console.log(proxy.age); // Output: Getting property: age, 30
target
объекта. get
логирует доступное свойство и возвращает соответствующее значение из target
объекта. Аналогичным образом, set
логирует заданное свойство и присваивает значение target
объекту.
Используя эти ловушки, мы можем беспрепятственно перехватывать и изменять операции с объектами в соответствии с нашими требованиями.
Общие сведения о прокси-ловушках
Прокси JavaScript предоставляет несколько ловушек, каждая из которых соответствует отдельной операции с прокси-объектом. Некоторые из часто используемых ловушек включаютget
, set
, has
, apply
, construct
и другие. Эти ловушки позволяют нам перехватывать и настраивать такие операции, как доступ к свойствам, назначение, вызов функций, создание экземпляров объектов и многое другое.
Давайте рассмотрим некоторые из этих ловушек на примерах:
get
В этом примереconst target = { name: 'John', age: 20 }; const handler = { get(target, property) { console.log(`Getting property: ${property}`); return target[property]; } }; const proxy = new Proxy(target, handler); console.log(proxy.name); // Output: Getting property: name, John console.log(proxy.age); // Output: Getting property: age, 20
get
перехватывает доступ к свойству на прокси и логирует доступ к свойству перед возвратом его значения.
set
Здесьconst target = { name: 'John', age: 20 }; const handler = { set(target, property, value) { console.log(`Setting property: ${property} = ${value}`); target[property] = value; } }; const proxy = new Proxy(target, handler); proxy.name = 'Jerry'; // Output: Setting property: name = Jerry console.log(proxy.name); // Output: Jerry
set
перехватывает назначение свойства на прокси и логирует назначенное свойство и значение, прежде чем изменять их в целевом объекте.
Используя эти и другие ловушки, мы можем эффективно настраивать и контролировать поведение прокси-объектов в соответствии с нашими конкретными потребностями.
Перехват операций с объектами с помощью прокси
JavaScript Proxy позволяет нам перехватывать и настраивать различные операции с объектами. Давайте рассмотрим несколько примеров:Удаление свойства
В этом примере ловушкаconst target = { name: 'John', age: 20 }; const handler = { deleteProperty(target, property) { console.log(`Deleting property: ${property}`); delete target[property]; } }; const proxy = new Proxy(target, handler); delete proxy.age; // Output: Deleting property: age console.log(proxy); // Output: { name: 'John' }
deleteProperty
перехватывает удаление свойства прокси-объекта. Мы можем настроить поведение, чтобы логировать удаленное свойство, а затем удалить его из целевого объекта.
Перехват вызова функции
В этом случае ловушкаconst target = { sum: (a, b) => a + b }; const handler = { apply(target, thisArg, argumentsList) { console.log(`Calling function: ${target.name}`); return target.apply(thisArg, argumentsList); } }; const proxy = new Proxy(target.sum, handler); console.log(proxy(2, 3)); // Output: Calling function: sum, 5
apply
перехватывает вызов функции в прокси-объекте. Мы можем настроить поведение для логирования имени функции, прежде чем вызывать ее с предоставленными аргументами.
Перехват проверки наличия свойства
Ловушкаhas
срабатывает, когда оператор in
используется для проверки наличия свойства в прокси-объекте. Определив эту ловушку, можно настроить реакцию прокси-объекта на проверки существования свойства. Это полезно, если требуется динамически управлять наличием свойств или реализовать механизмы управления доступом.
В приведенном примере кода мы создаем объектconst target = { name: 'John', age: 20 }; const handler = { has(target, property) { console.log(`Checking property existence for "${property}"`); return property in target; } }; const proxy = new Proxy(target, handler); console.log('name' in proxy); // Output: Checking property existence for "name", true console.log('email' in proxy); // Output: Checking property existence for "email", false
handler
с ловушкой has
. Внутри ловушки has
мы логируем сообщение, указывающее, что выполняется проверка существования свойства. Затем мы используем оператор in
, чтобы проверить, существует ли свойство в прокси-объекте. Ловушка перехватывает эту операцию и возвращает true
или false
в зависимости от того, существует ли свойство в базовом целевом объекте.
Перехват создания объекта
Ловушкаconstruct
в JavaScript Proxy перехватывает создание объекта, когда прокси-объект используется в качестве функции-конструктора с new
. Он позволяет настраивать процесс создания экземпляров, проверять аргументы конструктора и применять определенные шаблоны создания объектов.
В примере кода мы определяем объектclass Person { constructor(name) { this.name = name; } } const handler = { construct(target, argumentsList) { console.log(`Creating new instance of "${target.name}" with arguments: ${argumentsList}`); return new target(...argumentsList); } }; const ProxyPerson = new Proxy(Person, handler); const john = new ProxyPerson('John'); // Output: Creating new instance of "Person" with arguments: John
handler
с помощью construct
. Когда прокси-объект вызывается с new
, construct
перехватывает создание объекта. Мы логируем сообщение, указывающее на создание нового экземпляра с конкретными аргументами. Ловушку construct
можно использовать для реализации пользовательской логики инициализации, проверки входных данных или обеспечения требуемого поведения во время создания объекта.
Прокси для валидации и безопасности
Одним из мощных вариантов использования JavaScript Proxy является проверка данных и безопасность. Прокси могут использоваться для обеспечения соблюдения определенных правил и ограничений на доступ к данным и их изменение. Например, мы можем гарантировать, что доступ к определенным свойствам возможен только при определенных условиях, или ограничить несанкционированные изменения. Рассмотрим следующий пример:В этом примереconst target = { password: 'secretpassword' }; const handler = { get(target, property) { if (property === 'password') { console.log('Access denied!'); return undefined; } return target[property]; }, set(target, property, value) { if (property === 'password') { console.log('Unauthorized modification!'); return false; } target[property] = value; return true; } }; const proxy = new Proxy(target, handler); console.log(proxy.username); // Output: undefined console.log(proxy.password); // Output: Access denied! proxy.password = 'newpassword'; // Output: Unauthorized modification!
get
ограничивает доступ к свойству password
, запрещая его извлечение. Аналогичным образом, ловушка set
предотвращает несанкционированное изменение свойства password
.
Используя JavaScript Proxy, мы можем добавить дополнительный уровень проверки и безопасности к нашим данным, гарантируя, что выполняются только разрешенные операции.
Ограничения и совместимость с браузерами
Хотя прокси JavaScript является мощной функцией, у него есть некоторые ограничения, о которых следует помнить. Во-первых, не все браузеры поддерживают прокси, поэтому важно проверить совместимость браузеров, прежде чем использовать их в продакшене. Однако с ростом внедрения ECMAScript 6 поддержка прокси стала более распространенной. Еще одно ограничение заключается в том, что прокси не могут перехватывать определенные операции, которые считаются фундаментальными или внутренними для JavaScript. К ним относятся такие операции, какObject.preventExtensions()
, Object.isExtensible()
и Object.setPrototypeOf()
. Поэтому прокси могут подходить не для всех сценариев и вариантов использования.
Кроме того, стоит отметить, что использование прокси может привести к снижению производительности, особенно при работе с крупномасштабными приложениями. Перехват и настройка операций с объектами сопряжены с затратами. Хотя прокси могут быть оптимизированы в определенных случаях, важно учитывать потенциальное влияние на производительность и оценивать, перевешивают ли преимущества компромиссы с производительностью.
Реальные варианты использования прокси в JavaScript
JavaScript Proxy находит практическое применение в различных реальных сценариях. Вот несколько примеров:- Логирование: прокси можно использовать для логирования операций с объектами и отслеживания изменений, предоставляя ценную отладочную информацию.
- Кэширование: прокси могут реализовывать механизмы кэширования для повышения производительности за счет хранения и извлечения вычисленных или дорогостоящих значений.
- Мемоизация: прокси можно использовать для реализации мемоизации, которая помогает оптимизировать вызовы функций, кэшируя их результаты на основе предоставленных аргументов.
- Контроль доступа: прокси могут применять правила контроля доступа, гарантируя, что доступ к определенным свойствам или операциям могут получить только авторизованные сущности.
Итоги
JavaScript Proxy предлагает разработчикам мощный инструмент для перехвата и настройки операций с объектами в JavaScript. Используя концепцию ловушек, прокси обеспечивают детальный контроль над фундаментальными операциями, позволяя гибко и динамично изменять поведение. В этой статье мы рассмотрели основы использования прокси JavaScript, поняли, как определять ловушки. Мы также выяснили, как прокси можно использовать для проверки, безопасности, а также изучили их ограничения производительности. Вооружившись этими знаниями, теперь вы можете уверенно использовать JavaScript Proxy для создания надежных и безопасных приложений, используя его потенциал для настройки и контроля.Полное руководство по асинхронному JavaScript
2 года назад·7 мин. на чтение
На пути к тому, чтобы стать разработчиком JavaScript, вы, вероятно, столкнетесь с функциями обратного вызова, промисами (promise) и async/await.
JavaScript по своей сути является синхронным или однопоточным языком. Это означает, что каждое действие выполняется одно за другим, и каждое действие зависит от выполнения предыдущего.
Думайте об этом как о машинах, ожидающих на светофоре. Каждая машина должна ждать, пока заведется предыдущая.
Но что произойдет, если первая машина сломается? Должны ли все остальные машины ждать? У кого есть на это время?
Не лучше ли было бы, чтобы каждая машина не зависела от предыдущей? Почему нас должно волновать, если какая-то машина сломана? Если моя машина работает, почему я должен ждать, пока кто-нибудь заведет ее машину? Разве я не могу просто объехать ее?
Это и позволяет нам делать асинхронный JavaScript. Он создает для нас еще одну «полосу». Асинхронность означает, что если JavaScript должен дождаться завершения операции, он выполнит остальную часть кода во время ожидания. Мы можем переместить наши действия с основной линии и выполнять их в своем собственном темпе, позволяя им заниматься своими делами. И как мы этого добиваемся?
Используя обратные вызовы, промисы и
Мы также можем сделать обратные вызовы частью асинхронного JavaScript.
Асинхронный обратный вызов выполняется после выполнения функции высшего порядка, которая использует колбэк. Если наша машина сломается, мы отвезем ее к механику, после чего снова сможем ею пользоваться. Сначала нам нужно подождать некоторое время, чтобы починить машину. Смоделируем ожидание с помощью
JavaScript сначала выполнил синхронный код (в нашем случае вызов функции
Что ж, отлично, мы починили нашу машину и теперь можем на ней ездить.
Но что, если нашу машину нельзя починить? Как мы будем обрабатывать ошибки? А как насчет ремонта нескольких автомобилей каждый день?
Давайте посмотрим на это в действии.
У вас кружится голова, пытаясь понять это? Не волнуйтесь, вы не одиноки.
Есть причина, по которой это явление называется callback hell.
Кроме того, обратите внимание, что если одна из машин разбита, то есть ее не получается определить, другие машины даже не получат шанса на ремонт.
Чтобы создать промис в JavaScript, используйте ключевое слово
Но почему
Как видно из блока кода выше, мы используем
Как вы можете видеть, после каждого вызова метода
Как видите, ключевое слово
Используйте блок
Результат выполнения кода.const firstCar = 'first car'; const secondCar = 'second car'; console.log('Start ' + firstCar); console.log('Start ' + secondCar);
Start first car Start second car
Результат выполнения кода.const firstCar = 'broken'; const secondCar = 'second car'; if (firstCar === "broken") { throw Error("The first car is broken. Everybody stop."); } console.log('Start ' + firstCar); console.log('Start ' + secondCar);
Error: The first car is broken. Everybody stop.
async
/await
.
Функции обратного вызова (callback)
Обратные вызовы — это функции, вложенные в другую функцию в качестве аргумента. Их можно использовать как часть синхронного или асинхронного кода. Синхронный обратный вызов выполняется во время выполнения функции высшего порядка, которая использует обратный вызов.Результат выполнения кода.function startFirst(car, callback) { console.log("Start " + car); callback(); } // функция обратного вызова function startSecond() { console.log("Start second car"); } // передача функции как аргумент startFirst("first car", startSecond);
Start first car Start second car
setTimeout
, а затем мы сможем наслаждаться вождением нашей только что починенной машины.
Результат выполнения кода.function fixMyCar(car) { setTimeout(() => { console.log(`Fixing your ${car}.`); }, 1000); } function driveMyCar(car) { console.log(`Driving my new ${car}.`); } let myCar = "BMW x5"; fixMyCar(myCar); driveMyCar(myCar);
Driving my new BMW x5. Fixing your BMW x5.
driveMyCar()
), а затем через 1000 миллисекунд записал результат fixMyCar()
.
Но как мы можем водить машину, если она еще не починена?
Мы должны передать функцию driveMyCar()
в качестве колбэка функции fixMyCar()
. Таким образом, функция driveMyCar()
не будет выполняться до тех пор, пока автомобиль не будет отремонтирован.
Результат выполнения кода.function fixMyCar(car, callback) { setTimeout(() => { console.log(`Fixing your ${car}.`); callback(car); }, 1000); } function driveMyCar(car) { console.log(`Driving my new ${car}.`); } let myCar = "BMW x5"; fixMyCar(myCar, driveMyCar);
Fixing your BMW x5. Driving my new BMW x5.
Результат выполнения кода.function fixMyCar(car, success, failure) { setTimeout(() => { car ? success(car) : failure(car); }, 1000); } const car1 = "BMW x5"; const car2 = "Toyota RAV4"; const car3 = "Honda Civic"; fixMyCar( car1, function (car1) { console.log(`Fixed your ${car1}.`); fixMyCar( car2, function (car2) { console.log(`Fixed your ${car2}.`); fixMyCar( car3, function (car3) { console.log(`Fixed your ${car3}.`); }, function (car3) { console.log(`Your ${car3} car can not be fixed.`); } ); }, function (car2) { console.log(`Your ${car2} car can not be fixed.`); } ); }, function (car1) { console.log(`Your ${car1} car can not be fixed.`); } );
Fixed your BMW x5. Fixed your Toyota RAV4. Fixed your Honda Civic.
Результат выполнения кода.function fixMyCar(car, success, failure) { setTimeout(() => { car ? success(car) : failure(car); }, 1000); } const car1 = "BMW x5"; const car2 = undefined; const car3 = "Honda Civic"; fixMyCar( car1, function (car1) { console.log(`Fixing your ${car1}.`); fixMyCar( car2, function (car2) { console.log(`Fixing your ${car2}.`); fixMyCar( car3, function (car3) { console.log(`Fixing your ${car3}.`); }, function (car3) { console.log(`Your ${car3} car can not be fixed.`); } ); }, function (car2) { console.log(`Your ${car2} car can not be fixed.`); } ); }, function (car1) { console.log(`Your ${car1} car can not be fixed.`); } );
Fixing your BMWx5. Your undefined car can not be fixed.
Промисы (Promise)
Promise — это объект, который можно использовать для получения результата асинхронной операции, когда этот результат недоступен прямо сейчас. Поскольку код JavaScript выполняется неблокирующим образом, промисы становятся необходимыми, когда нам нужно дождаться какой-либо асинхронной операции, не задерживая выполнение остального кода. Промисы JavaScript — это объект, который может находиться в одном из трех состояний.- Pending (в ожидании) - обещание еще не выполнено (ваша машина у механика)
- Fulfilled (выполнено) - запрос выполнен успешно (автомобиль отремонтирован)
- Rejected (отклонено) - запрос не выполнен (автомобиль не может быть починен)
new
и внутри конструктора передайте функцию-исполнитель. Затем эта функция отвечает за разрешение или отклонение промиса.
Давайте представим следующий сценарий. Если нашу машину починят, то мы сможем отправиться в отпуск. Там мы можем осмотреть достопримечательности, затем мы можем сделать несколько снимков, опубликовать их в социальных сетях. Но если машину нельзя починить, то придется остаться дома.
Давайте напишем наши шаги.
- Механик обещает, что починит нашу машину
- Починить машину — значит отправиться в отпуск.
- Оказавшись там, мы можем отправиться на экскурсию
- Сделаем несколько фотографий
- После этого мы опубликуем их в социальных сетях
setTimeout
для имитации асинхронности.
Результат выполнения кода.const mechanicsPromise = new Promise( (resolve, reject) => { setTimeout(() => { const fixed = true; if (fixed) resolve("Car is fixed"); else reject("Car can not be fixed"); }, 2000); }); console.log(mechanicsPromise);
Promise { <pending> } [[Prototype]]: Promise [[PromiseState]]: "pending" [[PromiseResult]]: undefined
PromiseResult
- undefined
? Разве ваш механик не говорил вам, что попытается починить вашу машину? Нет, ваш механик вас не обманывал. Что мы забыли сделать, так это обработать промис. И как мы это делаем? Используя методы .then()
и .catch()
.
Результат выполнения кода.const mechanicsPromise = new Promise((resolve, reject) => { setTimeout(() => { const fixed = true; if (fixed) resolve("Car is fixed"); else reject("Car can not be fixed. Go home"); }, 2000); }); mechanicsPromise .then((message) => { console.log(`Success: ${message}`); }) .catch((error) => { console.log(error); });
[[Prototype]]: Promise [[PromiseState]]: "fulfilled" [[PromiseResult]]: Success: Car is fixed
.then()
для получения результата метода resolve()
и .catch()
для получения результата метода reject()
.
Наша машина починена, и теперь мы можем отправиться в отпуск и сделать все, что планировали.
Метод .then()
возвращает новое промис с результатом, преобразованным в значение. Мы можем вызвать метод .then()
для возвращенного промиса следующим образом:
Результат выполнения кода.const mechanicsPromise = new Promise((resolve, reject) => { setTimeout(() => { const fixed = true; if (fixed) resolve("Car is fixed"); else reject("Car can not be fixed"); }, 2000); }); mechanicsPromise .then((message) => { console.log(`Success: ${message}`); message = "Go sight seeing"; return message; }) .then((message) => { console.log(message); message = "Take some pictures"; return message; }) .then((message) => { console.log(message); message = "Posting pictures on social media"; console.log(message); }) .catch((error) => { console.log(error); }) .finally(() => { console.log("Go home"); });
Success: Car is fixed Go sight seeing Take some pictures Posting pictures on social media Go home
.then()
мы вызывали еще один .then()
с сообщением от предыдущего .then()
.
Мы также добавили .catch()
для обнаружения любых ошибок, которые могут возникнуть.
Если мы поедем или не поедем в отпуск, нам обязательно придется вернуться домой.
Это то, что делает .finally()
, этот метод всегда выполняется независимо от того, выполнено ли обещание или отклонено. Другими словами, метод .finally()
выполняется, когда обещание (promise) выполнено.
Наш код выглядит немного лучше, чем когда мы использовали колбэки. Но мы можем сделать это еще лучше с помощью специального синтаксиса под названием async
/await
. Это позволяет нам работать с промисами более удобным способом.
async
/await
async
/await
позволяет нам писать промисы, но код будет выглядеть синхронным, хотя на самом деле он асинхронный. Под капотом мы все еще используем Promise
. async
/await
— это синтаксический сахар, а это означает, что хотя он и не добавляет к нашему коду никаких новых функций, его приятнее использовать.
Результат выполнения кода.const mechanicsPromise = new Promise((resolve, reject) => { setTimeout(() => { const fixed = true; if (fixed) resolve("Car is fixed"); else reject("Car can not be fixed"); }, 2000); }); async function doMyThing() { let message = await mechanicsPromise; console.log(`Success: ${message}`); message = "Go sight seeing"; console.log(message); message = "Take some pictures"; console.log(message); message = "Posting pictures on social media"; console.log(message); console.log("Go home"); } doMyThing()
Success: Car is fixed Go sight seeing Take some pictures Posting pictures on social media Go home
await
заставляет функцию приостанавливать выполнение и ждать разрешенного промиса, прежде чем оно продолжится. Ключевое слово await
можно использовать только внутри асинхронной функции.
А что, если машина сломается? Как мне обрабатывать ошибки с этим новым синтаксисом?
Мы можем использовать блок try
/catch
.
Результат выполнения кода.const mechanicsPromise = new Promise((resolve, reject) => { setTimeout(() => { const fixed = false; if (fixed) resolve("Car is fixed"); else reject("Car can not be fixed"); }, 2000); }); async function doMyThing() { try { let message = await mechanicsPromise; console.log(`Success: ${message}`); message = "Go sight seeing"; console.log(message); message = "Take some pictures"; console.log(message); message = "Posting pictures on social media"; console.log(message); console.log("Go home"); } catch (error) { console.log(error); } } doMyThing();
Your car can not be fixed
try
/catch
только в том случае, если вызов помечен как await
. В противном случае исключение не будет поймано.