我的博客
diff --git a/src/components/blog/id/ReadingProgress.tsx b/src/components/blog/id/ReadingProgress.tsx
index afb13d8..b450f86 100644
--- a/src/components/blog/id/ReadingProgress.tsx
+++ b/src/components/blog/id/ReadingProgress.tsx
@@ -25,11 +25,15 @@ export default function ReadingProgress() {
if (!isVisible) return null;
return (
-
+ <>
+ {width && (
+
+ )}
+ >
);
}
diff --git a/src/data/blogPosts.ts b/src/data/blogPosts.ts
index a2fd62d..1d29468 100644
--- a/src/data/blogPosts.ts
+++ b/src/data/blogPosts.ts
@@ -1,4 +1,20 @@
-import { content1, content2 } from "./ts";
+import {
+ content1,
+ content2,
+ content3,
+ content4,
+ content5,
+ content6,
+ content7,
+ content8,
+ content9,
+ content10,
+ content11,
+ content12,
+ content13,
+ content14,
+ content15,
+} from "./ts";
export interface BlogPost {
id: number;
@@ -37,94 +53,7 @@ export const blogPosts: BlogPost[] = [
id: 3,
title: "CSS-in-JS解决方案对比",
excerpt: "比较流行的CSS-in-JS库的优缺点...",
- content: `
-# CSS-in-JS解决方案对比
-
-CSS-in-JS已成为现代前端开发中的重要工具。本文将对比分析几种流行的CSS-in-JS解决方案,包括styled-components、Emotion、CSS Modules等。我们将从性能、开发体验、维护性等多个角度进行评估,并提供每种方案的最佳使用场景。此外,我们还将探讨CSS-in-JS与传统CSS方法的区别,以及如何在大型项目中有效管理样式。
-
-## styled-components
-
-styled-components是最流行的CSS-in-JS库之一。它结合了CSS和JavaScript的优点,使得我们可以在React组件中定义样式。
-
-### 优点
-
-1. 简洁的语法
-2. 支持动态样式
-3. 自动生成唯一的类名
-4. 易于主题化
-5. 良好的开发体验
-
-### 缺点
-
-1. 运行时性能开销
-2. 学习曲线较陡
-3. 不支持CSS Modules的特性
-
-### 最佳使用场景
-
-styled-components适用于需要动态样式和主题化的项目,尤其是中小型项目。
-
-## Emotion
-
-Emotion是另一种流行的CSS-in-JS库,它提供了更灵活的API和更好的性能。
-
-### 优点
-
-1. 高性能
-2. 支持CSS Modules的特性
-3. 易于主题化
-4. 良好的开发体验
-
-### 缺点
-
-1. 学习曲线较陡
-2. 不支持动态样式
-
-### 最佳使用场景
-
-Emotion适用于需要高性能和CSS Modules特性的项目,尤其是大型项目。
-
-## CSS Modules
-
-CSS Modules是一种CSS-in-JS解决方案,它将CSS模块化,并将类名作为JavaScript对象导出。
-
-### 优点
-
-1. 简单易用
-2. 支持CSS Modules的特性
-3. 良好的开发体验
-
-### 缺点
-
-1. 不支持动态样式
-2. 不易于主题化
-3. 类名不是唯一的
-
-### 最佳使用场景
-
-CSS Modules适用于需要简单、可维护的样式解决方案的项目,尤其是小型项目。
-
-## CSS-in-JS与传统CSS的区别
-
-CSS-in-JS与传统CSS有一些重要的区别:
-
-1. 作用域隔离: CSS-in-JS可以确保样式只应用于特定的组件,而传统CSS需要手动管理类名和命名空间。
-2. 动态样式: CSS-in-JS可以根据组件的状态和属性动态生成样式,而传统CSS需要使用JavaScript来切换类名。
-3. 主题化: CSS-in-JS可以轻松地支持主题化,而传统CSS需要使用预处理器或后处理器来实现。
-
-## 在大型项目中管理样式
-
-在大型项目中,有效管理样式是一个重要的挑战。以下是一些建议:
-
-1. 使用CSS-in-JS库: CSS-in-JS库可以提供更好的作用域隔离和动态样式支持,从而简化样式管理。
-2. 使用主题化: 主题化可以使样式更易于维护和扩展,尤其是在多个项目或不同环境中。
-3. 使用CSS Modules: CSS Modules可以提供简单、可维护的样式解决方案,尤其是在小型项目中。
-4. 使用CSS-in-JS库的最佳实践: 每个CSS-in-JS库都有自己的最佳实践,例如styled-components的\`ThemeProvider\`和Emotion的\`css\`函数。
-
-## 结论
-
-CSS-in-JS是一种强大的工具,它可以提供更好的作用域隔离、动态样式支持和主题化。styled-components、Emotion和CSS Modules都是流行的解决方案,每种方案都有自己的优缺点和最佳使用场景。在选择CSS-in-JS库时,应该根据项目的需求和规模来权衡性能、开发体验和维护性。
- `,
+ content: content3,
date: "2024-03-25",
author: "王五",
tags: ["CSS-in-JS", "styled-components", "Emotion"],
@@ -133,100 +62,7 @@ CSS-in-JS是一种强大的工具,它可以提供更好的作用域隔离、动
id: 4,
title: "TypeScript高级类型技巧",
excerpt: "掌握TypeScript中的高级类型用法...",
- content: `
-# TypeScript高级类型技巧
-
-TypeScript的类型系统非常强大,但也有一定的学习曲线。本文将深入探讨TypeScript中的高级类型技巧,包括条件类型、映射类型、联合类型和交叉类型等。我们将通过实际子展这些高级类型的应用,如何使用它们来创建更灵活、更安全的代码。同时,我们还将讨论TypeScript的类型推断机制,以及如何编写和使用自定义类型守卫。
-
-## 条件类型
-
-条件类型允许我们根据条件选择不同的类型。它的语法如下:
-
-\`\`\`
-type SomeType
= T extends SomeCondition ? TrueType : FalseType;
-\`\`\`
-
-例如,我们可以使用条件类型来创建一个\`Nullable\`类型:
-
-\`\`\`
-type Nullable = T extends null | undefined ? T : T & { notNull: true };
-\`\`\`
-
-## 映射类型
-
-映射类型允许我们对现有类型的每个属性进行转换。它的语法如下:
-
-\`\`\`
-type MappedType = {
- [P in keyof T]: TransformedType;
-};
-\`\`\`
-
-例如,我们可以使用映射类型来创建一个\`Readonly\`类型:
-
-\`\`\`
-type Readonly = {
- readonly [P in keyof T]: T[P];
-};
-\`\`\`
-
-## 联合类型和交叉类型
-
-联合类型允许我们表示多个类型中的任意一个。它的语法如下:
-
-\`\`\`
-type UnionType = Type1 | Type2 | Type3;
-\`\`\`
-
-交叉类型允许我们组合多个类型的属性。它的语法如下:
-
-\`\`\`
-type IntersectionType = Type1 & Type2 & Type3;
-\`\`\`
-
-例如,我们可以使用交叉类型来创建一个\`WithRequired\`类型:
-
-\`\`\`
-type WithRequired = T & { [P in K]-?: T[P] };
-\`\`\`
-
-## 类型推断
-
-TypeScript的类型推断机制可以自动推断变量的类型。它基于以下规则:
-
-1. 如果有明确的类型注释,则使用该类型
-2. 如果没有类型注释,则从初始化表达式推断类型
-3. 如果初始化表达式是函数调用,则使用函数返回类型
-
-例如,以下代码中的\`x\`和\`y\`都会被推断为\`number\`类型:
-
-\`\`\`
-let x = 10;
-let y = x * 2;
-\`\`\`
-
-## 自定义类型守卫
-
-自定义类型守卫允许我们在运行时检查类型。它的语法如下:
-
-\`\`\`
-function isTypeGuard(value: any): value is Type {
- // 检查类型
-}
-\`\`\`
-
-例如,我们可以使用自定义类型守卫来检查一个值是否是\`string\`类型:
-
-\`\`\`
-function isString(value: any): value is string {
- return typeof value === 'string';
-}
-\`\`\`
-
-## 结论
-
-TypeScript的高级类型技巧可以帮助我们创建更灵活、更安全的代码。通过掌握条件类型、映射类型、联合类型和交叉类型等高级类型,我们可以更好地表达复杂的类型关系。同时,通过理解TypeScript的类型推断机制和自定义类型守卫,我们可以更好地控制类型检查。
- `,
+ content: content4,
date: "2024-03-30",
author: "赵六",
tags: ["TypeScript", "类型系统", "前端开发"],
@@ -235,64 +71,7 @@ TypeScript的高级类型技巧可以帮助我们创建更灵活、更安全的
id: 5,
title: "深入理解JavaScript异步编程",
excerpt: "探索JavaScript中的异步编程模式和最佳实践...",
- content: `
-# JavaScript异步编程深度解析
-
-JavaScript的异步编程是前端开发中的重要概念。本文将深入探讨各种异步编程模式及其应用。
-
-## 回调函数
-
-回调函数是最基本的异步编程方式:
-
-\`\`\`javascript
-function fetchData(callback) {
- setTimeout(() => {
- callback('Data fetched');
- }, 1000);
-}
-
-fetchData((result) => {
- console.log(result);
-});
-\`\`\`
-
-## Promise
-
-Promise提供了更优雅的异步处理方式:
-
-\`\`\`javascript
-function fetchData() {
- return new Promise((resolve, reject) => {
- setTimeout(() => {
- resolve('Data fetched');
- }, 1000);
- });
-}
-
-fetchData()
- .then(result => console.log(result))
- .catch(error => console.error(error));
-\`\`\`
-
-## Async/Await
-
-Async/Await是基于Promise的语法糖,使异步代码更易读:
-
-\`\`\`javascript
-async function getData() {
- try {
- const result = await fetchData();
- console.log(result);
- } catch (error) {
- console.error(error);
- }
-}
-
-getData();
-\`\`\`
-
-通过掌握这些异步编程模式,我们可以更好地处理复杂的异步操作,提高代码的可读性和可维护性。
- `,
+ content: content5,
date: "2024-04-05",
author: "陈七",
tags: ["JavaScript", "异步编程", "Promise", "Async/Await"],
@@ -301,63 +80,7 @@ getData();
id: 6,
title: "React性能优化实战指南",
excerpt: "学习React应用的高级性能优化技巧...",
- content: `
-# React性能优化实战指南
-
-在构建大型React应用时,性能优化至关重要。本文将介绍一些实用的React性能优化技巧。
-
-## 使用React.memo
-
-React.memo可以帮助我们避免不必要的重渲染:
-
-\`\`\`jsx
-const MyComponent = React.memo(function MyComponent(props) {
- /* 渲染使用到的props */
-});
-\`\`\`
-
-## 使用useMemo和useCallback
-
-useMemo和useCallback可以帮助我们缓存计算结果和回调函数:
-
-\`\`\`jsx
-const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);
-
-const memoizedCallback = useCallback(
- () => {
- doSomething(a, b);
- },
- [a, b],
-);
-\`\`\`
-
-## 虚拟化长列表
-
-对于长列表,我们可以使用虚拟化技术来提高性能:
-
-\`\`\`jsx
-import { FixedSizeList as List } from 'react-window';
-
-function Row({ index, style }) {
- return Row {index}
;
-}
-
-function Example() {
- return (
-
- {Row}
-
- );
-}
-\`\`\`
-
-通过应用这些优化技巧,我们可以显著提升React应用的性能,为用户提供更流畅的体验。
- `,
+ content: content6,
date: "2024-04-10",
author: "林八",
tags: ["React", "性能优化", "虚拟列表"],
@@ -366,55 +89,7 @@ function Example() {
id: 7,
title: "WebAssembly与前端的未来",
excerpt: "探索WebAssembly如何革新Web应用开发...",
- content: `
-# WebAssembly与前端的未来
-
-WebAssembly (Wasm) 正在改变Web应用的性能界限。本文将深入探讨Wasm的工作原理、与JavaScript的协作方式,以及在前端项目中的实际应用案例。
-
-## WebAssembly简介
-
-WebAssembly是一种低级的类汇编语言,可以在现代Web浏览器中运行。它的主要特点包括:
-
-1. 近乎原生的执行速度
-2. 跨平台兼容性
-3. 与JavaScript的无缝集成
-
-## WebAssembly的工作原理
-
-WebAssembly模块通常由C++、Rust等语言编译而来。它的执行过程如下:
-
-1. 加载.wasm文件
-2. 实例化WebAssembly模块
-3. 调用WebAssembly函数
-
-## 与JavaScript的协作
-
-WebAssembly可以与JavaScript进行双向通信:
-
-\`\`\`javascript
-// 加载WebAssembly模块
-WebAssembly.instantiateStreaming(fetch('module.wasm'))
- .then(result => {
- const exports = result.instance.exports;
- const result = exports.someFunction(42);
- console.log(result);
- });
-\`\`\`
-
-## 实际应用案例
-
-1. 图像处理: 使用WebAssembly加速滤镜应用
-2. 游戏引擎: 将复杂的游戏逻辑编译为WebAssembly
-3. 加密算法: 实现高性能的加密/解密操作
-
-## WebAssembly的未来发展
-
-1. 多线程支持: 利用Web Workers实现并行计算
-2. 垃圾回收: 简化内存管理
-3. 异常处理: 改善错误处理机制
-
-WebAssembly正在不断发展,为Web应用带来更多可能性。通过掌握WebAssembly,前端开发者可以构建更高性能、更复杂的Web应用。
- `,
+ content: content7,
date: "2024-04-15",
author: "吴九",
tags: ["WebAssembly", "性能优化", "前端创新"],
@@ -423,53 +98,7 @@ WebAssembly正在不断发展,为Web应用带来更多可能性。通过掌握We
id: 8,
title: "AI驱动的前端开发:机遇与挑战",
excerpt: "探讨AI技术如何改变前端开发流程...",
- content: `
-# AI驱动的前端开发:机遇与挑战
-
-人工智能正在深刻影响前端开发领域。本文将介绍AI在代码自动补全、UI设计生成、性能优化等方面的应用。
-
-## AI在前端开发中的应用
-
-1. 代码自动补全
- - GitHub Copilot
- - TabNine
-
-2. UI设计生成
- - Figma的AI功能
- - Adobe Sensei
-
-3. 性能优化
- - 自动化性能分析
- - 智能代码重构
-
-## AI编程助手的使用技巧
-
-以GitHub Copilot为例:
-
-1. 编写清晰的注释
-2. 使用自然语言描述功能
-3. 结合单元测试提高准确性
-
-## 机器学习优化用户体验
-
-1. 个性化推荐
-2. 智能表单填充
-3. 预测用户行为
-
-## AI带来的伦理问题
-
-1. 版权问题
-2. 隐私保护
-3. 算法偏见
-
-## AI对开发者角色的影响
-
-1. 重点转向高层次设计
-2. 增强问题解决能力
-3. 持续学习新技术
-
-AI技术正在改变前端开发的方方面面。开发者需要拥抱这些变化,同时保持批判性思考,以充分利用AI带来的机遇并应对挑战。
- `,
+ content: content8,
date: "2024-04-20",
author: "郑十",
tags: ["AI", "前端开发", "自动化"],
@@ -478,84 +107,7 @@ AI技术正在改变前端开发的方方面面。开发者需要拥抱这些变
id: 9,
title: "Web3和去中心化应用(DApps)开发入门",
excerpt: "学习构建基于区块链的Web应用...",
- content: `
-# Web3和去中心化应用(DApps)开发入门
-
-Web3技术正在兴起,为开发者带来新的机遇。本文将介绍Web3的核心概念,并指导如何创建一个简单的DApp。
-
-## Web3核心概念
-
-1. 智能合约: 自动执行的程序,运行在区块链上
-2. 去中心化存储: IPFS, Filecoin等
-3. 去中心化身份验证: MetaMask, WalletConnect等
-
-## 创建简单DApp
-
-使用Ethereum和Solidity创建一个简单的投票DApp:
-
-1. 编写智能合约:
-
-\`\`\`solidity
-pragma solidity ^0.8.0;
-
-contract Voting {
- mapping(string => uint256) public votes;
-
- function vote(string memory candidate) public {
- votes[candidate] += 1;
- }
-
- function getVotes(string memory candidate) public view returns (uint256) {
- return votes[candidate];
- }
-}
-\`\`\`
-
-2. 使用Web3.js与合约交互:
-
-\`\`\`javascript
-import Web3 from 'web3';
-
-const web3 = new Web3(Web3.givenProvider);
-const contract = new web3.eth.Contract(ABI, CONTRACT_ADDRESS);
-
-async function vote(candidate) {
- const accounts = await web3.eth.getAccounts();
- await contract.methods.vote(candidate).send({ from: accounts[0] });
-}
-\`\`\`
-
-3. 集成React前端:
-
-\`\`\`jsx
-function VotingApp() {
- const [candidate, setCandidate] = useState('');
- const [votes, setVotes] = useState(0);
-
- async function handleVote() {
- await vote(candidate);
- const newVotes = await contract.methods.getVotes(candidate).call();
- setVotes(newVotes);
- }
-
- return (
-
-
setCandidate(e.target.value)} />
-
-
Votes: {votes}
-
- );
-}
-\`\`\`
-
-## Web3应用面临的挑战
-
-1. 可扩展性: 处理高并发交易
-2. 用户体验: 简化钱包连接和交易确认
-3. 法律合规: 应对不同地区的监管要求
-
-Web3技术为开发者提供了创新的机会,但也带来了新的挑战。通过不断学习和实践,我们可以在这个新兴领域中创造出革命性的应用。
- `,
+ content: content9,
date: "2024-04-25",
author: "黄十一",
tags: ["Web3", "区块链", "DApps"],
@@ -564,82 +116,7 @@ Web3技术为开发者提供了创新的机会,但也带来了新的挑战。通
id: 10,
title: "微前端架构实践与性能优化",
excerpt: "深入理解微前端的实现原理和优化策略...",
- content: `
-# 微前端架构实践与性能优化
-
-微前端架构允许多个独立开发、部署的前端应用共存于一个页面。本文将详细介绍微前端的实现方法和优化策略。
-
-## 微前端实现方法
-
-1. 使用Single-SPA框架:
-
-\`\`\`javascript
-import { registerApplication, start } from 'single-spa';
-
-registerApplication({
- name: 'app1',
- app: () => import('./app1/main.js'),
- activeWhen: '/app1'
-});
-
-registerApplication({
- name: 'app2',
- app: () => import('./app2/main.js'),
- activeWhen: '/app2'
-});
-
-start();
-\`\`\`
-
-2. 使用Qiankun框架:
-
-\`\`\`javascript
-import { registerMicroApps, start } from 'qiankun';
-
-registerMicroApps([
- {
- name: 'app1',
- entry: '//localhost:8080',
- container: '#container',
- activeRule: '/app1',
- },
- {
- name: 'app2',
- entry: '//localhost:8081',
- container: '#container',
- activeRule: '/app2',
- },
-]);
-
-start();
-\`\`\`
-
-## 微前端通信机制
-
-1. 基于CustomEvent的发布订阅模式
-2. 使用Props进行父子应用通信
-3. 全局状态管理(如Redux)
-
-## 样式隔离
-
-1. BEM命名约定
-2. CSS Modules
-3. Shadow DOM
-
-## 性能优化策略
-
-1. 应用预加载
-2. 公共依赖提取
-3. 按需加载子应用
-
-## 实践经验与注意事项
-
-1. 统一技术栈,降低维护成本
-2. 制定明确的应用边界
-3. 建立完善的监控体系
-
-微前端架构为大型前端项目提供了灵活的解决方案,但也带来了额外的复杂性。通过合理的架构设计和优化策略,我们可以充分发挥微前端的优势,构建高效、可维护的大型前端应用。
- `,
+ content: content10,
date: "2024-04-30",
author: "刘十二",
tags: ["微前端", "架构设计", "性能优化"],
@@ -648,89 +125,7 @@ start();
id: 11,
title: "前端可视化技术的新趋势",
excerpt: "探索数据可视化和3D渲染的最新进展...",
- content: `
-# 前端可视化技术的新趋势
-
-前端可视化技术正在快速发展,本文将介绍最新的3D渲染和数据可视化技术,以及它们的实际应用。
-
-## WebGL和Three.js
-
-WebGL是一种用于渲染交互式3D图形的JavaScript API。Three.js是基于WebGL的3D库,大大简化了3D场景的创建过程。
-
-创建一个简单的3D场景:
-
-\`\`\`javascript
-import * as THREE from 'three';
-
-const scene = new THREE.Scene();
-const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
-const renderer = new THREE.WebGLRenderer();
-
-renderer.setSize(window.innerWidth, window.innerHeight);
-document.body.appendChild(renderer.domElement);
-
-const geometry = new THREE.BoxGeometry();
-const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
-const cube = new THREE.Mesh(geometry, material);
-scene.add(cube);
-
-camera.position.z = 5;
-
-function animate() {
- requestAnimationFrame(animate);
- cube.rotation.x += 0.01;
- cube.rotation.y += 0.01;
- renderer.render(scene, camera);
-}
-
-animate();
-\`\`\`
-
-## 数据可视化库
-
-1. D3.js: 强大而灵活的数据可视化库
-2. ECharts: 功能丰富的图表库
-
-使用ECharts创建交互式图表:
-
-\`\`\`javascript
-import * as echarts from 'echarts';
-
-const chartDom = document.getElementById('main');
-const myChart = echarts.init(chartDom);
-
-const option = {
- title: {
- text: '示例图表'
- },
- xAxis: {
- type: 'category',
- data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
- },
- yAxis: {
- type: 'value'
- },
- series: [{
- data: [120, 200, 150, 80, 70, 110, 130],
- type: 'bar'
- }]
-};
-
-myChart.setOption(option);
-\`\`\`
-
-## WebGPU
-
-WebGPU是下一代图形和计算API,有望在未来取代WebGL。它提供了更低级的硬件访问,可以实现更高效的渲染和计算。
-
-## 实际应用案例
-
-1. 交互式数据仪表板
-2. 3D产品展示
-3. 虚拟现实(VR)和增强现实(AR)应用
-
-前端可视化技术正在不断突破边界,为用户提供更丰富、更直观的数据展示和交互体验。通过掌握这些新兴技术,前端开发者可以创造出令人惊叹的视觉效果和用户体验。
- `,
+ content: content11,
date: "2024-05-05",
author: "赵十三",
tags: ["数据可视化", "WebGL", "3D渲染"],
@@ -739,125 +134,7 @@ WebGPU是下一代图形和计算API,有望在未来取代WebGL。它提供了
id: 12,
title: "渐进式Web应用(PWA)开发指南",
excerpt: "学习如何构建离线可用、类原生应用体验的Web应用...",
- content: `
-# 渐进式Web应用(PWA)开发指南
-
-渐进式Web应用(PWA)结合了Web和原生应用的优点,提供了卓越的用户体验。本文将深入探讨PWA的核心技术和实现方法。
-
-## Service Workers
-
-Service Workers是PWA的核心,用于实现离线缓存和后台同步。
-
-注册Service Worker:
-
-\`\`\`javascript
-if ('serviceWorker' in navigator) {
- window.addEventListener('load', function() {
- navigator.serviceWorker.register('/sw.js').then(function(registration) {
- console.log('ServiceWorker registration successful');
- }, function(err) {
- console.log('ServiceWorker registration failed: ', err);
- });
- });
-}
-\`\`\`
-
-实现离线缓存:
-
-\`\`\`javascript
-// sw.js
-const CACHE_NAME = 'my-site-cache-v1';
-const urlsToCache = [
- '/',
- '/styles/main.css',
- '/script/main.js'
-];
-
-self.addEventListener('install', function(event) {
- event.waitUntil(
- caches.open(CACHE_NAME)
- .then(function(cache) {
- console.log('Opened cache');
- return cache.addAll(urlsToCache);
- })
- );
-});
-
-self.addEventListener('fetch', function(event) {
- event.respondWith(
- caches.match(event.request)
- .then(function(response) {
- if (response) {
- return response;
- }
- return fetch(event.request);
- }
- )
- );
-});
-\`\`\`
-
-## Web App Manifest
-
-Web App Manifest定义了应用的图标、启动行为等信息。
-
-\`\`\`json
-{
- "name": "My PWA",
- "short_name": "MyPWA",
- "icons": [
- {
- "src": "icons/icon-192x192.png",
- "sizes": "192x192",
- "type": "image/png"
- },
- {
- "src": "icons/icon-512x512.png",
- "sizes": "512x512",
- "type": "image/png"
- }
- ],
- "start_url": "/",
- "display": "standalone",
- "background_color": "#ffffff",
- "theme_color": "#000000"
-}
-\`\`\`
-
-## Push Notifications
-
-Push Notifications允许应用向用户发送实时通知。
-
-\`\`\`javascript
-// 请求推送权限
-Notification.requestPermission().then(function(permission) {
- if (permission === 'granted') {
- console.log('Notification permission granted.');
- }
-});
-
-// 监听推送事件
-self.addEventListener('push', function(event) {
- const options = {
- body: event.data.text(),
- icon: 'icons/icon-192x192.png',
- badge: 'icons/badge-128x128.png'
- };
-
- event.waitUntil(
- self.registration.showNotification('My PWA', options)
- );
-});
-\`\`\`
-
-## PWA的未来发展
-
-1. Web Bluetooth: 连接蓝牙设备
-2. Web USB: 访问USB设备
-3. Web Share: 共享内容
-
-PWA正在不断发展,为用户提供更多可能性。通过掌握PWA的核心技术,前端开发者可以构建出类原生的Web应用,为用户带来卓越的体验。
- `,
+ content: content12,
date: "2024-05-10",
author: "钱十四",
tags: ["PWA", "离线应用", "移动Web"],
@@ -866,116 +143,7 @@ PWA正在不断发展,为用户提供更多可能性。通过掌握PWA的核心
id: 13,
title: "GraphQL与现代API设计",
excerpt: "探索GraphQL如何改变前后端交互模式...",
- content: `
-# GraphQL与现代API设计
-
-GraphQL正在改变我们设计和使用API的方式。本文将深入讨论GraphQL的核心概念和优势,并指导如何在实际项目中使用GraphQL。
-
-## GraphQL简介
-
-GraphQL是一种用于API的查询语言,也是一个运行时。它的主要特点包括:
-
-1. 类型系统: 强类型定义提高了API的可预测性
-2. 按需获取: 客户端可以精确指定所需数据,减少过度获取
-3. 实时更新: Subscriptions支持实时数据流
-
-## 使用GraphQL
-
-1. 定义Schema:
-
-\`\`\`javascript
-type Query {
- getPost(id: ID!): Post
- getAllPosts: [Post]
-}
-
-type Mutation {
- createPost(input: PostInput!): Post
- updatePost(id: ID!, input: PostInput!): Post
- deletePost(id: ID!): Post
-}
-
-type Subscription {
- postCreated: Post
-}
-
-type Post {
- id: ID!
- title: String!
- content: String!
- author: Author!
-}
-
-type Author {
- id: ID!
- name: String!
- email: String!
-}
-
-input PostInput {
- title: String!
- content: String!
- authorId: ID!
-}
-\`\`\`
-
-2. 使用Apollo Client:
-
-\`\`\`javascript
-import { ApolloClient, InMemoryCache, ApolloProvider, useQuery, useMutation } from '@apollo/client';
-
-const client = new ApolloClient({
- uri: 'http://localhost:4000/graphql',
- cache: new InMemoryCache()
-});
-
-function App() {
- return (
-
-
-
- );
-}
-
-function PostList() {
- const { loading, error, data } = useQuery(GET_ALL_POSTS);
-
- if (loading) return Loading...
;
- if (error) return Error :(
;
-
- return (
-
- {data.getAllPosts.map(post => (
- - {post.title}
- ))}
-
- );
-}
-
-const GET_ALL_POSTS = gql\`
- query GetAllPosts {
- getAllPosts {
- id
- title
- }
- }
-\`;
-\`\`\`
-
-## 性能优化策略
-
-1. 查询合并: 将多个查询合并为一个,减少网络请求
-2. 缓存管理: 合理使用缓存,避免重复请求
-3. 分页查询: 对大量数据进行分页查询,提高性能
-
-## 实践经验与注意事项
-
-1. 避免过度使用Subscriptions: Subscriptions可能会增加复杂性和性能开销
-2. 使用Apollo Client的最佳实践: 如使用\`useQuery\`和\`useMutation\`钩子
-3. 处理错误和异常: 使用GraphQL错误处理机制,如\`errors\`字段和\`onError\`回调
-
-GraphQL为前后端交互带来了新的可能性。通过掌握GraphQL的核心概念和最佳实践,前端开发者可以构建出高性能、可维护的API,为用户提供更好的体验。
- `,
+ content: content13,
date: "2024-05-15",
author: "孙十五",
tags: ["GraphQL", "API设计", "全栈开发"],
@@ -984,44 +152,7 @@ GraphQL为前后端交互带来了新的可能性。通过掌握GraphQL的核心
id: 14,
title: "前端安全最佳实践",
excerpt: "学习保护Web应用免受常见安全威胁...",
- content: `
-# 前端安全最佳实践
-
-随着Web应用日益复杂,前端安全变得越来越重要。本文将全面介绍前端安全最佳实践,并指导如何在实际项目中保护Web应用免受常见安全威胁。
-
-## XSS防御
-
-1. 使用内容安全策略(CSP): 限制可执行脚本的来源
-2. 输入验证: 对用户输入进行严格的验证和过滤
-
-## CSRF保护
-
-1. 使用合适的CSRF令牌机制: 如同步令牌、双重Cookie等
-2. 使用HTTPS: 确保数据传输的安全性
-
-## 安全的第三方库管理
-
-1. 使用npm audit和Snyk等工具: 定期检查依赖库的安全漏洞
-2. 使用安全的CDN: 如Google的Hosted Libraries
-
-## HTTPS
-
-1. 正确配置SSL/TLS: 使用强加密算法和证书
-2. 启用HSTS: 强制使用HTTPS
-
-## 安全的本地存储
-
-1. 敏感数据加密存储: 如使用Web Crypto API
-2. 使用HttpOnly Cookie: 避免JavaScript访问Cookie
-
-## 实践经验与注意事项
-
-1. 定期更新依赖库: 及时修补安全漏洞
-2. 使用安全的编码实践: 如避免使用\`eval()\`和\`innerHTML\`
-3. 使用安全的通信协议: 如使用HTTPS和TLS
-
-前端安全是一个持续的过程。通过不断学习和实践,前端开发者可以为用户提供更安全的Web应用,保护用户数据和隐私。
- `,
+ content: content14,
date: "2024-05-20",
author: "周十六",
tags: ["Web安全", "XSS", "CSRF"],
@@ -1030,46 +161,7 @@ GraphQL为前后端交互带来了新的可能性。通过掌握GraphQL的核心
id: 15,
title: "前端工程化与构建优化",
excerpt: "探索现代前端工程化实践和构建性能优化...",
- content: `
-# 前端工程化与构建优化
-
-前端工程化对于大型项目的可维护性和性能至关重要。本文将深入探讨前端工程化的各个方面,并指导如何优化构建过程,提高开发效率和应用性能。
-
-## 模块化
-
-1. ES6模块: 使用\`import\`和\`export\`语句
-2. CommonJS: 使用\`require()\`和\`module.exports\`
-3. AMD: 使用\`define()\`和\`require()\`
-
-## 构建工具
-
-1. Webpack: 强大而灵活的构建工具
-2. Rollup: 用于构建库的工具
-3. Vite: 基于ESM的快速构建工具
-
-## 代码分割
-
-1. 实现按需加载: 使用\`import()\`和\`React.lazy()\`
-2. 使用动态导入: 如\`import('module').then(module => {...})\`
-
-## Tree Shaking
-
-1. 消除无用代码: 使用ES6模块的静态分析特性
-2. 使用SideEffects标记: 避免无意义的Tree Shaking
-
-## 持续集成/持续部署(CI/CD)
-
-1. 自动化测试: 使用Jest、Mocha等工具
-2. 自动化部署: 使用GitHub Actions、Travis CI等平台
-
-## 实践经验与注意事项
-
-1. 使用ESLint和Prettier等工具: 保持代码风格一致
-2. 使用TypeScript: 提高代码可维护性和类型安全
-3. 使用Docker: 确保构建环境的一致性
-
-前端工程化和构建优化是一个持续的过程。通过不断学习和实践,前端开发者可以构建出高性能、可维护的大型前端应用,为用户提供更好的体验。
- `,
+ content: content15,
date: "2024-05-25",
author: "吴十七",
tags: ["工程化", "构建优化", "性能优化"],
diff --git a/src/data/ts/10.ts b/src/data/ts/10.ts
new file mode 100644
index 0000000..7aaa8c4
--- /dev/null
+++ b/src/data/ts/10.ts
@@ -0,0 +1,229 @@
+export const content10 = `
+# 微前端架构实践与性能优化
+
+微前端架构是一种将前端应用分解成更小、更易管理的独立部分的现代web开发方法。它允许多个独立开发、部署的前端应用共存于一个页面,为大型复杂的前端项目提供了灵活的解决方案。本文将深入探讨微前端的实现方法、通信机制、样式隔离、性能优化策略以及实践经验。
+
+## 微前端实现方法
+
+### 1. 使用Single-SPA框架
+
+Single-SPA是一个流行的微前端框架,它允许您在一个页面中加载和卸载多个JavaScript应用程序。
+
+\`\`\`javascript
+import { registerApplication, start } from 'single-spa';
+
+registerApplication({
+ name: 'app1',
+ app: () => import('./app1/main.js'),
+ activeWhen: '/app1'
+});
+
+registerApplication({
+ name: 'app2',
+ app: () => import('./app2/main.js'),
+ activeWhen: '/app2'
+});
+
+start();
+\`\`\`
+
+Single-SPA的优点包括:
+- 技术栈无关性
+- 独立部署
+- 懒加载
+
+### 2. 使用Qiankun框架
+
+Qiankun是基于Single-SPA的增强版微前端框架,提供了更多开箱即用的功能。
+
+\`\`\`javascript
+import { registerMicroApps, start } from 'qiankun';
+
+registerMicroApps([
+ {
+ name: 'app1',
+ entry: '//localhost:8080',
+ container: '#container',
+ activeRule: '/app1',
+ },
+ {
+ name: 'app2',
+ entry: '//localhost:8081',
+ container: '#container',
+ activeRule: '/app2',
+ },
+]);
+
+start();
+\`\`\`
+
+Qiankun的特点:
+- 简单易用的API
+- 完善的沙箱机制
+- 资源预加载
+
+### 3. Web Components方式
+
+使用原生Web Components也是实现微前端的一种方式:
+
+\`\`\`javascript
+class MicroApp extends HTMLElement {
+ connectedCallback() {
+ this.innerHTML = 'Micro App
';
+ // 加载微应用逻辑
+ }
+}
+
+customElements.define('micro-app', MicroApp);
+\`\`\`
+
+## 微前端通信机制
+
+### 1. 基于CustomEvent的发布订阅模式
+
+\`\`\`javascript
+// 发布事件
+window.dispatchEvent(new CustomEvent('myEvent', { detail: data }));
+
+// 订阅事件
+window.addEventListener('myEvent', (event) => {
+ console.log(event.detail);
+});
+\`\`\`
+
+### 2. 使用Props进行父子应用通信
+
+在主应用中:
+\`\`\`javascript
+
+\`\`\`
+
+在微应用中:
+\`\`\`javascript
+export function bootstrap({ prop1, prop2 }) {
+ // 使用prop1和prop2
+}
+\`\`\`
+
+### 3. 全局状态管理
+
+使用Redux或MobX等状态管理库来实现跨应用的状态共享。
+
+## 样式隔离
+
+### 1. BEM命名约定
+
+使用Block__Element--Modifier命名规范:
+
+\`\`\`css
+.app1__button--primary {
+ /* 样式 */
+}
+\`\`\`
+
+### 2. CSS Modules
+
+在webpack配置中启用CSS Modules:
+
+\`\`\`javascript
+{
+ test: /\.css$/,
+ use: [
+ 'style-loader',
+ {
+ loader: 'css-loader',
+ options: {
+ modules: true,
+ },
+ },
+ ],
+}
+\`\`\`
+
+### 3. Shadow DOM
+
+使用Shadow DOM实现完全的样式隔离:
+
+\`\`\`javascript
+class MicroApp extends HTMLElement {
+ constructor() {
+ super();
+ this.attachShadow({ mode: 'open' });
+ }
+
+ connectedCallback() {
+ this.shadowRoot.innerHTML = \`
+
+ Micro App Content
+ \`;
+ }
+}
+\`\`\`
+
+## 性能优化策略
+
+### 1. 应用预加载
+
+使用Qiankun的预加载功能:
+
+\`\`\`javascript
+import { prefetchApps } from 'qiankun';
+
+prefetchApps([
+ { name: 'app1', entry: '//localhost:8080' },
+ { name: 'app2', entry: '//localhost:8081' },
+]);
+\`\`\`
+
+### 2. 公共依赖提取
+
+使用webpack的externals配置:
+
+\`\`\`javascript
+module.exports = {
+ externals: {
+ 'react': 'React',
+ 'react-dom': 'ReactDOM',
+ },
+};
+\`\`\`
+
+### 3. 按需加载子应用
+
+使用动态import实现按需加载:
+
+\`\`\`javascript
+const loadApp = () => import('./app');
+\`\`\`
+
+## 实践经验与注意事项
+
+1. 统一技术栈,降低维护成本
+ - 尽可能使用相同的框架和库版本
+ - 制定统一的代码规范和最佳实践
+
+2. 制定明确的应用边界
+ - 明确划分各个微应用的职责
+ - 避免微应用之间的过度耦合
+
+3. 建立完善的监控体系
+ - 使用性能监控工具(如New Relic, Sentry)
+ - 实现自定义的错误捕获和上报机制
+
+4. 版本管理和发布策略
+ - 实施语义化版本控制
+ - 采用蓝绿部署或金丝雀发布等策略
+
+5. 安全性考虑
+ - 实现跨域资源共享(CORS)策略
+ - 使用内容安全策略(CSP)防止XSS攻击
+
+6. 测试策略
+ - 单元测试: 针对各个微应用的独立功能
+ - 集成测试: 测试微应用之间的交互
+ - 端到端测试: 模拟用户操作,测试整个系统
+
+微前端架构为大型前端项目提供了灵活的解决方案,但也带来了额外的复杂性。通过合理的架构设计、优化策略和最佳实践,我们可以充分发挥微前端的优势,构建高效、可维护的大型前端应用。在实施微前端架构时,需要权衡其带来的好处和潜在的挑战,根据项目的具体需求做出明智的选择。
+`;
diff --git a/src/data/ts/11.ts b/src/data/ts/11.ts
new file mode 100644
index 0000000..e06970b
--- /dev/null
+++ b/src/data/ts/11.ts
@@ -0,0 +1,174 @@
+export const content11 = `
+# 前端可视化技术的新趋势
+
+随着Web技术的不断发展,前端可视化已经成为现代Web应用中不可或缺的一部分。本文将深入探讨最新的3D渲染和数据可视化技术,以及它们在实际应用中的潜力。
+
+## WebGL和Three.js
+
+WebGL(Web Graphics Library)是一种用于在Web浏览器中渲染高性能、交互式3D和2D图形的JavaScript API。它基于OpenGL ES 2.0,利用GPU加速来实现复杂的图形渲染。
+
+Three.js是一个流行的JavaScript 3D库,它大大简化了使用WebGL创建3D场景的过程。通过提供高级抽象和丰富的功能,Three.js使开发者能够快速构建复杂的3D应用。
+
+### Three.js的核心概念
+
+1. 场景(Scene): 所有3D对象的容器
+2. 相机(Camera): 定义观察点和视角
+3. 渲染器(Renderer): 将3D场景渲染到2D屏幕上
+4. 几何体(Geometry): 定义3D对象的形状
+5. 材质(Material): 定义对象的外观
+6. 网格(Mesh): 几何体和材质的组合
+
+### 创建一个简单的3D场景
+
+以下代码展示了如何使用Three.js创建一个旋转的立方体:
+
+\`\`\`javascript
+import * as THREE from 'three';
+
+// 创建场景
+const scene = new THREE.Scene();
+
+// 创建相机
+const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+camera.position.z = 5;
+
+// 创建渲染器
+const renderer = new THREE.WebGLRenderer();
+renderer.setSize(window.innerWidth, window.innerHeight);
+document.body.appendChild(renderer.domElement);
+
+// 创建立方体
+const geometry = new THREE.BoxGeometry();
+const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
+const cube = new THREE.Mesh(geometry, material);
+scene.add(cube);
+
+// 动画循环
+function animate() {
+ requestAnimationFrame(animate);
+ cube.rotation.x += 0.01;
+ cube.rotation.y += 0.01;
+ renderer.render(scene, camera);
+}
+
+animate();
+\`\`\`
+
+这个例子展示了Three.js的基本用法,但它的功能远不止于此。开发者可以创建复杂的3D模型、添加光源和阴影、实现粒子系统,甚至创建VR体验。
+
+## 数据可视化库
+
+数据可视化是将复杂数据转化为直观、易懂的图形表示的过程。在前端开发中,有几个强大的库可以帮助我们实现这一目标。
+
+### 1. D3.js
+
+D3.js(Data-Driven Documents)是一个强大而灵活的JavaScript库,用于创建动态、交互式的数据可视化。它直接操作DOM,允许开发者将数据绑定到HTML或SVG元素上,然后使用强大的转换和过渡效果来操作这些元素。
+
+D3.js的优势:
+- 极高的灵活性和可定制性
+- 强大的数据绑定机制
+- 丰富的动画和交互能力
+- 广泛的社区支持和大量示例
+
+### 2. ECharts
+
+ECharts是百度开发的一个功能丰富的图表库,提供了直观、交互丰富、可高度个性化定制的数据可视化图表。
+
+ECharts的特点:
+- 丰富的图表类型
+- 响应式设计
+- 强大的交互功能
+- 大数据量展现能力
+
+### 使用ECharts创建交互式图表
+
+以下是使用ECharts创建一个简单柱状图的示例:
+
+\`\`\`javascript
+import * as echarts from 'echarts';
+
+// 初始化图表
+const chartDom = document.getElementById('main');
+const myChart = echarts.init(chartDom);
+
+// 配置选项
+const option = {
+ title: {
+ text: '周销售数据'
+ },
+ tooltip: {},
+ xAxis: {
+ type: 'category',
+ data: ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
+ },
+ yAxis: {
+ type: 'value'
+ },
+ series: [{
+ name: '销售额',
+ type: 'bar',
+ data: [120, 200, 150, 80, 70, 110, 130],
+ itemStyle: {
+ color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
+ {offset: 0, color: '#83bff6'},
+ {offset: 0.5, color: '#188df0'},
+ {offset: 1, color: '#188df0'}
+ ])
+ }
+ }]
+};
+
+// 使用配置项设置图表
+myChart.setOption(option);
+\`\`\`
+
+这个例子展示了如何创建一个带有渐变色的基本柱状图。ECharts支持更多复杂的图表类型和交互功能,如地图、散点图、热力图等。
+
+## WebGPU: 下一代图形和计算API
+
+WebGPU是一个新兴的Web标准,旨在提供对现代图形硬件更直接的访问。它有望在未来取代WebGL,成为Web上高性能图形和通用计算的首选API。
+
+WebGPU的主要优势:
+1. 更低级的硬件访问,提供更高的性能
+2. 更现代的API设计,简化复杂任务的实现
+3. 支持通用GPU计算(GPGPU),扩展了Web应用的计算能力
+4. 更好的跨平台一致性
+
+虽然WebGPU仍在开发中,但它已经显示出巨大的潜力,特别是在以下领域:
+- 高性能3D渲染
+- 科学可视化
+- 机器学习
+- 物理模拟
+
+## 实际应用案例
+
+前端可视化技术在各个领域都有广泛的应用。以下是一些具体的案例:
+
+### 1. 交互式数据仪表板
+
+现代商业智能(BI)工具大量使用前端可视化技术来创建动态、交互式的数据仪表板。这些仪表板可以实时显示关键业务指标,帮助决策者快速洞察数据趋势。
+
+### 2. 3D产品展示
+
+电商和制造业越来越多地采用3D产品展示技术。用户可以360度旋转查看产品,甚至在虚拟环境中"试用"产品。这种交互式体验大大提升了用户参与度和购买信心。
+
+### 3. 虚拟现实(VR)和增强现实(AR)应用
+
+WebXR API结合Three.js等3D库,使得在Web浏览器中创建VR和AR体验成为可能。这项技术正在改变教育、培训、娱乐和零售等多个行业。
+
+### 4. 地理信息系统(GIS)
+
+结合WebGL和地图数据,开发者可以创建复杂的3D地图可视化,用于城市规划、环境监测、物流优化等领域。
+
+### 5. 科学可视化
+
+在医学、物理学、气象学等领域,复杂的科学数据通过高级可视化技术变得更加直观和易于理解。例如,3D分子模型、天气模拟等。
+
+## 结论
+
+前端可视化技术正在不断突破边界,为用户提供更丰富、更直观的数据展示和交互体验。从WebGL到WebGPU,从D3.js到ECharts,这些工具和技术使得创建复杂的可视化变得前所未有的简单。
+
+随着硬件性能的提升和新标准的出现,我们可以期待看到更多令人惊叹的视觉效果和创新应用。对于前端开发者来说,掌握这些可视化技术不仅可以提升技术能力,还能为用户创造出更加吸引人和有价值的Web体验。
+
+在这个数据驱动的时代,有效的数据可视化已经成为沟通和决策的关键工具。通过不断学习和实践这些新兴技术,前端开发者可以在这个快速发展的领域中保持竞争力,并为塑造未来的数字体验做出重要贡献。
+`;
diff --git a/src/data/ts/12.ts b/src/data/ts/12.ts
new file mode 100644
index 0000000..651efe6
--- /dev/null
+++ b/src/data/ts/12.ts
@@ -0,0 +1,214 @@
+export const content12 = `# 渐进式Web应用(PWA)开发指南
+
+渐进式Web应用(Progressive Web Apps, PWA)是现代Web应用开发的一个重要趋势,它结合了Web和原生应用的优点,为用户提供接近原生应用的体验。本文将深入探讨PWA的核心技术、实现方法以及未来发展趋势。
+
+## PWA的核心特性
+
+1. 可靠性(Reliable): 即使在不稳定的网络环境下也能加载运行
+2. 快速(Fast): 响应迅速,动画流畅
+3. 沉浸式(Engaging): 提供类似原生应用的用户体验
+
+## Service Workers
+
+Service Workers是PWA的核心技术,它是一个运行在浏览器背景中的脚本,使得应用能够控制网络请求、实现离线缓存、后台同步等功能。
+
+### 注册Service Worker
+
+首先,我们需要在应用中注册Service Worker:
+
+\`\`\`javascript
+if ('serviceWorker' in navigator) {
+ window.addEventListener('load', function() {
+ navigator.serviceWorker.register('/sw.js').then(function(registration) {
+ console.log('ServiceWorker registration successful with scope: ', registration.scope);
+ }, function(err) {
+ console.log('ServiceWorker registration failed: ', err);
+ });
+ });
+}
+\`\`\`
+
+### 实现离线缓存
+
+在Service Worker文件(sw.js)中,我们可以实现离线缓存功能:
+
+\`\`\`javascript
+// sw.js
+const CACHE_NAME = 'my-site-cache-v1';
+const urlsToCache = [
+ '/',
+ '/styles/main.css',
+ '/script/main.js',
+ '/images/logo.png'
+];
+
+// 安装事件: 缓存资源
+self.addEventListener('install', function(event) {
+ event.waitUntil(
+ caches.open(CACHE_NAME)
+ .then(function(cache) {
+ console.log('Opened cache');
+ return cache.addAll(urlsToCache);
+ })
+ );
+});
+
+// 激活事件: 清理旧缓存
+self.addEventListener('activate', function(event) {
+ event.waitUntil(
+ caches.keys().then(function(cacheNames) {
+ return Promise.all(
+ cacheNames.map(function(cacheName) {
+ if (cacheName !== CACHE_NAME) {
+ return caches.delete(cacheName);
+ }
+ })
+ );
+ })
+ );
+});
+
+// 拦截网络请求
+self.addEventListener('fetch', function(event) {
+ event.respondWith(
+ caches.match(event.request)
+ .then(function(response) {
+ // 如果找到缓存的响应,则返回缓存
+ if (response) {
+ return response;
+ }
+ // 否则发起网络请求
+ return fetch(event.request).then(
+ function(response) {
+ // 检查是否是有效的响应
+ if(!response || response.status !== 200 || response.type !== 'basic') {
+ return response;
+ }
+ // 克隆响应
+ var responseToCache = response.clone();
+ caches.open(CACHE_NAME)
+ .then(function(cache) {
+ cache.put(event.request, responseToCache);
+ });
+ return response;
+ }
+ );
+ })
+ );
+});
+\`\`\`
+
+## Web App Manifest
+
+Web App Manifest是一个JSON文件,定义了应用的图标、名称、启动行为等信息,使PWA能够像原生应用一样被添加到主屏幕。
+
+\`\`\`json
+{
+ "name": "我的PWA应用",
+ "short_name": "MyPWA",
+ "description": "这是一个示例PWA应用",
+ "icons": [
+ {
+ "src": "icons/icon-192x192.png",
+ "sizes": "192x192",
+ "type": "image/png"
+ },
+ {
+ "src": "icons/icon-512x512.png",
+ "sizes": "512x512",
+ "type": "image/png"
+ }
+ ],
+ "start_url": "/",
+ "display": "standalone",
+ "background_color": "#ffffff",
+ "theme_color": "#000000",
+ "orientation": "portrait",
+ "scope": "/",
+ "lang": "zh-CN"
+}
+\`\`\`
+
+在HTML中引用Manifest文件:
+
+\`\`\`html
+
+\`\`\`
+
+## Push Notifications
+
+Push Notifications允许应用向用户发送实时通知,即使在用户未打开应用的情况下也能工作。
+
+### 请求通知权限
+
+\`\`\`javascript
+function requestNotificationPermission() {
+ Notification.requestPermission().then(function(permission) {
+ if (permission === 'granted') {
+ console.log('通知权限已授予');
+ subscribeUserToPush();
+ } else {
+ console.log('通知权限被拒绝');
+ }
+ });
+}
+\`\`\`
+
+### 订阅推送服务
+
+\`\`\`javascript
+function subscribeUserToPush() {
+ return navigator.serviceWorker.register('/sw.js')
+ .then(function(registration) {
+ const subscribeOptions = {
+ userVisibleOnly: true,
+ applicationServerKey: urlBase64ToUint8Array(
+ 'BEl62iUYgUivxIkv69yViEuiBIa-Ib9-SkvMeAtA3LFgDzkrxZJjSgSnfckjBJuBkr3qBUYIHBQFLXYp5Nksh8U'
+ )
+ };
+
+ return registration.pushManager.subscribe(subscribeOptions);
+ })
+ .then(function(pushSubscription) {
+ console.log('Received PushSubscription: ', JSON.stringify(pushSubscription));
+ return pushSubscription;
+ });
+}
+\`\`\`
+
+### 处理推送事件
+
+在Service Worker中处理推送事件:
+
+\`\`\`javascript
+self.addEventListener('push', function(event) {
+ console.log('[Service Worker] Push Received.');
+ console.log(\`[Service Worker] Push had this data: "\${event.data.text()}"\`);
+
+ const title = '推送通知';
+ const options = {
+ body: event.data.text(),
+ icon: 'icons/icon-192x192.png',
+ badge: 'icons/badge-128x128.png'
+ };
+
+ event.waitUntil(self.registration.showNotification(title, options));
+});
+\`\`\`
+
+## PWA的未来发展
+
+PWA技术正在不断发展,未来将会有更多令人兴奋的特性:
+
+1. Web Bluetooth: 允许Web应用与蓝牙设备通信
+2. Web USB: 提供对USB设备的访问
+3. Web Share: 实现内容的原生分享功能
+4. Background Sync: 在网络恢复时自动同步数据
+5. Payment Request API: 简化Web支付流程
+6. Web Assembly: 提高Web应用的性能
+7. AR/VR支持: 通过WebXR API实现增强现实和虚拟现实体验
+
+## 结论
+
+PWA代表了Web应用的未来发展方向,它结合了Web的开放性和原生应用的优势。通过掌握Service Workers、Web App Manifest和Push Notifications等核心技术,开发者可以构建出性能卓越、用户体验出色的Web应用。随着PWA技术的不断发展和浏览器支持的改进,我们可以期待看到更多创新和令人兴奋的PWA应用出现。
+`;
diff --git a/src/data/ts/13.ts b/src/data/ts/13.ts
new file mode 100644
index 0000000..31d29be
--- /dev/null
+++ b/src/data/ts/13.ts
@@ -0,0 +1,344 @@
+export const content13 = `
+# GraphQL与现代API设计:深入探讨与实践指南
+
+GraphQL正在彻底改变我们设计和使用API的方式。本文将深入探讨GraphQL的核心概念、优势以及在实际项目中的应用,为开发者提供全面的GraphQL实践指南。
+
+## 1. GraphQL简介
+
+GraphQL是由Facebook开发并开源的一种用于API的查询语言和运行时。它的出现解决了传统REST API面临的一些挑战,为现代应用程序提供了更灵活、高效的数据交互方式。
+
+### 1.1 核心特性
+
+1. **类型系统**:
+ - GraphQL使用强类型定义,提高了API的可预测性和可靠性。
+ - 通过Schema定义,前后端可以清晰地了解数据结构和可用操作。
+
+2. **按需获取**:
+ - 客户端可以精确指定所需的数据字段,避免过度获取(over-fetching)和数据不足(under-fetching)问题。
+ - 这种灵活性使得前端可以更自由地设计UI,而不受后端API结构的限制。
+
+3. **实时更新**:
+ - GraphQL的Subscriptions支持实时数据流,适用于需要即时更新的应用场景。
+ - 相比WebSocket,Subscriptions提供了更结构化和类型安全的实时数据传输方式。
+
+4. **单一端点**:
+ - 所有的查询和变更操作都通过单一的API端点进行,简化了API的版本管理和维护。
+
+5. **内省(Introspection)**:
+ - GraphQL API可以查询自身的Schema,这为自动生成文档和开发工具提供了基础。
+
+## 2. GraphQL vs REST
+
+| 特性 | GraphQL | REST |
+|------|---------|------|
+| 数据获取 | 精确获取所需数据 | 可能存在过度获取或数据不足 |
+| 端点 | 单一端点 | 多个端点 |
+| 版本控制 | 无需显式版本控制 | 通常需要版本控制 |
+| 实时更新 | 原生支持(Subscriptions) | 需要额外实现(如WebSocket) |
+| 类型安全 | 强类型系统 | 通常无内置类型系统 |
+
+## 3. 深入GraphQL核心概念
+
+### 3.1 Schema定义语言(SDL)
+
+GraphQL使用SDL来定义API的类型系统。以下是一个更复杂的Schema示例:
+
+\`\`\`graphql
+type Query {
+ getPost(id: ID!): Post
+ getAllPosts(page: Int = 1, limit: Int = 10): PostConnection!
+ searchPosts(keyword: String!): [Post!]!
+}
+
+type Mutation {
+ createPost(input: PostInput!): Post
+ updatePost(id: ID!, input: PostInput!): Post
+ deletePost(id: ID!): Boolean!
+ likePost(id: ID!): Post
+}
+
+type Subscription {
+ postCreated: Post
+ postUpdated(id: ID!): Post
+}
+
+type Post {
+ id: ID!
+ title: String!
+ content: String!
+ author: Author!
+ comments: [Comment!]!
+ createdAt: DateTime!
+ updatedAt: DateTime
+ likes: Int!
+}
+
+type Author {
+ id: ID!
+ name: String!
+ email: String!
+ posts: [Post!]!
+}
+
+type Comment {
+ id: ID!
+ content: String!
+ author: Author!
+ createdAt: DateTime!
+}
+
+type PostConnection {
+ edges: [PostEdge!]!
+ pageInfo: PageInfo!
+}
+
+type PostEdge {
+ node: Post!
+ cursor: String!
+}
+
+type PageInfo {
+ hasNextPage: Boolean!
+ endCursor: String
+}
+
+input PostInput {
+ title: String!
+ content: String!
+ authorId: ID!
+}
+
+scalar DateTime
+\`\`\`
+
+### 3.2 解析器(Resolvers)
+
+解析器是GraphQL服务器的核心,负责实现Schema中定义的字段。以下是一个示例解析器:
+
+\`\`\`javascript
+const resolvers = {
+ Query: {
+ getPost: async (_, { id }, context) => {
+ // 实现获取单个帖子的逻辑
+ },
+ getAllPosts: async (_, { page, limit }, context) => {
+ // 实现分页获取帖子的逻辑
+ },
+ searchPosts: async (_, { keyword }, context) => {
+ // 实现搜索帖子的逻辑
+ }
+ },
+ Mutation: {
+ createPost: async (_, { input }, context) => {
+ // 实现创建帖子的逻辑
+ },
+ // ... 其他mutation解析器
+ },
+ Subscription: {
+ postCreated: {
+ subscribe: (_, __, { pubsub }) => pubsub.asyncIterator(['POST_CREATED'])
+ },
+ // ... 其他subscription解析器
+ },
+ Post: {
+ author: async (post, _, context) => {
+ // 实现获取帖子作者的逻辑
+ },
+ comments: async (post, _, context) => {
+ // 实现获取帖子评论的逻辑
+ }
+ }
+ // ... 其他类型的解析器
+};
+\`\`\`
+
+## 4. 使用GraphQL客户端
+
+### 4.1 Apollo Client
+
+Apollo Client是最流行的GraphQL客户端库之一,提供了强大的缓存和状态管理功能。
+
+\`\`\`javascript
+import { ApolloClient, InMemoryCache, ApolloProvider, useQuery, useMutation } from '@apollo/client';
+
+// 创建Apollo Client实例
+const client = new ApolloClient({
+ uri: 'http://localhost:4000/graphql',
+ cache: new InMemoryCache()
+});
+
+// 在React应用中使用ApolloProvider
+function App() {
+ return (
+
+
+
+ );
+}
+
+// 使用useQuery钩子获取数据
+function PostList() {
+ const { loading, error, data } = useQuery(GET_ALL_POSTS, {
+ variables: { page: 1, limit: 10 }
+ });
+
+ if (loading) return 加载中...
;
+ if (error) return 错误: {error.message}
;
+
+ return (
+
+ {data.getAllPosts.edges.map(({ node }) => (
+ - {node.title}
+ ))}
+
+ );
+}
+
+// GraphQL查询
+const GET_ALL_POSTS = gql\`
+ query GetAllPosts($page: Int!, $limit: Int!) {
+ getAllPosts(page: $page, limit: $limit) {
+ edges {
+ node {
+ id
+ title
+ }
+ }
+ pageInfo {
+ hasNextPage
+ endCursor
+ }
+ }
+ }
+\`;
+
+// 使用useMutation钩子执行变更操作
+function CreatePostForm() {
+ const [createPost, { data, loading, error }] = useMutation(CREATE_POST);
+
+ const handleSubmit = (event) => {
+ event.preventDefault();
+ createPost({ variables: { input: { /* 表单数据 */ } } });
+ };
+
+ // 渲染表单
+}
+
+const CREATE_POST = gql\`
+ mutation CreatePost($input: PostInput!) {
+ createPost(input: $input) {
+ id
+ title
+ content
+ }
+ }
+\`;
+\`\`\`
+
+### 4.2 Relay
+
+Relay是Facebook开发的另一个强大的GraphQL客户端,特别适合大型、复杂的React应用。
+
+## 5. GraphQL性能优化策略
+
+1. **查询合并**:
+ - 使用Apollo Client的\`apollo-link-batch-http\`可以自动合并多个查询为一个HTTP请求。
+ - 示例配置:
+ \`\`\`javascript
+ import { BatchHttpLink } from "@apollo/client/link/batch-http";
+
+ const link = new BatchHttpLink({ uri: "/graphql", batchMax: 5 });
+ \`\`\`
+
+2. **缓存管理**:
+ - 利用Apollo Client的缓存机制,避免重复请求。
+ - 使用\`@connection\`指令管理分页数据的缓存。
+ - 示例:
+ \`\`\`graphql
+ query GetAllPosts($cursor: String) {
+ getAllPosts(first: 10, after: $cursor) @connection(key: "PostList") {
+ edges {
+ node {
+ id
+ title
+ }
+ }
+ }
+ }
+ \`\`\`
+
+3. **分页查询**:
+ - 实现基于游标的分页,提高大数据集的查询效率。
+ - 使用\`fetchMore\`函数加载更多数据。
+
+4. **数据预取**:
+ - 使用Apollo Client的\`prefetch\`方法预加载数据,提升用户体验。
+
+5. **选择性轮询**:
+ - 对需要频繁更新的数据使用轮询,而不是全局Subscription。
+
+## 6. GraphQL安全性考虑
+
+1. **查询复杂度限制**:
+ - 使用工具如\`graphql-depth-limit\`限制查询深度。
+ - 示例:
+ \`\`\`javascript
+ import depthLimit from 'graphql-depth-limit';
+
+ const server = new ApolloServer({
+ schema,
+ validationRules: [depthLimit(5)]
+ });
+ \`\`\`
+
+2. **速率限制**:
+ - 实现API级别的速率限制,防止DoS攻击。
+
+3. **身份验证和授权**:
+ - 在解析器中实现细粒度的权限控制。
+
+4. **输入验证**:
+ - 使用自定义标量类型和输入验证逻辑确保数据安全。
+
+## 7. GraphQL最佳实践
+
+1. **使用片段(Fragments)**:
+ - 复用查询片段,提高代码可维护性。
+ - 示例:
+ \`\`\`graphql
+ fragment PostFields on Post {
+ id
+ title
+ content
+ }
+
+ query GetPost($id: ID!) {
+ getPost(id: $id) {
+ ...PostFields
+ author {
+ name
+ }
+ }
+ }
+ \`\`\`
+
+2. **错误处理**:
+ - 利用GraphQL的错误处理机制,返回结构化的错误信息。
+ - 在客户端优雅地处理错误。
+
+3. **版本控制策略**:
+ - 使用字段别名和可空字段实现API演进。
+ - 避免破坏性更改,保持向后兼容性。
+
+4. **文档和注释**:
+ - 在Schema中使用描述性注释,生成自动文档。
+ - 使用工具如GraphQL Playground提供交互式文档。
+
+5. **性能监控**:
+ - 使用Apollo Studio等工具监控GraphQL查询性能。
+ - 分析慢查询,优化热点字段。
+
+## 结论
+
+GraphQL为现代API设计带来了革命性的变化,提供了更灵活、高效的数据交互方式。通过深入理解GraphQL的核心概念、最佳实践和优化策略,开发者可以构建出高性能、可扩展的API,为用户提供卓越的应用体验。随着生态系统的不断发展,GraphQL正在成为构建下一代Web和移动应用的关键技术。
+`;
diff --git a/src/data/ts/14.ts b/src/data/ts/14.ts
new file mode 100644
index 0000000..189adad
--- /dev/null
+++ b/src/data/ts/14.ts
@@ -0,0 +1,131 @@
+export const content14 = `
+# 前端安全最佳实践: 全面保护您的Web应用
+
+在当今复杂的网络环境中,前端安全已成为Web开发中不可忽视的关键环节。本文将深入探讨前端安全最佳实践,为开发者提供全面的指导,以构建更安全、更可靠的Web应用。
+
+## XSS (跨站脚本) 防御
+
+跨站脚本攻击是最常见且危险的Web安全威胁之一。以下是防御XSS的关键策略:
+
+1. 内容安全策略 (CSP):
+ - 实施严格的CSP: 限制可执行脚本、样式和其他资源的来源。
+ - 示例: \`Content-Security-Policy: default-src 'self'; script-src 'self' https://trusted.cdn.com\`
+
+2. 输入验证与输出编码:
+ - 对所有用户输入进行严格验证和过滤。
+ - 在输出到HTML、JavaScript、CSS或URL时,使用适当的编码函数。
+ - 使用成熟的库如DOMPurify进行HTML净化。
+
+3. HttpOnly和Secure标志:
+ - 为敏感Cookie设置HttpOnly标志,防止JavaScript访问。
+ - 使用Secure标志确保Cookie仅通过HTTPS传输。
+
+4. X-XSS-Protection头:
+ - 启用浏览器内置的XSS过滤器: \`X-XSS-Protection: 1; mode=block\`
+
+## CSRF (跨站请求伪造) 保护
+
+CSRF攻击利用用户的已认证会话执行未授权操作。防御措施包括:
+
+1. CSRF令牌:
+ - 实现同步令牌模式: 在表单中包含随机生成的令牌。
+ - 双重提交Cookie: 将令牌同时存储在Cookie和请求参数中。
+
+2. SameSite Cookie属性:
+ - 设置\`SameSite=Strict\`或\`SameSite=Lax\`限制跨站Cookie传输。
+
+3. 自定义请求头:
+ - 为AJAX请求添加自定义头,如\`X-Requested-With: XMLHttpRequest\`。
+
+4. 验证Referer和Origin:
+ - 检查请求的Referer或Origin头,确保请求来自合法来源。
+
+## 安全的第三方库管理
+
+第三方库可能引入安全漏洞,需要谨慎管理:
+
+1. 依赖审计:
+ - 使用npm audit、yarn audit或Snyk定期检查依赖。
+ - 集成到CI/CD流程中,自动化漏洞检测。
+
+2. 版本锁定:
+ - 使用package-lock.json或yarn.lock锁定依赖版本。
+ - 定期更新并测试最新的安全补丁。
+
+3. 子资源完整性 (SRI):
+ - 为CDN资源添加integrity属性,确保内容未被篡改。
+ - 示例: \`\`
+
+## HTTPS 实施
+
+HTTPS对于保护数据传输至关重要:
+
+1. 全站HTTPS:
+ - 将所有HTTP流量重定向到HTTPS。
+ - 使用HSTS (HTTP严格传输安全) 头强制HTTPS连接。
+
+2. 正确配置TLS:
+ - 使用强加密套件,禁用不安全的协议版本。
+ - 定期更新和轮换SSL/TLS证书。
+
+3. 证书透明度 (CT) 日志:
+ - 监控CT日志,及时发现针对您域名的可疑证书颁发。
+
+## 安全的客户端存储
+
+正确使用客户端存储机制对保护用户数据至关重要:
+
+1. 敏感数据加密:
+ - 使用Web Crypto API进行客户端加密。
+ - 避免在localStorage中存储敏感信息。
+
+2. IndexedDB安全:
+ - 实施适当的访问控制和数据隔离。
+ - 考虑对存储的数据进行加密。
+
+3. 安全的会话管理:
+ - 使用服务器端会话存储敏感数据。
+ - 实现会话超时和安全的注销机制。
+
+## 高级安全实践
+
+1. 子域隔离:
+ - 将不同功能部署到不同子域,限制潜在攻击面。
+
+2. 浏览器指纹防护:
+ - 最小化暴露给第三方脚本的信息。
+ - 考虑使用隐私保护技术如Tor浏览器。
+
+3. WebSocket安全:
+ - 实施适当的身份验证和授权机制。
+ - 使用wss://协议确保加密传输。
+
+4. 防御点击劫持:
+ - 使用X-Frame-Options或CSP frame-ancestors指令。
+
+5. API安全:
+ - 实施速率限制和请求节流。
+ - 使用OAuth 2.0和OpenID Connect进行安全授权。
+
+## 持续安全实践
+
+1. 安全编码规范:
+ - 制定并执行安全编码指南。
+ - 进行定期的代码审查和安全培训。
+
+2. 漏洞赏金计划:
+ - 考虑建立漏洞赏金项目,鼓励外部研究人员报告安全问题。
+
+3. 安全监控和响应:
+ - 实施日志记录和监控系统。
+ - 制定并演练安全事件响应计划。
+
+4. 定期安全评估:
+ - 进行渗透测试和安全审计。
+ - 使用自动化工具进行持续的安全扫描。
+
+结论:
+前端安全是一个动态且持续的过程,需要开发者保持警惕并不断学习。通过实施这些最佳实践,您可以显著提高Web应用的安全性,保护用户数据和隐私。记住,安全不是一次性的工作,而是需要持续关注和改进的领域。让我们共同努力,为用户创造一个更安全的网络环境!
+`;
diff --git a/src/data/ts/15.ts b/src/data/ts/15.ts
new file mode 100644
index 0000000..de33855
--- /dev/null
+++ b/src/data/ts/15.ts
@@ -0,0 +1,261 @@
+export const content15 = `
+# 前端工程化与构建优化
+
+前端工程化对于大型项目的可维护性和性能至关重要。本文将深入探讨前端工程化的各个方面,并指导如何优化构建过程,提高开发效率和应用性能。
+
+## 模块化
+
+模块化是前端工程化的基础,它允许我们将代码分割成可重用的独立单元。
+
+1. ES6模块:
+ - 使用\`import\`和\`export\`语句
+ - 静态分析,有利于Tree Shaking
+ - 示例:
+ \`\`\`javascript
+ // math.js
+ export const add = (a, b) => a + b;
+
+ // main.js
+ import { add } from './math.js';
+ console.log(add(2, 3));
+ \`\`\`
+
+2. CommonJS:
+ - 使用\`require()\`和\`module.exports\`
+ - Node.js默认使用的模块系统
+ - 示例:
+ \`\`\`javascript
+ // math.js
+ module.exports.add = (a, b) => a + b;
+
+ // main.js
+ const { add } = require('./math.js');
+ console.log(add(2, 3));
+ \`\`\`
+
+3. AMD (Asynchronous Module Definition):
+ - 使用\`define()\`和\`require()\`
+ - 专为浏览器设计的异步模块加载系统
+ - 示例:
+ \`\`\`javascript
+ // math.js
+ define([], function() {
+ return {
+ add: function(a, b) { return a + b; }
+ };
+ });
+
+ // main.js
+ require(['math'], function(math) {
+ console.log(math.add(2, 3));
+ });
+ \`\`\`
+
+## 构建工具
+
+构建工具帮助我们自动化开发流程,处理资源,优化输出。
+
+1. Webpack:
+ - 强大而灵活的构建工具
+ - 支持多种模块系统
+ - 丰富的插件生态系统
+ - 配置示例:
+ \`\`\`javascript
+ // webpack.config.js
+ module.exports = {
+ entry: './src/index.js',
+ output: {
+ filename: 'bundle.js',
+ path: path.resolve(__dirname, 'dist'),
+ },
+ module: {
+ rules: [
+ {
+ test: /\.js$/,
+ use: 'babel-loader',
+ exclude: /node_modules/,
+ },
+ ],
+ },
+ };
+ \`\`\`
+
+2. Rollup:
+ - 专注于构建库的工具
+ - 生成更小、更高效的bundle
+ - 配置示例:
+ \`\`\`javascript
+ // rollup.config.js
+ export default {
+ input: 'src/main.js',
+ output: {
+ file: 'bundle.js',
+ format: 'cjs'
+ }
+ };
+ \`\`\`
+
+3. Vite:
+ - 基于ESM的快速构建工具
+ - 开发时无需打包,利用浏览器原生ES模块
+ - 配置示例:
+ \`\`\`javascript
+ // vite.config.js
+ export default {
+ plugins: [],
+ build: {
+ target: 'esnext',
+ minify: 'terser'
+ }
+ };
+ \`\`\`
+
+## 代码分割
+
+代码分割可以提高应用的加载速度,实现按需加载。
+
+1. 实现按需加载:
+ - 使用\`import()\`和\`React.lazy()\`
+ - 示例:
+ \`\`\`jsx
+ const OtherComponent = React.lazy(() => import('./OtherComponent'));
+
+ function MyComponent() {
+ return (
+ Loading... }>
+