JS基础总结
本人码皇，新人，初识JS，被迫含泪总结。如有错误，不许骂我，如果看官干椒还可以请用三连，打赏侮辱我（使劲，用力，我受得了）。
目录给这呢
JS介绍
布兰登.艾奇(Brend Eich,1961~)用十天写出来的（真是草率）；js（javaScript（听说当年java为了蹭热度才在前面加上啦java））是运行在客户端的 脚本语言（脚本语言不应编译）大概就这了其他自己百度去。（我只知道这些，对不起）
JS作用
js可以干嘛呢 **
1）开发网站
2）开发app
3）小程序
4）游戏开发 小程序游戏 网页游戏
5）写后端 node.js
6）嵌入式 c
7）区块链**
JS结构
javaScript包括三部分ECMAScript javascript的语法，DOM 页面文档对象模型，BOM阅览器对象模型
JS与HTML和CSS的区别
和html,css对比：
相同：html,css,js代码都可以在浏览器中运行，html，css，js它们的运行环境是浏览器
不同点：html，css 不叫编程语言 js是编程语言 js的运行环境不只浏览器，还可以在其它的环境中支行。
JS书写方式和语法
js的书写方式
1）把js写在html文件中 学习时通常就写在script标签中(内部写法)
2）把JS写在JS文件中，然后在html文件中通过script标签引入 写项目时通常会把JS写在一个单独的文件中（外部写法）
3）把JS代码写在开始标签中，当成开始标签的属性（行内写法）
基本语法：
1）JS是区分大小写 var a = 1; var A = 2;
2）忽略空白符（空格 换行 tab）
3）语句分号可加可不加
4）注释 单行注释 多行注释 注释是给程序员看的
5）标识符 和 关键字 var a = 110; var 关键字 a变量名标识符
JS变量
JS变量定义
数据：一个软件打开后，界面上有很多的数据，也叫状态，这个状态可以保存在两个地方，一个是内存，一个是硬盘
内存中的数据，一断电，数据就没了，
还有一个地方，也可以保存数据，是硬盘，硬盘上的数据断电是不会丢失的。
项目运行起来，只有把数据加载到内存中，才使用使用数据。
内存空间地址：就是一块内存空间的地址，可以通过地址操作它对应空间中的数据，使用地址来操作非常不方便，指针。
变量：变量就是内存中的一个空间。
变量名：内存空间的别名 对变量名的操作就是对内存空间的操作
变量值：存储在内存空间中的状态（数据）
在JS中，如何定义变量：
var a = 110; // 定义了一个变量 变量的名是a 变量的值是110;
JS变量的分类
变量的分类：
1）全局变量
2）局部变量
判断分界点是：函数
只要把带var的变量写在函数里面就是局部变量，只要写在函数外面就是全局变量。
// 全局变量
var address = "郑州";
// 定义函数 函数必须通过函数进行声明
function f() {
// 函数内部的变量叫局部变量
var m = 111; // 局部变量
a=2//虽然在函数里但是没带var就是全局变量
}
if(true){
var k = 123; // 全局变量
}
for(var i=0; i<10; i++){ // i全局变量
var o = 666; // o是全局变量
}
</script>
// 声明一个变量
var a = 110;
// 声明一个函数
function f() {
//在函数里面访问全局变量
console.log(a);
var b = 666; // 局部变量
console.log(b); // 函数内部是可以访问到局部变量
}
// 调用函数
f() // 一个函数没有调用相当于这个函数没有写
// 在函数外面访问全局变量
console.log(a);
console.log(b); // b is not defined 函数外面是访问不了函数里面的变量
</script>-->
<!--<script>
// 单独声明
var name = "xiaoqiang";
var age = 110;
var address = "北京";
// 连续声明
var m = 1, n = 2;//等价于 var m=1；var n=2；
var m=n=1 //等价于 var m=1 ；n=1；
// 不使用var
k = 123; // 如果没有加var 此时这个变量只能是全局变量 不管你是写在函数内还是写在函数外
</script>
全局变量和局部变量有什么特点：
1）全局变量可以在函数内部都能访问到
2）局部变量只能在函数内部访问到
js的书写
JS数据类型
JS数据类型定义与分类
为什么需要数据类型：
age 10
id 3456783456783456789
为了更加合理使用内存空间，基本上所有的编程语言中都提出
数据类型的概念，研究针对不同的数据，分配不同的空间。
JS中的数据类型：
基本数据的类型：（存储在栈里的）
number 数字 var a = 110; int a = 110;
string 字符串 ”“ ‘’ JS中不分字符和字符串 都叫字符串
boolean true false 布尔类型
undefiend 没有值
null 没有值
引用数据类型：（储存在堆里）
object 对象
array 数组
function 函数 在JS中函数也是一种数据类型
JS中基础数据类型：number型
number（默认值为0对于布尔值来说0就是false，其他数字就是true）
1）number是一个数据类型，这个数据类型对应的值有无数个。
2）在JS中number数据类型是不分整数和小数 都是number
3）可以通过typeof查看一个变量值的数据类型
4）最大值 和 最小值
5）number可以通过不同进制显示 进制 10进制 2进制 16进制 8进制
6）NaN Not a Number 不是一个数字
7）JS中不要对小数运算 要运算先转成整数 得到的结果往往不对
在JS中，说到数据类型，主要指变量值的数据类型。
typeof是运算符 + - * / 都是运算符
Number叫类，也叫构造器，也叫函数
代码后面的//是这一行的输出结果
var a = 110; // 110是一个数据 这个数据的类型是number
var b = 3.14; // 3.14也一个number数据
console.log(a);
console.log(typeof a)
console.log(Number.MAX_VALUE)
console.log(Number.MIN_VALUE)
var c = 123; // 123是10进制
var d = 0x123; // 16进制 0~f 以零x打头
console.log(d); // 291
var e = 0123; // 8进制 以零打头
console.log(e); // 83
console.log("abc"*100) // NaN
// == 是运算符 判断两则的数是否相等
// 关系运算符 得到结果是true或false 1>2
console.log((1-0.7) == 0.3) // false
</script>
JS中基础数据类型：string型
string类型
1）在JS中 使用‘’ “”把字符串包起来 不包 JS会给它当成变量
2）单引号不要嵌套单引号 双引号不要嵌套双引号 外单内双 外双内单
3）string数据类型对应的数据有无数个
// var addrss = beijing; // beijing is not defined这个没有加引号
// console.log(addrss);
// var a = "hello "abc"js"
var a = "hello 'abc' js"
console.log(a);
</script>
JS中基础数据类型：Boolean型
Boolean类型
1）boolean数据类型对应的值就两个 true false
2）true 和 True 不一样的 JS是区分大小写的
var b = true;
console.log(b);
console.log(typeof b);//boolean
</script>-->
JS中基础数据类型：undefined型
undefind
1）undefiend是一个数据类型，这种数据类型对应的值是undefiend
2）什么时候会出现undeined?
答：一个变量没有赋值 它的值是undefiend 这个值的类型是undefiend
var a;
console.log(a); // undefined 值
console.log(typeof a); // undefined 是类型
</script>-->
JS中基础数据类型：null型
null也表示是空
null突出变量的值是不存在的
Number(null) // 0
5 + null // 5
JS数据引用类型：object
object类型存放在堆里的
例如字符组，函数都是引用型
JS的数据类型转化（隐式转化与强制转化）
JS是编程语言（动态语言，变量的数据类型是可以转化的）
数据类型转化
隐式类型转化：静悄悄地，不知不觉地就进行了类型转化
强制类型转化：写代码进行转化
在JS中，下面的值转成false其它值都转成true:
0 -0
""
undefiend
null
转化的前提：在JS中，运算符两侧需要保存数据类型一致，如果不一致，JS解释器会帮你把一个数据类型转成另一个数据类型。
–>
隐式类型转化
+ 叫运算符 123操作数 "abc"也叫操作数
一个运算符如果有两个操作数，这个运算符叫二元运算符，也叫二目运算符，还叫双目运算符
**+ - =**都可以造成隐式转换
如果一个运算符只有一个操作数，这个运算符叫一元，单目运算符
// 有：typeof ++ --
</script>
// +是双元运算符 运算符你要保证两侧操作数的数据类型要一致
// var res = 123 + "abc"; //(123隐式转化成字符串)
// console.log(res); // 123abc
// console.log(typeof res); // string(字符的类型装换为string)
// var isMerry = true;
// if(isMerry){ // 语句
// // 如果if后面的（）里面是true 执行{}里面的代码
// console.log("结婚了....")
// }else{
// console.log("没有结婚....")
// }
// var isLove = "";//0,-0,"",'',undfine,null
// // if后面的小（）里面要么放true 要么放false
// // if后面小（）里面放了一非布尔类型的值，也会进行隐式类型转化
// if(isLove){
// console.log("是真爱");
// }else{
// console.log("是骗子");
// }
// 1>2 没有类型转化 > 运算符 关系运算符 返回的就是布尔值
// if(1>2){}
强制类型转化通过函数强制转换
/* console.log(parseInt(3.14)); // 把小数转成整数
console.log(parseInt("3.14abc")); // 尝试把字符型小数或非数字转成整数
console.log(parseFloat(3))//3
console.log(parseFloat("3.14abc"))//3.14
console.log(Number("abc123")) // NaN
console.log(Number("123abc")) // NaN
console.log(Number("123")) // 123
console.log(String(123456)) // 123456
</script>-->
对于number来说0就是false 其他的数字都是true
对于undefined，null，false，0，NaN，""或’’（空字符串）转出来的都是false
JS初步执行
JS代码在执行时分两个阶段：
1）预编译
2）代码执行
每一个阶段做的事情是不一样的。
补充概念（很重要偶，你要是实在看不懂可以看后面的图）
（无论是变量还是函数）定义=申明+赋值
var a=1;//这就是一个定义变量
var a //这个是申明
=1//才是赋值这个很重要，后面会用到
1什么是ECstrack就是执行代码会产生一个栈，我们可以形象的比喻为一个杯子
2什么是EC（G）首先EC（G）是存在于ECstrack里面的一个鸡蛋，这里面放的是全局加var的和function申请的函数的存放的地址，也是一个栈。
3什么是EC（函数名）呢，首先EC（G）是存在于ECstrack里面的一个鸡蛋，他是执行调用函数的时候产生的栈（每执行一个函数就会产生一个EC（函数名）也就是一个栈）是存储函数执行上下文里加var的变量和function申请的函数存放的地址的数据。
4什么是vo，vo是放在EC（G）里的，用来存储全局变量全局加var的和function申请的函数存放的地址的数据也就是ECG里放东西的容器
5什么AO vo是放在EC（函数名）里的，用来存储局部变量加var变量的和function申请的函数存放的地址的数据也就是EC（函数名）里放东西的容器
6什么是G0 存放全局的数据，加var 的全局变量，函数的堆地址，还有不加var的全局变量。
7什么提升： 提升就是把全局变量里的带var变量的申明提升到代码的最前面，还有全局里的函数（整个函数提升到代码最前面），还有局部也是函数里的带var的变量的申明提升都函数的最前面，这个是提升。
（你要是感觉不懂那你自己看看图）
定义变量和声明变量：
定义变量：var a = 110; 定义 = 声明+赋值
声明变量：var a = 110; 说的声明仅仅是说var a 后面是赋值
第一步预编译
把加var的变量进行提升 变量声明会提升 变量的赋值是不会提升
提升到了代码段最前面
把使用function声明的函数进行提升 提升的是整个函数声明
第二步执行
一行一行执行
<script>
console.log(a); // und
var a = 110;
console.log(a); // 110
f();
//使用function声明了一个函数
//函数名是f 函数值是{}
// 定义了一个函数f
function f() {
console.log("f...")
}
</script>
<script>
// g 是
console.log(g); // undefined
g(); // undefied() g is not a function
// = 赋值运算符 先看后面
// 函数也是数据 数据类型是引用数据类型object
// 把数据赋值给变量g
var g = function () { // 这里提升的是声明 g
console.log("g...")
}
// function f() {
//
// }
f(); // 函数调用 函数名+（）
</script>
// 在计算机中对于+1 和 -1用的非常多 所有大多数编程语言都对+1操作进行封装
// 封装了++和--
// ++ 和 -- 是运算符 是单元 看操作数个数
// var a = 1;
// // a = a+1;
// a++;
// a++;
// console.log(a);
// var i = 0;
// i++; // ++可以放在前面，也可以放到后面
// ++i;
// console.log(i);
// ++在前和++在后，对于i的值来说，都是加1操作
// 整体也有一个值 此时++在前和++在后就不一样
// var i = 0;
// var r1 = i++; // i++整体也有一个值
// var r2 = ++i; // ++i整体也有一个值
// console.log(i); // 2
// console.log(r1); // ++在后，整体的值是一个旧值 0
// console.log(r2); // ++在前，整体的值是一个新值
</script>-->
<script>
var a = 12,
b = 13,
c = 14;
function fn(a) {
console.log(a,b,c);
a = 100;
c = 200;
console.log(a,b,c);
}
b = fn(10);
console.log(a,b,c);
</script>
我们来详细的执行一下这个代码看图（太多了还是有点点没有详细的解释，特别是局部里面没有的要到父类ECg里去找）
执行拓展（加var与不加var区别）
1）在全局代码中，加var会提升，没有var的不会提升。
console.log(a);//没有提升a 所以a相当于还没有申明，所以输出 a is not defined
a = 110; // a is not defined
2）不管加没加var的全局变量，都会作为window的属性
var a = 1;
b = 2;
console.log(window.a)//1
console.log(window.b)//2
3）没有加var的变量，只能作为全局变量，只要是全局变量，肯定是window的属性
function f() {
a = 666;//是全局变量因为他没有加var
}
f()
console.log(window.a)//666
4）加var的局部变量，不会作为window的属性
function f() {
var a = 666;
}
f()
console.log(a)
访问一个对象上不存在的属性，结果就是und
console.log(window.a) // undefined
</script>
零碎总结
什么是代码段
一个script标签就是一个代码段。
JS代码在执行时，是一个代码段一个代码段执行。
<script>
var a = 1;
console.log(a);
</script>
<script>
var b = 2;
console.log(b);
</script>
函数是任何编程语言都有概念
// 在JS中定义函数有两种形式
// 函数定义
// 函数表达式
// 函数定义 f叫函数名 ()是函数特有的标识 {} 叫函数体
// 定义 = 声明 + 赋值
// function f() {
// console.log("hello")
// console.log("js")
// console.log("vue")
// }
函数调用
// f(); // 调用函数时，就会把函数体中的代码都执行了
函数的返回值
// function f() {
// return 666;
// }
// // 函数的返回值是返回到了函数调用处
// var a = f(); // 函数调用
// console.log(a);
// console.log(f()); // f()得到的就是函数的返回值
// 一个函数如果没有返回值，默认返回undefiend
// function f(){
// }
// console.log(f()); // undefined
und出现的地方？
// 答：一个变量没有赋值 值就是und 一个函数没有返回值，也是返回und
给函数传递数据
function f(a,b) { // a b叫形式参数 形参
// 形参就是函数内部的局部变量
return a+b;
}
// 1 2叫实际参数 实参
var r = f(1,2); // 函数调用的过程就是实参向形参赋值的过程
console.log(r);
const与let的总结
let申明的是一个变量
1）let声明的变量没有提升(let声明的变量也提升，仅仅是没有初始化)
// console.log(a);
// let a = 110; // Cannot access 'a' before initialization
2）let 配合 {} 也可以形成块级作用域
// if(true){
// var a = 110; // 全局变量
// // b只能在当前的{}中被访问到 出了块就访问不了
// let b = 666; // let + {} 形成块级作用域
// }
// console.log(b); // b is not defined
3）使用let声明的变量不会挂载到GO上
// let a = 110;
// console.log(window.a); // undefined 访问一个对象上没有属性，得到的就是und
4）使用let不能重复声明
// let a = 1;
// let a = 2;
// console.log(a); // Identifier 'a' has already been declared
// 访住：不要使用var来定义变量 使用let声明变量
const是声明一个常量
// const a = 110; // 定义了一个常量（不会改变的量）
// a = 666;
// console.log(a); // TypeError: Assignment to constant variable.
1）也没有提升
// console.log(a);
// const a = 1; // Cannot access 'a' before initialization
- 也会形成块级作用域
// if(true){
// const a = 111;
// }
// console.log(a); // a is not defined
3）使用const声明的常量不会挂载到GO上
// const a = 1;
// console.log(window.a); // undefined
4）使用const不能重复声明
// const a = 1;
// const a = 2;
// // Identifier 'a' has already been declared
// console.log(a);
5)const在声明常量时，必须赋值
// const a;
// a = 1;
// console.log(a)
// 用法：声明变量使用let 声明常量使用const 不要用var
js面试题总结
var a = 1;
var b = 1;
function f() {
console.log(a, b)
var a = b = 2;
console.log(a, b)
}
f();
console.log(a, b)
// var a = b = 2; // var a=2; b = 2;
// var a=2, b = 2; // var a=2; var b = 2;
<!--<script>
debugger
var a = 1;
var obj = { name:"wangcai" };
function f() {
var a2 = a;
obj2 = obj;
a2 = a;
obj.name = "xiaoqiang";
}
f();
console.log(a);
console.log(obj);
</script>
/* var a = 12;
var b = a;
b = 13;
console.log(a);*/
/*var a = {n:12};
var b = a;
b.n = 13;
console.log(a.n);*/
/* var a = { m:666 };
var b = a;
b = { m:888 };
console.log(a.m);*/
var a = { n:110 };
var b = a;
b.m = b = { n:666 };
console.log(a);
console.log(b);
// a = b = c = 1;
// 赋值运算符有副作用：整体也会有个值，这个值是右值
// c = 1; 整体有个值
// c最终的是1 c=1整体的值也是1
// a = b = c = 1; // 同时进行
</script>
// bug 虫子 debug
debugger
var i = 5;
function fn(i) {
return function (n) {
console.log(n+(++i));
}
}
var f = fn(1);
f(2);
fn(3)(4);
fn(5)(6);
f(7);
console.log(i);
// 一部分人是这么认为：
//在一个函数内部嵌套了一个函数，并且里面的函数引用外面的函数的变量
//里面的函数就可以叫闭包
// function f() {
// var i = 1;
// function g() {
// console.log(i)
// }
// }
// 还有一部分人是这么说：一个局部执行上下文就是一个闭包
</script>-->
<!--<script>
var i = 20;
function fn() {
i -= 2;
var i=10;
return function (n) {
console.log((++i)-n);
}
}
var f = fn();
f(1);
f(2);
fn()(3);
</script>-->
<!--<script>
let x = 5;
function fn(x) {
return function (y) {
console.log(y+(++x));
}
}
let f = fn(6);
f(7);
fn(8)(9);
f(10);
console.log(x);
// 14 18 18 5
</script>-->
<!--<script>
let x = 5;
function fn() {
return function (y) {
console.log(y+(++x));
}
}
let f = fn(6);
f(7);
fn(8)(9);
f(10);
console.log(x);
// 13 16 18 8
</script>-->
<script>
let a = 0;
b = 0;
function A(a) {
A = function (b) {
alert(a+b++)
}
alert(a++)
}
A(1);
A(2);
// 1 4
</script>
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
