macrocc/tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: Add cutPic, dexcel, and zip tools

Browse Source
This commit is contained in:
macro
2026-04-25 00:01:40 +08:00
commit 8fb110adbd
15 changed files with 2704 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dexcel/src/main.rs
+706
View File
@@ -0,0 +1,706 @@
use calamine::{open_workbook, Data, DataType, Reader, Xlsx};
use chrono::{Datelike, Timelike};
use clap::{Parser, Subcommand};
use std::path::PathBuf;
#[derive(Parser)]
#[command(name = "dexcel")]
#[command(about = "Excel 读写工具", long_about = None)]
struct Cli {
/// Excel 文件路径
file: PathBuf,
#[command(subcommand)]
command: Commands,
}
#[derive(Subcommand)]
enum Commands {
/// 查询数据
Query {
/// 获取行数（正数从前获取，负数从后获取）
#[arg(default_value_t = 0, allow_hyphen_values = true)]
count: i32,
/// 开始行号（从1开始，负数表示倒数）
#[arg(long, allow_hyphen_values = true)]
start: Option<i32>,
/// 获取最后一行
#[arg(long)]
last: bool,
/// Sheet 名称（可选，默认为第一个sheet）
#[arg(long)]
sheet: Option<String>,
},
/// 统计行数
Count {
/// Sheet 名称（可选，默认为第一个sheet）
#[arg(long)]
sheet: Option<String>,
},
/// 插入行
Insert {
/// 要插入的值（使用 split 分隔列）
value: String,
/// 插入位置（行号，不指定则追加到末尾）
#[arg(long, allow_hyphen_values = true)]
row: Option<i32>,
/// Sheet 名称（可选，默认为第一个sheet）
#[arg(long)]
sheet: Option<String>,
/// 分割符号（默认 |）
#[arg(long, default_value = "|")]
split: String,
},
/// 更新数据
Update {
/// 要更新的值（使用 split 分隔列）
value: String,
/// 行号（必需）
#[arg(long, allow_hyphen_values = true)]
row: i32,
/// 起始列号（从1开始，不指定则从第1列开始）
#[arg(long)]
cell: Option<u32>,
/// Sheet 名称（可选，默认为第一个sheet）
#[arg(long)]
sheet: Option<String>,
/// 分割符号（默认 |）
#[arg(long, default_value = "|")]
split: String,
},
/// 删除数据
Delete {
/// 删除数量（单元格数或行数）
#[arg(default_value_t = 1)]
count: u32,
/// 行号（必需）
#[arg(long, allow_hyphen_values = true)]
row: i32,
/// 列号（可选，不指定则删除整行）
#[arg(long)]
cell: Option<u32>,
/// Sheet 名称（可选，默认为第一个sheet）
#[arg(long)]
sheet: Option<String>,
},
}
fn main() {
let cli = Cli::parse();
match cli.command {
Commands::Query {
count,
start,
last,
sheet,
} => {
if let Err(e) = query_excel(&cli.file, count, start, last, &sheet) {
eprintln!("错误: {}", e);
std::process::exit(1);
}
}
Commands::Count { sheet } => {
if let Err(e) = count_excel(&cli.file, &sheet) {
eprintln!("错误: {}", e);
std::process::exit(1);
}
}
Commands::Insert {
value,
row,
sheet,
split,
} => {
if let Err(e) = insert_excel(&cli.file, &value, row, &sheet, &split) {
eprintln!("错误: {}", e);
std::process::exit(1);
}
}
Commands::Update {
value,
row,
cell,
sheet,
split,
} => {
if let Err(e) = update_excel(&cli.file, &value, row, cell, &sheet, &split) {
eprintln!("错误: {}", e);
std::process::exit(1);
}
}
Commands::Delete {
count,
row,
cell,
sheet,
} => {
if let Err(e) = delete_excel(&cli.file, count, row, cell, &sheet) {
eprintln!("错误: {}", e);
std::process::exit(1);
}
}
}
}
// 格式化单元格值为字符串
fn format_cell(cell: &Data) -> String {
match cell {
Data::Empty => String::new(),
Data::Int(v) => v.to_string(),
Data::Float(v) => {
if *v > 1.0 && *v < 2958466.0 && (*v - v.floor()).abs() < 0.0001 {
let temp_data = Data::Float(*v);
if let Some(dt) = temp_data.as_datetime() {
let year = dt.year();
if year >= 1900 && year <= 2100 {
return dt.format("%Y-%m-%d").to_string();
}
}
}
v.to_string()
}
Data::String(s) => s.clone(),
Data::Bool(b) => b.to_string(),
Data::DateTime(d) => {
if let Some(dt) = d.as_datetime() {
if dt.hour() == 0 && dt.minute() == 0 && dt.second() == 0 {
dt.format("%Y-%m-%d").to_string()
} else {
dt.format("%Y-%m-%d %H:%M:%S").to_string()
}
} else {
d.to_string()
}
}
Data::DateTimeIso(s) => s.clone(),
Data::DurationIso(s) => s.clone(),
Data::Error(e) => format!("#{}", e),
_ => String::new(),
}
}
// 统计行数（count 命令）
fn count_excel(
file: &PathBuf,
sheet_name: &Option<String>,
) -> Result<(), Box<dyn std::error::Error>> {
let mut workbook: Xlsx<_> = open_workbook(file)?;
let sheet = match sheet_name {
Some(name) => name.clone(),
None => {
let sheets = workbook.sheet_names();
if sheets.is_empty() {
return Err("Excel 文件中没有 sheet".into());
}
sheets[0].clone()
}
};
let range = workbook
.worksheet_range(&sheet)
.map_err(|e| format!("找不到 sheet: {}, 错误: {}", sheet, e))?;
let total_rows = range.height();
println!("{}", total_rows);
Ok(())
}
// 查询数据（query 命令）
fn query_excel(
file: &PathBuf,
count: i32,
start: Option<i32>,
last: bool,
sheet_name: &Option<String>,
) -> Result<(), Box<dyn std::error::Error>> {
let mut workbook: Xlsx<_> = open_workbook(file)?;
let sheet = match sheet_name {
Some(name) => name.clone(),
None => {
let sheets = workbook.sheet_names();
if sheets.is_empty() {
return Err("Excel 文件中没有 sheet".into());
}
sheets[0].clone()
}
};
let range = workbook
.worksheet_range(&sheet)
.map_err(|e| format!("找不到 sheet: {}, 错误: {}", sheet, e))?;
let total_rows = range.height();
let _total_cols = range.width();
if total_rows == 0 {
println!("表格为空");
return Ok(());
}
// 计算要读取的行范围
let (start_row, end_row) = if last {
(total_rows - 1, total_rows)
} else if let Some(s) = start {
// 使用 start 参数
let actual_start = if s < 0 {
let pos = total_rows as i32 + s;
if pos < 0 { 0 } else { pos as usize }
} else {
(s as usize).saturating_sub(1)
};
if count > 0 {
(actual_start, (actual_start + count as usize).min(total_rows))
} else if count < 0 {
let abs_count = (-count) as usize;
let end = (actual_start + abs_count).min(total_rows);
(actual_start, end)
} else {
// count 为 0，显示从 start 到末尾（最多20行）
let max_display = 20;
let end = (actual_start + max_display).min(total_rows);
if total_rows - actual_start > max_display {
eprintln!("提示: 从第 {} 行开始共有 {} 行数据，仅显示 {} 行",
actual_start + 1, total_rows - actual_start, max_display);
}
(actual_start, end)
}
} else if count > 0 {
(0, count as usize)
} else if count < 0 {
let abs_count = (-count) as usize;
let start = if abs_count >= total_rows { 0 } else { total_rows - abs_count };
(start, total_rows)
} else {
// 默认显示最后20行
let max_display = 20;
if total_rows > max_display {
eprintln!("提示: 共有 {} 行数据，仅显示最后 {} 行", total_rows, max_display);
eprintln!("如需查看更多数据，请使用 dexcel query <行数> 或 --last\n");
(total_rows - max_display, total_rows)
} else {
(0, total_rows)
}
};
let end_row = end_row.min(total_rows);
// 收集所有数据
let mut data: Vec<Vec<String>> = Vec::new();
for r in start_row..end_row {
let mut row_values = Vec::new();
for c in 0..range.width() {
let cell = range.get((r, c));
if let Some(cell_data) = cell {
row_values.push(format_cell(cell_data));
} else {
row_values.push(String::new());
}
}
data.push(row_values);
}
if data.is_empty() {
println!("没有数据");
return Ok(());
}
// 使用 tabled 输出表格
let output_count = data.len();
let col_count = data[0].len();
// 使用 Builder API 创建动态表格
use tabled::builder::Builder;
let mut builder = Builder::default();
// 添加所有行
for row in &data {
builder.push_record(row.iter().map(|s| s.as_str()));
}
let mut table = builder.build();
// 设置样式
table.with(tabled::settings::Style::modern());
println!("{}", table);
eprintln!("\n共输出 {} 行数据，{} 列", output_count, col_count);
Ok(())
}
// 插入行（insert 命令）
fn insert_excel(
file: &PathBuf,
value: &str,
row: Option<i32>,
sheet_name: &Option<String>,
split: &str,
) -> Result<(), Box<dyn std::error::Error>> {
use rust_xlsxwriter::*;
let sheet = match sheet_name {
Some(name) => name.clone(),
None => "Sheet1".to_string(),
};
// 如果文件不存在，创建新文件
if !file.exists() {
let mut workbook = Workbook::new();
let worksheet = workbook.add_worksheet();
worksheet.set_name(&sheet)?;
let values: Vec<&str> = value.split(split).collect();
for (col_idx, val) in values.iter().enumerate() {
let trimmed = val.trim();
if !trimmed.is_empty() {
worksheet.write_string(0, col_idx as u16, trimmed)?;
}
}
workbook.save(file.as_path())?;
println!("✓ 操作成功：已创建新文件并插入一行数据");
eprintln!(" 文件: {}, Sheet: {}", file.display(), sheet);
return Ok(());
}
let mut workbook: Xlsx<_> = open_workbook(file.as_path())?;
let range = workbook
.worksheet_range(&sheet)
.map_err(|e| format!("找不到 sheet: {}, 错误: {}", sheet, e))?;
let total_rows = range.height();
let total_cols = range.width();
// 确定插入位置
let insert_row = match row {
Some(r) => {
if r < 0 {
let pos = total_rows as i32 + r + 1;
if pos < 0 || pos > total_rows as i32 {
return Err(format!("行号无效: {}", r).into());
}
pos as usize
} else {
let pos = r as usize - 1;
if pos > total_rows {
return Err(format!("行号超出范围: {} (总行数: {})", r, total_rows).into());
}
pos
}
}
None => total_rows, // 默认追加到末尾
};
// 创建新工作簿
let mut new_workbook = Workbook::new();
let new_worksheet = new_workbook.add_worksheet();
new_worksheet.set_name(&sheet)?;
let values: Vec<&str> = value.split(split).collect();
let mut new_row = 0u32;
// 复制插入行之前的数据
for r in 0..insert_row {
for c in 0..range.width() {
if let Some(cell_data) = range.get((r, c)) {
write_cell(new_worksheet, new_row, c as u16, cell_data)?;
}
}
new_row += 1;
}
// 写入新行
for (col_idx, val) in values.iter().enumerate() {
let trimmed = val.trim();
if !trimmed.is_empty() {
new_worksheet.write_string(new_row, col_idx as u16, trimmed)?;
}
}
new_row += 1;
// 复制插入行之后的数据
for r in insert_row..total_rows {
for c in 0..range.width() {
if let Some(cell_data) = range.get((r, c)) {
write_cell(new_worksheet, new_row, c as u16, cell_data)?;
}
}
new_row += 1;
}
// 保存文件
new_workbook.save(file.as_path())?;
println!("✓ 操作成功：已在第 {} 行插入一行数据", insert_row + 1);
eprintln!(" 文件: {}, Sheet: {}, 总行数: {}", file.display(), sheet, total_rows + 1);
Ok(())
}
// 更新数据（update 命令）
fn update_excel(
file: &PathBuf,
value: &str,
row: i32,
cell: Option<u32>,
sheet_name: &Option<String>,
split: &str,
) -> Result<(), Box<dyn std::error::Error>> {
use rust_xlsxwriter::*;
if !file.exists() {
return Err(format!("文件不存在: {}", file.display()).into());
}
let mut workbook: Xlsx<_> = open_workbook(file.as_path())?;
let sheet = match sheet_name {
Some(name) => name.clone(),
None => {
let sheets = workbook.sheet_names();
if sheets.is_empty() {
return Err("Excel 文件中没有 sheet".into());
}
sheets[0].clone()
}
};
let range = workbook
.worksheet_range(&sheet)
.map_err(|e| format!("找不到 sheet: {}, 错误: {}", sheet, e))?;
let total_rows = range.height();
let total_cols = range.width();
// 确定行号
let target_row = if row < 0 {
let pos = total_rows as i32 + row;
if pos < 0 || pos >= total_rows as i32 {
return Err(format!("行号无效: {}", row).into());
}
pos as usize
} else {
let pos = row as usize - 1;
if pos >= total_rows {
return Err(format!("行号超出范围: {} (总行数: {})", row, total_rows).into());
}
pos
};
// 确定起始列
let start_col = cell.map(|c| (c - 1) as usize).unwrap_or(0);
// 创建新工作簿并复制所有数据
let mut new_workbook = Workbook::new();
let new_worksheet = new_workbook.add_worksheet();
new_worksheet.set_name(&sheet)?;
let values: Vec<&str> = value.split(split).collect();
for r in 0..total_rows {
for c in 0..range.width() {
if r == target_row && c >= start_col {
// 更新这一行的指定列
let col_offset = c - start_col;
if col_offset < values.len() {
let trimmed = values[col_offset].trim();
if !trimmed.is_empty() {
new_worksheet.write_string(r as u32, c as u16, trimmed)?;
}
} else {
// 超出提供的值，保持原样
if let Some(cell_data) = range.get((r, c)) {
write_cell(new_worksheet, r as u32, c as u16, cell_data)?;
}
}
} else {
// 复制原有数据
if let Some(cell_data) = range.get((r, c)) {
write_cell(new_worksheet, r as u32, c as u16, cell_data)?;
}
}
}
}
// 保存文件
new_workbook.save(file.as_path())?;
println!("✓ 操作成功：已更新第 {} 行，从第 {} 列开始", target_row + 1, start_col + 1);
eprintln!(" 文件: {}, Sheet: {}", file.display(), sheet);
Ok(())
}
// 删除数据（delete 命令）
fn delete_excel(
file: &PathBuf,
count: u32,
row: i32,
cell: Option<u32>,
sheet_name: &Option<String>,
) -> Result<(), Box<dyn std::error::Error>> {
use rust_xlsxwriter::*;
if !file.exists() {
return Err(format!("文件不存在: {}", file.display()).into());
}
let mut workbook: Xlsx<_> = open_workbook(file.as_path())?;
let sheet = match sheet_name {
Some(name) => name.clone(),
None => {
let sheets = workbook.sheet_names();
if sheets.is_empty() {
return Err("Excel 文件中没有 sheet".into());
}
sheets[0].clone()
}
};
let range = workbook
.worksheet_range(&sheet)
.map_err(|e| format!("找不到 sheet: {}, 错误: {}", sheet, e))?;
let total_rows = range.height();
let total_cols = range.width();
// 确定行号
let target_row = if row < 0 {
let pos = total_rows as i32 + row;
if pos < 0 || pos >= total_rows as i32 {
return Err(format!("行号无效: {}", row).into());
}
pos as usize
} else {
let pos = row as usize - 1;
if pos >= total_rows {
return Err(format!("行号超出范围: {} (总行数: {})", row, total_rows).into());
}
pos
};
// 显示确认信息
if let Some(c) = cell {
eprintln!("⚠ 警告：即将删除单元格");
eprintln!(" 文件: {}", file.display());
eprintln!(" Sheet: {}", sheet);
eprintln!(" 位置: 第 {} 行, 第 {} 列", target_row + 1, c);
} else {
eprintln!("⚠ 警告：即将删除以下数据：");
eprintln!(" 文件: {}", file.display());
eprintln!(" Sheet: {}", sheet);
eprintln!(" 删除行: 第 {} 行（共 {} 行）", target_row + 1, total_rows);
// 显示要删除的行的内容
eprint!(" 内容: ");
for c in 0..range.width() {
if let Some(cell_data) = range.get((target_row, c)) {
eprint!("{}", format_cell(cell_data));
if c < range.width() - 1 {
eprint!(" | ");
}
}
}
eprintln!();
}
eprintln!();
// 请求用户确认
eprint!("是否继续？(y/N): ");
use std::io::{self, Write};
io::stdout().flush().unwrap();
let mut input = String::new();
io::stdin().read_line(&mut input)?;
let input = input.trim().to_lowercase();
if input != "y" && input != "yes" {
println!("✗ 操作已取消");
return Ok(());
}
// 创建新工作簿
let mut new_workbook = Workbook::new();
let new_worksheet = new_workbook.add_worksheet();
new_worksheet.set_name(&sheet)?;
if let Some(c) = cell {
// 删除单元格：将该单元格及其右侧的单元格左移
let target_col = (c - 1) as usize;
let mut new_row = 0u32;
for r in 0..total_rows {
let mut new_col = 0u16;
for col in 0..total_cols {
if r == target_row && col == target_col {
continue; // 跳过要删除的单元格
}
if let Some(cell_data) = range.get((r, col)) {
write_cell(new_worksheet, new_row, new_col, cell_data)?;
new_col += 1;
}
}
new_row += 1;
}
println!("✓ 操作成功：已删除第 {} 行第 {} 列的单元格", target_row + 1, c);
} else {
// 删除整行
let mut new_row = 0u32;
for r in 0..total_rows {
if r == target_row {
continue; // 跳过要删除的行
}
for c in 0..range.width() {
if let Some(cell_data) = range.get((r, c)) {
write_cell(new_worksheet, new_row, c as u16, cell_data)?;
}
}
new_row += 1;
}
println!("✓ 操作成功：已删除第 {} 行", target_row + 1);
eprintln!(" 剩余行数: {}", total_rows - 1);
}
// 保存文件
new_workbook.save(file.as_path())?;
eprintln!(" 文件: {}, Sheet: {}", file.display(), sheet);
Ok(())
}
// 辅助函数：写入单元格
fn write_cell(
worksheet: &mut rust_xlsxwriter::Worksheet,
row: u32,
col: u16,
data: &Data,
) -> Result<(), rust_xlsxwriter::XlsxError> {
match data {
Data::String(s) => worksheet.write_string(row, col, s.as_str()).map(|_| ()),
Data::Int(v) => worksheet.write_number(row, col, *v as f64).map(|_| ()),
Data::Float(v) => worksheet.write_number(row, col, *v).map(|_| ()),
Data::Bool(b) => worksheet.write_boolean(row, col, *b).map(|_| ()),
_ => Ok(()),
}
}