.NET应用系统的国际化-基于Roslyn抽取词条、更新代码
上篇文章我们介绍了
系统国际化改造整体设计思路如下：
- 提供一个工具，识别前后端代码中的中文，形成多语言词条，按语言、界面、模块统一管理多有的多语言词条
- 提供一个翻译服务，批量翻译多语言词条
- 提供一个词条服务，支持后端代码在运行时根据用户登录的语言，动态获取对应的多语言文本
- 提供前端多语言JS生成服务，按界面动态生成对应的多语言JS文件，方便前端VUE文件使用。
- 提供代码替换工具，将VUE前端代码中的中文替换为$t("词条ID")，后端代码中的中文替换为TermService.Current.GetText("词条ID")
今天，我们在上篇文章的基础上，继续介绍基于Roslyn抽取词条、更新代码。
一、业务背景
先说一下业务背景，后端.NET代码中存在大量的中文提示和异常消息，甚至一些中文返回值文本。
这些中文文字都需要识别出来，抽取为多语言词条，同时将代码替换为调用多语言词条服务获取翻译后的文本。
例如：
private static void CheckMd5(string fileName, string md5Data)
{
string md5Str = MD5Service.GetMD5(fileName);
if (!string.Equals(md5Str, md5Data, StringComparison.OrdinalIgnoreCase))
{
throw new CustomException(PackageExceptionConst.FileMd5CheckFailed, "服务包文件MD5校验失败：" + fileName);
}
}
代码中需要将“服务包文件MD5校验失败”这个文本做多语言改造。
这里通过调用多语言词条服务I18NTermService，根据线程上下文中设置的语言，获取对应的翻译文本。例如以下代码：
var text=T.Core.I18N.Service.TermService.Current.GetTextFormatted("词条ID"，"默认文本");
throw new CustomException(PackageExceptionConst.FileMd5CheckFailed, text + fileName);
以上背景下，我们准备使用Roslyn技术对代码进行中文扫描，对扫描出来的文本，做词条抽取、代码替换。
二、使用Roslyn技术对代码进行中文扫描
首先，我们先定义好代码中多语言词条的扫描结果类TermScanResult
1 [Serializable]
2 public class TermScanResult
3 {
4 public Guid Id { get; set; }
5 public string OriginalText { get; set; }
6
7 public string ChineseText { get; set; }
8
9 public string SlnName { get; set; }
10
11 public string ProjectName { get; set; }
12
13 public string ClassFile { get; set; }
14
15 public string MethodName { get; set; }
16
17 public string Code { get; set; }
18
19 public I18NTerm I18NTerm { get; set; }
20
21 public string SlnPath { get; set; }
22
23 public string ClassPath { get; set; }
24 28 public string SubSystemCode { get; set; }
29
30 public override string ToString()
31 {
32 return Code;
33 }
34 }
上述代码中SubSystemCode是一个业务管理维度。大家忽略即可。
我们会以sln解决方案为单位，扫描代码中的中文文字。
以下是具体的实现代码
public async Task<List<TermScanResult>> CheckSln(string slnPath, System.ComponentModel.BackgroundWorker backgroundWorker, SubSystemFile subSystemFiles, string subSystem)
{
var slnFile = new FileInfo(slnPath);
var results = new List<TermScanResult>(); MSBuildHelper.RegisterMSBuilder();
var solution = await MSBuildWorkspace.Create().OpenSolutionAsync(slnPath); var subSystemInfo = subSystemFiles?.SubSystemSlnMappings.FirstOrDefault(w => w.SlnName.Select(s => s += ".sln").Contains(slnFile.Name.ToLower())); if (solution.Projects != null && solution.Projects.Count() > 0)
{
foreach (var project in solution.Projects.ToList())
{
backgroundWorker.ReportProgress(10, $"扫描Project: {project.Name}");
var documents = project.Documents.Where(x => x.Name.Contains(".cs")); if (project.Name.ToLower().Contains("test"))
{
continue;
}
var codeReplace = new CodeReplace();
foreach (var document in documents)
{
var tree = await document.GetSyntaxTreeAsync();
var root = tree.GetCompilationUnitRoot();
if (root.Members == null || root.Members.Count == 0) continue;
//member
var classDeclartions = root.DescendantNodes().Where(i => i is ClassDeclarationSyntax); foreach (var classDeclare in classDeclartions)
{
var programDeclaration = classDeclare as ClassDeclarationSyntax;
if (programDeclaration == null) continue; foreach (var memberDeclarationSyntax in programDeclaration.Members)
{
foreach (var item in GetLiteralStringExpression(memberDeclarationSyntax))
{
var statementCode = item.Item1;
foreach (var syntaxNode in item.Item3)
{
ExpressionSyntaxParser expressionSyntaxParser = new ExpressionSyntaxParser();
var text = "";
var expressionSyntax = expressionSyntaxParser
.GetExpressionSyntaxVerifyRule(syntaxNode as ExpressionSyntax, statementCode);
if (expressionSyntax != null)
{
// 排除
if (expressionSyntaxParser.IsExcludeCaller(expressionSyntax, statementCode))
{
continue;
} text = expressionSyntaxParser.GetExpressionSyntaxOriginalText(expressionSyntax, statementCode);
if (expressionSyntax is Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax)
{
text = expressionSyntaxParser.GetExpressionSyntaxOriginalText(expressionSyntax, statementCode); if (expressionSyntax is Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax)
{
if (!expressionSyntax.IsKind(SyntaxKind.StringLiteralExpression))
{
continue;
}
text = expressionSyntax.NormalizeWhitespace().ToString();
}
}
}
if (CheckChinese(text) == false) continue;
if (string.IsNullOrWhiteSpace(text)) continue;
if (string.IsNullOrWhiteSpace(text.Replace("\"", "").Trim())) continue; results.Add(new TermScanResult()
{
Id = Guid.NewGuid(),
ClassPath = programDeclaration.SyntaxTree.FilePath,
SlnPath = slnPath,
OriginalText = text.Replace("\"", "").Trim(),
ChineseText = text,
SlnName = slnFile.Name,
ProjectName = project.Name,
ClassFile = programDeclaration.Identifier.Text,
MethodName = item.Item2,
Code = statementCode,
SubSystemCode = subSystem
});
}
}
}
}
}
}
} return results;
}
上述代码中，我们先使用MSBuilder编译，构建 sln解决方案
MSBuildHelper.RegisterMSBuilder();
var solution = await MSBuildWorkspace.Create().OpenSolutionAsync(slnPath);
然后遍历solution下的各个Project中的class类
foreach (var project in solution.Projects.ToList())
var documents = project.Documents.Where(x => x.Name.Contains(".cs"));
然后遍历类中声明、成员、方法中的每行代码，通过正则表达式识别是否有中文字符
public static bool CheckChinese(string strZh)
{
Regex re = new Regex(@"[\u4e00-\u9fa5]+");
if (re.IsMatch(strZh))
{
return true;
}
return false;
}
如果存在中文字符，作为扫描后的结果，识别为多语言词条
results.Add(new TermScanResult()
{
Id = Guid.NewGuid(),
ClassPath = programDeclaration.SyntaxTree.FilePath,
SlnPath = slnPath,
OriginalText = text.Replace("\"", "").Trim(),
ChineseText = text,
SlnName = slnFile.Name,
ProjectName = project.Name,
ClassFile = programDeclaration.Identifier.Text,
MethodName = item.Item2,
Code = statementCode, //管理维度
SubSystemCode = subSystem //管理维度
});
TermScanResult中没有对词条属性赋值。
public I18NTerm I18NTerm { get; set; }
下一篇文章的代码中，我们会通过多语言翻译服务，将翻译后的文本放到I18NTerm 属性中，作为多语言词条。
三、代码替换
代码替换这块逻辑中，我们设计了一个类SourceWeaver，对上一步的代码扫描结果，进行代码替换
CodeScanReplace这个方法中完成了代码的二次扫描和替换
/// <summary>
/// 源代码替换服务
/// </summary>
public class SourceWeaver
{
List<CommonTermDto> commonTerms = new List<CommonTermDto>();
List<CommonTermDto> commSubTerms = new List<CommonTermDto>(); public SourceWeaver()
{
commonTerms = JsonConvert.DeserializeObject<List<CommonTermDto>>(File.ReadAllText("comm_data.json"));
commSubTerms = JsonConvert.DeserializeObject<List<CommonTermDto>>(File.ReadAllText("comm_sub_data.json"));
}
public async Task CodeScanReplace(Tuple<List<I18NTerm>, List<TermScanResult>> result, System.ComponentModel.BackgroundWorker backgroundWorker)
{
try
{
backgroundWorker.ReportProgress(0, "正在对代码进行替换.");
var termScanResultGroupBy = result.Item2.GroupBy(g => g.SlnName);
foreach (var termScanResult in termScanResultGroupBy)
{
var termScan = termScanResult.FirstOrDefault();
MSBuildHelper.RegisterMSBuilder();
var solution = await MSBuildWorkspace.Create().OpenSolutionAsync(termScan.SlnPath).ConfigureAwait(false);
if (solution.Projects.Any())
{
foreach (var project in solution.Projects.ToList())
{
if (project.Name.ToLower().Contains("test"))
{
continue;
}
var projectTermScanResults = result.Item2.Where(f => f.ProjectName == project.Name); var documents = project.Documents.Where(x =>
{
return x.Name.Contains(".cs") && projectTermScanResults.Any(f => $"{f.ClassPath}" == x.FilePath);
}); foreach (var document in documents)
{
var tree = await document.GetSyntaxTreeAsync().ConfigureAwait(false);
var root = tree.GetCompilationUnitRoot();
if (root.Members.Count == 0) continue; var classDeclartions = root.DescendantNodes()
.Where(i => i is ClassDeclarationSyntax);
List<MemberDeclarationSyntax> syntaxNodes = new List<MemberDeclarationSyntax>();
foreach (var classDeclare in classDeclartions)
{
if (!(classDeclare is ClassDeclarationSyntax programDeclaration)) continue;
var className = programDeclaration.Identifier.Text; // SyntaxNode classSyntaxNode = await classDeclare.SyntaxTree.GetRootAsync().ConfigureAwait(false); foreach (var method in programDeclaration.Members)
{
if (method is ConstructorDeclarationSyntax)
{
syntaxNodes.Add((ConstructorDeclarationSyntax)method);
}
else if (method is MethodDeclarationSyntax)
{
syntaxNodes.Add((MethodDeclarationSyntax)method);
}
else if (method is PropertyDeclarationSyntax)
{
syntaxNodes.Add(method);
}
else if (method is FieldDeclarationSyntax)
{
// 注：常量不支持
syntaxNodes.Add(method);
}
}
} var terms = termScanResult.Where(
f => f.ProjectName == document.Project.Name && f.ClassPath == document.FilePath).ToList();
backgroundWorker.ReportProgress(10, $"正在检查{document.FilePath}文件.");
ReplaceNodesAndSave(root, syntaxNodes, terms, result, backgroundWorker, document.Name);
}
}
}
}
}
catch (Exception ex)
{
LogUtils.LogError(string.Format("异常类型：{0}\r\n异常消息：{1}\r\n异常信息：{2}\r\n",
ex.GetType().Name, ex.Message, ex.StackTrace));
backgroundWorker.ReportProgress(0, ex.Message);
}
} public async void ReplaceNodesAndSave(SyntaxNode classSyntaxNode, List<MemberDeclarationSyntax> syntaxNodes, IEnumerable<TermScanResult> terms, Tuple<List<I18NTerm>, List<TermScanResult>> result,
System.ComponentModel.BackgroundWorker backgroundWorker, string className)
{ {//check pro是否存在词条
if (AppConfig.Instance.IsCheckTermPro)
{
backgroundWorker.ReportProgress(15, $"词条验证中.");
var termsCodes = terms.Select(f => f.I18NTerm.Code).ToList();
var size = 100;
var p = (result.Item2.Count() + size - 1) / size; using DBHelper dBHelper = new DBHelper();
List<I18NTerm> items = new List<I18NTerm>();
for (int i = 0; i < p; i++)
{
var list = termsCodes
.Skip(i * size).Take(size);
Thread.Sleep(10);
var segmentItems = await dBHelper.GetTermsAsync(termsCodes).ConfigureAwait(false);
items.AddRange(segmentItems);
} List<TermScanResult> termScans = new List<TermScanResult>();
foreach (var term in terms)
{
if (items.Any(f => f.Code == term.I18NTerm.Code))
{
termScans.Add(term);
}
else
{
backgroundWorker.ReportProgress(20, $"词条{term.OriginalText}未导入到词条库，该词条将忽略替换.");
}
}
terms = termScans;
}
} var newclassDeclare = classSyntaxNode;
newclassDeclare = classSyntaxNode.ReplaceNodes(syntaxNodes,
(methodDeclaration, _) =>
{
// var methodName = methodDeclaration.Identifier.Text;
//var methodTerms = terms.Where(term => term.MethodName == methodName)
// .OrderByDescending(term => term.OriginalText.Length); MemberDeclarationSyntax newMemberDeclarationSyntax = methodDeclaration;
var className = ((ClassDeclarationSyntax)newMemberDeclarationSyntax.Parent).Identifier.Text;
List<StatementSyntax> statementSyntaxes = new List<StatementSyntax>(); switch (newMemberDeclarationSyntax)
{
case ConstructorDeclarationSyntax:
{
var blockSyntax = (newMemberDeclarationSyntax as ConstructorDeclarationSyntax).NormalizeWhitespace().Body;
if (blockSyntax == null)
{
break;
}
foreach (var statement in blockSyntax.Statements)
{
var nodeStatement = statement.DescendantNodes(); statementSyntaxes.Add(new CodeReplace().ReplaceStatementNodes(statement,
new ExpressionSyntaxParser().LiteralStringExpression(nodeStatement), terms, commonTerms, commSubTerms));
} break;
} case MethodDeclarationSyntax:
{
var blockSyntax = (methodDeclaration as MethodDeclarationSyntax).NormalizeWhitespace().Body;
if (blockSyntax == null)
{
break;
}
foreach (var statement in blockSyntax.Statements)
{
var nodeStatement = statement.DescendantNodes();
statementSyntaxes.Add(new CodeReplace().ReplaceStatementNodes(statement,
new ExpressionSyntaxParser().LiteralStringExpression(nodeStatement), terms, commonTerms, commSubTerms));
} break;
} case PropertyDeclarationSyntax:
{
var propertyDeclarationSyntax = newMemberDeclarationSyntax as PropertyDeclarationSyntax; var nodeStatement = propertyDeclarationSyntax.DescendantNodes(); return new CodeReplace().ReplacePropertyNodes(newMemberDeclarationSyntax as PropertyDeclarationSyntax,
new ExpressionSyntaxParser().LiteralStringExpression(nodeStatement), terms, commonTerms, commSubTerms);
} case FieldDeclarationSyntax:
{
var fieldDeclarationSyntax = newMemberDeclarationSyntax as FieldDeclarationSyntax;
var nodeStatement = fieldDeclarationSyntax.DescendantNodes();
return new CodeReplace().ReplaceFiledNodes(fieldDeclarationSyntax,
new ExpressionSyntaxParser().LiteralStringExpression(nodeStatement), terms, commonTerms, commSubTerms);
}
}
backgroundWorker.ReportProgress(50, $"解析并对类文件{className}中的方法做语句替换.");
// 替换方法内部
if (newMemberDeclarationSyntax is MethodDeclarationSyntax)
{
return new CodeReplace().ReplaceMethodDeclaration(newMemberDeclarationSyntax as MethodDeclarationSyntax, statementSyntaxes);
}
else if (newMemberDeclarationSyntax is ConstructorDeclarationSyntax)
{
return new CodeReplace().ReplaceConstructorDeclaration(newMemberDeclarationSyntax as ConstructorDeclarationSyntax, statementSyntaxes);
}
return newMemberDeclarationSyntax;
}); var sourceStr = newclassDeclare.NormalizeWhitespace().GetText().ToString();
File.WriteAllText(newclassDeclare.SyntaxTree.FilePath, sourceStr);
backgroundWorker.ReportProgress(100, $"完成{className}的替换.");
}
}
关键的代码语义替换的实现代码：
public StatementSyntax ReplaceStatementNodes(StatementSyntax statement, List<ExpressionSyntax> expressionSyntaxes, IEnumerable<TermScanResult> terms
, List<CommonTermDto> commonTerms, List<CommonTermDto> commSubTerms)
{
var statementSyntax = statement.ReplaceNodes(expressionSyntaxes, (syntaxNode, _) =>
{
var statementStr = statement.NormalizeWhitespace().ToString(); var argumentLists = statement.DescendantNodes().
OfType<InvocationExpressionSyntax>();
ExpressionSyntaxParser expressionSyntaxParser = new ExpressionSyntaxParser();
return expressionSyntaxParser.ExpressionSyntaxTermReplace(syntaxNode, statementStr, terms, commonTerms, commSubTerms); }); return statementSyntax;
}
这里，我们抽象了一个ExpressionSyntaxParser 类，负责替换代码：
T.Core.I18N.Service.TermService.Current.GetTextFormatted
public ExpressionSyntax ExpressionSyntaxTermReplace(ExpressionSyntax syntaxNode, string statementStr, IEnumerable<TermScanResult> terms
, List<CommonTermDto> commonTerms, List<CommonTermDto> commSubTerms)
{
var expressionSyntax = GetExpressionSyntaxVerifyRule(syntaxNode, statementStr);
var originalText = GetExpressionSyntaxOriginalText(expressionSyntax, statementStr); var I18Expr = "";
var interpolationSyntaxes = syntaxNode.DescendantNodes().OfType<InterpolationSyntax>();
var term = terms.FirstOrDefault(i => i.ChineseText == originalText); if (term == null)
return syntaxNode;
string termcode = term.I18NTerm.Code;
if (syntaxNode is InterpolatedStringExpressionSyntax)
{
if (interpolationSyntaxes.Count() > 0)
{
var parms = "";
foreach (var item in interpolationSyntaxes)
{
parms += $",{item.ToString().TrimStart('{').TrimEnd('}')}";
}
I18Expr = "$\"{T.Core.I18N.Service.TermService.Current.GetTextFormatted(\"" + termcode + "\", " + originalText + parms + ")}\"";
var token1 = SyntaxFactory.Token(default, SyntaxKind.StringLiteralToken, I18Expr, "", default);
return SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, token1);
}
else
{ var startToken = SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken);
if ((syntaxNode as InterpolatedStringExpressionSyntax).StringStartToken.Value == startToken.Value)
{
// 如果本身有"$"
I18Expr = "$\"{T.Core.I18N.Service.TermService.Current.GetText(\"" + termcode + "\"," + originalText + ")}";
}
else
{
// 如果没有"$"
I18Expr = "$\"{T.Core.I18N.Service.TermService.Current.GetText(\"" + termcode + "\",\\teld\"" + originalText + "\")}";
I18Expr = I18Expr.Replace("\\teld", "$");
}
}
}
else
{
I18Expr = "$\"{T.Core.I18N.Service.TermService.Current.GetText(\"" + termcode + "\"," + originalText + ")}";
} var token = SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.InterpolatedVerbatimStringStartToken, I18Expr, "$\"", default(SyntaxTriviaList));
var literalExpressionSyntax = SyntaxFactory.InterpolatedStringExpression(token);
return literalExpressionSyntax;
}
T.Core.I18N.Service.TermService这个就是多语言词条服务类，这个类中提供了一个GetText的方法，通过词条编号，获取多语言文本。
代码完成替换后，打开VS，对工程引用多语言词条服务的Nuget包/dll，重新编译代码，手工校对替换后的代码即可。
以上是.NET应用系统的国际化-基于Roslyn抽取词条、更新代码的分享。
周国庆
2023/3/19
.NET应用系统的国际化-基于Roslyn抽取词条、更新代码的更多相关文章
- springmvc国际化 基于请求的国际化配置
springmvc国际化 基于请求的国际化配置 基于请求的国际化配置是指,在当前请求内,国际化配置生效,否则自动以浏览器为主. 项目结构图: 说明:properties文件中为国际化资源文件.格式相关 ...
- springmvc国际化 基于浏览器语言的国际化配置
当前标签: springmvc springmvc国际化 基于浏览器语言的国际化配置 苏若年 2013-10-09 13:03 阅读:305 评论:0 SpringMVC中应用Ajax异步通讯 ...
- 如何写好、管好单元测试？基于Roslyn+CI分析单元测试，严控产品提测质量
上一篇文章中,我们谈到了通过Roslyn进行代码分析,通过自定义代码扫描规则,将有问题的代码.不符合编码规则的代码扫描出来,禁止签入,提升团队的代码质量. .NET Core技术研究-通过Roslyn ...
- 基于 Roslyn 实现动态编译
基于 Roslyn 实现动态编译 Intro 之前做的一个数据库小工具可以支持根据 Model 代码文件生成创建表的 sql 语句,原来是基于 CodeDom 实现的,最近改成使用基于 Roslyn ...
- 基于roslyn的动态编译库Natasha
人老了,玩不转博客园的编辑器,详细信息转到:https://mp.weixin.qq.com/s/1r6YKBkyovQSMUgfm_VxBg 关键字:Github, NCC, Natasha,Ros ...
- 基于 Roslyn 实现一个简单的条件解析引擎
基于 Roslyn 实现一个简单的条件解析引擎 Intro 最近在做一个勋章的服务,我们想定义一些勋章的获取条件,满足条件之后就给用户颁发一个勋章,定义条件的时候会定义需要哪些参数,参数的类型,获取勋 ...
- 搭建基于SornaQube的自动化安全代码检测平台
一.背景和目的 近年来,随着新业务.新技术的快速发展,应用软件安全缺陷层出不穷.虽然一般情况下,开发者基本都会有单元测试.每日构建.功能测试等环节来保证应用的可用性.但在安全缺陷方面,缺乏安全意识.技 ...
- 基于Quick-cocos2d-x的资源更新方案 二
写在前面 又是12点半了,对于一个程序员来说,这是一个黄金时间,精力旺盛,我想,是最适合整理和分享一些思路的时候了. 自从上次写了 基于Quick-cocos2d-x的资源更新方案 同样可见quick ...
- jQuery基于ajax实现星星评论代码
本文实例讲述了jQuery基于ajax实现星星评论代码.分享给大家供大家参考.具体如下: 这里使用jquery模仿点评网的星星评论功能,Ajax评论模块,鼠标点击星星即可评价,下边是分数,可以点击后给 ...
- 基于eclipse的mybatis映射代码自动生成的插件
基于eclipse的mybatis映射代码自动生成的插件 分类: JAVA 数据库 工具相关2012-04-29 00:15 2157人阅读 评论(9) 收藏 举报 eclipsegeneratori ...
随机推荐
- spider_object_01使用正则爬取百度贴吧所有内容保存成html
"""本案例不涉及数据提取,仅指导 网页分页爬取的两种方式 思路非第一种:利用while Ture,传参,然后在设定一个判断条件,案例中用的是如果找不到下一页,循环退出( ...
- 前端vue框架上手记录
---恢复内容开始--- Vue CLI 是一个基于 Vue.js 进行快速开发的完整系统,提供: 通过 @vue/cli 搭建交互式的项目脚手架. 通过 @vue/cli + @vue/cli-se ...
- Django基础篇 04-模型类注册到后台Django Admin中
一.django自带的admin的url地址 urls.py文件中 from django.contrib import admin from django.urls import path from ...
- Number（数字）
Python 中的变量不需要声明.每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建. 在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对 ...
- idea 部署项目到 docker 运行
1.在远程服务器上开启 docker 远程连接 $vim /usr/lib/systemd/system/docker.service # ExecStart=/usr/bin/dockerd -H ...
- 双指针_Leetcode刷题_13/100
算法解释 双指针主要用于遍历数组,两个指针指向不同的元素,从而协同完成任务.也可以延伸到多个数组的多个指针. 若两个指针指向同一个数组,遍历的方向相同且不会相交,则也称为滑动窗口: 若两个指针指向同一 ...
- nodejs 配置国内镜像
npm config set registry https://registry.npm.taobao.org npm config set disturl https://npm.taobao.or ...
- redis面试题汇总
1redis持久化机制 redis是一个支持持久化的内存数据库,通过持久化机制把内存中的数据同步到硬盘文件来保证数据持久化,当redis重启后通过把硬盘文件重新加载到内存,就能达到恢复数据的目的 2缓 ...
- 创建一个Openpyxl
from openpyxl import Workbook wb = Workbook(r'C:\Users\yjiang3\Desktop\23.xlsx') ws = wb.active from ...
- JS第一节课
document.getElementById() id document.getElementsByClassName() class document.getElementsByNa ...