JavaScript简介#

console.log("Hello World!");

// 双斜杠后面的任何内容都是英文注释。
// 仔细阅读注释：它们解释了JavaScript代码。


// 变量是值的符号名称。 
// 变量使用 let 关键字声明：
let x; // 声明一个名为 x 的变量。


// 可以使用等号（=）将值赋给变量
x = 0; // 现在变量 x 的值为 0。
x // => 0: 变量的值即为其本身。


// JavaScript支持多种类型的值。
x = 1; // 数值
x = 0.01; // 数值可以是整数或实数。
x = "hello world"; // 用引号括起来的文本字符串。
x = 'JavaScript'; // 单引号也用于界定字符串。
x = true; // 布尔值
x = false; // 另一个布尔值
x = null; // Null 是一个特殊的值，表示“无值”。
x = undefined; // Undefined 也是一个特殊值，与null类似

// JavaScript 最重要的数据类型是对象。
// 一个对象是名称/值对的集合，或者是一个字符串到值的映射。
let book = { // 对象用大括号括起来。
    topic: "JavaScript", // “属性“topic”的值是“JavaScript”。”
    edition: 7 // “edition”属性的值为7
}; // 大括号标志着对象的结束。


// 使用 . 或 [] 访问对象的属性:
book.topic // => "JavaScript"
book["edition"] // => 7: 访问属性值的另一种方法。
book.author = "Flanagan"; // 通过赋值创建新属性。
book.contents = {}; // {} 是一个没有属性的空对象。


// 使用?.有条件地访问属性（ES2020）:
book.contents?.ch01?.sect1 // => undefined: book.contents没有ch01属性。


// JavaScript 还支持数组（按数字索引的列表）值:
let primes = [2, 3, 5, 7]; // 一个包含4个值的数组，用 [ 和 ] 分隔。
primes[0] // => 2：数组的第一个元素（索引0）。
primes.length // => 4: 数组中有多少元素。
primes[primes.length - 1] // => 7: 数组的最后一个元素。
primes[4] = 9; // 通过赋值添加一个新元素.
primes[4] = 11; // 或者通过赋值更改现有元素。
let empty = []; // []是一个没有元素的空数组。
empty.length // => 0


// 数组和对象可以包含其他数组和对象：
let points = [ // 一个包含2个元素的数组。
    {x: 0, y: 0}, // 每个元素都是一个对象。
    {x: 1, y: 1}
];
let data = { // 具有两个属性的对象
    trial1: [[1, 2], [3, 4]], // 每个属性的值是一个数组。
    trial2: [[2, 3], [4, 5]]  // 数组的元素是数组。
};

// 运算符对值（操作数）进行操作以产生新值。
// 算术运算符是最简单的运算符之一：
3 + 2 // => 5: 加法
3 - 2 // => 1: 减法
3 * 2 // => 6: 乘法
3 / 2 // => 1.5: 除法
points[1].x - points[0].x // => 1: 更复杂的操作数也有效
"3" + "2" // => "32": +号用于拼接字符串


// JavaScript 定义了一些简写算术运算符
let count = 0; // 定义一个变量
count++; // 自增
count--; // 自减
count += 2; // 加2：等同于 count = count + 2;
count *= 3; // 乘以3：等同于 count = count * 3;
count // => 6: 变量名也是表达式。


// 相等和关系运算符用于测试两个值是否相等，
// 不等于、小于、大于，等等。它们的结果为真或假。
let x = 2, y = 3; // 这些=符号是赋值，而不是相等性测试
x === y // => false: 相等操作符
x !== y // => true: 不相等操作符
x < y // => true: 小于操作符
x <= y // => true: 小于等于操作符
x > y // => false: 大于操作符
x >= y // => false: 大于等于操作符
"two" === "three" // => false: 两个字符串不相等
"two" > "three" // => true: “tw” 在字母顺序上大于 “th”
false === (x > y) // => true: false等于false


// 逻辑运算符用于组合或取反布尔值
(x === 2) && (y === 3) // => true: 两个比较都为真。&& 表示与
(x > 3) || (y < 3) // => false: 两个比较都不成立。|| 是或运算符
!(x === y) // => true: ! 反转布尔值

// 函数是参数化的 JavaScript 代码块，我们可以调用它们。
function plus1(x) { // 定义一个名为"plus1"、带有参数"x"的函数
    return x + 1; // 返回一个比传入值大一的值
} // 函数用大括号括起来

plus1(y) // => 4: y is 3, so this invocation returns 3+1

let square = function (x) { // 函数是值，可以赋给变量
    return x * x; // 计算函数的值
}; // 分号表示赋值的结束。

square(plus1(y)) // => 16: 在一个表达式中调用两个函数

const plus1 = x => x + 1; // The input x maps to the output x + 1
const square = x => x * x; // The input x maps to the output x * x
plus1(y) // => 4: 函数调用是相同的
square(plus1(y)) // => 16

// 当函数被分配给一个对象的属性时，我们称之为
// “它们的方法。” 所有 JavaScript 对象（包括数组）都有方法：
let a = []; // 创建一个空数组
a.push(1, 2, 3); // push() 方法向数组添加元素
a.reverse(); // 另一种方法：颠倒元素的顺序


// 我们也可以定义我们自己的方法。"this"关键字指的是对象。
// 该方法定义于：在这种情况下，是前面提到的点数组。
points.dist = function () { // 定义一种计算点之间距离的方法
    let p1 = this[0]; // 我们调用的数组的第一个元素
    let p2 = this[1]; // this对象的第二个元素
    let a = p2.x - p1.x; // x 坐标的差异
    let b = p2.y - p1.y; // y坐标的差异
    return Math.sqrt(a * a + // 勾股定理
        b * b); // Math.sqrt() 计算平方根
};
points.dist() // => Math.sqrt(2): 我们两个点之间的距离

// JavaScript 语句包括使用 C、C++、Java 及其他语言语法的条件语句和循环语句。
function abs(x) {
    // if语句...
    if (x >= 0) {
        return x;
    } else {
        return -x;
    }
}

abs(-10) === abs(10) // => true


function sum(array) {
    let sum = 0;
    // for循环语句
    for (let x of array) {
        sum += x;
    }
    return sum;
}

sum(primes) 


function factorial(n) { 
    let product = 1; 
    // while循环语句
    while (n > 1) { 
        product *= n; 
        n--; 
    } 
    return product; 
}

factorial(4) 
function factorial2(n) { 
    let i, product = 1; 
    // for循环语句
    for (i = 2; i <= n; i++) 
        product *= i; 
    return product; 
}

factorial2(5) 

class Point { 
    constructor(x, y) { // 构造函数用于初始化新实例.
        this.x = x; 
        this.y = y; 
    } 

    distance() { // 计算从原点到点的距离的方法。
        return Math.sqrt( 
            this.x * this.x + 
            this.y * this.y 
        );
    }
}

// 使用 "new" 关键字与 Point() 构造函数来创建 Point 对象。
let p = new Point(1, 1); 
// 现在使用 Point 对象 p 的方法
p.distance() // => Math.SQRT2