EVAL：执行脚本

redis.call(command, ...)
redis.pcall(command, ...)

redis> EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 "message" "hello world"
OK
redis> GET "message"
"hello world"

redis> EVAL "return redis.call('ZADD', KEYS[1], ARGV[1], ARGV[2])" 1 "fruit-price"
8.5 "apple"
(integer) 1
redis> ZRANGE "fruit-price" 0 -1 WITHSCORES
1) "apple"
2) "8.5"

-- Lua的type()函数用于查看给定值的类型
redis> EVAL "return type(redis.call('WRONG_COMMAND'))" 0
(error) ERR Error running script (call to f_2c59998e8c4eb7f9fdb467ba67ba43dfaf8a6592): @user_scr
ipt:1: @user_script: 1: Unknown Redis command called from Lua script
redis> EVAL "return type(redis.pcall('WRONG_COMMAND'))" 0
"table"

redis> EVAL "return 3.14" 0
(integer) 3

redis> EVAL "return tostring(3.14)" 0
"3.14"

redis> EVAL "local database='redis';return database" 0
"redis"

redis> EVAL "number=10" 0
(error) ERR Error running script (call to f_a2754fa2d614ad76ecfd143acc06993bedf1f691): @enable_s
trict_lua:8: user_script:1: Script attempted to create global variable 'number'

redis> SET dbnumber 0 -- 将0号数据库的dbnumber键的值设置为0
OK
redis> SELECT 1 -- 切换至1号数据库
OK
redis[1]> SET dbnumber 1 -- 将1号数据库的dbnumber键的值设置为1
OK
redis[1]> SELECT 0 -- 切换回0号数据库
OK
redis> EVAL "redis.call('SELECT', ARGV[1]); return redis.call('GET', KEYS[1])" 1 "dbnumber" 1
"1" -- 在脚本中切换至1号数据库，并获取dbnumber键的值
redis> GET dbnumber
"0" -- dbnumber 键的值为0，这表示客户端的当前数据库仍然是0号数据库

redis.call("SET", KEYS[1], ARGV[1])
return redis.call("GET", KEYS[1])

$ redis-cli --eval set_and_get.lua 'msg' , 'Ciao!'
"Ciao!"

class IdentityLock:

    def __init__(self, client, key):
        self.client = client
        self.key = key

    def acquire(self, identity, timeout):
        """
        尝试获取一个带有身份标识符和最大使用时限的锁，
        成功时返回 True ，失败时返回 False 。
        """
        result = self.client.set(self.key, identity, ex=timeout, nx=True)
        return result is not None

    def release(self, input_identity):
        """
        根据给定的标识符，尝试释放锁。
        返回 True 表示释放成功；
        返回 False 则表示给定的标识符与锁持有者的标识符不相同，释放请求被拒绝。
        """
        script = """
        -- 使用局部变量储存锁键键名以及标识符，提高脚本的可读性
        local key = KEYS[1]
        local input_identity = ARGV[1]

        -- 获取锁键储存的标识符
        -- 当标识符为空时，Lua 会将 GET 返回的 nil 转换为 false
        local lock_identity = redis.call("GET", key)

        if lock_identity == false then
            -- 如果锁键储存的标识符为空，那么说明锁已经被释放
            return true
        elseif input_identity == lock_identity then
            -- 如果给定的标识符与锁键储存的标识符相同，那么释放这个锁
            redis.call("DEL", key)
            return true
        else
            -- 如果给定的标识符与锁键储存的标识符并不相同
            -- 那么说明当前客户端不是锁的持有者，拒绝本次释放请求
            return false
        end
        """
        # 因为 Redis 会将脚本返回的 true 转换为数字 1
        # 所以这里通过检查脚本返回值是否为 1 来判断解锁操作是否成功
        result = self.client.eval(script, 1, self.key, input_identity)
        return result == 1

LPOPRPUSH source target

item = LPOP source
RPUSH target item

WATCH source target
MULTI
item = LPOP source
RPUSH target item
EXEC

WATCH source
MULTI
item = LPOP source
EXEC
RPUSH target item

item = LPOP source
WATCH target
MULTI
RPUSH target item
EXEC

WATCH source
MULTI
item = LPOP source
EXEC
WATCH target
MULTI
RPUSH target item
EXEC

WATCH source target
item = LRANGE source 0 0 -- 获取源列表的左端元素
MULTI
LPOP source -- 弹出源列表的左端元素
RPUSH target item -- 向目标列表右端推入之前获取的左端元素
EXEC

def lpoprpush(client, source, target):
    script = """
    local source = KEYS[1]
    local target = KEYS[2]

    -- 从源列表左端弹出一个元素
    -- 当源列表为空时，LPOP 返回的 nil 将被 Lua 转换为 false
    local item = redis.call("LPOP", source)

    -- 如果被弹出元素不为空，那么将它推入到目标列表的右端
    -- 并向调用者返回该元素
    if item ~= false then
        redis.call("RPUSH", target, item)
        return item
    end
    """
    return client.eval(script, 2, source, target)

>>> from redis import Redis
>>> from lpoprpush import lpoprpush
>>> client = Redis(decode_responses=True)
>>> client.rpush("source", "a", "b", "c") # 创建源列表和目标列表
3L
>>> client.rpush("target", "d", "e", "f")
3L
>>> lpoprpush(client, "source", "target") # 弹出源列表的左端元素
'a' # 并将其推入目标列表的右端
>>> client.lrange("source", 0, -1)
['b', 'c']
>>> client.lrange("target", 0, -1)
['d', 'e', 'f', 'a']