帮助与文档 > 产品文档 > 作文批改 > API文档 > 英语作文批改(文本输入)
英语作文批改(文本输入)

英文作文批改(文本输入) API 简介

说明

Hi,您好,欢迎使用有道智云英文作文批改(文本输入)API 接口服务。

本文档主要针对需要集成 HTTP API 的技术开发工程师,详细描述英文作文批改(文本输入)能力相关的技术内容。

如果您有与我们商务合作的需求,可以通过以下方式联系我们:

商务邮箱: AIcloud_Business@corp.youdao.com

如果您对文档内容有任何疑问,可以通过以下几种方式联系我们:

客服 QQ:1906538062

智云作文批改技术交流 QQ 1 群: 1092639188

智云 OCR 技术交流 QQ 2 群: 471638046

联系邮箱: zhiyun@corp.youdao.com

温馨提示:

  • 本文档主要针对开发人员,接入测试前需要获取应用 ID 和应用密钥,并绑定实例;如果您还没有,请按照 新手指南 获取。
  • 平台向每个账户赠送 50 元的体验金,供用户集成前测试所用,具体资费规则详见 英文作文批改服务报价

接口说明

有道 AI 团队自研的基于深度学习网络技术的自动作文批改技术。覆盖学生英语学习全周期,提供高参考价值的智能批改功能,用户只需要输入一篇英文作文,选择对应的英文级别,智能批改服务即可一键给出文章得分、整体评价、拼写错误反馈、语法错误反馈、主题相关度反馈、以及高级词汇和推荐词组等一系列结果,从而向用户提供针对性的作文指导意见。

英文作文批改(文本输入) API HTTPS 地址:

https://openapi.youdao.com/correct_writing_text

协议须知

调用方在集成文本翻译 API 时,请遵循以下规则。

规则描述
传输方式HTTPS
请求方式POST
字符编码统一使用 UTF-8 编码
请求格式表单
响应格式JSON

接口调用参数

调用 API 需要向接口发送以下字段来访问服务。

字段名类型含义必填备注
qtext批改的文本。文本不超过 5000 字符Truetext
langTypetext语言,目前仅支持英文Falseen
appKeytext应用标识(应用 ID)True可在 应用管理 查看
salttext随机字符串Truehfa12lak56ja9gjl
signtext签名信息:sha256(appKey+input+salt+密钥)Truexxxxx
gradetext作文等级。支持列表见下面 grade 支持列表,默认不管等级,只评价句子好坏falsedefault
titletext作文标题false0
modelContenttext用户提供的范文内容false0
goodExpressiontext用户提供的好的表达false0
needTypotext是否需要 typo,(true/false),默认为 truefalsetrue
signTypetext签名类型truev3
limitedWordstext作文字数限制false1000

最好传输 limitedWords,这样评分更精确。
签名生成算法如下:

  • signType=v3,sha256(应用 ID+input+salt+curtime+密钥),推荐使用

sha256 签名计算方法为:sha256(应用 ID+input+salt+当前 UTC 时间戳+密钥)。

其中,input 的计算方式为:input=多个q拼接后前10个字符 + 多个q拼接长度 + 多个q拼接后十个字符(当多个 q 拼接后长度大于 20)或 input=多个q拼接的字符串(当多个 q 拼接后长度小于等于 20)。

不同语言获取时间戳,请参看此此链接

如果对签名有疑问,可以参看各语言 demo。

grade 支持列表

级别代码
不考虑级别,单纯评价句子好坏default
小学elementary
初中junior
高中high
四级cet4
六级cet6
考研graduate
托福toefl
GREgre
雅思ielts

响应码

错误码含义
101缺少必填的参数,出现这个情况还可能是 et 的值和实际加密方式不对应
102不支持的语言类型
103翻译文本过长
104不支持的 API 类型
105不支持的签名类型
106不支持的响应类型
107不支持的传输加密类型
108appKey 无效,注册账号, 登录后台创建应用和实例并完成绑定, 可获得应用 ID 和密钥等信息,其中应用 ID 就是 appKey( 注意不是应用密钥)
109batchLog 格式不正确
110无相关服务的有效实例
111开发者账号异常
201解密失败,可能为 DES,BASE64,URLDecode 的错误
202签名检验失败
203访问 IP 地址不在可访问 IP 列表
205请求的接口与应用的平台类型不一致
206因为时间戳无效导致签名校验失败
207重放请求
301辞典查询失败
302小语种查询失败
303服务端的其它异常
401账户已经欠费停
411访问频率受限,请稍后访问
412大图片请求过于频繁,请稍后访问
29001inputType 类型不对
29002needTypo 类型不对
29003Q 超过限制长度
29004grade 类型不对
29005文件为空
29006图片过大
29301作文批改请求失败

响应结果说明

{
"errorCode": "错误码",
"Result": {
    "uniqueKey": "每个请求独一无二的字符串标识",
    "essayLangName": "语言信息",
    "rawEssay": "请求原文",
    "refEssay": "参考范文",
    "stLevel": "作文级别",
    "reqSource": "请求来源",
    "extraParams": "额外请求参数(扩展用参数)",
    "wordNum": "文章总词数"
    "conjWordNum": "文章连接词数",
    "AllFeatureAdvice": { # 作文各特征的建议
        "WordNum": "词数建议,如文章字数疑似超出该考试字数要求",
        "Spelling": "拼写错误建议",
        "WordDiversity": "词汇丰富度建议,如词汇量积累非常少,只能给出一些零散的简单词汇,建议多积累词汇",
        "Structure": "文章结构建议",
        "AdvanceVocab": [
            "xx", "xx", "xx" # 文中使用的高级词汇
        ],
        "AdvanceVocabLeval": [0, 1, 2], # 对应高级词汇的级别
        "lexicalSubs": [ # 词汇替换(注意:candidates中词汇可能为空,表示没有推荐替换的近义词,但word使用频率超过3次)
            {"candidates": ["xx", "xx"], "count": 频率, "word": xx 对应词}, ...
        ]
        "Conjunction": [{
            "used": ["xx", "xx", "xx"] # 已使用连词
            "advice": ["xx", "xx", "xx"] # 推荐词
        }],
        "Topic": "主题相关性建议",
        "Grammar": "语法相关建议",
        "GoodExpression": ["xx", "xx", "xx"] # 好的表达
    },
    "AllFeatureScore": { # 对应上面AllFeatureAdvice各特征得分,除NeuralScore是没有Advice的,它代表神经网络作文打分结果,不是最终打分结果!
        "NeuralScore": 68.64,     # 范围:[0,100]
        "WordNum": 10,  # 范围:[0, 10] ---> 指的是词数得分
        "Spelling": 10,   # 范围:[0, 10]
        "WordDiversity": 0,  # 范围:[0, 10]
        "Structure": 8,  # 范围:[0, 10]
        "AdvanceVocab": 7.61,   # 范围:[0, 10]
        "Conjunction": 6.94,   # 范围:[0, 10]
        "Topic": 6.03,  # 范围:[0, 10]
        "Grammar": 2.5  # 范围:[0, 10]
        "SentComplex": 10 # 范围: [0, 10]
    },
    "majorScore": { # 是AllFeatureScore中score整合结果
        "WordScore": 10, # 词汇得分:包括词数、丰富度、高级词汇等得分
        "GrammarScore": 10, # 语法得分:包括拼写、语法、句子复杂度得分等
        "StructureScore": 10, # 逻辑得分:包括段落和连接词得分
        "topicScore": 10, # 内容(主题相关性)得分,如果没有参考范文,该部分得分会从语法和复杂度上考虑
    },
    "essayFeedback":{
        "sentsFeedback": [
            {
                "sentId": "句子在全文的编号,从0开始",
                "paraId": "该句所在的段落号,从0开始",
                "rawSent": "原句",
                "segSent": "原句分词后的结果",
                "correctedSent": "原句修正后的结果",
                "sentStartPos": "该句子在全文中相对于文章初始位置的偏移量",
                "errorPosInfos": [
                    {
                        "type": "错误类型(包括`grammar`,`typo`,`refactor`)",
                        "startPos": "错误起始位置相对rawSent起始位置的偏移量",
                        "endPos": "错误结束位置相对rawSent起始位置的偏移量",
                        "orgChunk": "错误块的具体内容",
                        "correctChunk": "错误块修正后的具体内容",
                        "error_type": "(弃用) 错误的具体类别(0表示拼写错误,1表示冠词错误,2表示动词时态或者第三人称单复数错误,3表示名词单复数错误,4表示格错误,5表示介词错误,6表示其他语法错误,7表示文本格式错误,8表示正确)",
                        "new_error_type": "错误类别(0表示完全正确,
                        1表示书写格式不规范,2表示拼写错误,
                        3表示标点错误,4表示冠词错误,5表示动词错误,
                        6表示名词单复数错误,7表示代词错误,8表示介词错误,
                        9表示形容词错误,10表示副词错误,11表示连词错误,
                        20表示其他错误,21表示代指所有语法错误(兼容))"
                        "new_sub_error_type": "细分错误类别(0表示正确,1表示未知错误,2表示词汇缺失,3表示词汇冗余,
                        4表示冠词误用,5表示介词误用,6表示动词主谓一致错误,7表示动词时态错误,8表示情态动词后应接动词原形错误,
                        9表示被动语态错误,10表示动词不定式错误,11表示动词错误,12表示形容词比较级错误,
                        13表示形容词最高级错误,14表示副词比较级错误,15表示副词最高级错误,16表示名词单复数错误,
                        17表示名词错误,18表示人称代词主宾格混淆,19表示人称代词和物主代词混淆,20表示形容词性和名词性代词混淆,
                        21表示人称代词和反身代词混淆,22表示疑问/关系/连接代词混淆,23表示指示代词混淆,24表示不定代词混淆,
                        25表示代词错误,26表示标点符号误用,27表示拼写错误,28表示不规范错误)"
                            "举例说明": 如果new_error_type=5, new_sub_error_type=2,说明是动词缺失
                        "reason": "错误的具体原因",
                        "isValidLangChunk": "类似下面的isValidSent,判断是否为合法片段(该片段如果语言检测结果与期望不一致,则认为不合法)"
                        "analysis": "错误的原因的具体辨析(保留接口,暂时应该没用)"
                    }, ..., {}
                ],
                "isValidLangSent": "是否为合法句子(合法与否取决于语言检测对该句的语言信息识别结果与期望结果是否一致)"
                "sentFeedback": "错误原因反馈,基于errorPosInfos中所有reason字段拼接而成",
                "isContainTypoError": "返回是否含有typo错误",
                "isContainGrammarError": "返回是否含有语法错误",
                "sentScore": "句子得分(暂时没有用,即将实现)"
            }
        ]
    }
    "totalScore": "文章最终得分"
    "fullScore": "对应级别满分"
    "essayAdvice": "文章最终评价"
    "paraNum": "文章段落数"
    "sentNum": "文章句子数"
}
}

常见问题及注意事项

  • 返回 101

首先确保必填参数齐全,然后,确认参数书写是否正确。

  • 返回 108

应用 ID 无效,注册账号,登录后台创建应用和实例并完成绑定,可获得应用 ID 和应用密钥等信息。

  • 返回 110

应用没有绑定服务实例,可以新建服务实例,绑定服务实例。
注:某些服务的翻译结果发音需要 tts 实例,需要在控制台创建语音合成实例绑定应用后方能使用。

  • 返回 202

如果确认应用 ID 和应用密钥的正确性,仍返回 202,一般是编码问题。请确保翻译文本 q 为 UTF-8 编码.

  • 返回 205

确保接入方式(Android SDK、IOS SDK、API)与创建的应用平台类型一致。

常用语言 Demo

Java 示例

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;


public class TextcorrectwritingV3Demo {

    private static Logger logger = LoggerFactory.getLogger(TextcorrectwritingV3Demo.class);

    private static final String YOUDAO_URL = "https://openapi.youdao.com/correct_writing_text";

    private static final String APP_KEY = "您的应用ID";

    private static final String APP_SECRET = "您的应用密钥";

    public static void main(String[] args) throws IOException {

        Map<String,String> params = new HashMap<String,String>();
        String q = "待输入的文字";
        String grade = "default";
        String salt = String.valueOf(System.currentTimeMillis());
        String curtime = String.valueOf(System.currentTimeMillis() / 1000);
        params.put("curtime", curtime);
        String signStr = APP_KEY + truncate(q) + salt + curtime + APP_SECRET;
        String sign = getDigest(signStr);
        params.put("appKey", APP_KEY);
        params.put("q", q);
        params.put("grade", grade);
        params.put("salt", salt);
        params.put("sign", sign);
        params.put("signType", "v3");
        /** 处理结果 */
        requestForHttp(YOUDAO_URL,params);
    }

    public static void requestForHttp(String url,Map<String,String> params) throws IOException {

        /** 创建HttpClient */
        CloseableHttpClient httpClient = HttpClients.createDefault();

        /** httpPost */
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> paramsList = new ArrayList<NameValuePair>();
        Iterator<Map.Entry<String,String>> it = params.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<String,String> en = it.next();
            String key = en.getKey();
            String value = en.getValue();
            paramsList.add(new BasicNameValuePair(key,value));
        }
        httpPost.setEntity(new UrlEncodedFormEntity(paramsList,"UTF-8"));
        CloseableHttpResponse httpResponse = httpClient.execute(httpPost);
        try{
            Header[] contentType = httpResponse.getHeaders("Content-Type");
            logger.info("Content-Type:" + contentType[0].getValue());
            if("audio/mp3".equals(contentType[0].getValue())){
                //如果响应是wav
                HttpEntity httpEntity = httpResponse.getEntity();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                httpResponse.getEntity().writeTo(baos);
                byte[] result = baos.toByteArray();
                EntityUtils.consume(httpEntity);
                if(result != null){//合成成功
                    String file = "合成的音频存储路径"+System.currentTimeMillis() + ".mp3";
                    byte2File(result,file);
                }
            }else{
                /** 响应不是音频流,直接显示结果 */
                HttpEntity httpEntity = httpResponse.getEntity();
                String json = EntityUtils.toString(httpEntity,"UTF-8");
                EntityUtils.consume(httpEntity);
                logger.info(json);
                System.out.println(json);
            }
        }finally {
            try{
                if(httpResponse!=null){
                    httpResponse.close();
                }
            }catch(IOException e){
                logger.info("## release resouce error ##" + e);
            }
        }
    }

    /**
     * 生成加密字段
     */
    public static String getDigest(String string) {
        if (string == null) {
            return null;
        }
        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        byte[] btInput = string.getBytes();
        try {
            MessageDigest mdInst = MessageDigest.getInstance("SHA-256");
            mdInst.update(btInput);
            byte[] md = mdInst.digest();
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (byte byte0 : md) {
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        } catch (NoSuchAlgorithmException e) {
            return null;
        }
    }

    /**
    *
    * @param result 音频字节流
    * @param file 存储路径
    */
    private static void byte2File(byte[] result, String file) {
        File audioFile = new File(file);
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream(audioFile);
            fos.write(result);

        }catch (Exception e){
            logger.info(e.toString());
        }finally {
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

  public static String truncate(String q) {
        if (q == null) {
            return null;
        }
        int len = q.length();
        String result;
        return len <= 20 ? q : (q.substring(0, 10) + len + q.substring(len - 10, len));
    }
}

Python 示例

# -*- coding: utf-8 -*-
import sys
import uuid
import requests
import hashlib
import time
import time

reload(sys)
sys.setdefaultencoding('utf-8')

YOUDAO_URL = 'https://openapi.youdao.com/correct_writing_text'
APP_KEY = '您的应用ID'
APP_SECRET = '您的应用密钥'


def encrypt(signStr):
    hash_algorithm = hashlib.sha256()
    hash_algorithm.update(signStr.encode('utf-8'))
    return hash_algorithm.hexdigest()


def truncate(q):
    if q is None:
        return None
    size = len(q)
    return q if size <= 20 else q[0:10] + str(size) + q[size - 10:size]


def do_request(data):
    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
    return requests.post(YOUDAO_URL, data=data, headers=headers)


def connect():
    q = "待输入的文字"
    grade = "待输入年级"
    data = {}
    curtime = str(int(time.time()))
    data['curtime'] = curtime
    salt = str(uuid.uuid1())
    signStr = APP_KEY + truncate(q) + salt + curtime + APP_SECRET
    sign = encrypt(signStr)
    data['appKey'] = APP_KEY
    data['q'] = q
    data['salt'] = salt
    data['sign'] = sign
    data['signType'] = "v3"
    data['grade'] = grade
    response = do_request(data)
    contentType = response.headers['Content-Type']
    if contentType == "audio/mp3":
        millis = int(round(time.time() * 1000))
        filePath = "合成的音频存储路径" + str(millis) + ".mp3"
        fo = open(filePath, 'wb')
        fo.write(response.content)
        fo.close()
    else:
        print response.content


if __name__ == '__main__':
    connect()

C# 示例

using System;
using System.IO;
using System.Web;
using System.Net;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Cryptography;

namespace zhiyun_csharp_demo
{
    class TextcorrectwritingV3Demo
    {
        public static void Main()
        {
            Dictionary<String, String> dic = new Dictionary<String, String>();
            string url = "https://openapi.youdao.com/correct_writing_text";
            string q = "待输入的文字";
            string grade = "待输入年级";
            string appKey = "您的应用ID";
            string appSecret = "您的应用密钥";
            string salt = DateTime.Now.Millisecond.ToString();
            TimeSpan ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc));
            long millis = (long) ts.TotalMilliseconds;
            string curtime = Convert.ToString(millis / 1000);
            dic.Add("curtime", curtime);
            string signStr = appKey + Truncate(q) + salt + curtime + appSecret;;
            string sign = ComputeHash(signStr, new SHA256CryptoServiceProvider());
            dic.Add("q", System.Web.HttpUtility.UrlEncode(q));
            dic.Add("appKey", appKey);
            dic.Add("salt", salt);
            dic.Add("sign", sign);
            dic.Add("signType", "v3");
            dic.Add("grade", grade);
            Post(url, dic);
        }

        protected static string ComputeHash(string input, HashAlgorithm algorithm)
        {
          Byte[] inputBytes = Encoding.UTF8.GetBytes(input);
          Byte[] hashedBytes = algorithm.ComputeHash(inputBytes);
          return BitConverter.ToString(hashedBytes).Replace("-", "");
        }

        protected static void Post(string url, Dictionary<String, String> dic)
        {
            string result = "";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
            req.Method = "POST";
            req.ContentType = "application/x-www-form-urlencoded";
            StringBuilder builder = new StringBuilder();
            int i = 0;
            foreach (var item in dic)
            {
                if (i > 0)
                    builder.Append("&");
                builder.AppendFormat("{0}={1}", item.Key, item.Value);
                i++;
            }
            byte[] data = Encoding.UTF8.GetBytes(builder.ToString());
            req.ContentLength = data.Length;
            using (Stream reqStream = req.GetRequestStream())
            {
                reqStream.Write(data, 0, data.Length);
                reqStream.Close();
            }
            HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
          if (resp.ContentType.ToLower().Equals("audio/mp3"))
            {
                SaveBinaryFile(resp, "合成的音频存储路径");
            }
            else {
                Stream stream = resp.GetResponseStream();
                using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
                {
                result = reader.ReadToEnd();
                }
                Console.WriteLine(result);
            }
        }

        protected static string Truncate(string q)
        {
            if (q == null)
            {
               return null;
            }
            int len = q.Length;
            return len <= 20 ? q : (q.Substring(0, 10) + len + q.Substring(len - 10, 10));
        }

        private static bool SaveBinaryFile(WebResponse response, string FileName)
        {
            string FilePath = FileName + DateTime.Now.Millisecond.ToString() + ".mp3";
            bool Value = true;
            byte[] buffer = new byte[1024];

            try
            {
                if (File.Exists(FilePath))
                    File.Delete(FilePath);
                Stream outStream = System.IO.File.Create(FilePath);
                Stream inStream = response.GetResponseStream();

                int l;
                do
                {
                    l = inStream.Read(buffer, 0, buffer.Length);
                    if (l > 0)
                        outStream.Write(buffer, 0, l);
                }
                while (l > 0);

                outStream.Close();
                inStream.Close();
            }
            catch
            {
                Value = false;
            }
            return Value;
        }
    }
}

PHP 示例

<?php
define("CURL_TIMEOUT",   2000);
define("URL",            "https://openapi.youdao.com/correct_writing_text");
define("APP_KEY",        "您的应用ID"); // 替换为您的应用ID
define("SEC_KEY",        "您的应用密钥"); // 替换为您的密钥

function do_request($q)
{
    $salt = create_guid();
    $args = array(
        'q' => $q,
        'appKey' => APP_KEY,
        'salt' => $salt,
    );
    $curtime = strtotime("now");
    $args['curtime'] = $curtime;
    $grade = "default"
    $args['grade'] = $grade;
    $args['signType'] = "v3";
    $signStr = APP_KEY . truncate($q) . $salt . $curtime . SEC_KEY;
    $args['sign'] = hash("sha256", $signStr);
    $ret = call(URL, $args);
    return $ret;
}

// 发起网络请求
function call($url, $args=null, $method="post", $testflag = 0, $timeout = CURL_TIMEOUT, $headers=array())
{
    $ret = false;
    $i = 0;
    while($ret === false)
    {
        if($i > 1)
            break;
        if($i > 0)
        {
            sleep(1);
        }
        $ret = callOnce($url, $args, $method, false, $timeout, $headers);
        $i++;
    }
    return $ret;
}

function callOnce($url, $args=null, $method="post", $withCookie = false, $timeout = CURL_TIMEOUT, $headers=array())
{
    $ch = curl_init();
    if($method == "post")
    {
        $data = convert($args);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
        curl_setopt($ch, CURLOPT_POST, 1);
    }
    else
    {
        $data = convert($args);
        if($data)
        {
            if(stripos($url, "?") > 0)
            {
                $url .= "&$data";
            }
            else
            {
                $url .= "?$data";
            }
        }
    }
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    if(!empty($headers))
    {
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    }
    if($withCookie)
    {
        curl_setopt($ch, CURLOPT_COOKIEJAR, $_COOKIE);
    }
    $r = curl_exec($ch);
    curl_close($ch);
    return $r;
}

function convert(&$args)
{
    $data = '';
    if (is_array($args))
    {
        foreach ($args as $key=>$val)
        {
            if (is_array($val))
            {
                foreach ($val as $k=>$v)
                {
                    $data .= $key.'['.$k.']='.rawurlencode($v).'&';
                }
            }
            else
            {
                $data .="$key=".rawurlencode($val)."&";
            }
        }
        return trim($data, "&");
    }
    return $args;
}

// uuid generator
function create_guid(){
    $microTime = microtime();
    list($a_dec, $a_sec) = explode(" ", $microTime);
    $dec_hex = dechex($a_dec* 1000000);
    $sec_hex = dechex($a_sec);
    ensure_length($dec_hex, 5);
    ensure_length($sec_hex, 6);
    $guid = "";
    $guid .= $dec_hex;
    $guid .= create_guid_section(3);
    $guid .= '-';
    $guid .= create_guid_section(4);
    $guid .= '-';
    $guid .= create_guid_section(4);
    $guid .= '-';
    $guid .= create_guid_section(4);
    $guid .= '-';
    $guid .= $sec_hex;
    $guid .= create_guid_section(6);
    return $guid;
}

function create_guid_section($characters){
    $return = "";
    for($i = 0; $i < $characters; $i++)
    {
        $return .= dechex(mt_rand(0,15));
    }
    return $return;
}

function truncate($q) {
    $len = strlen($q);
    return $len <= 20 ? $q : (substr($q, 0, 10) . $len . substr($q, $len - 10, $len));
}

function ensure_length(&$string, $length){
    $strlen = strlen($string);
    if($strlen < $length)
    {
        $string = str_pad($string, $length, "0");
    }
    else if($strlen > $length)
    {
        $string = substr($string, 0, $length);
    }
}

// 输入
$q = "待输入的文字";

$ret = do_request($q);
?>