纸盒

Navicat for mysql 注册Navicat_Keygen_Patch_v5.6_By_DFoX使用方法

Sun, 01 Feb 2026 15:16:52 +0800

在Nacicat官网下载Navicat for mysql 之后安装成功之后

将Navicat_Keygen_Patch_v5.6_By_DFoX 复制到Navicat for mysql的安装目录下
Navicat_Keygen_Patch_v5.6_By_DFoX 链接：https://pan.baidu.com/s/1fUNyyEmHKj5NnR9acrwPsA
提取码：lu5p
在Navicat关闭的情况下,运行该注册程序
点击patch 弹出窗口，显示为下图就是成功了

点击Generate—>出现序列码—>点击Copy
打开navicat,第一次打开的时候点击注册，然后把刚才copy的序列码复制进去，点击激活。
选择手动激活
然后会生成一大串请求码,复制请求码到注册机中的Request Code中，点击Activation Code下的generate，生成激活码

点击generate，生成激活码会自动复制

点击激活！！！即可

关于Nest.js 现代后端开发的一些指南

Tue, 16 Sep 2025 18:49:22 +0800

第一部分：认识Nest.js的「骨架」

1.1 框架定位

想象你要盖房子：

Express/Fastify = 给你砖头和水泥（基础工具）
Nest = 预制钢结构框架+施工图纸（企业级架构方案）

核心价值：用Angular风格的架构解决 Node.js 后端松散问题

1.2 核心三件套

// 典型结构示例
@Module({
  controllers: [CatsController],  // 接待处：处理请求
  providers: [CatsService],       // 工人：实际干活的
  imports: [DatabaseModule]       // 工具箱：其他模块的工具
})
export class CatsModule {}

1.3 依赖注入（DI）

场景：咖啡店点单

传统方式：你自己去后厨找牛奶、咖啡豆（紧密耦合）
DI模式：告诉服务员「我要拿铁」，后厨自动配齐（解耦）

代码体现：

// 错误示范：直接实例化（自己冲进后厨）
classCatController{
constructor(){
    this.catService =newCatService();// 耦合性强
}
}
// 正确做法：声明依赖（优雅点单）
@Controller()
classCatController{
constructor(privatereadonly catService: CatService){}// Nest自动注入
}

1.4 第一个Hello World（动手验证）

步骤分解：

安装脚手架：npm i -g @nestjs/cli
创建项目：nest new hello-world
核心文件结构：

src/
├─ main.ts          // 程序入口（点火装置）
├─ app.module.ts    // 主模块（大脑）
└─ app.controller.ts // 路由控制器（接线员）

修改app.controller.ts：

@Get()
getHello(): string {
  return '你好，这里是自定义问候语！'; // 修改官方默认响应
}

1.5 典型目录结构

以下是一份典型的Nest.js项目目录结构及注释说明，适用于中大型项目开发：

├── src/
│   ├── common/              # 通用共享模块
│   │   ├── decorators/      # 自定义装饰器（如@Roles）
│   │   ├── filters/         # 异常过滤器（全局异常处理）
│   │   ├── interceptors/    # 拦截器（响应格式化/日志）
│   │   └── middleware/      # 全局中间件（CORS/日志）
│   │
│   ├── config/              # 配置相关
│   │   ├── app.config.ts    # 应用基础配置
│   │   └── env/            # 环境配置校验
│   │
│   ├── database/            # 数据库模块
│   │   ├── entities/        # TypeORM实体类
│   │   ├── migrations/      # 数据库迁移脚本
│   │   └── database.module.ts
│   │
│   ├── auth/                # 认证授权模块
│   │   ├── strategies/      # Passport策略（JWT/Local）
│   │   ├── guards/          # 守卫（角色验证）
│   │   ├── dto/            # 数据传输对象（登录/注册）
│   │   └── auth.module.ts
│   │
│   ├── user/                # 用户模块
│   │   ├── user.controller.ts
│   │   ├── user.service.ts
│   │   ├── dto/            # DTO（创建/更新用户）
│   │   └── user.module.ts
│   │
│   ├── app.module.ts        # 根模块
│   └── main.ts              # 应用入口文件
│
├── test/                   # 测试目录
│   ├── e2e/               # 端到端测试
│   └── unit/              # 单元测试
│
├── public/                # 静态资源目录
├── uploads/               # 文件上传存储目录
│
├── .env                   # 本地环境变量
├── .env.prod              # 生产环境变量
├── docker-compose.yml     # Docker容器编排
├── Dockerfile             # Docker构建配置
├── nest-cli.json          # Nest CLI配置
├── package.json           # 依赖管理
└── tsconfig.json          # TypeScript配置

第二部分：控制器——你的业务「接线员」

2.1 控制器的本质

想象你有一个快递分拣中心：

包裹（请求）进入传送带
分拣机器人（控制器）根据：

目的地地址（路由路径）
包裹类型（HTTP方法）
决定送到哪个处理区（处理方法）

2.2 创建业务控制器

# 命令行生成控制器（最佳实践）
nest generate controller user

生成文件结构：

src/
└─ user/
   ├─ user.controller.ts
   ├─ user.service.ts
   └─ user.module.ts

2.3 路由方法实战（Restful风格）

@Controller('users')// 基础路径 /users
exportclassUserController{
// GET /users/profile
@Get('profile')
getProfile(){
    return'用户张三的个人页面';
}
// POST /users/register
@Post('register')
registerUser(@Body() userData:any){
    console.log('收到注册数据:', userData);
    return{ success:true, userId:123};
}
// 动态路由参数 /users/orders/789
@Get('orders/:orderId')
getOrder(@Param('orderId') orderId:string){
    return`查询订单${orderId}的详细信息`;
}
}

2.4 参数获取三大招

路径参数：@Param('id')

// GET /product/iphone-15
@Get(':model')
getProduct(@Param('model') model: string) {
  return `正在查询${model}型号`;
}

查询参数：@Query()

// GET /search?q=nestjs&page=2
@Get('search')
search(@Query() params: { q: string; page: number }) {
  return `搜索关键词：${params.q}，第${params.page}页`;
}

请求体：@Body()

// POST /login
@Post('login')
login(@Body() credentials: { username: string; password: string }) {
  // 实际开发中这里会调用验证服务
  return `用户${credentials.username}正在尝试登录`;
}

2.5 DTO模式（重要防御层）

场景：用户提交的数据就像未安检的行李

// 创建user.dto.ts
exportclassCreateUserDto{
@IsString()
@MinLength(5)
  username:string;
@IsEmail()
  email:string;
@IsStrongPassword()
  password:string;
}
// 在控制器中使用
@Post()
createUser(@Body() createUserDto: CreateUserDto){
// 自动验证通过后才会执行到这里
returnthis.userService.create(createUserDto);
}

2.6 常见问题现场诊断

Q：什么时候用@Param，什么时候用@Query？

用@Param：/users/123 （标识具体资源）
用@Query：/users?role=admin （过滤条件）

Q：DTO和普通的TypeScript接口有什么区别？

接口：只是类型声明
DTO：携带验证规则，实际参与运行时校验

第三部分：服务层——你的业务「后厨团队」

3.1 服务层定位

控制器 = 服务员（接收点单）
服务层 = 厨师团队（实际烹饪）
模块 = 餐厅部门划分（中厨/西厨）

3.2 创建标准服务（用户注册流程）

# 快速生成服务（附带测试文件）
nest generate service user

基础服务结构：

@Injectable()// 标记为可注入类
exportclassUserService{
// 模拟数据库
private users:any[]=[];
// 实际业务操作
asyncregister(userDto: CreateUserDto){
    // 检查用户名是否重复
    const exist =this.users.find(u => u.username === userDto.username);
    if(exist){
      thrownewConflictException('用户名已存在');
    }
    
    // 模拟入库操作
    const newUser ={
      id: Date.now(),
      ...userDto,
      createdAt:newDate()
    };
    this.users.push(newUser);
    
    return{
      success:true,
      data: _.omit(newUser,['password'])// 使用lodash过滤敏感字段
    };
}
}

3.3 控制器与服务联动

@Controller('users')
exportclassUserController{
// 依赖注入服务实例
constructor(privatereadonly userService: UserService){}
@Post('register')
asyncregister(@Body() dto: CreateUserDto){
    // 控制器只做参数传递
    returnawaitthis.userService.register(dto);
}
}

3.4 模块化拆分（数据库模块案例）

// database.module.ts
@Module({
  providers:[
    {
      provide:'DATABASE_CONNECTION',
      useFactory:async()=>{
        returnawaitcreateConnection({
          type:'mysql',
          host:'localhost',
          port:3306,
          username:'root',
          password:'root',
          database:'test'
        });
      }
    }
],
  exports:['DATABASE_CONNECTION']// 暴露给其他模块
})
exportclassDatabaseModule{}
// 在用户模块引入
@Module({
  imports:[DatabaseModule],// 导入数据库工具
  controllers:[UserController],
  providers:[UserService]
})
exportclassUserModule{}

3.5 异常处理艺术（错误分类）

// 自定义业务异常
exportclassInsufficientBalanceExceptionextendsHttpException{
constructor(){
    super('账户余额不足',402);// 特定状态码
}
}
// 在服务中使用
chargeUser(userId:number, amount:number){
const balance =this.getBalance(userId);
if(balance < amount){
    thrownewInsufficientBalanceException();
}
// 扣款逻辑...
}
// 全局过滤器（进阶用法）
@Catch(InsufficientBalanceException)
exportclassBalanceFilterimplementsExceptionFilter{
catch(exception: InsufficientBalanceException, host: ArgumentsHost){
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    
    response.status(402).json({
      code:402,
      message:'请先充值后再进行操作',
      rechargeUrl:'/payment'
    });
}
}

3.6 实战问答环节

Q：服务层必须用@Injectable装饰器吗？

必须，这是Nest识别可注入类的标记

Q：什么时候应该创建新模块？

当功能组件需要复用时（如数据库、第三方API）
业务领域明确独立时（如用户模块、订单模块）

Q：为什么不用全局try-catch？

Nest的异常过滤器机制更统一
可针对不同异常类型精细化处理

第四部分：管道——你的数据「安检通道」

4.1 管道核心作用

验证
：检查行李是否合规（数据格式）
转换
：把外币兑换成本地货币（数据格式化）
过滤
：没收违禁物品（清理不必要字段）

4.2 内置管道实战

// 单个路由使用
@Get(':id')
findOne(
@Param('id', ParseIntPipe) id:number// 自动转换数字
){
return`查询ID为${id}的用户`;
}
// 测试案例：
// 访问 /users/abc 将自动返回400错误
// 正确访问 /users/123 得到数字类型的123

4.3 自定义管道开发（手机号格式验证）

// phone.pipe.ts
@Injectable()
exportclassPhoneValidationPipeimplementsPipeTransform{
transform(value:any){
    const valid =/^1[3-9]\d{9}$/.test(value);
    if(!valid){
      thrownewBadRequestException('手机号格式错误');
    }
    return value.replace(/(\d{3})\d{4}(\d{4})/,'$1****$2');// 自动脱敏
}
}
// 在控制器中使用
@Post('bind-phone')
bindPhone(
@Body('phone', PhoneValidationPipe) phone:string
){
return`绑定成功：${phone}`;
}

4.4 全局管道配置（推荐方案）

// main.ts 启动文件
asyncfunctionbootstrap(){
const app =await NestFactory.create(AppModule);
// 全局启用数据验证
  app.useGlobalPipes(
    newValidationPipe({
      whitelist:true,          // 自动过滤DTO外的字段
      transform:true,          // 自动类型转换
      disableErrorMessages: process.env.NODE_ENV==='production'// 生产环境隐藏错误详情
    })
);
await app.listen(3000);
}

4.5 Class Validator深度集成（企业级方案）

安装必要包：

npm install class-validator class-transformer

DTO增强：

// create-user.dto.ts
exportclassCreateUserDto{
@IsString()
@Length(2,20,{ message:'用户名长度需在2-20字符之间'})
  username:string;
@IsEmail({},{ message:'必须是有效的邮箱格式'})
  email:string;
@Matches(/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$/,{
    message:'密码必须包含字母和数字，至少8位'
})
  password:string;
@Type(()=> Number)// 配合class-transformer转换类型
@IsInt({ message:'年龄必须是整数'})
@Min(18,{ message:'未满18岁不得注册'})
  age:number;
}

错误响应示例：

// 当验证失败时自动返回
{
"statusCode":400,
"message":[
    "用户名长度需在2-20字符之间",
    "必须是有效的邮箱格式",
    "未满18岁不得注册"
],
"error":"Bad Request"
}

4.6 常见问题排雷

Q：管道和中间件有什么区别？

中间件：更底层，处理HTTP请求/响应（跨域、日志）
管道：专注处理请求参数（路由参数、查询参数、请求体）

Q：为什么要用class-transformer？

处理原始请求数据到类实例的转换
解决嵌套对象、数组等复杂结构的类型转换

Q：生产环境为什么要禁用错误详情？

防止敏感信息泄露（如数据库字段结构）
避免给攻击者提供线索

第五部分：守卫——你的系统「安检门禁」

5.1 守卫核心职责

身份核验
：检查登机牌（是否登录）
权限确认
：检查舱位等级（用户角色）
访问控制
：拦截危险人员（黑名单IP）

5.2 创建JWT守卫（实战认证方案）

// jwt.guard.ts
@Injectable()
exportclassJwtAuthGuardimplementsCanActivate{
constructor(private jwtService: JwtService){}
canActivate(context: ExecutionContext):boolean{
    const request = context.switchToHttp().getRequest();
    const token =this.extractToken(request);
    
    if(!token){
      thrownewUnauthorizedException('请先登录');
    }
    try{
      const payload =this.jwtService.verify(token);
      request.user = payload;// 注入用户信息到请求对象
      returntrue;
    }catch{
      thrownewUnauthorizedException('登录凭证已过期');
    }
}
privateextractToken(request: Request):string|null{
    return request.headers.authorization?.split(' ')[1]||null;
}
}

5.3 角色权限守卫（RBAC实现）

// roles.decorator.ts（自定义装饰器）
exportconstRoles=(...roles:string[])=>SetMetadata('roles', roles);
// roles.guard.ts
@Injectable()
exportclassRolesGuardimplementsCanActivate{
constructor(private reflector: Reflector){}
canActivate(context: ExecutionContext):boolean{
    const requiredRoles =this.reflector.get<string[]>(
      'roles',
      context.getHandler()
    );
    if(!requiredRoles)returntrue;
    const{ user }= context.switchToHttp().getRequest();
    return requiredRoles.some(role => user.roles?.includes(role));
}
}
// 控制器使用示例
@Post('admin/reports')
@UseGuards(JwtAuthGuard, RolesGuard)
@Roles('admin','superadmin')
generateReport(){
return'生成管理员专属报表';
}

5.4 守卫注册方式（灵活配置）

// 全局注册（main.ts）
app.useGlobalGuards(newJwtAuthGuard());
// 控制器级别
@Controller('orders')
@UseGuards(JwtAuthGuard)
exportclassOrderController{}
// 路由方法级别
@Get('secret')
@UseGuards(RolesGuard)
getSecretData(){}

5.5 第三方登录集成（Github OAuth示例）

// github.strategy.ts（Passport集成）
@Injectable()
exportclassGithubStrategyextendsPassportStrategy(Strategy,'github'){
constructor(){
    super({
      clientID: process.env.GITHUB_CLIENT_ID,
      clientSecret: process.env.GITHUB_SECRET,
      callbackURL:'/auth/github/callback',
      scope:['user:email']
    });
}
asyncvalidate(accessToken:string, _refreshToken:string, profile:any){
    return{
      provider:'github',
      uid: profile.id,
      email: profile.emails[0].value,
      username: profile.username
    };
}
}
// 在控制器中使用
@Get('auth/github')
@UseGuards(AuthGuard('github'))
githubLogin(){}
@Get('auth/github/callback')
@UseGuards(AuthGuard('github'))
githubCallback(@Req() req){
returnthis.authService.handleOAuthLogin(req.user);
}

5.6 安全防护常见问题

Q：守卫和中间件的执行顺序？

中间件 -> 守卫 -> 拦截器 -> 管道 -> 控制器方法

Q：如何实现权限分级管理？

// 角色定义建议
enum UserRole {
TOURIST=1,    // 游客
USER=10,       // 普通用户
EDITOR=20,     // 内容编辑
ADMIN=99       // 系统管理员
}
// 权限检查时使用数字比对
hasPermission(userRole:number, requiredRole:number){
return userRole >= requiredRole;
}

Q：如何处理多设备登录问题？

// 生成带设备类型的JWT
createToken(userId:string, deviceType:string){
returnthis.jwtService.sign({
    sub: userId,
    device: deviceType // web/mobile/iot
});
}
// 在守卫中检查设备合法性
if(payload.device !=='web'){
thrownewForbiddenException('该设备无访问权限');
}

第六部分：拦截器——你的数据「物流中心」

6.1 拦截器核心能力（快递分拣系统比喻）

请求预处理
：包裹分类贴标签（添加全局请求头）
响应格式化
：统一包装盒规格（标准化响应结构）
异常捕获
：破损包裹拦截（错误日志记录）
性能监控
：运输时效统计（接口耗时计算）

6.2 创建基础拦截器（响应标准化）

// response.interceptor.ts
@Injectable()
exportclassResponseInterceptorimplementsNestInterceptor{
intercept(context: ExecutionContext, next: CallHandler): Observable<any>{
    const ctx = context.switchToHttp();
    const response = ctx.getResponse();
    
    // 统一设置响应头
    response.setHeader('X-Powered-By','NestJS');
    return next.handle().pipe(
      map(data =>({
        code:200,
        success:true,
        timestamp:newDate().toISOString(),
        data: _.isObject(data)? data :{ result: data }
      }))
    );
}
}
// 使用效果：
// 原始返回: 'Hello World'
// 处理后返回: 
// {
//   code: 200,
//   success: true,
//   timestamp: "2023-08-20T08:00:00Z",
//   data: { result: "Hello World" }
// }

6.3 多场景实战应用

案例一：API耗时监控

intercept(context: ExecutionContext, next: CallHandler){
const start = Date.now();
return next.handle().pipe(
    tap(()=>{
      const duration = Date.now()- start;
      console.log(`接口耗时：${duration}ms`);
    })
);
}

案例二：敏感数据脱敏

map(data => {
  if (data?.phone) {
    data.phone = data.phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
  }
  return data;
})

案例三：请求日志记录

const request = context.switchToHttp().getRequest();
logger.info(`[${request.method}] ${request.url} - Body: ${JSON.stringify(request.body)}`);
return next.handle().pipe(
  catchError(err => {
    logger.error(`请求失败：${err.stack}`);
    return throwError(() => err);
  })
);

6.4 全局拦截器配置

// main.ts
app.useGlobalInterceptors(
  new ResponseInterceptor(),
  new TimeoutInterceptor(5000) // 请求超时设置
);

6.5 高阶应用：缓存拦截器

// cache.interceptor.ts
@Injectable()
exportclassCacheInterceptorimplementsNestInterceptor{
private cache =newMap<string, any>();
intercept(context: ExecutionContext, next: CallHandler){
    const request = context.switchToHttp().getRequest();
    const cacheKey = request.originalUrl;
    if(request.method !=='GET')return next.handle();
    const cached =this.cache.get(cacheKey);
    if(cached){
      returnof(cached);// 直接返回缓存
    }
    return next.handle().pipe(
      tap(response =>{
        this.cache.set(cacheKey, response);
        setTimeout(()=>this.cache.delete(cacheKey),60000);// 60秒后清除
      })
    );
}
}

6.6 拦截器使用原则

职责单一：每个拦截器专注一个任务
执行顺序：

请求 -> 全局拦截器 -> 控制器拦截器 -> 路由方法拦截器

性能注意：避免在拦截器中做重型操作

6.7 常见问题解答

Q：拦截器 vs 中间件 vs 过滤器？

中间件：处理原始HTTP请求（跨域、压缩）
拦截器：处理控制器输入输出（业务相关）
过滤器：捕获未处理的异常（兜底处理）

Q：如何跳过某些路由的拦截器？

// 使用自定义元数据装饰器
exportconstSkipInterceptor=()=>SetMetadata('skipInterceptor',true);
// 在拦截器中判断
const shouldSkip =this.reflector.get<boolean>('skipInterceptor', context.getHandler());
if(shouldSkip)return next.handle()

Q：如何处理异步操作？

// 超时控制示例
intercept(context: ExecutionContext, next: CallHandler){
return next.handle().pipe(
    timeout(5000),// 5秒超时
    catchError(err =>{
      if(err instanceofTimeoutError){
        thrownewRequestTimeoutException();
      }
      returnthrowError(()=> err);
    })
);
}

第七部分：中间件——你的请求「预处理车间」

7.1 中间件定位

执行阶段
：控制器之前处理原始请求
典型场景
：

请求日志记录
跨域头设置
用户身份预校验
请求体压缩处理

7.2 创建日志中间件（实战演示）

// logger.middleware.ts
import{ Request, Response, NextFunction }from'express';
exportfunctionLoggerMiddleware(req: Request, res: Response, next: NextFunction){
const start = Date.now();
  res.on('finish',()=>{
    const duration = Date.now()- start;
    console.log(
      `[${new Date().toISOString()}] ${req.method} ${req.originalUrl} - ${res.statusCode} (${duration}ms)`
    );
});
next();// 必须调用next继续传递
}

7.3 中间件注册方式（三种绑定策略）

// 全局中间件（main.ts）
app.use(LoggerMiddleware);
// 模块中间件（app.module.ts）
exportclassAppModuleimplementsNestModule{
configure(consumer: MiddlewareConsumer){
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path:'user*', method: RequestMethod.ALL});// 匹配/user开头的所有路由
}
}
// 路由排除法
consumer
.apply(AuthMiddleware)
.exclude(
    { path:'auth/login', method: RequestMethod.POST},
    { path:'docs', method: RequestMethod.GET}
)
.forRoutes('*');

7.4 文件上传处理（Multer集成方案）

// 安装依赖
npm install @nestjs/platform-express multer @types/multer
// 文件上传控制器
@Post('avatar')
@UseInterceptors(FileInterceptor('file'))
uploadAvatar(
@UploadedFile() file: Express.Multer.File,
@Body() userId:string
){
returnthis.userService.updateAvatar(userId, file);
}
// 配置文件存储（自定义配置）
const storage = multer.diskStorage({
destination:(req, file, cb)=>{
    cb(null,'./uploads');
},
filename:(req, file, cb)=>{
    const ext = path.extname(file.originalname);
    cb(null,`${Date.now()}${ext}`);
}
});
// 在模块中注册
@Module({
  imports:[
    MulterModule.register({
      storage: storage,
      limits:{ fileSize:1024*1024*5}// 5MB限制
    })
]
})
exportclassFileModule{}

7.5 第三方中间件集成（安全防护）

// 安装安全中间件
npm install helmet compression
// main.ts配置
import*as helmet from'helmet';
import*as compression from'compression';
asyncfunctionbootstrap(){
const app =await NestFactory.create(AppModule);
// 安全头设置
  app.use(helmet({
    contentSecurityPolicy:false// 根据需求配置
}));
// 响应压缩
  app.use(compression({ level:6}));
await app.listen(3000);
}

7.6 中间件开发准则

功能纯净
：避免在一个中间件中做多件不相关的事
性能优先
：不要阻塞事件循环（避免同步耗时操作）
错误处理：必须捕获并传递错误

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('服务器开小差了！');
});

7.7 常见问题破解

Q：中间件和过滤器的区别？

中间件：处理请求/响应周期中的原始数据
过滤器：处理控制器抛出的异常

Q：如何实现CSRF防护？

// 安装csrf防护
npm install csurf @types/csurf
// 使用中间件
import*as csurf from'csurf';
app.use(csurf());
app.use((req, res, next)=>{
  res.cookie('XSRF-TOKEN', req.csrfToken());
next();
});
// 前端需要在请求头携带
headers:{
'X-XSRF-TOKEN':getCookie('XSRF-TOKEN')
}

Q：处理大文件上传优化策略？

// 分片上传中间件
app.post('/upload',(req, res)=>{
const chunk = req.body.chunk;
const index = req.body.index;
const total = req.body.total;
// 将分片暂存到临时目录
  fs.writeFileSync(`./temp/${index}`, chunk);
if(index === total){
    // 合并所有分片
    mergeFiles(total);
}
  res.sendStatus(200);
});

第八部分：微服务——你的业务「集团分部」

8.1 微服务核心特征（连锁餐厅）

独立运营
：每家分店自主管理（服务自治）
专业分工
：中央厨房负责食材供应（服务拆分）
统一协调
：总部调度各分店资源（服务发现）
容错机制
：某分店停业不影响整体（熔断降级）

8.2 创建基础微服务（TCP通信示例）

# 创建用户服务（独立项目）
nest new user-service --strict
# 创建订单服务（独立项目）
nest new order-service --strict

用户服务配置：

// main.ts
asyncfunctionbootstrap(){
const app =await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.TCP,
      options:{ host:'localhost', port:3001}
    }
);
await app.listen();
}

订单服务调用配置：

// order.module.ts
@Module({
  imports:[
    ClientsModule.register([
      {
        name:'USER_SERVICE',
        transport: Transport.TCP,
        options:{ host:'localhost', port:3001}
      }
    ])
]
})

8.3 跨服务通信模式（实战演示）

场景：创建订单时验证用户

// order.service.ts
@Injectable()
exportclassOrderService{
constructor(
    @Inject('USER_SERVICE')private userClient: ClientProxy
){}
asynccreateOrder(userId:string, items:string[]){
    // 调用用户服务验证
    const userValid =awaitthis.userClient
      .send<boolean>('validateUser', userId)
      .toPromise();
    if(!userValid){
      thrownewBadRequestException('用户不存在');
    }
    // 创建订单逻辑...
    return{ orderId: Date.now().toString()};
}
}
// user.controller.ts（用户服务）
@MessagePattern('validateUser')
validateUser(@Payload() userId:string){
returnthis.userService.exists(userId);// 返回布尔值
}

8.4 消息队列集成（RabbitMQ案例）

// 安装依赖
npm install @nestjs/microservices amqplib amqp-connection-manager
// 邮件服务配置
const app =await NestFactory.createMicroservice<MicroserviceOptions>(
  AppModule,
{
    transport: Transport.RMQ,
    options:{
      urls:['amqp://localhost:5672'],
      queue:'email_queue',
      queueOptions:{ durable:true}
    }
}
);
// 订单服务发送邮件通知
this.emailClient.emit('send_order_email',{
  email:'user@example.com',
  orderId:'12345'
});

8.5 网关统一入口（API网关模式）

// api-gateway项目配置
@Controller()
exportclassApiController{
constructor(
    @Inject('USER_SERVICE')private userClient: ClientProxy,
    @Inject('ORDER_SERVICE')private orderClient: ClientProxy
){}
@Get('user/:id/orders')
asyncgetUserOrders(@Param('id') userId:string){
    // 并行调用两个服务
    const[user, orders]=awaitPromise.all([
      this.userClient.send('getUser', userId).toPromise(),
      this.orderClient.send('getUserOrders', userId).toPromise()
    ]);
    return{...user, orders };
}
}

8.6 分布式系统常见问题

Q：如何保证数据一致性？

// 使用Saga模式示例
asynccreateOrder(){
try{
    // 阶段1：扣减库存
    await inventoryClient.emit('reduce_stock', items);
    
    // 阶段2：创建订单
    const order =awaitthis.create(orderData);
    
    // 阶段3：扣款
    await paymentClient.emit('deduct_balance', userId);
    
    return order;
}catch(error){
    // 补偿操作
    await inventoryClient.emit('rollback_stock', items);
    await paymentClient.emit('rollback_balance', userId);
    throw error;
}
}

Q：如何实现服务发现？

// 使用Consul配置示例
transport: Transport.CONSUL,
options:{
  host:'consul-server',
  port:8500,
  service:{
    name:'user-service',
    check:{
      interval:'10s',
      http:'http://localhost:3001/health'
    }
}
}

Q：如何监控微服务健康？

// 健康检查端点
@Get('health')
@HealthCheck()
checkHealth(){
returnthis.health.check([
    ()=>this.db.ping().then(()=> HealthCheckResult.healthy()),
    ()=>this.cache.ping().then(()=> HealthCheckResult.healthy())
]);
}

第九部分：MySQL集成——你的数据「智能仓库」

9.1 ORM核心概念（仓库管理员比喻）

实体（Entity） = 货物清单（数据结构定义）
仓库（Repository） = 货架管理员（数据存取操作）
迁移（Migration） = 仓库改造记录（数据结构变更）

9.2 环境配置（.env标准方案）

# .env
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=your_password
DB_NAME=nest_demo
DB_SYNC=false # 生产环境必须关闭！

9.3 实体定义规范（用户模型案例）

// user.entity.ts
@Entity()
exportclassUser{
@PrimaryGeneratedColumn()
  id:number;
@Column({ length:30, comment:'登录账号'})
  username:string;
@Column({
    select:false,// 查询时默认排除
    comment:'加密后的密码'
})
  password:string;
@Column({
    type:'enum',
    enum: UserRole,
    default: UserRole.USER
})
  role: UserRole;
@CreateDateColumn()
  createdAt: Date;
@UpdateDateColumn()
  updatedAt: Date;
}

9.4 数据库模块注册（动态配置）

// database.module.ts
@Module({
  imports:[
    TypeOrmModule.forRootAsync({
      imports:[ConfigModule],
      useFactory:(config: ConfigService)=>({
        type:'mysql',
        host: config.get('DB_HOST'),
        port: config.get('DB_PORT'),
        username: config.get('DB_USER'),
        password: config.get('DB_PASSWORD'),
        database: config.get('DB_NAME'),
        entities:[__dirname +'/../**/*.entity{.ts,.js}'],
        synchronize: config.get('DB_SYNC'),// 仅开发环境开启
        logging:['error','warn']// 生产环境建议关闭
      }),
      inject:[ConfigService]
    })
]
})
exportclassDatabaseModule{}

9.5 数据操作实战（CRUD演示）

// user.service.ts
@Injectable()
exportclassUserService{
constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>
){}
// 创建用户
asynccreate(userDto: CreateUserDto){
    const user =this.userRepository.create({
      ...userDto,
      password: bcrypt.hashSync(userDto.password,10)
    });
    returnawaitthis.userRepository.save(user);
}
// 分页查询
asyncpaginate(page =1, limit =10){
    const[data, total]=awaitthis.userRepository.findAndCount({
      skip:(page -1)* limit,
      take: limit,
      order:{ id:'DESC'}
    });
    
    return{
      data,
      meta:{ total, page, last_page: Math.ceil(total / limit)}
    };
}
// 事务操作
asynctransferMoney(fromId:number, toId:number, amount:number){
    awaitthis.userRepository.manager.transaction(async manager =>{
      const from =await manager.findOne(User,{ where:{ id: fromId }});
      const to =await manager.findOne(User,{ where:{ id: toId }});
      if(from.balance < amount)thrownewError('余额不足');
      
      await manager.update(User, fromId,{ balance: from.balance - amount });
      await manager.update(User, toId,{ balance: to.balance + amount });
    });
}
}

9.6 复杂查询构建（QueryBuilder实战）

// 多表联查示例
asyncgetUserWithOrders(userId:number){
returnthis.userRepository
    .createQueryBuilder('user')
    .leftJoinAndSelect('user.orders','orders')
    .where('user.id = :id',{ id: userId })
    .andWhere('orders.status = :status',{ status:'paid'})
    .orderBy('orders.createdAt','DESC')
    .getOne();
}
// 原生SQL执行
asynccountActiveUsers(){
returnthis.userRepository.query(`
    SELECT COUNT(*) as count 
    FROM users 
    WHERE last_login_at > DATE_SUB(NOW(), INTERVAL 30 DAY)
  `);
}

9.7 性能优化方案

索引优化：

@Index('IDX_USERNAME', ['username'], { unique: true })
@Entity()
export class User { ... }

查询缓存：

const users =awaitthis.userRepository.find({
  where:{ role:'admin'},
  cache:{
    id:'admin_users',
    milliseconds:60000// 1分钟缓存
}
});

连接池配置：

// database.module.ts
options:{
...,
  extra:{
    connectionLimit:20,// 最大连接数
    waitForConnections:true,
    queueLimit:0
}
}

9.8 数据迁移管理（生产环境必须）

# 生成迁移文件
npx typeorm migration:create ./migrations/InitSchema
# 执行迁移
npx typeorm migration:run
# 回滚迁移
npx typeorm migration:revert

迁移文件示例：

export classInitSchemaimplementsMigrationInterface{
publicasyncup(queryRunner: QueryRunner):Promise<void>{
    await queryRunner.query(`
      CREATE TABLE users (
        id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        username VARCHAR(30) NOT NULL UNIQUE,
        password VARCHAR(100) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      ) ENGINE=InnoDB;
    `);
}
publicasyncdown():Promise<void>{
    await queryRunner.dropTable('users');
}
}

9.9 安全注意事项

SQL注入防护：

// 危险！
query(`SELECT * FROM users WHERE name = '${name}'`);
// 安全✅
query('SELECT * FROM users WHERE name = ?', [name]);

始终使用参数化查询
避免直接拼接SQL语句

敏感数据处理：

// 密码加密处理
asyncfunctionhashPassword(password:string){
return bcrypt.hash(password,10);
}
// 敏感字段排除
@Entity()
exportclassUser{
@Column({ select:false})
  password:string;
}

9.10 常见问题解答

Q：实体和DTO有什么区别？

实体：描述数据库表结构（与数据库直接交互）
DTO：定义接口传输格式（请求/响应结构）

Q：如何高效处理批量插入？

const users =[...];// 大量用户数据
awaitthis.userRepository
.createQueryBuilder()
.insert()
.into(User)
.values(users)
.orIgnore()// 忽略重复
.execute();

Q：事务处理的正确方式？

使用transaction方法包裹原子操作
避免在事务中执行长时间操作
注意事务隔离级别设置

第十部分：测试与部署——你的系统「质检&物流」

10.1 测试金字塔模型（质量检测体系）

- 单元测试（70%）：单个函数/类测试
- 集成测试（20%）：模块间协作测试
- E2E测试（10%）：完整业务流程测试

10.2 单元测试实战（用户服务案例）

// user.service.spec.ts
describe('UserService',()=>{
let service: UserService;
let mockRepository: jest.Mocked<Repository<User>>;
beforeEach(async()=>{
    // 模拟数据库操作
    mockRepository ={
      findOne: jest.fn(),
      save: jest.fn().mockImplementation((user)=> user)
    }asany;
    const module: TestingModule =await Test.createTestingModule({
      providers:[
        UserService,
        { provide:getRepositoryToken(User), useValue: mockRepository }
      ]
    }).compile();
    service = module.get<UserService>(UserService);
});
it('创建用户时应加密密码',async()=>{
    const dto ={ username:'test', password:'123456'};
    await service.create(dto);
    
    expect(mockRepository.save).toBeCalledWith(
      expect.objectContaining({
        password: expect.not.stringMatching(dto.password)
      })
    );
});
});

10.3 E2E测试配置（完整流程验证）

// app.e2e-spec.ts
describe('用户模块 (e2e)',()=>{
let app: INestApplication;
beforeAll(async()=>{
    const moduleFixture =await Test.createTestingModule({
      imports:[AppModule],
    }).compile();
    app = moduleFixture.createNestApplication();
    await app.init();
});
it('/user/register (POST)',()=>{
    returnrequest(app.getHttpServer())
      .post('/user/register')
      .send({
        username:'e2e_test',
        password:'Test@123',
        email:'e2e@test.com'
      })
      .expect(201)
      .expect(res =>{
        expect(res.body.data.username).toBe('e2e_test');
        expect(res.body.data.password).toBeUndefined();
      });
});
afterAll(async()=>{
    await app.close();
});
});

10.4 Docker容器化（生产部署标准）

# Dockerfile 三阶段构建
# 阶段一：构建环境
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# 阶段二：生产依赖
FROM node:18-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
# 阶段三：最终镜像
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=deps /app/node_modules ./node_modules
COPY .env.prod .
EXPOSE 3000
CMD ["node", "dist/main.js"]

10.5 部署优化策略（生产环境配置）

# .env.prod 生产配置
NODE_ENV=production
DB_HOST=mysql-prod
DB_PORT=3306
DB_USER=prod_user
DB_PASSWORD=${DB_PASSWORD}# 从安全仓库注入
DB_NAME=prod_db
DB_SYNC=false
# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DB_PASSWORD=${DB_PASSWORD}
    depends_on:
      - mysql
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: prod_db
    volumes:
      - mysql_data:/var/lib/mysql
    command: --default-authentication-plugin=mysql_native_password
volumes:
  mysql_data:

10.6 监控与维护（生产必备）

// 健康检查端点
@Get('health')
@HealthCheck()
checkHealth(){
returnthis.health.check([
    ()=>this.db.ping().then(()=> HealthCheckResult.healthy()),
    ()=>this.redis.ping().then(()=> HealthCheckResult.healthy())
]);
}
// 日志切割配置（PM2）
module.exports ={
  apps:[{
    name:'nest-app',
    script:'dist/main.js',
    instances:'max',
    autorestart:true,
    watch:false,
    max_memory_restart:'1G',
    error_file:'/var/log/nest-app/error.log',
    out_file:'/var/log/nest-app/out.log',
    log_date_format:'YYYY-MM-DD HH:mm:ss',
    merge_logs:true,
    env_production:{
      NODE_ENV:'production'
    }
}]
};

10.7 持续集成实战（GitHub Actions）

# .github/workflows/deploy.yml
name: Deploy Production
on:
push:
    tags:
      -'v*'
jobs:
build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    -name: Checkout code
      uses: actions/checkout@v3
    -name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version:18
    -name: Install Dependencies
      run: npm ci
    -name: Build Project
      run: npm run build
    -name: Run Tests
      run: npm run test:ci
    -name: Build Docker Image
      run: docker build -t ${{ secrets.DOCKER_USER }}/nest-app:${{ github.ref_name }} .
    -name: Push to Docker Hub
      run:|
        echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USER }} --password-stdin
        docker push ${{ secrets.DOCKER_USER }}/nest-app:${{ github.ref_name }}
    -name: SSH Deploy
      uses: appleboy/ssh-action@v0.1.10
      with:
        host: ${{ secrets.PROD_HOST }}
        username: ${{ secrets.PROD_USER }}
        key: ${{ secrets.PROD_SSH_KEY }}
        script:|
          docker pull ${{ secrets.DOCKER_USER }}/nest-app:${{ github.ref_name }}
          docker stop nest-app || true
          docker rm nest-app || true
          docker run -d \
            --name nest-app \
            --env-file .env.prod \
            -p 3000:3000 \
            ${{ secrets.DOCKER_USER }}/nest-app:${{ github.ref_name }}

10.8 生产环境安全清单

1. [强制] 禁用Swagger文档（生产环境）
2. [推荐] 配置HTTPS证书（Let's Encrypt）
3. [重要] 定期备份数据库（每日全量+增量）
4. [必须] 使用防火墙限制端口访问
5. [建议] 实施速率限制（防止暴力破解）

10.9 故障排查指南

# 查看容器日志
docker logs nest-app --tail100-f
# 进入容器调试
dockerexec-it nest-app sh
# 性能分析
node--inspect=0.0.0.0:9229 dist/main.js
# 使用Chrome DevTools连接调试
# 内存泄漏检测
NODE_OPTIONS=--max-old-space-size=4096node dist/main.js

全系列总结路线图

1. 项目初始化 -> 基础架构搭建
2. 路由定义 -> 业务功能开发
3. 数据库集成 -> 数据持久化
4. 鉴权体系 -> 安全保障
5. 测试覆盖 -> 质量保障
6. 容器化 -> 部署标准化
7. 监控告警 -> 运维保障
8. 持续交付 -> 自动化流程

Javascript实现多类继承

Tue, 13 Dec 2022 14:21:09 +0800

好像在Javascript中多继承出现的场景并不多，这是因为在es6中并没有显式的支持多继承，不过，如果你认为它不能做到多继承就错了。

比如有类A、B、C、D，我希望类A去继承B、C、D，那么，可以让B去继承C，C继承D，最后让A继承B，就实现了多继承的效果。

在es6中，通过extends关键字去实现继承，如下示例。

class B extends C {}
class C extends D {}

但是，这样一层一层的去写也太麻烦了，那么我们需要了解另一个原理。

extends关键字之后除了放一个类或构造函数，还可以是一个Javascript表达式，任何一个可以解析为类或构造函数的表达式都是有效的，它会在求值类定义时被求值。

我们把extends之后的class改为一个表达式如下。

class Parent {}
function getParentClass() {
  console.log('get parent class')
  return Parent;
}
class Child extends getParentClass() {}

所以上述代码片段在控制台打印了get parent class。

基于这个特性，上面B、C、D三个类可以通过混入类的方式来实现效果。我们实现一个混入类的函数，该函数接收一个类作为参数，在函数内部去继承这个传入的类。

function Parent() {
  console.log('parent')
}
const ParentMixin = (SuperClass) => class extends SuperClass {
  parentLog() {
    console.log('parent log')
  }
}

const ChildMixin = (SuperClass) => class extends SuperClass {
  childLog() {
    console.log('child log')
  }
}

const SubChildMixin = (SuperClass) => class extends SuperClass {
  subChildLog() {
    console.log('subchild log')
  }
}

class Base extends SubChildMixin(ChildMixin(ParentMixin(Parent))) {}

const instance = new Base(); // parent
instance.subChildLog() // subchild log
instance.childLog() // child log
instance.parentLog() // parent log

这样写的话代码层层套娃不够简单优雅，实现一个辅助pipe函数，将函数的嵌套展开。

const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);

class Base extends pipe(SubChildMixin, ChildMixin, ParentMixin)(Parent) {}

总结

js多继承的使用场景并不是很多，甚至很多地方已经不建议使用多继承的方式，但是并不妨碍我们了解它的实现原理。

本文完。

如何在PHP中调用Python并获取运行结果

Tue, 13 Dec 2022 13:55:32 +0800

前言

在毕设中需要用到PHP传递参数调用Python脚本并获取后者返回的结果，经过查阅资料该问题得以解决。

思路

PHP借助shell_exec通过类似于python sum.py $aa $bb的形式以执行系统命令的方式传递参数给Python文件；

Python则通过sys.argv（需引入sys模块）来接收命令中所包含的参数（需要注意的是：此时传入的参数都会被默认为str类型，需要在函数内部进行解析和转换）并将处理结果通过print函数输出；

PHP通过将shell_exec函数返回的结果赋给变量实现取得Python返回数据的效果。

代码

PHP:

<form action="" method="post">
    请输入a:<input type="number" name="a" value="请输入a"><br> 请输入b:
    <input type="number" name="b" value="请输入b">
    <button type="submit">计算</button>
</form>
<?php
$aa = $_POST["a"];
$bb = $_POST["b"];
$cmd = shell_exec("python sum.py $aa $bb");
echo "a与b的和是： $cmd";
?>

Python:

import sys
 
a, b = sys.argv[1], sys.argv[2]   # 接收位置参数
print(int(a)+int(b))

效果

补充

Python:

除了sys.argv，Python还可以通过argparse、tf.app.run获取传入参数。

相对于sys.argv，argparse和tf.app.run可以认为是基于参数名称的传入（前者是基于位置的参数传入）。

后者的具体使用方法记录如下：

argparse

示例1：

import argparse
parser = argparse.ArgumentParser(description='manual to this script')
parser.add_argument('--gpus', type=str, default = None)
parser.add_argument('--batch-size', type=int, default=32)
args = parser.parse_args()
print args.gpus
print args.batch_size

利用argparse模块，在函数内定义好相关的命名参数（包括名称、数据类型和默认值等），从而在命令行中可以方便的调用。

需要注意的是，脚本运行命令python script.py -gpus=0,1,2 --batch-size=10中的--batch-size会被自动解析成batch_size.
parser.add_argument 方法的type参数理论上可以是任何合法的类型，但有些参数传入格式比较麻烦，例如list，所以一般使用bool, int, str, float这些基本类型就行了，更复杂的需求可以通过str传入，然后手动解析。bool类型的解析比较特殊，传入任何值都会被解析成True，传入空值时才为False

python script.py --bool-val=0 # args.bool_val=True
python script.py --bool-val=False # args.bool_val=True
python script.py --bool-val=     # args.bool_val=什么都不写False

示例2：

Python:

import argparse
 
parser = argparse.ArgumentParser(description='a demo of script')
parser.add_argument('--a', type=float, default=0.0)  # 添加变量
parser.add_argument('--b', type=float, default=1.0)
 
if __name__ == '__main__':
    args = parser.parse_args()   # 解析所有的命令行传入变量
    add(args.a, args.b)

Shell:

python script.py --a=4.0 --b=3.0
#  另一种写法： python script.py --a 4.0 --b 3.0
#　返回结果7.0

总结：通过这个方法还能指定命令的帮助信息。具体请看API文档：https://docs.python.org/2/library/argparse.html

通过这个方法还能指定命令的帮助信息。具体请看API文档：https://docs.python.org/2/library/argparse.html

tf.app.run

tensorflow也提供了一种方便的解析方式。

脚本的执行命令为：

python script.py -gpus=0,1,2 --batch_size=10

对应的python代码为：

import tensorflow as tf
tf.app.flags.DEFINE_string('gpus', None, 'gpus to use')
tf.app.flags.DEFINE_integer('batch_size', 5, 'batch size')
 
FLAGS = tf.app.flags.FLAGS
 
def main(_):
    print FLAGS.gpus
    print FLAGS.batch_size
 
if __name__=="__main__":
    tf.app.run()

有几点需要注意：

tensorflow只提供以下几种方法：

tf.app.flags.DEFINE_string，
tf.app.flags.DEFINE_integer,
tf.app.flags.DEFINE_boolean,

tf.app.flags.DEFINE_float 四种方法，分别对应str, int,bool,float类型的参数。这里对bool的解析比较严格，传入1会被解析成True，其余任何值都会被解析成False。

脚本中需要定义一个接收一个参数的main方法：def main(_):，这个传入的参数是脚本名，一般用不到，所以用下划线接收。

以batch_size参数为例，传入这个参数时使用的名称为--batch_size，也就是说，中划线不会像在argparse 中一样被解析成下划线。

tf.app.run()会寻找并执行入口脚本的main方法。也只有在执行了tf.app.run()之后才能从FLAGS中取出参数。

从它的签名来看，它也是可以自己指定需要执行的方法的，不一定非得叫main：

run(
    main=None,
    argv=None
)

tf.app.flags只是对argpars的简单封装。

代码：

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
 
"""Implementation of the flags interface."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse as _argparse
from tensorflow.python.util.all_util import remove_undocumented
_global_parser = _argparse.ArgumentParser()
 
# pylint: disable=invalid-name
 
class _FlagValues(object):
  """Global container and accessor for flags and their values."""
 
  def __init__(self):
    self.__dict__['__flags'] = {}
    self.__dict__['__parsed'] = False
 
  def _parse_flags(self, args=None):
    result, unparsed = _global_parser.parse_known_args(args=args)
    for flag_name, val in vars(result).items():
      self.__dict__['__flags'][flag_name] = val
    self.__dict__['__parsed'] = True
    return unparsed
 
  def __getattr__(self, name):
    """Retrieves the 'value' attribute of the flag --name."""
    if not self.__dict__['__parsed']:
      self._parse_flags()
    if name not in self.__dict__['__flags']:
      raise AttributeError(name)
    return self.__dict__['__flags'][name]
 
  def __setattr__(self, name, value):
    """Sets the 'value' attribute of the flag --name."""
    if not self.__dict__['__parsed']:
      self._parse_flags()
    self.__dict__['__flags'][name] = value
 
def _define_helper(flag_name, default_value, docstring, flagtype):
  """Registers 'flag_name' with 'default_value' and 'docstring'."""
  _global_parser.add_argument('--' + flag_name,
                              default=default_value,
                              help=docstring,
                              type=flagtype)
 
 
# Provides the global object that can be used to access flags.
FLAGS = _FlagValues()
 
 
def DEFINE_string(flag_name, default_value, docstring):
  """Defines a flag of type 'string'.
  Args:
    flag_name: The name of the flag as a string.
    default_value: The default value the flag should take as a string.
    docstring: A helpful message explaining the use of the flag.
  """
  _define_helper(flag_name, default_value, docstring, str)
 
 
def DEFINE_integer(flag_name, default_value, docstring):
  """Defines a flag of type 'int'.
  Args:
    flag_name: The name of the flag as a string.
    default_value: The default value the flag should take as an int.
    docstring: A helpful message explaining the use of the flag.
  """
  _define_helper(flag_name, default_value, docstring, int)
 
 
def DEFINE_boolean(flag_name, default_value, docstring):
  """Defines a flag of type 'boolean'.
  Args:
    flag_name: The name of the flag as a string.
    default_value: The default value the flag should take as a boolean.
    docstring: A helpful message explaining the use of the flag.
  """
  # Register a custom function for 'bool' so --flag=True works.
  def str2bool(v):
    return v.lower() in ('true', 't', '1')
  _global_parser.add_argument('--' + flag_name,
                              nargs='?',
                              const=True,
                              help=docstring,
                              default=default_value,
                              type=str2bool)
 
  # Add negated version, stay consistent with argparse with regard to
  # dashes in flag names.
  _global_parser.add_argument('--no' + flag_name,
                              action='store_false',
                              dest=flag_name.replace('-', '_'))
 
 
# The internal google library defines the following alias, so we match
# the API for consistency.
DEFINE_bool = DEFINE_boolean  # pylint: disable=invalid-name
 
 
def DEFINE_float(flag_name, default_value, docstring):
  """Defines a flag of type 'float'.
  Args:
    flag_name: The name of the flag as a string.
    default_value: The default value the flag should take as a float.
    docstring: A helpful message explaining the use of the flag.
  """
  _define_helper(flag_name, default_value, docstring, float)
 
_allowed_symbols = [
    # We rely on gflags documentation.
    'DEFINE_bool',
    'DEFINE_boolean',
    'DEFINE_float',
    'DEFINE_integer',
    'DEFINE_string',
    'FLAGS',
]
remove_undocumented(__name__, _allowed_symbols)

PHP:

除了使用shell_exec()，还可以使用exec()、passthru()和system()函数调用系统命令，

它们四者的区别如下：

shell_exec()

通过 shell 环境执行命令，并且将完整的输出以字符串的方式返回。
也就是说, PHP先运行一个shell环境, 然后让shell进程运行你的命令, 并且把所有输出以字符串形式返回, 如果程序执行有错误或者程序没有任何输出, 则返回null.

exec()

string exec ( string $command [, array &$output [, int &$return_var ]] )与 shell_exec() 不一样, exec不会创建shell进程, 可以理解是php进程直接创建一个子进程, 运行指定的命令, 返回值只返回命令的最后一行, 所有的返回以参数形式返回, 上面的 $output, 进程的退出代码以另外一个参数变量返回, 上面的 $return_var

passthru()

void passthru ( string $command [, int &$return_var ] )与 exec() 类似, 唯一不同的是, 命令的所有输出返回内容都不再导入到 PHP 环境, 而是直接作为输出内容, 返回到浏览器的输出上, 等效是把所有返回内容直接 echo 输出.

system()

这个方法和 passthru() 类似, 但是 system() 方法会在程序的每行输出的时候执行一次缓存输出动作, 可以理解为, 只要外部程序输出一行, php 就会马上把内容推送到浏览器, 无论这个内容是否足够大. php通常为了输出效率, 都会有一个输出缓存, 会等到输出内容足够大之后, 再一次输出返回. system() 方法则强制输出内容立刻推送, 即使输出的内容只有一个字母. 如果客户端具有实时打印服务器的返回 http 内容流的能力, 就可以看到 system() 的实时推送效果.

PHP 中调用 Python 并获取运行结果

Tue, 13 Dec 2022 13:41:02 +0800

这里就要用到PHP的内置函数exec() 和system() ；

PHP的exec() 和system() 函数区别：

（1）system()

原型：string system (string command [, int return_var])

system()函数很其它语言中的差不多，它执行给定的命令，输出和返回结果。

（2）exec()

原型：string exec (string command [, string array [, int return_var]])

exec ()函数与system()类似，也执行给定的命令，但不输出结果，而是返回结果的最后一行。

可以看出两个函数的区别就是PHP在调用执行外部命令后，system()函数将执行的结果输出并返回给PHP程序。而 exec() 函数在调用执行外部命令后不会将结果输出，只是返回结果。

程序代码实现和对比：

（1）in.php程序使用exec()函数代码及解析：

（2）test.py程序代码：

（3）PHP程序执行后效果1：

这样就利用exec()函数实现了对python脚本的调用，下面说一下将in.php程序中的exec()函数替换成system()函数后的执行效果。

（4）in.php程序使用system()函数代码及解析：

（5）PHP程序执行后效果2：

可以看出使用system()函数时，执行python程序时不但返回结果，而且将结果输出了，而exec()函数只是返回结果，没有输出。

扩展应用：（php web开发数据调用）

想要在网页上显示其它网站上的数据内容时，都需要网站提供数据的调用接口直接调用，如果没有接口，就需要用爬虫将数据爬回来后保存到数据库，在用程序从数据库中取出数据展示出来。（当然也可以用到php的curl库进行数据爬取后进行展示，但是个人认为在编程语言中做爬虫最简单并且强大的还是Python），而如果在PHP程序中直接调用python脚本进行爬虫，然后再将数据展示到网页上，这样就可以省去插入数据到数据库和从数据库读取数据的过程，这种做法对一些实时数据的爬取还是比较有用的，但是一定会影响网页的加载速度。下面将以前写的一个爬虫爬到的数据直接展示到web网页上供大家参考。

（1）php程序代码：

<?PHP
$output=exec('python test1.py');
echo $output;
?>

（2）python爬虫代码：

import requests
import json
class WeatherSpider(object):
    def __inti__(self):
        pass
    def request(self,url):
        headers = {
        'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36',
        'Referer': 'http://www.weather.com.cn/weather40d/101060201.shtml'
        }
        return requests.get(url,headers=headers)
    def create_url(self):
        year = '2016'
        for i in range(1,2):
            month = str(i) if i > 9 else "0" + str(i)
            url = "http://d1.weather.com.cn/calendar_new/" + year + "/101060201_" + year + month + ".html"
            self.get_data(url)
    def get_data(self,url):
        respone = self.request(url).content
        json_str = respone.decode(encoding='utf-8')[11:]
        weathers = json.loads(json_str)
        data = ""
        for weather in weathers:
            data = data+weather.get('date')+'星期'+weather.get('wk')+weather.get('hmax')+weather.get('hmin')+weather.get('hgl')+"<br>"
        print (data)
if __name__ == '__main__':
    jl_weather = WeatherSpider()
    jl_weather.create_url()

（3）web网页爬虫展示：

Python sys.argv

PHP 借助 shell_exec 通过类似于 python sum.py $aa $bb 的形式以执行系统命令的方式传递参数给Python文件；

Python 则通过 sys.argv（需引入sys模块） 来接收命令中所包含的参数（需要注意的是：此时传入的参数都会被默认为 str 类型，需要在函数内部进行解析和转换）并将处理结果通过print 函数输出；

PHP 通过将 shell_exec 函数返回的结果赋给变量实现取得 Python 返回数据的效果。

php index.php

<form action="" method="post">
    请输入a:<input type="number" name="a" value="请输入a"><br> 请输入b:
    <input type="number" name="b" value="请输入b">
    <button type="submit">计算</button>
</form>
<?php
$aa = $_POST["a"];
$bb = $_POST["b"];
$cmd = shell_exec("python sum.py $aa $bb");
echo "a与b的和是： $cmd";

python sum.py

import sys

# 以下两行解决中文乱码问题
import codecs
sys.stdout = codecs.getwriter('utf-8')(sys.stdout.detach())

a, b = sys.argv[1], sys.argv[2]   # 接收位置参数
print(int(a)+int(b))

字符串示例

?php

$name = '订单5210804229002567电子发票.pdf';
$cmd = shell_exec("python sum.py $name");

echo $cmd;

import sys

# 以下两行解决中文乱码问题
import codecs
sys.stdout = codecs.getwriter('utf-8')(sys.stdout.detach())

a = sys.argv[1]   # 接收位置参数
print(a)

PHP （shell_exec()、exec()、passthru()、system()）的区别

PHP：除了使用 shell_exec()，还可以使用 exec()、passthru() 和 system() 函数调用系统命令，

它们四者的区别如下：

shell_exec()

通过 shell 环境执行命令，并且将完整的输出以字符串的方式返回。

也就是说, PHP先运行一个 shell 环境, 然后让 shell 进程运行你的命令, 并且把所有输出以字符串形式返回, 如果程序执行有错误或者程序没有任何输出, 则返回 null。

exec()

与 shell_exec() 不一样, exec 不会创建 shell 进程, 可以理解是 php 进程直接创建一个子进程, 运行指定的命令, 返回值只返回命令的最后一行, 所有的返回以参数形式返回。

passthru()

与 exec() 类似, 唯一不同的是, 命令的所有输出返回内容都不再导入到 PHP 环境, 而是直接作为输出内容, 返回到浏览器的输出上, 等效是把所有返回内容直接 echo 输出。

system()

这个方法和 passthru() 类似, 但是 system() 方法会在程序的每行输出的时候执行一次缓存输出动作, 可以理解为, 只要外部程序输出一行, php 就会马上把内容推送到浏览器, 无论这个内容是否足够大。

php通常为了输出效率, 都会有一个输出缓存, 会等到输出内容足够大之后, 再一次输出返回. system() 方法则强制输出内容立刻推送, 即使输出的内容只有一个字母. 如果客户端具有实时打印服务器的返回 http 内容流的能力, 就可以看到 system() 的实时推送效果。

python 通过函数名判断函数是否存在及调用

Tue, 13 Dec 2022 13:18:49 +0800

1. 根据“__call__”属性判断

有时候用python就有这么一种感悟，各种钩子函数就是通过内置的“__”属性实现，python学得好不好，就是对“__”属性理解得透彻不透彻。

python函数在调用时，一定会首先调用其相关“__call__”函数（没有空格），请参见python总结(四)：类装饰器与方法的动态添加中的用法。

add = lambda a, b: a + b
#   判断成功
if(hasattr(add, '__call__')):
        print add(1,2)

2. 利用callable判断

这是一个据传快要废弃的方法，但是在Python 2中依旧很好用，如下：

#   判断成功
if(callable(add)):
        print add(2, 2)

3. 利用isfunction进行判断

Python的inspect模块包含了大量的与反射、元数据相关的工具函数，isfunction就是其中一种，使用方法如下：

from inspect import isfunction
#   判断成功
if(isfunction(add)):
    print add(5, 5)

-------------------------------我是分割线----------------------------

现在有多个命名类似的函数,我重新组装函数名(字符串)要判断是否存在及其调用,要用到了python的eval函数

def fun():
print('hello')
a = 'fun'
# 判断函数是否存在
print(callable(eval(a),'__call__'))
> True
# 调用函数
eval(a)()
> hello

应用示例:

def fun1(msg):
print(1,msg.get('info'))
def fun2(msg):
print(2,msg.get('info'))
def fun3(msg):
print(3,msg.get('info'))
msg = {'type':1,'info':'111'}
fun_name = 'fun'+str(msg.get('type'))
if callable(eval(fun_name),'__call__'):
eval(fun_name)(msg)
else:
raise Exception('not found function')

这样就可以根据消息类型调用不同的处理函数

45个实用的前端开发工具汇总

Wed, 23 Feb 2022 14:28:23 +0800

作为开发者的我们，学会使用一些适合自己的开发工具，可以让我们的生活更加自由轻松，因此，今天我跟大家分享45款实用的工具，主要是针对开发与设计人员的，希望这些工具能够帮助到你。

现在，我们就开始今天的内容。

1、Checklist Design

地址：https://www.checklist.design

在设计按钮、卡片、表格等网站元素时，通过网站上提供信息和基本元素来综合网站设计知识的地方。

2、Web Gradients

地址：https://webgradients.com/

在这里我们可以实现网站漂亮的渐变背景颜色的设计与合成。

3、Webframe

地址：https://webframe.xyz

收集精美的 Web 应用程序设计并每周更新。

4、spline

地址：https://spline.design

该应用程序可帮助我们为网站创建 3D 效果。

5、type anything

地址：https://app.typeanything.io

允许我们为网站设计排版Web 应用程序，例如字体选择、字体粗细、字间距……

6、Laws Of UX

地址：https://lawsofux.com

设计师在构建网站用户界面时的最佳实践集合。

7、animista

地址：https://animista.net

帮助我们练习用于网站开发的 CSS 动画效果的 Web 应用程序。

8、screenlane

地址：https://screenlane.com

专门为网站综合UI设计。

9、Froala 设计块

地址：https://froala.com

网站设计合成，上面有超过 170 个 UI 响应式设计。

10、 3Dicons

地址：https://3dicons.co

用于网站设计和开发的免费 3D 图标集合。

11、Collectui

地址：https://collectui.com

UI设计摘要并每天更新。

12、humaaans

地址：https://www.humaaans.com

为设计师收集人物插图。

13、设计原则

地址：https://principles.design

一个致力于提供设计原则和方法的开源集合。

14、learn-anything

地址：https://learn-anything.xyz

当我们想学习一些东西时，这里提供详细的路线。

15、简历设计

地址：https://standardresume.co

一个 Web 应用程序，可帮助设计人员、开发人员创建精美的简历/简历。

16、pictogon

地址：https://pictogon.com

帮助您为您的网站创建交互式图像。

17、 ui play book

地址：https://uiplaybook.dev

用于构建 UI 组件的文档。

18、ui patterns

地址：http://uipatterns.io

它可以帮助我们发现设计模式以及如何解决网站设计过程中的常见问题。

19、网站博物馆

地址：https://www.kapwing.com

是综合各个发展阶段著名网站设计的地方。在我看来，它将帮助我们更好地了解如何设计和开发网站界面。

20、用户体验挑战

地址：https://uxtools.co

网站用户体验设计练习集。我喜欢它的是，在每个挑战中，都会有特定的教程文章。

21、用户体验项目清单

地址：https://uxchecklist.github.io

一个帮助我们检查 UX 功能是否符合设计标准的地方。

22、登陆页面清单

地址：https://landingpage.fyi

综合了 100 多种登陆页面工具，例如选择域名、登陆页面设计软件、标志制作工具……

23、 Ray

地址：https://ray.so

为我们的代码创建漂亮图像的在线软件。

24、像素测量

地址：https://getpixelsnap.com

帮助我们精度测量网站中元素之间的距离。

25、Patternpad

地址：https://patternpad.com

为网站创建漂亮背景图案的Web 应用程序。

26、 Klart

地址：https://klart.io

该网站的一组漂亮的调色板。

27、 Drawkit

地址：https://drawkit.com

为 Web 项目提供免费的插图和图标资源。

28、 Get Waves

地址：https://getwaves.io

为网站创建波浪动画效果的工具。

29、用户体验流

地址：https://products.ls.graphics

它可以帮助我们在 Sketch、Figma 和 Adobe XD 中创建漂亮的网站布局变得容易。

30、Code to go

地址：https://codetogo.io

合成片段，帮助我们解决网站开发中的常见问题。

31、Blobmaker

地址：https://www.blobmaker.app

帮助我们轻松地为网页元素创建 blob 效果。

32、网页代码工具

地址：https://webcode.tools

为 HTML、CSS、元标记、JSON... 合成生成器工具

33、Responsively

地址：https://responsively.app

该应用程序可帮助我们在许多不同的设备屏幕上快速测试网站项目。

34、前端清单

地址：https://frontendchecklist.io

可以帮助我们在构建前端项目时检查要点的工具。

35、Sketch2Code

地址：https://sketch2code.azurewebsites.net

使用 AI 将手绘设计转换为 HTML 的工具。

36、Bootstrap Magic 4.0

地址：https://sketch2code.azurewebsites.net

它可以帮助我们在使用 Bootstrap4 设计网站时，让主题设计变得快速和容易。

37、 Glassmorphism CSS 生成器

地址：https://ui.glass/generator/

帮助我们为网站设计创建玻璃效果。

38、UnusedCSS

地址：https://unused-css.com

为 Web 项目删除不必要的 CSS 属性。

39、Magic Pattern

地址：https://www.magicpattern.design

网站设计工具的集合。

40、Cool Backgrounds

地址：https://coolbackgrounds.io

帮助我们为网站开发创建精美的背景图像效果。

41、Loremipsum

地址：https://loremipsum.io

帮助我们在网站开发过程中快速创建内容。

42、谷歌字体

地址：https://fonts.google.com

它是网站免费字体的集合。

43、Wicked Backgrounds

地址：https://wickedbackgrounds.com

44、自定义形状分隔线

地址：https://www.shapedivider.app/

帮助我们为网站项目创建漂亮的形状。

45、UI Design Daily

地址：https://www.uidesigndaily.com

它是一个为网页设计合成 UI 设计的地方。

26个为开发项目准备的免费优质矢量素材网站

Wed, 23 Feb 2022 14:14:57 +0800

为了避免重复劳动力，我把一些自己收藏使用的插图素材网站做了一个打包，希望这些资源网站对大家有所帮助。

现在，我们就开始今天的内容。

01、Flaticon design

网址：http://flat-icon-design.com

这个是一个日语网站，网站对各种矢量素材做了分类，都是比较主流的设计风格，对于做设计的朋友，这个网站，也是比较友好的，网站上还提供了多种下载格式，其中包括AI、EPS、JPEG、PNG、SVG。

02、unDraw

网址：https://undraw.co/illustrations

这个网站上有很多的插图，并且颜色可以自己定义，非常好用，网站上提供了SVG和PNG格式进行下载。

03、IRA Design

网址：https://iradesign.io/illustrations

这个网站上提供了多种色彩混合模式，包括人物、物体、背景等素材，这些素材还可以自定义渐变色彩。

04、Ouch

网址：https://icons8.com/illustrations

这个网站上有很多可以免费下载的 PNG 和 SVG 插图。

05、DrawKit

网址：https://www.drawkit.io/

这个网站上有免费的也有付费插画资源，我们可以根据自己需要进行下载获取即可，网站对插画图进行了分类，个人觉得非常方便。

06、Humaaans

网址：https://www.humaaans.com/

这个网站上的插画，可以随便混搭，我们可以在线改变插画人物的发型、上衣、裤子等，修改完后，我们还可以将自己设计的插画人物进行下载使用。

07、illu-station

网址：https://themeisle.com/illustrations/

这个网站上有很多高质量的插图，与 unDraw 类似，我们还可以自行设置插画颜色，然后再进行下载。

08、blush.design

网址：https://blush.design/zh-CN

这个网站上有很多风格的插画，我们可以进行多种尝试，网站上提供了 PNG 、 SVG格式供我们下载。

09、Glaze

网址：https://www.glazestock.com/

这个网站上的插图给我们进行了分类，有人物、地点、团队合作、动物、正念、商业、健康、技术等，免费插图我们可以通过PNG 格式进行下载。

10、ManyPixels

网址：https://www.manypixels.co/gallery

这个网站上有各种插图类型，例如轮廓、单色、等距、扁平线和双色，我们可以在线设置插图的主要颜色，以适应我们的特定设计。

11、Open Doodles

网址：https://www.opendoodles.com/

这个网站上的插图，特别有意思，它们都是基于手绘的独特矢量插图。

12、Storyset

网址：https://storyset.com/

这个网站上的在线编辑器功能，我觉得非常好用，我们可以在线根据自己需要，然后编辑好再下载，很方便。

13、Skribbl

网址：https://weareskribbl.com/

这个网站上的插画都是黑白形式的，喜欢这个风格的插画，可以上去看看。

14、OpenPeeps

网址：https://www.openpeeps.com/

这是一个手绘人物插图，在这个网站上，我们可以根据自己需要创建人物，也可以直接下载获取网站上的素材。

15、Illustratious

网址：https://illustratious.com

这个上面有很多免费的彩色插图和动画文件。

16、LukaszAdam

网址：https://lukaszadam.com/illustrations

这个网站上面的有很多插画家、设计师创建的插图，可以免费用于商业和个人用途。

17、Absurd.Design

网址：https://absurd.design/

第一次打开这个插画网站的时候，我就被上面有趣的插画吸引住了，如果我们做点不一样的插画，那这个网站不要错过。

18、Peecheey

网址：http://www.peecheey.com

这个网站上的矢量素材是完全免费的，主要有插画、信息图表、图标等。

19、Freepik

网址：https://www.freepik.com/

这个网站上的素材，有免费也有付费，建议直接下载免费的就可以了，这个上面的素材，质量都不错，既可以下载直接使用，也可以作为设计灵感库，我个人还是非常喜欢的。

20、bg-patterns

网址：http://bg-patterns.com

这个是一个矢量背景素材网站，我们可以自定义素材的彩色、形状、尺寸等，这也是我个人非常喜欢的一个网站。

21、Vecteezy

网址：http://www.vecteezy.com

这是一个免费矢量图的索引站点，收集了相当多的图片素材，并且天天有更新，在这还能看到其他设计师共享的一些矢量图形，我们可以随时随地的去下载免费的素材。

22、DryIcons

网址：https://dryicons.com/

这个网站上提供了大量免费矢量素材、图标、icon、背景等素材资源供我们下载，有免费也付费的，个人觉得，也可以上去看看。

23、Vector Portal

网址：https://vectorportal.com/

这个网站上提供了非常多的矢量插图，我们可以在个人和商业项目中使用，网站上还做了分类，也有搜索功能，找素材非常方便。

24、silhouetteAC

网址：https://www.silhouette-ac.com/tw/

这个网站的矢量素材，都是以剪影的方式呈现，非常有特色，我个人也比较喜欢，网站全部都能直接免费下载，并且也能进行商业使用，如果你喜欢这种剪影风格的矢量素材，我强烈推荐这个网站。

25、vectorish

网址：http://vectorish.com

这个网站上有很多免费创意矢量图，有抽象图、图标、Illustrator、自然、logo 等，这些素材都是可以免费下载使用的。

26、Shareicon

网址：http://www.shareicon.net

这个网站上拥有超过 25 万的icon 矢量图，120 多种分类，所有的素材都提供 PNG、SVG 格式下载，同时也包括多种尺寸，例如512*512、256*256、128*128、64*64、32*32、16*16等，这个网站跟阿里巴巴的矢量图标库有点像，很多做开发做设计的朋友都知道阿里巴巴矢量图标库，里面也有非常多的矢量图标，它也是一个非常好用的素材库网站。

总结

今天内容就先到这里了，如果还有什么问题，请在留言区给我留言，如果你觉得我今天的非常的资源不错，请不要忘记点赞我，关注我，同时，如果觉得非常有帮助的话，也请你分享给你身边做设计做开发或者需要这个资源的朋友。

JavaScript语法 ES6、ES7、ES8、ES9、ES10、ES11、ES12新特性汇总

Wed, 23 Feb 2022 13:51:01 +0800

新特性ES6（2015）

1、类（类）

class Man {
  constructor(name) {
    this.name =  JavaScript语法;
  }
  console() {
    console.log(this.name);
  }
}
const man = new Man( JavaScript语法);
man.console(); //  JavaScript语法

2、智能（ES模块）

// 模块 A 导出一个方法
export const sub = (a, b) = a + b;
// 模块 B 导入使用
import { sub } from ./A;
console.log(sub(1, 2)); // 3

3、箭头（箭头）函数

const func = (a, b) = a + b;
func(1, 2); // 3

4、函数参数默认值

function foo(age = 25,){ // ...}

5、模板字符串

const name =  JavaScript语法;
const str = `Your name is ${name}`;

6、解构架构

let a = 1, b= 2;
[a, b] = [b, a]; // a 2  b 1

7、延展符

let a = [...hello world]; // [h, e, l, l, o,  , w, o, r, l, d]

8、对象属性简写

const name= fly63前端,
const obj = { name };

9、承诺

Promise.resolve().then(() = { console.log(2); });
console.log(1);
// 先打印 1 ，再打印 2

10、让和常量

let name =  JavaScript语法；
const arr = [];

ES7（2016）

1、 Array.prototype.includes()

[1].includes(1); // true

2、指数操作符

2**10; // 1024

ES8（2017）

1、异步/等待

终极终极解决方案

async getData(){
    const res = await api.getTableData(); // await 异步任务
    // do something    
}

2、Object.values()

Object.values({a: 1, b: 2, c: 3}); // [1, 2, 3]

3、 Object.entries()

Object.entries({a: 1, b: 2, c: 3}); // [[a, 1], [b, 2], [c, 3]]

4、字符串填充

// padStart
hello.padStart(10); //      hello
// padEnd
hello.padEnd(10) hello

5、函数参数列表允许结尾

规定也一样，职能规定与规则和结尾的逗号，保持一致。

6、Object.getOwnPropertyDescriptors()

如果对象的所有自身属性获取一个空，则如果没有返回对象。

7、SharedArrayBuffer对象

SharedArray 对象使用表示一个通用的长度的密封缓冲区，密封，

/**
 * 
 * @param {*} length 所创建的数组缓冲区的大小，以字节(byte)为单位。
 * @returns {SharedArrayBuffer} 一个大小指定的新 SharedArrayBuffer 对象。其内容被初始化为 0。
 */
new SharedArrayBuffer(10)

8、原子对象

Atomics 对象提供了一组静态方法，用于对 SharedArrayBuffer 对象进行原子操作。

ES9（2018）

1、徒劳

await可以和for...的循环使用，以某种方式运行异步操作

async function process(array) {
  for await (let i of array) {
    // doSomething(i);
  }
}

2、 Promise.finally()

Promise.resolve().then().catch(e = e).finally();

3、Rest/Spread 属性

const values = [1, 2, 3, 5, 6];
console.log( Math.max(...values) ); // 6

4、正则导演组

const reg = /(year[0-9]{4})-(month[0-9]{2})-(day[0-9]{2})/;
const match = reg.exec(2021-02-23);

5、正则表达式相反声明

(=p)、(=p)  p 前面(位置)、p 后面(位置)
(!p)、(!p) 除了 p 前面(位置)、除了 p 后面(位置)

6、正则表达式dotAll模式

正则表达式中点。除匹配回车外的任何单字符，标记改变这种行为，允许行终止符的出现。

/hello.world/.test(hello\nworld); // false

ES10（2019）

1、Array.flat()和Array.flatMap()

平坦的（）

[1, 2, [3, 4]].flat(Infinity); // [1, 2, 3, 4]

平面图（）

[1, 2, 3, 4].flatMap(a = [a**2]); // [1, 4, 9, 16]

2、String.trimStart()和String.trimEnd()

去除字符串首尾字符

3、String.prototype.matchAll

matchAll（）为所有匹配的匹配对象返回一个重复器

const raw_arr = test1  test2  test3.matchAll((/t(e)(st(\d))/g));
const arr = [...raw_arr];

4、Symbol.prototype.description

只读属性，返回 Symbol 对象的任选描述的字符串。

Symbol(description).description; // description

5、 Object.fromEntries()

返回一个给定对象本人可枚举属性值的关键值。

// 通过 Object.fromEntries， 可以将 Map 转化为 Object:
const map = new Map([ [foo, bar], [baz, 42] ]);
console.log(Object.fromEntries(map)); // { foo: bar, baz: 42 }

6、任选捕获

在 ES10 之前，我们是这样异常的监护人：

try {// tryCode
} catch (err) {// catchCode
}

这里的err是必须的参数，在ES10可以省略这个参数。

ES11（2020）

1、空值合并操作符（空值处理）

表达式在的左边求价值，未定义或返回其性质。

let user = {
    u1: 0,
    u2: false,
    u3: null,
    u4: undefined
    u5: ,
}
let u2 = user.u2  用户2  // false
let u3 = user.u3  用户3  // 用户3
let u4 = user.u4  用户4  // 用户4
let u5 = user.u5  用户5  //

2、可选链（任选链）

用户检测宝宝的孩子

let user = {}
let u1 = user.childer.name // TypeError: Cannot read property name of undefined
let u1 = user.childer.name // undefined

3、Promise.allSettled

返回在所有给定的承诺中，已被拒绝或被拒绝后的亲，并以一个对象的承诺，每个对象表示。

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) = reject(我是失败的Promise_1));
const promise4 = new Promise((resolve, reject) = reject(我是失败的Promise_2));
const promiseList = [promise1,promise2,promise3, promise4]
Promise.allSettled(promiseList)
.then(values={
  console.log(values)
});

4、进口（）

导入导入

5、新基本数据类型 BigInt

任意匹配的概率

6、globalThis

浏览器：window
工人：自己
节点：全局

ES12（2021）

1、全部替换

返回一个全新的字符串，所有符合匹配规则的字符都将被替换掉

const str = hello world;
str.replaceAll(l, ); // heo word

2、Promise.any

Promise.any() 接收到一个Promise 就可以没有拒绝，只要其中的一个promise 成功，就返回那个promise 。如果已经可以让对象中返回一个promise 成功（所有的promise 都失败/），失败的承诺。

const promise1 = new Promise((resolve, reject) = reject(我是失败的Promise_1));
const promise2 = new Promise((resolve, reject) = reject(我是失败的Promise_2));
const promiseList = [promise1, promise2];
Promise.any(promiseList)
.then(values={
  console.log(values);
})
.catch(e={
  console.log(e);
});

3、弱引用

使用WeakRefs的Class类创建对对象的弱引用（对对象的弱引用是指当该对象应该被GC回收时不会阻止GC的回收行为）

4、逻辑和形式表现

之间的关系和表现，以及性能结合了之间的关系（和表现）

a ||= b
//等价于
a = a || (a = b)

a = b
//等价于
a = a  (a = b)

a = b
//等价于
a = a  (a = b)

5、数字字符

数字间隔性符，可以在数字之间创建可视化分隔符，通过_下划线来分割数字，使数字化可计算。

const money = 1_000_000_000;
//等价于
const money = 1000000000;

1_000_000_000 === 1000000000; // true

本文完~

17个免费看电影电视剧的网站，从此告别VIP，轻松看片追剧刷动漫，想看就看

Wed, 23 Feb 2022 13:12:43 +0800

当然，目前YouTube也有不少电影，但是，它广告比较多，除非，你付费观看，如果是这样的话，那爱奇艺，腾讯视频也一样可以，所以，这样一比较，YouTube就没有什么优势了。

我今天分享的这些网站，电影电视剧资源都各有千秋，大家都可以根据自己需要来选择网站进行观看。

有的网站，需要翻墙才可以观看，所以，需要大家先自行解决这个问题。

现在，我们就开始今天的内容吧。

01、4K影视

网址：https://www.4kvm.com/

4K影视网站，片源还是很丰富的，并且也不需要科学上网，打开网站即可播放，网站上有电影电视剧等影片，影片资源清晰度都很高。

02、泥巴影院

网址：https://www.nbyy.tv/

泥巴影院提供了电影，电视剧，综艺，动漫，纪录片，体育等资源。

并且播放视频时也无广告，导航清晰，还提供了安卓版手机App, 可下载到手机上方便观看。

03、片库

网址：https://www.mypianku.net/

片库网上有很多的电影电视剧资源，同时，动漫资源也很丰富，既可以在线观看，也可以选择下载观看，是一个非常好的免费看电影电视剧的网站，资源信息更新也比较快。

04、唐人街影院

网址：https://www.tangrenjie.tv/

唐人街影院，一听名字，就知道，它是一个专注于海外华人的电影电视剧网站。

它除了电影，电视剧外，还有动漫，综艺等内容，信息内容更新也比较快。

它除了支持电脑在线观看外，还支持安卓和苹果手机App安装观看。

无需注册会员，即可免费观看，最重要的是没有广告弹出。

05、捷华影视

网址：https://www.jiehua.tv/

捷华影视，是一个多频道影视网站，里面包括电影，国产电视剧，台湾剧，欧美剧，日本剧，应有尽有。

它支持简体繁体两种界面，它支持手机扫码观看。

电视剧，电影更新速度快，很多都是最新的。

06、欧乐影院

网址：https://www.olevod.com/

欧乐影院有电影，连续剧，综艺，动漫，午夜影院，VIP蓝光影院，支持高清视频，支持在线搜索站内影视及综艺节目。

同时，它们还有自己专用的欧乐官方播放器，播放起来更加流畅。

07、优视频

网址：https://www.uvod.tv/

优视频网站，主要针对海外华人，无需注册即可看标清和高清视频，超清视频需要VIP付费。

有iPhone版，安卓版，iPad版App应用。

播放速度快，视频播放过程中无广告，节目更新比较快。

08、独播库

网址：https://www.duboku.tv/

独播库网站上有很多电视剧，并且上面还有电视剧的打分，但是它上面没有任何电影的信息，如果你喜欢或者想观看电视剧的话，这个网站，你千万不要错过，里面有很多电视剧，主打大陆剧，英美剧，日韩剧，电影，动漫等。

电影电视剧更新速度快，并且播放过程中无广告。

09、胖子视频

网址：https://www.pangzitv.com/

胖子视频网站，是一个比较综合的视频网站，里面有很多搞笑的视频，也有一些游戏视频。

但是，网站的弹出广告较多，如果你不想被广告干扰，需要全屏播放，个人觉得这个网站体验一般。

它上面也支持观看新闻联播，焦点访谈这样的新闻类节目，是为海外华人准备的内容。

10、555电影

网站：https://www.o8tv.com/

555电影网，包括的内容有电影，电视剧，纪录片，动漫，综艺等众多内容。

网站加载速度快，页面干净，最重要的是没有广告插入。

11、瓜子TV

网址：https://guazitv.tv

瓜子TV网站，可以看各种电影电视剧，真的超级方便，还是有很多好看的综艺节目，最主要的是免费，而且还没有广告，更新速度也非常快。

12、剧嗨

网址：https://www.juhi.cc

剧嗨网，影片资源很丰富，而且网站界面也简洁清晰，影视资源更新也比较快，我个人比较喜欢这个网站的风格。

13、奈飞中文电影站

网址：https://yanetflix.com

如果喜欢奈飞电影的话，这个网站你一定不要错过，里面有很多高质量的电影，电视剧，而且支持手机APP观看，播放速度也非常流畅，最重要的就是没有广告。

14、Tubitv

网址：https://tubitv.com

Tubitv网站是一个美国的电影提供站，可以在很多国家进行访问，它的主要特点就是免费，没有广告。里面也有一些直播赛事，有兴趣的可以去看一下，我个人觉得觉得一般。

15、HOHO TV

网址：https://hoho.tv/

这个网站，有很多电影电视剧，不过它以韩剧质量高而著名，如果你喜欢看韩剧的话，这个网站不容错过。

网站也没有广告，可以自由观看。

16、大师兄影视

网址：https://dsxys.com

这个网站，我个人使用不多，因为我觉得打开速度有点慢，大家看我的截图就知道了，里面有的图片都没有加载出来，我不太喜欢等太久，所以，基本加载很慢的网站，我会直接关闭了。

但是，这个网站里面影片资源还是比较丰富的，也有很多最新出的电影电视剧，大家有兴趣的话，可以去看看。

17、爱迪影视

网址：https://aidi.tv

这个网站不需要科学上网，就可以打开，里面也有很多电影电视剧的影片资源。

总结

以上内容就是我与你分享的17个免费看电影电视剧的网站，这些网站，有的是需要翻墙才可以观看的，有的可以直接打开，如果可以直接打开的网站，我也做了说明，其他没有做说明的网站，基本是需要梯子的，所以请自备梯子。