新年总结 我的选择器发展史

最新推荐文章于 2025-09-10 19:44:49 发布
最新推荐文章于 2025-09-10 19:44:49 发布
阅读量80 收藏
点赞数
文章标签： javascript ViewUI
本文详细记录了作者从2009年至2011年初深入研究CSS选择器的过程，包括选择器的设计、实现和优化等多个方面。作者分享了一系列关键技术和心得，如获取祖先元素、UUID技术的应用以及从右到左的选择策略。

我想，我是国内最熟悉CSS选择器运作机理的人了。新的一年，也该是时间把曾经走过的足迹记录下来，让大家明白，所有成功都是来之不易的。

注：下面给的链接，许多都可能打不开，因为我并没有把它们公开出来。

最后附上queryv3.5的源码：

 
/*
query selector version 3.5
Copyright 2010
Dual licensed under the MIT or GPL Version 2 licenses.
author "司徒正美(zhongqincheng)"
http://www.cnblogs.com/rubylouvre/
 */
(function(window){
    var A_slice = Array.prototype.slice;
    window.dom = {
        UID:1,
        oneObject : function(array,val){
            var result = {},value = val !== void 0 ? val :1;
            for(var i=0,n=array.length;i < n;i++)
                result[array[i]] = value;
            return result;
        },
        slice:function(nodes,start,end){
            return A_slice.call(nodes,(start || 0),(end || nodes.length))
        },
        isXML : function(context) {
            context = context.ownerDocument || document;
            return context.createElement("p").nodeName !== context.createElement("P").nodeName;
        },
        contains : function(ancestor,node) {
            if (node.compareDocumentPosition)
                return (node.compareDocumentPosition(ancestor) & 8) === 8;
            if (ancestor.contains)
                return ancestor.contains(node) && ancestor !== node;
            while (node = node.parentNode)
                if (node == ancestor) return true;
            return false;
        },
        queryId : function (id, context) {
            var el = (context || document).getElementById(id);
            return el && [el] || []
        },
        queryTag : function(tag,context){
            var flag_skip = tag !== "*",result = [],els = context.getElementsByTagName(tag);
            if(-[1,]){
                return A_slice.call(els)
            }else{
                for(var i = 0,ri = 0,el;el = els[i++];)
                    if(flag_skip || el.nodeType === 1){
                        result[ri++] = el
                    }
            }
            return result;
        },
        queryPos : function(selectors,context,flag_xml,name,value){
            var filter = dom.$$filters[name],ret = [],recursion = [], i = 0, ri = 0,nodes,node,selector;
            do{
                selector = selectors.pop();
                if(selector != ","){
                    recursion.unshift(selector)
                }else{
                    selectors.push(selector);
                    break;
                }
            }while(selectors.length);
            nodes = dom.query(recursion,context,flag_xml);
            //如果value为空白则将集合的最大索引值传进去，否则将exp转换为数字
            var num = (value === ""|| value === void 0) ? nodes.length - 1 : ~~value;
            for (; node = nodes[i];i++){
                if(filter.call(node,i, num))
                    ret[ri++] = node;
            }
            ret.selectors = selectors
            return ret
        }
    }
    var child_pseudo = "first-child|last-child|only-child|nth-child|nth-last-child";
    var reg_find =/(^[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*)|^(\*)|^#([\w\u00a1-\uFFFF-]+)|^\.([\w\u00a1-\uFFFF-]+)|^:(root)|^:(link)|^:(eq|gt|lt|even|odd|first[^-]|last[^-])\(?(.*)\)?/;
    var reg_swap = /([\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*)(\.[\w\u00a1-\uFFFF-]+|:(?!eq|gt|lt|even|odd|first[^-]|last[^-])\S+(?:\(.*\))?|\[[^\]]*\])/g;
    var reg_split =/^\s+|[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*|[#.:][\w\u00a1-\uFFFF-]+(?:\([^\)]*\))?|\[[^\]]*\]|(?:\s*)[>+~,*](?:\s*)|\s(?=[\w\u00a1-\uFFFF*#.[:])/g;
    var reg_id=  /^#([^,#:\.\s\xa0\u3000\+>~\[\(])+$/;
    var reg_tag =  /^[\w\u00a1-\uFFFF][\w\u00a1-\uFFFF-]*$/;
    var reg_pseudo =  /^:(\w[-\w]*)(?:\((.*)\))?$/;
    var reg_href = /^(?:src|href|style)$/;
    var reg_attribute = /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/ ;
    var one_child = dom.oneObject((child_pseudo+"|"+child_pseudo.replace(/child/g,"of-type")).split("|"));
    var one_position = dom.oneObject("eq|gt|lt|first|last|even|odd".split("|"));
    var documentOrder = !-[1,] ? function (a, b) {
        return (a.sourceIndex - b.sourceIndex);
    }:function (a, b) {
        return (3 - (a.compareDocumentPosition(b) & 6));
    }
    var map_attr = {
        "accept-charset": "acceptCharset",
        accesskey: "accessKey",
        bgcolor: "bgColor",
        cellpadding: "cellPadding",
        cellspacing: "cellSpacing",
        "char": "ch",
        charoff: "chOff",
        "class": "className",
        codebase: "codeBase",
        codetype: "codeType",
        colspan: "colSpan",
        datetime: "dateTime",
        defaultchecked:"defaultChecked",
        defaultselected:"defaultSelected",
        defaultvalue:"defaultValue",
        "for": "htmlFor",
        frameborder: "frameBorder",
        "http-equiv": "httpEquiv",
        ismap: "isMap",
        longdesc: "longDesc",
        maxlength: "maxLength",
        marginwidth:"marginWidth",
        marginheight:'marginHeight',
        nohref: "noHref",
        noresize:"noResize",
        noshade: "noShade",
        readonly: "readOnly",
        rowspan: "rowSpan",
        tabindex: "tabIndex",
        usemap: "useMap",
        vspace: "vSpace",
        valuetype: "valueType"
    };
    var queryAttribute = function(el,name,flag_xml){
        var special = map_attr[name];
        if(!flag_xml && special)
            return el[special];
        var flag = reg_href.test(name) ? 2 : 0;
        return el.getAttribute(name,flag) ;
    };
    /**************************特征侦探*****************************************/
    dom.support = {
        sliceNodes : true
    };
    var HTML = document.documentElement;
    var div = document.createElement("div");
    HTML.insertBefore(div, HTML.firstChild);
    var id = new Date - 0
    div.innerHTML = '<a name="'+id+'"></a><b id="'+id+'"></b>';
    dom.support.diffName = document.getElementById(id) !== div.firstChild;
    try{//检测是否支持
        A_slice.call(div.childNodes)
    }catch(e){
        dom.support.sliceNodes = false;
    }
    div.appendChild(document.createComment(''))
    dom.support.diffComment = div.getElementsByTagName("*").length !== 3;
    HTML.removeChild(div)
    /************************根据浏览器特征重写部分函数**************************/
    if(!dom.support.diffName){
        dom.queryId = function(id,root){
            root = root || document;
            if(root.getElementById){
                var el = root.getElementById(id);
                return el && el.attributes['id'].value === id ? [el] :[]
            } else {
                var all = root.all[id];
                for(var i=0;el=all[i++];){
                    if(el.attributes['id'].value === id)
                        return [el]
                }
                return []
            }
        }
    }
    if(!dom.support.sliceNodes){
        dom.slice = function(nodes,start,end){
            var i = nodes.length,result = [];
            while(i--){
                result[i] = nodes[i];
            }
            return  A_slice.call(result,(start || 0),(end || result.length));
        }
    }
    /****************************过滤器*****************************************/
    var queryPseudoNoExp = function(name,isLast,isOnly){
        var head = "var node = this;{0} while((node=node.{1}))  if(node.{2} === {3}) return false;";
        var body = "var prev = this;while ((prev = prev.previousSibling)) if (prev.{2} === {3}) return false;"
        var foot = "return true;"
        var start = isLast ? "nextSibling": "previousSibling";
        var fills = {
            type : ["var tagName = this.nodeName;",start,"nodeName","tagName"],
            child : [""                           ,start,"nodeType","1"]
        };
        var fn = isOnly ? head+body+foot :head+foot;
        return new Function(fn.replace(/{(\d)}/g, function($,$1){
            return fills[name][$1];
        }));
    }
    var queryPseudoHasExp = function(name,isLast){
        var outer = function(a,b){
            var el = this,parent = el.parentNode;
            if (parent.querytime != dom.querytime ){
                undefined
            }
            var diff = el.queryIndex - b;
            if ( a === 0 ) {
                return diff === 0;
            } else {
                return ( diff % a === 0 && diff / a >= 0 );
            }
        }
        var inner = "var {0}; for (var node = parent.{1}; node; node = node.{2}){ if(node.nodeType === 1){ {3} } } parent.querytime = dom.querytime;";
        var buildIndexByChild = "node.queryIndex = ++index;"
        var buildIndexByType =  "tagName = node.nodeName;if(tagName in cache){ ++cache[tagName]; }else{cache[tagName] = 1;}node.queryIndex = cache[tagName];"
        var start = isLast ? "lastChild" : "firstChild";
        var next =  isLast ? "previousSibling":"nextSibling";
        var fills = {
            type :  ["cache = {},tagName",start,next,buildIndexByType],
            child : ["index = 0"         ,start,next,buildIndexByChild]
        }
        inner = inner.replace(/{(\d)}/g, function($,$1){
            return fills[name][$1];
        });
        return  eval(("[" +outer+"]").replace("undefined",inner))[0];
    }
    dom.$$filters = { //伪类选择器的过滤器
        enabled: function(){//CSS3属性伪类
            return this.disabled === false && this.type !== "hidden";
        },
        disabled: function(){//CSS3属性伪类
            return this.disabled === true;
        },
        checked: function(){//CSS3属性伪类
            return this.checked === true;
        },
        indeterminate:function(){//CSS3属性伪类
            return this.indeterminate = true && this.type === "checkbox"
        },
        selected: function(){//自定义属性伪类
            this.parentNode.selectedIndex;//处理safari的bug
            return this.selected === true;
        },
        empty: function () {//CSS3结构伪类（子元素过滤伪类）
            return !this.firstChild;
        },
        link:function(){//CSS2链接伪类
            return this.nodeName === "A";
        },
        lang: function (reg) {//CSS3语言伪类
                var el = this;
                while (el && el.getAttribute){//如果是文档对象就不用往上找了
                    if(reg.test(el.getAttribute("lang")))
                        return true;
                    el = el.parentNode;
                }
        },
        header: function(){//自定义属性伪类
            return /h\d/i.test( this.nodeName );
        },
        button: function(){//自定义属性伪类
            return "button" === this.type || this.nodeName === "BUTTON";
        },
        input: function(){//自定义属性伪类
            return /input|select|textarea|button/i.test(this.nodeName);
        },
        hidden : function( ) {//自定义可见性伪类
            return this.type === "hidden" || (this.offsetWidth === 0 ) || (!-[1,] && this.currentStyle.display === "none") ;
        },
        visible : function( ) {//自定义可见性伪类
            return this.type !== "hidden" && (this.offsetWidth || this.offsetHeight || (!-[1,] && this.currentStyle.display !== "none"));
        },
        target:function(exp,context){//CSS2.1目标标准
            var id = context.location.hash.slice(1);
            return (this.id || this.name) === id;
        },
        parent : function( ) {//自定义结构伪类
            return !!this.firstChild;
        },
        contains: function(exp) {//自定义内容伪类
            return (this.textContent||this.innerText||'').indexOf(exp) !== -1
        },
        has: function( ) {//自定义结构伪类（子元素过滤伪类，根据子节点的选择器情况进行筛选）
            for(var i =0,node;node = arguments[i++];)
                if(dom.contains(this,node)){
                    return true;
                }
            return false;
        },
        first: function(index){//自定义位置伪类
            return index === 0;
        },
        last: function(index, num){//自定义位置伪类
            return index === num;
        },
        even: function(index){//自定义位置伪类
            return index % 2 === 0;
        },
        odd: function(index){//自定义位置伪类
            return index % 2 === 1;
        },
        lt: function(index, num){//自定义位置伪类
            return index < num;
        },
        gt: function(index, num){//自定义位置伪类
            return index > num;
        },
        eq: function(index, num){//自定义位置伪类
            return index ===  num;
        },
        not:function(){},//CSS3反选伪类
        "nth-child"       : queryPseudoHasExp("child",false),//CSS3子元素过滤伪类
        "nth-last-child"  : queryPseudoHasExp("child",true),//CSS3子元素过滤伪类
        "nth-of-type"     : queryPseudoHasExp("type",false),//CSS3子元素过滤伪类
        "nth-last-of-type": queryPseudoHasExp("type",true),//CSS3子元素过滤伪类
        "first-child"     : queryPseudoNoExp("child",false,false),//CSS3子元素过滤伪类
        "last-child"      : queryPseudoNoExp("child",true ,false),//CSS3子元素过滤伪类
        "only-child"      : queryPseudoNoExp("child",true ,true),//CSS3子元素过滤伪类
        "first-of-type"   : queryPseudoNoExp("type" ,false,false),//CSS3子元素过滤伪类
        "last-of-type"    : queryPseudoNoExp("type" ,true ,false),//CSS3子元素过滤伪类
        "only-of-type"    : queryPseudoNoExp("type" ,true ,true)//CSS3子元素过滤伪类
    }
    "text|radio|checkbox|file|password|submit|image|reset".replace(/\w+/g, function(name){
        dom.$$filters[name] = function(){//自定义属性伪类
            return this.type === name;
        }
    });
    /***********************迭代器**************************/
    var makeIterator = function(name){
        var outer = function(nextset){
            var set = this, nodes = this.nodes,tagName = this.tagName, filter = this.filter,args = this.args,
            level = this.level, _level, result = [], testee, uid, pid,yess = {};
            for(var i = 0,ri = 0, node; node = nodes[i++];){
                uid =  node.uniqueID || (node.uniqueID = dom.UID++);
                testee = set[uid] || node;
                undefined;
            }
            nextset.nodes = result;
        }
        var parents = "if(level){_level = level; while(_level-- && ( testee = testee.parentNode));if(!testee)break;}"
        var fills ={
            current : [""            ,""],
            border :  [""            ,""      ,"previousSibling",""     ,"break;"],
            borders : ["yess[pid] = ","break;","previousSibling",""     ,""],
            parent :  ["yess[pid] = ",""      ,"parentNode"     ,""     ,"break;"],
            parents : ["yess[pid] = ","break;","parentNode"     ,parents,""]
        }
        var filter = "if((!tagName || tagName === testee.nodeName) && (!filter || filter.apply(testee,args))){\
                 {0}  result[ri++] = node;nextset[uid] = testee;{1} }".replace(/{(\d)}/g, function($,$1){
            return fills[name][$1];
        });
        var inner = "while((testee = testee.{2})){if(testee.nodeType === 1 ){ {3}"+
        (name === "border" ? "" : "pid = testee.uniqueID || (testee.uniqueID = dom.UID++);if(yess[pid]){ result[ri++] = node;nextset[uid] = testee; break;}")+"FILTER {4} } }"
        if(name === "current"){
            return eval(("[" +outer+"]").replace("undefined",filter))[0];
        }else{
            inner = inner.replace(/{(\d)}/g, function($,$1){
                return fills[name][$1];
            }).replace("FILTER",filter);
            return  eval(("[" +outer+"]").replace("undefined",inner))[0];
        }
    }
    var iterators = {
        current:makeIterator("current"),
        parent:makeIterator("parent"),
        parents:makeIterator("parents"),
        border:makeIterator("border"),
        borders:makeIterator("borders")
    }
    /***********************适配器*********************************************/
    //通过获取每次的过滤器,迭代器等
    var adapters = {
        "#":function(selector,flag_xml,context,transport){//★★★★(1)ID选择器
            transport.args = [selector.slice(1)];
            transport.filter  =  function(id){
                return (this.id || this.getAttribute("id")) ===  id;
            }
        },
        ".":function(selector,flag_xml,context,transport){//★★★★(2)类选择器
            transport.args = [new RegExp('(?:^|[ \\t\\r\\n\\f])' + selector.slice(1) + '(?:$|[ \\t\\r\\n\\f])')];
            transport.filter  =  function(reg_class){
                return  reg_class.test(this.className || this.getAttribute && this.getAttribute("class"));
            }
        },
        "[":function(selector,flag_xml,context,transport){//★★★★(3)属性选择器
            var match = selector.match(reg_attribute);
            transport.args = [match[1], match[2], match[4]];
            transport.filter   = function(name,operator,value){
                var attrib = queryAttribute(this, name, flag_xml);//取得元素的实际属性值
                 if(!operator)
                    return attrib !== false && attrib+"";
                switch (operator) {
                    case "=":
                        return attrib === value;
                    case "!=":
                        return attrib !== value;
                    case "~=":
                        return (" " + attrib + " ").indexOf(value) !== -1;
                    case "^=":
                        return attrib.indexOf(value) === 0;
                    case "$=":
                        return attrib.lastIndexOf(value) + value.length === attrib.length;
                    case "*=":
                        return attrib.indexOf(value) !== -1;
                    case "|=":
                        return attrib === value || attrib.substring(0, value.length + 1) === value + "-";
                }
            }
        },
        ">":function(selector,flag_xml,context,transport){//★★★★(4)亲子
            transport.iterator = iterators.parent;
        },
        "~":function(selector,flag_xml,context,transport){//★★★★(5)兄长
            transport.iterator = iterators.borders;
        },
        "+":function(selector,flag_xml,context,transport){//★★★★(6)相邻
            transport.iterator = iterators.border;
        },
        " ":function(selector,flag_xml,context,transport){//★★★★(7)后代
            transport.iterator = iterators.parents;
        },
        "*":function(selector,flag_xml,context,transport){//★★★★(8)后代
            transport.level = ~~transport.level + 1;
            transport.iterator = iterators.parents;
        },
        ":":function(selector,flag_xml,context,transport){//★★★★(9)伪类
            var match = selector.match(reg_pseudo), name = match[1],value = match[2]||"",nodes;
            if(one_position[name]){//位置伪类
                nodes = dom.queryPos(transport.selectors,context,flag_xml,name, value);
                transport.selectors = nodes.selectors;

            }else if(name === "has"){
                transport.args = dom.query(value,context,flag_xml);
                transport.filter =  dom.$$filters[name];
                var nextset = {}
                transport.iterator(nextset);
                transport.nodes = nextset.nodes;
                delete transport.filter;
                return
            }else if( name ==="not"){
                nodes = dom.query(value,context,flag_xml);
            }else{
                if(name==="lang")
                    transport.args = [new RegExp("^" + value, "i")];
                if(one_child[name]){
                    match = (value === "even" && "2n" || value === "odd" && "2n+1" || value.replace(/\s/g,"").replace(/(^|\D+)n/g,"$11n")).split("n");
                    transport.args = [~~match[0],~~match[1]];
                }
                transport.filter =  dom.$$filters[name];
                return
            }
            if(nodes){
                for(var i = 0, hash = {}, uid , node;node = nodes[i++];){
                    uid = node.uniqueID || (node.uniqueID = dom.UID++);
                    hash[uid] = node;
                }
                transport.args = [hash,name === "not"];
                transport.filter = function(hash,not){
                    return hash[this.uniqueID] ^ not
                }
            }
        }
    }
    var adapterOfTag = function(selector,flag_xml,context,transport){
        selector =  flag_xml ? selector : selector.toUpperCase();
        transport.tagName = selector
    }
    /*************************获取候选集***************************/
    var getCandidates = function(selectors,context,flag_xml,transport){
        var selector = selectors.pop(), match = selector.match(reg_find), nodes, node;
        if(match){
            if(match[7]){//位置伪类
                nodes = dom.queryPos(selectors,context,flag_xml, match[7], match[8]);
            }else if(match[1] || match[2] ){//标签或通配符选择器
                nodes = dom.queryTag(match[1] || match[2],context);
            }else if(match[3] && context.getElementById){//ID选择器
                node = context.getElementById(match[3]);
                nodes = node && [node] || [];
            }else if(match[4] && context.getElementsByClassName){//类选择器
                nodes = dom.slice(context.getElementsByClassName(match[4]));
            }else if(match[5] && context.documentElement){//根伪类
                nodes = [context.documentElement];
            }else if(match[6] && context.links){//链接伪类
                nodes = dom.slice(context.links);
            }
        }
        if(!nodes){
            nodes = dom.queryTag("*",context);
            selectors.push(selector);
        }
        transport.selectors = "selectors" in nodes ? nodes.selectors : selectors;
        transport.nodes = nodes;
        transport.iterator = iterators.current;
    }

    dom.query = function(selectors, context,flag_xml){
        dom.querytime =  new Date-0;
        context = context || document;
        if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
            return [];
        }
        flag_xml = flag_xml !== void 0 ? flag_xml : dom.isXML(context);
        var result = [],uniqResult = {}, transport = {},parts = [],
        selector, ri = 0,  i = -1, nodes, node, flag_sort ,uid;
        if (typeof selectors === "string" ) {
            selectors = selectors.replace(/^[^#\(]*(#)/, "$1");
            if(arguments.length === 1){
                if(reg_id.test(selectors))
                    return dom.queryId(selectors.slice(1),context);
                if(reg_tag.test(selectors)){
                    return dom.queryTag(selectors,context);
                }
            }
            //将标签选择器与紧跟在它后面的非位置伪类、类、属性相调换
            selectors = selectors.replace(reg_swap, "$2^$1");
            //将选择器群组转换为数组
            selectors.replace(reg_split,function(part){
                i++
                if(part == false ){//如果为空白字符串
                    if(i)
                        parts[ri++] = " ";//并且并不是第一个捕获的
                }else if(part.match(/^\s*([>+~,*])\s*$/)){
                    parts[ri++] = RegExp.$1;
                }else {
                    parts[ri++] = part;
                }
            });
            selectors = parts;

        }
        //将候选集与选择器数组与下一次要使用的迭代器附于传送器上
        getCandidates(selectors,context,flag_xml,transport);
        selectors = transport.selectors;
        //transport的生存周期从上一次甄选操作到下一次甄选操作
        while(selectors.length){
            selector = selectors.pop();
            if(selector === ","){
                result = result.concat(transport.nodes);//开始一下选择器群组做准备
                getCandidates(selectors,context,flag_xml,transport);
                selectors = transport.selectors ;
                flag_sort = true;
            }else{
                (adapters[selector.charAt(0)] || adapterOfTag)(selector,flag_xml,context,transport) ;
                selectors = transport.selectors || selectors;
                if(transport.filter || transport.tagName){
                    transport.iterator(uniqResult);//返回新的传输器（兼映射集），它里面附有节点集
                    transport = uniqResult;
                    uniqResult = {};//这是新的传输器
                }
            }
        }
        result = result.concat(transport.nodes);
        if(result.length > 1 && flag_sort){
            i = ri = 0, nodes= [];
            //减少候选集的个数再进行排序
            for(;node = result[i++];){
                uid = node.uniqueID || (node.uniqueID = dom.UID++);
                if (!uniqResult[uid]){
                    uniqResult[uid] = nodes[ri++] = node;
                }
            }
            result = nodes.sort(documentOrder);
        }
        return result;
    }

})(this);
HTML5新特性
qq_43682422的博客
10-21 1649
HTML5新特性
世界各大操作系统发展史
chuanzou4767的博客
10-26 868
前言 众所周知，电脑都是由硬件和软件组成的，缺了任何一样电脑都是没有办法运行的。在我们使用电脑的过程中，一切的操作都是利用操作系统来完成。 最早的计算机其实并没有操作系统，在那个时候人们想要操作计算机只能通过各种不同的操作按钮来控制计算机，然后随着计算机技术的不断发展随后就出现了汇编语言...
GPU发展史（二）：改变游戏规则的3Dfx Voodoo
了不起的云计算
07-08 1620
这将是使用这种形式的RAM的第一张卡。Quantum 3D的Voodoo2实现包括Obsidian2X-24作为单个SLI卡，可以与2D子卡配对，单槽SLISB200/200SBi带有24MB的EDORAM，以及MercuryHeavyMetal，它具有四个通过控制器板（AAlchemy）连接的200SBiSLI板，以此连接的SLI板具有当今多GPU卡设置中的SLI桥功能。TNT与Voodoo2和Banshee进行了交易，提供了更好的功能集，更好的CPU时钟速度扩展，出色的AGP纹理和更好的2D性能。
Linux概述、发展史
鱼里别放刺
08-15 992
LINUX概述、发展史 “Hello everybody out there using minix——I’m doing a (free) operating system”  在1991年的八月，网络上出现了一篇以此为开篇话语的帖子——这是一个芬兰的名为Linus Torvalds的大学生为自己开始写作一个类似minix，可运行在386上的操作系统寻找志同道合的合作伙伴。
Linux发展史
wujinyan2011的专栏
05-17 614
<br /><br />linux 发展史<br />Linux是一套免费使用和自由传播的类Unix操作系统，它主要用于基于Intel x86系列CPU的计算机上。这个系统是由全世界各地的成千上万的程序员设计和实现的。其目的是建立不受任何商品化软件的版权制约的、全世界都能自由使用的Unix兼容产品<br />Linux以它的高效性和灵活性著称。它能够在PC计算机上实现全部的Unix特性，具有多任务、多用户的能力。Linux是在GNU公共许可权限下免费获得的，是一个符合POSIX标准的操作系统。Linux操作
linux的发展史
weixin_34250434的博客
10-11 138
"Hello everybody out there using minix——I'm doing a (free) operating system" 在1991年的八月，网络上出现了一篇以此为开篇话语的帖子——这是一个芬兰的名为Linus Torvalds的大学生为自己开始写作一个类似minix，可运行在386上的操作系统寻找志同道合的合作...
Android发展历程
EricWZY2008的专栏
08-09 1051
如题。
30 分钟，无代码，我用 Cursor 开发了一个软件
非著名程序员
01-04 523
最近准备在我的知识星球社群「AIGC·掘金成长研习社」开设一个新的专栏，专门讲一讲如何使用 Cursor AI 编程工具无代码的方式下，开发一些工具类的软件案例。让大家切实的感受到 AI 编程现在已经发展到什么地步了？不是程序员的普通人也可能通过自己的想法来开发一些不错的实用的小工具。今天给大家分享一下，昨天晚上，我花了 30 分钟，无代码的方式开发了一个浏览器插件：小红书海报生成器，整个过程，我...
机器学习的1000+篇文章总结
02-28 9908
机器学习的1000+篇文章总结 本文收集和总结了有关机器学习的1000+篇文章，由于篇幅有限只能总结近期的内容，想了解更多内容可以访问：http://www.ai2news.com/, 其分享了有关AI的论文、文章、图书。 吴恩达机器学习-9-降维PCA http://www.ai2news.com/blog/12185/ 机器学习也有弱点？哪些是机器学习的未解之谜？ http://www.ai2news.com/blog/39473/ 一站式机器学习平台建设实践 http://www
java小项目 未来出行汽车租赁平台
xiaoyoukaoer的博客
09-06 311
未来出行汽车租赁平台是基于Java开发的汽车租赁管理系统，旨在为用户提供便捷的车辆租赁服务。系统包含用户管理、车辆管理、订单管理等功能模块，适用于小型企业或个人学习使用。
vue2(7)-单页应用程序&路由
Naiveyouzhi的博客
09-07 251
快速引入组件，也可以用绝对路径 基于@指代src目录，从src目录出发找组件。最大的原因是：页面按需更新 要按需更新，就要明确访问路径和组件的关系。类名太长可以在router，index.js里面配置。单页应用程序，之所以开发效率高，性能高，用户体验好。右边第三个框，是在main.js中导入的。5.声明式导航-导航链接。2.路由：路径和组件的映射关系。配组件 配规则，配导航 配出口。如 单页：网易云，多页：京东。6.声明式导航-两个链接。6.声明式导航-跳转传参。
大数据毕业设计选题推荐-基于大数据的贵州茅台股票数据分析系统-Spark-Hadoop-Bigdata
IT研究室的博客
09-07 939
本文介绍了基于Hadoop+Spark的贵州茅台股票数据分析系统，采用Python/Java语言开发，集成Django/Spring Boot后端与Vue前端，实现多维金融数据分析。系统核心功能包括价格趋势分析、成交量跟踪、波动性评估及技术指标验证，通过Spark SQL和Pandas处理海量交易数据，支持日均价格走势、价量相关性、MACD/RSI指标等深度挖掘。界面展示包含Echarts动态可视化图表，代码示例演示了Spark计算日均均价、20日均线及价格区间统计逻辑。
从Java全栈开发到微服务架构的实战经验分享
CatchLight的博客
09-09 703
应聘者：我认为最重要的是能够理解业务需求，并将其转化为技术方案。同时，持续学习新技术，保持对行业趋势的关注也很关键。毕竟，技术更新很快，只有不断学习才能跟上节奏。通过这次面试，我们可以看到一位资深Java全栈开发者的专业能力和实践经验。他不仅掌握了多种技术栈，还能在实际业务场景中灵活运用，解决实际问题。同时，他也展现了良好的沟通能力和学习能力，这些都是成为一名优秀工程师的关键素质。
Vite 中的 import.meta.env 与通用 process.env.NODE_ENV 的区别与最佳实践
最新发布
BI
09-10 233
这篇文章对比了 process.env.NODE_ENV 和 Vite 的 import.meta.env。 两者都用于区分开发和生产环境，并支持代码优化（Tree-Shaking）。 核心区别在于：process.env.NODE_ENV 是源于 Node.js 的通用标准，是字符串，适用于需要兼容多种构建工具的库。而 import.meta.env 是 Vite 内置的现代对象，提供 DEV、PROD 等布尔值，语义更清晰，是 Vite 应用的首选。
从Java全栈到前端框架的实战之路
CatchLight的博客
09-10 729
面试官我们会在几天内通知你面试结果。应聘者面试官：加油！期待你加入我们团队。Java版本：Java 11和Java 17，注重性能优化和新特性支持。JVM内存模型：理解堆、栈、方法区等组成部分。前端技术栈：Vue3和TypeScript，使用Element Plus进行UI开发。微服务架构：使用Spring Cloud和OpenFeign进行服务治理。数据库与ORM：MyBatis和JPA，根据项目需求选择合适框架。测试与调试。
JavaScript的功能和作用
2402_83164836的博客
09-10 187
JavaScript（简称 JS）是一种​​，最初设计用于为网页添加动态交互功能。经过多年发展，其应用场景已远超浏览器，成为覆盖前端、后端、移动端、桌面端甚至物联网等领域的“全场景语言”。
web 网页数据传输处理过程
weixin_47106289的博客
09-08 752
web 网页数据传输处理过程
基于若依框架Vue+TS导出PDF文件的方法
m0_69564658的博客
09-08 424
本文介绍了在若依框架(Vue+TypeScript)中导出PDF的实现方法。主要使用html2canvas和jspdf库，通过将HTML内容转换为Canvas再生成PDF文件。文章详细说明了安装依赖、封装工具函数、组件调用步骤，并提供了代码示例。同时指出了跨域图片、样式控制等注意事项，并建议了pdfmake、vue-html2pdf等进阶方案。该方法适用于若依框架的PDF导出需求，可根据实际场景灵活调整。
＜uniapp＞＜指针组件＞基于uniapp，编写一个自定义箭头指针组件
用沸腾的热血，支付我们的人生吧！
09-10 166
本文介绍了基于uniapp开发的自定义带箭头指针组件，通过SVG实现直线和箭头的组合效果。组件支持设置长度、颜色、角度等参数，并提供三种箭头规格(small/normal/big)可选。文章详细讲解了SVG结构的实现过程，包括计算终点坐标、响应式参数处理等核心功能，并展示了不同配置下的指针效果。该组件可用于时钟指针等场景，具有灵活性和复用性特点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值