精华内容
下载资源
问答
  • JavaScript中 with用法

    万次阅读 多人点赞 2018-03-28 12:50:09
      说起js中的with关键字,很多小伙伴们的第一印象可能就是with关键字的作用在于改变作用域,然后最关键的一点是不推荐使用with关键字。听到不推荐with关键字后,我们很多人都会忽略掉with关键字,认为不要去管它用...

    文章是本人大三期间的学习笔记,一些论断取自书籍和网上博客,碍于当时的技术水平有一些写得不够好的地方,可以在评论处理智讨论~

    说起js中的with关键字,很多小伙伴们的第一印象可能就是with关键字的作用在于改变作用域,然后最关键的一点是不推荐使用with关键字。听到不推荐with关键字后,我们很多人都会忽略掉with关键字,认为不要去管它用它就可以了。但是有时候,我们在看一些代码或者面试题的时候,其中会有with关键字的相关问题,很多坑是你没接触过的,所以还是有必要说说with这一个关键字。

    with的基本用法


    with 语句的原本用意是为逐级的对象访问提供命名空间式的速写方式. 也就是在指定的代码区域, 直接通过节点名称调用对象。

    with 通常被当做重复引用同一个对象中的多个属性的快捷方式,可以不需要重复引用对象本身。

    比如,目前现在有一个这样的对象:

    var obj = {
    	a: 1,
    	b: 2,
    	c: 3
    };
    

    如果想要改变 obj 中每一项的值,一般写法可能会是这样:

    // 重复写了3次的“obj”
    obj.a = 2;
    obj.b = 3;
    obj.c = 4;
    

    而用了 with 的写法,会有一个简单的快捷方式

    with (obj) {
    	a = 3;
    	b = 4;
    	c = 5;
    }
    

    在这段代码中,使用了 with 语句关联了 obj 对象,这就以为着在 with 代码块内部,每个变量首先被认为是一个局部变量,如果局部变量与 obj 对象的某个属性同名,则这个局部变量会指向 obj 对象属性。

    with的弊端


    在上面的例子中,我们可以看到,with 可以很好地帮助我们简化代码。但是为什么不推荐使用呢?下面我们来说说with的缺点:

    导致数据泄漏

    我们来看下面的这部分代码

    function foo(obj) {
    	with (obj) {
    		a = 2;
    	}
    }
    
    var o1 = {
    	a: 3
    };
    
    var o2 = {
    	b: 3
    }
    
    foo(o1);
    console.log(o1.a);	//2
    
    foo(o2);
    console.log(o2.a);	//underfined
    console.log(a);		//2,a被泄漏到全局作用域上
    

    首先,我们来分析上面的代码。例子中创建了 o1 和 o2 两个对象。其中一个有 a 属性,另外一个没有。foo(obj) 函数接受一个 obj 的形参,该参数是一个对象引用,并对该对象引用执行了 with(obj) {...}。在 with 块内部,对 a 有一个词法引用,实际上是一个 LHS引用,将 2 赋值给了它。

    当我们将 o1 传递进去,a = 2 赋值操作找到了 o1.a 并将 2 赋值给它。而当 o2 传递进去,o2 并没有 a 的属性,因此不会创建这个属性,o2.a 保持 undefined。

    但为什么对 o2的操作会导致数据的泄漏呢?

    这里需要回到对 LHS查询 的机制问题(详情可移步 JavaScript中的LHS和RHS查询)。

    当我们传递 o2 给 with 时,with 所声明的作用域是 o2, 从这个作用域开始对 a 进行 LHS查询。o2 的作用域、foo(…) 的作用域和全局作用域中都没有找到标识符 a,因此在非严格模式下,会自动在全局作用域创建一个全局变量),在严格模式下,会抛出ReferenceError 异常。

    另一个不推荐 with 的原因是。在严格模式下,with 被完全禁止,间接或非安全地使用 eval(…) 也被禁止了。

    性能下降

    with 会在运行时修改或创建新的作用域,以此来欺骗其他在书写时定义的词法作用域。with 可以使代码更具有扩展性,虽然有着上面的数据泄漏的可能,但只要稍加注意就可以避免,难道不是可以创造出很好地功能吗?

    答案是否定的,具体原因我们先来看下面的这部分代码。

    下面代码可以直接复制出去运行

    <script>
    function func() {
    	console.time("func");
    	var obj = {
    		a: [1, 2, 3]
    	};
    	for(var i = 0; i < 100000; i++)
    	{
    		var v = obj.a[0];
    	}
    	console.timeEnd("func");
    }
    func();
    
    function funcWith() {
    	console.time("funcWith");
    	var obj = {
    		a: [1, 2, 3]
    	};
    	with(obj) {
    		for(var i = 0; i < 100000; i++) {
    			var v = a[0];
    		}
    	}
    	console.timeEnd("funcWith");
    }
    
    funcWith();
    </script>
    

    接着是,测试效果:

    这里写图片描述

    在处理相同逻辑的代码中,没用 with 的运行时间仅为 4.63 ms。而用 with 的运用时间长达 81.87ms。

    这是为什么呢?

    原因是 JavaScript 引擎会在编译阶段进行数项的性能优化。其中有些优化依赖于能够根据代码的词法进行静态分析,并预先确定所有变量和函数的定义位置,才能在执行过程中快速找到标识符。

    但如果引擎在代码中发现了 with,它只能简单地假设关于标识符位置的判断都是无效的,因为无法知道传递给 with 用来创建新词法作用域的对象的内容到底是什么。

    最悲观的情况是如果出现了 with ,所有的优化都可能是无意义的。因此引擎会采取最简单的做法就是完全不做任何优化。如果代码大量使用 with 或者 eval(),那么运行起来一定会变得非常慢。无论引擎多聪明,试图将这些悲观情况的副作用限制在最小范围内,也无法避免如果没有这些优化,代码会运行得更慢的事实

    展开全文
  • oracle with as用法

    千次阅读 2019-10-12 16:00:09
    withas语法 相当于建了个临时表 ,或者sql的别命名 with tmp1 as(select*from aa where id="001"), tmp2as(select*frombb where id="001"), tmp3as(select*from cc where id="001"), ...select *from tmp1 , tmp2,...

    with as语法
    相当于建了个临时表 ,或者sql的别命名

    with
    tmp1 as(select * from aa where id="001"),
    tmp2 as(select * from bb where id="001"),
    tmp3 as(select* from cc where id="001"),
    ...select *from tmp1 ,  tmp2,tmp3 ... where tmp1.id=tmp2.id=tmp3.id='001'  ;
    --相当于
    create table  tmp1  as  select * from aa
    
    create table  tmp2  as  select * from bb
    
    create table  tmp3  as  select * from cc
    
    select * from tmp1  ,tmp2,tmp3  where tmp1.id=tmp2.id=tmp3.id='001'  ;
    

    如: aa表数据如下,bb,cc表数据跟aa表一样

    查询结果如下

    注意:如果没有条件管控,查询结果为笛卡尔积

    with
    tmp1 as(select * from aa),
    tmp2 as(select * from bb),
    tmp3 as(select* from cc),
    ...select *from tmp1 ,  tmp2,tmp3 ...;
    --相当于
    
    create table  tmp1  as  select * from aa
    
    create table  tmp2  as  select * from bb
    
    create table  tmp3  as  select * from cc
    
    select * from tmp1  ,tmp2,tmp3 ;

     

     结果也就是笛卡尔积(比如  aa 8条数据,bb8调数据,cc8条数据,则总共8*8*8=512条数据)

    如下:

     

     向一张表插入数据的 with as 用法:

    insert into table2
    with
        s1 as (select rownum c1 from dual connect by rownum <= 10),
        s2 as (select rownum c2 from dual connect by rownum <= 10)
    select a.c1, b.c2 from s1 a, s2 b where...;
    同样 需要有关联条件,不然结果任会是笛卡尔积
    with as 相当于虚拟视图.
    with as短语,也叫做子查询部分(subquery factoring),可以让你做很多事情,定义一个sql片断,该sql片断会被整个sql语句所用到.有
    的时候,是为了让 sql 语句的可读性更高些,也有可能是在 union all 的不同部分,作为提供数据的部分。
    特别对于 union all 比较有用.因为 union all的每个部分可能相同,但是如果每个部分都去执行一遍的话,则成本太高,所以可以使用 with as短语,则只要执行一遍即可。如果 with as短语所定义的表名被调用两次以上,则优化器会自动将 with as短语所获取的数据放入一个temp表里,如果只是被调用一次,则不会。而提示materialize 则是强制将 with as短语里的数据放入一个全局临时表里.很多查询通过这种方法都可以提高速度。
    
    with as优点
    增加了 sql的易读性,如果构造了多个子查询,结构会更清晰;
    更重要的是:"一次分析,多次使用”,这也是为什么会提供性能的地方,达到了"少读”的目标
    展开全文
  • SQL With As 用法

    万次阅读 2018-10-07 16:17:15
    SQL With As 用法 一.WITH AS的含义 WITH AS短语,也叫做子查询部分(subquery factoring),可以定义一个SQL片断,该SQL片断会被整个SQL语句用到。可以使SQL语句的可读性更高,也可以在UNION ALL的不同部分,...

    SQL With As 用法

    一.WITH AS的含义

    WITH AS短语,也叫做子查询部分(subquery factoring),可以定义一个SQL片断,该SQL片断会被整个SQL语句用到。可以使SQL语句的可读性更高,也可以在UNION ALL的不同部分,作为提供数据的部分。

    对于UNION ALL,使用WITH AS定义了一个UNION ALL语句,当该片断被调用2次以上,优化器会自动将该WITH AS短语所获取的数据放入一个Temp表中。而提示meterialize则是强制将WITH AS短语的数据放入一个全局临时表中。很多查询通过该方式都可以提高速度。

    二.使用方法 
    先看下面一个嵌套的查询语句:

    select * from person.StateProvince where CountryRegionCode in 
             (select CountryRegionCode from person.CountryRegion where Name like 'C%')

    上面的查询语句使用了一个子查询。虽然这条SQL语句并不复杂,但如果嵌套的层次过多,会使SQL语句非常难以阅读和维护。因此,也可以使用表变量的方式来解决这个问题,SQL语句如下:

    declare @t table(CountryRegionCode nvarchar(3)) 
    insert into @t(CountryRegionCode)  (select CountryRegionCode from person.CountryRegion where Name like 'C%')
    
    select * from person.StateProvince where CountryRegionCode 
                         in (select * from @t)

    虽然上面的SQL语句要比第一种方式更复杂,但却将子查询放在了表变量@t中,这样做将使SQL语句更容易维护,但又会带来另一个问题,就是性能的损失。由于表变量实际上使用了临时表,从而增加了额外的I/O开销,因此,表变量的方式并不太适合数据量大且频繁查询的情况。为此,在SQL Server 2005中提供了另外一种解决方案,这就是公用表表达式(CTE),使用CTE,可以使SQL语句的可维护性,同时,CTE要比表变量的效率高得多。

     

    下面是CTE的语法:

    [ WITH <common_table_expression> [ ,n ] ] 
    <common_table_expression>::= 
            expression_name [ ( column_name [ ,n ] ) ] 
        AS 
            ( CTE_query_definition )

    现在使用CTE来解决上面的问题,SQL语句如下:

    按 Ctrl+C 复制代码

     

    按 Ctrl+C 复制代码

    其中cr是一个公用表表达式,该表达式在使用上与表变量类似,只是SQL Server 2005在处理公用表表达式的方式上有所不同。

    在使用CTE时应注意如下几点:

    1. CTE后面必须直接跟使用CTE的SQL语句(如select、insert、update等),否则,CTE将失效。如下面的SQL语句将无法正常使用CTE:

     

    with
    cr as
    (
        select CountryRegionCode from person.CountryRegion where Name like 'C%'
    )
    select * from person.CountryRegion  -- 应将这条SQL语句去掉
    -- 使用CTE的SQL语句应紧跟在相关的CTE后面 --
    select * from person.StateProvince where CountryRegionCode in (select * from cr)

     

    2. CTE后面也可以跟其他的CTE,但只能使用一个with,多个CTE中间用逗号(,)分隔,如下面的SQL语句所示:

     

    with
    cte1 as
    (
        select * from table1 where name like 'abc%'
    ),
    cte2 as
    (
        select * from table2 where id > 20
    ),
    cte3 as
    (
        select * from table3 where price < 100
    )
    select a.* from cte1 a, cte2 b, cte3 c where a.id = b.id and a.id = c.id

     

    3. 如果CTE的表达式名称与某个数据表或视图重名,则紧跟在该CTE后面的SQL语句使用的仍然是CTE,当然,后面的SQL语句使用的就是数据表或视图了,如下面的SQL语句所示:

     

    --  table1是一个实际存在的表
    
    with
    table1 as
    (
        select * from persons where age < 30
    )
    select * from table1  --  使用了名为table1的公共表表达式
    select * from table1  --  使用了名为table1的数据表

     

    4. CTE 可以引用自身,也可以引用在同一 WITH 子句中预先定义的 CTE。不允许前向引用。

    --使用递归公用表表达式显示递归的多个级别
    WITH DirectReports(ManagerID, EmployeeID, EmployeeLevel) AS 
    (
        SELECT ManagerID, EmployeeID, 0 AS EmployeeLevel
        FROM HumanResources.Employee
        WHERE ManagerID IS NULL
        UNION ALL
        SELECT e.ManagerID, e.EmployeeID, EmployeeLevel + 1
        FROM HumanResources.Employee e
            INNER JOIN DirectReports d
            ON e.ManagerID = d.EmployeeID 
    )
    SELECT ManagerID, EmployeeID, EmployeeLevel 
    FROM DirectReports ;
    
    --使用递归公用表表达式显示递归的两个级别
    WITH DirectReports(ManagerID, EmployeeID, EmployeeLevel) AS 
    (
        SELECT ManagerID, EmployeeID, 0 AS EmployeeLevel
        FROM HumanResources.Employee
        WHERE ManagerID IS NULL
        UNION ALL
        SELECT e.ManagerID, e.EmployeeID, EmployeeLevel + 1
        FROM HumanResources.Employee e
            INNER JOIN DirectReports d
            ON e.ManagerID = d.EmployeeID 
    )
    SELECT ManagerID, EmployeeID, EmployeeLevel 
    FROM DirectReports 
    WHERE EmployeeLevel <= 2 
    
    --使用递归公用表表达式显示层次列表
    WITH DirectReports(Name, Title, EmployeeID, EmployeeLevel, Sort)
    AS (SELECT CONVERT(varchar(255), c.FirstName + ' ' + c.LastName),
            e.Title,
            e.EmployeeID,
            1,
            CONVERT(varchar(255), c.FirstName + ' ' + c.LastName)
        FROM HumanResources.Employee AS e
        JOIN Person.Contact AS c ON e.ContactID = c.ContactID 
        WHERE e.ManagerID IS NULL
        UNION ALL
        SELECT CONVERT(varchar(255), REPLICATE ('| ' , EmployeeLevel) +
            c.FirstName + ' ' + c.LastName),
            e.Title,
            e.EmployeeID,
            EmployeeLevel + 1,
            CONVERT (varchar(255), RTRIM(Sort) + '| ' + FirstName + ' ' + 
                     LastName)
        FROM HumanResources.Employee as e
        JOIN Person.Contact AS c ON e.ContactID = c.ContactID
        JOIN DirectReports AS d ON e.ManagerID = d.EmployeeID
        )
    SELECT EmployeeID, Name, Title, EmployeeLevel
    FROM DirectReports 
    ORDER BY Sort
    
    --使用 MAXRECURSION 取消一条语句
    --可以使用 MAXRECURSION 来防止不合理的递归 CTE 进入无限循环。以下示例特意创建了一个无限循环,然后使用 MAXRECURSION 提示将递归级别限制为两级
    WITH cte (EmployeeID, ManagerID, Title) as
    (
        SELECT EmployeeID, ManagerID, Title
        FROM HumanResources.Employee
        WHERE ManagerID IS NOT NULL
      UNION ALL
        SELECT cte.EmployeeID, cte.ManagerID, cte.Title
        FROM cte 
        JOIN  HumanResources.Employee AS e 
            ON cte.ManagerID = e.EmployeeID
    )
    --Uses MAXRECURSION to limit the recursive levels to 2
    SELECT EmployeeID, ManagerID, Title
    FROM cte
    OPTION (MAXRECURSION 2)
    --在更正代码错误之后,就不再需要 MAXRECURSION。以下示例显示了更正后的代码
    WITH cte (EmployeeID, ManagerID, Title)
    AS
    (
        SELECT EmployeeID, ManagerID, Title
        FROM HumanResources.Employee
        WHERE ManagerID IS NOT NULL
      UNION ALL
        SELECT  e.EmployeeID, e.ManagerID, e.Title
        FROM HumanResources.Employee AS e
        JOIN cte ON e.ManagerID = cte.EmployeeID
    )
    SELECT EmployeeID, ManagerID, Title
    FROM cte

     

     

    5. 不能在 CTE_query_definition 中使用以下子句:

      (1)COMPUTE 或 COMPUTE BY

      (2)ORDER BY(除非指定了 TOP 子句)

      (3)INTO

      (4)带有查询提示的 OPTION 子句

      (5)FOR XML

      (6)FOR BROWSE

    6. 如果将 CTE 用在属于批处理的一部分的语句中,那么在它之前的语句必须以分号结尾,如下面的SQL所示:

     

    declare @s nvarchar(3)
    set @s = 'C%'
    ;  -- 必须加分号
    with
    t_tree as
    (
        select CountryRegionCode from person.CountryRegion where Name like @s
    )
    select * from person.StateProvince where CountryRegionCode in (select * from t_tree)

    复制代码

    展开全文
  • Oracle WITH AS 用法

    千次阅读 2018-01-11 18:15:55
    可以把WITH AS 的用法看成赋值的用法,以减少SQL语句的冗余。 当我们在SQL语句中频繁的利用某一个Select查询语句作为数据源时,我们可以用WITH AS 的用法进行简写 增加了SQL的易读性,如果构造了多个子查询,结构...

    前言

     可以把WITH AS 的用法看成赋值的用法,以减少SQL语句的冗余。
     当我们在SQL语句中频繁的利用某一个Select查询语句作为数据源时,我们可以用WITH AS 的用法进行简写
     增加了SQL的易读性,如果构造了多个子查询,结构会更清晰;更重要的是:“一次分析,多次使用”。
    

    语法

    with tempName1 as (select ....),tempName2 as (select ....)
    select ...from  tempName 

    例子

    例子:

    //普通使用方法
    Select * from (
        select name ,age from stu
        union 
        select name,age from tech
        union
        …
    )
    
    //wtih as 
    with schoolPeople as (
        select name ,age from stu
        union 
        select name,age from tech
        union
        …
    )
    select * from schoolPeople

    注意事项

    • ① 子查询可重用相同或者前一个with查询块,通过select调用(with子句也只能被select调用)
    • ② with子句的查询输出存储到用户临时表空间,一次查询,到处使用
    • ③ 同级select前有多个查询定义,第一个用with,后面的不用with,并且用逗号分割
    • ④ 最后一个with查询块与下面的select调用之间不能用逗号分割,只通过右括号分离,with子句的查询必须括号括起
    • ⑤如果定义了with子句,而在查询中不使用,则会报ora-32035错误,只要后面有引用的即可,不一定在select调用,在后with查询块引用也是可以的
    • ⑥ 前面的with子句定义的查询在后面的with子句中可以使用,但是一个with子句内部不能嵌套with子句
    • ⑦ with查询的结果列有别名,引用时候必须使用别名或者*
    展开全文
  • python的with用法

    万次阅读 多人点赞 2016-10-06 21:18:11
    1.With语句是什么?有一些任务,可能事先需要设置,事后做清理工作。对于这种场景,Python的with语句提供了一种非常方便的处理方式。一个很好的例子是文件处理,你需要获取一个文件句柄,从文件中读取数据,然后关闭...
  • Python中with用法

    万次阅读 多人点赞 2018-07-01 12:03:29
    之前再遇到with语句在文件操作上的用法非常巧妙,以前不太熟悉,看的时候也产生一些困惑 With语句是什么? 有一些任务,可能事先需要设置,事后做清理工作。对于这种场景,Python的with语句提供了一种非常方便的处理...
  • NEO4J中WITH用法

    千次阅读 2020-01-05 20:30:28
    和Oracle中with用法相似,把with后面结果集当成一个查询结果、在这个结果基础上再做where条件的筛选 比如下面这个语句:查询所有电影集、每个电影至少有8个以上的演员参演。 with o,count(r) as count_r,以这个...
  • ORACLE WITH AS 用法

    千次阅读 2017-11-08 09:00:52
    语法:with tempName as (select ....) select ...例:现在要从1-19中得到11-14。一般的sql如下:select * from ( --模拟生一个20行的数据 SELECT LEVEL AS lv FROM DUAL CONNECT BY LEVEL < 20
  • SQL:with as用法

    千次阅读 2017-08-31 14:38:37
    WITH AS短语,也叫做子查询部分,定义一个SQL片断后,该SQL片断可以被整个SQL语句所用到。有的时候,with as是为了提高SQL语句的可读性,减少嵌套冗余。比如sql:with A as ( select * from user ) select * ...
  • Python with用法

    千次阅读 2014-03-07 16:04:57
    Python的with用法,详解!
  • WITH AS 用法

    万次阅读 2011-03-04 13:21:00
    一.WITH AS的含义  WITH AS短语,也叫做子查询部分(subquery factoring),可以让你做很多事情,定义一个SQL片断,该SQL片断会被整个SQL语句所用到。有的时候,是为了让SQL语句的可读性更高些,...
  • sql with as 用法

    万次阅读 2013-11-21 10:45:41
    sql with as 用法(适用sqlserver,好像oracle也适用) Server 2005中提供了公用表表达式(CTE),使用CTE,可以使SQL语句的可维护性,同时,CTE要比表变量的效率高得多。 下面是CTE的语法: [ WITH [ ,n ] ] ...
  • with用法小结

    千次阅读 2018-01-27 01:18:10
    文章转自:...版权归原作者! 一、with表拥有某物 Mary married a man with a lot of money . 马莉嫁给了一个有着很多钱的男人。 I often dream of a big house with a nice garden .
  • python中with用法

    千次阅读 2017-11-23 10:53:05
    刚刚开始学python,今天在一个基础例子中看到了一行代码,觉得很有意思,就去研究了一下with open("../config/name_login.txt",'r') as f:其实这是python中的with语句,类似于php中的try()……catch(),主要是用来...
  • python with as 用法

    千次阅读 2015-11-13 15:16:34
    基本思想是with所求值的对象必须有一个__enter__()方法,一个__exit__()方法。 紧跟with后面的语句被求值后,返回对象的__enter__()方法被调用,这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被...
  • drawInRect:withAttributes用法

    千次阅读 2015-12-21 14:48:08
    iOS--drawInRect:withFont等方法在iOS7.0后背弃用,代替方法drawInRect:withAttributes用法(转载) 1.NSKernAttributeName:@10 调整字句 kerning 字句调整 2.NSFontAttributeName : [UIFont ...
  • satisfy with用法

    千次阅读 2019-08-01 04:30:27
    Other people are satisfied with staying where they are- I'm telling you, these are the people who never get cancer. ---《老友记》第一季 第二集 其他人则安于现状告诉你,这种人不会得癌症。 meet 一般是...
  • SQL语句 with as 用法

    万次阅读 多人点赞 2015-09-23 15:54:10
    一直以来很少使用过with as 的用法,现在打算记录这条语句的使用方法。  比如  with A as (select * from class)  select *from A 这个语句的意思就是,先执行select * from class 得到一个结果,将这个结果记录...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 308,954
精华内容 123,581
关键字:

with的所有用法