JavaScript基础题和面试题

1. 变量相关

1. 选择题：下列哪个关键字用于声明变量并对其赋值？
   a) var
   b) let
   c) const
   d) 以上都可以
   d

2. 补全代码：请补充以下代码，使其声明一个名为 "age" 的变量并赋予其初始值为 25。
   let age = 25

3. 选择题：以下哪种声明变量的方式在定义后不可再修改其值？
   a) var
   b) let
   c) const
   d) 以上都可以
   C

4. 程序补全题：请根据描述补全以下代码，声明一个常量 "PI" 并赋值为3.14。
   const PI = 3.14

5. 选择题：以下哪种声明变量的方式具有块级作用域？
   a) var
   b) let
   c) const
   d) 以上都不是
   b

6. 补全代码：请补全以下代码，使其交换变量 x 和 y 的值而不使用临时变量。

   var x = 5; var y = 10; // 在此处补充代码
   
   
     function fn(a,b){
      let c = a + b
       b = c-b
       a = c-a
       console.log(a,b);
     }
     fn(5,10)

7. 程序补全题：请根据描述补全以下代码，声明一个变量 "name" 并将其赋值为 "John"。
   let name = "John"

8. 选择题：以下哪种方式可以检查一个变量是否已定义？
   a) defined()
   b) isDefined()
   c) typeof
   d) 以上都不是
   c

9. 程序编程题：编写一个函数，接受一个参数并判断它的数据类型是否为字符串。

   function isString(input) { 
       return typeof input === 'string';
   }
   console.log(isString(2)); // 输出：false
   console.log(isString('hello')); // 输出：true
   

10. 程序编程题：编写一个函数，接受一个数字参数并返回其平方值。

    function square(num) {
        if(typeof num === 'number'){
            return num * num; 
        } else {
            // 可以选择在这里处理参数不是数字的情况
            return "输入不是数字";
        }
    }
    console.log(square(5)); // 输出：25
    

2. 表达式

1. 选择题：在以下选项中，哪个是合法的JavaScript表达式？
   A. 5 + 3
   B. var x = 10;
   C. if (x > 5) { console.log("Hello"); }
   D. function myFunction() {}
   B

2. 选择题：以下哪个是逻辑与运算符的正确表达式？
   A. ||
   B. !
   C. &&
   D. &
   C

3. 编程题：编写一个JavaScript函数，接受一个数字作为参数，并判断该数字是否为偶数，然后返回布尔值作为表达式的结果。
    

   function fn(number) {
     if (number % 2 === 0) {
       return true;
     } else {
       return false;
     }
   }
   
   console.log(fn(5)); // 输出：false
   

4. 选择题：以下哪个是三元条件运算符的正确语法？
   A. if-else
   B. switch-case
   C. for-loop
   D. ? :
   D

5. 编程题：编写一个JavaScript函数，接受一个字符串作为参数，并将其反转，然后返回反转后的字符串作为表达式的结果。
    

   function fn(str){
       if(typeof str === 'string'){
           let arr = []
           for(let i = 0; i < str.length; i++){
               arr.push(str[i])
           }
           return console.log(arr.reverse().join(''));
       } 
   }
   fn('hello')

6. 选择题：以下哪个是算术运算符的正确表达式？
   A. &&
   B. +
   C. !
   D. ===
   B

7. 编程题：编写一个JavaScript表达式，判断一个字符串是否为回文字符串（正读和反读都一样）。

   function isPalindrome(str) {
     const reversedStr = str.split('').reverse().join('');
     return str === reversedStr;
   }
   
   // 测试
   console.log(isPalindrome("level")); // true
   console.log(isPalindrome("hello")); // false
   

8. 编程题：编写一个JavaScript表达式，计算一个字符串中每个字符出现的次数，并返回一个包含字符和次数的对象。

     function fn(str) {
       let obj = {};
       for (let i = 0; i < str.length; i++) {
           obj[str[i]] = 0
           for(let j = 0; j < str.length; j++){
               if(str[i] === str[j]){
                   obj[str[i]] ++
               }
           }
       }
       console.log(obj);
     }
     fn("hello");

 3. 算术运算

1. 假设变量 x 的初始值为 5，下面的代码会输出什么结果？

   console.log(x++);

   A) 5
   B) 6
   C) 4
   D) 报错
   A

2. 下面的表达式的结果是什么？

   console.log(10 % 3);

   A) 3
   B) 1
   C) 0
   D) 10
   B

3. 下面的表达式的结果是什么？

   console.log(15 / 2);

   A) 7.5
   B) 7
   C) 7.500000
   D) 0.75
   A

4. 假设变量 a 的值为 4，变量 b 的值为 2，下面的表达式的结果是什么？

   console.log(a - b++);

   A) 1
   B) 2
   C) 3
   D) 4
   B

5. 下面的表达式的结果是什么？

   console.log(10 % 4);

   A) 4
   B) 2
   C) 0
   D) 1
   B

6. 假设变量 x 的值为 5，下面的表达式的结果是什么？

   console.log(++x);

   A) 5
   B) 6
   C) 4
   D) 报错
   B

7. 下面的表达式的结果是什么？

   console.log(10 / 3);

   A) 3.3333333333333335
   B) 3
   C) 3.33
   D) 0.3
   A

8. 下面的表达式的结果是什么？

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

   A) 21
   B) 23
   C) 1
   D) 报错
   A

9. 下面的代码会输出什么结果？

   var a = 1;
   function b() {
     var a = 2;
     function c() {
       console.log(a);
     }
     c();
   }
   b();
   

   A) 1
   B) 2
   C) undefined
   D) 报错
   B

10. 下面的代码会输出什么结果？

    var a = 10;
    function foo() {
      console.log(a);
    }
    function bar() {
      var a = 20;
      foo();
    }
    bar();
    

     

    A) 10
    B) 20
    C) undefined
    D) 报错
    A

4. 对象

1. 下面哪个选项描述了JavaScript中对象属性的正确定义方式？
   A. 属性是一种方法，用于执行特定的操作。
   B. 属性是一种变量，用于存储特定的值。
   C. 属性是一种条件语句，用于控制程序流程。
   D. 属性是一种事件处理器，用于响应用户操作。
   B

2. 如何在JavaScript中删除一个对象的属性？
   A. 使用delete关键字
   B. 使用remove关键字
   C. 使用clear关键字
   D. 使用discard关键字
   A

3. 在JavaScript中，如何检查一个对象是否拥有特定的属性？
   A. 使用hasOwnProperty()方法
   B. 使用checkProperty()方法
   C. 使用isPropertyPresent()方法
   D. 使用validateProperty()方法
   A

4. 在JavaScript中，如何定义一个对象的方法？
   A. 将函数赋值给对象属性
   B. 使用method关键字声明方法
   C. 使用function关键字声明方法
   D. 将方法作为参数传递给对象构造函数
   A

5. 下面哪个选项描述了JavaScript中对象的继承？
   A. 继承是一种将对象属性复制到其他对象的过程。
   B. 继承是一种将对象方法复制到其他对象的过程。
   C. 继承是一种通过原型链关联对象的机制。
   D. 继承是一种创建新对象的过程。
   C

6. 在JavaScript中，如何实现对象的继承？
   A. 使用extend关键字
   B. 使用inherit关键字
   C. 使用prototype关键字
   D. 使用super关键字
   C

7. 在JavaScript中，如何创建一个对象的副本？
   A. 使用clone()方法
   B. 使用copy()方法
   C. 使用duplicate()方法
   D. 使用Object.assign()方法
   D

8. 如何在JavaScript中检查一个对象是否是另一个对象的实例？
   A. 使用checkInstance()方法
   B. 使用isInstanceOf()方法
   C. 使用instanceof关键字
   D. 使用isInstance()方法
   C

9. 在JavaScript中，如何实现对象的封装？
   A. 使用private关键字
   B. 使用protected关键字
   C. 使用encapsulate关键字
   D. 使用闭包（closure）
   D

10. 在JavaScript中，如何创建一个原型对象？
    A. 使用Object.create()方法
    B. 使用new关键字
    C. 使用prototype关键字
    D. 使用inherit关键字
    A

11. 如何在JavaScript中获取对象的原型？
    A. 使用getPrototype()方法
    B. 使用__proto__属性
    C. 使用prototype属性
    D. 使用getProto()方法
    A,B

12. 在JavaScript中，如何修改对象的原型？
    A. 使用setPrototype()方法
    B. 使用__proto__属性
    C. 使用prototype属性
    D. 使用modifyProto()方法
    A

13. 如何在JavaScript中创建一个具有特定原型的对象？
    A. 使用new关键字和构造函数
    B. 使用create()方法和原型对象
    C. 使用setProto()方法和原型对象
    D. 使用inherit()方法和原型对象
    A,B

14. 在JavaScript中，如何判断两个对象是否相等？
    A. 使用isEqual()方法
    B. 使用equals()方法
    C. 使用===操作符
    D. 使用compare()方法
    A

15. 编写一个函数，接受一个字符串作为参数，并返回一个新的字符串，其中每个单词的首字母都大写。

    function fn(str) {
      let first = str[0];
      if (typeof first === 'string') {
        return str.replace(first, first.toUpperCase());
      }
    }
    console.log(fn("acc")); // 输出 "Acc"
    

5. 数组

1. 下面代码的输出结果是什么？

   var arr = [1, 2, 3, 4, 5]; 
   arr.splice(2, 1); 
   console.log(arr);

   A. [1, 2, 4, 5]
   B. [2, 3, 4, 5]
   C. [1, 2, 3, 5]
   D. [1, 2, 4]
   A
2. 下面代码的输出结果是什么？

   var arr1 = [1, 2, 3]; 
   var arr2 = [4, 5, 6]; 
   var arr3 = arr1.concat(arr2); 
   console.log(arr3);

   A. [1, 2, 3, 4, 5, 6]
   B. [1, 4, 2, 5, 3, 6]
   C. [4, 5, 6, 1, 2, 3]
   D. [1, 2, 3], [4, 5, 6]
   A
3. 下列哪个方法可以在数组的末尾添加一个元素？
   A. push()
   B. pop()
   C. unshift()
   D. shift()
   A
4. 下面代码的输出结果是什么？

   var arr1 = [1, 2, 3];
   var arr2 = arr1;
   arr2[0] = 0;
   console.log(arr1[0]);
   
   

   A. 0 B. 1 C. undefined D. 报错
   A
5. 下面哪个方法可以删除数组中指定位置的元素？
   A. splice()
   B. slice()
   C. concat()
   D. push()
   A
6. 下列哪个方法可以从数组的开头删除一个元素？
   A. shift()
   B. unshift()
   C. push()
   D. pop()
   A
7. 下面代码的输出结果是什么？

   var arr = [1, 2, 3, 4];
   arr.splice(2, 0, 5);
   console.log(arr);

   A. [1, 2, 3, 4]
   B. [1, 2, 5, 3, 4]
   C. [1, 2, 5, 4, 3]
   D. [1, 2, 4, 5, 3]
    [1, 2, 3, 5, 4]
8. 下面代码的输出结果是什么？

   var arr = [1, 2, 3];
   var sum = arr.reduce(function(prev, curr) {
   return prev + curr;
   });
   console.log(sum);

   A. 1
   B. 6
   C. 5
   D. undefined
   B
9. 下面哪个方法可以将数组中的所有元素合并成一个字符串？
   A. join()
   B. toString()
   C. pop()
   D. shift()
   A
10. 编写一个函数，接受一个数组作为参数，返回该数组中所有奇数的平方和。

    function getOddSquareSum(arr) {
        // 在此处补充代码
        let sum = 0;
        for (let i = 0; i < arr.length; i++) {
          if (arr[i] % 2 !== 0) {
            sum += arr[i] * arr[i];
          }
        }
        return console.log(sum);
    }
    
    console.log(getOddSquareSum([1, 2, 3, 4, 5])); // 输出结果为 35
    

11. 编写一个函数，接受一个数组作为参数，返回该数组中出现频率最高的元素。如果有多个元素频率相同，则返回其中任意一个。

    function getMostFrequentElement(arr) {
        // 在此处补充代码
    }
    
    console.log(getMostFrequentElement([1, 2, 3, 2, 4, 2, 5])); // 输出结果为 2
    

12. 编写一个函数，接受一个数组和一个目标值作为参数，返回数组中是否存在两个元素的和等于目标值。

    function hasTwoSum(arr, target) {
        // 在此处补充代码
    }
    
    console.log(hasTwoSum([1, 2, 3, 4, 5], 7)); // 输出结果为 true
    console.log(hasTwoSum([1, 2, 3, 4, 5], 10)); // 输出结果为 false
    

13. 编写一个函数，接受一个数组作为参数，返回该数组中的所有子数组（包括空数组）。

    function getAllSubarrays(arr) {
        // 在此处补充代码
    }
    
    console.log(getAllSubarrays([1, 2, 3])); // 输出结果为 [[], [1], [2], [3], [1, 2], [2, 3], [1, 2, 3]]
    

6. 原型

1. 在JavaScript中，每个对象都有一个 prototype 属性，它指向该对象的原型。下列关于原型的说法，错误的是：
   A. 在创建新对象时，可以指定其原型
   B. 原型链的终点是 Object.prototype
   C. 可以通过 proto 属性来访问对象的原型
   D. 所有对象都有自己的原型，原型可以被改变
   B
2. 下面哪个选项可以正确地创建一个新对象，并将其原型设置为 obj？
   A. var newObj = Object.create(obj);
   B. var newObj = new Object(obj);
   C. var newObj = Object.assign({}, obj);
   D. var newObj = Object.setPrototypeOf({}, obj);
   A
3. 在JavaScript中，使用 proto 属性可以访问对象的原型。那么，下列代码的输出结果是什么？

   var obj = {};
   console.log(obj.__proto__ === Object.prototype);
   

   A. true
   B. false
   C. undefined
   D. 抛出异常
   A
4. 下列哪个选项可以正确地判断 obj 是否是 Array 的实例？
   A. obj instanceof Array
   B. Array.isPrototypeOf(obj)
   C. obj.proto === Array.prototype
   D. Object.getPrototypeOf(obj) === Array.prototype
   D
5. 下列哪个方法可以将 obj 的原型设置为 proto？
   A. Object.setPrototypeOf(obj, proto)
   B. obj.proto = proto
   C. Object.create(proto)
   D. 所有选项都可以
   D
6. 补全以下代码，使得所有 Student 对象的原型都指向 Person，并设置 Person 的 constructor 属性。

   function Person() {}
   Person.prototype.sayHello = function() {
       console.log("Hello, I'm a person.");
   };
   
   function Student() {}
   
   // 补充代码
   

7. 补全以下代码，实现一个 extend 函数，该函数将子类的原型设置为父类的实例，并设置子类的 constructor 属性。

   function extend(child, parent) {
       // 补充代码
   }
   
   function Animal() {}
   Animal.prototype.sayHello = function() {
       console.log("Hello, I'm an animal.");
   };
   
   function Dog() {}
   extend(Dog, Animal);
   
   var dog = new Dog();
   dog.sayHello(); // 输出结果为 "Hello, I'm an animal."
   console.log(dog instanceof Animal); // 输出结果为 true
   console.log(dog instanceof Dog); // 输出结果为 true
   

8. 实现一个函数，计算 obj 中所有属性的个数（包括原型链上的属性）。

   function addProperties(obj, offset) {
       // 在此处补充代码
   }
   
   var obj = {a: 10, b: 20};
   addProperties(obj, 5);
   console.log(obj); // 输出结果为 {a: 15, b: 25}
   

9. 实现一个函数，将 obj 中所有属性值比较大小，并返回最大值。

   function getMaxPropertyValue(obj) {
       // 在此处补充代码
   }
   
   var obj = {a: 10, b: 20, c: 5};
   console.log(getMaxPropertyValue(obj)); // 输出结果为 20
   

10. 实现一个函数，判断 obj 是否是构造函数 constructor 的实例。

    function isInstanceOf(obj, constructor) {
        // 在此处补充代码
    }
    
    function Person() {}
    var person = new Person();
    console.log(isInstanceOf(person, Person)); // 输出结果为 true
    console.log(isInstanceOf(person, Object)); // 输出结果为 true
    console.log(isInstanceOf({}, Person)); // 输出结果为 false
    

7. 原型链

1. 下列哪个选项描述了JavaScript中原型链的正确行为？
   A) 原型链是一种单向链接，对象可以访问其原型的属性和方法，但原型不能访问对象的属性和方法。
   B) 原型链是一种双向链接，对象可以访问其原型的属性和方法，同时原型也可以访问对象的属性和方法。
   C) 原型链是一种单向链接，对象可以访问其原型的属性和方法，同时原型也可以访问对象的属性和方法。
   D) 原型链是一种双向链接，对象可以访问其原型的属性和方法，但原型不能访问对象的属性和方法。
   A

2. 在JavaScript中，当一个对象试图访问一个属性或方法时，它会首先在自身的属性和方法中查找，如果找不到，则会继续沿着原型链向上查找，这个过程被称为：
   A) 属性遍历
   B) 方法搜索
   C) 原型继承
   D) 原型查找
   D

3. 完成下面的代码，使得 cat 对象继承自 animal 对象

   function Animal(name) {
     this.name = name;
   }
   
   // 在这里补全代码，实现继承
   
   var cat = new Cat('Tom');
   console.log(cat.name); // 应输出 'Tom'
   

8. 继承

1. 请简述JavaScript中继承的两种实现方式，并说明它们的不同之处。
2. 下面代码的输出结果是什么？

   function A() {}
   A.prototype.n = 1;
   var b = new A();
   A.prototype = {
     n: 2,
     m: 3
   };
   var c = new A();
   console.log(b.n, b.m, c.n, c.m);
   

3. 下面代码的输出结果是什么？

   function Person(name) {
     this.name = name;
   }
   Person.prototype.sayName = function() {
     console.log(this.name);
   }
   function Student(name, grade) {
     Person.call(this, name);
     this.grade = grade;
   }
   Student.prototype = Object.create(Person.prototype);
   Student.prototype.constructor = Student;
   Student.prototype.sayGrade = function() {
     console.log(this.grade);
   }
   var s = new Student('Tom', 3);
   s.sayName();
   s.sayGrade();
   

4. 请编写一个Dog类，继承自Mammal类，在构造函数中调用父类构造函数并传入name参数，拥有bark方法，在方法中输出'woof woof!'。

5. 下面代码的输出结果是什么？

   function Animal() {}
   Animal.prototype.species = '动物';
   function Cat(name, color) {
     this.name = name;
     this.color = color;
   }
   Cat.prototype = new Animal();
   Cat.prototype.constructor = Cat;
   var cat1 = new Cat('大毛', '黄色');
   console.log(cat1.species);
   delete cat1.species;
   console.log(cat1.species);
   

6. 下面代码的输出结果是什么？

   function Person() {}
   Person.prototype.name = 'Tom';
   function Student() {}
   Student.prototype = Object.create(Person.prototype, {
     constructor: {
       value: Student,
       writable: true,
       configurable: true,
       enumerable: false
     }
   });
   var s = new Student();
   console.log(s instanceof Person);
   console.log(s instanceof Student);
   

9. 作用域

1. 下面代码的输出结果是什么？

   var a = 10;
   function test() {
     console.log(a);
     var a = 5;
   }
   test();
   

   A. 10

   B. 5

   C. undefined

   D. 报错
   A

2. 下面代码的输出结果是什么？

   var a = 10;
   function test() {
     console.log(a);
     var a = 5;
     console.log(a);
   }
   test();
   

   A. 10, 5

   B. 5, 5

   C. 10, undefined

   D. undefined, 5
   A

3. 下面代码的输出结果是什么？

   for (var i = 0; i < 5; i++) {
     setTimeout(function () {
       console.log(i);
     }, 1000 * i);
   }
   

   A. 0, 1, 2, 3, 4

   B. 5, 5, 5, 5, 5

   C. 1, 2, 3, 4, 5

   D. 4, 2, 0, 1, 3
   B

4. 下面代码的输出结果是什么？

   var a = 10;
   function test() {
     console.log(a);
     a = 5;
   }
   test();
   console.log(a);
   

   A. 10, 5

   B. 5, 10

   C. 10, 10

   D. 5, 5
   C

5. 下面代码的输出结果是什么？

   var a = 1;
   function outer() {
     function inner() {
       console.log(a);
     }
     var a = 2;
     return inner;
   }
   var fn = outer();
   fn();
   

   A. 1

   B. 2

   C. undefined

   D. 报错
   C

6. 下面代码的输出结果是什么？

   var a = 10;
   function test() {
     var a = 5;
     function inner() {
       console.log(a);
     }
     return inner;
   }
   var fn = test();
   fn();
   

   A. 10

   B. 5

   C. undefined

   D. 报错
   B

7. 补全下面代码，使输出结果为 'outer-inner'

   var x = 'outer';
   function test() {
     var x = 'inner';
     function inner() {
       console.log(___);
     }
     inner();
   }
   test();
   

8. 补全下面代码，使输出结果为 'Hello, World!'

   var message = 'Hello, ';
   function sayHello() {
     console.log(message + 'World!' );
   }
   sayHello();
   

9. 什么是变量提升？它是如何工作的？
10. 什么是let和const关键字？它们如何影响作用域？
11. 如何理解JavaScript中的“块级作用域”？