Это работает А это не работает. что в 5.3 что в 5.4
> t=setmetatable({},{ __bshl = function(x,y) print(x,y) end}) > print (t<<2) stdin:1: attempt to perform bitwise operation on a table value (global 't') stack traceback: stdin:1: in main chunk [C]: in ? > print (t>>2) stdin:1: attempt to perform bitwise operation on a table value (global 't') stack traceback: stdin:1: in main chunk [C]: in ?
метод __bshl не видится почему то
Пасхалочка для Алексея Иванникова:
Пользователь
Сообщений: Регистрация: 30.01.2015
09.07.2022 16:54:12
Цитата
написал: > t=setmetatable({},{ __div = function(x,y) print(x,y) end})> print (t/2)table: 0000000000620d10 2nilЭто работаетА это не работает. что в 5.3 что в 5.4> t=setmetatable({},{ __bshl = function(x,y) print(x,y) end})> print (t<<2)
забавно, что на одних заборах называют этот метод правильно, __shl, а на других неправильно __bshl. И вторых заборов много..
Пасхалочка для Алексея Иванникова:
Пользователь
Сообщений: Регистрация: 30.01.2015
10.07.2022 07:54:20
Скажу Вам по секрету, лучше читать не на заборе, особенно , если там написано русскими словами, как правило, те кто пишет на русском списывают это с англоязычных сайтов и с ошибками, а начинать читать с первоисточника. ------------------- Например , в Вашем случае, смотрим документацию на Lua 5.3 (5.4)
Скрытый текст
A detailed list of events controlled by metatables is given next. Each operation is identified by its corresponding key.
__add: the addition (+) operation. If any operand for an addition is not a number (nor a string coercible to a number), Lua will try to call a metamethod. First, Lua will check the first operand (even if it is valid). If that operand does not define a metamethod for __add, then Lua will check the second operand. If Lua can find a metamethod, it calls the metamethod with the two operands as arguments, and the result of the call (adjusted to one value) is the result of the operation. Otherwise, it raises an error.
__sub: the subtraction (-) operation. Behavior similar to the addition operation.
__mul: the multiplication (*) operation. Behavior similar to the addition operation.
__div: the division (/) operation. Behavior similar to the addition operation.
__mod: the modulo (%) operation. Behavior similar to the addition operation.
__pow: the exponentiation (^) operation. Behavior similar to the addition operation.
__unm: the negation (unary -) operation. Behavior similar to the addition operation.
__idiv: the floor division (//) operation. Behavior similar to the addition operation.
__band: the bitwise AND (&) operation. Behavior similar to the addition operation, except that Lua will try a metamethod if any operand is neither an integer nor a value coercible to an integer (see ).
__bor: the bitwise OR (|) operation. Behavior similar to the bitwise AND operation.
__bxor: the bitwise exclusive OR (binary ~) operation. Behavior similar to the bitwise AND operation.
__bnot: the bitwise NOT (unary ~) operation. Behavior similar to the bitwise AND operation.
__shl: the bitwise left shift (<<) operation. Behavior similar to the bitwise AND operation.
__shr: the bitwise right shift (>>) operation. Behavior similar to the bitwise AND operation.
__concat: the concatenation (..) operation. Behavior similar to the addition operation, except that Lua will try a metamethod if any operand is neither a string nor a number (which is always coercible to a string).
__len: the length (#) operation. If the object is not a string, Lua will try its metamethod. If there is a metamethod, Lua calls it with the object as argument, and the result of the call (always adjusted to one value) is the result of the operation. If there is no metamethod but the object is a table, then Lua uses the table length operation (see ). Otherwise, Lua raises an error.
__eq: the equal (==) operation. Behavior similar to the addition operation, except that Lua will try a metamethod only when the values being compared are either both tables or both full userdata and they are not primitively equal. The result of the call is always converted to a boolean.
__lt: the less than (<) operation. Behavior similar to the addition operation, except that Lua will try a metamethod only when the values being compared are neither both numbers nor both strings. The result of the call is always converted to a boolean.
__le: the less equal (<=) operation. Unlike other operations, the less-equal operation can use two different events. First, Lua looks for the __le metamethod in both operands, like in the less than operation. If it cannot find such a metamethod, then it will try the __lt metamethod, assuming that a <= b is equivalent to not (b < a). As with the other comparison operators, the result is always a boolean. (This use of the __lt event can be removed in future versions; it is also slower than a real __le metamethod.)
__index: The indexing access operation table[key]. This event happens when table is not a table or when key is not present in table. The metamethod is looked up in table.
Despite the name, the metamethod for this event can be either a function or a table. If it is a function, it is called with table and key as arguments, and the result of the call (adjusted to one value) is the result of the operation. If it is a table, the final result is the result of indexing this table with key. (This indexing is regular, not raw, and therefore can trigger another metamethod.)
__newindex: The indexing assignment table[key] = value. Like the index event, this event happens when table is not a table or when key is not present in table. The metamethod is looked up in table.
Like with indexing, the metamethod for this event can be either a function or a table. If it is a function, it is called with table, key, and value as arguments. If it is a table, Lua does an indexing assignment to this table with the same key and value. (This assignment is regular, not raw, and therefore can trigger another metamethod.)
Whenever there is a __newindex metamethod, Lua does not perform the primitive assignment. (If necessary, the metamethod itself can call to do the assignment.)
__call: The call operation func(args). This event happens when Lua tries to call a non-function value (that is, func is not a function). The metamethod is looked up in func. If present, the metamethod is called with func as its first argument, followed by the arguments of the original call (args). All results of the call are the result of the operation. (This is the only metamethod that allows multiple results.)
что в переводе гугла означает:
Скрытый текст
Далее приведен подробный список событий, управляемых метатаблицами. Каждая операция идентифицируется соответствующей клавишей.
__add: операция сложения (+). Если какой-либо операнд для сложения не является числом (или строкой, приводимой к числу), Lua попытается вызвать метаметод. Сначала Lua проверит первый операнд (даже если он действителен). Если этот операнд не определяет метаметод для __add, тогда Lua проверит второй операнд. Если Lua может найти метаметод, он вызывает метаметод с двумя операндами в качестве аргументов, и результат вызова (скорректированный на одно значение) является результатом операции. В противном случае возникает ошибка.
__sub: операция вычитания (-). Поведение аналогично операции сложения.
__mul: операция умножения (*). Поведение аналогично операции сложения.
__div: операция разделения (/). Поведение аналогично операции сложения.
__mod: операция modulo (%). Поведение аналогично операции сложения.
__pow: операция возведения в степень (^). Поведение аналогично операции сложения.
__unm: операция отрицания (унарная-). Поведение аналогично операции сложения.
__idiv: операция разделения этажей (//). Поведение аналогично операции сложения.
__band: побитовая операция И (&). Поведение аналогично операции сложения, за исключением того, что Lua попытается выполнить метаметод, если какой-либо операнд не является ни целым числом, ни значением, приводимым к целому числу (см. ).
__bor: побитовая операция ИЛИ (|). Поведение аналогично побитовой операции И.
__bxor: побитовая исключающая ИЛИ (двоичная~) операция. Поведение аналогично побитовой операции И.
__bnot: побитовая НЕ (унарная~) операция. Поведение аналогично побитовой операции И.
__shl: операция побитового сдвига влево (<<). Поведение аналогично побитовой операции И.
__shr: операция побитового сдвига вправо (>>). Поведение аналогично побитовой операции И.
__concat: операция конкатенации (..). Поведение аналогично операции сложения, за исключением того, что Lua попытается выполнить метаметод, если какой-либо операнд не является ни строкой, ни числом (что всегда приводит к строке).
__len: операция length (#). Если объект не является строкой, Lua попробует его метаметод. Если существует метаметод, Lua вызывает его с объектом в качестве аргумента, и результатом вызова (всегда с поправкой на одно значение) является результат операции. Если метаметода нет, но объект представляет собой таблицу, тогда Lua использует операцию длины таблицы (см. ). В противном случае Lua выдает ошибку.
__eq: операция equal (==). Поведение, аналогичное операции сложения, за исключением того, что Lua будет использовать метаметод только тогда, когда сравниваемые значения являются либо обеими таблицами, либо обеими полными пользовательскими данными, и они не являются примитивно равными. Результат вызова всегда преобразуется в логическое значение.
__lt: операция меньше, чем (<) . Поведение аналогично операции сложения, за исключением того, что Lua будет использовать метаметод только тогда, когда сравниваемые значения не являются ни обоими числами, ни обеими строками. Результат вызова всегда преобразуется в логическое значение.
__le: операция less equal (<=) . В отличие от других операций, операция с меньшим равенством может использовать два разных события. Во-первых, Lua ищет __leметаметод в обоих операндах, как в операции меньше, чем. Если он не может найти такой метаметод, то он попробует __ltметаметод, предполагая, что a <= bэто эквивалентно not (b < a). Как и в случае с другими операторами сравнения, результатом всегда является логическое значение. (Это использование __ltсобытия может быть удалено в будущих версиях; это также медленнее, чем настоящий __leметаметод.)
__index: Операция доступа к индексации table[key]. Это событие происходит, когда tableне является таблицей или когда keyотсутствует в table. Метаметод ищется в .table
Несмотря на название, метаметод для этого события может быть либо функцией, либо таблицей. Если это функция, она вызывается с tableаргументами и keyв качестве аргументов, а результат вызова (скорректированный на одно значение) является результатом операции. Если это таблица, конечный результат является результатом индексации этой таблицы с keyпомощью . (Это индексирование является обычным, а не необработанным, и поэтому может вызвать другой метаметод.)
__newindex: Назначение индексации table[key] = value. Как и событие index, это событие происходит, когда tableне является таблицей или когда keyотсутствует в table. Метаметод ищется в .table
Как и в случае с индексацией, метаметодом для этого события может быть либо функция, либо таблица. Если это функция, она вызывается с table, key, и valueв качестве аргументов. Если это таблица, Lua выполняет индексирование для этой таблицы с тем же ключом и значением. (Это назначение является обычным, а не необработанным, и поэтому может вызвать другой метаметод.)
Всякий раз, когда существует __newindexметаметод, Lua не выполняет назначение примитива. (При необходимости сам метаметод может быть вызван для выполнения назначения.)
__call: Операция вызова func(args). Это событие происходит, когда Lua пытается вызвать нефункциональное значение (то funcесть не является функцией). Метаметод ищется в .func Если присутствует, метаметод вызывается с funcпервым аргументом, за которым следуют аргументы исходного вызова (args) . Все результаты вызова являются результатом операции. (Это единственный метаметод, который допускает множественные результаты.)
