Yapei Li

专注于前端领域

0%

js基础4、值类型、堆、栈、判断语句、循环语句

发表于 分类于
本文字数： 4.7k 阅读时长 ≈ 4 分钟

值类型（基本数据类型）：基本数据类型的值会存储在当前作用域下

var a=12;

  1. 首先在当前作用域下开辟一个空间存储12
    2）在当前作用域中声明一个变量a
    3）让声明的变量和存储的12进行关联

    直接按置操作：把原有的值复制一份，放在新的空间位置上，和原来的值没有关系，变量间相互不影响

    一个变量只能存一个值

对象数据类型（引用数据类型）：按内存空间【引用地址】地址来操作

引用数据类型不能直接存储到当前作用域（因为存储的内容过于复杂），我们需要新开辟一个空间把内容存储在这个空间中

js遇到对象：

1、先创建一个变量（声明一个函数名和声明一个变量一样 ，如果两个变量名重复 是会冲突的）
2、浏览器为其开辟一个新的内存空间，为了方便别的地方找到这个空间 会给空间分配一个16进制的地址 （16进制：0-9 a-f）
3、按照一定顺序，把对象中的键值对存到内存空间
4、把开辟内存的地址赋值给变量（或者其他的东西比如事件），以后变量就可以通过地址找到内存空间然后进行操作

操作的是空间的引用地址：把原来空间地址赋值给新变量，但是空间没有被克隆，还是一个空间，这样就会出现多个变量关联的是相同的空间，相互之间就会存在影响

栈内存、堆内存

栈内存：本身就是一个供js代码执行的环境，所有的基本数据类型都会在栈内存中开辟一个位置进行存储;作用域就是一个栈内存

堆内存：用来存储引用类型中的信息值的，对象存储的是键值对，函数存储的是代码字符串

判断操作语句

if、else if、else

如果好几个条件都成立了，只把第一个成立的条件执行，后面成立的条件忽略不管

条件的写法：

A==B,A!=B,A>=B,A<=B,

if(A)先把A转化为布尔类型判断真假以此来决定条件是否成立

if(A>B && A<10) 只有两个小条件都是真整体才是真

if(A>B || A==0)只要其中一个小条件成立，整体就是真

1
2
3
4
5
6
7
8
9
10

if(条件1){
    //条件1成立执行的操作
}else if(条件2){
    //上面的条件不成立，条件2成立，执行的操作
}
...
else{
    //以上条件都不成立执行的操作
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var num = parseFloat('width:12.5px');
if(num==12.5){
    alert(12.5)
}else if(num==NaN){
    alert(NaN)
}else if(typeof num == 'number'){
    alert(0)
}else{
    alert('啥也不是')
}
//考查到了 parseFloat机制  得出NaN
//考查到了 NaN==NaN  为false
//考查到了 typeof NaN 结果为 'number' 
//考查到了 alert输出的都是字符串

//=>  '0'  答案必须是字符串'0'

三元运算符：

语法 ：条件?条件成立执行:条件不成立执行;

三元运算符就是if(){}else{}的另一种方法

num++ : num+=1,num=num+1;自身累加1

三元运算符不要else：条件?条件成立执行:null

空着（条件?条件成立执行:;）语法不符合，可以用null 、undefined、 void 0

某一种条件下执行多条操作，使用小括号包起来，中间用逗号分隔

在三元运算符中不能出现break/continue/return;这些关键词 不能改写为三元运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
var num=10;
if(num>5 && num<=10){
    num++;
}else{
    num--;
}
//改写为三元运算符
num>5 && num<=10?num++:num--;


//某一种条件下执行多条操作
var num=10;
if(num>5 && num<=10){
    num++;
    console.log('aaa')
}else{
    num--;
}
//改写为三元运算符
num>5 && num<=10?(num++,console.log('aaa')):num--;


//某一种条件下出现break/continue/return;
var num=10;
if(num>5 && num<=10){
    num++;
    break/continue/return;
}else{
    num--;
}
//不能改写为三元运算符


//不建议用  还是写为if、else
var num =10;
num>0?(num<10?num++:num--):(num>-10?num+=2:num-=2);

switch case:一个变量在不同值情况下的不同操作

switch case应用于if、else中一个变量在不同值情况下的不同操作

1、switch后面小括号中存放的是一个值（一般我们都写变量：把变量存储的值拿来用，有时候也可能是一个计算）
2、case后面放的都是值，目的是验证switch后面的值和哪一种case后面的值相等，相等的进行对应的处理
3、default：switch后面的值和每一种case情况对应的值都不相等，执行最后的default，类似于else
4、switch 中比较用的是 ===

‘6’ == 6 为true; ‘6’===6 false；

5、不加break 不管后面的条件是否成立，都会继续向下执行，直到遇到break为止
6、最后一项可以不加break 也能跳出判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var num=10;
switch(num){
    case 1:
        ...
        break;
    case 2:
        ...
        break;
    case 10:
        ...
        break;
    default:
        ...
}

A%B:取A/B的余数

案例剖析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
var num=5;
switch(num%2){//先把取余数操作进行运运算，拿到运算结果和case比较
    case 0:
        num++;
        break;  //不加break 不管后面的条件是否成立，都会继续向下执行，直到遇到break为止
     case 2-1:   //case后面也应该是值，此处先把2-1计算，把计算结果和switch值比较
        num--;
                //最后一项可以不加break  也能跳出判断
}
//4

//不加break应用：把符合某几项值都去做同一件事情
switch(num%3){
    case 0:
    case 1:          //余数是0或者1都执行加加的操作
        num++;
        break;
}

//证明  switch用的  ===
var num = '6';
switch(num){
    case 0:
        num++;
        break;
    case 6:
        num--;
        break;
    default:
        num=0;
}
console.log(num)  //0

循环操作语句for循环

按照一定规律，重复去做某件事情，此时我们需要使用循环处理

步骤：

  • 1、设置初始值

  • 2、设置循环成立的条件（条件成立，执行循环体；不成立，循环结束）

  • 3、条件成立，执行循环体中的内容

  • 4、执行步长累加操作

continue：结束本轮循环，继续执行下一轮，循环体中continue后面的代码不会执行，它会直接的去执行步长累加，然后进入到下一轮

break：结束整个循环，循环体中一旦遇到break 后面的代码不执行而且步长累加也不执行了，循环都结束了

for循环：

1
2
3
for(设置循环起始的值；设置循环执行的条件；步长累加){
    //=>循环体：重复做的事情都在循环体中
}

案例剖析：

1
2
3
4
5
6
7
8
//1、设置初始值；
//2、验证条件；
//3、条件成立，执行循环体；不成立，循环结束
//4、步长累加
    for(var i=0;i<5;i++){
        console.log(i)  //0,1,2,3,4
    }
    console.log(i)   //5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var i=0;
for(;i<5;){    //没有步长累加，会是死循环
    console.log(i)  //0,1,2,3,4
}
console.log(i)   //5

var i=0;
for(;i<5;i+=2){    //步长不一定是1
    console.log(i)  //0，2,4
}
console.log(i)   //6



for(var i=0;i<5;i+=2){    //步长不一定是1
    console.log(i)  //0，2,4
    continue;       //=>结束本轮循环，继续执行下一轮，循环体中continue后面的代码不会执行，它会直接的去执行步长累加，然后进入到下一轮
    ...
}
console.log(i)   //6



for(var i=0;i<5;i+=2){    //步长不一定是1
    console.log(i)  //0
    break;       //=>结束整个循环，循环体中一旦遇到break 后面的代码不执行而且步长累加也不执行了，循环都结束了
    ...
}
console.log(i)   //0
1
2
3
4
5
6
7
8
9
10
11
for(var i=1;i<10;i+=2){            //i=1   4   7
    if(i<5){
        i++;                    //i=2   5  
        continue;
    }else{
        i+=3;                   //          i=10
        break;
    }
    console.log(i)          
}
console.log(i)       //10

倒序循环：

1
2
3
4
var  arr=[1,2,3]
for(var i=arr.length-1;i>-1;i--){            
    console.log(arr[i])          
}

while循环

while(条件){

条件成立干的事

}

条件不成立了就不循环了

循环次数不确定、起始值不确定、也没有步长累加、就有一个条件时 使用

1
2
3
4
5
6
7
8
9
10
11
//生成四位不重复验证码
var str='sadasdasdasdasdasdgfdsegd4545445fasfVGYVYYVGGasfKKasdfasfasff';
var res='';
//只要res.length小于4就接着循环
while(res.length<4){
    var n=Math.round(Math.random()*str.length);
    var char=str.charAt(n);
    if(res.indexOf(char)===-1){
        res+=chart;
    }
}