web优化之-Asp.net MVC js、css动态合并 动态压缩 (2)

最新推荐文章于 2024-04-25 22:37:35 发布
最新推荐文章于 2024-04-25 22:37:35 发布
阅读量5.6k 收藏 1
点赞数 2
分类专栏： ASP.NET MVc 文章标签： css mvc 优化 web string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ma_jiang/article/details/8081129
版权

在前一篇文章web优化之-Asp.net MVC js、css动态合并 动态压缩中的js和css的路径都是Scripts/jquery-1.5.1.js,Scripts/jquery.validate.js这在http请求时路径比较长，为此我们可以改用[Scripts/jquery-1.5.1,jquery.validate]这种格式。同时为了防止文件更新后客户端无法刷新的问题我们加了version标记

修改后的代码：

CombineFiles：

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Text;
    using System.IO;
    using Yahoo.Yui.Compressor;

    /// <summary>
    /// Summary description for CombineFiles
    /// </summary>
    public class CombineFiles : IHttpHandler
    {

        public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/javascript";
            HttpRequest request = context.Request;
            HttpResponse response = context.Response;
            string[] allkeys = request.QueryString.AllKeys;
            string version = string.Empty;
            if (allkeys.Contains("version"))
            {
                version = request.QueryString["version"].Trim().ToLower();
            }
            if (!allkeys.Contains("href") || !allkeys.Contains("type") || !allkeys.Contains("compress"))
            {
                response.Write("请求格式不正确，正确格式是type=....&href=....&compress=...\r\n");
                response.Write("type只能是js或则css,compress只能是true或则false，href则是请求的文件，多个文件已逗号分隔\r\n");
                response.Write("示例如下:\r\n type=js&compress=true&href=[Scripts/jquery-1.5.1,jquery.validate][Scripts/MicrosoftAjax]");
            }
            else
            {
                string cacheKey = request.Url.Query;
                #region /*确定合并文件类型*/
                string fileType = request.QueryString["type"].Trim().ToLower();
                string contenType = string.Empty;
                if (fileType.Equals("js"))
                {
                    contenType = "text/javascript";
                }
                else if (fileType.Equals("css"))
                {
                    contenType = "text/css";
                }
                /*确定合并文件类型*/
                #endregion
                CacheItem cacheItem = HttpRuntime.Cache.Get(cacheKey) as CacheItem;//服务端缓存
                if (cacheItem != null && !String.IsNullOrEmpty(cacheItem.Version) && !string.IsNullOrEmpty(version))
                {
                    if (cacheItem.Version != version)
                    {
                        cacheItem = null;
                    }
                }
                if (cacheItem == null)
                {
                    #region 合并压缩文件
                    /*合并文件*/
                    string href = context.Request.QueryString["href"].Trim();
                    string content = string.Empty;
                    string[] files = GetFilePath(href);
                    StringBuilder sb = new StringBuilder();
                    foreach (string fileName in files)
                    {

                        string filePath = context.Server.MapPath(fileName + "." + fileType);
                        if (File.Exists(filePath))
                        {
                            string readstr = File.ReadAllText(filePath, Encoding.UTF8);
                            sb.Append(readstr);
                            //content = JavaScriptCompressor.Compress(content);
                            //response.Write(content);
                        }
                        else
                        {
                            sb.AppendLine("\r\n未找到源文件" + filePath + "\r\n");
                        }
                    }
                    content = sb.ToString();
                    /*合并文件*/
                    /*压缩文件*/
                    string compressStr = request.QueryString["compress"].Trim();
                    bool iscompress = bool.Parse(compressStr);
                    if (iscompress)
                    {
                        if (fileType.Equals("js"))
                        {
                            //content = JavaScriptCompressor.Compress(content);
                            content = (new JavaScriptCompressor()).Compress(content);
                        }
                        else if (fileType.Equals("css"))
                        {
                           // content = CssCompressor.Compress(content);
                            content = (new CssCompressor()).Compress(content);
                        }
                    }
                    /*压缩文件*/
                    #endregion
                    cacheItem = new CacheItem() { Content = content, Expires = DateTime.Now.AddHours(1), Version = version };
                    HttpRuntime.Cache.Insert(cacheKey, cacheItem, null, cacheItem.Expires, TimeSpan.Zero);
                }
                response.ContentType = contenType;
                if (request.Headers["If-Modified-Since"] != null && TimeSpan.FromTicks(cacheItem.Expires.Ticks - DateTime.Parse(request.Headers["If-Modified-Since"]).Ticks).Seconds < 100)
                {
                    response.StatusCode = 304;
                    // response.Headers.Add("Content-Encoding", "gzip");  
                    response.StatusDescription = "Not Modified";
                }
                else
                {
                    response.Write(cacheItem.Content);
                    SetClientCaching(response, DateTime.Now);
                }
            }  //合并文件结束
        }

        string[] GetFilePath(string filesrc)
        {
            List<string> result = new List<string>();
            string[] files = filesrc.Split(new char[] { '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string file in files)
            {
                string[] srcs = file.Split(new char[] { ',' });
                string first = srcs[0];
                int index = first.LastIndexOf("/");
                string prefx = first.Substring(0, index);
                result.Add(first);
                if (srcs.Length > 1)
                {
                    srcs = srcs.Where((x, i) => { return i > 0; }).Select(x => prefx + "/" + x).ToArray();
                    result.AddRange(srcs);
                }
            }
            return result.ToArray();
        }
        private void SetClientCaching(HttpResponse response, DateTime lastModified)
        {
            response.Cache.SetETag(lastModified.Ticks.ToString());
            response.Cache.SetLastModified(lastModified);
            //public 以指定响应能由客户端和共享（代理）缓存进行缓存。    
            response.Cache.SetCacheability(HttpCacheability.Public);
            //是允许文档在被视为陈旧之前存在的最长绝对时间。    
            response.Cache.SetMaxAge(new TimeSpan(7, 0, 0, 0));
            //将缓存过期从绝对时间设置为可调时间    
            response.Cache.SetSlidingExpiration(true);
        }
        class CacheItem
        {
            public string Content { set; get; }
            public DateTime Expires { set; get; }
            public string Version { set; get; }
        }
        public bool IsReusable
        {
            get
            {
                return false;
            }
        }
    }

CombineResFile： 

namespace System.Web.Mvc.Html
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Web.Mvc;
    using System.Text;
    using System.Collections;
    using System.IO;


    public enum ResOrderType
    {
        Highest = 1,
        High = 2,
        Normal = 3,
        Low = 4,
        Lowest = 5
    }
    public enum ResourceType
    {
        /// <summary>
        /// CSS
        /// </summary>
        StyleSheet = 0,

        /// <summary>
        /// JS
        /// </summary>
        Script = 1
    }


    public static class CombineResFile
    {
        class ResourceInfo
        {
            public string Url { set; get; }
            public string Group { set; get; }
            public ResOrderType Order { set; get; }
        }
        const string conAppendFileKey = "AppendFileKey";
        const string conRemoveFileKey = "RemoveFileKey";
        const string conRemoveGroupKey = "RemoveGroupKey";

        /// <summary>
        /// 合并路径
        /// </summary>
        /// <param name="paths"></param>
        /// <returns></returns>

        /// <summary>
        /// 添加资源文件
        /// </summary>
        /// <param name="htmlHelper"></param>
        /// <param name="resType">资源类型</param>
        /// <param name="url">文件的路径</param>
        /// <param name="group">文件的分组名称</param>
        /// <param name="order">文件同组中的优先级,默认：Normal</param>
        public static void AppendResFile(this HtmlHelper htmlHelper, ResourceType resType, string url, string group = "", ResOrderType order = ResOrderType.Normal)
        {
            AppendResFile(htmlHelper, resType, GetFilePath(url), group, order);
        }

        /// <summary>
        /// 添加资源文件
        /// </summary>
        /// <param name="htmlHelper"></param>
        /// <param name="resType">资源类型</param>
        /// <param name="urls">文件的路径列表，如“channel/fanbuxie/urlcommon”,不支[]限定符</param>
        /// <param name="group">文件的分组名称</param>
        /// <param name="order">文件同组中的优先级,默认：Normal</param>
        public static void AppendResFile(this HtmlHelper htmlHelper, ResourceType resType, string[] urls, string group = "", ResOrderType order = ResOrderType.Normal)
        {
            Dictionary<string, ResourceInfo> resFiles = null;
            var urlArray = urls.Where(s => !string.IsNullOrWhiteSpace(s)).ToArray<string>();
            if (urlArray == null || urlArray.Length == 0)
            {
                return;
            }

            string key = string.Format("{0}_{1}", resType.ToString(), conAppendFileKey);
            if (htmlHelper.ViewContext.HttpContext.Items.Contains(key))
            {
                resFiles = htmlHelper.ViewContext.HttpContext.Items[key] as Dictionary<string, ResourceInfo>;
            }
            else
            {
                resFiles = new Dictionary<string, ResourceInfo>();
                htmlHelper.ViewContext.HttpContext.Items.Add(key, resFiles);
            }
            for (int i = 0; i < urlArray.Length; i++)
            {
                if (resFiles.Keys.Contains(urlArray[i]))
                {
                    resFiles[urlArray[i]].Group = group;
                    resFiles[urlArray[i]].Order = order;
                }
                else
                {
                    resFiles.Add(urlArray[i], new ResourceInfo() { Url = urlArray[i], Group = group, Order = order });
                }
            }

            htmlHelper.ViewContext.HttpContext.Items[key] = resFiles;
        }

        /// <summary>
        /// 移除资源文件
        /// </summary>
        /// <param name="resType">资源类型</param>
        /// <param name="htmlHelper"></param>
        /// <param name="urls">移除文件,可以为空或则null </param>
        /// <param name="group">移除文件所在的组可以为null</param>
        public static void RemoveResFile(this HtmlHelper htmlHelper, ResourceType resType, string url, string group = "")
        {
            RemoveResFile(htmlHelper, resType, GetFilePath(url), group);
        }
        /// <summary>
        /// 移除资源文件
        /// </summary>
        /// <param name="resType">资源类型</param>
        /// <param name="htmlHelper"></param>
        /// <param name="urls">移除文件列表,可以为空或则null </param>
        /// <param name="group">移除文件所在的组可以为null</param>
        public static void RemoveResFile(this HtmlHelper htmlHelper, ResourceType resType, string[] urls, string group = "")
        {
            var urlArray = urls.Where(s => !string.IsNullOrWhiteSpace(s)).ToArray<string>();

            #region 按照js的地址移除
            if (urlArray != null && urlArray.Length > 0)
            {

                List<string> removeFileKeys = null;
                string key = string.Format("{0}_{1}", resType.ToString(), conRemoveFileKey);

                if (htmlHelper.ViewContext.HttpContext.Items.Contains(key))
                {
                    removeFileKeys = htmlHelper.ViewContext.HttpContext.Items[key] as List<string>;
                }
                else
                {
                    removeFileKeys = new List<string>();
                    htmlHelper.ViewContext.HttpContext.Items.Add(key, removeFileKeys);
                }
                for (int i = 0; i < urlArray.Length; i++)
                {
                    var url = urlArray[i].Trim().ToLower();
                    if (!removeFileKeys.Contains(url))
                    {
                        removeFileKeys.Add(url);
                    }
                }
            }
            #endregion

            #region  按照js的group移除
            if (!string.IsNullOrEmpty(group))
            {
                List<string> removeGroupKeys = null;
                string keyGroup = string.Format("{0}_{1}", resType.ToString(), conRemoveGroupKey);
                if (htmlHelper.ViewContext.HttpContext.Items.Contains(keyGroup))
                {
                    removeGroupKeys = htmlHelper.ViewContext.HttpContext.Items[keyGroup] as List<string>;
                }
                else
                {
                    removeGroupKeys = new List<string>();
                    htmlHelper.ViewContext.HttpContext.Items.Add(keyGroup, removeGroupKeys);
                }
                if (!removeGroupKeys.Contains(group))
                {
                    removeGroupKeys.Add(group);
                }

            }
            #endregion
        }
        /// <summary>
        /// 输出js
        /// </summary>
        /// <param name="htmlHelper"></param>
        /// <returns></returns>
        public static MvcHtmlString RenderResFile(this HtmlHelper htmlHelper, ResourceType resType)
        {
            string keyAppend = string.Format("{0}_{1}", resType.ToString(), conAppendFileKey);
            string keyRemove = string.Format("{0}_{1}", resType.ToString(), conRemoveGroupKey);
            string keyRemoveGroup = string.Format("{0}_{1}", resType.ToString(), conRemoveGroupKey);
            Dictionary<string, ResourceInfo> resFiles = null;
            StringBuilder content = new StringBuilder();
            if (htmlHelper.ViewContext.HttpContext.Items.Contains(keyAppend))
            {
                resFiles = htmlHelper.ViewContext.HttpContext.Items[keyAppend] as Dictionary<string, ResourceInfo>;
                List<string> removeFileKey = new List<string>();
                if (htmlHelper.ViewContext.HttpContext.Items.Contains(keyRemove))
                {
                    removeFileKey = htmlHelper.ViewContext.HttpContext.Items[keyRemove] as List<string>;
                }
                List<string> removeGroupKey = new List<string>();
                if (htmlHelper.ViewContext.HttpContext.Items.Contains(keyRemoveGroup))
                {
                    removeGroupKey = htmlHelper.ViewContext.HttpContext.Items[keyRemoveGroup] as List<string>;
                }
                List<ResourceInfo> files = resFiles.Select(x => x.Value)
                    .Where(x => !removeFileKey.Contains(x.Url) && !removeGroupKey.Contains(x.Group))
                    .ToList<ResourceInfo>();

                IEnumerable<IGrouping<string, ResourceInfo>> jsGroupFiles = files.OrderByDescending(x => x.Group).GroupBy(x => x.Group);
                foreach (IGrouping<string, ResourceInfo> item in jsGroupFiles)
                {
                    var resPath = CombinePath(item.ToArray());
                    string version = "0";
                    //获取版本号
                    version = GetVersion(item.ToArray(), resType);

                    switch (resType)
                    {
                        case ResourceType.StyleSheet:
                            string cssformat = "<link charset=\"utf-8\" rel=\"stylesheet\" type=\"text/css\" href=\"/CombineFiles.ashx?type=js&compress=false&href={0}&version={1}\">";
                            content.Append(string.Format(cssformat, resPath, version));
                            break;

                        case ResourceType.Script:
                            string jsformat = "<script type=\"text/javascript\" src=\"/CombineFiles.ashx?type=js&compress=true&href={0}&version={1} \"></script>";
                            content.Append(string.Format(jsformat, resPath, version));
                            break;
                    }

                }
            }//end if
            return new MvcHtmlString(content.ToString());
        }

        static string CombinePath(ResourceInfo[] items)
        {
            var all = items.OrderBy(x => x.Order).GroupBy(x => x.Order).ToArray();
            StringBuilder sb = new StringBuilder();
            foreach (var item in all)
            {
                int order = 1;
                var files = item.Select(x =>
                {
                    int lastIndex = x.Url.LastIndexOf('/');
                    string prefix = x.Url.Substring(0, lastIndex);
                    string fileName = x.Url.Substring(lastIndex + 1);
                    return new { Prfx = prefix, FileName = fileName, FileOrder = order++ };
                }).OrderBy(x => x.FileOrder);

                var keysgroup = files.GroupBy(x => x.Prfx).ToArray();
                foreach (var key in keysgroup)
                {
                    var list = files.Where(x => x.Prfx.Equals(key.Key)).ToArray();
                    sb.Append("[" + list[0].Prfx + "/" + list[0].FileName);
                    string jsprfx = list[0].Prfx;
                    for (int i = 1; i < list.Length; i++)
                    {
                        sb.Append("," + list[i].FileName);
                    }
                    sb.Append("]");
                }
            }
            return sb.ToString();
        }
        static string[] GetFilePath(string filesrc)
        {
            List<string> result = new List<string>();
            string[] files = filesrc.Split(new char[] { '[', ']' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string file in files)
            {
                string[] srcs = file.Split(new char[] { ',' });
                string first = srcs[0];
                int index = first.LastIndexOf("/");
                string prefx = first.Substring(0, index);
                result.Add(first);
                if (srcs.Length > 1)
                {
                    srcs = srcs.Where((x, i) => { return i > 0; }).Select(x => prefx + "/" + x).ToArray();
                    result.AddRange(srcs);
                }
            }
            return result.ToArray();
        }
        static string GetVersion(ResourceInfo[] items, ResourceType restype)
        {
            StringBuilder sb = new StringBuilder();
            string ext = ".js";
            if (restype == ResourceType.StyleSheet)
            {
                ext = ".css";
            }
            foreach (ResourceInfo item in items)
            {
                string filename = item.Url + ext;
                string filepath = HttpContext.Current.Server.MapPath(filename);
                FileInfo file = new FileInfo(filepath);
                sb.Append(file.LastWriteTime.ToString("yyyyMMddHHmmss"));
            }
            string version = sb.ToString().GetHashCode().ToString();
            version = version.Replace("-", string.Empty);

            ///Read web config
            
            ///
            return version;
        }

    }
}


结果如图：


注意Yahoo.Yui.Compressor版本不同,调用方式也不同.

如果是在MVC4项目里,这里可以不用Yahoo.Yui.Compressor来压缩文件,可以用WebGrease.1.1.0\lib\WebGrease.dll中的Minifier类来实现压缩.代码如下:

CodeSettings codeSettings = new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false
};

content= (new Microsoft.Ajax.Utilities.Minifier()).MinifyJavaScript(content,codeSettings);

--------------------------------------------------------------------

CssSettings setting = new CssSettings() { CommentMode=CssComment.None };
content = (new Microsoft.Ajax.Utilities.Minifier()).MinifyStyleSheet(content,setting);


dz45693
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Asp.net MVC下使用Bundle合并、压缩js与css文件详解
10-20
在web优化中有一种手段，压缩js，css...asp.net mvc中为我们提供一种使用c#代码压缩合并js和css这类静态文件的方法。这篇文章主要介绍了在Asp.net MVC下使用Bundle合并、压缩js与css文件的方法,需要的朋友可以参考下。
asp.net html 压缩,ASP.NET Core 3.0 对 CSS、JS、HTML 文件进行压缩、合并
weixin_42299032的博客
06-09 312
安装 Nuget 包：项目根目录创建绑定配置文件：bundleconfig.json示例：[{"outputFileName":"wwwroot/css/site.min.css","inputFiles":["wwwroot/css/site.css","wwwroot/css/custom.css"]},{"outputFileName":"wwwroot/js/site.min.js"...
ASP.NET MVC用Bundles压缩js文件，并让浏览器异步加载js
u011511086的专栏
08-12 1575
mvc默认的写法js引用（会自动压缩js文件）： @Scripts.Render("~/bundles/mybundle") Scripts.Render是asp.net mvc自身采用比较优化的压缩技术和缓存技术，将多个js压缩优化并且整合为1个体积较小的js，但对于外部使用来说，功能是不会出现任何区别的，从而提高了页面体验。而压缩和缓存的过程都是通过框架自动实现的，浏览器第二次访问时就会从
MVC4中使用的js和css文件捆绑压缩功能(MVC如何调用脚本和样式)
丘鸣山的博客
03-27 676
1，捆绑和缩小是ASP.NET 4.5中可以使用的两种技术，可以改善请求加载时间。捆绑和缩小可以减少对服务器的请求数量并减少所请求资产（例如CSS和JavaScript）的大小，从而缩短加载时间 如下图所示： 大多数当前主流浏览器将每个主机名的同时连接数限制为六个。这意味着在处理六个请求时，浏览器会对主机上的其他资产请求进行排队。在下图中，IE F12开发人员工具网络选项卡显示示例应用程序的“...
Asp.Net MVC4 Bundle捆绑压缩技术
weixin_30566063的博客
04-12 175
很高兴，最近项目用到了Asp.Net MVC4 + Entity Framework5，发现mvc4加入了Bundle、Web API等技术，着实让我兴奋，以前是用第三方的，这里主要说说Bundle技术。 很多大网站都没有用Bundle技术造成很多资源浪费与性能的牺牲，别小瞧 用上了你会发现他的好处： 将多个请求捆绑为一个请求，减少服务器请求数 没有使用Bundle技术，debug下...
ASP.NET MVC 中CSS JS压缩合并 功能的使用方法
iack-Ji's 技术积累博客
01-01 2051
通过压缩合并js文件和css文件,可以减少 服务器的响应 次数和 流量,可以大大减小服务器的压力,对网站优化有比较明显的帮助!压缩合并 css 文件和js文件是网站优化的一个 比较常用的方法. ASP.NET MVC 中提供了一套为css文件和js文件压缩合并的方法. 步骤: 一.打开MVC项目下的 App_start目录中的BuddleConfig.cs文件, 二.在 Regis
在ASP.NET MVC中，使用Bundle来打包压缩js和css
weixin_34192732的博客
09-02 281
在ASP.NET MVC4中（在WebForm中应该也有），有一个叫做Bundle的东西，它用来将js和css进行压缩（多个文件可以打包成一个文件），并且可以区分调试和非调试，在调试时不进行压缩，以原始方式显示出来，以方便查找问题。 具体优势可自行百度或参看官方介绍：http://www.asp.net/mvc/tutorials/mvc-4/bundling-and-minification ...
web优化之-Asp.net MVC js、css动态合并 动态压缩
dz45693的专栏
08-30 5504
上次写了两篇有关js的合并压缩如 web优化之-mvc js动态合并 动态压缩 去掉js重复引用 js缓存 js延迟加载 web优化之-asp.net js延迟加载 js动态合并 js动态压缩 看了一下的访问两比较大，现在js和css的合并压缩整理一下。 首先还是需要一个handler来处理文件的合并、压缩、缓存,.js和css的压缩我们采用的是Yahoo.Yui.Compressor，所
MyBlog-ASP.NET-MVC5:使用ASP.NET MVC 5构建博客
05-02
演示： : youtube： : 如何在本地IIS上安装它： : MyBlog-ASP.NET-MVC5 使用ASP.NET MVC 5构建博客MVC博客建立个人博客-ASP.NET MVC5 我使用ASP.NET MVC5构建该项目，对于个人博客来说，它的想法是太多的，所以添加...
Cinema-ASP.NET-MVC:ASP.NET MVC中的Cinema Web Application阅读自述文件
05-18
电影院-ASP.NET-MVC ASP.NET MVC中的电影网站应用程序下面，我将尝试以一种简单的形式介绍该项目，但是所有代码都可以在存储库中找到。 该项目旨在扩大我在以下技术方面的知识： HTML5 CSS 引导程序带有...
mvc js和css文件压缩合并
02-13
演示asp.net mvc4下通过BundleConfig对js和css进行压缩和并，提高网页响应速度，优化网站
ASP.NET+MVC+3性能优化
09-24
ASP.NET+MVC+3性能优化
Asp.net程序优化js、css实现合并与压缩的方法
10-25
主要介绍了Asp.net程序优化js、css实现合并与压缩的方法,使用第三方组件实现访问时将js与css文件压缩并缓存在客户端的效果,非常具有实用价值,需要的朋友可以参考下
使用MVC实现css动态效果
weixin_44540244的博客
04-08 564
开发工具与关键技术：Visual Studio 2015 使用MVC实现css动态效果 作者：抽刀流水、刘 撰写时间：2019年3月29日 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title></title> <meta charset...
关于MVC中BundleCollection压缩js css文件 发布后获取失败的问题
月
08-17 4123
ASP.NET MVC4，ASP.NET MVC5中对JS和CSS的引用又做了一次变化，在MVC3中我们这样引用资源文件： link href="@Url.Content("~/Content/Site.css")" rel="stylesheet" type="text/css" /> 将在运行的时候自动将虚拟（相对）路径转换为应用程序绝对路径。这是比较传统的引用方式，尽管他
CSS基础常用属性之字体属性（如果想知道CSS的字体属性知识点，那么只看这一篇就足够了！）
秋刀鱼不做梦的编程日常
04-22 1270
CSS基础常用属性之字体属性（如果想知道CSS的字体属性知识点，那么只看这一篇就足够了！）
前端开发攻略---合并表格单元格，表格内嵌套表格实现手风琴效果。
nibabaoo的博客
04-18 532
合并表格单元格，表格内嵌套表格实现手风琴效果。
前端CSS基础6（CSS列表与表格的相关属性，边框的样式调整）
qq_51752841的博客
04-22 818
CSS列表与表格的相关属性，边框的样式调整
CSS中的 5 类常见伪元素详解！
最新发布
u013179804的博客
04-25 742
CSS 伪元素用于创建特定的特殊效果，它们可以用于选择和样式化元素的某些部分，这些部分在文档树中并不存在作为可访问的元素节点。伪元素主要用于添加装饰性的效果，例如添加前缀内容、创建边框效果等。而前文的伪类CSS伪类大全！4大类伪类详解用于根据特定条件为已有元素添加样式，它们描述了元素的某个状态，如:hover:focus等。伪元素在 CSS 中使用两个冒号（ok，那我们一起来看看吧。
用WEB--ASP.NET谢一个登入页面
03-23
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css"> <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值