精华内容
下载资源
问答
  • 2021-04-24 19:46:50

    thinkphp5.1-vue-element-admin

    介绍

    基于thinkphp5.1、vue、element做的一个后台管理系统,默认打包出的是异步加载

    还有一点需要注意的是,如果使用本项目的ThinkPHP5.1进行接口开发,值得注意的一点是,我已经封装好接管异常的处理了,只需要创建异常类文件继承封装的异常就可以了。异常目录 app/lib/excption 目录,这个异常类分两种,一种是客户端异常(BaseException),一种服务器异常(不需要管,接管的异常会自动处理),当需要在不同功能接口返回异常时,只需要创建对应的异常类来继承客户端异常(即 BaseException)即可。

    架构

    架构说明

    目录结构

    ThinkPHP的目录结构就不用多说了,要说的是结合Vue后的目录

    public目录

    ├─preview 预览目录(安装之后直接删除)

    ├─static 应用目录

    │ ├─admin 后台目录(本后台管理系统主目录)

    │ ├─home 前台目录

    │ ├─src 模块目录

    │ │ ├─api 接口请求目录

    │ │ ├─assets 静态资源目录

    │ │ ├─common 公共目录(如:公共函数,可直接修改,不影响打包后的文件)

    │ │ ├─components 组件目录

    │ │ ├─config 配置目录

    │ │ ├─lib 核心库目录

    │ │ ├─router 路由目录

    │ │ ├─store vuex目录

    │ │ ├─views 视图目录

    │ │ ├─App.vue 根组件

    │ │ ├─index.html 主页

    │ │ ├─main.js 入口文件

    │ │ └─ ...

    Getting started

    # clone the project

    git clone https://github.com/chichengyu/thinkphp5.1-vue-element-admin.git

    # install dependency

    composer install

    # install dependency

    npm install

    # test development build

    npm run build:dev

    # build

    npm run build

    # watch

    npm run watch

    Build

    # Dev server

    npm run dev

    # test development build

    npm run build:dev

    # build

    npm run build

    # watch

    npm run watch

    安装异常

    可能会出现的异常情况

    路由报错

    Uncaught (in promise) NavigationDuplicated {_name: "NavigationDuplicated", name: "NavigationDuplicated"},这是可能路由安装的是报错的版本,解决方法:

    npm uninstall -S vue-router@3.0

    重新安装一个稳定的版本,或者,在 main.js中,加上如下代码:

    import VueRouter from 'vue-router'

    // 解决路由报错 Uncaught (in promise) NavigationDuplicated {_name: "NavigationDuplicated", name: "NavigationDuplicated"}

    const originalPush = VueRouter.prototype.push;

    VueRouter.prototype.push = function push(location) {

    return originalPush.call(this, location).catch(err => err)

    };

    该异常可能会出现

    npm ERR! path C:\Users\admin\Desktop\abc\node_modules\less

    npm ERR! code EISGIT

    npm ERR! git C:\Users\admin\Desktop\abc\node_modules\less: Appears to be a git repo or submodule.

    npm ERR! git C:\Users\admin\Desktop\abc\node_modules\less

    npm ERR! git Refusing to remove it. Update manually,

    npm ERR! git or move it out of the way first.

    npm ERR! A complete log of this run can be found in:

    npm ERR! C:\Users\admin\AppData\Roaming\npm-cache\_logs\2019-08-19T01_12_12_963Z-debug.log

    ‼ Command failed: C:\Users\admin\Desktop\www\element\node_modules\pngquant-bin\vendor\pngquant.exe --version

    ‼ pngquant pre-build test failed i compiling from source

    × Error: pngquant failed to build, make sure that libpng-dev is installed

    at Promise.all.then.arr (C:\Users\admin\Desktop\www\element\node_modules\bin-build\node_modules\execa\index.js:231:11)

    at process._tickCallback (internal/process/next_tick.js:68:7)

    npm WARN thinkphp5.1-vue-element-admin@1.0.0 No repository field.

    去掉 image-webpack-loader在重新进行安装即可。

    使用说明

    ThinkPHP5.1、Vue、element的使用就不在此多说了,这里要说的是前后分离时的 权限控制,这里介绍两种方法,两种都需要前后配合

    Vue-Router的meta元信息

    在需要验证的路由中加入 meta 属性 meta:{rules:['admin','editor']},如下:

    {

    path:'index',

    name:'adminIndex',

    meta:{rules:['admin','editor']},// 如此这样

    component: () => import(/* webpackChunkName: "login" */ '@/views/admin/components/index.vue')

    }

    admin、editor表示只有 admin/editor 两个用户组的用户能访问此条路由。

    当用户登陆时返回的用户信息中需要有当前用户所属的用户组(键名:roles)

    如:

    {

    username: 'admin',

    token: ' 5bf4b1a323557c43607406bc',

    roles: ['admin']

    }

    Vue-Router的name属性

    在需要验证的路由中加入 name 属性,且每个路由的 name 值必须是独一无二的,不能有相同值的,后台需要返回一个以所有路由中 name 值的对象规则,

    {

    "rules": {

    'index': true,

    'adminIndex': true,

    'table': true,

    'form': true,

    'keyboard': true,

    'line': true,

    'icons': true,

    'mix': true,

    'notAuth': false,

    'found': false,

    }

    }

    然后在路由守卫里进行判断筛选出当前登陆用户的菜单动态挂载到路由上。

    这里使用的是 meta 属性进行权限控制的,当然两种各有优劣势

    如果需要粒度更细的权限,如:按钮权限,这里我在 src\router\rules.js这个文件算是一个权限映射文件,只需要填写正确的权限id即可使用

    License

    更多相关内容
  • element VS iview(最近项目UI框架在选型 ,做了个分析, 不带有任何利益相关)主要从以下几个方面来做对比使用率(npm 平均下载频率,组件数量,star, issue…)API风格打包优化与设计师友好性1,使用率(npm 平均下载...

    element VS iview

    (最近项目UI框架在选型 ,做了个分析, 不带有任何利益相关)

    主要从以下几个方面来做对比

    使用率(npm 平均下载频率,组件数量,star, issue…)

    API风格

    打包优化

    与设计师友好性

    1,使用率(npm 平均下载频率,组件数量,star, issue…)

    element-ui

    结论 ,element 生态更好,使用频率远超过iview ,element开发团队实力

    感谢评论区

    纠错

    1.Element 有级联选择。

    2.Element 的 Popover 即 iView 的 Poptip 组件。

    3.Tooltip iView 和 Element 都有。

    一些小众组件上各有所长 整体iview 更丰富(时间轴,加载进度条,气泡卡片 ,BackTop,图钉)

    API风格

    通过使用平率最高的 form table 日历 select 等比较两者

    对应代码

    明显感觉 iview 的api 更加简洁,在生成类似表格 下拉框这些较复杂的组件时 , iview 的方式类似于antdesign , 好处是直接传数据进去,在内部实现了模板生成,高效 快捷。 而element 则是用到到v-for vue指令结合的方式去生成,批量生成元素。

    表格 操作列 自定义渲染的时 ,iview 使用的是 vue的 render 函数, element 直接在template 中插入对应模板

    表格分页都需要 引入分页组件 配合使用

    两者api 总体比较 ,iview 要比element 简洁许多。 饿了么更侧重于在template里直接去渲染模板

    思想上 个人觉得iview偏向react, element 更vue

    表单校验 两者都使用同一款插件 async-validator 校验方式一样

    项目优化角度

    首屏优化,第三方组件库依赖过大 会给首屏加载带来很大的压力,一般解决方式是 按需求引入组件

    element-ui 根据官方说明 现需要引入 babel-plugin-component 插件 做相关配置 然后直接在组件目录 注册全局组件

    iview 按需求加载 这里感觉官方给的文档不是很详细

    主题

    iview

    本身提供了一套主题可供选择,除此之外 自定义主题

    方法一(官方推荐,前提条件是使用webpack):

    新建一个.less 文件 , 先在less文件中引入官方样式文件 然后在此基础上复写

    方法二 :

    官方提供了 自动编译工具iview-them 来编译。干的事情就是 把自定义的样式和 github仓库最新的样式 通过工具生成一个新的样式文件。

    element-ui

    如果只替换颜色 ,可以使用 在线主题生成工具 在线编辑颜色, 生成element-ui 主题 直接下载 再引入

    深度定制主题

    官方提供了 主题生成工具 element-them

    执行命令 初始化得到一个配置文件 ,修改相关配置 经过编译得到 得到相关主题文件 再通过babel 插件引入

    双方都提供了专门的工具用于深度定制主题,综合比较 iview 更加简单,element 主题定制需要配合 babel做一些预编译 ,以及步骤更多 显得更加复杂

    过渡动画

    element 有内置过渡动画 使得组件的切换变化 更具动感

    iview 更为中规中矩

    对设计人员

    element 提供了 Sketch 和 Axure 工具 对设计人员友好

    iview 没有提供

    以上 ...

    展开全文
  • 几种解析的优劣势.....

    千次阅读 2016-04-26 09:02:03
    DOM SAX JDOM 和DOM4J 的几种优劣势
    • 1.DOM解析xml
    • ================================================
    • DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性,
    • 可以任意地控制整个XML文档中的内容。然而,由于DOM分析器把整个XML文
    •         档转化成DOM树放在了内存中,因此,当文档比较大或者结构比较复杂时,
    • 对内存的需求就比较高。而且,对于结构复杂的树的遍历也是一项耗时的操
    • 作。所以,DOM分析器对机器性能的要求比较高,实现效率不十分理想。不
    • 过,由于DOM分析器所采用的树结构的思想与XML文档的结构相吻合,同时鉴
    • 于随机访问所带来的方便,因此,DOM分析器还是有很广泛的使用价值的。
    • Node对象:DOM 结 构 中 最 为 基  本 的 对 象
    • Document对象:代表整个XML的文档
    • NodeList对象:包含一个或者多个Node的列表
    • Element对象:代表XML文档中的标签元素
    • 2.pull解析
    • =============================================
    • PULL解析是一种比较节省内存的解析方式,它允许应用程序代码从解析器中获取事件,例如,文档开始、文档结束、标签开始、标签结束。PULL解析器的运行方式与 SAX 解析器相似。PULL解析和SAX解析不一样的地方是PULL读取XML文件后触发相应的事件调用方法返回的是数字,另外,PULL可以在程序中被控制,想解析到哪里停止就可解析到哪里停止。

    • 3.SAX解析xml
    • ====================================================
    •   与DOM比较而言,SAX是一种轻量型的方法。我们知道,在处理DOM
    • 的时候,我们需要读入整个的XML文档,然后在内存中创建DOM树,生成DOM树上
    • 的每个Node对象。当文档比较小的时候,这不会造成什么问题,但是一旦文档大起
    • 来,处理DOM就会变得相当费时费力。特别是其对于内存的需求,也将是成倍的增
    • 长,以至于在某些应用中使用DOM是一件很不划算的事(比如在applet中)。这时候
    • ,一个较好的替代解决方法就是SAX。
    •      SAX在概念上与DOM完全不同。它不同于DOM的文档驱动,它是事件驱动的,
    • 它并不需要读入整个文档,而文档的读入过程也就是SAX的解析过程。所谓事件驱
    • 动,是指一种基于回调(callback)机制的程序运行方法。
    • DOM(文件对象模型)解析:解析器读入整个文档,然后构建一个驻留内存的树结
    • 构,然后代码就可以根据DOM接口来操作这个树结构了。




    • 4.DOM和SAX优劣势
    • ====================================================
    •   优点:整个文档读入内存,方便操作:支持修改、删除和重现排列等多种功能。

    •   缺点:将整个文档读入内存中,保留了过多的不需要的节点,浪费内存和空间。

    •   使用场合:一旦读入文档,还需要多次对文档进行操作,并且在硬件资源充足

    • 的情况下(内存,CPU)。

    • 为了解决DOM解析存在的问题,就出现了SAX解析。其特点为:


    •   优点:不用实现调入整个文档,占用资源少。尤其在嵌入式环境中,如android

    • ,极力推荐使用SAX解析。

    •   缺点:不像DOM解析一样将文档长期驻留在内存中,数据不是持久的。如果事

    • 件过后没有保存数据,数据就会丢失。

    •   使用场合:机器有性能限制


    • 5.JDOM解析 
    • =================================================
    •          JDOM的目的是成为java特定文档模型,它简化与xml的交互并且不使用DOM实
    • 现更快,JDOM仅使用具体类而不是接口。这在某些方面简化API,但是也限制了灵
    • 活性。第二,API大量使用了colletions类,简化。




    • 5.DOM4J解析
    • =================================================
    •           DOM4J使用接口和抽象基本方法。DOM4J大量使用了API中的Collections类,
    • 但是在许多情况下,它提供了一些替代方法允许更好的性能或更直接的编码方法。
    • 直接好处是,虽然DOM4J付出了更多复杂的API的代价,但它提供了比JDOM大得多
    • 的灵活性。

    • 6.初始步骤如下:
    • =================================================
    • 1.创建解析工厂:
    • DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
    • 2.指定DocumentBuilder
    • DocumentBuilder db = factory.newDocumentBuilder();
    • 3.从文件构造一个Document,因为XML文件中已经指定了编码,所以这里不必了
    • Document xmlDoc = db.parse(new File("book.xml")); 
    • 上面三步可以得到映射了指定的XML文件的Document,之后,通过这个Document可以
    • 来操作XML。
    • 得到Document的根
    • Element root = xmlDoc.getDocumentElement() 
    • 得到根后通过getTagName可以得到根节点名及其他一系列操作。
    • 获得XML某个元素的值:
    • NodeList list = root.getElementsByTagName_r("page");
    • //NodeList对象存储的是指定元素的值的列表,
    • //我们可以通过遍历来得到指定元素的各个值:
    • for(int i=0;i<list.getLength();i++){
    • Element element = (Element)list.item(i); //得到"page"的第i+1组标签
    • String id = element.getAttribute("id");  //获得ID属性
    • //
    • //得到标签title的列表
    • NodeList titleList = element.getElementsByTagName_r("title");
    • //得到"title"的第1组标签,事实上也只有一组标签
    • Element titleElement = (Element)titleList.item(0);
    • //获得title元素的第一个值
    • String title = titleElement.getFirstChild().getNodeValue();
    • }
    •  
    • 二.修改
    • Element theBook=null, theElem=null;
    • //   创建指定类型的元素
    •    theBook = xmlDoc.createElement_x("book");
    •    theElem = xmlDoc.createElement_x("name");
    • //   元素theElem设置数值,并作为theBook的子节点   
    •    theElem.setTextContent("新书");
    •    theBook.a(theElem);
    • //     作为root的子节点
    •    root.a(theBook);
    •  
    • 三.输出
    • 通过DOMSource和StreamResult完成
    • //首先创建转化工厂
    • TransformerFactory transFactory=TransformerFactory.newInstance();
    • //创建Transformer,它能够将源树转换为结果树
    • Transformer transformer = transFactory.newTransformer();
    • //接下来设置输出属性
    • transformer.setOutputProperty("indent", "yes");
    • DOMSource source =new DOMSource();
    • source.setNode(xmlDoc);
    • StreamResult result = new StreamResult();
    • 接下来有三种输出用途:
    • //1.将XML字符串输出到String字符串中
    • ByteArrayOutputStream baos = new ByteArrayOutputStream();
    • result.setOutputStream(baos);
    • 在执行完transformer.transform(source, result)后,
    • 加入String s = baos.toString();
    • //2.直接输出到控制台上
    • result.setOutputStream(System.out);
    • //3.保存到指定的文件里面
    • result.setOutputStream(new FileOutputStream("book.xml"));
    • //开始执行将XML Source转换为 Result
    • transformer.transform(source, result); 
    展开全文
  • 在了解了ArrayList的增加和删除的原理之后,总结一下ArrayList的缺点: 1.因为ArrayList底层是以数组实现的所以决定了它在查找的时候会非常的快。 2.ArrayList在顺序添加元素的时候其实是相当于向数组中添加一...

    ArrayList是开发人员经常使用的一个集合类,从名称上看,ArrayList是一个以数组的形式实现的集合,
    注:以下的代码中的中文注释并不是源码中的注释,而是本人根据自己的理解添加上去的,jdk版本1.7

     private static final Object[] EMPTY_ELEMENTDATA = {};
     public ArrayList() {
            super();
            this.elementData = EMPTY_ELEMENTDATA;
        }
    

    再使用ArrayList的时候如果没有初始化容量,ArrayList会自动给予一个默认的初始化容量

     private static final int DEFAULT_CAPACITY = 10;

    当然在创建对象的时候可以手动设置一个自定义的初始化的容量,具体是通过带参的构造函数得以实现:

    `public ArrayList(int initialCapacity) {
        super();
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal      Capacity: "+ initialCapacity);
            this.elementData = new Object[initialCapacity];
        }`  

    如果传入的参数是负数,则会抛出不合法的参数异常。在了解了ArrayList的底层实现之后可以先初步总结一下:
    1.可以为空;通过数组区存储数据,决定了在ArrayList的任意位置可以为空。
    2.是有序的;存入的数据是以一定的顺序进行存放的,每一个存进来的数 据,都有一个唯一的索引标识相应的数据,所以,读取数据的顺序与存入数据的顺序是一致的。
    3.可以重复;因为每一个数据都有相应的索引标识,所以可以存储重复的数据。

    扩容
    通过

        private static final int DEFAULT_CAPACITY = 10;

    我们知道ArrayList的默认的大小是10;当存储的数据量大于10的时候,会动态扩容:

      private void ensureCapacityInternal(int minCapacity) {
            //如果数组是初始化的那个数组,则将初始化容量和现在的容量中较大的数值传入后续的方法中
            if (elementData == EMPTY_ELEMENTDATA) {
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
            ensureExplicitCapacity(minCapacity);
     }
    
     private void ensureExplicitCapacity(int minCapacity) {
            modCount++;   
            //如果现在的容量大于数组原本的长度调用grow方法     
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
     }
      private void grow(int minCapacity) {        
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);                
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    

    其中 int newCapacity = oldCapacity + (oldCapacity >> 1)中的”>>”标识右移,转为二进制的形式可能更好理解,0000 1111(15)右移2位的结果是0000 0011(3),0001 1010(18)右移3位的结果是0000 0011(3)。
    可以看到在源码中通过严格的大小比较判断,决定是否要进行扩容,扩容后的容量大小是多少;将最终的容量大小,和原数组elementData作为参数,调用Arrays.copyOf方法,将原数组里的内容复制到新的数组里面去。

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
            T[] copy = ((Object)newType == (Object)Object[].class)
                ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength);
            System.arraycopy(original, 0, copy, 0,
                             Math.min(original.length, newLength));
            return copy;
     }

    添加元素
    在没有泛型约束的情况下ArrayList中是可以添加任意的元素:

     public boolean add(E e) {
            //给予一个新的容量大小进行扩容
            ensureCapacityInternal(size + 1);
            //在数组的最后一个位置放入对象e
            elementData[size++] = e;
            return true;
     }

    制定任意的位置添加元素

     public void add(int index, E element) {
            rangeCheckForAdd(index);
    
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            elementData[index] = element;
            size++;
        }

    在理解了扩容之后就很容易理解添加操作了

    删除

    首先是指定具体位置的删除

     public E remove(int index) {
            rangeCheck(index);
    
            modCount++;
            E oldValue = elementData(index);
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
            //将指定元素后面的元素整体向前移动一个位置
                System.arraycopy(elementData, index+1, elementData, index, numMoved);
            //设置最后一个位置为空
            elementData[--size] = null;
    
            return oldValue;
        }

    删除指定的元素

    public boolean remove(Object o) {
            if (o == null) {
                for (int index = 0; index < size; index++)
                    if (elementData[index] == null) {
                        fastRemove(index);
                        return true;
                    }
            } else {
                for (int index = 0; index < size; index++)
                    //通过循环遍历查找与指定元素相同的元素的索引进行删除
                    if (o.equals(elementData[index])) {
                        fastRemove(index);
                        return true;
                    }
            }
            return false;
        }
    private void fastRemove(int index) {
            modCount++;
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,numMoved);
            elementData[--size] = null;
        }

    删除指定的元素原理跟删除指定位置的元素类似

    在了解了ArrayList的增加和删除的原理之后,总结一下ArrayList的优缺点:
    1.因为ArrayList底层是以数组实现的所以决定了它在查找的时候会非常的快。
    2.ArrayList在顺序添加元素的时候其实是相当于向数组中添加一个元素,所以速度也很快。
    3.ArrayList在向指定位置添加元素或者是删除元素的时候涉及到一次元素的复制和移动,所以如果元素比较多的话会比较耗费性能。
    所以,综上所述,ArrayList适合顺序添加(add())和随机访问(get())的场景。
    ArrayList的并发问题
    ArrayList是线程非安全的,因为其中的方法都不是同步的,并发情况下回出现一些问题。为了解决这个问题,有两种办法可以尝试:
    1.通过Collections.synchronizedList()方法将ArrayList变成线程安全的list;代码实现如下:

     public static <T> List<T> synchronizedList(List<T> list) {
            return (list instanceof RandomAccess ?
                    new SynchronizedRandomAccessList<>(list) :
                    new SynchronizedList<>(list));
        }

    另外的一个方法就是使用Vector,Vector中的方法都是线程安全的。例如:

     public synchronized void addElement(E obj) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = obj;
        }

    在看ArrayList的底层实现的时候,看到一个比较少见的关键字:transient

     private transient Object[] elementData;

    当对象被序列化时(写入字节序列到目标文件)时,transient阻止实例中那些用此关键字声明的变量持久化;当对象被反序列化时(从源文件读取字节序列进行重构),这样的实例变量值不会被持久化和恢复。
    那为什么底层的数组要用这个变量修饰呢?因为序列化ArrayList的时候elementData未必是满的。比如说容量是10,但是只有3个元素放在了里面,没有必要序列化整个elementData。ArrayList中重写了writeObject方法:

      private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
            // Write out element count, and any hidden stuff
            int expectedModCount = modCount;
            s.defaultWriteObject();
    
            // Write out size as capacity for behavioural compatibility with clone()
            s.writeInt(size);
    
            // Write out all elements in the proper order.
            for (int i=0; i<size; i++) {
                s.writeObject(elementData[i]);
            }
    
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
        }

    每次序列化的时候调用这个方法只序列化elementData中的非transient元素。即加快了序列化的速度,又减小了序列化之后的文件大小。

    展开全文
  • 关于SAX,DOM,PULL,DOM4J解析XML文件的优劣势浅显分析   1.SAX简介   SAX处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,...
  • WSDL绑定样式各种组合优劣势比较  目前Web服务的相关标准是WSDL【Web服务描述语言】,一种标准的类似XML Schema的语言,用它来详细说明Web服务和SOAP【简单对象访问协议】,Web服务使用的实际的...
  • 在做vue项目中,组件之间的通信是必不可少的,但是vue有多少种方式、用法、缺点及适用场景,本篇文章大概总结一下。(本篇摘抄[Vue组件通信方式及其应用场景总结](https://juejin.cn/post/6903796293445877773)并...
  • WSDL绑定样式各种组合优劣势比较

    千次阅读 2010-07-08 21:08:00
    wrapper element (封装元素))。这个元素依次为该方法的每个参数还有返回值作了 记录。 Document 样 式 如果是 document 样 式,就没有像在 RPC 样式中的 ...
  • 1.SAX解析 解析方式是事件驱动机制!... //获取根节点里面的元素 Element name1 = rootElement1.element("name"); //打印元素里面的内容 System.out.println(name1.getText()); //关闭流 file1.close(); } }
  • 前端开发中spa的缺点Micro-frontends are the future of frontend web development. Inspired by microservices, which allow you to break up your backend into smaller pieces, micro-frontends allow you to ...
  • 一般channel的声明形式为:var chanName chan ElementType  ElementType指定这个channel所能传递的元素类型。 定义一个channel也很简单,直接使用内置的函数make()即可:  ch := make(chan int,bufferSize) //...
  • 数组 优势和劣势

    千次阅读 2019-07-11 10:36:19
    数组的优势和劣势 优势 数组拥有非常高效的随机访问能力,只要给出下标,就可以用常量时间找到对应元素。有一种高效查找元素的算法叫作二分查找,就是利用了数组这个优势。 劣势 至于数组的劣势,体现在插入和删除...
  • ArrayList和LinkedList在性能上各 有缺点,都有各自所适用的地方,总的说来可以描述如下: 1.对ArrayList和LinkedList而言,在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言,主要是在内部数组...
  • Vue的缺点

    千次阅读 2021-02-02 19:01:15
    一、Vue缺点 优点: 虚拟DOM(类似ReactJS) 首先,将传统DOM结构变为JSON结构,用操作js的方式代替操作DOM,性能更快; 其次,虚拟dom同步到真实dom,使用sync()方法,分批渲染。 双向绑定(类似AngularJS)...
  • Bins are converted to trees when adding an element to a * bin with at least this many nodes. The value must be greater * than 2 and should be at least 8 to mesh with assumptions in * tree removal ...
  • 对于以上三类开发方式都有各自的优势和劣势,在使用过程中也应该按照自己业务进行具体的选型使用,大致可以按照如此规则进行使用,一般公司App会存在三种技术栈,当然也存在单一类型实现方案的公司,对于三种技术栈...
  • 虚拟DOM 什么是虚拟DOM 1 var element = { 2 element: 'ul', 3 props: { 4 id:"ulist" 5 }, 6 children: [ 7 { element: 'li', props: { id:"first" }, children: ['这是第一个List元素'] }, 8 { element: 'li', ...
  • element = WebDriverWait(driver,5,0.5).until(lambda driver:driver.presence_of_element_located(By.ID,‘kw’)) #单独针对这个元素设置等待,等待时长为5秒(最大等待时间),每隔0.5秒找一次(搜索频率),直到...
  • 优劣势是: 被动触发,对于服务的资源消耗更小; Redis的Pub/Sub不可靠,没有ACK机制等,但是一般情况可以容忍; 键空间通知功能会耗费一些CPU 基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理...
  • 译者前言 这是一篇来自 StackOverflow 的问答,提问的人认为 React 相比 WebComponents 有一些“先天不足”之处,列举如下: 原生浏览器支持 原生语法支持(意即不把样式和结构混杂在 JS 中) 使用 Shadow DOM ...
  • 最近用selenium进行采集,遇到一些麻烦,对selenium的缺点有了更深刻的理解。 先说说优点吧: 可视化界面,初学容易上手。 不深入理解动态加载和后端的交互也可以进行数据采集 比较符合普通人操作网页进行复制...
  • 针对你个人经验,来谈谈 Flutter 和移动端的优劣势,排除性能相关。 工作中会编写测试用例吗?用过哪儿些?自动化测试工具呢? 举例说明你在工作中最有成就感、最有难度的一个事儿。 我看你最近在应用上架,简单聊...
  • 据 AI 解决方案提供商 Element AI 预测,目前大约有 20000 名博士级别的计算机科学家可以搭建 AI 系统;据 Bloomberg 最近发布的研究显示,全世界范围内只有不到 10000 名开发人员具备机器学习技术能力。此外,KPMG ...
  • PrintElement ( TElemType e ) { //输出元素e的值 printf ( "%c" , e ) ; return OK ; } Status PreOrderTraverse ( BiTree T , Status ( * Visit ) ( TElemType e ) ) { if ( T ) { ...
  • selenium三种等待方式

    2019-10-30 12:28:04
    强制等待的缺点: 强制等待(涉及到多个系统的交互时就用强制等待),不够灵活 time.sleep() 代码如下: 2.隐式等待 隐式等待(查找元素):背后默默的等待,几乎感觉不到他的存在 driver.implicitly_wait(10) ...
  • To compute the softmax value of each of the individual output element, we must compute all the e^xk for all the element k. 该算法包含两个步骤: 1在图形中的节点上执行随机遍历以生成节点序列 2...
  • 劣势 Python 标准库 BeautifulSoup(markup, "html.parser") Python的内置标准库、执行速度适中、文档容错能力强 Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差 lxml HTML 解析器 ...
  • 自定义注解 注解用于标记需要认证的目标,当然也可以标记不需要认证的目标,最好使用AOP自定义注解拦截,来应对不同业务需求 注解@JwtCheck,用于标记接口需要验证,只需要 @Target({ElementType.METHOD, Element...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 851
精华内容 340
热门标签
关键字:

element的优劣势