Перейти к содержимому

Как можно динамически создать функцию с кодом из произвольной строки js

  • автор:

Eval: выполнение строки кода

Встроенная функция eval позволяет выполнять строку кода.

let result = eval(code);
let code = 'alert("Привет")'; eval(code); // Привет

Строка кода может быть большой, содержать переводы строк, объявления функций, переменные и т.п.

Результатом eval будет результат выполнения последней инструкции.

let value = eval('1+1'); alert(value); // 2
let value = eval('let i = 0; ++i'); alert(value); // 1

Код в eval выполняется в текущем лексическом окружении, поэтому ему доступны внешние переменные:

let a = 1; function f() < let a = 2; eval('alert(a)'); // 2 >f();

Значения внешних переменных можно изменять:

let x = 5; eval("x = 10"); alert(x); // 10, значение изменено

В строгом режиме у eval имеется своё лексическое окружение. Поэтому функции и переменные, объявленные внутри eval , нельзя увидеть снаружи:

// напоминание: режим 'use strict' включён по умолчанию во всех исполняемых примерах eval("let x = 5; function f() <>"); alert(typeof x); // undefined (нет такой переменной) // функция f тоже невидима

Без use strict у eval не будет отдельного лексического окружения, поэтому x и f будут видны из внешнего кода.

Использование «eval»

В современной разработке на JavaScript eval используется весьма редко. Есть даже известное выражение – «eval is evil» («eval – это зло»).

Причина такого отношения достаточно проста: давным-давно JavaScript был не очень развитым языком, и многие вещи можно было сделать только с помощью eval . Но та эпоха закончилась более десяти лет назад.

На данный момент нет никаких причин, чтобы продолжать использовать eval . Если кто-то всё ещё делает это, то очень вероятно, что они легко смогут заменить eval более современными конструкциями или JavaScript-модулями.

Пожалуйста, имейте в виду, что код в eval способен получать доступ к внешним переменным, и это может иметь побочные эффекты.

Минификаторы кода (инструменты, используемые для сжатия JS-кода перед тем, как отправить его конечным пользователям) заменяют локальные переменные на другие с более короткими именами для оптимизации. Обычно это безопасная манипуляция, но не тогда, когда в коде используется eval , так как код из eval может изменять значения локальных переменных. Поэтому минификаторы не трогают имена переменных, которые могут быть доступны из eval . Это ухудшает степень сжатия кода.

Использование внутри eval локальных переменных из внешнего кода считается плохим решением, так как это усложняет задачу по поддержке такого кода.

Существует два пути, как гарантированно избежать подобных проблем.

Если код внутри eval не использует внешние переменные, то вызывайте его так – window.eval(. ) :

В этом случае код выполняется в глобальной области видимости:

Как можно динамически создать функцию с кодом из произвольной строки js

Есть функция, которая записана в строку

var fstr = "function (arg)";

Следующий код не работает

var fstr = "function (arg)"; eval(fstr);

и это ооочень печально
Умею распарсить аргументы и тело функции
Путь названия аргументов хранятся в массиве aargs, а тело функции в fbodystr

var aargs=["'arg'"]; var fbodystr = "return 'hello'+\"world\"+arg";

Функцию ешё можно создать с помощью new Function(аргументы, тело)
Пробую

var fref = eval("new Function("+aargs.toString()+", '"+fbodystr +"')")

ИМХО не работает, так как кавычек не хватает.. При определении new Fun.. используются «‘» и в теле функции они тоже есть!
Как быть, как динамически из строки создать функцию, поскажите..

С уважением, Иван

Re: [JS] создание функции на лету из строки

От: WSN
Дата: 26.11.07 12:33
Оценка:

Здравствуйте, WSN, Вы писали:

WSN>Как быть, как динамически из строки создать функцию, поскажите..

Сделал через БООЛЬШУЮ Ж.. но работает.

var args=["aa", "bb"]; var fbody = "alert(aa+bb)"; var fnref = function(args, body) < return function() < for (var i = 0; i>(args, fbody) fnref("hello ", "world");

Вообщем вот.. Жду каких нить более трезвых решений, потому что тело такой созданной функции по ссылке потом получить будет невозможно..
Задача в пределах сереализации объектов jscript через xml
И все это надо проделать для того, чтобы серелиазовать и воосстановить функцию.. Так что если каки-нить мысли по сереалиции появятся, пишите буду рад

С уважением, Иван

Re: [JS] создание функции на лету из строки

От: anonymous http://denis.ibaev.name/
Дата: 26.11.07 12:44
Оценка:

Здравствуйте, WSN, Вы писали:

WSN>Есть функция, которая записана в строку
WSN>

WSN>var fstr = "function (arg)"; WSN>

WSN>Следующий код не работает
WSN>

WSN>var fstr = "function (arg)"; WSN>eval(fstr); WSN>
var str = "function(a) < alert(a); >"; var func = eval(str); func(1);

Re[2]: [JS] создание функции на лету из строки

От: WSN
Дата: 26.11.07 13:09
Оценка:

Здравствуйте, anonymous, Вы писали:

A>

A>var str = "function(a) < alert(a); >"; A>var func = eval(str); A>func(1); A>

Да супер! Если бы это еще работало. У меня IE6. В нем такое НЕ выполняется!
Мне тоже это очень странно стало!
Может это баг.. но даже если это баг, надо как-то обойти его..

Прошу дельных предложений.
С уважением, Иван

Re: [JS] создание функции на лету из строки

От: .
Дата: 26.11.07 13:41
Оценка: 2 (1)

WSN wrote:

> Следующий код не работает
>
> var fstr = «function (arg)»;
> eval(fstr);

У меня такое заработало:

var fstr = "function (arg)"; eval("(function())()")(1);

Posted via RSDN NNTP Server 2.1 beta
но это не зря, хотя, может быть, невзначай
гÅрмония мира не знает границ — сейчас мы будем пить чай
Re[2]: [JS] создание функции на лету из строки

От: WSN
Дата: 26.11.07 14:04
Оценка:

Здравствуйте, ., Вы писали:
.>У меня такое заработало:
.>

.>var fstr = "function (arg)"; .>eval("(function())()")(1); .>

У меня тоже! Спасибо!
Но все же.. почему не проходит прямое создание.

Re[2]: [JS] создание функции на лету из строки

От: SuhanovSergey
Дата: 26.11.07 14:08
Оценка:

Здравствуйте, ., Вы писали:

.>WSN wrote:

>> Следующий код не работает
>>
>> var fstr = «function (arg)»;
>> eval(fstr);
.>
.>У меня такое заработало:
.>

.>var fstr = "function (arg)"; .>eval("(function())()")(1); .>

Ещё вариант. По сути тоже, что предлагал ., но имхо попроще для чтения.

var fstr = "function (arg)"; eval("var tmp="+fstr+"; tmp;")(1);

Re[3]: [JS] создание функции на лету из строки

От: SuhanovSergey
Дата: 26.11.07 15:09
Оценка: 3 (1) +1

Здравствуйте, WSN, Вы писали:

WSN>Здравствуйте, ., Вы писали:
.>>У меня такое заработало:
.>>

.>>var fstr = "function (arg)"; .>>eval("(function())()")(1); .>>

WSN>У меня тоже! Спасибо!
WSN>Но все же.. почему не проходит прямое создание.
eval(«function(a) < alert(a); >«)(1) не работает в IE, Opera, Safari. Рабоатет в FF. Интересно, кто прав?

Похоже FF не прав. Смотрим определение eval:

eval (x) When the eval function is called with one argument x, the following steps are taken: 1. If x is not a string value, return x. 2. Parse x as a Program. If the parse fails, throw a SyntaxError exception (but see also clause 16). 3. Evaluate the program from step 2. 4. . 

Икак, параметр должен соответствовать грамматике Program. Смотрим грамматику:

Program : SourceElements SourceElements : SourceElement SourceElements SourceElement SourceElement : Statement Statement : Block VariableStatement EmptyStatement ExpressionStatement IfStatement IterationStatement ContinueStatement BreakStatement ReturnStatement WithStatement LabelledStatement SwitchStatement ThrowStatement TryStatement ExpressionStatement : [lookahead ∉ ] Expression ;

Получается, что ExpressionStatement не может начинаться со слова function, о чём кстати пишется далее в комментариях

Note that an ExpressionStatement cannot start with an opening curly brace because that might make it ambiguous with a Block. Also, an ExpressionStatement cannot start with the function keyword because that might make it ambiguous with a FunctionDeclaration.

Получается, что голый ExpressionStatement нельзя писать в eval, но можно, например, operator,:
var fstr = «function(a) < alert(a); >«;
eval(«0, «+fstr)(1);

Re[4]: [JS] создание функции на лету из строки

От: AKS.
Дата: 27.11.07 04:30
Оценка:
 var args = 'a, b'; var fbodystr = 'alert("hello, " + a + " " + b + "!")'; var F = new Function(args, fbodystr);// создание функции посредством конструктора F('my', 'world'); var fstr = "function S(a) < alert(a); >";// создание именованной функции eval(fstr) S(1);// вызов по имени

Re[4]: [JS] создание функции на лету из строки

От: Аноним
Дата: 03.12.07 18:47
Оценка:

Здравствуйте, SuhanovSergey, Вы писали:
SS>Получается, что голый ExpressionStatement нельзя писать в eval, но можно, например, operator,:

В eval можно писать всё, что можно писать в global scope, т.е. всё, кроме return, break, continue.

Разница между FunctionExpression и FunctionDeclaration в том, что первое возвращает ссылку на функцию, а второе undefined. Именно поэтому в eval надо писать «голый ExpressionStatement», частным случаем которого является FunctionExpression, но «нельзя» FunctionDeclaration.

Re[5]: [JS] создание функции на лету из строки

От: AKS.
Дата: 04.12.07 08:22
Оценка:

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, SuhanovSergey, Вы писали:

А>Именно поэтому в eval надо писать «голый ExpressionStatement», частным случаем которого является FunctionExpression, но «нельзя» FunctionDeclaration.

Что значит «нельзя»? В предыдущем сообщении я привел пример, свидетельствующий об обратном.

Re[6]: [JS] создание функции на лету из строки

От: Аноним
Дата: 04.12.07 10:24
Оценка:

Здравствуйте, AKS., Вы писали:

AKS>Что значит «нельзя»? В предыдущем сообщении я привел пример, свидетельствующий об обратном.

Там пример создания глобальной функции — eval при этом возвращает void, а не ссылку на функцию.

Re[7]: [JS] создание функции на лету из строки

От: AKS.
Дата: 04.12.07 14:14
Оценка:

Здравствуйте, Аноним, Вы писали:

А>Там пример создания глобальной функции — eval при этом возвращает void, а не ссылку на функцию.

Я не писал о том, что возвращает eval. Я заметил, что Вы не правы, утверждая: «в eval . писать . «нельзя» FunctionDeclaration».

Re[8]: [JS] создание функции на лету из строки

От: Аноним
Дата: 04.12.07 15:09
Оценка:

Здравствуйте, AKS., Вы писали:

AKS>Я не писал о том, что возвращает eval.

Тогда на кой было встревать в тред про значение, возвращаемое из eval?

AKS> Я заметил, что Вы не правы, утверждая: «в eval . писать . «нельзя» FunctionDeclaration».

Еще немного, и Вам удастся разглядеть контекст, в котором это утверждалось.

Re[9]: [JS] создание функции на лету из строки

От: AKS.
Дата: 05.12.07 05:34
Оценка:

Здравствуйте, Аноним, Вы писали:

А>Тогда на кой было встревать в тред про значение, возвращаемое из eval?

Во-первых, разве интелегентные люди так общаются? Я имею ввиду «на кой» и «встревать».
А во-вторых, здесь нет треда, называющегося «Про значение, возвращаемое из eval»!

А>Еще немного, и Вам удастся разглядеть контекст, в котором это утверждалось.

Так ведь контекст-то один — контекст спецификации ECMAScript Language. Тем не менее, я готов узнать о вашей интерпретации, а именно, каким образом в eval надо писать:

А>. «голый ExpressionStatement», частным случаем которого является FunctionExpression
, чтобы при этом случилось то, что Вы называете:

А>. возвращает ссылку на функцию

Re: [JS] создание функции на лету из строки

От: _JoKe_
Дата: 06.12.07 10:10
Оценка:

WSN>Есть функция, которая записана в строку
WSN>

WSN>var fstr = "function (arg)"; WSN>

WSN>Следующий код не работает
WSN>

WSN>var fstr = "function (arg)"; WSN>eval(fstr); WSN>

WSN>и это ооочень печально

eval("var fstr = function (arg)"); alert( fstr("!") );

Запуск кода из строки: метод eval

Здравствуйте! В этом уроке речь пойдет о таком может малоизвестном методе eval. Функция eval(code) позволяет выполнить любой код, переданный ей в виде строки. И в этом кроется ее опасность ведь если ей передать зловредный код в виде строки, то он будет выполнен.

Этот код будет выполнен в текущей области видимости.

Метод eval выполнение кода JS

Использование eval

В простейшем случае eval всего лишь выполняет код, вот пример:

var a = 1; (function() < var a = 2; eval(' alert(a) '); // 2 >)()

Но он может не только выполнить код, но и также вернуть результат.
Вызов eval возвращает последнее вычисленное выражение, например:

alert( eval('2+1') ); // 3

При вызове eval имеет полный доступ к локальным переменным.

Это означает, что переменные могут быть изменены или дополнены:

var x = 5; eval(" alert( x ); x = 10"); // 5, доступ к старому значению alert( x ); // 10, значение изменено внутри eval

В строгом режиме eval имеет свою область видимости

В строгом режиме функционал eval чуть-чуть меняется.
При use strict код внутри eval по-прежнему сможет читать и менять внешние переменные, однако переменные и функции, объявленные внутри eval, не попадут наружу.

"use strict"; eval("var a = 5; function f() < >"); alert( a ); // ошибка, переменная не определена // функция f тоже не видна снаружи

Другими словами, в новом стандарте eval имеет свою область видимости, а к внешним переменным обращается через замыкание, аналогично тому, как работают обычные функции.

Неграмотное использование eval

Начнём с того, что eval применяется довольно очень редко. Действительно редко. Есть даже такое выражение как «eval is evil» (eval – зло).

Причина проста: когда-то JavaScript был гораздо более слабым языком, чем сейчас, и некоторые вещи без eval было попросту сделать невозможно. Но те времена давно канули в лету. И теперь найти тот случай, когда действительно надо выполнить код из строки – это надо сильно постараться.

Но если вы действительно знаете, что это именно тот случай и вам просто необходим eval – есть несколько нбансов, которые нужно иметь в виду.

Доступ к локальным переменным – худшее, что можно сделать при eval.

Читайте также Функции для взаимодействия с пользователем: alert, prompt, confirm

Дело в том, что локальные переменные могут быть очень легко переименованы:

function sayHi()

Переменная phrase может быть переименована в hello, и если строка str обращается к ней – будет ошибка.

Современные средства сжатия JavaScript переименовывают локальные переменные автоматически. Это считается безопасным, так как локальная переменная видна лишь внутри функции и если в ней везде поменять phrase на p, то никто этого и не заметит.
До сжатия:

function sayHi()
function sayHi()

На самом деле всё ещё проще – в данном случае утилита сжатия автоматически уберёт переменную a и код станет таким:

function sayHi()

Итак, если где-то в функции есть eval, то его взаимодействие с локальными переменными будет нарушено.

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

Как правило, eval не нужен, именно поэтому и говорят: «eval is evil».

Запуск скрипта в глобальной области

Хорошо взаимодействовать с локальными переменными нельзя.

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

Здесь eval может пригодиться. Имеются 2 трюка для выполнения кода в глобальной области:

    Везде, кроме IE8-, достаточно вызвать eval не напрямую, а через window.eval.Вот так:

var a = 1; (function() < var a = 2; window.eval(' alert(a) '); // 1, выполнено глобально везде, кроме IE8- >)();
  1. В IE8- можно применить нестандартную фунцию execScript. Она, как и собственно eval, выполняет код, но всегда только в глобальной области видимости и не возвращает значение.

Оба способа можно объединить в единой функции globalEval(code), выполняющей код без доступа к локальным переменным:

function globalEval(code) < // соединим два способа в одну функцию window.execScript ? execScript(code) : window.eval(code); >var a = 1; (function() < var a = 2; globalEval(' alert(a) '); // 1, во всех браузерах >)();

Внешние данные через new Function

Итак, у нас есть код, который всё же нужно выполнить динамически, через eval, но не просто скрипт – а ему нужно передать какие-то значения.

Читайте также Циклы while, for в JavaScript

Как мы говорили ранее, считать их из локальных переменных нельзя: это подвержено ошибкам при переименовании переменных и сразу ломается при сжатии JavaScript. Да и вообще, неочевидно и кривовато.

К счастью, существует отличная альтернатива eval, которая позволяет корректно взаимодействовать с внешним кодом: new Function.

Вызов new Function(‘a,b’, ‘..тело..’) создает функцию с указанными аргументами a,b и телом. Как мы помним, доступа к текущему замыканию у такой функции не будет, но вы можете передать параметры и получить результат.

var a = 2, b = 3; // вместо обращения к a,b через eval // будем принимать их как аргументы динамически созданной функции var mul = new Function('a, b', ' return a * b;'); alert( mul(a, b) ); // 6

JSON и eval

В браузерах IE7- не было методов JSON.stringify и JSON.parse, поэтому работа с JSON происходила через eval.

Этот способ работы с JSON давно устарел, но его можно встретить кое-где в старом коде, так что для примера рассмотрим его.

Вызов eval(code) выполняет код и, если это выражение, то возвращает его значение, поэтому можно в качестве кода передать JSON.

var str = '< \ "name": "Вася", \ "age": 25 \ >'; var user = eval('(' + str + ')'); alert( user.name ); // Вася

Зачем здесь нужны скобки eval( ‘(‘ + str + ‘)’ ), почему не просто eval(str)?

Поэтому если передать в eval объект напрямую, то интерпретатор подумает, что это на самом деле блок кода, а там внутри какие-то двоеточия

Вот, для примера, eval без скобок, он выдаст ошибку:

var user = eval('< "name": "Вася", "age": 25 >');

А если eval получает выражение в скобках ( … ), то интерпретатор точно знает, что это не блок кода, а объект:

var user = eval('( < "name": "Вася", "age": 25 >)'); alert( user.age ); // 25

Осторожно, злой JSON!

Если мы получаем JSON из недоверенного источника, например с чужого сервера, то разбор через eval может быть и опасен.

Читайте также Работа с куки в JavaScript, document.cookie

Например, чужой сервер может быть взломан (за свой-то код мы отвечаем, а вот за чужой – нет), и вместо JSON вставлен злонамеренный JavaScript-код.

Поэтому рекомендуется, всё же, использовать JSON.parse.

При разборе через JSON.parse некорректный JSON просто приведёт к ошибке, а вот при разборе через eval этот код реально выполнится, и он может вывести что-то на странице, перенаправить посетителя куда-то и т.п да мало ли что еще можно придумать.

Итоги

  • Функция eval(str) выполняет код и возвращает последнее вычисленное выражение. В современном JavaScript она используется очень редко.
  • Вызов eval может читать и менять локальные переменные. Это – зло, поэтому следует этого избегать.
  • Для выполнения скрипта в глобальной области используются трюк с window.eval/execScript. При этом локальные переменные не будут затронуты, так что такое выполнение безопасно и иногда, в редких архитектурах, может быть полезным.
  • Если выполняемый код всё же должен взаимодействовать с локальными переменными – используйте выражение new Function. Создавайте функцию из строки и передавайте переменные ей, это надёжно и безопасно.

Задания

Eval-калькулятор

Вам надо написать интерфейс, который принимает математическое выражение (prompt) и возвращает его результат.

Проверять выражение на корректность не требуется.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

JSX в деталях

These docs are old and won’t be updated. Go to react.dev for the new React docs.

JSX — синтаксический сахар для функции React.createElement(component, props, . children) . Этот JSX-код:

MyButton color="blue" shadowSize=2>> Нажми меня MyButton>
React.createElement( MyButton, color: 'blue', shadowSize: 2>, 'Нажми меня' )

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

div className="sidebar" />
React.createElement( 'div', className: 'sidebar'> )

Если вы хотите проверить, как JSX-код компилируется в JavaScript, попробуйте онлайн-компилятор Babel.

Указание типа React-элемента

Первая часть JSX-тега определяет тип React-элемента.

Типы, написанные с большой буквы, указывают, что JSX-тег ссылается на React-компонент. Эти теги компилируются в прямую ссылку на именованную переменную, поэтому, если вы используете JSX-выражение , то Foo должен быть в области видимости.

React должен находиться в области видимости

Поскольку JSX компилируется в вызов React.createElement , библиотека React должна всегда быть в области видимости вашего JSX-кода.

К примеру, в данном коде оба импорта являются необходимыми, даже если на React и CustomButton нет прямых ссылок из JavaScript:

import React from 'react';import CustomButton from './CustomButton'; function WarningButton()   // return React.createElement(CustomButton, , null); return CustomButton color="red" />; >

Если вы не используете сборщик JavaScript и загружаете React с помощью тега , то он уже доступен как React в глобальной области видимости.

Использование записи через точку

Вы также можете ссылаться на React-компонент, используя запись через точку. Это удобно, если у вас есть модуль, который экспортирует много React-компонентов. К примеру, если MyComponents.DatePicker является компонентом, то вы можете обратиться к нему напрямую, используя запись через точку:

import React from 'react'; const MyComponents =  DatePicker: function DatePicker(props)  return div>Представьте, что здесь цвет props.color> виджета выбора даты.div>; > > function BlueDatePicker()   return MyComponents.DatePicker color="blue" />;>

Названия типов пользовательских компонентов должны начинаться с большой буквы

Если название типа элемента начинается с маленькой буквы, он ссылается на встроенный компонент, к примеру или , что в результате приведёт к тому, что в React.createElement будет передана строка ‘div’ или ‘span’ . Типы, начинающиеся с заглавной буквы, такие как , компилируются в React.createElement(Foo) и соответствуют компоненту, который был объявлен или импортирован в вашем JavaScript-файле.

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

К примеру, этот код будет работать не так, как ожидается:

import React from 'react'; // Неправильно! Это компонент и он должен быть записан с заглавной буквы:function hello(props)  // Правильно! Использование разрешено, так как это валидный HTML-тег: return div>Привет, props.toWhat>div>; > function HelloWorld()   // Неправильно! React думает, что - это HTML-тег, // потому что он записан с маленькой буквы: return hello toWhat="Мир" />; >

Для того, чтобы исправить это, мы переименуем hello в Hello и станем использовать , когда будем ссылаться на него:

import React from 'react'; // Правильно! Это компонент и он должен быть записан с заглавной буквы:function Hello(props)  // Правильно! Использование разрешено, так как это валидный HTML-тег: return div>Привет, props.toWhat>div>; > function HelloWorld()   // Правильно! React знает, что это компонент, // потому что он написан с заглавной буквы. return Hello toWhat="Мир" />; >

Выбор типа во время исполнения

В качестве типа React-элемента нельзя использовать выражение. Если вы хотите использовать выражение, чтобы указать тип элемента, присвойте его в переменную, начинающуюся с заглавной буквы. Это подходит для рендера компонентов в зависимости от ваших пропсов:

import React from 'react'; import  PhotoStory, VideoStory > from './stories'; const components =  photo: PhotoStory, video: VideoStory >; function Story(props)   // Неправильно! JSX-тип не может являться выражением return components[props.storyType] story=props.story> />;>

Чтобы исправить это, мы присвоим тип в переменную, начинающуюся с заглавной буквы:

import React from 'react'; import  PhotoStory, VideoStory > from './stories'; const components =  photo: PhotoStory, video: VideoStory >; function Story(props)   // Правильно! JSX-тип может являться переменной, названной с заглавной буквы const SpecificStory = components[props.storyType]; return SpecificStory story=props.story> />;>

Существует несколько разных способов передачи пропсов в JSX.

JavaScript-выражения как пропсы

Вы можете передавать любые JavaScript-выражения как пропсы, обернув их в <> . К примеру, в этом JSX:

MyComponent foo=1 + 2 + 3 + 4> />

Для MyComponent значение props.foo будет равно 10 , потому что выражение 1 + 2 + 3 + 4 будет вычислено.

Оператор if и цикл for не являются выражениями в JavaScript, поэтому их нельзя непосредственно использовать в JSX. Вместо этого, вы можете окружить ими JSX-код. К примеру:

function NumberDescriber(props)  let description; if (props.number % 2 == 0)  description = strong>чётнымstrong>; > else  description = i>нечётнымi>; > return div>props.number> является description> числомdiv>; >

Вы можете узнать больше про условный рендеринг и циклы в соответствующих разделах.

Вы можете передать строковый литерал как проп. Эти два выражения эквивалентны:

MyComponent message="привет, мир" /> MyComponent message='привет, мир'> />

Когда вы передаёте строковый литерал, все его возможные символы будут преобразованы в соответствующие HTML-сущности. Поэтому эти два JSX-выражения будут эквивалентны:

MyComponent message="<3" /> MyComponent message='> />

Обычно такое поведение не должно вас волновать. Оно упомянуто для полноты картины.

Установка пропсов по умолчанию в «true»

Если вы не передаёте значение в проп, то по умолчанию оно будет true . Эти два JSX выражения эквивалентны:

MyTextBox autocomplete /> MyTextBox autocomplete=true> />

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

Если у вас уже есть пропсы внутри объекта props и вы хотите передать их в JSX, вы можете использовать оператор расширения . , чтобы передать весь объект с пропсами. Эти два компонента эквивалентны:

function App1()  return Greeting firstName="Иван" lastName="Иванов" />; > function App2()  const props = firstName: 'Иван', lastName: 'Иванов'>; return Greeting . props> />;>

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

const Button = props =>   const  kind, . other > = props; const className = kind === "primary" ? "PrimaryButton" : "SecondaryButton"; return button className=className> . other> />; >; const App = () =>  return ( div> Button kind="primary" onClick=() => console.log("Кнопка нажата!")>> Привет, мир! Button> div> ); >;

В приведённом выше примере, проп kind используется безопасно и не передаётся в элемент , находящийся в DOM. Все остальные пропсы передаются с помощью объекта . other , что делает этот компонент очень гибким. Вы можете видеть, что он передаёт пропсы onClick и children .

Атрибуты расширения могут быть полезны, однако, также они позволяют передать ненужные пропсы в компоненты или невалидные HTML-атрибуты в DOM. Мы рекомендуем использовать этот синтаксис с осторожностью.

Дочерние компоненты в JSX

В JSX-выражениях содержимое, которое расположено между открывающими и закрывающими тегами, передаётся с помощью специального пропа: props.children . Существует несколько способов передать дочерние компоненты:

Если вы поместите строку между открывающим и закрывающим тегом, то props.children будет равно этой строке. Это полезно при создании встроенных HTML-элементов. К примеру:

MyComponent>Привет, мир!MyComponent>

Это корректный JSX-код, в котором значение props.children в MyComponent будет строкой «Привет, мир!» . HTML не экранируется, поэтому JSX можно писать так же, как HTML:

div>Это одновременно и валидный HTML и JSX.div>

JSX удаляет пустые строки и пробелы в начале и конце строки. Новые строки, примыкающие к тегу будут удалены. Новые строки между строковых литералов сжимаются в один пробел. Следующие три примера кода рендерят одинаковый результат:

div>Привет, мирdiv> div> Привет, мир div> div> Привет, мир div> div> Привет, мир div>

Чтобы отобразить вложенные компоненты, можно указать несколько JSX-элементов в качестве дочерних.

MyContainer> MyFirstComponent /> MySecondComponent /> MyContainer>

Вы можете смешивать различные типы потомков, скажем, использовать строковый литерал вместе с JSX-элементами. Вот ещё один пример, в котором JSX похож на HTML, причём данный код является валидным и для JSX, и для HTML:

div> Ниже представлен список: ul> li>Элемент 1li> li>Элемент 2li> ul> div>

Также React-компонент может возвращать массив элементов:

render()  // Не нужно оборачивать список элементов в дополнительный элемент! return [ // Не забудьте про ключи :) li key="A">Первый элементli>, li key="B">Второй элементli>, li key="C">Третий элементli>, ]; >

JavaScript-выражения как дочерние компоненты

Вы можете передать любое JavaScript-выражение как дочерний компонент, обернув его в <> . К примеру, эти выражения эквивалентны:

MyComponent>ПримерMyComponent> MyComponent>'Пример'>MyComponent>

Часто это бывает полезно при рендере списка JSX-выражений произвольной длины. Например, эта запись рендерит HTML-список:

function Item(props)   return li>props.message>li>;> function TodoList()  const todos = ['закончить документацию', 'отправить пулреквест', 'снова напомнить Дэну про ревью']; return ( ul> todos.map((message) => Item key=message> message=message> />)>  ul> ); >

JavaScript-выражения могут быть использованы вместе с другими типами дочерних компонентов. Они могут рассматриваться как альтернатива шаблонным строкам:

function Hello(props)   return div>Привет, props.addressee>!div>;>

Функции как дочерние компоненты

Обычно JavaScript-выражения, вставленные в JSX, будут приведены к строке, React-элементу или списку из всего этого. Тем не менее, props.children работает так же, как и любой другой проп, поэтому в него можно передавать любые типы данных, а не только те, которые React знает как рендерить. К примеру, если у вас есть пользовательский компонент, можно было бы передать колбэк в props.children :

// Вызывает колбэк numTimes раз для создания повторяющего компонента function Repeat(props)  let items = []; for (let i = 0; i  props.numTimes; i++)  items.push(props.children(i)); > return div>items>div>; > function ListOfTenThings()  return ( Repeat numTimes=10>> (index) => div key=index>>Это элемент списка с ключом index>div>>  Repeat> ); >

Дочерние компоненты, передаваемые пользовательскому компоненту, могут быть чем угодно с тем условием, что компонент преобразует их во что-то, что React сможет понять и отрендерить. Следующий пример редко встречается, но им можно воспользоваться, если необходимо расширить возможности JSX.

Логические значения, null и undefined игнорируются

Значения false , null , undefined и true — валидные дочерние компоненты. Просто они не рендерятся. Эти JSX-выражения будут рендерить одно и то же:

div /> div>div> div>false>div> div>null>div> div>undefined>div> div>true>div>

Этот подход может быть полезным для рендера по условию. Вот пример, где JSX рендерит , если showHeader равняется true :

div> showHeader && Header />>  Content /> div>

Есть один нюанс в том, что React будет рендерить «ложные» (falsy) значения, такие как число 0 . Код ниже ведёт себя не так, как вы могли ожидать, так как 0 будет отображён, если массив props.messages пуст:

div> props.messages.length && MessageList messages=props.messages> /> > div>

Чтобы исправить это, убедитесь что выражение перед оператором && всегда является boolean:

div> props.messages.length > 0 && MessageList messages=props.messages> /> > div>

И наоборот, если вы хотите, чтобы такие значения как false , true , null или undefined отрисовались, то сначала вы должны преобразовать их в строку:

div>  Моя переменная JavaScript - String(myVariable)>. div>

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *