前端牛客网刷题总结【 JS基础变量、数据类型、数据类型转换、运算符等】

本文链接：https://blog.csdn.net/qq_44810886/article/details/124205889

1.JavaScript是解释性语言。正确。体现在JS文件在完成之后，不会经过任何的编译。而是在运行时去解释执行。最好的例子就是，JS中一个函数有语法的错误，但是不会因为这个局部的错误而影响其他函数运行

2. JS是弱类型的语言。正确。

静态语言（强类型语言）

静态语言是在编译时变量的数据类型即可确定的语言，多数静态类型语言要求在使用变量之前必须声明数据类型。
例如：C++、Java、Delphi、C#等。

动态语言（弱类型语言）

动态语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明，通常变量的类型是被赋值的那个值的类型。
例如PHP/ASP/Ruby/Python/Perl/ABAP/SQL/JavaScript/Unix Shell等等

3. JavaScript是面向对象的程序设计语言。错误。面向对象语言提供了类、继承等成分，有识认性、多态性、类别性和继承性四个主要特点。而javascript没有这些

一、JS中的变量定义

1.var，let，const定义的变量有什么区别？（这三者有什么区别）

let定义的变量不会挂载到window上

二、数据类型

1.基本数据类型（存储在栈中的简单数据段）
Number，string，boolean，undefined，null，Symbol
2.引用数据类型（存储在堆中的对象，存储在栈中的值是一个指针，指向存储对象的内存地址）Object，Arrray，Function

访问obj的方式有两种

点的方式obj.arr;

中括号的方式obj["arr"];

let obj = {
  num1: 117
}
let res = obj;
obj.child = obj = { num2: 935 };
var x = y = res.child.num2;
console.log(obj.child);
console.log(res.num1);
console.log(y);

输出：undefined、117、935

3.数据类型的判断方法
3.1 typeof：不能判断null，object，array，能识别函数

 <script>
        console.log(typeof 1);          //number
        console.log(typeof 'pipi');     //string
        console.log(typeof '');         //string
        console.log(typeof true);       //boolean
        console.log(typeof undefined);  //undefined
        console.log(typeof null);       //object
        console.log(typeof {});         //object
        console.log(typeof ['1', '2']); //object
        console.log(typeof Symbol());   //symbol
        console.log(typeof
            function() {});            //function
    </script>

typeof Date.now() 的值是 Number （返回一个时间戳）（360集团2018）

3.2 instanceof

原理：通过原型链来实现，A（实例对象）instanceof B( 构造函数），可以判断这个实例是否由这个构造函数所创建，或者这个实例是否继承于这个父类

        function Foo() {}
        var f1 = new Foo()
        console.log(f1 instanceof Foo); //true
        console.log(f1 instanceof Object); //true
        

        console.log([] instanceof Array); //true
        console.log(function() {} instanceof Function); //true
        console.log({} instanceof Object); //true
         console.log(null instanceof Object) // false,，美的笔试

       //通过字面量创建的基本数据类型，不是所属类的实例
        console.log("1" instanceof String); //false
        console.log(1 instanceof Number);//false
        console.log(true instanceof Boolean);//false
       

       //通过new关键字去创建基本数据类型
        console.log(new Number(1) instanceof Number);//true
        console.log(new String('1') instanceof String);//true
        console.log(new Boolean(false) instanceof Boolean);//true

        console.log('foo' == new function() {
            return String('foo')
        });//false
        console.log('foo' == new function() {
            return new String('foo')
        });//true
        console.log([] == 0); //true
        console.log(![]); //false
        console.log(!0); //true

例题：下面这段程序的显示结果是？hi

var x = new Boolean(false);
if (x) {
  alert('hi'); 
}
var y = Boolean(0);
if (y) {
  alert('hello');  
}

var x = new Boolean(false); 用 new 调用构造函数会新建一个布尔对象，那么 x 就是一个 Boolean 类型的对象，若执行 if(ｘ) 时，对象转布尔，始终是 true

三、数据类型转换

1.转换为数字型

perseInt()

parseFloat()

Number()强制转换

js隐式转换

关于 perseInt（）

将字符串转换为整数，如果第二个参数为0或省略第二个参数的时候，转换为10进制；如果第二个参数为小于2或者大于32，结果为NaN

注意:

1.string字符串只会被解析从第一个字符开始直到不是数字的字符部分 console.log(parseInt('223'));//223

2 当字符串中间存在非数字,那么就只解析前面是数字的部分字符 console.log(parseInt('22e3'));//22

3 如果字符串中第一个字符就不是数字,那么返回NaN

console.log(parseInt('e21'));//NaN

4. 如果第一个参数前缀使用0x/0X则表示使用16进制 console.log(parseInt(0x99));//153=16*9+9

5.如果第一个参数使用了0x表示十六进制,那么第二个参数设置了值也无效

console.log(parseInt(0x99,10));

一些例题：

console.log(parseInt('0xB')); //11

console.log(parseInt('1', 1)); //NaN

console.log(parseInt('1', 40)); //NaN

console.log(parseInt('1', 2)); //1

console.log(parseInt('2', 2)); //NaN

例题

[1,2,3].map(parseInt）返回什么

解析

1.map接收parseInt作为回调函数,相当于

[1,2,3].map((item,index)=>{

return parseInt(item,index)}）

第一次遍历数组parseInt(1,0);//1

第一次遍历数组parseInt(2,1);//NaN

第一次遍历数组parseInt(3,2);//NaN

Number()强制转换

console.log(undefined + 1);  //NaN
解释：console.log(undefined + 1);  一元+操作符相当于Number()函数，会将undefined转化为数字，如果转化不了，那么就是NAN，所以会变为NAN+1 == NAN；结果就是NAN

  <script>
        console.log(Number(undefined)); //NaN
        console.log(Number('a')); //NaN
        console.log(Number({})); //NaN
        console.log(Number(true)); //1
        console.log(Number(null)); //0
        console.log(Number()); //0
        console.log(Number(0)); //0
        console.log(Number('')); //0
        console.log(Number([0])); //0
        console.log(Number(false)); //0
        console.log(Number([])); //0
    </script>

2.转换为布尔型

任何对象转为布尔值，都为得到 true（在 JS 中，只有 0，-0，NaN，""，null，undefined 这六个值转布尔值时，结果为 false）

3.转换为字符串

toString（）

String()强制装换

加号拼接字符串

四、代码回收规则

代码回收规则如下

1.全局变量不会被回收。
2.局部变量会被回收，也就是函数一旦运行完以后，函数内部的东西都会被销毁。
3.只要被另外一个作用域所引用就不会被回收

五、运算符

1.前置自增、后置自增

<script>
        var i = 5;
        var a = i++; //后置递增，表达式先返回原值（执行完该语句后），变量再自增
        console.log(i); //6
        console.log(a); //5

        var j = 5;
        var b = ++j; //前置递增，
        console.log(j); //6，变量先加1，再执行该语句
        console.log(b); //6

 </script>


        var c = 10;
        c++; 
        var d = c++ + 2
        console.log(d); //13


        var c1 = 10;
        ++c1; 
        var d1 = ++c1 + 2
        console.log(d1); //14

        var e = 10;
        var f = e++ + ++e;
        console.log(f);//22

所以以下代码输出10

<script>
 function out(x){
     var temp = 2;
     function inside(y){
         document.write( x + y + (temp--));
     }
     inside(5);
 }
 out(3);
 </script>

2、逻辑运算符

操作符之间的优先级（高到低）：

算数操作符 → 比较操作符 → 布尔（逻辑）操作符 → “=”赋值符号

&&优先级高于||

&&左为真返回右边 123&&456,返回456 0&&456，返回0

|| 左为真返回左边 123||456||123+456，返回123

例1

var a = 4399 < 0 || typeof(4399 + '');
console.log(a);
|| 这个是短路或，也就是||前面为true的话就直接等于前面的值了，不会再看||后面。
这里4399<0是false，所以还需要往后看，4399+''是字符串类型，typeof返回的是值的类型
所以在控制台输出的是String

3.一元运算符

例

"+new Array(017)" 这段代码输出为？（） NaN

相当于：

a = new Array(017);

console.log(a instanceof Array); //true

console.log(a.length);//得到的是一个长度为15的空数组

console.log(+a); //NaN

解释：

一元运算符+

+Symbol => 报错

<script>
        console.log(+12); //12
        console.log(+'pipi'); //NaN,非数字样式的字符串 会转换为NaN
        console.log(+'14');//14,数字样式的字符串 会转换为字符串

     
        console.log(+true); //1
        console.log(+false); //0
        console.log(+null); //0
        console.log(+undefined); //NaN
        console.log(+{}); //NaN
        
        console.log(+[]); //0
 </script>

例题：

console.log(1+ "2"+"2");
console.log(1+ +"2"+"2");
console.log("A"- "B"+"2");
console.log("A"- "B"+2);

122 32 NaN2 NaN

console.log(1+ "2"+"2"); //对于加法来说，如果只有一个操作数是字符串，则将另一个操作数也转换为字符串，然后将两者拼接,为122
console.log(1+ +"2"+"2"); //(+"2")应用了一元加操作符，一元加操作符相当于Number()函数，会将 (+"2")转换为2,1+2+"2"=32
console.log("A"- "B"+"2"); //在减法中遇到字符串和加法相反，调用Number()函数将字符串转换为数字，不能转换则返回NaN，此时运用加法规则，NaN+"2"，"2"是字符串，则将两者拼接。
console.log("A"- "B"+2); //这个与上面的不太相同，减法运算后依然为NaN，但是加号后面的为数字2，加法规则中，如果有一个操作数是NaN，则结果为NaN

总结：

对于“+”来说，有两个含义：

1，做字符串拼接，如果操作数里有一个是字符串，其他的值将被转换成字符串；

2，加减法中的加法其他情况，操作数转换成数字执行加法运算。

而对于“ - ”来说，只有一个含义，就是做减法，不会转化成字符串

var foo = "10"+3-"1";

console.log(foo)；//结果是102

关于精度的例题

下题的结果正确的是？

var one   = 0.1

var two   = 0.2

var six   = 0.6

var eight = 0.8

[two - one == one, eight - six == two] //true false

https://blog.csdn.net/weixin_43465339/article/details/108182482

六、基本语句

1. break表示跳出循环，本次循环之后的都不执行

2. continue表示停止当前语句，并从头执行该语句

例1，最后输出x为3，不是2
var x=0; 
 switch(++x) { 
     case 0: ++x; 
     case 1: ++x; 
     case 2: ++x; 
 }
解释：

1.++x是前置自增，也就是先自增加1，再将x返回，所以switch表达式的值为1，匹配第二个case语句

2.同样对x进行前置自增，x的值变为2

3.由于没有使用break语句，在成功匹配后，会继续往下执行后面的case语句，也就是继续执行第三个case语句，最终x值为3

例2. 下面代码的输出为：啥也没有
var i = 0;
while( i < 40 ){
    if( i < 30 )
        continue;
    Document.write(‘########’);
    i++;
}
解释：

continue语句只能用在while语句、do/while语句、for语句、或者for/in语句的循环体内，在其它地方使用都会引起错误！是停止当前语句，并从头执行该语句。

例3
var k = 0;
for(var i=0,j=0;i<10,j<6;i++,j++){
    k += i + j;
}
console.log(k)
考点：逗号表达式只有最后一项是有效的，即对于i<10,j<6; 来说，判断循环是否结束的是 j < 6

例4
 <script>
        for (var i = 1; i <= 5; i++) {
            if (i == 3) {
                break;
            }
            console.log('我正在吃第' + i + '个包子');
        }
</script>