月度归档： 2017 年 4 月

关于JavaScript中重置URL参数的说明

/**
* 构造URL参数信息
* nameValues：要构造的URL参数信息，由键值对构成，如name=value
* includeEmpty：是否包括空值参数
* return：返回构造后URL参数信息
*/
function buildUrlParams(nameValues, includeEmpty) {
    // 定义新的URL参数字典
    var newParams = {};
    // 构造要设置的URL参数信息
    var nameValue = nameValues instanceof Array ? nameValues.join("&") : nameValues;
    // 拆分URL参数信息
    var oldParams = nameValue.split("&");
    // 遍历每个URL参数
    for (var i = 0, length = oldParams.length; i < length; i++) {
        // 获取URL参数的键值对
        var items = oldParams[i].split("=");
        // 判断URL参数的键值对是否有效
        if (items.length) {
            // 获取参数名
            var name = items[0];
            // 判断参数名是否有效
            if (name) {
                // 获取参数值
                var value = null;
                if (items.length > 1) {
                    value = items[1]
                }
                // 判断URL参数的键值对是否有效
                if (includeEmpty || value) {
                    // 获取已构造的参数值
                    var values = newParams[name];
                    if (!values) {
                        // 没有构造过参数则添加新的参数信息
                        values = newParams[name] = [];
                    }
                    // 添加新的参数值
                    if (value) {
                        // 如参数未URL编码则对其进行编码
                        //value = decodeURIComponent(value) == value ? encodeURIComponent(value) : value;
                        values.push(value);
                    }
                }
            }
        }
    }
    // 返回构造后URL参数信息
    return newParams;
}

/**
* 设置URL参数
* url：要设置参数的URL
* nameValues：要设置的参数信息，由键值对构成，如name=value
* return：返回设置参数后的URL
*/
function setUrlParams(url, nameValues) {
    // 构造要设置的URL参数信息
    var newParams = buildUrlParams(nameValues, true);
    // 获取URL地址中参数开始索引
    var index = url.indexOf("?");
    // 判断URL地址中是否有参数
    if (index >= 0) {
        // 构造原始的URL参数信息
        var oldParams = buildUrlParams(url.substring(index + "?".length));
        // 获取不带参数的URL地址
        url = url.substring(0, index);
        // 遍历要设置的URL参数信息
        for (var name in newParams) {
            // 将要设置的URL参数信息覆盖添加到原始参数信息中
            oldParams[name] = newParams[name];
        }
        // 重新设置URL参数信息
        newParams = oldParams;
    }
    // 构造URL参数键值对
    var params = [];
    for (var name in newParams) {
        var values = newParams[name];
        if (values.length) {
            params.push(name + "=" + values.join(","));
        }
    }
    // 判断是否有参数
    if (params.length) {
        // 返回构造后的URL地址
        return url + "?" + params.join("&");
    }
    else {
        // 没有参数则返回不带参数的URL地址
        return url;
    }
}

关于C#中重置URL参数的说明

/// <summary>
/// 构造URL参数信息
/// </summary>
/// <param name="includeEmpty">是否包括空值参数</param>
/// <param name="nameValues">要构造的URL参数信息，由键值对构成，如name=value</param>
/// <returns>返回构造后URL参数信息</returns>
public virtual Dictionary<string, List<object>> BuildUrlParams(bool includeEmpty, params object[] nameValues)
{
    // 定义新的URL参数字典
    Dictionary<string, List<object>> newParams = new Dictionary<string, List<object>>();
    // 构造要设置的URL参数信息
    string nameValue = string.Join("&", nameValues);
    // 拆分URL参数信息
    string[] oldParams = nameValue.Split(new string[] { "&" }, StringSplitOptions.RemoveEmptyEntries);
    // 遍历每个URL参数
    for (int i = 0, length = oldParams.Length; i < length; i++)
    {
        // 获取URL参数的键值对
        string[] items = oldParams[i].Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
        // 判断URL参数的键值对是否有效
        if (items.Length > 0)
        {
            // 获取参数名
            string name = items[0];
            // 获取参数值
            string value = null;
            if (items.Length > 1)
            {
                value = items[1];
            }
            // 判断URL参数的键值对是否有效
            if (includeEmpty || value != null)
            {
                // 获取已构造的参数值
                List<object> values;
                if (!newParams.TryGetValue(name, out values))
                {
                    // 没有构造过参数则添加新的参数信息
                    values = newParams[name] = new List<object>();
                }
                // 添加新的参数值
                if (value != null)
                {
                    // 如参数未URL编码则对其进行编码
                    value = HttpUtility.UrlDecode(value, Encoding) == value ? HttpUtility.UrlEncode(value, Encoding) : value;
                    values.Add(value);
                }
            }
        }
    }
    // 返回构造后URL参数信息
    return newParams;
}

/// <summary>
/// 设置URL参数
/// </summary>
/// <param name="url">要设置参数的URL</param>
/// <param name="nameValues">要设置的参数信息，由键值对构成，如name=value</param>
/// <returns>返回设置参数后的URL</returns>
public virtual string SetUrlParams(string url, params object[] nameValues)
{
    // 构造要设置的URL参数信息
    Dictionary<string, List<object>> newParams = BuildUrlParams(true, nameValues);
    // 获取URL地址中参数开始索引
    int index = url.IndexOf("?");
    // 判断URL地址中是否有参数
    if (index >= 0)
    {
        // 构造原始的URL参数信息
        Dictionary<string, List<object>> oldParams = BuildUrlParams(false, url.Substring(index + "?".Length));
        // 获取不带参数的URL地址
        url = url.Substring(0, index);
        // 判断是否存在原始URL参数信息
        if (oldParams.Count > 0)
        {
            // 遍历要设置的URL参数信息
            foreach (KeyValuePair<string, List<object>> item in newParams)
            {
                // 将要设置的URL参数信息覆盖添加到原始参数信息中
                oldParams[item.Key] = item.Value;
            }
            // 重新设置URL参数信息
            newParams = oldParams;
        }
    }
    // 判断是否有参数
    if (newParams.Count > 0)
    {
        // 构造新的URL参数信息
        string newParam = string.Join("&", newParams.Where(n => n.Value.Count > 0).Select(n => string.Format("{0}={1}", n.Key, string.Join(",", n.Value))));
        // 返回构造后的URL地址
        return string.Format("{0}?{1}", url, newParam);
    }
    else
    {
        // 没有参数则返回不带参数的URL地址
        return url;
    }
}
 ©  LuYutao