01引入方式与运行环境
JavaScript 可以写在 HTML 里,也可以独立成文件。现代项目推荐独立文件,并在末尾或使用 defer 引入,避免阻塞渲染。
<!-- 1. 内联脚本:仅用于极小的演示 -->
<script>
console.log('Hello');
</script>
<!-- 2. 外部脚本:推荐 -->
<script src="main.js" defer></script>
<!-- 3. ES Module:可以用 import / export -->
<script type="module" src="app.js"></script>
| 方式 | 行为 | 适合 |
|---|---|---|
普通 <script> | 立即下载并执行,阻塞解析 | 需要尽早执行的少量代码 |
defer | 并行下载,DOM 解析完成后按顺序执行 | 常规脚本 |
async | 下载完成后立即执行,顺序不定 | 独立统计脚本 |
type="module" | 默认延迟执行,拥有独立作用域 | 现代模块化项目 |
调试入口:在浏览器中按 F12 打开开发者工具,切换到 Console。这里可以执行任意 JS、查看变量、捕获报错,是最重要的学习工具。
02变量、常量与数据类型
现代 JavaScript 用 const 与 let 声明变量,var 已不推荐使用(存在变量提升与作用域问题)。
// 常量:一旦赋值不可重新指向,优先使用
const siteName = '拾光前端';
// 变量:值会变化时使用
let visitCount = 0;
visitCount += 1;
// 对象与数组的内容可以修改(const 约束的是绑定,不是内容)
const colors = ['绿', '粉'];
colors.push('蓝'); // 允许
// colors = []; // 报错
const user = { name: '拾光', age: 18 };
user.age = 19; // 允许
// 原始类型
const str = '文本'; // string
const num = 42; // number
const bool = true; // boolean
const empty = null; // null:有意为空
let notDefined; // undefined:未赋值
const big = 9007199254740993n; // bigint
const sym = Symbol('id'); // symbol
// 引用类型
const obj = { a: 1 };
const arr = [1, 2, 3];
const fn = function () {};
const date = new Date();
// 类型判断
typeof 'abc'; // 'string'
typeof 42; // 'number'
typeof null; // 'object'(历史遗留,需注意)
Array.isArray([]); // true
Number.isNaN(NaN); // true
模板字符串与解构
const name = '拾光';
const count = 6;
// 模板字符串:支持换行与插值
const message = `你好,${name}!
本站共有 ${count} 个篇章。`;
// 对象解构
const user = { name: '拾光', age: 18, city: '杭州' };
const { name: userName, age, city = '未知' } = user;
// 数组解构
const [first, second, ...rest] = [1, 2, 3, 4, 5];
// first = 1, second = 2, rest = [3, 4, 5]
// 展开运算符:浅拷贝与合并
const copy = { ...user, age: 20 };
const merged = [...colors, '白'];
// 可选链与空值合并
const title = user?.profile?.title ?? '无标题';
浅拷贝陷阱:展开运算符只复制第一层。如果对象里嵌套了对象,修改嵌套属性仍会影响原对象,需要深拷贝(structuredClone(obj) 是现代浏览器提供的深拷贝方案)。
03运算、比较与流程控制
// 使用 === 严格相等,避免隐式类型转换
1 == '1'; // true (不推荐)
1 === '1'; // false (推荐)
// 逻辑运算符会返回「值」而不只是布尔值
const nickname = inputName || '匿名用户';
const safeCount = count ?? 0; // 仅当 count 为 null / undefined 时兜底
// 三元表达式
const label = score >= 60 ? '及格' : '继续努力';
// if / else if / else
if (score >= 90) {
level = '优秀';
} else if (score >= 60) {
level = '及格';
} else {
level = '待提升';
}
// switch:适合枚举值分支
switch (role) {
case 'admin':
console.log('管理员');
break;
case 'editor':
console.log('编辑');
break;
default:
console.log('访客');
}
// 循环
for (let i = 0; i < 3; i++) {
console.log(i); // 0 1 2
}
for (const item of list) { // 遍历值
console.log(item);
}
for (const key in obj) { // 遍历键(包含原型链上可枚举属性)
console.log(key, obj[key]);
}
// 提前退出
for (const n of numbers) {
if (n < 0) continue; // 跳过本次
if (n > 100) break; // 结束循环
console.log(n);
}
为什么推荐 ===?== 会做隐式转换,例如 '' == 0 为 true、null == undefined 为 true,容易引发难以排查的 bug。除非刻意利用,否则一律用严格相等。
04函数、作用域与箭头函数
// 函数声明:会被提升,可在定义前调用
function add(a, b) {
return a + b;
}
// 函数表达式
const minus = function (a, b) {
return a - b;
};
// 箭头函数:更简洁,没有自己的 this
const multiply = (a, b) => a * b;
// 默认参数与剩余参数
function createCard(title, tags = [], ...extras) {
return { title, tags, extras };
}
// 解构参数
function render({ title, content, tags = [] }) {
return `${title}: ${content} (${tags.join('/')})`;
}
// 高阶函数:函数作为参数或返回值
function withLog(fn) {
return function (...args) {
console.log('调用参数:', args);
return fn(...args);
};
}
const loggedAdd = withLog(add);
loggedAdd(2, 3); // 打印参数,返回 5
// 作用域链
const globalVar = 'global';
function outer() {
const outerVar = 'outer';
function inner() {
const innerVar = 'inner';
// 可以访问 innerVar -> outerVar -> globalVar
console.log(innerVar, outerVar, globalVar);
}
inner();
}
outer();
var、let、const 的作用域对比
| var | let | const | |
|---|---|---|---|
| 作用域 | 函数作用域 | 块级作用域 | 块级作用域 |
| 变量提升 | 会,初始为 undefined | 会,但有暂时性死区 | 同 let |
| 重复声明 | 允许 | 不允许 | 不允许 |
| 重新赋值 | 允许 | 允许 | 不允许 |
点击「运行示例」查看输出…
05数组与对象常用方法
日常开发中,数据处理大多围绕数组与对象展开。下面这些方法几乎每天都会用到,值得熟记。
const books = [
{ title: '瓦尔登湖', year: 1854, tags: ['自然', '哲学'] },
{ title: '人间草木', year: 1998, tags: ['散文'] },
{ title: '小王子', year: 1943, tags: ['童话', '哲学'] }
];
// forEach:遍历,不返回新数组
books.forEach(book => console.log(book.title));
// map:映射为新数组(最常用)
const titles = books.map(book => book.title);
// ['瓦尔登湖', '人间草木', '小王子']
// filter:筛选
const old = books.filter(book => book.year < 1950);
// 瓦尔登湖、小王子
// find / findIndex:找第一个匹配项
const found = books.find(book => book.title === '小王子');
const index = books.findIndex(book => book.title === '小王子');
// some / every:存在 / 全部满足
const hasPhilosophy = books.some(book => book.tags.includes('哲学'));
const allOld = books.every(book => book.year < 2000);
// reduce:归约,可做求和、分组、去重
const totalYear = books.reduce((sum, book) => sum + book.year, 0);
const byTag = books.reduce((acc, book) => {
book.tags.forEach(tag => {
(acc[tag] ||= []).push(book.title);
});
return acc;
}, {});
// { 自然: [...], 哲学: [...], 散文: [...], 童话: [...] }
// sort:原地排序,会修改原数组
const sorted = [...books].sort((a, b) => a.year - b.year);
// flat / flatMap
const nested = [[1, 2], [3, [4]]];
nested.flat(2); // [1, 2, 3, 4]
// Object 常用方法
Object.keys(books[0]); // ['title', 'year', 'tags']
Object.values(books[0]);
Object.entries(books[0]); // [['title', ...], ...]
Object.fromEntries([['a', 1]]); // { a: 1 }
Object.freeze(books[0]); // 冻结,禁止修改
链式思维:先 filter 筛选,再 map 取字段,最后 reduce 汇总。大多数数据变换都能用这条链路表达,代码也更容易读。
06DOM:用代码操控页面
浏览器把 HTML 解析成一棵 DOM 树,JavaScript 可以通过 document 访问并修改它。修改 DOM 会触发浏览器的重新渲染。
// 查询元素
const title = document.querySelector('.card__title'); // 第一个匹配
const allCards = document.querySelectorAll('.card'); // NodeList
const byId = document.getElementById('app');
// 修改内容(注意 XSS:不要直接插入用户输入)
title.textContent = '新的标题'; // 纯文本,安全
title.innerHTML = '<em>斜体标题</em>'; // 解析 HTML
// 修改样式
title.style.color = '#4c6b57';
title.classList.add('is-active');
title.classList.toggle('hidden', false);
// 修改属性
const link = document.querySelector('a');
link.setAttribute('aria-current', 'page');
link.dataset.id = '42';
// 创建与插入
const li = document.createElement('li');
li.textContent = '新条目';
document.querySelector('ul').append(li);
// 批量插入:DocumentFragment 只触发一次重排
const frag = document.createDocumentFragment();
for (let i = 0; i < 100; i++) {
const item = document.createElement('li');
item.textContent = `条目 ${i}`;
frag.append(item);
}
document.querySelector('ul').append(frag);
// 删除
li.remove();
// 读取尺寸与位置
const rect = title.getBoundingClientRect();
console.log(rect.width, rect.height, rect.top);
// 现代 API:更简洁
document.querySelector('.list').replaceChildren(...newItems);
innerHTML 与 XSS:把用户输入直接拼进 innerHTML 会导致脚本注入。优先用 textContent;确实需要渲染 HTML 时,务必先做转义或使用可信的富文本库。
07事件与事件委托
事件是页面与用户之间的桥梁。理解「捕获 → 目标 → 冒泡」三个阶段,就能写出更高效、更易维护的交互代码。
const btn = document.querySelector('.btn');
// 1. 基础监听
btn.addEventListener('click', function (event) {
console.log('点击了', event.target);
});
// 2. 事件委托:把监听器挂在父元素上
document.querySelector('.list').addEventListener('click', function (e) {
const item = e.target.closest('.list__item');
if (!item) return;
console.log('点击了条目:', item.dataset.id);
});
// 3. 阻止默认行为与冒泡
link.addEventListener('click', function (e) {
e.preventDefault(); // 阻止跳转
e.stopPropagation(); // 阻止继续冒泡
});
// 4. 只执行一次
btn.addEventListener('click', function () {
console.log('只会触发一次');
}, { once: true });
// 5. 自定义事件
const bus = new EventTarget();
bus.addEventListener('save', e => console.log('已保存', e.detail));
bus.dispatchEvent(new CustomEvent('save', { detail: { id: 1 } }));
// 6. 键盘与输入
input.addEventListener('input', e => {
console.log('当前值:', e.target.value);
});
window.addEventListener('keydown', e => {
if (e.key === 'Escape') closeDialog();
});
// 7. 滚动与尺寸(性能敏感,注意节流)
window.addEventListener('scroll', () => {
console.log(window.scrollY);
}, { passive: true });
为什么用事件委托?列表项可能有几百个,逐个绑定监听器既占内存又难维护。把监听器放在父容器上,利用冒泡统一处理,新增元素也自动生效。
08闭包、this 与执行上下文
这三者是 JavaScript 面试与实战中的高频难点。理解了它们,很多「看起来奇怪」的行为都能解释得通。
闭包:函数记住了它出生时的环境
function createCounter() {
let count = 0; // 被闭包「保存」下来
return {
increment() { count++; },
decrement() { count--; },
get value() { return count; }
};
}
const counter = createCounter();
counter.increment();
counter.increment();
console.log(counter.value); // 2
// 外部无法直接访问 count,只能通过暴露的方法修改
// 这就是「私有变量」的经典实现
// 常见应用:防抖
function debounce(fn, delay = 300) {
let timer = null;
return function (...args) {
clearTimeout(timer);
timer = setTimeout(() => fn.apply(this, args), delay);
};
}
const onSearch = debounce(keyword => {
console.log('搜索:', keyword);
}, 500);
this 的指向规则
| 调用方式 | this 指向 |
|---|---|
obj.method() | obj 本身 |
普通函数 fn() | 严格模式下为 undefined,非严格为 window |
| 箭头函数 | 继承外层作用域的 this,无法被改变 |
fn.call(obj) / apply / bind | 指定的对象 |
new Fn() | 新创建的实例 |
| DOM 事件回调 | 绑定事件的元素(普通函数) |
const user = {
name: '拾光',
greet() {
console.log('你好,' + this.name);
}
};
user.greet(); // 你好,拾光
// 赋值后再调用,this 丢失
const fn = user.greet;
fn(); // 你好,undefined
// 用 bind 固定 this
const bound = user.greet.bind(user);
bound(); // 你好,拾光
// 箭头函数不绑定自己的 this
const timer = {
seconds: 0,
start() {
setInterval(() => {
this.seconds++; // 这里的 this 指向 timer
}, 1000);
}
};
09原型链与 class
JavaScript 的对象通过「原型链」实现继承。ES6 的 class 只是更友好的语法糖,底层仍然是原型。
class Book {
#secret = '私有字段'; // 真正的私有属性
constructor(title, year) {
this.title = title;
this.year = year;
}
get age() {
return new Date().getFullYear() - this.year;
}
summary() {
return `${this.title}(${this.year})`;
}
static create(title, year) {
return new Book(title, year);
}
}
class Ebook extends Book {
constructor(title, year, format) {
super(title, year); // 必须先调用 super
this.format = format;
}
summary() {
return `${super.summary()} · ${this.format}`; // 调用父类方法
}
}
const epub = new Ebook('瓦尔登湖', 1854, 'EPUB');
console.log(epub.summary());
console.log(epub.age);
console.log(epub instanceof Book); // true
// 原型链的本质
Object.getPrototypeOf(epub) === Ebook.prototype; // true
Object.getPrototypeOf(Ebook.prototype) === Book.prototype; // true
10异步:从回调到 async/await
JavaScript 是单线程的,耗时任务(网络请求、定时器)不能阻塞主线程。异步机制让这些任务在完成后通过回调返回结果。
// 1. 回调:容易形成「回调地狱」
setTimeout(() => {
console.log('1 秒后');
setTimeout(() => {
console.log('再过 1 秒');
}, 1000);
}, 1000);
// 2. Promise:把异步结果包装成对象
function wait(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
wait(800)
.then(() => console.log('完成'))
.catch(err => console.error(err))
.finally(() => console.log('无论成败都执行'));
// 3. async / await:用同步写法表达异步逻辑
async function loadBooks() {
try {
const res = await fetch('/api/books');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();
return data;
} catch (err) {
console.error('加载失败:', err);
return [];
}
}
// 4. 并发:并行请求,等全部完成
async function loadDashboard() {
const [profile, books, stats] = await Promise.all([
fetch('/api/profile').then(r => r.json()),
fetch('/api/books').then(r => r.json()),
fetch('/api/stats').then(r => r.json())
]);
return { profile, books, stats };
}
// 5. 容错:某个失败也继续(allSettled)
const results = await Promise.allSettled([
fetch('/api/a'),
fetch('/api/b')
]);
// 6. 超时控制
function timeout(promise, ms) {
const abort = new Promise((_, reject) =>
setTimeout(() => reject(new Error('请求超时')), ms)
);
return Promise.race([promise, abort]);
}
事件循环简述:同步代码先执行;遇到异步任务交给浏览器计时 / 网络线程;完成后把回调放入任务队列;主线程空闲时再依次执行。Promise 回调进入微任务队列,优先级高于宏任务(setTimeout)。
11ES6+ 与模块化
模块化让代码可以拆分、复用与按需加载。浏览器原生支持 ES Module,无需构建工具也能使用 import / export。
// 具名导出
export const PI = 3.14159;
export function debounce(fn, delay = 300) {
let timer;
return (...args) => {
clearTimeout(timer);
timer = setTimeout(() => fn(...args), delay);
};
}
// 默认导出:一个模块通常只有一个
export default class Store {
constructor(initial = {}) {
this.state = initial;
}
get(key) { return this.state[key]; }
set(key, value) { this.state[key] = value; }
}
import Store, { PI, debounce } from './utils.js';
const store = new Store({ theme: 'light' });
// 动态导入:按需加载,减小首屏体积
button.addEventListener('click', async () => {
const { renderChart } = await import('./chart.js');
renderChart('#canvas');
});
值得记住的新语法
// 逻辑赋值
config.debug ||= false;
config.retries ??= 3;
// 数字分隔符
const million = 1_000_000;
// Array.prototype.at:支持负索引
const last = list.at(-1);
// Object.hasOwn:比 hasOwnProperty 更安全
Object.hasOwn(user, 'name');
// 顶层 await(仅限 module)
const data = await fetch('/api/config').then(r => r.json());
// structuredClone:原生深拷贝
const deep = structuredClone({ a: { b: 1 } });
// Intl:格式化日期与数字
new Intl.DateTimeFormat('zh-CN', { dateStyle: 'long' }).format(new Date());
new Intl.NumberFormat('zh-CN', { style: 'currency', currency: 'CNY' }).format(1288);
12交互实战:计数器与迷你待办
把前面学到的变量、函数、DOM 与事件串起来,做一个最小但完整的交互示例。代码只有三十多行,却包含了状态、渲染与事件三要素。
state 变化 → 重新渲染 → 用户看到新数字
// 1. 找到元素
const numEl = document.getElementById('counterNum');
const plusBtn = document.getElementById('plusBtn');
const minusBtn = document.getElementById('minusBtn');
// 2. 定义状态
let count = 0;
// 3. 渲染函数:状态 -> 视图
function render() {
numEl.textContent = count;
numEl.style.color = count > 0 ? '#4c6b57' : (count < 0 ? '#a3716d' : '#33302b');
}
// 4. 绑定事件:事件 -> 修改状态 -> 渲染
plusBtn.addEventListener('click', () => {
count++;
render();
});
minusBtn.addEventListener('click', () => {
count--;
render();
});
render(); // 初始化视图
迷你待办:状态驱动渲染
const form = document.getElementById('todoForm');
const input = document.getElementById('todoInput');
const list = document.getElementById('todoList');
// 唯一数据源
let todos = [];
function render() {
list.innerHTML = '';
todos.forEach(todo => {
const li = document.createElement('li');
li.className = 'todo' + (todo.done ? ' is-done' : '');
li.dataset.id = todo.id;
const label = document.createElement('label');
const checkbox = document.createElement('input');
checkbox.type = 'checkbox';
checkbox.checked = todo.done;
const span = document.createElement('span');
span.textContent = todo.text;
label.append(checkbox, span);
const del = document.createElement('button');
del.type = 'button';
del.textContent = '删除';
del.className = 'todo__del';
li.append(label, del);
list.append(li);
});
}
form.addEventListener('submit', e => {
e.preventDefault();
const text = input.value.trim();
if (!text) return;
todos.push({ id: Date.now(), text, done: false });
input.value = '';
render();
});
// 事件委托:一个监听器处理勾选与删除
list.addEventListener('click', e => {
const li = e.target.closest('.todo');
if (!li) return;
const id = Number(li.dataset.id);
if (e.target.matches('input[type="checkbox"]')) {
todos = todos.map(t => t.id === id ? { ...t, done: !t.done } : t);
}
if (e.target.matches('.todo__del')) {
todos = todos.filter(t => t.id !== id);
}
render();
});
13常见坑与调试技巧
- 在 DOM 加载前查询元素。脚本要放在 body 末尾,或使用
defer/DOMContentLoaded。 - 把异步当同步。
fetch返回的是 Promise,忘记await会拿到 Promise 对象而不是数据。 - 误以为 const 对象不可变。const 只固定引用,属性仍可修改。
- 在循环里使用 var。所有回调共享同一个变量,应改用 let。
- 内存泄漏。定时器、事件监听、闭包引用未清理,页面越用越卡。
- 频繁操作 DOM。在循环里反复改 DOM 会触发多次重排,应集中修改或使用 DocumentFragment。
常用调试手段
// 打印与分组
console.log('普通日志');
console.warn('警告');
console.error('错误');
console.table([{ name: 'A', age: 18 }, { name: 'B', age: 20 }]);
console.group('请求信息');
console.log('url', '/api/books');
console.groupEnd();
// 计时
console.time('渲染');
render();
console.timeEnd('渲染');
// 断言
console.assert(count > 0, 'count 应大于 0');
// 断点:在 Sources 面板点击行号,或写 debugger
function calculate() {
debugger; // 执行到这里暂停
return 1 + 1;
}
// 捕获全局错误
window.addEventListener('error', e => {
console.error('运行时错误:', e.message, e.filename, e.lineno);
});
window.addEventListener('unhandledrejection', e => {
console.error('未处理的 Promise 拒绝:', e.reason);
});
下一步:语言基础打牢之后,去 进阶篇章 看看 Canvas、Web Components 与 Service Worker,把能力边界再往外推一圈。