Tailwind CSS 在任何特定于框架/技术的UI开发中都有发展趋势。我发现了一些最好的使用基于 tailwind CSS的组件库，您可以在其中直接使用tailwind自定义组件。

* Daisy UI：Daisy为您提供特殊类，如“btn”、“card”等。这些特殊类是其他顺风工具类的组合。
* Flowbite：Flowbite 是一组免费的开源 Figma UI 组件和页面，旨在与 Tailwind CSS 的实用程序类集成。
* WindUI：像 Flowbite 但更好。这个组件库确实支持很多框架技术，所以只需复制和粘贴即可。
* Material Tailwind：非常漂亮且专业的组件库。不像之前的其他组件库......


本文翻译自：

https://dev.to/pruthvidarji1993/tailwind-web-components-293l

原作者：Pruthvi Darji



Tailwind CSS 在任何特定于框架/技术的UI开发中都有发展趋势。我发现了一些最好的使用基于 tailwind CSS的组件库，您可以在其中直接使用tailwind自定义组件。

Tailwind CSS 相关的组件库


## 一、引言

在前端开发中，数组是一种常见且重要的数据结构。数组提供了许多便捷的方法来操作和处理其中的数据。本文将简单介绍前端中数组常用的API，包括添加、删除、截取、合并、转换等操作。

## 二、push() 方法和 pop() 方法
push()方法用于向数组末尾添加一个或多个元素，并返回修改后的数组的新长度。

    const fruits = ['苹果', '香蕉'];
    const res = fruits.push('橘子', '西瓜');
    console.log(fruits);  //[ '苹果', '香蕉', '橘子', '西瓜' ]
    console.log(res);     //4

pop() 方法用于删除并返回数组的最后一个元素。

    const fruits = ['苹果', '香蕉', '橘子'];
    const lastFruit = fruits.pop();
    console.log(fruits);     // ['苹果', '香蕉']
    console.log(lastFruit); //橘子

## 三、shift() 方法和 unshift() 方法

shift() 方法用于删除并返回数组的第一个元素。

    const fruits = ['苹果', '香蕉', '橘子'];
    const firstFruit = fruits.shift();
    console.log(fruits);      //[ '香蕉', '橘子' ]
    console.log(firstFruit);  //苹果

unshift() 方法用于向数组的开头添加一个或多个元素，并返回修改后的数组的新长度。

    const fruits = ['苹果', '香蕉'];
    const newLength = fruits.unshift('橘子', '西瓜');
    console.log(fruits);        //[ '橘子', '西瓜', '苹果', '香蕉' ]
    console.log(newLength); //4

## 四、slice() 方法
slice() 方法用于从数组中截取指定位置的元素，返回一个新的数组。
语法是：array.slice(start, end)，其中，start和end都是可选参数，表示选取的元素的起始位置和结束位置。如果不传入参数则默认选取整个数组。该方法返回的是一个新的数组，包含从start到end（不包括end）的元素。

    const names = ['张三', '李四', '王五', '赵六'];
    const slicedNames = names.slice(1, 3);
    const slicedNames1 = names.slice();
    const slicedNames2 = names.slice(0);
    const slicedNames3 = names.slice(2);
    const slicedNames4 = names.slice(3);
    const slicedNames5 = names.slice(4);

    //slice不改变原数组
    console.log(names);          //[ '张三', '李四', '王五', '赵六' ] 
    console.log(slicedNames);  //[ '李四', '王五' ]
    console.log(slicedNames1); //[ '张三', '李四', '王五', '赵六' ] 
    console.log(slicedNames2); //[ '张三', '李四', '王五', '赵六' ] 
    console.log(slicedNames3); //[ '王五', '赵六' ]
    console.log(slicedNames4); //[ '赵六' ]
    console.log(slicedNames5); //[] 参数大于等于4时就输出空数组

## 五、splice() 方法
splice() 方法用于从数组中删除、替换或添加元素，并返回被删除的元素组成的数组，它会直接修改原数组。
语法：array.splice(start, deleteCount, item1, item2, ...)
其中，start表示要修改的起始位置，deleteCount表示要删除的元素个数，item1、item2等表示要添加的元素。如果deleteCount为0，则表示只添加元素，不删除元素。

    //实现删除
    let arr = [1,2,3,4,5]
    console.log(arr.splice(0,2));  //[ 1, 2 ] 返回被删除的元素
    console.log(arr);  //[ 3, 4, 5 ]   该方法会改变原数组

    //实现添加
    let arr2 = [1,2,3,4,5]
    console.log(arr2.splice(1,0,666,777)); //[] 返回空数组，没有删除元素
    console.log(arr2);  //[ 1, 666, 777, 2, 3, 4, 5 ]  原数组改变了

    // 实现替换
    let arr3 = [1,2,3,4,5]
    console.log(arr3.splice(2,1,"aaa","bbb")); //[ 3 ]  返回被删除的一个元素
    console.log(arr3);  //[ 1, 2, 'aaa', 'bbb', 4, 5 ]  可以添加字符串

    let arr4 = [1,2,3,4,5]
    console.log(arr4.splice(1,4,666)); //[ 2, 3, 4, 5 ]  返回被删除的四个元素
    console.log(arr4);  //[ 1, 666 ]

## 六、join() 方法
join() 方法用于将数组中的所有元素以指定的分隔符连接成一个字符串。

    const fruits = ['苹果', '香蕉', '橘子'];
    const joinedString = fruits.join(',');
    console.log(fruits);  //[ '苹果', '香蕉', '橘子' ]
    console.log(joinedString); //苹果,香蕉,橘子

## 七、concat() 方法

    concat() 方法用于合并两个或多个数组，返回一个新的数组。
    const fruits1 = ['苹果', '橘子'];
    const fruits2 = ['西瓜', '蓝莓'];
    const combinedFruits = fruits1.concat(fruits2);
    console.log(combinedFruits); //[ '苹果', '橘子', '西瓜', '蓝莓' ]

## 八、forEach() 方法
forEach() 方法用于对数组中的每个元素执行一个回调函数。

    const fruits = ['火龙果', '蓝莓', '西瓜', '葡萄'];
    fruits.forEach(fruit => {
    console.log(fruit); //火龙果 蓝莓 西瓜 葡萄
    });

## 九、map() 方法
map() 方法用于对数组中的每个元素执行一个回调函数，并返回一个新的数组，新数组中的元素为回调函数的返回值。

    const numbers = [1, 2, 3, 4, 5];
    const squaredNumbers = numbers.map(num => num * num);
    console.log(squaredNumbers); //[ 1, 4, 9, 16, 25 ]

## 十、filter() 方法
filter() 方法用于筛选、过滤数组中符合条件的元素，并返回一个新的数组。
    //筛选出偶数
    const numbers = [1, 2, 3, 4, 5];
    const evenNumbers = numbers.filter(num => num % 2 === 0);
    console.log(evenNumbers); //[ 2, 4 ]

## 十一、reduce() 方法
reduce() 方法是数组对象的一个方法，用于将数组中的所有元素按照指定的规则进行归并计算，返回一个最终值。

语法：`array.reduce(callback, initialValue)`

该方法接收两个参数，第一个参数是一个回调函数，第二个参数是一个初始值。回调函数中可以接收四个参数，分别是：

* accumulator：累加器，用于存储上一次回调函数的返回值或初始值。
* currentValue：当前元素的值。
* currentIndex：当前元素的索引。
* array：数组对象本身。

initialValue是初始值，可选参数。

    const arr = [1, 2, 3, 4, 5];
    const sum = arr.reduce((acc, num) => {
    return acc + num
    }, 10);
    console.log(sum); //25
    //如果初始值是设为0，则输出15

## 十二、fill() 方法
JS中的fill方法可以填充一个数组中的所有元素，它会直接修改原数组。

语法：array.fill(value, start, end)

其中，value表示要填充的值，start和end表示要填充的起始位置和结束位置。如果不传入start和end，则默认填充整个数组。该方法返回的是被修改后的原数组。

    let arr = [1, 2, 3, 4, 5];
    arr.fill(0);
    console.log(arr); // [0, 0, 0, 0, 0]

    //将数组中从位置2到位置4(不包括位置4)的元素都填充为6
    arr.fill(6, 2, 4);
    console.log(arr);  //[ 0, 0, 6, 6, 0 ]

## 十三、数组查找API
1.includes()方法

includes方法用于检查数组中是否包含某个元素，如果包含则返回 true，否则返回 false。
与 indexOf() 方法不同，includes() 方法不支持指定起始位置，它从数组的开头开始搜索。

    const fruits = ['苹果', '香蕉', '橘子', '西瓜', 1, 2, 3];
    console.log(fruits.includes('橘子')); //true
    console.log(fruits.includes('葡萄')); //false
    console.log(fruits.includes(3));      //true
    console.log(fruits.includes(4));      //false

2.indexOf()方法

需要注意的是，indexOf方法只会返回第一个匹配项的位置。如果数组中存在多个相同的元素，该方法只会返回第一个元素的位置。
此外，indexOf方法还可以接受一个可选的第二个参数，用于指定从哪个位置开始查找。

    const fruits = ['苹果', '蓝莓', '橘子', '西瓜', '葡萄'];
    console.log(fruits.indexOf('橘子', 1));  //2  返回元素下标
    console.log(fruits.indexOf('橘子', 3));  //-1  没有该元素
    const arr = [1,2,3,4,5,6,7,6,6,5];
    // 从下标6开始查找元素5
    console.log(arr.indexOf(5,6)); //9

3.lastIndexOf()()方法

lastIndexOf() 方法用于查找数组中某个元素最后一次出现的索引（位置），如果找到则返回该索引值，否则返回 -1。

    const fruits = ['火龙果', '橘子', '蓝莓', '西瓜', '葡萄', '橘子'];
    console.log(fruits.lastIndexOf('橘子')); //5
    console.log(fruits.lastIndexOf('柚子')); //-1

4.findIndex()方法

findIndex() 方法用于查找数组中满足条件的元素的索引，如果找到则返回该索引值，否则返回 -1。

    const arr = [1, 2, 3, 4, 5, 6];
    const index = arr.findIndex(num => num > 3);
    console.log(index);   //3  返回第一个符合条件的元素的下标
    const index2 = arr.findIndex(num => num > 10);
    console.log(index2); //-1  不存在符合条件的元素

## 十四、sort() 方法
sort() 方法用于对数组进行原地排序，会直接修改原始数组，而不会创建新的数组。默认情况下，它将数组元素视为字符串，并按照 Unicode 码点进行排序。但是，可以传入自定义的比较函数来实现基于其他规则的排序。

比较函数：比较函数接收两个参数，通常被称为 a 和 b，表示进行比较的两个元素。它应该返回一个负数、零或正数，表示 a 应该在 b 之前、与 b 相同位置还是在 b 之后。比较函数的返回值规则如下：

* 如果返回值小于 0，则 a 排在 b 前面。
* 如果返回值等于 0，则 a 和 b 的相对位置不变。
* 如果返回值大于 0，则 a 排在 b 后面。

例子：

    const arr = [3, 1, 5, 2, 4];
    arr.sort();
    console.log(arr);  //[1, 2, 3, 4, 5]

    //默认排序（按照 Unicode 码点排序）
    const arr = ['f', 'k', 'c', 'a', 'b'];
    arr.sort();
    console.log(arr);  //[ 'a', 'b', 'c', 'f', 'k' ]

    //使用比较函数进行自定义排序
    const arr = [10, 2, 66, 26, 13, 1];
    arr.sort((a, b) => a - b);
    console.log(arr);  //[ 1, 2, 10, 13, 26, 66 ]

    const arr = [10, 2, 66, 26, 13, 1];
    arr.sort((a, b) => b - a);
    console.log(arr);  //[ 66, 26, 13, 10, 2, 1 ]

## 十五、reverse() 方法
reverse() 方法用于反转数组中的元素顺序，即将数组元素进行逆序排列。

    const arr = [1, 2, 3, 4, 5];
    arr.reverse();
    console.log(arr); //[ 5, 4, 3, 2, 1 ]

## 十六、toString()和toLocaleString()方法
toString方法将数组转换为一个由数组元素组成的字符串，元素之间用逗号分隔。

    const arr = [1, 2, 3, 4, 5];
    console.log(arr.toString());  //1,2,3,4,5
    const arr2 = ['苹果', '蓝莓', '橘子', '西瓜', '葡萄'];
    const arr3 = ['a', 'null', 'b', 'c', 'undefined', 'd', 'e']
    console.log(arr2.toString());  //苹果,蓝莓,橘子,西瓜,葡萄
    console.log(arr3.toString());  //a,null,b,c,undefined,d,e

toLocaleString方法将数组转换为一个由数组元素组成的字符串，元素之间同样用逗号分隔，但是它会根据当前环境的语言和地区设置来决定元素的格式。

    //根据当前环境的语言和地区设置来决定元素的格式
    const arr = [123456.789, new Date()];
    //我补充写作的时间
    console.log(arr.toLocaleString()); //123,456.789,2023/5/29 07:57:19

    const arr2 = [1000, 2000, 3000];
    const str = arr2.toLocaleString();
    console.log(str); //1,000,2,000,3,000

## 十七、Array.from() 方法
Array.from() 是 JavaScript 中一个用于从类数组或可迭代对象创建新数组的静态方法。它接收一个可迭代对象或类数组的对象，并返回一个新的数组实例。
Array.from(iterable, mapFn, thisArg)

* iterable: 必需，一个可迭代对象或类似数组的对象，用于创建新的数组。
* mapFn (可选): 一个映射函数，用于对每个元素进行处理后返回新数组中的元素。
* thisArg (可选): 可选参数，执行 mapFn 函数时的 this 值。

例子：

    //使用类似数组的对象创建数组
    const obj = {
    0: "榴莲",
    1: "牛油果",
    2: "蓝莓",
    length: 3
    };
    const arr = Array.from(obj);
    console.log(arr);  //[ '榴莲', '牛油果', '蓝莓' ]

    //使用字符串创建数组
    const str = "Hello";
    const arr = Array.from(str);
    console.log(arr); //[ 'H', 'e', 'l', 'l', 'o' ]

    //使用映射函数处理数组元素
    const numbers = [1, 2, 3, 4, 5];
    const doubledNumbers = Array.from(numbers, num => num * 2);
    console.log(doubledNumbers); //[ 2, 4, 6, 8, 10 ]


## 十八、最后的话

本文介绍了前端中数组常用的 API，涵盖了添加、删除、截取、合并、转换等常见操作。熟练掌握这些方法可以提高一定的开发效率。在实际开发中，请根据具体需求选择适合的数组方法。
能力一般，水平有限，本文可能存在纰漏或错误，如有问题欢迎指正，感谢你阅读这篇文章，如果你觉得写得还行的话，不要忘记点赞、评论、收藏哦！祝生活愉快！

作者：牛哥说我不优雅

链接：https://juejin.cn/post/7237879664026615866

来源：稀土掘金

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

在前端开发中，数组是一种常见且重要的数据结构。数组提供了许多便捷的方法来操作和处理其中的数据。本文将简单介绍前端中数组常用的API，包括添加、删除、截取、合并、转换等操作。

JS中数组常用API总结，slice、splice、map、reduce、shift、filter、indexOf......

在Vue+element+Vite项目中设置 Tailwind CSS。

1. 请先创建一个新的Vite项目。最常见的方法是使用 Create Vite。

    npm init vue@latest

起好项目的名称，然后一路回车即可。

2. 安装 tailwindcss 及其对等依赖项，然后生成 `tailwind.config.js` 和 `postcss.config.js` 文件。


   npm install -D tailwindcss postcss autoprefixer
   npx tailwindcss init -p


3. 在 `tailwind.config.js` 文件中添加所有模板文件的路径。


    /** @type {import('tailwindcss').Config} */
    export default {
    content: [
        "./index.html",
        "./src/**/*.{vue,js,ts,jsx,tsx}",
    ],
    theme: {
        extend: {},
    },
    plugins: [],
    }


4. 将每个 Tailwind 层的 @tailwind 指令添加到您的 ./src/style/taiwind.css 文件中。


    @tailwind base;
    @tailwind components;
    @tailwind utilities;


5. 在main.js中添加`taiwind.css`的引用：

    import "./style/tailwind.css";

6. 使用 `npm run dev` 运行构建过程。

7. 开始使用 Tailwind 的实用程序类来设计您的内容。
 
`<h1 class="text-3xl font-bold underline">Hello world!</h1>`
   



你学会了吗？

在Vue+element+Vite项目中设置 Tailwind CSS。

Vue+element+Vite安装 Tailwind CSS

在Django中，路由由URL模式和视图函数组成。URL模式定义了URL的结构和匹配规则，而视图函数则定义了当URL匹配时要执行的代码逻辑。Django的路由系统允许你根据URL的不同部分进行模式匹配，并从URL中提取参数传递给视图函数。

    # myapp/urls.py

    from django.urls import path
    from . import views

    urlpatterns = [
        path('', views.home, name='home'),
        path('about/', views.about, name='about'),
        path('post/<int:post_id>/', views.post_detail, name='post_detail'),
    ]

在上面的示例中，我们定义了三个URL模式：

1. 空路径：path('') 将映射到 views.home 视图函数，表示应用程序的主页。
2. `about/`路径：path('about/') 将映射到 views.about 视图函数，表示关于页面。
3. `post/int:post_id/`路径：`path('post/<int:post_id>/')` 将映射到 `views.post_detail` 视图函数，并将URL中的post_id作为参数传递给该视图函数。这个URL模式使用了尖括号（< >）来标记参数部分，并指定了参数的类型为整数（int）。
在上述示例中，urlpatterns列表定义了应用程序的所有URL模式。每个URL模式由path函数定义，接受两个参数：第一个参数是URL模式的字符串表示，第二个参数是要调用的视图函数。你还可以为每个URL模式指定一个名称（name），以便在代码中引用它们。

通常，你需要在项目的主路由文件中包含应用程序的URL配置。例如，如果你的应用程序名为myapp，你需要在项目的主路由文件中包含以下内容：

    # project/urls.py

    from django.urls import include, path

    urlpatterns = [
        path('myapp/', include('myapp.urls')),
    ]

上述示例中，include函数用于将myapp/urls.py文件中定义的URL模式包含到主路由文件中。这样，当用户访问/myapp/路径时，Django将使用应用程序的URL配置来处理该请求。

这只是Django路由系统的基本介绍。Django还提供了其他高级功能，如正则表达式匹配、命名空间等。通过使用Django的路由系统，你可以轻松地定义URL模式，并将它们与相应的视图函数关联起来，从而构建功能完整的Web应用程序。

相关参考：

[Django URL调度器](https://docs.djangoproject.com/zh-hans/4.2/topics/http/urls/)


在Django中，路由由URL模式和视图函数组成。URL模式定义了URL的结构和匹配规则，而视图函数则定义了当URL匹配时要执行的代码逻辑。Django的路由系统允许你根据URL的不同部分进行模式匹配，并从URL中提取参数传递给视图函数。

Django 4.2 复习笔记(六)Django的路由

SQLAlchemy和Django都是流行的Python框架，用于处理数据库关系。虽然它们都提供了关系字段的概念，但在实现和使用上有一些不同点。以下是SQLAlchemy和Django关系字段之间的一些主要区别：

1. 定义语法：

    * SQLAlchemy：使用ORM（对象关系映射）方式，关系字段通常在模型类中定义为类属性。常见的关系字段包括relationship、backref等。
    * Django：使用Django的模型定义语法，关系字段作为模型类的字段进行定义，使用特定的关系字段类（如ForeignKey、ManyToManyField）来表示不同的关系类型。

2. 引用和访问：
   
    * SQLAlchemy：关系字段通常使用对象引用来表示关联关系。通过关系字段可以在模型之间导航和访问相关对象。
    * Django：关系字段通常使用数据库的引用机制（如外键）来表示关联关系。通过关系字段可以在模型之间导航和访问相关对象。Django还提供了ORM的查询API来执行复杂的数据库查询操作。
  
3. 外键约束：

    * SQLAlchemy：在定义关系字段时，可以选择是否启用外键约束。外键约束可以确保数据库中的关联完整性。
    * Django：Django自动为关系字段创建外键约束，并通过数据库的外键机制来维护关联完整性。
  

4. 数据库支持：
   
    * SQLAlchemy：支持多种数据库后端，包括常见的关系数据库（如MySQL、PostgreSQL、SQLite）以及其他一些数据库系统。
    * Django：同样支持多种数据库后端，可以使用不同的数据库引擎来与数据库进行交互。

5. 灵活性和扩展性：

    * SQLAlchemy：提供了更高级别的灵活性，允许开发者定义和控制数据库的更多细节。它支持更复杂的关联关系，自定义查询和表达式，以及更细粒度的控制。
    * Django：提供了更简化和自动化的开发经验，尤其适合快速开发和常见的用例。它强调约定优于配置，并提供了一套简单且易于使用的ORM和查询API。


需要注意的是，以上只是SQLAlchemy和Django关系字段的一些常见差异，具体使用和行为可能还受到各个框架版本、配置和个人开发者偏好的影响。根据具体的项目需求和开发背景，选择合适的框架和关系字段有助于提高开发效率和代码质量。

SQLAlchemy和Django都是流行的Python框架，用于处理数据库关系。虽然它们都提供了关系字段的概念，但在实现和使用上有一些不同点。

SQLAlchemy的关系字段和Django的关系字段他们的不同点。

Django是一个使用Python编写的开源Web应用程序框架，它提供了一种方便的方式来处理数据库关系。Django的关系字段允许你在模型之间建立各种类型的关联关系，如一对一、一对多和多对多关系。以下是Django中常见的关系字段及其示例。

## 一对一关系（OneToOneField）

一对一关系表示两个模型之间的唯一关联。每个对象只能与另一个对象相关联。例如，考虑一个UserProfile模型与User模型之间的一对一关系，可以这样定义：

    from django.contrib.auth.models import User

    class UserProfile(models.Model):
        user = models.OneToOneField(User, on_delete=models.CASCADE)
        # 其他字段...

在这个例子中，每个用户（User对象）都对应一个用户配置文件（UserProfile对象），并且每个用户配置文件也只能与一个用户相关联。

`on_delete=models.CASCADE`表示：级联删除。Django 模拟了 SQL 约束 ON DELETE CASCADE 的行为，也删除了包含 ForeignKey 的对象。

## 一对多关系（ForeignKey）

一对多关系表示一个模型对象与另一个模型对象之间的多个关联。例如，考虑一个Author模型与Book模型之间的一对多关系，可以这样定义：

    class Author(models.Model):
        name = models.CharField(max_length=100)
        # 其他字段...

    class Book(models.Model):
        title = models.CharField(max_length=100)
        author = models.ForeignKey(Author, on_delete=models.CASCADE)
        # 其他字段...

在这个例子中，一个作者（Author对象）可以有多本书（Book对象），而每本书只能属于一个作者。

## 多对多关系（ManyToManyField）

多对多关系表示两个模型对象之间的多个关联。例如，考虑一个Student模型与Course模型之间的多对多关系，可以这样定义：

    class Student(models.Model):
        name = models.CharField(max_length=100)
        courses = models.ManyToManyField(Course)
        # 其他字段...

    class Course(models.Model):
        name = models.CharField(max_length=100)
        # 其他字段...

在这个例子中，一个学生（Student对象）可以选择多门课程（Course对象），而一门课程也可以有多个学生选择。

这些是Django中常见的关系字段，它们提供了一种便捷的方式来定义和处理模型之间的关联关系，使得在数据库层面进行复杂的查询和操作变得更加简单和高效。

参考：

[Django关系字段](https://docs.djangoproject.com/zh-hans/4.2/ref/models/fields/#module-django.db.models.fields.related)

Django是一个使用Python编写的开源Web应用程序框架，它提供了一种方便的方式来处理数据库关系。Django的关系字段允许你在模型之间建立各种类型的关联关系，如一对一、一对多和多对多关系。以下是Django中常见的关系字段及其示例。

Django 4.2 复习笔记(五)Django中常见的关系字段及其示例

这段代码的效果是，为h1标签设置一个彩虹渐变的背景，并使文本颜色透明，从而实现彩虹渐变的文本效果。具体效果如下：

![在这里插入图片描述](https://suiyan.cc/assets/images/2023/ch.png)

具体实现：

1. 定义一个名为`--rainbow-gradient`的CSS变量，用于存储一个渐变背景。这个渐变背景是一个线性渐变，从左到右分别是不同的颜色，角度为-90度。


        :root{
            --rainbow-gradient:
            linear-gradient(-90deg,
            #602ce5 0,
            #2ce597 30%,
            #e7bb18 50%,
            #ff7657 70%,
            #45c1ee 90%,
            #2ce597 100%); 
        }


2. 为类和`h1`标签设置样式。这里使用了刚刚定义的 --rainbow-gradient 变量作为背景图片，并设置了一些其他样式属性。


        h1 {
            background-image: var(--rainbow-gradient, #fff);
            background-size: 100%;
            background-repeat: repeat;
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            -moz-background-clip: text;
            -moz-text-fill-color: transparent;
            filter: drop-shadow(0 0 2rem #000);
            text-shadow: none !important;
        }



解释一下这段CSS：

- background-image：使用 --rainbow-gradient 变量作为背景图片，如果该变量未定义，则使用白色（#fff）作为背景。
- background-size：设置背景图片的尺寸为 100%。
- background-repeat：设置背景图片重复显示。
- -webkit-background-clip 和 -moz-background-clip：这两个属性用于设置背景图片的裁剪区域。这里设置为 text，表示只显示在文本区域的背景图片。
- -webkit-text-fill-color 和 -moz-text-fill-color：这两个属性用于设置文本的填充颜色。这里设置为 transparent，表示文本颜色透明，这样就可以看到背景图片的颜色。
- filter：设置一个阴影效果，颜色为黑色（#000），模糊半径为 2rem。
- text-shadow：设置文本阴影为无，!important 表示这个属性的优先级最高。


这段代码的效果是，为 h1 标签设置一个彩虹渐变的背景，并使文本颜色透明，从而实现彩虹渐变的文本效果。同时，还添加了一个阴影效果，赶快试试吧，是不是很好看？


## 最新的代碼

    .rainbow_text {
    background: linear-gradient(-90deg, #602ce5 0%, #2ce597 30%, #e7bb18 50%, #ff7657 70%, #45c1ee 90%, #2ce597 100%);
    -webkit-background-clip: text;
    color: transparent;
    }

请使用上边的代码，更简单些。

这段代码的效果是，为h1标签设置一个彩虹渐变的背景，并使文本颜色透明，从而实现彩虹渐变的文本效果。

css实现漂亮的彩虹渐变文本效果

Django的ORM操作非常简答，几乎把所有你能想到的数据库的操作都封装了，即便没有你需要的，也可以使用原生的SQL语句进行查询。

## 创建模型

为了测试查询，先创建一个简单的Django模型：

`myapp/models.py`

    class Article(models.Model):
        title = models.CharField(max_length=128,verbose_name='文章标题')
        content = models.TextField(verbose_name='文章内容')


其他还有一些操作：配置文件里需要添加应用，连接数据库和生成数据库的表，这些操作之前都有介绍，参考：[Django 4.2 复习笔记(二)编写和调试Model模型](https://suiyan.cc/2023/20230520081153.html)

## 增删改查(CRUD)

终端下敲入：

`$ python manage.py shell`

开始测试Django的增删改查(CRUD)

### 添加数据

    >>> from myapp.models import Article
    >>> a = Article(title="测试文章的标题",content="哈哈，我来测试一下......")
    >>> a.save()
    >>> a.title
    '测试文章的标题'
    >>> a.id
    2

### 更新数据

    >>> a.title="修改后的标题"
    >>> a.save()
    >>> a.title
    '修改后的标题'
    >>> 

### 删除数据

    >>> a.delete()

此时数据已经删除，在表中已不存在。

### 查询

数据的查询的需求有时是非常复杂的，这里只列举一些常用的查询。

Django的ORM数据操作常用函数：

all()函数，返回符合条件的全部记录。

    arts = Article.objects.all()

filter()函数，返回指定条件的记录。filter后面的括号内为过滤条件，类似于SQL中语句where后面的条件语句。

    >>> b = Article.objects.filter(title='aaa')
    >>> len(b)
    1
    >>> 

用 get() 检索单个对象.

    c = Article.objects.get(title='aaa')


order_by()函数，按照order_by后面括号中的字段排序。

exclude(**kwargs) 返回一个新的 QuerySet，包含的对象 不 满足给定查询参数。

### 总结

Django查询还有很多方法，这里就不一一介绍了，请参考官方文档：

[执行查询](https://docs.djangoproject.com/zh-hans/4.2/topics/db/queries/#)




Django的ORM操作非常简答，几乎把所有你能想到的数据库的操作都封装了，即便没有你需要的，也可以使用原生的SQL语句进行查询。

Django 4.2 复习笔记(四)数据的查询Django的ORM

Django的ORM在Python中算是数一数二的，使用起来非常的简单和丝滑，文档也写的简单直观，相对于SQLAlchemy有过之而无不及。

## 模型字段

常用的字段选项：

<table>
  <thead>
    <tr>
      <th>选项</th>
      <th>作用</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>null</td>
      <td>如果是 True， Django 将在数据库中存储空值为 NULL。默认为 False。</td>
    </tr>
    <tr>
      <td>blank</td>
      <td>如果是 True ，该字段允许为空。默认为 False 。</td>
    </tr>
    <tr>
      <td>db_index</td>
      <td>如果是 True，将为该字段创建数据库索引。</td>
    </tr>
    <tr>
      <td>default</td>
      <td>该字段的默认值。可以是一个值或者是个可调用的对象，如果是个可调用对象，每次实例化模型时都会调用该对象。</td>
    </tr>
    <tr>
      <td>help_text</td>
      <td>额外的“帮助”文本，随表单控件一同显示。即便你的字段未用于表单，它对于生成文档也是很有用的。</td>
    </tr>
    <tr>
      <td>primary_key</td>
      <td>如果设置为 True ，将该字段设置为该模型的主键。</td>
    </tr>
    <tr>
      <td>unique</td>
      <td>如果设置为 True，这个字段必须在整个表中保持值唯一。</td>
    </tr>
    <tr>
      <td>verbose_name</td>
      <td>字段的一个人类可读名称，如果没有给定详细名称，Django 会使用字段的属性名自动创建，并将下划线转换为空格。</td>
    </tr>
    <tr>
      <td>validators</td>
      <td>要为该字段运行的验证器列表</td>
    </tr>
  </tbody>
</table>

常见字段类型：

<table>
  <thead>
    <tr>
      <th>名称</th>
      <th>作用</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>AutoField</td>
      <td>一个 IntegerField，根据可用的 ID 自动递增。你通常不需要直接使用它；如果你没有指定，主键字段会自动添加到你的模型中。</td>
    </tr>
    <tr>
      <td>BooleanField</td>
      <td>单元一个 true／false 字段。格</td>
    </tr>
    <tr>
      <td>DateField</td>
      <td>一个日期，在 Python 中用一个 datetime.date 实例表示。有一些额外的、可选的参数。</td>
    </tr>
    <tr>
      <td>DateTimeField</td>
      <td>一个日期和时间，在 Python 中用一个 datetime.datetime 实例表示。</td>
    </tr>
    <tr>
      <td>EmailField</td>
      <td>一个 CharField，使用 EmailValidator 来检查该值是否为有效的电子邮件地址。</td>
    </tr>
    <tr>
      <td>FileField</td>
      <td>一个文件上传字段</td>
    </tr>
    <tr>
      <td>ImageField</td>
      <td>继承 FileField 的所有属性和方法，但也验证上传的对象是有效的图像。</td>
    </tr>
    <tr>
      <td>IntegerField</td>
      <td>一个整数。从 -2147483648 到 2147483647 的值在 Django 支持的所有数据库中都是安全的。</td>
    </tr>
    <tr>
      <td>CharField</td>
      <td>一个字符串字段，适用于小到大的字符串。</td>
    </tr>
    <tr>
      <td>TextField</td>
      <td>一个大的文本字段。该字段的默认表单部件是一个 Textarea。</td>
    </tr>
    <tr>
      <td>TimeField</td>
      <td>一个时间，在 Python 中用 datetime.time 实例表示。接受与 DateField 相同的自动填充选项。</td>
    </tr>
    <tr>
      <td>UUIDField</td>
      <td>一个用于存储通用唯一标识符的字段。使用 Python 的 UUID 类。当在 PostgreSQL 上使用时，它存储在一个 uuid 的数据类型中，否则存储在一个 char(32) 中。</td>
    </tr>
  </tbody>
</table>

关系字段：

<table>
  <tr>
    <th>名称</th>
    <th>作用</th>
  </tr>
  <tr>
    <td>ForeignKey</td>
    <td>一个多对一的关系。</td>
  </tr>
  <tr>
    <td>ManyToManyField</td>
    <td>一个多对多的关系</td>
  </tr>
  <tr>
    <td>OneToOneField</td>
    <td>一对一的关系。概念上，这类似于 ForeignKey 与 unique=True，但关系的“反向”将直接返回一个单一对象。</td>
  </tr>
</table>


关系字段极大的简化了数据中表关系的设置。

参考：

[模型字段参考](https://docs.djangoproject.com/zh-hans/4.2/ref/models/fields/)



Django的ORM在Python中算是数一数二的，使用起来非常的简单和丝滑，文档也写的简单直观，相对于SQLAlchemy有过之而无不及。

Django 4.2 复习笔记(三)Model模型字段

今天打包一个项目，发现element button 样式被其他矿建的样式覆盖了，项目里还使用了`tailwindcss`，当时打包的时候提示文件大小超过了默认值，我就修改了vite build的配置项chunkSizeWarningLimit,并且使文件分开打包，然后就发现element的样式后边始终跟随一个样式表，会覆盖element button的背景颜色的样式，网上搜了很多方法都没有效果。

## 解决方法：

vite中的build配置删除拆分打包的配置项，只保留并设置chunk的大小即可完美解决。

    build: {
            chunkSizeWarningLimit: 1500,
        },

今天打包一个项目，发现element button 样式被其他矿建的样式覆盖了，项目里还使用了`tailwindcss`，当时打包的时候提示文件大小超过了默认值，我就修改了vite build的配置项chunkSizeWarningLimit,并且使文件分开打包，然后就发现element的样式后边始...

vite打包后element样式被其他框架样式覆盖的解决方法


## vite打包遇到的问题

使用vite打包的时候提示：

    (!) Some chunks are larger than 500 KiB after minification. Consider:
    - Using dynamic import() to code-split the application
    - Use build.rollupOptions.output.manualChunks to improve chunking: https://rollupjs.org/guide/en/#outputmanualchunks
    - Adjust chunk size limit for this warning via build.chunkSizeWarningLimit.

这个是打包文件超过了默认大小的值，规定触发警告的 chunk 大小。（以 kbs 为单位）。默认： 500。

## 解决方法

`vite.config.js`中加入：

    build: {
            chunkSizeWarningLimit: 1500,
        },

如果代码不是很多只加入上边的代码就好，有些把.js和.css分开打包了，如果你对打包顺序的控制不太理解，不建议使用，不然会产生一些莫名其妙的错误。

解决vite打包超出默认值，出现警告的错误。

如何解决 Some chunks are larger than 500 KiB after minification？


对于web应用的编写应该从哪里开始呢？如果包含了数据的增删改查，那么对于使用Django开发web应用来说，从模型(Model)开始最好不过了。模型准确且唯一的描述了数据。它包含您储存的数据的重要字段和行为。一般来说，每一个模型都映射一张数据库表。

## 数据库配置

首先，使用数据库需要先连接到数据库才能定义表和操作数据，Django的数据库连接在配置文件`settins.py`中配置：

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': BASE_DIR / 'db.sqlite3',
        }
    }

上边的代码配置一个sqlite3的数据库连接，本文是用sqlite数据库来进行测试，如果你需要连接其他数据库，可以修改数据库到对应的连接方式，官方支持 PostgreSQL、MariaDB、MySQL、Oracle 和 SQLite。对数据库连接的配置可以参考这个网址：

[https://docs.djangoproject.com/zh-hans/4.2/ref/settings/#std-setting-DATABASES](https://docs.djangoproject.com/zh-hans/4.2/ref/settings/#std-setting-DATABASES)

## 模型(Model)

定义模型在Django里边是很简单的，可以在Django的应用的`app/model.py`编写模型定义的代码,每个模型都是一个 Python 的类，这些类继承 django.db.models.Model，先导入：

    from django.db import models

然后就可以编写model的代码了：

    class Article(models.Model):
        title = models.CharField(max_length=128,verbose_name='文章标题')
        content = models.TextField(verbose_name='文章内容')

任何模型的定义都需要继承models.Model，Django为开发者提供了大量的class，模型类的每个属性都相当于一个数据库的字段。

相关参考：

[模型字段参考](https://docs.djangoproject.com/zh-hans/4.2/ref/models/fields/#model-field-types)

[字段类型参考](https://docs.djangoproject.com/zh-hans/4.2/ref/models/fields/#field-types)

## 激活模型

定义完模型，首先需要生成相关的数据库和表，然后通过Django的命令行进行调试。

配置文件`mysite/settings.py`中添加`myapp`，你的应用名称。

    INSTALLED_APPS = [
        'myapp',
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
    ]

然后，终端下运行：

    $ python manage.py makemigrations myapp
    Migrations for 'myapp':
    myapp/migrations/0001_initial.py
        - Create model Article

这是通过Django的命令行生成了对应SQL语句，执行这些SQL语句就会生成对应的表和字段。

继续敲入`python manage.py migrate`

    $ python manage.py migrate
    Operations to perform:
    Apply all migrations: admin, auth, contenttypes, myapp, sessions
    Running migrations:
    Applying contenttypes.0001_initial... OK
    Applying auth.0001_initial... OK
    Applying admin.0001_initial... OK
    Applying admin.0002_logentry_remove_auto_add... OK
    Applying admin.0003_logentry_add_action_flag_choices... OK
    Applying contenttypes.0002_remove_content_type_name... OK
    Applying auth.0002_alter_permission_name_max_length... OK
    Applying auth.0003_alter_user_email_max_length... OK
    Applying auth.0004_alter_user_username_opts... OK
    Applying auth.0005_alter_user_last_login_null... OK
    Applying auth.0006_require_contenttypes_0002... OK
    Applying auth.0007_alter_validators_add_error_messages... OK
    Applying auth.0008_alter_user_username_max_length... OK
    Applying auth.0009_alter_user_last_name_max_length... OK
    Applying auth.0010_alter_group_name_max_length... OK
    Applying auth.0011_update_proxy_permissions... OK
    Applying auth.0012_alter_user_first_name_max_length... OK
    Applying myapp.0001_initial... OK
    Applying sessions.0001_initial... OK

这个时候就会生成相关的数据库，当然Django一些自带的项目依赖的数据库也一并创建了。

## 调试模型

终端下敲入：

`$ python manage.py shell`


进入Python的交互模式，敲入下边的代码进行测试：

    >>> from myapp.models import Article
    >>> a = Article(title='测试标题',content='这是一篇很长很长的文章。。。。。。')
    >>> a.save()
    >>> a.id
    1
    >>> a.title
    '测试标题'
    >>> a.content
    '这是一篇很长很长的文章。。。。。。'
    >>> Article.objects.all()
    <QuerySet [<Article: Article object (1)>]>
    >>> Article.objects.filter(id=1)
    <QuerySet [<Article: Article object (1)>]>
    >>> Article.objects.get(id=1)
    <Article: Article object (1)>
    >>> 


是不是很方便？不但可以创建还可以进行其他的增删改查。

## 总结

有关模型的使用这篇文章只是起了个头，模型是Django应用的核心与灵魂，web网站的数据都是围绕着模型展开的，熟练的创建和调试模型，会大大的提高Django应用的编写与开发，稍后会详细的介绍模型编写的一些细节。

对于web应用的编写应该从哪里开始呢？如果包含了数据的增删改查，那么对于使用Django开发web应用来说，从模型(Model)开始最好不过了。模型准确且唯一的描述了数据。它包含您储存的数据的重要字段和行为。一般来说，每一个模型都映射一张数据库表。

Django 4.2 复习笔记(二)编写和调试Model模型


许多年前曾经接触过Django，那时候还是1.X版本，现在都到了4.2版本了。今天抽空复习一下有关Django的相关技术要点。

## Django 安装

建议使用conda创建虚拟环境

conda 常用的命令。

    conda list 查看安装了哪些包。
    conda env list 或 conda info -e 查看当前存在哪些虚拟环境
    conda update conda 检查更新当前conda
    conda --version 查询conda版本
    conda -h 查询conda的命令使用
    activate // 切换到base环境
    conda deactivate //退出虚拟环境
    activate learn // 切换到learn环境
    conda create -n learn python=3 // 创建一个名为learn的环境并指定python版本为3(的最新版本)
    conda env list // 列出conda管理的所有环境
    conda list // 列出当前环境的所有包
    conda install requests 安装requests包
    conda remove requests 卸载requets包
    conda remove -n learn --all // 删除learn环境及下属所有包
    conda update requests 更新requests包
    conda env export > environment.yaml // 导出当前环境的包信息
    conda env create -f environment.yaml // 用配置文件创建新的虚拟环境

然后使用pip进行安装：

    pip install Django

查询Django版本：

    >>> import django
    >>> print(django.get_version())
    4.2

## 创建Django项目

新建一个项目目录，例如：app

    cd app
    django-admin startproject mysite


之后我们可以看到项目的结构大体如下：

    .
    └── mysite
        ├── manage.py
        └── mysite
            ├── __init__.py
            ├── asgi.py
            ├── settings.py
            ├── urls.py
            └── wsgi.py



切换到项目的根目，`manage.py`同目录：

    python manage.py runserver

    admin, auth, contenttypes, sessions.
    Run 'python manage.py migrate' to apply them.
    May 18, 2023 - 01:38:18
    Django version 4.2.1, using settings 'app.settings'
    Starting development server at http://127.0.0.1:8000/
    Quit the server with CONTROL-C.

浏览器输入网址：http://127.0.0.1:8000/ 就可以看到Django的默认的欢迎页面了。

## 创建应用

进入项目的目录，要和`manage.py`同目录，运行创建一个应用：

    python manage.py startapp myapp


    .
    └── mysite
        ├── db.sqlite3
        ├── manage.py
        ├── myapp
        └── mysite

这个时候发现myapp的这个应用就创建成功了。

`django-admin startproject mysite`和`python manage.py startapp myapp`的区别是，startproject创建的是一个项目，startapp创建的是一个应用，一个项目可以包括多个应用，例如创建一个网站项目，可以包括：新闻、图片库、后台管理等，这些可以细化成单个的应用，可以对应到路由，应用模块化后方便以后分开进行开发。

## 添加视图和路由

在`myapp/views.py`添加一个视图：

    from django.http import HttpResponse
    def index(request):
        return HttpResponse("Hello world!")

在`myapp/urls.py`添加路由:

    from django.urls import path
    from . import views


    urlpatterns = [
        path("",views.index,name="index"),
    ]

好了，这一套组合拳下去，我们也该看看效果了，在`manage.py`所在的目录中运行：`python manage.py runserver`，然后在浏览器里访问你的地址加上你的目录:`http://127.0.0.1:8000/myapp`，就可以看到久违的'hello world'了。

## 总结

如果你使用过flask或是fastapi，你会发现Django的hello world显得有些繁琐，但是每个web框架都有各自的优缺点，Django大而全，帮你准备好了web所需的各种依赖，相对于flask和fastapi，Django更重些但更全面。


许多年前曾经接触过Django，那时候还是1.X版本，现在都到了4.2版本了。今天抽空复习一下有关Django的相关技术要点。

Django 4.2 复习笔记(一)迅速概览


[使用Python编写并部署个人静态博客:(一)分析与设计](https://suiyan.cc/2023/20230410075954.html)

[使用Python编写并部署个人静态博客:(二)实现静态页面的输出](https://suiyan.cc/2023/20230420101527.html)

[使用Python编写并部署个人静态博客:(三)搜集博客数据](https://suiyan.cc/2023/20230517084718.html)

[使用Python编写并部署个人静态博客:(四)逐步输出静态页面](https://suiyan.cc/2023/20230609081842.html)

[使用Python编写并部署个人静态博客:(五)Python异步输出博文页面](https://suiyan.cc/2023/20230613193700.html)

## 搜集博客数据

![在这里插入图片描述](https://suiyan.cc/assets/images/2023/b01.png)

博客的静态页面的生成都是由博客的基础数据支撑的，搜集博客的基本信息和博客文章数据，是生成博客静态文件的核心功能。

## 博客的基础配置

每个博客都会有一些最基础的配置，例如博客的名称、简介、站长的昵称头像等，我们可以把这些基础的数据设置为一个配置文件，这里我使用了JSON格式的配置文件。可以在站点的根目录下创建一个config.json，其内容格式大概如下，可以根据自己的需要添加修改。

    {
        "dev": 0,
        "blog_name": "碎言博客",
        "blog_name_en": "SuiYan",
        "blog_author": "J.sky",
        "blog_description_en": "You see see you , This one day day di.",
        "blog_typed": [
            "Life is short, you need Python",
            "人生苦短，我用Python.",
            "Beautiful is better than ugly.",
            "美丽优于丑陋.",
            "Explicit is better than implicit.",
            "直白优于含蓄.",
            "Simple is better than complex.",
            "简单优于复杂.",
            "Complex is better than complicated.",
            "复杂优于繁琐.",
            "Readability counts.",
            "可读性很重要."
        ],
        "meta_description": " Python Django JavaScript 学习讨论,我们是一群热爱Python的程序员，人生苦短，我用JavaScript！一个不会JavaScript的Python开发者不是一个好网管。",
        "meta_keywords":"Python,Django,JavaScript,程序员,人生苦短,我用Python",
        "profile_image":"assets/images/avatar.jpg",
        "blog_bg": "assets/images/bg.jpg",
        "theme": "my_blog",
        "build": "blog",
        "md_dir": "articles",
        "blog_page_num":8,
        "blog_test_url":"http://127.0.0.1:5501/",
        "blog_url":"https://suiyan.cc/",
        "blog_sns": [
            {
                "ico": "github",
                "url": "https://github.com/bosichong/suiyan"
            },
            {
                "ico": "git",
                "url": "https://gitee.com/J_Sky/suiyan"
            },
            {
                "ico": "envelope",
                "url": "mailto:285911@gmail.com"
            },
            {
                "ico": "book",
                "url": "https://www.zhihu.com/people/J_sky/activities"
            },
            {
                "ico": "rss-square",
                "url": "https://suiyan.cc/rss.xml"
            }
        ],
        "nav": [
            {
                "ico": "home",
                "text": "Home",
                "url": ""
            },
            {
                "ico": "archive",
                "text": "Archive",
                "url": "archives.html"
            },
            {
                "ico": "tags",
                "text": "Tags",
                "url": "tags.html"
            },
            {
                "ico": "user-md",
                "text": "About Me",
                "url": "aboutme.html"
            },
            {
                "ico": "link",
                "text": "Links",
                "url": "links.html"
            }
        ]

    }

然后就可以在程序的文件中组织这些最基础的配置，例如提取文件地址和内容，分配静态文件生成发布的目录等，使用一些常量来定他们，放到代码的最顶部。

    APP_CONFIG = "config_my.json"
    BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # 当前目录地址
    CONFIG = load_configjson(os.path.join(BASE_DIR, APP_CONFIG))  # 获取当前配置
    BLOGPAGES = os.path.join(BASE_DIR, CONFIG["build"])  # 所有静态资源存放目录
    ARTICLES_DIR = os.path.join(BASE_DIR, CONFIG["md_dir"])  # 博文目录
    THEME = os.path.join(BASE_DIR, "theme")  # 主题目录
    CONFIGJSON = os.path.join(BASE_DIR, APP_CONFIG)
    BLOGCONFIG = os.path.join(BLOGPAGES, 'config.json')
    BLOGDATAJSON = os.path.join(BLOGPAGES, 'blog_data.json')
    SUIYANVERSION = "3.1.0"  # 程序版本

通过Python读写文件的操作，定义一个方法从磁盘上来获取config.json的内容并转化为Python的字典：

    def load_configjson(jsonpath):
        """载入blog配置文件config.json"""
        config_code = loadcode(jsonpath)
        config = json.loads(config_code)
        return config

具体的代码可以查看碎言静态博客的代码仓库，这里只介绍一些项目的架构技巧。

## 博客文章以及其他相关数据的搜集

博客的静态文件除了基础的博客信息外，还有博客的归档、分类(标签)、博客页面的数据等，这些都需要从博客文章的Markdown文件数据集中计算得出。
这里我采用了从文章目录中搜集博客文章，读取文章头部的定义内容，组织这些数据创建一个blog.json的索引，这个索引可以用来生成归档和标签页面的内容，也可以用来作为搜索的依据。

具体通过递归扫描文章目录来生成：

    def create_blogdata_json(adir):
        """
        递归获得当前目录及其子目录中所有的.md文件列表。
        并创建blog的data索引JSON
        :param adir: 文章日志所在目录
        :param bdir: 站点根目录
        :return: json字符串
        """
        data_json = []
        # 当前目录下所有的文件、子目录、子目录下的文件。
        for root, dirs, files in os.walk(adir):
            for file in files:
                # 值读取.md
                if file.endswith('.md'):
                    url = os.path.join(root, file).replace(
                        adir + os.sep, '').replace('.md', '')  # 最后需要组装的相对目录
                    furl = os.path.join(root, file)  # 当前文件的绝对目录
                    f_data = extract_md_header(furl)  # 获取.md的文章信息转成字典
                    f_data["url"] = url
                    f_data["uptime"] = get_file_modification_time(os.path.join(root, file))
                    data_json.append(f_data)  # 添加到需要返回的数据数组中

        data_json.sort(key=lambda x: x["time"], reverse=True)  # 对数组进行降序排序
        data_json_str = json.dumps(data_json, ensure_ascii=False)  # 转化为json字符串
        return data_json_str

有了这个文章数据之后，基本上就是解决了所有的静态博客文件生成依赖了。之后我们就可以编写代码，依次或是批量生成相关的页面了。

博客的静态页面的生成都是由博客的基础数据支撑的，搜集博客的基本信息和博客文章数据，是生成博客静态文件的核心功能。

使用Python编写并部署个人静态博客:(三)搜集博客数据

这几天一直琢磨这给博客文章页面添加个第三方的评论系统，最好是免费的，然后就搜到了`giscus`，从安装到使用，用一个字来评价：真特么绝！具体效果可以拉倒最底端查看。

## giscus 安装与配置


首先，需要Using the GraphQL API for Discussions，这个跟着GitHub的官方文档安装没有任何难度，传送门：[Using the GraphQL API for Discussions](https://docs.github.com/en/graphql/guides/using-the-graphql-api-for-discussions),其实就是开通一个仓库的评论系统，一般大家默认选择存放站点静态文件的仓库就好。

然后，安装[giscus](https://github.com/apps/giscus)，点开后，install就OK了。

最后，打开这个网址：[giscus官方和评论系统代码配置](https://giscus.app/zh-CN)，把你刚刚打算作为评论系统的仓库地址填到配置项的表单字段那里，然后选择几个选项，就可以生成配置代码了，把它添加到你的博客需要的地方就可以显示出来了。

这几天一直琢磨这给博客文章页面添加个第三方的评论系统，最好是免费的，然后就搜到了`giscus`，从安装到使用，用一个字来评价：真特么绝！

giscus一款基于GitHub的免费评论系统！


一直想对博客页面的时间进行格式化，把标准的时间格式修改成XX时间前或相对时间，因为时间已经直接输出到了页面DOM中，所以考虑直接使用相关的js库来实现比较方便，搜了一下发现二个JavaScript的时间处理库比较不错，他们是：`Moment.js`和`Day.js`。

使用相关库里处理后的时间显示效果：

<table class="table table-striped table-bordered">
  <thead>
    <tr>
      <th>范围</th>
      <th>Key</th>
      <th>示例输出</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>0 到 44 秒</td>
      <td>s</td>
      <td>几秒钟前</td>
    </tr>
    <tr>
      <td><i>取消设置</i></td>
      <td>SS</td>
      <td>44 秒前</td>
    </tr>
    <tr>
      <td>45 至 89 秒</td>
      <td>m</td>
      <td>一分钟前</td>
    </tr>
    <tr>
      <td>90 秒到 44 分钟</td>
      <td>mm</td>
      <td>2分钟前... 44 分钟前</td>
    </tr>
    <tr>
      <td>45至89分钟</td>
      <td>h</td>
      <td>一小时前</td>
    </tr>
    <tr>
      <td>90 分钟到 21 小时</td>
      <td>hh</td>
      <td>2小时前 ... 21 小时前</td>
    </tr>
    <tr>
      <td>22 至 35 小时</td>
      <td>d</td>
      <td>一天前</td>
    </tr>
    <tr>
      <td>36 小时至 25 天</td>
      <td>dd</td>
      <td>2天前 ... 25天前</td>
    </tr>
    <tr>
      <td>26至45天</td>
      <td>M</td>
      <td>一个月前</td>
    </tr>
    <tr>
      <td>45至319天</td>
      <td>MM</td>
      <td>2个月前 ... 10个月前</td>
    </tr>
    <tr>
      <td>320 至 547 天（1.5 年）</td>
      <td>y</td>
      <td>一年前</td>
    </tr>
    <tr>
      <td>548天+</td>
      <td>yy</td>
      <td>2年前 ... 20年前</td>
    </tr>
  </tbody>
</table>

这样的看起来更人性化，好了，开搞。

## Moment.js

首先引入相关库的CDN：

1. `moment.min.js`主要的程序依赖库。
2. `moment-with-locales.min.js` 国际化的语言支持。

    <script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.29.4/moment.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.29.4/moment-with-locales.min.js" ></script>


DOM结构：

    <small class="cr-time">2019-12-30 16:25:07</small>

jQuery代码更方便一些：

    moment.locale('zh-CN');//设置为中文
    $(function () {
        $('.cr-time').each(function (i, e) {
            $(e).text(moment($(e).text()).fromNow())
        });
    });

至此 moment格式化时间的配置都搞定了，但是，我发现moment官网已经开始劝退了，一下引用官网的原话：

> Moment 团队对这些问题进行了详细讨论。 我们认识到许多现有项目可能会继续使用 Moment，但我们不希望在未来的新项目中使用 Moment。我们现在普遍认为 Moment 是处于维护模式的旧项目。 它没有死，但它确实结束了。

好家伙，我确实是都调试好了，都发布上线了，才看了一眼官网的首页，好吧我认了，看看推荐那些替代了？看到了：`Day.js`。

> Day.js 旨在成为 Moment.js 的极简替代品，使用类似的 API。 它不是直接替代品，但如果您习惯使用 Moment 的 API 并希望快速上手，请考虑使用 Day.js。

那就用`Day.js`来替换吧，整个替换过程很快，因为他们的属性方法都一样，只做了写小改动即可。

## Day.js

引入CDN ：

    <script src="https://unpkg.com/dayjs@1.8.21/dayjs.min.js"></script>
    <script src="https://unpkg.com/dayjs@1.8.21/plugin/relativeTime.js"></script>
    <script src="https://unpkg.com/dayjs@1.8.21/locale/zh-cn.js"></script>
        
这里自上而下的是：主程序库、relativeTime插件库和国际化的库。DOM的结构不变和上边的一样。

jQuery代码：

    dayjs.locale('zh-cn')// 设置中文
    dayjs.extend(window.dayjs_plugin_relativeTime)
    $(function () {
        $('.cr-time').each(function (i, e) {
            $(e).text(dayjs($(e).text()).fromNow())
        });
    });

其他就是把库的名称由`moment`换成了`dayjs`就可以了。然后就可以完美运行了，具体效果抬头看下文章标题下边就行啦。

相关网站：

[moment.js官方网站](https://moment.nodejs.cn/)
[day.js官方网站](https://dayjs.gitee.io/zh-CN/)

一直想对博客页面的时间进行格式化，把标准的时间格式修改成XX时间前或相对时间，因为时间已经直接输出到了页面DOM中，所以考虑直接使用相关的js库来实现比较方便，搜了一下发现二个JavaScript的时间处理库比较不错，他们是：`Moment.js`和`Day.js`。