# 字符串处理模块
字符串处理模块提供了丰富的字符串操作功能，包括截断、格式化、大小写转换、随机生成等实用工具函数。
## 引用方式
### ES6 模块引用
```javascript
import sinma from 'sinmajs';
// 或者使用解构赋值
import { truncate, capitalize, camelCase, randomString } from 'sinmajs';
```
### CommonJS 引用
```javascript
const sinma = require('sinmajs');
```
### 浏览器直接引用
```html
<script src="https://unpkg.com/sinmajs@latest/dist/sinma.min.js"></script>
<script>
// 直接使用 sinma 对象
console.log(sinma.truncate('很长的文本内容', 5));
</script>
```
## API 列表
### truncate(str, length, suffix) - 截断字符串
截断字符串到指定长度，并添加后缀。
#### 参数
- `str` {string} - 原字符串
- `length` {number} - 截断长度，默认 `10`
- `suffix` {string} - 后缀字符串，默认 `'...'`
#### 返回值
- {string} - 截断后的字符串
#### 功能代码
```javascript
function truncate(str, length = 10, suffix = '...') {
if (typeof str !== 'string') return '';
if (str.length <= length) return str;
return str.substring(0, length) + suffix;
}
```
#### 使用方法
```javascript
sinma.truncate('这是一个很长的文本内容', 5); // '这是一个很...'
sinma.truncate('短文本', 10); // '短文本'
sinma.truncate('Hello World', 5, '***'); // 'Hello***'
sinma.truncate('测试', 10); // '测试'
```
#### 使用范例
```javascript
// 文章摘要生成
function generateSummary(article, maxLength = 100) {
return sinma.truncate(article.content, maxLength, '...[阅读更多]');
}
// 商品名称显示
const products = [
{ name: '苹果iPhone 15 Pro Max 256GB 深空黑色 5G手机', price: 9999 },
{ name: '华为Mate 60 Pro', price: 6999 }
];
const displayProducts = products.map(product => ({
...product,
displayName: sinma.truncate(product.name, 20)
}));
console.log(displayProducts);
// [
// { name: '...', price: 9999, displayName: '苹果iPhone 15 Pro ...' },
// { name: '...', price: 6999, displayName: '华为Mate 60 Pro' }
// ]
// 表格列宽限制
function formatTableCell(content, maxWidth = 15) {
return sinma.truncate(content, maxWidth, '...');
}
```
---
### capitalize(str) - 首字母大写
将字符串的首字母转换为大写，其余字母转换为小写。
#### 参数
- `str` {string} - 原字符串
#### 返回值
- {string} - 首字母大写的字符串
#### 功能代码
```javascript
function capitalize(str) {
if (typeof str !== 'string' || str.length === 0) return '';
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}
```
#### 使用方法
```javascript
sinma.capitalize('hello world'); // 'Hello world'
sinma.capitalize('JAVASCRIPT'); // 'Javascript'
sinma.capitalize('mIxEd CaSe'); // 'Mixed case'
sinma.capitalize(''); // ''
sinma.capitalize('a'); // 'A'
```
#### 使用范例
```javascript
// 用户姓名格式化
function formatUserName(firstName, lastName) {
return `${sinma.capitalize(firstName)} ${sinma.capitalize(lastName)}`;
}
console.log(formatUserName('john', 'DOE')); // 'John Doe'
// 标题格式化
const titles = ['javascript tutorial', 'VUE.JS GUIDE', 'rEaCt bAsIcS'];
const formattedTitles = titles.map(title => sinma.capitalize(title));
console.log(formattedTitles);
// ['Javascript tutorial', 'Vue.js guide', 'React basics']
// 输入框自动格式化
function autoCapitalizeInput(inputElement) {
inputElement.addEventListener('blur', function() {
this.value = sinma.capitalize(this.value);
});
}
```
---
### camelCase(str) - 驼峰命名转换
将带有连接符的字符串转换为驼峰命名格式。
#### 参数
- `str` {string} - 原字符串
#### 返回值
- {string} - 驼峰命名格式的字符串
#### 功能代码
```javascript
function camelCase(str) {
if (typeof str !== 'string') return '';
return str.replace(/[_-](.)/g, (match, char) => char.toUpperCase());
}
```
#### 使用方法
```javascript
sinma.camelCase('user_name'); // 'userName'
sinma.camelCase('first-name'); // 'firstName'
sinma.camelCase('api_key_value'); // 'apiKeyValue'
sinma.camelCase('hello-world-test'); // 'helloWorldTest'
sinma.camelCase('already_camelCase'); // 'alreadyCamelCase'
```
#### 使用范例
```javascript
// API 数据字段转换
function convertApiResponse(data) {
const converted = {};
for (const [key, value] of Object.entries(data)) {
const camelKey = sinma.camelCase(key);
converted[camelKey] = value;
}
return converted;
}
const apiData = {
user_id: 123,
first_name: 'John',
last_name: 'Doe',
email_address: 'john@example.com',
phone_number: '13812345678'
};
const jsData = convertApiResponse(apiData);
console.log(jsData);
// {
// userId: 123,
// firstName: 'John',
// lastName: 'Doe',
// emailAddress: 'john@example.com',
// phoneNumber: '13812345678'
// }
// CSS 类名转换
function cssClassToJs(className) {
return sinma.camelCase(className.replace(/^-+/, ''));
}
console.log(cssClassToJs('background-color')); // 'backgroundColor'
console.log(cssClassToJs('border-top-width')); // 'borderTopWidth'
```
---
### randomString(length, includeSymbols) - 生成随机字符串
生成指定长度的随机字符串，可选择是否包含特殊符号。
#### 参数
- `length` {number} - 字符串长度，默认 `8`
- `includeSymbols` {boolean} - 是否包含特殊符号，默认 `false`
#### 返回值
- {string} - 生成的随机字符串
#### 功能代码
```javascript
function randomString(length = 8, includeSymbols = false) {
let chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
if (includeSymbols) chars += '!@#$%^&*';
let result = '';
for (let i = 0; i < length; i++) {
result += chars.charAt(Math.floor(Math.random() * chars.length));
}
return result;
}
```
#### 使用方法
```javascript
sinma.randomString(); // 'aBc123Xy' (8位)
sinma.randomString(12); // 'Km9pQ2nR5vBx' (12位)
sinma.randomString(6, true); // 'K@9m!P' (包含符号)
sinma.randomString(16); // '7xR9mK2pQ6vB8nL4' (16位)
```
#### 使用范例
```javascript
// 生成用户临时密码
function generateTempPassword() {
return sinma.randomString(12, true);
}
// 生成验证码
function generateVerificationCode(length = 6) {
// 只使用数字和大写字母，避免混淆
const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
let result = '';
for (let i = 0; i < length; i++) {
result += chars.charAt(Math.floor(Math.random() * chars.length));
}
return result;
}
// 生成文件名
function generateFileName(originalName) {
const extension = originalName.split('.').pop();
const randomName = sinma.randomString(16);
return `${randomName}.${extension}`;
}
console.log(generateFileName('document.pdf')); // 'aBc123XyZm9pQ2nR.pdf'
// 生成API密钥
function generateApiKey() {
const timestamp = Date.now().toString(36);
const random = sinma.randomString(20);
return `${timestamp}_${random}`;
}
// 批量生成唯一标识符
function generateIds(count) {
const ids = new Set();
while (ids.size < count) {
ids.add(sinma.randomString(10));
}
return Array.from(ids);
}
console.log(generateIds(5));
// ['aBc123XyZm', 'pQ2nR5vBx7', 'K9mP6qN8L4', 'R7xK2pQ6vB', 'M8nL4R7xK2']
```
---
### stripHtml(str) - 去除HTML标签
去除字符串中的所有HTML标签，只保留文本内容。
#### 参数
- `str` {string} - 包含HTML标签的字符串
#### 返回值
- {string} - 去除HTML标签后的纯文本
#### 功能代码
```javascript
function stripHtml(str) {
if (typeof str !== 'string') return '';
return str.replace(/<[^>]*>/g, '');
}
```
#### 使用方法
```javascript
sinma.stripHtml('<p>Hello World</p>'); // 'Hello World'
sinma.stripHtml('<div><span>测试</span></div>'); // '测试'
sinma.stripHtml('<h1>标题</h1><p>内容<br>换行</p>'); // '标题内容换行'
sinma.stripHtml('纯文本内容'); // '纯文本内容'
sinma.stripHtml('<script>alert("xss")</script>文本'); // 'alert("xss")文本'
```
#### 使用范例
```javascript
// 富文本内容预览
function generateTextPreview(htmlContent, maxLength = 100) {
const plainText = sinma.stripHtml(htmlContent);
return sinma.truncate(plainText, maxLength);
}
const richText = `
<div class="article">
<h1>文章标题</h1>
<p>这是文章的第一段内容，包含了<strong>重要</strong>信息。</p>
<p>第二段内容继续描述相关内容。</p>
</div>
`;
console.log(generateTextPreview(richText, 50));
// '文章标题这是文章的第一段内容，包含了重要信息。第二段内容继续描述相关...'
// 搜索功能的文本提取
function extractSearchableText(htmlArray) {
return htmlArray.map(html => ({
original: html,
searchText: sinma.stripHtml(html).toLowerCase(),
preview: sinma.truncate(sinma.stripHtml(html), 100)
}));
}
// 评论内容过滤
function sanitizeComment(comment) {
// 去除HTML标签，防止XSS攻击
const cleanText = sinma.stripHtml(comment);
// 进一步清理和验证
return cleanText.trim();
}
// 邮件文本版本生成
function generatePlainTextEmail(htmlEmail) {
let plainText = sinma.stripHtml(htmlEmail);
// 处理换行和段落
plainText = plainText.replace(/\s+/g, ' ').trim();
return plainText;
}
// SEO meta description 生成
function generateMetaDescription(htmlContent) {
const plainText = sinma.stripHtml(htmlContent);
const description = sinma.truncate(plainText, 155);
return description.replace(/\s+/g, ' ').trim();
}
```
## 高级用法示例
### 字符串处理链式操作
```javascript
// 结合多个字符串处理函数
function processUserInput(input) {
return sinma.truncate(
sinma.capitalize(
sinma.stripHtml(input)
),
50
);
}
// 使用链式调用语法糖（如果支持）
function processUserInputChain(input) {
return sinma.chain(input)
.stripHtml()
.capitalize()
.truncate(50)
.unwrap();
}
```
### 批量字符串处理
```javascript
// 批量处理字符串数组
function processBatch(strings, operations = []) {
return strings.map(str => {
let result = str;
operations.forEach(op => {
switch (op.type) {
case 'truncate':
result = sinma.truncate(result, op.length, op.suffix);
break;
case 'capitalize':
result = sinma.capitalize(result);
break;
case 'camelCase':
result = sinma.camelCase(result);
break;
case 'stripHtml':
result = sinma.stripHtml(result);
break;
}
});
return result;
});
}
const strings = ['hello_world', '<p>HTML content</p>', 'MIXED case'];
const operations = [
{ type: 'stripHtml' },
{ type: 'camelCase' },
{ type: 'capitalize' }
];
console.log(processBatch(strings, operations));
// ['HelloWorld', 'HtmlContent', 'MixedCase']
```
### 文本内容分析
```javascript
// 文本统计和分析
function analyzeText(text) {
const plainText = sinma.stripHtml(text);
return {
originalLength: text.length,
plainTextLength: plainText.length,
wordCount: plainText.split(/\s+/).filter(word => word.length > 0).length,
preview: sinma.truncate(plainText, 100),
htmlTagsCount: text.length - plainText.length,
containsHtml: text.length > plainText.length
};
}
const sampleText = '<p>这是一段<strong>包含HTML标签</strong>的文本内容，用于测试分析功能。</p>';
console.log(analyzeText(sampleText));
```
## 性能优化建议
1. **避免重复操作**: 对于大量数据处理，考虑缓存处理结果
2. **合理使用截断**: 在前端显示时才进行截断，避免过早截断丢失信息
3. **HTML标签处理**: 对于大量HTML内容，考虑使用更专业的HTML解析器
4. **随机字符串缓存**: 如果需要大量随机字符串，考虑预生成和缓存
## 注意事项
1. **类型检查**: 所有函数都会检查输入类型，非字符串类型会返回默认值
2. **HTML安全**: `stripHtml` 函数只是简单去除标签，不能完全防止XSS攻击
3. **中文字符**: 所有函数都正确处理中文字符，不会出现乱码问题
4. **性能考虑**: 对于大量数据处理，建议使用批量处理函数
## 相关模块
- [数据验证模块](./validator.md) - 提供字符串格式验证功能
- [中文处理模块](./chinese.md) - 提供中文特有的字符串处理功能
- [链式调用模块](./chain.md) - 提供字符串处理的链式调用语法
