JavaScript语法

* number 数字，不论是整数还是小数，数据类型都是number
* string 字符串，
* boolean 布尔值，只有两个，true和false. 只有python中是首字母大写
* object 对象，这个比较特殊.你可以理解为所有被new出来的东西都是对象
* undefined，这个表示未定义.所有没有被定义过的东西默认都是该类型

* 数字相关

var a, b = 20;

console.log(a)  // undefined

console.log(b)  // 20

// 类型查看     typeof()
console.log(typeof (a))


var c = '123';

// js在做 + 运算时，会检测数据类型，如果其中有字符串，则是拼接
// （）中全是数字才是加法运算
console.log(c + 10)   // 12310

// 转换数字     parseInt()
d = parseInt(c)

console.log(d + 10)   // 133

* 字符串相关
s.split(separator)：字符串切割，使用 separator 分隔符进行切割，返回一个由分割后的子字符串组成的数组。

s.substr(start, len)：从字符串的 start 索引位置开始，切割 len 个字符，返回切割后的子字符串。

s.substring(start, end)：从字符串的 start 索引位置开始切割，直到 end 索引位置结束（不包含 end），返回切割后的子字符串。

s.length：获取字符串的长度。

s.charAt(i)：获取字符串中索引位置为 i 的字符。

s.indexOf('xxx')：返回子字符串 'xxx' 在 s 中第一次出现的位置索引，如果没有找到则返回 -1。

s.includes('x××')：判断子字符串 'x××' 是否在 s 中出现，返回布尔值。

s.toUpperCase()：将字符串转换为大写字母形式。

s.startsWith('xxx')：判断字符串是否以子字符串 'xxx' 开头，返回布尔值。

var d = 123;

// 转换字符串    toString()
e = d.toString()

console.log(e + 10)

// 转字符串的另一种写法
var f = 10;
var g = 20;
h = f + '' + g
console.log(h)  // 1020

* i++
* 关于 ++ 和 = 的问题，
* 在重新赋值时，变量在前，直接赋值变量的值。 ++在前 先+再赋值

var i = 10;
i++
console.log(i)  // 11

var i7 = 10;
var e7 = i7++;
console.log(i7) // 11
console.log(e7) // 10

var i8 = 10;
var e8 = ++i8;
console.log(i8) // 11
console.log(e8) // 11


var i9 = 10;
var i9 = i9++;
console.log(i9) // 10

var i5 = 10;
var i5 = ++i5;
console.log(i5) // 11

* bool相关

var bo = 3 < 2;

console.log(bo)  // false

// JavaScript 引擎会将 undefined 转换为 NaN
// 任何数字与 NaN 进行比较都会返回 false
var j = 2 < undefined;
console.log(j)

// 无论正数负数与字符串比较，统一返回false
var q = -8 > '李';
console.log(q)

* 根据 JavaScript 的类型转换规则，空字符串 '' 在被转换为数字时会变成 0
* 比较操作符 === 是严格相等，它会比较两个值的类型和值是否完全相等
* ==，<，>，会在比较之前尝试进行类型转换,只比较值是否相等

// 负数<''   true    负数>'' false
// 正数<''   false   正数>'' true
// 0 > ''   false   0 < '' false
// 0 == ''  true
// 0 === '' false
var o = 0 === '';
console.log(o)

* 运算符相关
* && 相当于python中的and
* &&（逻辑与）操作符的优先级高于 ||（逻辑或）操作符
* || 相当于python中的or
* || 运算符在计算时会尽可能早地确定整个表达式的值，如果其中一个操作数为真，则整个表达式就为真，不会再继续计算后面的操作数。

// &&操作：全部为真，结果为真，一个为假，结果为假
var x = (3 > 2) && (4 > 3) && (5 > 18);
console.log(x)  // false

// ||操作：一个为真则立即返回
var y = (5 > 18) || (3 > 2) && (4 > 3);
console.log(y)  // true


var l = 0 === '' > 'Fox' && 8 + (4 - 7) || -999 < undefined && !(0 === '' > 'Fox') || 'QQ' || !!'true';
console.log('>>>>', l)  // >>>> QQ

* JavaScript中常见运算符的优先级排列（优先级从高到低）：
Member Access（成员访问）：. 和 []
Function Call（函数调用）：() 和 new
Logical NOT（逻辑非）：!
Bitwise NOT（位非）：~
Unary Plus（一元加）和 Unary Negation（一元减）：+ 和 -
Multiplication（乘法）、Division（除法）和 Remainder（取余）：*、/ 和 %
Addition（加法）和 Subtraction（减法）：+ 和 -
Bitwise Shift（位移）：<<、>>、>>>
Relational（关系）：<、>、<=、>=、instanceof、in
Equality（相等性）：==、!=、===、!==
Bitwise AND（位与）：&
Bitwise XOR（位异或）：^
Bitwise OR（位或）：|
Logical AND（逻辑与）：&&
Logical OR（逻辑或）：||
Conditional（三元条件）：? :
Assignment（赋值）：=, +=, -=, *=, /=, %= 等
Comma（逗号）：,（用于分隔表达式）

* 三元表达式    条件？值1:值2

var m = 1 > 2 ? 'QQ' : 'WW'
console.log(m)  // WW

// 嵌套
var c1 = 10;
var c2 = 20;
var c3 = 30;
var c4 = c1 > c2 ? c1 + c2 : c2 > c3 ? c2 - c3 : c3 * c1;
console.log(c4);    // c3 * c1 --> 300

var o1 = 10;
var o2 = 20;
var o3 = o1 > o2 ? o1 : o2 ? o1 : o2
console.log(o3) // 10

* 二进制和十进制转换

var b1 = (5).toString(2)  // string类型 101

var i1 = parseInt('111', 2)   // number类型 7

* | 位或，两个对应位中至少有一个为 1，则该位结果为1，否则为0
* & 位与，两个对应位都为 1，则该位结果为 1，否则为 0

const Read = 0b0001;
const Write = 0b0010;
const Execute = 0b0100;
const Delete = 0b1000;

let userPermissions = Read | Write; // 用户具有读取和写入权限
let requestedPermissions = Read | Execute; // 请求读取和执行权限

function checkPermissions(user, requested) {
    // 如果user拥有对应权限，
    // 那么user & requested 计算之后的值为该权限requested的值
    return (user & requested) === requested;
}

console.log(checkPermissions(userPermissions, requestedPermissions)); // 输出 false，用户没有执行权限

* if语句

var f1 = 50;
if (f1 < 20) {
    console.log('f1小于20');
} else if (f1 < 30) {
    console.log('f1小于30');
} else if (f1 < 40) {
    console.log('f1小于40');
} else if (f1 < 50) {
    console.log('f1小于50');
} else if (f1 <= 60) {
    console.log('f1小于60');
} else {
    console.log('大于60');
}


// 单行if语句
var f2 = 100;
if (f2 < 5) console.log('f2 大于 5');
if (f2 < 20) console.log('f2小于20'); else console.log('f2大于20');


// 如果使用逗号运算符分隔多个表达式，实际上只会取最后一个表达式f4 > 15的值作为条件判断的结果
var f3 = 10, f4 = 20;
if (f3 > f4, 30 > f3, f4 > 15) {
    console.log('条件成立');
}

* switch语句
* break 防止case穿透

var month = 6;
var season = '';

switch (month) {
    case 1:
    case 2:
    case 12:
        season = 'Winter';
        break;
    case 3:
    case 4:
    case 5:
        season = 'Spring';
        break;
    case 6:
    case 7:
    case 8:
        season = 'Summer';
        break;
    case 9:
    case 10:
    case 11:
        season = 'Autumn';
        break;
    default:
        season = 'Invalid month';
}

console.log('The season for month ' + month + ' is ' + season);

* 循环语句 while  do.while  for  forEach

var num = 1;
while (num > 0 && num < 10) {
    console.log('num:', num);
    num += Math.random() > 0.5 ? 1 : -1;
}


var num2 = 0;
do {
    console.log('do..while执行');
} while (num2);


for (var i2 = 1, j2 = 10; i2 < j2; i2++, j2 -= 2) {
    console.log('i2:', i2, 'j2:', j2);
}


var array1 = [10, 20, 30];
for (var item in array1) {
    console.log(array1[item])
}


var array2 = [10, 20, 30];
array2.forEach(function (item) {
    console.log(item)
})

* 数组

var arr1 = [1, 2, 3];

var arr2 = new Array(1, 2, 3);

var arr3 = new Array(3);  // [ <3 empty items> ]    --> [ , , ]

console.log(arr3[0])    // undefined

arr3[2] = '下雨天'   // [ <2 empty items>, '下雨天' ]

console.log(arr3)

arr3[4] = '阴天'

console.log(arr3);  // [ <2 empty items>, '下雨天', <1 empty item>, '阴天' ]

for (var i4 = 0; i4 < arr3.length; i4++) {
    console.log(arr3[i4])
}   // undefined  undefined  下雨天  undefined  阴天

* 对象字面量

// 创建一个对象字面量
var dictionary = {
    "apple": "果实，苹果",
    "banana": "一种水果",
    "car": "汽车，车辆"
};

// 访问对象字面量中的值
console.log(dictionary["apple"]);  // 输出："果实，苹果"
console.log(dictionary["banana"]); // 输出："一种水果"
console.log(dictionary["car"]);    // 输出："汽车，车辆"

// 添加新的键值对
dictionary["dog"] = "狗";

// 删除键值对
delete dictionary["car"];

// 遍历字典中的键值对
for (var key in dictionary) {
    console.log(key + ": " + dictionary[key]);
}