Year 11 SQA Computing: Common Misconceptions and How to Correct Them | Year 11 SQA 计算机：常见误区与纠正方法

📚 Year 11 SQA Computing: Common Misconceptions and How to Correct Them | Year 11 SQA 计算机：常见误区与纠正方法

Many Year 11 pupils studying SQA Computing Science encounter the same tricky misunderstandings year after year. These misconceptions can trip you up in the exam and in practical tasks, but once you know what they are and how to put them right, your confidence and grades will soar. This article pinpoints the most frequent errors in software design, computer systems, databases, web development and programming, giving clear explanations and correcting each one in a friendly, step‑by‑step way.

每一年，学习 SQA 计算机科学的 Year 11 学生都会遇到同样难缠的误解。这些误区可能在考试和实操中绊倒你，但一旦你弄清它们是什么、学会如何纠正，你的信心和成绩都会大幅提升。这篇文章瞄准了软件设计、计算机系统、数据库、网页开发与编程中最常出现的错误，用友好、循序渐进的方式给出清晰的解释与纠正。

1. Misunderstanding Variables and Constants | 变量和常量的误解

A widespread mistake is to treat constants as if they were variables. Pupils sometimes write code that tries to change the value of a constant mid‑program, or they declare a constant thinking it can be updated later. In SQA reference language, a variable is created with a DECLARE statement (or simply by assigning a value), whereas a constant must be declared with CONST and never altered.

一个普遍的错误是把常量当作变量来使用。学生们有时会写出试图在程序运行中途改变常量值的代码，或者声明一个常量却认为以后可以更新它。在 SQA 参考语言中，变量通过 DECLARE 语句（或直接赋值）创建，而常量必须用 CONST 声明并且绝不改动。

To correct this, remember the golden rule: a variable can vary—its value can be reassigned as often as needed. A constant is fixed; it receives its value at declaration and stays the same throughout execution. Exam questions often ask you to identify why a program fails when a constant is accidentally reassigned, so underline the word CONST in your planning and check that it is only set once.

纠正这一点要记住黄金法则：变量可以变化——它的值能被多次重新赋值。常量是固定的，它在声明时获得数值，并在整个执行过程中保持不变。考题常常要求你识别当常量被意外重新赋值时程序为什么出错，因此在草稿上划出 CONST 一词并检查它是否只被设置过一次。

Additionally, students sometimes confuse the naming conventions. In SQA exams, constants are usually written in UPPER_CASE with underscores, and variables in camelCase or lower case. Spotting the difference visually helps prevent accidental changes.

此外，学生有时也会混淆命名规范。在 SQA 考试中，常量通常用 UPPER_CASE 加下划线书写，变量则使用 camelCase 或全小写。在视觉上区分两者有助于防止意外的改动。

2. Off‑by‑One Errors in Loops and Array Indices | 循环与数组索引的“差一错误”

One of the most frustrating bugs is the off‑by‑one error. When iterating through an array, a pupil might write FOR i FROM 1 TO 10 for a ten‑element list, forgetting that array indices start at 0. This either misses the first element or crashes the program by trying to access index 10, which does not exist.

最令人沮丧的 bug 之一是“差一错误”。当遍历一个数组时，学生可能为一个含有十个元素的列表写下 FOR i FROM 1 TO 10，忘记了数组索引是从 0 开始的。这会要么漏掉第一个元素，要么试图访问不存在的索引 10 而导致程序崩溃。

The correct approach is to loop from 0 to length‑1. For an array ‘scores’ of size 10, use FOR i FROM 0 TO 9 or, more generally, FOR i FROM 0 TO LENGTH(scores)‑1. When using a conditional loop, make sure the test checks the correct boundary so that the loop runs exactly the intended number of times.

正确的方式是从 0 循环到长度减 1。对于一个大小为 10 的数组 ‘scores’，使用 FOR i FROM 0 TO 9，或更一般地 FOR i FROM 0 TO LENGTH(scores)-1。使用条件循环时，确保测试条件检查了正确的边界，使循环恰好运行预期的次数。

Another related slip is with ordered output. When asked to print the 1st, 2nd, 3rd elements, students sometimes output i instead of i+1. A quick desk check with a small array can reveal these mistakes before the final exam.

另一个相关失误是序号输出。当要求打印第 1、第 2、第 3 个元素时，学生们有时会输出 i 而不是 i+1。在最终考试前用一个小数组进行桌面检查就能发现这类错误。

3. Confusing RAM and ROM | RAM 与 ROM 的区别混淆

Memory types are a classic exam topic, and the roles of RAM (Random Access Memory) and ROM (Read Only Memory) are frequently muddled. Many learners believe RAM stores data permanently or that ROM is used for running applications. Neither is correct.

存储器类型是经典的考试话题，而 RAM（随机存取存储器）和 ROM（只读存储器）的功能常常被搞混。许多学生认为 RAM 能永久保存数据，或者 ROM 被用来运行应用程序。这两种想法都不正确。

Feature	RAM	ROM
Volatility	Volatile – loses content when power is off	Non‑volatile – retains content without power
Purpose	Holds data and programs currently in use	Stores firmware, e.g., BIOS / boot instructions
Writable	Read and write	Read only (in typical usage)

RAM is your computer’s working memory. When you open a document or run a game, it is loaded into RAM for fast access. Shut down the machine and RAM empties. ROM, on the other hand, holds the essential start‑up programme (the BIOS) that tells the computer what to do when it turns on. This must survive power‑offs.

RAM 是计算机的工作内存。当你打开一份文档或运行一款游戏时，它会被加载到 RAM 中以供快速访问。关机后 RAM 清空。而 ROM 则保存着必不可少的启动程序（BIOS），告诉计算机开机时该做什么。这一内容必须在断电后依然存在。

Exam questions often present a scenario, such as “Why does a game need to be installed into RAM before playing?” The correct answer always mentions volatile, fast access memory versus permanent storage on the hard disk. Never claim that RAM stores your photos forever.

考题常会给出一个场景，比如“为什么玩游戏前需要把游戏安装到 RAM 里？”正确答案总要提及易失性、快速存取的内存与硬盘上的永久存储。绝对不要说 RAM 能永远保存你的照片。

4. Binary Addition and Overflow Mistakes | 二进制加法与溢出错误

Binary arithmetic is a reliable source of confusion. Pupils often forget to carry a ‘1’ correctly or misapply the carry to the next column. The rules themselves are simple: 0+0=0, 0+1=1, 1+0=1, 1+1=0 carry 1, and 1+1+1=1 carry 1.

二进制算术是常见的混乱来源。学生们经常忘记正确地进“1”，或者将进位错误地应用到下一列。规则本身很简单：0+0=0、0+1=1、1+0=1、1+1=0 进 1、1+1+1=1 进 1。

Stand‑alone eight‑bit addition can trip you up when the result exceeds 255 (unsigned) or 127 (signed two’s complement). Overflow occurs when the carry into the most‑significant bit differs from the carry out. Many students simply ignore the overflow flag and write down an answer that doesn’t fit in 8 bits, losing marks.

独立的八位加法可能会因结果超出 255（无符号）或 127（有符号二进制补码）而让你出错。当进入最高位的进位和进位输出不同时，便发生溢出。许多学生直接忽略溢出标志，写下一个在 8 位里装不下的答案，从而丢分。

To master binary addition, practise with a neat column layout, drawing the carry row above the numbers. For example, adding 1010₁₀₂ (that is 10 in decimal) and 0110₂ (6) gives 10000₂ (16) – but that’s a 5‑bit result. In an 8‑bit register you must recognise the overflow. Checking your work with decimal conversion is a great habit.

要掌握二进制加法，请使用整洁的列排版进行练习，并在数字上方划一行进位。例如，将 1010₂（即十进制 10）与 0110₂（6）相加得到 10000₂（16）——但这已经是 5 位的结果。在 8 位寄存器中你必须识别出溢出。用十进制转换来验算是一个好习惯。

5. Mixing Up Primary Keys and Foreign Keys | 主键与外键的混用

Database design questions often ask you to identify or justify primary and foreign keys. A typical mistake is to think a foreign key must be unique in its own table, or that the primary key is the field that links to another table. In fact, the primary key uniquely identifies each record in its table, while the foreign key exists to create a relationship by pointing to a primary key in a different table.

数据库设计题经常要求你识别或说明主键和外键。一个典型的错误是认为外键在自己的表中必须是唯一的，或者认为主键是用来连接另一张表的字段。实际上，主键唯一标识它所在表中的每一条记录，而外键的存在是为了通过指向另一张表的主键来建立关系。

Imagine a ‘Students’ table with a primary key StudentID. An ‘Enrolment’ table contains the foreign key StudentID to link each enrolment back to a student. The same student can have many enrolments, so the foreign key column is not unique in the Enrolment table. Grasping this distinction is essential for drawing correct entity‑relationship diagrams.

设想一张“Students”表，主键为 StudentID。一张“Enrolment”表包含外键 StudentID，用以将每条注册记录关联回学生。同一个学生可以有多次注册，因此外键列在 Enrolment 表中并非唯一。把握这一区别对于绘制正确的实体关系图至关重要。

Another common slip is assigning a composite primary key carelessly. Remember that the minimal set of fields must uniquely identify a row. If you pick a combination that is likely to repeat, the database structure will be flawed. Always test with sample data.

另一个常见失误是随意分配复合主键。要记住最小的字段组合必须能唯一标识一行。如果你选择了一个很可能重复的组合，数据库结构就会有缺陷。总是要用样例数据来验证。

6. Assignment ‘=’ vs Equality ‘==’ in Programming | 编程中赋值“=”与相等“==”的混淆

In many programming languages and in SQA pseudocode variants, a single equals sign is used for assignment while a double equals sign tests for equality. Students frequently write IF score = 10 THEN when they mean to compare, but depending on the context the examiner may interpret this as an assignment. This leads to logical errors or constant conditions that are always true.

在许多编程语言和 SQA 伪代码变体中，单个等号用于赋值，双等号用于测试相等性。学生们经常在打算比较时写下 IF score = 10 THEN，但根据上下文，考官可能会把这解读为赋值。这会导致逻辑错误或始终为真的条件。

The safe approach is to use the keyword SET for assignment (e.g., SET score TO 10) and reserve = or == for comparison as required by the reference language you are following. In SQA National 5 expressions, = is often used as a comparison operator when it appears in a condition after IF, but the distinction must be made crystal clear by code layout and comments.

安全的做法是使用关键字 SET 进行赋值（例如 SET score TO 10），并将 = 或 == 保留给比较运算，具体取决于你遵循的参考语言。在 SQA National 5 表达式中，当 = 出现在 IF 后面的条件中时，通常作为比较运算符，但通过代码布局和注释必须让这一区别极为清晰。

Practise by writing short code snippets that deliberately contrast assignment and comparison, and then trace the variable values. Seeing the difference in operation will cement the concept.

通过编写故意对比赋值与比较的短代码片段，然后追踪变量的值来练习。看到操作上的区别将会巩固这一概念。

7. CSS Specificity Misunderstandings | CSS 选择器优先级的误解

When a web page doesn’t look as expected, the culprit is often a misunderstanding of how CSS chooses which rule to apply. Many students think “the last rule in the stylesheet always wins”. This is only true when the selectors have equal specificity.

当网页显示不如人意时，罪魁祸首往往是对 CSS 如何选择应用规则的理解有误。很多学生认为“样式表中最后一条规则总是胜出”。这只在选择器特异性相同时才成立。

Specificity works like a point system: an ID selector (#header) outweighs a class selector (.nav), which in turn outweighs an element selector (div). So a rule #header .nav will override a later rule .nav even if the later rule appears at the bottom of the file. Forgetting this leads to frustration when changes seem to be ignored.

特异性像一个积分系统：ID 选择器（#header）的权重高于类选择器（.nav），而类选择器又高于元素选择器（div）。因此规则 #header .nav 会覆盖位于后面的规则 .nav，即便这条较后的规则出现在文件底部。忘记这一点就会让改动似乎被无视，令人沮丧。

Develop the habit of using the browser’s developer tools to inspect which styles are actually being applied and which have been overridden. When stuck, try to increase specificity by adding a more specific selector rather than piling on !important.

养成使用浏览器开发者工具来检查实际应用了哪些样式、哪些被覆盖的习惯。卡住时，试着通过添加一个更具体的选择器来提高特异性，而不是堆砌 !important。

8. HTML Tag Closing and Nesting Errors | HTML 标签关闭与嵌套错误

Forgotten closing tags and poorly nested elements can break entire page layouts. A common mistake is writing Hello – the strong element should be closed before the paragraph ends. Browsers may try to fix the error, but the result is unpredictable and will lose marks in an exam’s practical paper.

忘记关闭标签以及糟糕的元素嵌套可能毁掉整个页面布局。一个常见错误是写下 Hello —— strong 元素应该在段落结束前关闭。浏览器也许会尝试修正错误，但结果是不可预测的，在考试实践卷中还会因此丢分。

Remember the “last opened, first closed” rule: if you open a and then a , you must close before . This is exactly like brackets in maths. A cleanly indented HTML structure helps your eyes spot mismatches, especially in nested lists and tables.

记住“后进先出”的规则：如果你打开了 ，然后又打开了 ，就必须在关闭 之前关闭 。这就像数学中的括号一样。整洁缩进的 HTML 结构有助于眼睛发现不匹配，特别是在嵌套列表和表格中。

It is also worth noting

Published by TutorHao | Year 11 Computer Science Revision Series | aleveler.com

更多咨询请联系16621398022（同微信）

Year 11 SQA Computing: Common Misconceptions and How to Correct Them | Year 11 SQA 计算机：常见误区与纠正方法