js 学习【二】

小鱼儿 2023-06-06 03:39 3阅读 0赞

### 输出是什么？ ###

let c = { greeting: 'Hey!' }
    let d
    
    d = c
    c.greeting = 'Hello'
    console.log(d.greeting)
    
    //A: Hello

在 JavaScript 中，当设置两个对象彼此相等时，它们会通过引用进行交互。

首先，变量 c 的值是一个对象。接下来，我们给 d 分配了一个和 c 对象相同的引用。

因此当我们改变其中一个对象时，其实是改变了所有的对象。

### 输出是什么？ ###

let a = 3
    let b = new Number(3)
    let c = 3
    
    console.log(a == b)
    console.log(a === b)
    console.log(b === c)
    
    //C: true false false

new Number() 是一个内建的函数构造器。虽然它看着像是一个 number，但它实际上并不是一个真实的 number：它有一堆额外的功能并且它是一个对象。

当我们使用 == 操作符时，它只会检查两者是否拥有相同的值。因为它们的值都是 3，因此返回 true。

然后，当我们使用 === 操作符时，两者的值以及类型都应该是相同的。new Number() 是一个对象而不是 number，因此返回 false

### 当我们这么做时，会发生什么？ ###

function bark() {
      console.log('Woof!')
    }
    
    bark.animal = 'dog'

答案: A

这在 JavaScript 中是可以的，因为函数是对象！（除了基本类型之外其他都是对象）

函数是一个特殊的对象。你写的这个代码其实不是一个实际的函数。函数是一个拥有属性的对象，并且属性也可被调用。

### 输出是什么？ ###

答案: A

你不能像常规对象那样，给构造函数添加属性。如果你想一次性给所有实例添加特性，你应该使用原型。因此本例中，使用如下方式

Person.prototype.getFullName = function () {
      return `${this.firstName} ${this.lastName}`;
    }

这才会使 member.getFullName() 起作用。为什么这么做有益的？假设我们将这个方法添加到构造函数本身里。也许不是每个 Person 实例都需要这个方法。这将浪费大量内存空间，因为它们仍然具有该属性，这将占用每个实例的内存空间。相反，如果我们只将它添加到原型中，那么它只存在于内存中的一个位置，但是所有实例都可以访问它！

### 输出是什么？ ###

function Person(firstName, lastName) {
      this.firstName = firstName
      this.lastName = lastName
    }
    
    const lydia = new Person('Lydia', 'Hallie')
    const sarah = Person('Sarah', 'Smith')
    
    console.log(lydia)
    console.log(sarah)
    
    A: Person {firstName: "Lydia", lastName: "Hallie"} and undefined
    B: Person {firstName: "Lydia", lastName: "Hallie"} and Person {firstName: "Sarah", lastName: "Smith"}
    C: Person {firstName: "Lydia", lastName: "Hallie"} and {}
    D:Person {firstName: "Lydia", lastName: "Hallie"} and ReferenceError

答案: A

对于 sarah，我们没有使用 new 关键字。当使用 new 时，this 引用我们创建的空对象。当未使用 new 时，this 引用的是全局对象（global object）。

我们说 this.firstName 等于 "Sarah"，并且 this.lastName 等于 "Smith"。实际上我们做的是，定义了 global.firstName = 'Sarah' 和 global.lastName = 'Smith'。而 sarah 本身是 undefined。

### 所有对象都有原型 ###

A: true
    B: false

答案: B

除了**基本对象**（base object），所有对象都有原型。基本对象可以访问一些方法和属性，比如 `.toString`。这就是为什么你可以使用内置的 JavaScript 方法！所有这些方法在原型上都是可用的。虽然 JavaScript 不能直接在对象上找到这些方法，但 JavaScript 会沿着原型链找到它们，以便于你使用。

### 输出是什么？ ###

function sum(a, b) {
      return a + b
    }
    
    sum(1, '2')

*  A: `NaN`
 *  B: `TypeError`
 *  C: `"12"`
 *  D: `3`

答案: C

JavaScript 是一种**动态类型语言**：我们不指定某些变量的类型。值可以在你不知道的情况下自动转换成另一种类型，这种类型称为**隐式类型转换**（implicit type coercion）。**Coercion** 是指将一种类型转换为另一种类型。

在本例中，JavaScript 将数字 `1` 转换为字符串，以便函数有意义并返回一个值。在数字类型（`1`）和字符串类型（`'2'`）相加时，该数字被视为字符串。我们可以连接字符串，比如 `"Hello" + "World"`，这里发生的是 `"1" + "2"`，它返回 `"12"`。

### 输出是什么？ ###

let number = 0
    console.log(number++)
    console.log(++number)
    console.log(number)

*  A: `1` `1` `2`
 *  B: `1` `2` `2`
 *  C: `0` `2` `2`
 *  D: `0` `1` `2`

答案: C

一元**后自增**运算符 `++`：

返回值（返回 `0`）

值自增（number 现在是 `1`）

值自增（number 现在是 `2`）

返回值（返回 `2`）

### 输出是什么？ ###

function getPersonInfo(one, two, three) {
      console.log(one)
      console.log(two)
      console.log(three)
    }
    
    const person = 'Lydia'
    const age = 21
    
    getPersonInfo`${person} is ${age} years old`

*  A: `"Lydia"` `21` `["", " is ", " years old"]`
 *  B: `["", " is ", " years old"]` `"Lydia"` `21`
 *  C: `"Lydia"` `["", " is ", " years old"]` `21`

答案: B

如果使用标记模板字面量，第一个参数的值总是包含字符串的数组。其余的参数获取的是传递的表达式的值！

### 输出是什么？ ###

function checkAge(data) {
      if (data === { age: 18 }) {
        console.log('You are an adult!')
      } else if (data == { age: 18 }) {
        console.log('You are still an adult.')
      } else {
        console.log(`Hmm.. You don't have an age I guess`)
      }
    }
    
    checkAge({ age: 18 })

*  ``A: `You are an adult!`
 *  B: `You are still an adult.`
 *  C: `Hmm.. You don't have an age I guess`

答案: C

在测试相等性时，基本类型通过它们的值（value）进行比较，而对象通过它们的引用（reference）进行比较。JavaScript 检查对象是否具有对内存中相同位置的引用。

题目中我们正在比较的两个对象不是同一个引用：作为参数传递的对象引用的内存位置，与用于判断相等的对象所引用的内存位置并不同。

这也是 `{ age: 18 } === { age: 18 }` 和 `{ age: 18 } == { age: 18 }` 都返回 `false` 的原因。

### 输出是什么？ ###

function getAge(...args) {
      console.log(typeof args)
    }
    
    getAge(21)

*  A: `"number"`
 *  B: `"array"`
 *  C: `"object"`
 *  D: `"NaN"`

答案: C

扩展运算符（`...args`）会返回实参组成的数组。而数组是对象，因此 `typeof args` 返回 `"object"`。

### 输出是什么？ ###

const obj = { a: 'one', b: 'two', a: 'three' }
    console.log(obj)

*  A: `{ a: "one", b: "two" }`
 *  B: `{ b: "two", a: "three" }`
 *  C: `{ a: "three", b: "two" }`
 *  D: `SyntaxError`

答案: C

如果你有两个名称相同的键，则键会被替换掉。它仍然位于第一个键出现的位置，但是值是最后出现那个键的值。

### 输出什么? ###

const name = "Lydia"
    
    console.log(name())

*  A: `SyntaxError`
 *  B: `ReferenceError`
 *  C: `TypeError`
 *  D: `undefined`

答案: C

变量`name`保存字符串的值，该字符串不是函数，因此无法调用。

当值不是预期类型时，会抛出`TypeErrors`。 JavaScript期望`name`是一个函数，因为我们试图调用它。 但它是一个字符串，因此抛出`TypeError`：`name is not a function`

当你编写了一些非有效的JavaScript时，会抛出语法错误，例如当你把`return`这个词写成`retrun`时。 当JavaScript无法找到您尝试访问的值的引用时，抛出`ReferenceErrors`。

### 给字符串按顺序排序 ###

例如：红蓝蓝黄红黄蓝红红黄红，排序后为：黄黄黄红红红红红蓝蓝蓝。

//splice(redIndex, 0, str[i])  起始位、删除个数、插入的数据
    //先把字符串放进数组里，用数组的方法添加，然后导出时将数组转成字符串
    
        var str = '红蓝蓝黄红黄蓝红红黄红'
        function sortStr(str) {
        var arr = [];
        var redIndex = 0;
        for(let i = 0; i< str.length; i++) {
            switch(str[i]) {
                case "黄":
                    arr.unshift(str[i])
                    redIndex++;
                    break;
                case "红": 
                    arr.splice(redIndex, 0, str[i])
                    redIndex++
                    break;
                case "蓝": 
                    arr.push(str[i]);
                    break;
            }
        }
        return arr.join("");
        }
    
        console.log(sortStr(str));