变量类型

var 数字变量 = 1
var 文本变量 = '一个文本'
var 真假值变量 = true
var 真假值变量2 = 2 > 1 // true

var 数字1 = 123
var 数字2 = 123
数字1 === 数字2 // true

var 无效数字 = NaN
无效数字 === NaN // false
isNaN(无效数字) // true

var 数组1 = []
var 数组2 = []
数组1 === 数组2 // false

数字

1 + 2 // 返回 3
2 * 6 // 返回 12
+5 // 返回 5

Number("123") // 返回 123
Number("123") === 123 // true
Number('123.') // 返回 123

Number(true) // 1
Number(false) // 0

Number("123d") // NaN
Number("ABC") // NaN
Number(undefined) // NaN

var 无效数字 = NaN
无效数字 === NaN // false
isNaN(无效数字) // true

255 === 255.0 // true

0.3 === 0.1 + 0.2 // false
0.1 + 0.2 // 0.30000000000000004

String(0.1 + 0.2) // '0.30000000000000004'

var 小数变量 = 12345.6789;

小数变量.toFixed(); // 返回 "12346"
小数变量.toFixed(1); // 返回 "12345.7"
小数变量.toFixed(2); // 返回 "12345.78"

Math.floor(1.7) // 返回 1，向下取整到 1
Math.ceil(1.7) // 返回 2，向上取整到 2
Math.round(1.7) // 返回 2，四舍五入到 2

文本

var 文本变量1 = '这是一个文本'
var 文本变量2 = "这也是一个文本"
var 文本变量3 = `这还是一个文本`

var 包含引号的文本 = "这是一个包含\"引号\"的文本"

var 包含换行的文本 = '段落1\n段落2'

var 文本1 = 'Hello, '
var 文本2 = 'world!'
var 拼接后的文本 = 文本1 + 文本2 // 'Hello, world!'

var 文本1 = `你的金钱数量：${属性.金钱}。`
var 文本2 = `打 7 折后的价钱为：${(100*0.7).toFixed(2)}。`

var 文本变量 = '这是一个文本'
文本变量.length // 返回 7

var 文本变量 = '这是一个文本'
文本变量[1] // 返回 '是'

var 文本变量 = '这是一个文本'
文本变量.slice(2, 4) // 返回 '一个'

String(123) // 返回 '123'
String(true) // 返回 'true'
String(undefined) // 返回 'undefined'
String(null) // 返回 'null'

var 文本变量 = '这是一个文本，是吗？'
文本变量.indexOf('是') // 返回 1，“是”第一次出现的位置
文本变量.lastIndexOf('是') // 返回 8，“是”最后一次出现的位置

var 文本变量 = 'Hello World!'
文本变量.toUpperCase() // 返回 'HELLO WORLD!'
文本变量.toLowerCase() // 返回 'hello world!'

var 文本变量 = '这是一个文本'
文本变量.replaceAll('是', '不是') // 返回 '这不是一个文本'

'这是一个文本'.split('') // ['这', '是', '一', '个', '文', '本']
'这是一个文本'.split('是') // ['这', '一个文本']
'a,b,c,d,e,f'.split(',') // ['a', 'b', 'c', 'd', 'e', 'f']

var 文本变量 = ' 这是一个文本 '
var 去除空白后的文本 = 文本变量.trim() // '这是一个文本'

真假值

!true // false
!!true // true （取反两次，先变成 false 再变成 true）

var 真假值变量 = 属性.金钱 > 100

Boolean(0) // false
Boolean(1) // true
Boolean('') // false

if (真假值) {

}

比较符号 == 和 ===

123 == '123' // true
true == 1 // true
undefined == null // true

123 === '123' // false
true === 1 // false
undefined === null // false

undefined 和 null

undefined

var 未定义变量;
未定义变量 // undefined

var 变量2 = undefined;
变量2 // undefined

var 对象 = {};
对象.不存在的属性 // undefined

var 数组 = [];
数组[0] // undefined

var 变量 = 数据.读(['不存在', '的', '路径'])
变量 // undefined

null

var 空变量 = null;

?? 操作符

var 变量 = undefined ?? '默认值';
变量 // '默认值'

var 变量2 = null ?? '默认值';
变量2 // '默认值'

var 变量3 = '已定义的值' ?? '默认值';
变量3 // '已定义的值'

转换为其他类型

Boolean(undefined) // false
Boolean(null) // false

String(undefined) // "undefined"
String(null) // "null"

Number(undefined) // NaN
Number(null) // 0

数组

var 数组变量 = ['元素1', '元素2', '元素3'];

数组变量[0] // '元素1'

数组变量[0] = '新元素';
数组变量[0] // '新元素'

数组变量.length // 3

数组变量.push('新元素');
数组变量.length // 4
数组变量[3] // '新元素'

数组变量.pop() // '新元素'
数组变量.length // 3

数组变量.shift() // '新元素'
数组变量.length // 2

数组变量.unshift('新元素');
数组变量.length // 3
数组变量[0] // '新元素'

数组变量.indexOf('元素2') // 1
数组变量.indexOf('不存在的元素') // -1

数组变量.slice(1, 3) // ['元素2', '元素3']

数组变量.splice(1, 1, '新元素') // ['元素2']
数组变量 // ['新元素', '元素3']

数组变量.join(', ') // '新元素, 元素3'

var 数组变量 = ['元素1', '元素2', '元素3'];
var 新数组变量 = [...数组变量, '元素4'];
新数组变量 // ['元素1', '元素2', '元素3', '元素4']

对象

var 对象变量 = {
  键1: '值1',
  键2: '值2',
  键3: '值3'
}

对象变量.键1 // '值1'

对象变量['键1'] // '值1'
var 属性名 = '键2';
对象变量[属性名] // '值2'

对象变量.键1 = '新值';
对象变量.键1 // '新值'

delete 对象变量.键1;
对象变量.键1 // undefined
对象变量 // { 键2: '值2', 键3: '值3' }

'键2' in 对象变量 // true
'不存在的键' in 对象变量 // false

Object.keys(对象变量) // ['键2', '键3', '新键']

Object.values(对象变量) // ['值2', '值3', '新值']

Object.entries(对象变量) // [['键2', '值2'], ['键3', '值3'], ['新键', '新值']]

var 对象变量2 = {
  ...对象变量,
  键4: '值4'
}
对象变量2 // { 键2: '值2', 键3: '值3', 新键: '新值', 键4: '值4' }

函数

function 加法(参数1, 参数2, 参数3) {
  return 参数1 + 参数2 + 参数3; 
}

加法(1, 2, 3); // 返回 6

var 手续费率 = 0.01;
function 计算手续费(金额) {
  return 金额 * 手续费率;
}

function 计算手续费(金额) {
  var 手续费率 = 0.01;
  return 金额 * 手续费率;
}
手续费率; // 这里访问不到 手续费率 临时变量

var 变量1 = function(参数1, 参数2, 参数3) {
  return 参数1 + 参数2 + 参数3; 
}

变量1(1, 2, 3); // 返回 6

var 函数1 = function(参数1, 参数2, 参数3) {
  return 参数1 + 参数2 + 参数3; 
}

var 函数2 = function(参数1, 参数2, 参数3) {
  return 参数1 * 参数2 * 参数3; 
}

var 函数数组 = [函数1, 函数2];

函数数组[0](1, 2, 3); // 返回 6
函数数组[1](1, 2, 3); // 返回 6

var 对象变量 = {
  属性1: function(参数1, 参数2, 参数3) {
    return 参数1 + 参数2 + 参数3;
  }
}

对象变量.属性1(1, 2, 3); // 返回 6

var 变量1 = {
  名字: '张三',
  年龄: 20,
  打招呼: function() {
    return '你好，我叫' + this.名字;
  },
  庆祝生日: function() {
    this.年龄++;
  }
}

变量1.打招呼(); // 返回 '你好，我叫张三'
变量1.年龄; // 返回 20
变量1.庆祝生日();
变量1.年龄; // 返回 21

var 对象变量 = {
  属性1: (参数1, 参数2, 参数3) => {
    // 这里面如果有 this 不会指向函数所在的对象
    return 参数1 + 参数2 + 参数3;
  }
}

function 函数1(回调函数) {
  return 回调函数();
}

函数1(function () {
  return 'Hello, world!';
}); // 返回 'Hello, world!'

typeof 操作符

typeof 123 // "number"
typeof 'Hello' // "string"
typeof true // "boolean"
typeof undefined // "undefined"
typeof null // "object"
typeof {} // "object"
typeof [] // "object"
typeof function() {} // "function"

提示(typeof 临时变量)

变量与 JSON 之间的转换

JSON.stringify()

var 对象变量 = {
  名称: "张三",
  年龄: 30,
  爱好: ["阅读", "旅行"]
};

var 文本变量 = JSON.stringify(对象变量); // '{"名称":"张三","年龄":30,"爱好":["阅读","旅行"]}'

JSON.parse()

var 文本变量 = '{"名称":"张三","年龄":30,"爱好":["阅读","旅行"]}';
var 对象变量 = JSON.parse(文本变量);
对象变量.名称; // "张三"
对象变量.爱好[0]; // "阅读"

注意事项

var 对象 = {
  名称: "张三",
  介绍: undefined,
  打招呼: function() {
    return `你好，我是${this.名称}。`;
  }
};
JSON.stringify(对象); // '{"名称":"张三"}'，undefined 和函数被忽略