作用域

var a=1,b=1；与var a=b=1; 在工作中第一种写法比较常见，但是我们偶尔也图方便用到第二种写法，以前以为他们表达的语义是一样的，实际操作中发现不太一样，上例子说明： 1 console.log(a, b); 2 var a = 1, b = 1; 3 function fn() { 4 console.log(a, b); 5 var a = b = 2; 6 console.log(a, b); 7 } 8 fn(); 9 console.log(a, b); 看到上面一段代码，有一点开发经验的可能会脱口而出，从上至下： 很明显，既然这样问了，这个答案就不准确 变量提升： 当栈内存(作用域)形成，JS代码自上而下执行之前，浏览器首先会把所有带 var/function 关键词的进行提前 声明 或者 定义 ，这种预先处理机制称之为 变量提升 声明： var a （此时a=undefined） 定义： a=2（没有声明，所以放在哪里都是全局变量） var： 只声明未定义 funtion： 声明和赋值都完成了 变量提升 只发生在当前作用域，开始加载页面的时候 全局作用域是当前作用域 ，所以只会对全局作用域下的进行提升，因为变量提升是 发生在当前作用域 ，因为此时函数是私有作用域，没有任何提升行为，函数中的代码只是存储的字符串而已 在全局作用域下声明（var

阅读目录 　楔子 　命名空间和作用域 　函数嵌套及作用域链 　函数名的本质 　闭包 　本章小结 返回顶部 楔子 假如有一个函数，实现返回两个数中的较大值： def my_max(x,y): m = x if x>y else y return mbigger = my_max(10,20)print(bigger) 之前是不是我告诉你们要把结果return回来你们就照做了？可是你们有没有想过，我们为什么要把结果返回？如果我们不返回m，直接在程序中打印，行不行？ 来看结果： >>> def my_max(x,y): ... m = x if x>y else y ... >>> my_max(10,20) >>> print(m) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'm' is not defined 报错了！错误是“name 'm' is not defined”。变量m没有被定义。。。为啥？我明明定义了呀！ 在这里我们首先回忆一下python代码运行的时候遇到函数是怎么做的。 从python解释器开始执行之后，就在内存中开辟了一个空间 每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来。 但是

1.let name //不能重复声明，变量，块级作用域，可以修改。 2.const name //不能重复声明，常亮，快级作用域，不可以修改。 来源：博客园 作者： 765427457 链接：https://www.cnblogs.com/shangmao/p/11586788.html

for ( var i = 0 ; i < btnArr . length ; i ++){ btnArr [ i ]. addEventListener ( 'click' , function (){ tabCardShow ( i ); })； } 普通的for循环，触发事件时传入的 i 的值一定是等于 btnArr.length ，i 的值停留在了循环执行完毕之后，并不符合初衷。 原因：i只作用于 for循环的作用域，所有 元素绑定时传入的都是该作用域的同一个 i 值，而 i 值停留在了循环最后一次的值上。 for ( var i = 0 ; i < btnArr . length ; i ++){ ( function ( i ){ btnArr [ i ]. addEventListener ( 'click' , function (){ tabCardShow ( i ); }) })( i ); } 原因：闭包传入i值，相当于每次循环都创造了一个作用域，向传入了 i 值，避免了污染，循环了多少次 ，就有多少个作用域，就有多少个 i 值。 来源：博客园 作者： 见信 链接：https://www.cnblogs.com/JianXin1994/p/11576077.html

C语言常见问题 问题： 在学习Java语言的时候，会用一节讲java语言的作用域，但是C语言却没有。那么C语言有作用域么，和java语言有什么区别？ 代码1 （我们常这样写） # include <stdio.h> //代码1 int main ( int argc , char * argv [ ] ) { int i = 20 ; for ( int i = 0 ; i < 5 ; i ++ ) { //在for里面初始化一个i，和main里面的不同。 printf ( "i = %d\n" , i ) ; } return 0 ; } 运行结果 bao:day0920 bao$ gcc -o test1 test1.c bao:day0920 bao$ ./test1 i = 0 i = 1 i = 2 i = 3 i = 4 代码2 # include <stdio.h> //代码2 int main ( int argc , char * argv [ ] ) { int i = 20 ; //在main函数初始化一个变量i； for ( i = 0 ; i < 5 ; i ++ ) { //在for的作用域里面，将main的i再次赋值为0； printf ( "i = %d\n" , i ) ; } return 0 ; } 运行结果 bao:day0920 bao$

{ var "小花" ; let "小明" ; //小花 //小明 } //小花 //Error:str2 is not defined let作用域仅限于当前代码块，而var的作用域是全局的 let不能被重复定义 来源：博客园 作者： 十八岁少年 链接：https://www.cnblogs.com/lee1-w/p/11525285.html

什么是闭包函数？ 闭包函数是一种函数的使用方式，最常见的如下： function fn1(){ function fn(){ } return fn; } 这种函数的嵌套方式就是闭包函数，这种模式的好处是可以让内层函数访问到外层函数的变量，并且让函数整体不至于因为函数的执行完毕而被销毁。 例如： function fn1(){ var a =10; function fn(){ console.log(a); // 10 } return fn; } 再比如下面的代码，随着函数的每次执行，变量的值都会进行递增1，原因是因为外层函数的变量处于内层函数的作用域链当中，被内层函数所使用着，当js垃圾回收机制读取到这一情况后就不会进行垃圾回收。 例如： function fn1(){ var a = 1; function fn(){ a++; console.log(a); } return fn; } // 调用函数 var x = fn1(); x(); // 2 x();//3 闭包函数在js的开发当中是非常常见的写法，例如下面这种写法，功能是实现了对数组的一些常规操作的封装，也是属于对闭包函数的一种应用。 let Utils = (function(){ var list = []; return { add:function(item){ if(list.indexOf

昨日回顾 初识函数 定义: 对动作或者功能的封装. 语法: def 函数名(形参): 函数体(return) 函数名(实参) 形参: 在函数声明的位置写的变量 1. 位置参数 2. 默认值参数. 实参: 在函数调用的位置给出的具体的值 1. 位置参数 2. 关键字参数 3. 混合 位置, 关键字 传参: 把实参传递给形参的过程 return: 返回, 程序如果运行到return, 函数结束运行. 1. 当我的函数不写return, 表示默认返回None 2. 函数中写return, 返回None 3. return 值, 有一个返回值 4. return 值1, 值2, 值3 多个返回值, 返回的是元组 View Code 今日内容 1. 动态传参(重点) *, ** *, ** : 形参: 聚合 位置参数* -> 元组 关键字** -> 字典 实参: 打散(##动态参数的另一种传参方式,第一种是直接传递多个位置参数或关键字参数) 列表, 字符串, 元组 -> * 字典 -> ** 形参顺序(重点): 位置, *args, 默认值, **kwargs 无敌传参 def func(*args, **kwargs): arguments参数 keyword-arguments关键字参数 pass ## 所谓的接收动态位置参数或者说接收动态关键字参数是指的实参(手动重点:位置,关键字)

作用域 >>> x = 1 >>> scope = vars() >>> scope['x'] 1 >>> scope['x'] += 1 >>> x 2 警告 　 >>> def foo(): x = 42 ... >>> x = 1 >>> foo() >>> x 1 >>> def output(x): print(x) ... >>> x = 1 >>> y = 2 >>> output(y) 2 >>> def combine(parameter): print(parameter + external) ... >>> external = 'berry' >>> combine('Shrub') Shrubberry 警告 　 “遮盖”的问题 >>> def combine(parameter): ... print(parameter + globals()['parameter']) ... >>> parameter = 'berry' >>> combine('Shrub') Shrubberry 重新关联 >>> x = 1 >>> def change_global(): ... global x ... x = x + 1 ... >>> change_global() >>> x 2 def foo(): def bar(): print("Hello

#define #define macro的作用域有点类似于C/C++全局静态变量 编译器处理宏的时机是预处理阶段 编译器按文本顺序处理 遇到宏时就定义一个宏变量 假设这种情况 void test() { #define MACRO 1 } int main() { #ifdef MACRO // do some thing #endif } main函数也是看得到MACRO宏的 因为文本顺序上test在前 编译器处理到test时定义了一个宏变量 使得main也能“看见“这个宏 假如把顺序交换 int main() { #ifdef MACRO // do some thing #endif } void test() { #define MACRO 1 } main就看不见MACRO宏了 不同源文件中的宏 不同源文件是看不到互相定义的宏的 除非将宏定义在了头文件中 宏的机制类似于全局变量 一般情况不会暴露给另一个源文件 除非你特意在头文件中暴露了它 #a.c #define CX 1 #b.c int main() { #ifdef CX //不会被执行 因为看不到这个宏 #endif }