精华内容
下载资源
问答
  • 说起js中的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);     //不好,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的操作会导致数据的泄漏呢?

    当我们传递 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(),那么运行起来一定会变得非常慢。无论引擎多聪明,试图将这些悲观情况的副作用限制在最小范围内,也无法避免如果没有这些优化,代码会运行得更慢的事实


     

    展开全文
  • with语句的用法: with context_expression [as target(s)]: with-body  context_expression为上下文表达式,该表达式需返回一个带 上下文管理器的对象,即该对象中实现了__enter()__和__exit()__方法  with...

    with语句的用法:

    with context_expression [as target(s)]:
    
        with-body

     context_expression为上下文表达式,该表达式需返回一个带

    上下文管理器的对象,即该对象中实现了__enter()__和__exit()__方法

     with-body中为执行代码块

    with语句首先执行context_expression,返回一个带上下文管理器的对象,

    接着执行返回对象中的__enter()__方法,若有as子句,则将__enter()__

    方法返回的值赋值给target(s),然后执行with-body中的代码块,最后执行

    context_expression返回对象中的__exit()__方法。例如:

    import requests
    
    r = requests.get("https://github.com/favicon.ico")
    
    with open('favicon.ico','wb') as f: #用open()方法打开一个文件,若无则创建 方法返回值赋给f
        f.write(r.content)

    With 后的open()方法会返回一个文件对象,该对象含上下文管理器,with获得open()对象后,调用对象

    中的__enter()__方法,open中的该方法返回的值为该对象本身,之后将open对象赋值给as后的变量f;

    接着执行with-body中的代码块f.write(r.content);执行完后,再执行open对象中的__exit()__方法,该方法

    会关闭open对象,即__exit()__方法中又调用了open().close()方法。

    with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后自动关闭、线程中锁的自动获取和释放等。

     

    参考文档 :https://www.ibm.com/developerworks/cn/opensource/os-cn-pythonwith/

    展开全文
  • JavaScript中 with用法

    万次阅读 多人点赞 2018-03-28 12:50:09
      说起js中的with关键字,很多小伙伴们的第一印象可能就是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(),那么运行起来一定会变得非常慢。无论引擎多聪明,试图将这些悲观情况的副作用限制在最小范围内,也无法避免如果没有这些优化,代码会运行得更慢的事实

    展开全文
  • 【环境】 ...1,With基本用法 # 在with中使用自定义的类,一定至少要定义__enter__和__exit__两个方法 class A(): def __enter__(self): self.a = 5 return self.a def __exit__(self,...

    【环境】

    Python 3.6.7
    Tensorflow 1.12.0
    

    1,With基本用法

    # 在with中使用自定义的类,一定至少要定义__enter__和__exit__两个方法
    
    class A():
        def __enter__(self):
            self.a = 5
            return self.a
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            print('exit')
    
    with A() as b:
        print(b)
    
    # 输出
    # 5
    # exit

    2,Tensorflow两数相加(为了逐步展示tensorflow基本原理,采用了逐渐复杂的四种方法)

    # 第一种方法
    import tensorflow as tf
    
    a = tf.Variable(1)
    b = tf.Variable(2)
    c = a + b
    
    init = tf.global_variables_initializer()
    
    sess = tf.Session()
    
    sess.run(init)
    
    print(sess.run(c))
    
    # 输出
    # 3
    
    
    
    # 第二种方法,使用with
    import tensorflow as tf
    
    a = tf.Variable(1)
    b = tf.Variable(2)
    c = a + b
    
    init = tf.global_variables_initializer()
    
    with tf.Session() as sess:
        sess.run(init)
        print(sess.run(c))
    
    # 输出
    # 3
    

     

    
    # 第三种方法,使用with 和 placeholder,也是通常的用法
    import tensorflow as tf
    
    a = tf.placeholder(tf.int64)
    b = tf.placeholder(tf.int64)
    
    c = a + b
    
    init = tf.global_variables_initializer()
    
    with tf.Session() as sess:
        sess.run(init)
        print(sess.run(c, feed_dict={a: 1, b: 2}))
    
    # 输出
    # 3
    
    
    # 第四种方法,使用with 和 placeholder,并在tensorboard可视化一下
    import tensorflow as tf
    
    a = tf.placeholder(tf.int16, name='a')
    b = tf.placeholder(tf.int16, name='b')
    
    with tf.name_scope('Add_function'):  # 此声明下面包含的运算在tensorboard计算图中会显示在同一个方块中,如果声明下不包含运算,则不显示方块
        c = a + b
        # c1 = tf.reduce_mean(c)  # 求c中所有元素均值,可以用来将传入的参数转化为一个数值,按需使用
        tf.summary.scalar('result', c)  # tf.summary.scalar(tags, values)两个参数:第一个参数表示在tensorboard中显示的名字,第二个参数loss应为一个标量,即一个数值,否则报错
    
    init = tf.global_variables_initializer()
    
    merge = tf.summary.merge_all()
    
    with tf.Session() as sess:
        sess.run(init)
        summary_writer = tf.summary.FileWriter(logdir='logs', graph=sess.graph)
        summary, result = sess.run([merge, c], feed_dict={a: 1, b: 2})
        summary_writer.add_summary(summary)
        summary_writer.close()
        print(result)
    
    # 输出
    # 3
    
    # 第四种方法会在程序所在目录生成logs文件夹,打开终端,进入程序所在目录(logs所在的目录)
    # $ cd 程序所在目录
    # $ tensorboard --logdir logs
    
    # 终端输出为:
    # TensorBoard 1.12.2 at http://xxxx:6006 (Press CTRL+C to quit)
    

    # 在浏览器打开http://localhost:6006/ 即可看到曲线图和计算图,本例中曲线只有1个点,即求和的结果3
    # 注意每次运行程序都会在logs文件夹下生成1个文件,如需修改程序并在浏览器看新效果,需要先清空logs文件夹再运行修改后的程序,之后再在浏览器查看效果

     

    第四种方法对应的图

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

    其他:

    1,同时看多个tensorboard(打开其他端口):

    # tensorboard --logdir=tmp --port=6005
    
    # tmp是当前目录中包含 events.out.tfevents.xxxx.xxxpc 类似文件的文件夹

    参考:https://blog.csdn.net/feynman233/article/details/86480974

    2,在一个tensorboard中显示多条曲线

    参考:https://blog.csdn.net/shahuzi/article/details/81223980#commentBox

    3,模型训练结束之后产生的静态event文件也可以通过tensorboard进行查看。如果复制网址到浏览器,tensorboard页面无法显示,可以试试绝对路径:

    tensorboard --logdir=D:\Projects\xxx\logs --port=6005

    4,Tensorboard界面说明:https://blog.csdn.net/qq_33039859/article/details/80277379

    5,Tensorboard中同时看多条曲线:

    D:\tmp\retrain_logs>tensorboard --logdir=. # 点号.代表当前文件夹

    retrain_logs下有两个文件夹,每个文件夹下都有一个event文件。这样写能让两条曲线显示在同一个页面中,并且可以自由选择显示什么曲线。参考链接。

    6,【远程使用tensorboard】

    # 从本地登录到服务器,用端口转发的方式登录。将远程服务器(xx.xxx.xxx.xx)的6009端口转发到本地的8001端口
    # 在本地终端运行下面的命令(xxx是登录远程服务器使用的用户名),比如在moba xterm中新建一个terminal,输入:
    ssh -L 8001:localhost:6009 xxx@xx.xxx.xxx.xx
    # 此时已经把服务器对应的6009端口映射到了本地的8001端口
    # 可能需要输入密码才能登录(如果之前没有在moba xterm中保存过密码的话)
    
    # 此时已经进入服务器命令界面(因为已经登录)
    # 进入tensorflow训练产生的log文件所在的上级目录,如folder1
    # folder1中可以包含多个子文件夹,每个子文件夹中都有单独的log文件,这样可以在一个tensorboard浏览器界面中同时对比查看多条曲线。
    # 在服务器终端输入:
    $ cd ~/projects/folder1
    
    # 可视化log文件,继续在服务器终端输入:
    $ tensorboard --logdir ./ --port=6009
    
    # 在本地浏览器输入:
    http://127.0.0.1:8001/
    
    
    #【致谢】https://blog.csdn.net/zhaokx3/article/details/70994350

     

    展开全文
  • DROP TABLE #temp; with cr as ( SELECT At.SysNo AS AtSysNo , ( CASE WHEN At.Source = 1 THEN At.VendorSysNo ELSE At.DistributorSysNo ...
  • DB2 with用法

    2019-03-07 10:08:01
    1.with理解与基本用法 说起WITH 语句,除了那些第一次听说WITH语句的人,大部分人都觉得它是用来做递归查询的。其实那只是它的一个用途而已, 它的本名正如我们标题写的那样,叫做:公共表表达式(Commo...
  • js中 with用法

    2019-04-12 10:59:19
    with基本用法 with 语句的原本用意是为逐级的对象访问提供命名空间式的速写方式. 也就是在指定的代码区域, 直接通过节点名称调用对象。 with 通常被当做重复引用同一个对象中的多个属性的快捷方式,可以不需要重复...
  • python中with用法

    2019-10-09 18:02:42
    with用法with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后自动关闭、线程中锁的自动获取和释放等。 With语句的基本语法格式: with ...
  • oracle 基本用法

    2019-09-26 00:32:32
    with as的用法  with as 是在内存中会间理一个临时表,基本使用: with temp_table as (select * from table) select * from temp_table  如果需要建立多个临时表,则使用: with temp_tablea as...
  • python with as用法

    2019-04-04 14:46:31
    基本思想是with所求值的对象必须有一个__enter__()方法,一个__exit__()方法。 紧跟with后面的语句被求值后,返回对象的__enter__()方法被调用,这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被...
  • With 用法

    2010-06-26 23:14:13
    基本语法: WITH subquery_nameAS(the aggregation SQL statement)SELECT(query naming subquery_name); 示例: With a as (...
  • Glide基本用法

    2018-10-31 15:15:44
    转发 ...这篇文章介绍了基本用法,但是最新的4.8.0版本不可以如下调用.error .placeholder Glide.with(this) .load(url) .placeholder(R.drawable.loading) .error(R....
  • sgdisk基本用法

    万次阅读 2017-07-28 17:09:55
    sgdisk基本用法简介sgdisk是Linux下操作GPT分区的工具,就像fdisk是操作MBR分区的工具。关于GPT和MBR的区别请参考: ...
  • python with as 用法

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

    2017-10-19 12:43:22
    基本思想是with所求值的对象必须有一个__enter__()方法,一个__exit__()方法。 紧跟with后面的语句被求值后,返回对象的__enter__()方法被调用,这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全
  • Webpack基本用法

    2019-08-13 22:20:48
    本篇体验Webpack的基本面以及一个例子。 ■ What is Webpack ● module bundler● module with dependencies● module generates static assets ■ Why Webpack ● good for development but also the ...
  • listview基本用法

    2010-11-28 14:33:06
    Delphi ListView基本用法大全(转)默认分类 2009-09-29 09:27:56 阅读138 评论0 字号:大中小 订阅 Delphi高级编程 Delphi文章 WEB开发 Delphi控件 Delphi ListView基本用法大全 作者:seeker 日期:2009...
  • NSInvocation基本用法

    2017-12-23 16:10:46
    一种是performSelector:withObject; 再一种就是NSInvocation。 第一种方式比较简单,能完成简单的调用。但是对于&gt;2个的参数或者有返回值的处理,那performSelector:withObject就显得有点有心无力了,那么在...
  • SQL With Ties 用法

    2010-12-22 09:49:00
    指定从基本结果集中返回附加的行,这些行包含与出现在 TOP n (PERCENT) 行最后的 ORDER BY 列中的值相同的值。如果指定了 ORDER BY 子句,则只能指定 TOP ...WITH   相当于下面实现的功能: ...
  • oracle 中start with用法

    千次阅读 2013-12-10 12:26:22
    基本用法~~~~~~~~~~~~~~~~~~~~~~ SELECT * FROM tree -- where 子句 , 若有,只是过滤最终结果的作用 START WITH father = '爷爷' -- 从 father 为 '爷爷' 的 那一条记录开始 -- 若有 nocyle 关键字, 则不走环, ...
  • db2 With定义与用法

    2019-05-07 17:34:41
    1.with理解与基本用法 说起WITH 语句,除了那些第一次听说WITH语句的人,大部分人都觉得它是用来做递归查询的。其实那只是它的一个用途而已, 它的本名正如我们标题写的那样,叫做:公共表表达式(Common Table ...
  • python 中 with用法 with 的目的是从流程图中把 try, except, finally 关键字和资源分配释放相关代码统统去掉,简化 try, except, finally 的处理流程。 with 语句适用于对资源进行访问的场合,确保不管使用过程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,299
精华内容 519
关键字:

with基本用法