Article Detail

php redis 学习笔记

PHP操作redis Redis 安装 Window 下安装下载地址：https://github.com/dmajkic/redis/downloads。 ...

PHP 阅读 84万 40 分钟阅读 2018-08-29 09:57

Redis 安装

Window 下安装
下载地址：https://github.com/dmajkic/redis/downloads。

下载到的Redis支持32bit和64bit。根据自己实际情况选择，将64bit的内容cp到自定义盘符安装目录取名redis。如 C:\reids

打开一个cmd窗口使用cd命令切换目录到 C:\redis 运行

redis-server.exe redis.conf

。Windows PowerShell

./redis-server.exe redis.conf

前面加 ./

如果想方便的话，可以把redis的路径加到系统的环境变量里，这样就省得再输路径了，后面的那个redis.conf可以省略，如果省略，会启用默认的。输入之后，会显示如下界面：

这时候另启一个cmd窗口，原来的不要关闭，不然就无法访问服务端了。

切换到redis目录下运行

redis-cli.exe -h 127.0.0.1 -p 6379

Windows PowerShell 前面加 ./ 。
设置键值对 set myKey abc
取出键值对 get myKey

Linux 下安装
下载地址：http://www.redis.net.cn/download/，下载最新文档版本。

本教程使用的最新文档版本为 2.8.17，下载并安装：

$ wget http://download.redis.io/releases/redis-2.8.17.tar.gz
$ tar xzf redis-2.8.17.tar.gz
$ cd redis-2.8.17
$ make

make完后 redis-2.8.17目录下会出现编译后的redis服务程序redis-server,还有用于测试的客户端程序redis-cli

下面启动redis服务.

$ ./redis-server

注意这种方式启动redis 使用的是默认配置。也可以通过启动参数告诉redis使用指定配置文件使用下面命令启动。

$ ./redis-server redis.conf

redis.conf是一个默认的配置文件。我们可以根据需要使用自己的配置文件。

启动redis服务进程后，就可以使用测试客户端程序redis-cli和redis服务交互了。比如：

$ ./redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

Ubuntu 下安装
在 Ubuntu 系统安装 Redi 可以使用以下命令:

$sudo apt-get update
$sudo apt-get install redis-server

启动 Redis

$redis-server

查看 redis 是否启动？

$redis-cli

以上命令将打开以下终端：

redis 127.0.0.1:6379>

127.0.0.1 是本机 IP ，6379 是 redis 服务端口。现在我们输入 PING 命令。

redis 127.0.0.1:6379> ping
PONG

以上说明我们已经成功安装了redis。
Redis 安装_redis教程

php处理redis

connect 实例连接到一个Redis

描述：实例连接到一个Redis.
参数：host: string，port: int
返回值：BOOL 成功返回：TRUE;失败返回：FALSE
示例：

<?php  
$redis = new redis();  
$result = $redis->connect('127.0.0.1', 6379);  
var_dump($result); //结果：bool(true)

set 设置key和value的值

描述：设置key和value的值
参数：Key Value
返回值：BOOL 成功返回：TRUE;失败返回：FALSE
示例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$result = $redis->set('test',"11111111111");  
var_dump($result);    //结果：bool(true)

get 获取有关指定键的值

描述：获取有关指定键的值
参数：key
返回值：string或BOOL 如果键不存在，则返回 FALSE。否则，返回指定键对应的value值。
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$result = $redis->get('test');  
var_dump($result);   //结果：string(11) "11111111111"

delete 删除指定的键

描述：删除指定的键
参数：一个键，或不确定数目的参数，每一个关键的数组：key1 key2 key3 … keyN
返回值：删除的项数
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->set('test',"1111111111111");  
echo $redis->get('test');   //结果：1111111111111  
$redis->delete('test');  
var_dump($redis->get('test'));  //结果：bool(false)

setnx 如果在数据库中不存在该键，设置关键值参数

描述：如果在数据库中不存在该键，设置关键值参数
参数：key value
返回值：BOOL 成功返回：TRUE;失败返回：FALSE
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->set('test',"1111111111111");  
$redis->setnx('test',"22222222");  
echo $redis->get('test');  //结果：1111111111111  
$redis->delete('test');  
$redis->setnx('test',"22222222");  
echo $redis->get('test');  //结果：22222222

exists 验证指定的键是否存在

描述：验证指定的键是否存在
参数key
返回值：Bool 成功返回：TRUE;失败返回：FALSE
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->set('test',"1111111111111");  
var_dump($redis->exists('test'));  //结果：bool(true)

incr 数字递增存储键值键

描述：数字递增存储键值键.
参数：key value：将被添加到键的值
返回值：INT the new value
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->set('test',"123");  
var_dump($redis->incr("test"));  //结果：int(124)  
var_dump($redis->incr("test"));  //结果：int(125)

decr 数字递减存储键值

描述：数字递减存储键值。
参数：key value：将被添加到键的值
返回值：INT the new value
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->set('test',"123");  
var_dump($redis->decr("test"));  //结果：int(122)  
var_dump($redis->decr("test"));  //结果：int(121)

getMultiple 取得所有指定键的值

描述：取得所有指定键的值。如果一个或多个键不存在，该数组中该键的值为假
参数：其中包含键值的列表数组
返回值：返回包含所有键的值的数组
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->set('test1',"1");  
$redis->set('test2',"2");  
$result = $redis->getMultiple(array('test1','test2'));  
print_r($result);   //结果：Array ( [0] => 1 [1] => 2 )

lpush 由列表头部添加字符串值

描述：由列表头部添加字符串值。如果不存在该键则创建该列表。如果该键存在，而且不是一个列表，返回FALSE。
参数：key,value
返回值：成功返回数组长度，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
var_dump($redis->lpush("test","111"));   //结果：int(1)  
var_dump($redis->lpush("test","222"));   //结果：int(2)

rpush 由列表尾部添加字符串值

描述：由列表尾部添加字符串值。如果不存在该键则创建该列表。如果该键存在，而且不是一个列表，返回FALSE。
参数：key,value
返回值：成功返回数组长度，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
var_dump($redis->lpush("test","111"));   //结果：int(1)  
var_dump($redis->lpush("test","222"));   //结果：int(2)  
var_dump($redis->rpush("test","333"));   //结果：int(3)  
var_dump($redis->rpush("test","444"));   //结果：int(4)

lpop 返回和移除列表的第一个元素

描述：返回和移除列表的第一个元素
参数：key
返回值：成功返回第一个元素的值，失败返回false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->lpush("test","111");  
$redis->lpush("test","222");  
$redis->rpush("test","333");  
$redis->rpush("test","444");  
var_dump($redis->lpop("test"));  //结果：string(3) "222"

lsize llen 返回的列表的长度

描述：返回的列表的长度。如果列表不存在或为空，该命令返回[BLUE]0[/BLUE]。如果该键不是列表，该命令返回。
参数：Key
返回值：成功返回数组长度，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->lpush("test","111");  
$redis->lpush("test","222");  
$redis->rpush("test","333");  
$redis->rpush("test","444");  
var_dump($redis->lsize("test"));  //结果：int(4)

lget 返回指定键存储在列表中指定的元素

描述：返回指定键存储在列表中指定的元素。 0第一个元素，1第二个… -1最后一个元素，-2的倒数第二…错误的索引或键不指向列表则返回FALSE。
参数：key index
返回值：成功返回指定元素的值，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->lpush("test","111");  
$redis->lpush("test","222");  
$redis->rpush("test","333");  
$redis->rpush("test","444");  
var_dump($redis->lget("test",3));  //结果：string(3) "444"

lset 为列表指定的索引赋新的值

描述：为列表指定的索引赋新的值,若不存在该索引返回false.
参数：key index value
返回值：成功返回true,失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->lpush("test","111");  
$redis->lpush("test","222");  
var_dump($redis->lget("test",1));  //结果：string(3) "111"  
var_dump($redis->lset("test",1,"333"));  //结果：bool(true)  
var_dump($redis->lget("test",1));  //结果：string(3) "333"

lgetrange 返回在该区域中的指定键列表中开始到结束存储的指定元素

描述：返回在该区域中的指定键列表中开始到结束存储的指定元素，lGetRange(key, start, end)。0第一个元素，1第二个元素… -1最后一个元素，-2的倒数第二…
参数：key start end
返回值：成功返回查找的值，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->lpush("test","111");  
$redis->lpush("test","222");  
print_r($redis->lgetrange("test",0,-1));  //结果：Array ( [0] => 222 [1] => 111 )

lremove 从列表中从头部开始移除count个匹配的值

描述：从列表中从头部开始移除count个匹配的值。如果count为零，所有匹配的元素都被删除。如果count是负数，内容从尾部开始删除。
参数：key count value
返回值：成功返回删除的个数，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->lpush('test','a');  
$redis->lpush('test','b');  
$redis->lpush('test','c');  
$redis->rpush('test','a');  
print_r($redis->lgetrange('test', 0, -1)); //结果：Array ( [0] => c [1] => b [2] => a [3] => a )  
var_dump($redis->lremove('test','a',2));   //结果：int(2)  
print_r($redis->lgetrange('test', 0, -1)); //结果：Array ( [0] => c [1] => b )

sadd 为一个Key添加一个值

描述：为一个Key添加一个值。如果这个值已经在这个Key中，则返回FALSE。
参数：key value
返回值：成功返回true,失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
var_dump($redis->sadd('test','111'));   //结果：bool(true)  
var_dump($redis->sadd('test','333'));   //结果：bool(true)  
print_r($redis->sort('test')); //结果：Array ( [0] => 111 [1] => 333 )

sremove 删除Key中指定的value值

描述：删除Key中指定的value值
参数：key member
返回值：true or false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd('test','111');  
$redis->sadd('test','333');  
$redis->sremove('test','111');  
print_r($redis->sort('test'));    //结果：Array ( [0] => 333 )

smove 将Key1中的value移动到Key2中

描述：将Key1中的value移动到Key2中
参数：srcKey dstKey member
返回值：true or false
范例

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->delete('test1');  
$redis->sadd('test','111');  
$redis->sadd('test','333');  
$redis->sadd('test1','222');  
$redis->sadd('test1','444');  
$redis->smove('test',"test1",'111');  
print_r($redis->sort('test1'));    //结果：Array ( [0] => 111 [1] => 222 [2] => 444 )

scontains 检查集合中是否存在指定的值

描述：检查集合中是否存在指定的值。
参数：key value
返回值：true or false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd('test','111');  
$redis->sadd('test','112');  
$redis->sadd('test','113');  
var_dump($redis->scontains('test', '111')); //结果：bool(true)

ssize 返回集合中存储值的数量

描述：返回集合中存储值的数量
参数：key
返回值：成功返回数组个数，失败0
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd('test','111');  
$redis->sadd('test','112');  
echo $redis->ssize('test');   //结果：2

spop 随机移除并返回key中的一个值

描述：随机移除并返回key中的一个值
参数：key
返回值：成功返回删除的值，失败false
范例

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
var_dump($redis->spop("test"));  //结果：string(3) "333"

sinter 返回一个所有指定键的交集

描述：返回一个所有指定键的交集。如果只指定一个键，那么这个命令生成这个集合的成员。如果不存在某个键，则返回FALSE。
参数：key1, key2, keyN
返回值：成功返回数组交集，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
$redis->sadd("test1","111");  
$redis->sadd("test1","444");  
var_dump($redis->sinter("test","test1"));  //结果：array(1) { [0]=> string(3) "111" }

sinterstore 执行sInter命令并把结果储存到新建的变量中

描述：执行sInter命令并把结果储存到新建的变量中。
参数：
Key: dstkey, the key to store the diff into.
Keys: key1, key2… keyN. key1..keyN are intersected as in sInter.
返回值：成功返回，交集的个数，失败false
范例:

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
$redis->sadd("test1","111");  
$redis->sadd("test1","444");  
var_dump($redis->sinterstore('new',"test","test1"));  //结果：int(1)  
var_dump($redis->smembers('new'));  //结果:array(1) { [0]=> string(3) "111" }

sunion 返回一个所有指定键的并集

描述：返回一个所有指定键的并集
参数：Keys: key1, key2, … , keyN
返回值：成功返回合并后的集，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
$redis->sadd("test1","111");  
$redis->sadd("test1","444");  
print_r($redis->sunion("test","test1"));  //结果：Array ( [0] => 111 [1] => 222 [2] => 333 [3] => 444 )

sunionstore 执行sunion命令并把结果储存到新建的变量中

描述：执行sunion命令并把结果储存到新建的变量中。
参数：
Key: dstkey, the key to store the diff into.
Keys: key1, key2… keyN. key1..keyN are intersected as in sInter.
返回值：成功返回，交集的个数，失败false
范例:

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
$redis->sadd("test1","111");  
$redis->sadd("test1","444");  
var_dump($redis->sinterstore('new',"test","test1"));  //结果：int(4)  
print_r($redis->smembers('new'));  //结果:Array ( [0] => 111 [1] => 222 [2] => 333 [3] => 444 )

sdiff 返回第一个集合中存在并在其他所有集合中不存在的结果

描述：返回第一个集合中存在并在其他所有集合中不存在的结果
参数：Keys: key1, key2, … , keyN: Any number of keys corresponding to sets in redis.
返回值：成功返回数组，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
$redis->sadd("test1","111");  
$redis->sadd("test1","444");  
print_r($redis->sdiff("test","test1"));  //结果：Array ( [0] => 222 [1] => 333 )

sdiffstore 执行sdiff命令并把结果储存到新建的变量中

描述：执行sdiff命令并把结果储存到新建的变量中。
参数：
Key: dstkey, the key to store the diff into.
Keys: key1, key2, … , keyN: Any number of keys corresponding to sets in redis
返回值：成功返回数字，失败false
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
$redis->sadd("test","333");  
$redis->sadd("test1","111");  
$redis->sadd("test1","444");  
var_dump($redis->sdiffstore('new',"test","test1"));  //结果：int(2)  
print_r($redis->smembers('new'));  //结果:Array ( [0] => 222 [1] => 333 )

smembers sgetmembers 返回集合的内容

描述：返回集合的内容
参数：Key: key
返回值：An array of elements, the contents of the set.
范例：

<?php  
$redis = new redis();  
$redis->connect('127.0.0.1', 6379);  
$redis->delete('test');  
$redis->sadd("test","111");  
$redis->sadd("test","222");  
print_r($redis->smembers('test'));  //结果:Array ( [0] => 111 [1] => 222 )

Comments 评论区

广西河池市宜州市 2018-08-30 18:08

PHP中利用redis实现消息队列处理高并发请求

将请求存入redis
 
为了模拟多个用户的请求,使用一个for循环替代
 
//redis数据入队操作
$redis = new Redis();
$redis->connect('127.0.0.1',6379);
for($i=0;$i<50;$i++){
    try{
        $redis->LPUSH('click',rand(1000,5000));
    }catch(Exception $e){
        echo $e->getMessage();
    }
}
 
 
 
 
在后台进行数据处理
 
守护进程
 
 
 
//redis数据出队操作,从redis中将请求取出
$redis = new Redis();
$redis->pconnect('127.0.0.1',6379);
while(true){
    try{
        $value = $redis->LPOP('click');
        if(!$value){
            break;
        }
        //var_dump($value)."\n";
        /*
         *  利用$value进行逻辑和数据处理
         */
    }catch(Exception $e){
        echo $e->getMessage();
    }
}

广西河池市宜州市2018-08-30 18:09:43

//关于redis事务的案例
header("content-type:text/html;charset=utf-8");
$redis = new redis();
$redis->connect('localhost', 6379);
//$result = $redis->connect('localhost', 6379);

//$redis = Yii::app()->redis;
$redis->set("testName","33");
//$mywatchkey = $redis->get("mywatchkey");

$mywatchkey = $redis->get('testName');
//($test);exit;

$rob_total = 100;   //抢购数量
if($mywatchkey<$rob_total){
    $redis->watch("testName");
    $redis->multi();

    //设置延迟，方便测试效果。
    sleep(5);
    //插入抢购数据
    $redis->hSet("testName","user_id_".mt_rand(1, 9999),time());
    $redis->set("testName",$mywatchkey+1);
    $rob_result = $redis->exec();
    if($rob_result){
        $mywatchlist = $redis->hGetAll("testName");
        echo "抢购成功！<br/>";
        echo "剩余数量：".($rob_total-$mywatchkey-1)."<br/>";
        echo "用户列表：<pre>";
        var_dump($mywatchlist);
    }else{
        echo "手气不好，再抢购！";exit;
    }
}

广西河池市宜州市2018-08-30 18:17:30

先将商品库存存入队列：

<?php  
$store=1000;  //商品库存
$redis=new Redis();  
$result=$redis->connect('127.0.0.1',6379);  
$res=$redis->llen('goods_store');   

for($i=0; $i<$store; $i++){  
    $redis->lpush('goods_store',1);  
}  
echo $redis->llen('goods_store');  
?>

客户执行下单操作：

$redis=new Redis();  
$result=$redis->connect('127.0.0.1',6379);
$count = $redis->lpop('goods_store');
if(!$count){
    echo '抢购失败！';
    return;
}

#⁰

广西南宁市 2025-11-16 05:48

图片拖曳排序

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Drag and Drop Image Sorting</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            margin: 0;
            padding: 20px;
        }
        .container {
            display: flex;
            flex-wrap: wrap;
            gap: 10px;
        }
        .item {
            margin: 10px;
            cursor: grab;
            transition: transform 0.2s ease, opacity 0.2s ease;
        }
        .item img {
            width: 100px;
            height: 100px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
        }
        .dragging {
            opacity: 0.5;
            transform: scale(1.1);
        }
        .placeholder {
            width: 100px;
            height: 100px;
            border: 2px dashed #ccc;
            border-radius: 8px;
            background-color: #f9f9f9;
        }
        #order-info {
            margin-top: 20px;
            font-size: 16px;
            color: #333;
        }
    </style>
</head>
<body>
    <h1>Drag and Drop Image Sorting</h1>
    <div class="container">
        <div class="item" draggable="true" data-id="1"><img src="image1.jpg" alt="Image 1"></div>
        <div class="item" draggable="true" data-id="2"><img src="image2.jpg" alt="Image 2"></div>
        <div class="item" draggable="true" data-id="3"><img src="image3.jpg" alt="Image 3"></div>
        <div class="item" draggable="true" data-id="4"><img src="image4.jpg" alt="Image 4"></div>
    </div>
    <div id="order-info"></div>

    <script>
        const container = document.querySelector('.container');
        const orderInfo = document.getElementById('order-info');
        let dragItem = null;

        container.addEventListener('dragstart', function(e) {
            dragItem = e.target;
            setTimeout(() => {
                dragItem.classList.add('dragging');
            }, 0);
        });

        container.addEventListener('dragend', function(e) {
            dragItem.classList.remove('dragging');
            dragItem = null;
            updateOrderInfo();
        });

        container.addEventListener('dragover', function(e) {
            e.preventDefault();
            const afterElement = getDragAfterElement(container, e.clientX);
            const currentElement = document.querySelector('.dragging');
            if (afterElement == null) {
                container.appendChild(currentElement);
            } else {
                container.insertBefore(currentElement, afterElement);
            }
        });

        function getDragAfterElement(container, x) {
            const draggableElements = [...container.querySelectorAll('.item:not(.dragging)')];

            return draggableElements.reduce((closest, child) => {
                const box = child.getBoundingClientRect();
                const offset = x - box.left - box.width / 2;
                if (offset < 0 && offset > closest.offset) {
                    return { offset: offset, element: child };
                } else {
                    return closest;
                }
            }, { offset: Number.NEGATIVE_INFINITY }).element;
        }

        function updateOrderInfo() {
            const items = container.querySelectorAll('.item');
            const order = Array.from(items).map(item => item.getAttribute('data-id'));
            orderInfo.textContent = `Current Order: ${order.join(', ')}`;
        }

        // Initial order info
        updateOrderInfo();
    </script>
</body>
</html>

广西南宁市2025-11-16 06:15:46

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>图片拖曳排序</title>
  
  <style>
    /* 基础样式与变量 */
    :root {
      --primary: #3B82F6;
      --secondary: #10B981;
      --neutral: #64748B;
      --gray-100: #F3F4F6;
      --gray-600: #4B5563;
      --gray-800: #1F2937;
      --black-60: rgba(0, 0, 0, 0.6);
      --white-80: rgba(255, 255, 255, 0.8);
    }
    
    * {
      margin: 0;
      padding: 0;
      box-sizing: border-box;
      font-family: 'Inter', sans-serif;
    }
    
    body {
      background-color: var(--gray-100);
      min-height: 100vh;
      padding: 20px;
    }
    
    .container {
      max-width: 1200px;
      margin: 0 auto;
      padding: 20px 16px;
    }
    
    header {
      text-align: center;
      margin-bottom: 32px;
    }
    
    h1 {
      font-size: clamp(1.8rem, 4vw, 2.5rem);
      font-weight: bold;
      color: var(--gray-800);
      margin-bottom: 8px;
    }
    
    header p {
      color: var(--neutral);
      font-size: 1.125rem;
    }
    
    /* 图片画廊样式 */
    #imageGallery {
      display: grid;
      grid-template-columns: 1fr;
      gap: 24px;
      margin-bottom: 40px;
    }
    
    @media (min-width: 640px) {
      #imageGallery {
        grid-template-columns: repeat(2, 1fr);
      }
    }
    
    @media (min-width: 768px) {
      #imageGallery {
        grid-template-columns: repeat(3, 1fr);
      }
    }
    
    @media (min-width: 1024px) {
      #imageGallery {
        grid-template-columns: repeat(4, 1fr);
      }
    }
    
    .image-container {
      position: relative;
      overflow: hidden;
      border-radius: 8px;
      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
      transition: all 0.3s ease;
      cursor: move;
    }
    
    .image-container:hover {
      box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
    }
    
    .image-container img {
      width: 100%;
      height: 192px;
      object-fit: cover;
    }
    
    .image-container .caption {
      position: absolute;
      bottom: 0;
      left: 0;
      right: 0;
      background-color: var(--black-60);
      color: white;
      padding: 8px;
      font-size: 0.875rem;
    }
    
    .image-container .drag-icon {
      position: absolute;
      top: 8px;
      right: 8px;
      background-color: var(--white-80);
      border-radius: 50%;
      padding: 4px;
    }
    
    /* 拖放相关样式 */
    .drag-placeholder {
      background-color: rgba(59, 130, 246, 0.2);
      border: 2px dashed var(--primary);
      border-radius: 8px;
    }
    
    .drag-active {
      opacity: 0.5;
      transform: scale(0.95);
      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
    }
    
    /* 顺序显示区域 */
    .order-display {
      background-color: white;
      padding: 24px;
      border-radius: 8px;
      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
    }
    
    .order-display h2 {
      font-size: 1.25rem;
      font-weight: 600;
      margin-bottom: 16px;
      color: var(--gray-800);
    }
    
    .order-display p {
      color: var(--gray-600);
      line-height: 1.5;
    }
  </style>
</head>
<body>
  <div class="container">
    <header>
      <h1>图片拖曳排序</h1>
      <p>拖放图片可以重新排列它们的顺序</p>
    </header>
    
    <div id="imageGallery">
      <!-- 图片将通过JavaScript动态加载 -->
    </div>
    
    <div class="order-display">
      <h2>当前顺序</h2>
      <p id="orderOutput">拖动图片后将显示新的顺序</p>
    </div>
  </div>

  <script>
    // 示例图片数据
    const images = [
      { id: 1, url: 'https://picsum.photos/seed/img1/400/300', alt: '风景图片 1' },
      { id: 2, url: 'https://picsum.photos/seed/img2/400/300', alt: '风景图片 2' },
      { id: 3, url: 'https://picsum.photos/seed/img3/400/300', alt: '风景图片 3' },
      { id: 4, url: 'https://picsum.photos/seed/img4/400/300', alt: '风景图片 4' },
      { id: 5, url: 'https://picsum.photos/seed/img5/400/300', alt: '风景图片 5' },
      { id: 6, url: 'https://picsum.photos/seed/img6/400/300', alt: '风景图片 6' },
      { id: 7, url: 'https://picsum.photos/seed/img7/400/300', alt: '风景图片 7' },
      { id: 8, url: 'https://picsum.photos/seed/img8/400/300', alt: '风景图片 8' }
    ];

    const gallery = document.getElementById('imageGallery');
    const orderOutput = document.getElementById('orderOutput');
    let draggedItem = null;

    // 初始化画廊
    function initGallery() {
      images.forEach(img => addImageToGallery(img));
      updateOrderDisplay();
    }

    // 添加图片到画廊
    function addImageToGallery(image) {
      const div = document.createElement('div');
      div.className = 'image-container';
      div.draggable = true;
      div.dataset.id = image.id;
      
      // 用简单符号替代Font Awesome图标
      div.innerHTML = `
        <img src="${image.url}" alt="${image.alt}">
        <div class="caption">${image.alt}</div>
        <div class="drag-icon">↔</div>
      `;
      
      // 添加拖放事件监听
      div.addEventListener('dragstart', handleDragStart);
      div.addEventListener('dragover', handleDragOver);
      div.addEventListener('dragenter', handleDragEnter);
      div.addEventListener('dragleave', handleDragLeave);
      div.addEventListener('drop', handleDrop);
      div.addEventListener('dragend', handleDragEnd);
      
      gallery.appendChild(div);
    }

    // 拖放事件处理函数
    function handleDragStart(e) {
      draggedItem = this;
      
      // 添加拖动时的视觉效果
      setTimeout(() => {
        this.classList.add('drag-active');
      }, 0);
      
      // 设置拖动数据
      e.dataTransfer.setData('text/plain', this.dataset.id);
    }

    function handleDragOver(e) {
      e.preventDefault(); // 允许放置
    }

    function handleDragEnter(e) {
      e.preventDefault();
      if (this !== draggedItem) {
        this.classList.add('drag-placeholder');
      }
    }

    function handleDragLeave() {
      this.classList.remove('drag-placeholder');
    }

    function handleDrop(e) {
      e.preventDefault();
      this.classList.remove('drag-placeholder');
      
      if (this !== draggedItem) {
        // 获取所有图片容器
        const children = Array.from(gallery.children);
        const draggedIndex = children.indexOf(draggedItem);
        const dropIndex = children.indexOf(this);
        
        // 重新排列图片
        if (draggedIndex < dropIndex) {
          gallery.insertBefore(draggedItem, this.nextSibling);
        } else {
          gallery.insertBefore(draggedItem, this);
        }
        
        // 更新顺序显示
        updateOrderDisplay();
      }
    }

    function handleDragEnd() {
      // 移除所有拖动相关的类
      this.classList.remove('drag-active');
      Array.from(gallery.children).forEach(child => {
        child.classList.remove('drag-placeholder');
      });
    }

    // 更新顺序显示
    function updateOrderDisplay() {
      const order = Array.from(gallery.children).map(item => item.dataset.id);
      orderOutput.textContent = `图片ID顺序: ${order.join(' → ')}`;
    }

    // 初始化
    document.addEventListener('DOMContentLoaded', initGallery);
  </script>
</body>
</html>

广西南宁市2025-11-16 08:12:24

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Image Sorting with Drag and Arrows</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            margin: 0;
            padding: 20px;
        }
        .container {
            display: flex;
            align-items: center;
            gap: 10px;
        }
        .item {
            margin: 10px;
            cursor: grab;
            transition: transform 0.3s ease;
        }
        .item img {
            width: 100px;
            height: 100px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
        }
        .arrow {
            font-size: 24px;
            cursor: pointer;
            user-select: none;
        }
        #order-info {
            margin-top: 20px;
            font-size: 16px;
            color: #333;
        }
        .item.dragging {
            opacity: 0.5;
        }
    </style>
</head>
<body>
    <h1>Image Sorting with Drag and Arrows</h1>
    <div class="container">
        <div class="arrow" id="left-arrow">◀</div>
        <div class="item" data-id="1" draggable="true"><img src="image1.jpg" alt="Image 1"></div>
        <div class="item" data-id="2" draggable="true"><img src="image2.jpg" alt="Image 2"></div>
        <div class="item" data-id="3" draggable="true"><img src="image3.jpg" alt="Image 3"></div>
        <div class="item" data-id="4" draggable="true"><img src="image4.jpg" alt="Image 4"></div>
        <div class="arrow" id="right-arrow">▶</div>
    </div>
    <div id="order-info"></div>

    <script>
        const container = document.querySelector('.container');
        const leftArrow = document.getElementById('left-arrow');
        const rightArrow = document.getElementById('right-arrow');
        const orderInfo = document.getElementById('order-info');

        let currentIndex = 0;

        // Function to move the current item to the right
        function moveRight() {
            const items = container.querySelectorAll('.item');
            if (currentIndex < items.length - 1) {
                const item = items[currentIndex];
                const nextItem = items[currentIndex + 1];
                container.insertBefore(item, nextItem.nextSibling);
                currentIndex++;
            } else {
                currentIndex = 0;
                moveRight();
            }
            updateOrderInfo();
        }

        // Function to move the current item to the left
        function moveLeft() {
            const items = container.querySelectorAll('.item');
            if (currentIndex > 0) {
                const item = items[currentIndex];
                const prevItem = items[currentIndex - 1];
                container.insertBefore(item, prevItem);
                currentIndex--;
            } else {
                currentIndex = items.length - 1;
                moveLeft();
            }
            updateOrderInfo();
        }

        // Function to update the order info
        function updateOrderInfo() {
            const items = container.querySelectorAll('.item');
            const order = Array.from(items).map(item => item.getAttribute('data-id'));
            orderInfo.textContent = `Current Order: ${order.join(', ')}`;
        }

        // Add drag and drop functionality
        let draggedItem = null;

        container.addEventListener('dragstart', (e) => {
            if (e.target.classList.contains('item')) {
                draggedItem = e.target;
                e.target.classList.add('dragging');
            }
        });

        container.addEventListener('dragover', (e) => {
            e.preventDefault();
            const targetItem = e.target.closest('.item');
            if (targetItem && targetItem !== draggedItem) {
                const items = Array.from(container.querySelectorAll('.item'));
                const draggedIndex = items.indexOf(draggedItem);
                const targetIndex = items.indexOf(targetItem);

                if (draggedIndex < targetIndex) {
                    container.insertBefore(draggedItem, targetItem.nextSibling);
                } else {
                    container.insertBefore(draggedItem, targetItem);
                }
            }
        });

        container.addEventListener('dragend', (e) => {
            if (e.target.classList.contains('item')) {
                e.target.classList.remove('dragging');
                updateOrderInfo();
            }
        });

        // Add arrow click events
        leftArrow.addEventListener('click', moveLeft);
        rightArrow.addEventListener('click', moveRight);

        // Update order info initially
        updateOrderInfo();
    </script>
</body>
</html>

广西南宁市2025-11-16 08:17:17

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Image Sorting with Drag and Arrows</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            margin: 0;
            padding: 20px;
        }
        .container {
            display: flex;
            align-items: center;
            gap: 10px;
        }
        .item {
            margin: 10px;
            cursor: grab;
            transition: transform 0.3s ease;
        }
        .item img {
            width: 100px;
            height: 100px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
        }
        .arrow {
            font-size: 24px;
            cursor: pointer;
            user-select: none;
        }
        #order-info {
            margin-top: 20px;
            font-size: 16px;
            color: #333;
        }
        .item.dragging {
            opacity: 0.5;
        }
        .item.selected {
            border: 2px solid #007bff;
        }
    </style>
</head>
<body>
    <h1>Image Sorting with Drag and Arrows</h1>
    <div class="container">
        <div class="arrow" id="left-arrow">◀</div>
        <div class="item" data-id="1" draggable="true"><img src="image1.jpg" alt="Image 1"></div>
        <div class="item" data-id="2" draggable="true"><img src="image2.jpg" alt="Image 2"></div>
        <div class="item" data-id="3" draggable="true"><img src="image3.jpg" alt="Image 3"></div>
        <div class="item" data-id="4" draggable="true"><img src="image4.jpg" alt="Image 4"></div>
        <div class="item" data-id="5" draggable="true"><img src="image5.jpg" alt="Image 5"></div>
        <div class="arrow" id="right-arrow">▶</div>
    </div>
    <div id="order-info"></div>

    <script>
        const container = document.querySelector('.container');
        const leftArrow = document.getElementById('left-arrow');
        const rightArrow = document.getElementById('right-arrow');
        const orderInfo = document.getElementById('order-info');

        let selectedItem = null;

        // Function to move the selected item to the right
        function moveRight() {
            if (selectedItem) {
                const items = container.querySelectorAll('.item');
                const index = Array.from(items).indexOf(selectedItem);
                if (index < items.length - 1) {
                    container.insertBefore(selectedItem, items[index + 1].nextSibling);
                }
                updateOrderInfo();
            }
        }

        // Function to move the selected item to the left
        function moveLeft() {
            if (selectedItem) {
                const items = container.querySelectorAll('.item');
                const index = Array.from(items).indexOf(selectedItem);
                if (index > 0) {
                    container.insertBefore(selectedItem, items[index - 1]);
                }
                updateOrderInfo();
            }
        }

        // Function to update the order info
        function updateOrderInfo() {
            const items = container.querySelectorAll('.item');
            const order = Array.from(items).map(item => item.getAttribute('data-id'));
            orderInfo.textContent = `Current Order: ${order.join(', ')}`;
        }

        // Add click event to select an item
        container.addEventListener('click', (e) => {
            const clickedItem = e.target.closest('.item');
            if (clickedItem) {
                if (selectedItem) {
                    selectedItem.classList.remove('selected');
                }
                selectedItem = clickedItem;
                selectedItem.classList.add('selected');
            }
        });

        // Add drag and drop functionality
        let draggedItem = null;

        container.addEventListener('dragstart', (e) => {
            if (e.target.classList.contains('item')) {
                draggedItem = e.target;
                e.target.classList.add('dragging');
            }
        });

        container.addEventListener('dragover', (e) => {
            e.preventDefault();
            const targetItem = e.target.closest('.item');
            if (targetItem && targetItem !== draggedItem) {
                const items = Array.from(container.querySelectorAll('.item'));
                const draggedIndex = items.indexOf(draggedItem);
                const targetIndex = items.indexOf(targetItem);

                if (draggedIndex < targetIndex) {
                    container.insertBefore(draggedItem, targetItem.nextSibling);
                } else {
                    container.insertBefore(draggedItem, targetItem);
                }
            }
        });

        container.addEventListener('dragend', (e) => {
            if (e.target.classList.contains('item')) {
                e.target.classList.remove('dragging');
                updateOrderInfo();
            }
        });

        // Add arrow click events
        leftArrow.addEventListener('click', moveLeft);
        rightArrow.addEventListener('click', moveRight);

        // Update order info initially
        updateOrderInfo();
    </script>
</body>
</html>

#⁰

广西南宁市 2025-11-16 09:06

免责声明：本站无法保证用户张贴内容的可靠性，投资有风险，健康问题请遵医嘱。

广西南宁市2025-11-16 09:07:19

雨后夜骑，享受夜的美丽，静静欣赏圆圆的月亮

广西南宁市2025-11-16 09:14:54

广西南宁市2025-11-16 09:40:34

广西南宁市2025-11-16 09:43:11

广西南宁市2025-11-18 19:14:55

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>选择文本自定义菜单</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            padding: 20px;
        }
        .custom-menu {
            position: fixed;
            background-color: #fff;
            border: 1px solid #ccc;
            padding: 10px;
            box-shadow: 0 0 5px rgba(0, 0, 0, 0.1);
            z-index: 1000;
        }
        .custom-menu div {
            cursor: pointer;
            padding: 5px;
        }
        .custom-menu div:hover {
            background-color: #f0f0f0;
        }
    </style>
</head>
<body>
    <p>这是一段示例文本，请选择其中的部分内容以查看自定义菜单。</p>

    <script>
        document.addEventListener('selectionchange', function () {
            const selection = window.getSelection();
            if (selection.toString().trim() !== '') {
                const range = selection.getRangeAt(0);
                const rect = range.getBoundingClientRect();

                // 移除已存在的菜单
                const existingMenu = document.querySelector('.custom-menu');
                if (existingMenu) {
                    document.body.removeChild(existingMenu);
                }

                // 创建自定义菜单
                const menu = document.createElement('div');
                menu.className = 'custom-menu';
                menu.style.left = `${rect.left + window.scrollX}px`;
                menu.style.top = `${rect.bottom + window.scrollY}px`;

                // 复制选项
                const copyOption = document.createElement('div');
                copyOption.textContent = '复制';
                copyOption.addEventListener('click', function () {
                    navigator.clipboard.writeText(selection.toString());
                    document.body.removeChild(menu);
                });

                // 分享选项
                const shareOption = document.createElement('div');
                shareOption.textContent = '分享';
                shareOption.addEventListener('click', function () {
                    alert('分享功能未实现');
                    document.body.removeChild(menu);
                });

                // 添加选项到菜单
                menu.appendChild(copyOption);
                menu.appendChild(shareOption);
                document.body.appendChild(menu);

                // 点击其他地方关闭菜单
                document.addEventListener('click', function () {
                    if (menu) {
                        document.body.removeChild(menu);
                    }
                }, { once: true });
            }
        });
    </script>
</body>
</html>

广西南宁市2025-11-20 03:20:09

#⁴传说：忘了在哪看到的了：明日花就特没职业素养，搭戏的是这几个老头，表情就特敷衍死鱼一样，碰见年轻帅哥就特投入。

只要不遇上松本一香，大概率出不了工伤

德田重男
出来赚钱的，还能挑客人：、：

工作缠身，GVH，来晚了，722
应该是gvh望月这部715吧

广西南宁市2025-11-20 03:21:00

广西南宁市2025-11-21 02:07:19

https://bujiwang.com/#new

广西南宁市2025-11-28 17:11:56

有个古早的软涩情系列叫action girls

广西南宁市2025-11-28 17:21:46

广西南宁市2025-11-28 18:00:15

广西南宁市2025-12-11 00:26:00

Anna Delos

广西2025-12-16 17:19:51

广西2025-12-22 09:27:43

#⁰

广西 2025-12-22 09:28

清朝条约全集
清朝条约全集.rar

广西南宁市2025-12-31 07:34:08

广西南宁市2026-01-08 04:47:46

NHDTA路286次裸の大陆特别编，2012的老番

广西南宁市2026-01-08 07:15:42

广西南宁市2026-01-08 08:59:52

广西南宁市2026-01-08 12:45:57

广西南宁市2026-01-08 15:00:44

#⁰

广西南宁市 2026-01-11 03:00

PUBG.PLUS 游戏地图

广西南宁市2026-01-11 08:32:49

广西南宁市2026-01-13 00:46:06

WAAA-325

广西2026-03-05 18:09:39

16K - 图片资源库

广西南宁市2026-03-08 07:19:23

EBOD街806号店铺的店员楪可怜

广西南宁市2026-03-08 07:21:19

广西南宁市2026-03-08 07:31:37

广西南宁市2026-03-08 07:33:19

广西南宁市2026-03-08 08:17:17

魔域小矮仙传奇

广西南宁市2026-03-08 08:18:47

广西南宁市2026-03-08 08:53:54

广西2026-03-10 11:43:02

司机是七森莉莉

广西2026-03-10 12:29:51

CAWD-940
2026年4月

#⁰

广西南宁市 2026-01-13 00:46

广西南宁市2026-01-13 01:30:22

#⁰

广西南宁市 2026-01-13 02:08

#⁰

广西南宁市 2026-01-13 02:15

#⁰

广西 2026-01-15 09:16

#⁰

广西南宁市 2026-01-18 05:17

497确实是巅峰油菜
ipzz有几部确实不错
现在都是无脑冲濑户环奈
桥本有菜枫カレン浅野こころ
桥本有菜小魔女教师 SSNI-497
枫可怜媚药觉醒绝顶共处一室NTR IPX-811‌
浅野心什么样的命令都完全同意的可爱的M女仆 SONE-855

广西南宁市2026-01-18 05:18:17

广西南宁市2026-01-18 05:39:12

我掐指一算，感觉是YRH-097星云的三位女菩萨

广西南宁市2026-01-18 08:15:55

广西2026-01-22 14:15:05

#⁰

广西南宁市 2026-01-31 01:32

#⁰

广西南宁市 2026-02-04 10:42

SSIS-091
gif的封面明明是SSNI438

广西南宁市2026-02-05 19:23:54

于是会心一战，梗消失在空中这个形容很文艺
SSIS-091
优衣库有一件联名的T恤就是猫女，背后是她的念能力“玩具修理者”，我可喜欢了
那你要帮漫画里被断头的家伙狠狠报仇吗
gif的封面明明是SSNI438
原来架乃由罗已经退役了吗……
架乃由罗相当可爱，是我喜欢的演员，虽然有点五短，但是动作都很有劲
哈哈，的确看过猎人的人感觉很有画面感