这是关于 IPv4 子网的规范问题。
有关的：
子网划分是如何工作的，您是如何手动或在脑海中进行的？ 有人可以从概念上和几个例子来解释吗？服务器故障有很多子网作业问题，因此我们可以使用答案将它们指向服务器故障本身。
- 如果我有一个网络，我如何弄清楚如何拆分它？
- 如果给我一个网络掩码，我怎么知道它的网络范围是什么？
- 有时有一个斜线后跟一个数字，那个数字是多少？
- 有时有子网掩码，也有通配符掩码，它们看起来是一样的，但它们是不同的？
- 有人为此提到了一些关于了解二进制的内容？
AskOverflow.Dev
存在 IP 子网以允许路由器为数据包选择适当的目的地。您可以出于逻辑原因（防火墙等）或物理需要（较小的广播域等）使用 IP 子网来分解较大的网络。
简而言之，IP 路由器使用您的 IP 子网来做出路由决策。了解这些决策是如何工作的，您就可以了解如何规划 IP 子网。
数到 1
如果您已经精通二进制（以 2 为基数）表示法，则可以跳过本节。
对于那些剩下的人：为不流利的二进制表示而感到羞耻！
是的，这可能有点苛刻。学习以二进制计数，学习将二进制转换为十进制并返回的快捷方式真的非常容易。你真的应该知道怎么做。
二进制数非常简单，因为您只需要知道如何数到 1！
想想汽车的“里程表”，除了与传统的里程表不同，每个数字只能从 0 数到 1。当汽车刚从工厂出来时，里程表的读数是“00000000”。
当您驾驶第一英里时，里程表显示“00000001”。到目前为止，一切都很好。
当您行驶第二英里时，里程表的第一个数字回滚到“0”（因为它的最大值是“1”），里程表的第二个数字回滚到“1”，使里程表读数为“ 00000010”。这看起来像十进制的数字 10，但它实际上是二进制的 2（到目前为止您驾驶汽车的英里数）。
当您行驶第三英里时，里程表显示“00000011”，因为里程表的第一个数字再次转动。以二进制表示的数字“11”与十进制数字 3 相同。
最后，当您行驶了第四英里时，两个数字（在第三英里结束时读数为“1”）回滚到零位置，第三个数字回滚到“1”位置，给我们“ 00000100”。那是十进制数 4 的二进制表示。
如果你愿意，你可以记住所有这些，但你真的只需要了解小里程表是如何随着它计数的数字变大而“滚动”的。它与传统十进制里程表的操作完全相同，只是在我们虚构的“二进制里程表”上每个数字只能是“0”或“1”。
要将十进制数字转换为二进制，您可以将里程表向前滚动，逐个滴答，大声计数，直到您滚动它的次数等于要转换为二进制的十进制数。在所有的计数和滚动之后，里程表上显示的任何内容都将是您计数到的十进制数的二进制表示。
由于您了解里程表如何向前滚动，您也将了解它如何向后滚动。要将里程表上显示的二进制数转换回十进制数，您可以一次将里程表向后滚动一个刻度，大声计数直到里程表读数为“00000000”。完成所有计数和滚动后，您大声说出的最后一个数字将是里程表开始时二进制数的十进制表示。
以这种方式在二进制和十进制之间转换值将非常繁琐。你可以这样做，但它不会很有效。学习一个小算法来更快地完成它更容易。
顺便说一句：二进制数中的每个数字都称为“位”。那是“二进制”中的“b”和“数字”中的“it”。一点点都没有挖掘它。
将诸如“1101011”之类的二进制数转换为十进制是一个简单的过程，并带有一个方便的小算法。
首先计算二进制数中的位数。在这种情况下，有 7 个。在一张纸上（在您的脑海中，在文本文件中等）制作 7 个分区，然后从右到左开始填写它们。在最右边的插槽中，输入数字“1”，因为我们总是以“1”开头。在左边的下一个槽中输入右边槽中的值的两倍（因此，下一个中的“2”，下一个中的“4”）并继续直到所有槽都已满。（随着你越来越多地这样做，你最终会记住这些数字，它们是 2 的幂。我的脑海中最多可以达到 131,072，但之后我通常需要一个计算器或纸）。
所以，你应该在你的小插槽中的纸上写下以下内容。
从插槽下方的二进制数中转录位，如下所示：
现在，添加一些符号并计算问题的答案：
做所有的数学，你应该想出：
就是这样。十进制的“1101011”是107。这只是简单的步骤和简单的数学运算。
将十进制转换为二进制同样简单，并且是相同的基本算法，反向运行。
假设我们要将数字 218 转换为二进制。从一张纸的右边开始，写下数字“1”。在左边，将该值加倍（因此，“2”）并继续向纸的左侧移动，使最后一个值加倍。如果您要写入的数字大于正在转换的数字，请停止写入。否则，继续将先前的数字加倍并写入。（使用这种算法将一个大数，如 34,157,216,092 转换为二进制可能有点乏味，但它肯定是可能的。）
所以，你的纸上应该有：
您停止在 128 处写入数字，因为将 128 加倍，即为 256，将大于转换后的数字 (218)。
从最左边的数字开始，在其上方写下“218”（128）并问自己：“218 是否大于或等于 128？” 如果答案是肯定的，请在“128”下方划一个“1”。在“64”上方，写出 218 减去 128 (90) 的结果。
看着“64”，问自己：“90 是否大于等于 64？” 是的，所以你会在“64”下方写一个“1”，然后从 90 中减去 64 并将其写在“32”上方（26）。
但是，当您到达“32”时，您会发现 32 不大于或等于 26。在这种情况下，请在“32”下方写一个“0”，然后将数字（26）从 32“上方复制到上方” 16”，然后继续用其他数字问自己同样的问题。
完成后，您应该拥有：
顶部的数字只是计算中使用的注释，对我们来说意义不大。但是，在底部，您会看到一个二进制数“11011010”。果然，218，转换成二进制，就是“11011010”。
按照这些非常简单的程序，您可以使用计算器将二进制转换为十进制，然后再转换回来。数学非常简单，只需稍加练习即可记住规则。
拆分地址
将 IP 路由想象成披萨外卖。
当您被要求将披萨送到“123 Main Street”时，作为人类，您很清楚您想去名为“Main Street”的街道上编号为“123”的建筑物。很容易知道你需要去 Main Street 的 100 街区，因为楼号在 100 到 199 之间，而且大多数城市街区的编号都以数百为单位。您“只知道”如何拆分地址。
路由器传送数据包，而不是披萨。他们的工作与披萨司机一样：将货物（包）尽可能靠近目的地。路由器连接到两个或多个 IP 子网（完全有用）。路由器必须检查数据包的目标 IP 地址，并将这些目标地址分解为它们的“街道名称”和“建筑物编号”组件，就像披萨司机一样，以做出有关交付的决定。
IP 网络上的每台计算机（或“主机”）都配置有唯一的 IP 地址和子网掩码。该 IP 地址可以分为称为“主机 ID”的“建筑物编号”部分（如上例中的“123”）和称为“主机 ID”的“街道名称”部分（如上例中的“主街”） “网络 ID”。对于我们的肉眼来说，很容易在“123 Main Street”中看到建筑物编号和街道名称的位置，但在“子网掩码为 255.255.192.0”的“10.13.216.41”中很难看到该划分。
IP 路由器“只知道”如何将 IP 地址拆分为这些组成部分以做出路由决策。由于了解 IP 数据包如何路由取决于了解此过程，因此我们也需要知道如何分解 IP 地址。幸运的是，从 IP 地址和子网掩码中提取主机 ID 和网络 ID 实际上非常容易。
首先以二进制形式写出 IP 地址（如果您还没有在头脑中学会这样做，请使用计算器，但记下学习如何做 - 这真的非常简单，并且给异性留下深刻印象派对）：
也用二进制写出子网掩码：
并排书写，您可以看到子网掩码中“1s”停止的点与 IP 地址中的点“对齐”。这就是网络 ID 和主机 ID 分裂的地方。所以，在这种情况下：
路由器使用子网掩码“屏蔽”IP 地址中被 1 覆盖的位（将未被“屏蔽”的位替换为 0）以提取网络 ID：
同样，通过使用子网掩码“屏蔽”IP 地址中被 0 覆盖的位（再次用 0 替换未被“屏蔽”的位），路由器可以提取主机 ID：
我们的肉眼在比萨配送过程中看到网络ID和主机ID之间的“断线”并不像物理地址中的“楼号”和“街道名称”那样容易，但最终的效果是相同的。
现在您可以将 IP 地址和子网掩码拆分为主机 ID 和网络 ID，您可以像路由器一样路由 IP。
更多术语
您将看到整个 Internet 上以及此答案的其余部分都写为（IP/号码）的子网掩码。这种表示法称为“无类域间路由”(CIDR) 表示法。"255.255.255.0" 由 24 位 1 开头，写成 "/24" 比写成 "255.255.255.0" 快。要将 CIDR 编号（如“/16”）转换为点分十进制子网掩码，只需写出该数量的 1，将其分成 8 位组，然后将其转换为十进制。（例如，“/16”是“255.255.0.0”。）
回到“旧时代”，子网掩码没有被指定，而是通过查看 IP 地址的某些位得出。例如，以 0 - 127 开头的 IP 地址具有隐含的子网掩码 255.0.0.0（称为“A 类”IP 地址）。
这些隐含的子网掩码今天不再使用，我不建议您再学习它们，除非您不幸处理不支持无类 IP 寻址的非常旧的设备或旧协议（如 RIPv1）。我不会进一步提及这些地址“类别”，因为它在今天不适用并且可能会造成混淆。
一些设备使用称为“通配符掩码”的符号。“通配符掩码”只不过是一个子网掩码，其中有 1 的地方全为 0，有 0 的地方全为 1。/26 的“通配符掩码”是：
通常，您会看到用于匹配访问控制列表或防火墙规则中的主机 ID 的“通配符掩码”。我们不会在这里进一步讨论它们。
路由器的工作原理
正如我之前所说，IP 路由器的工作类似于披萨送货司机，因为它们需要将货物（数据包）送到目的地。当收到一个发往地址 192.168.10.2 的数据包时，IP 路由器需要确定它的哪个网络接口可以最好地使该数据包更接近其目的地。
假设您是一个 IP 路由器，并且您有连接到您的接口编号：
如果您收到一个目标地址为“192.168.10.2”的数据包，那么很容易（用您的肉眼）判断该数据包应该从接口 Ethernet1 发送出去，因为 Ethernet1 接口地址对应于数据包的目标地址。连接到 Ethernet1 接口的所有计算机的 IP 地址都会以“192.168.10.”开头，因为分配给您的接口 Ethernet1 的 IP 地址的网络 ID 是“192.168.10.0”。
对于路由器，此路由选择过程是通过构建路由表并在每次发送数据包时查阅该表来完成的。路由表包含网络 ID 和目标接口名称。您已经知道如何从 IP 地址和子网掩码获取网络 ID，因此您正在构建路由表。这是这个路由器的路由表：
对于绑定到“192.168.10.2”的传入数据包，我们只需将该数据包的地址转换为二进制（作为人类——路由器一开始就将其作为二进制从网络中获取）并尝试将其与我们路由中的每个地址匹配表（直到子网掩码中的位数），直到我们匹配一个条目。
将其与我们的路由表中的条目进行比较：
Ethernet0 的条目与前 19 位匹配良好，但随后停止匹配。这意味着它不是正确的目标接口。可以看到接口 Ethernet1 匹配 24 位目的地址。啊哈！数据包被绑定到接口 Ethernet1。
在现实生活中的路由器中，路由表的排序方式是首先检查最长的子网掩码是否匹配（即最具体的路由），然后在数字上进行排序，以便一旦找到匹配项就可以路由数据包并且不需要进一步的匹配尝试（这意味着 192.168.10.0 将首先列出，而 192.168.20.0 将永远不会被检查）。在这里，我们稍微简化一下。花哨的数据结构和算法使 IP 路由器更快，但简单的算法将产生相同的结果。
静态路由
到目前为止，我们已经讨论了我们假设的路由器，因为它有网络直接连接到它。显然，这不是这个世界真正运作的方式。在比萨开车的类比中，有时司机不允许进入大楼比前台更远的地方，并且必须将比萨交给其他人以交付给最终的收件人（暂停你的怀疑并容忍我，而请扩展我的类比）。
让我们从前面的示例“Router A”中调用我们的路由器开始。你已经知道RouterA的路由表为：
假设有另一个路由器“路由器 B”，其 IP 地址 192.168.10.254/24 和 192.168.30.1/24 分配给它的 Ethernet0 和 Ethernet1 接口。它具有以下路由表：
在漂亮的 ASCII 艺术中，网络看起来像这样：
您可以看到路由器 B 知道如何“到达”网络 192.168.30.0/24，而路由器 A 对此一无所知。
假设一台连接到路由器 A 的 Ethernet0 接口的网络的 IP 地址为 192.168.20.13 的 PC 向路由器 A 发送数据包以进行传送。我们假设的数据包的目的地是 IP 地址 192.168.30.46，这是一个连接到路由器 B 的 Ethernet1 接口的网络的设备。
使用如上所示的路由表，Router A 的路由表中没有一个条目与目标 192.168.30.46 匹配，因此 Router A 会将数据包返回给发送 PC，并显示“Destination network unreachable”消息。
为了让路由器 A “知道” 192.168.30.0/24 网络的存在，我们将以下条目添加到路由器 A 的路由表中：
这样，路由器 A 就有一个路由表条目与示例数据包的 192.168.30.46 目的地相匹配。这个路由表条目实际上是说“如果你收到一个发往 192.168.30.0/24 的数据包，请将它发送到 192.168.10.254，因为他知道如何处理它。” 这与我之前提到的类似的“在前台交出比萨饼”动作——将数据包传递给知道如何将其更接近目的地的其他人。
“手动”向路由表添加条目称为添加“静态路由”。
如果路由器 B 想要将数据包传送到 192.168.20.0 子网掩码 255.255.255.0 网络，它也需要在其路由表中添加一个条目：
这将在 192.168.30.0/24 网络和 192.168.20.0/24 网络之间通过这些路由器之间的 192.168.10.0/24 网络创建传递路径。
您总是希望确保这样一个“间隙网络”两侧的路由器都有一个用于“远端”网络的路由表条目。如果我们示例中的路由器 B 没有连接到路由器 A 的“远端”网络 192.168.20.0/24 的路由表条目，我们假设来自 192.168.20.13 的 PC 的数据包将到达 192.168.30.46 的目标设备，但是任何 192.168.30.46 试图发回的回复都会被路由器 B 返回为“目标网络不可达”。单向通信通常是不可取的。当您考虑计算机网络中的通信时，请务必考虑双向流动的流量。
您可以从静态路线中获得大量里程。EIGRP、RIP 等动态路由协议实际上只不过是路由器在彼此之间交换路由信息的一种方式，实际上可以配置静态路由。但是，在静态路由上使用动态路由协议的一大优势是，动态路由协议可以根据网络条件（带宽利用率、接口“关闭”等）动态更改路由表，因此，使用动态路由路由协议可能会导致配置“绕过”网络基础设施中的故障或瓶颈。（不过，动态路由协议超出了这个答案的范围。）
你不能从这里到达那里
在我们的示例路由器 A 的情况下，当一个发往“172.16.31.92”的数据包进来时会发生什么？
查看路由器 A 路由表，目标接口或静态路由都不匹配 172.18.31.92 的前 24 位（顺便说一下，即 10101100.00010010.00011111.01011100）。
我们已经知道，路由器 A 会通过“目标网络不可达”消息将数据包返回给发送方。
假设有另一个路由器（路由器 C）位于地址“192.168.20.254”。路由器 C 已连接到 Internet！
如果路由器 A 可以将不匹配任何本地接口的数据包路由到路由器 C，这样路由器 C 可以将它们发送到 Internet，那就太好了。输入“默认网关”路由。
在我们的路由表末尾添加一个条目，如下所示：
当我们尝试将“172.16.31.92”与路由表中的每个条目匹配时，我们最终会遇到这个新条目。起初，这有点令人困惑。我们希望将目标地址的零位与...等等...什么相匹配？匹配零位？所以，我们根本不是在寻找匹配项。这个路由表条目基本上是说，“如果你到达这里，而不是放弃交付，将数据包发送到 192.168.20.254 的路由器并让他处理它”。
192.168.20.254是我们知道如何将数据包传送到的目的地。当面对一个发往我们没有特定路由表条目的目的地的数据包时，这个“默认网关”条目将始终匹配（因为它匹配目标地址的零位），并为我们提供了一个“最后的手段”位置，我们可以发送数据包以进行交付。您有时会听到称为“最后的网关”的默认网关。
为了使默认网关路由有效，它必须引用使用路由表中的其他条目可到达的路由器。例如，如果您尝试在路由器 A 中指定默认网关 192.168.50.254，则传送到此类默认网关将失败。192.168.50.254 不是路由器 A 知道如何使用其路由表中的任何其他路由传递数据包的地址，因此这样的地址作为默认网关无效。这可以简明扼要地说：必须将默认网关设置为使用路由表中的另一条路由已经可以到达的地址。
真正的路由器通常将默认网关存储为路由表中的最后一条路由，以便在它们未能匹配表中的所有其他条目后匹配数据包。
城市规划和 IP 路由
将 IP 子网分解为更小的 IP 子网就像城市规划一样。在城市规划中，分区用于适应景观的自然特征（河流、湖泊等），影响城市不同部分之间的交通流量，以及分隔不同类型的土地利用（工业、住宅等） . IP 子网划分实际上是相同的。
对网络进行子网划分的主要原因有三个：
您可能希望通过不同的通信媒体进行通信。如果您在两座建筑物之间有 T1 WAN 连接，则可以将 IP 路由器放置在这些连接的末端，以促进跨 T1 的通信。每一端的网络（可能还有 T1 本身的“间隙”网络）将被分配到唯一的 IP 子网，以便路由器可以决定应该通过 T1 线路发送哪些流量。
在以太网中，您可以使用子网划分来限制网络给定部分的广播流量。应用层协议将以太网的广播功能用于非常有用的目的。但是，随着越来越多的主机被打包到同一个以太网网络中，有线（或无线以太网中的空中）广播流量的百分比可能会增加到一定程度，从而为非广播流量的传递带来问题。（在过去，广播流量可能会迫使主机检查每个广播数据包，从而使主机的 CPU 不堪重负。如今这种情况不太可能发生。）交换以太网上的过多流量也可能以“将帧泛洪到未知目的地”的形式出现。这种情况是由于以太网交换机无法跟踪网络上的每个目的地造成的，这也是交换式以太网无法扩展到无限数量的主机的原因。出于子网划分的目的，将帧泛洪到未知目的地的影响类似于过度广播流量的影响。
您可能想要“监管”不同主机组之间的流量类型。也许您有打印服务器设备，并且您只希望授权的打印队列服务器计算机向它们发送作业。通过限制允许流向打印服务器设备子网的流量，用户无法将其 PC 配置为直接与打印服务器设备对话以绕过打印计费。您可以将打印服务器设备单独放入一个子网中，并在连接到该子网的路由器或防火墙中创建一个规则，以控制允许向打印服务器设备发送流量的主机列表。（路由器和防火墙通常都可以根据数据包的源地址和目标地址来决定如何或是否发送数据包。防火墙通常是具有强迫性个性的路由器的一个子类。他们可能非常非常关心数据包的有效负载，而路由器通常会忽略有效负载而只是传递数据包。）
在规划城市时，您可以规划街道如何相互交叉，并且可以使用仅转弯、单向和死胡同的街道来影响交通流量。您可能希望 Main Street 有 30 个街区长，每个街区最多有 99 座建筑物。规划街道编号非常容易，因此 Main Street 中的每个街区的街道编号范围每街区增加 100。很容易知道每个后续块中的“起始编号”应该是什么。
在规划 IP 子网时，您关心的是使用正确数量的可用主机 ID（建筑物编号）构建正确数量的子网（街道），并使用路由器将子网相互连接（交叉点）。路由器中指定的有关允许的源地址和目标地址的规则可以进一步控制流量。防火墙可以像痴迷的交通警察。
出于此答案的目的，构建我们的子网是我们唯一的主要关注点。不像城市规划那样使用十进制，而是使用二进制来描述每个子网的边界。
继续：IPv4 子网如何工作？
（是的......我们达到了答案的最大大小（30000 个字符）。）
Continued from: How does IPv4 Subnetting Work?
Your ISP gives you the range the network ID 192.168.40.0/24 (11000000.10101000.00101000.00000000). You know that you'd like to use a firewall / router device to limit communication between different parts of your network (servers, client computers, network equipment) and, as such,you'd like to break these various parts of your network up into IP subnets (which the firewall / router device can then route between).
You have:
What's a good way to break up 192.168.40.0/24 into these pieces?
Thinking in even powers of two, and working with the larger numbers of possible devices, you can come up with:
In a given IP subnet, there are two addresses reserved that can't be used as valid device IP addresses-- the address with all zeros in the host ID portion and the address with all ones in the host ID portion. As such, for any given IP subnet, the number of host addresses available is two to the power of the quantity of 32 minus the number of bits in the subnet mask, minus 2. So, in the case of 192.168.40.0/24 we can see that the subnet mask has 24 bits. That leaves 8 bits available for host IDs. We know that 2 to the 8th power is 256-- meaning that 256 possible combinations of bits fit into a slot 8 bits wide. Since the "11111111" and "00000000" combinations of those 8 bits aren't allowable for host IDs, that leaves us with 254 possible hosts that can be assigned in the 192.168.40.0/24 network.
Of those 254 hosts, it looks like we can fit the client computers, switches, and server computers into that space, right? Let's try.
You have 8 bits of subnet mask to "play with" (the remaining 8 bits of the IP address 192.168.40.0/24 not covered by the subnet mask provided by your ISP). We have to work out a way to use those 8 bits to create a number of unique network IDs that can accommodate the devices above.
Start with the largest network - the client computers. You know that the next larger power of two from the number of possible devices is 128. The number 128, in binary, is "10000000". Fortunately for us, that fits into the 8 bit slot we have free (if it didn't, that would be an indication that our starting subnet is too small to accommodate all our devices).
Let's take our network ID, as provided by our ISP, and add a single bit of subnet mask to it, breaking it up into two networks:
Look over that until it makes sense. We increased the subnet mask by one bit in length, causing the network ID to cover one bit that would have been used for host ID. Since that one bit can be either zero or one, we've effectively split our 192.168.40.0 network into two networks. The first valid IP address in the 192.168.40.0/25 network will be the first host ID with a "1" in the right-most bit:
The first valid host in the 192.168.40.128 network will, likewise, be the first host ID with a "1' in the right-most bit:
The last valid host in each network will be the host ID with every bit except the right-most bit set to "1":
So, in this way, we've created a network large enough to hold our client computers, and a second network that we can then apply the same principle to break down into yet smaller networks. Let's make a note:
Now, to break down the second network for our servers and switches, we do the same thing.
We have 12 server computers, but we might buy up to 6 more. Let's plan on 18, which leaves us the next highest power of 2 as 32. In binary, 32 is "100000", which is 6 bits long. We have 7 bits of subnet mask left in 192.168.40.128/25, so we have enough bits to continue "playing". Adding one more bit of subnet mask gives us two more networks:
So, now we've broken up 192.168.40.128/25 into two more networks, each of which has 26 bits of subnet mask, or a total of 62 possible host IDs-- 2 ^ (32 - 26) - 2.
That means that both of those networks have enough addresses for our servers and switches! Let's make notes:
This technique is called variable-length subnet masking (VLSM) and, if properly applied, causes "core routers" to have smaller routing tables (through a process called "route summarization"). In the case of our ISP in this example, they can be totally unaware of how we've subnetted 192.168.40.0/24. If their router has a packet bound for 192.168.40.206 (one of our switches), they need only know to pass it to our router (since 192.168.40.206 matches the network id and subnet mask 192.168.40.0/24 in their router's routing table) and our router will get it to the destination. This keeps our subnet routes out of their routing tables. (I'm simplifying here, but you get the idea.)
You can plan very geographically large networks in this same way. As long as you do the right "urban planning" up front (anticipating the number of hosts in each sub-network with some accuracy and an eye to the future) you can create a large routing hierarchy that, at the core routers, "summarizes" to a very small number of routes. As we saw above, the more routes that are in a router's routing table the slower it performs its job. Designing an IP network with VLSM and keeping routing tables small is a Good Thing(tm).
The Unrealism of Examples
The fictional world in this answer is, obviously, fictional. Typically you can make subnets on modern switched Ethernet with more hosts than 254 (traffic profile dependent). As has been pointed out in comments, using /24 networks between routers isn't consistent with Real Life(tm). It makes for cute examples, but is a waste of address space. Typically, a /30 or a /31 (see http://www.faqs.org/rfcs/rfc3021.html for details on how /31's work-- they are beyond the scope of this answer for sure) network is used on links that are strictly point-to-point between two routers.
子网
子网并不难，但它可能令人生畏。因此，让我们从最简单的步骤开始。学习用二进制数数。
二进制
二进制是一种以 2 为底的计数系统。仅由两个数字（1 和 0）组成。以这种方式进行计数。
因此，如果您只是想象每个 1 是一个值的占位符（所有二进制值都是 2 的幂）
所以... 100000 = 32。和 10000000 = 128。和 11111111 = 255。
当我说“我的子网掩码为 255.255.255.0”时，我的意思是“我的子网掩码为 11111111.11111111.11111111.00000000”。我们使用子网作为简写。
地址中的句点隔开每 8 个二进制数字（一个八位字节）。这就是为什么 IPv4 被称为 32 位 (8*4) 地址空间的原因。
为什么是子网？
IPv4 地址 (192.168.1.1) 供不应求。子网为我们提供了一种增加可用网络（或主机）数量的方法。这是出于管理原因和技术原因。
每个 IP 地址分为两个独立的部分，即网络和主机。默认情况下，C 类地址 (192.168.1.1) 使用前 3 个八位字节 (192.168.1) 作为地址的网络部分。和第 4 个八位字节 (.1) 作为主机部分。
默认情况下，C 类地址的 IP 地址和子网掩码如下所示
像这样的二进制
再次查看二进制示例。请注意我所说的前三个八位字节是用于网络的吗？请注意网络部分是如何全部为 1 的？这就是子网的全部内容。让我们展开。
鉴于我的主机部分只有一个八位字节（在上面的示例中）。我只能拥有 256 台主机（256 是一个八位字节的最大值，从 0 开始计数）。但是还有另一个小技巧：您需要从可用的主机地址中减去 2 个主机地址（当前为 256）。范围内的第一个地址将用于网络 (192.168.1.0)，范围内的最后一个地址将用于广播 (192.168.1.255)。因此，一个网络中的主机确实有 254 个可用地址。
案例研究
假设我给了你下面这张纸。
让我们来看看这个。/24 称为 CIDR 表示法。我们只引用网络所需的位，而不是引用 255.255.255.0。在这种情况下，我们需要来自 32 位地址的 24 位（3*8）。用二进制写出来
接下来我们知道我们需要弄清楚我们需要多少个子网。看起来像 4。由于我们需要创建更多网络（目前我们只有一个），让我们翻转一些位
现在我们已经决定使用 /26，让我们开始分配主机。一个简单的数学：
我们在每个网络中为主机分配 6 位。请记住，我们需要为每个网络减去 2。
现在我们需要弄清楚主机的去向。回到二进制！
通过这种方式，您可以计算整个子网。
通配符 通配符掩码是反转的子网掩码。
更远
Google for the terms 'super-netting', and 'VLSM (variable length subnet mask)', for more advanced topics.
I can see now that I took too long in responding ... sigh
一个简短的历史教训：最初，单播 IPv4 地址分为 3 类，每类都有一个关联的“默认”掩码长度（称为有类子网掩码）
这个想法是，可以为不同规模的组织分配不同类别的 IP 地址，以有效利用 IP 地址空间。
然而，随着 IP 网络的发展，这种方法显然存在问题。仅举三例：
在分类世界中，所有子网都必须具有 /8、/16 或 /24 的掩码。这意味着可以配置的最小子网是 /24，它允许 254 个主机地址（.0 和 .255 分别保留为网络和广播地址）。这非常浪费，尤其是在仅连接两个路由器的点对点链路上。
即使在放宽此限制之后，早期的路由协议（例如RIPv1）也不会公布与 IP 前缀关联的掩码长度。在没有特定掩码的情况下，它将使用同一有类网络中直接连接接口的掩码，或者回退到使用有类掩码。例如，如果您想将网络 172.16.0.0 用于具有 /30 掩码的路由器间链路，则 172.16.0.0 - 172.16.255.255 的所有子网都必须具有 /30 掩码（16384 个子网，每个子网有 2 个可用 IP ）。
互联网路由器的路由表开始占用越来越多的内存；这被称为“路由表爆炸”。例如，如果提供商有 16 个连续 /24 个网络，他们将需要通告所有 16 个前缀，而不是覆盖整个范围的单个摘要。
两项相关的改进使我们能够超越上述限制。
VLSM 是指路由协议在同一有类网络中支持不同子网掩码的能力。例如：
可以分为：
这允许更有效地使用地址空间；子网可以根据连接到它们的主机/路由器的数量正确调整大小。
CIDR 采用 VLSM 并以另一种方式扩展它；除了将单个有类网络拆分为更小的子网之外，CIDR 还允许将多个有类网络聚合为一个摘要。例如，以下 B 类 (/16) 网络：
可以使用单个前缀聚合/汇总：
在子网划分方面：子网掩码为 32 位长。掩码长度表示有多少位标识地址的网络部分。例如：
这意味着，假设整个 10.0.0.0/8 网络被划分为 /24s，那么在此范围内将有 65536 (2 ^ 16) 个子网。（这是假设您使用的平台支持 0 和 255 的子网号。请参阅 Cisco 的 ip subnet-zero）。
地址的“主机部分”中剩余 8 位。这意味着有 256 个可用的 IP 地址（2^8），其中 2 个是保留的（10.1.1.0 是网络地址，10.1.1.255 是子网定向广播地址）。这会在该子网上留下 254 个可用的 IP 地址。((2^8) - 2)
I’ll pose and answer a few related questions along the way:
255.255.255.0so often?192.168.0.1?127.0.0.1?Why such weird numbers — 255, 192, 168, 127?
8+8+8+8-bit dotted decimal
Internet addresses like 194.60.38.10 use dotted-decimal notation to split 32 bits up into 8+8+8+8 bits. Dotted-decimal means converting† each number to binary then left-padding it with
0’s.For example
.60.→ 60=32+16+8+4 →111100→.00111100..So 194.60.38.10 is dotted-decimal for the 4×8=32-bit address
11000010.00111100.00100110.00001010, since 38 →100110, 10 →1010, and so on. 194 requires all 8 bits; the rest are padded.Once you think about 255, 192, and 127 in 8-bit binary, you can more easily understand why certain decimal numbers are so common:
1111111111000000_111111110000000These decimal numbers happen to represent visually convenient 8-bit blocks like ■■■■■■■■, ■□□□□□□□, and □■■■■■■■. So you’ve never seen 256=2⁹ because of the 8-bit limit, and 127=128−1=2⁸−1 is the bit-flip of a power-of-two—and powers-of-two are
10………00000’s in binary.10101000Subnet masks: What’s mine is mine + What’s yours is yours
Subnet masks then break each 32-bit internet address up into a network ID and a host ID. Whereas internet addresses can have any mixture of 1’s and 0’s, subnet masks begin with only 1’s and end with only 0’s.
Blacking out the first 8+8+8=24 bits and whiting out the final 8 bits is a way of splitting the IP ■■□□□□■□|□□■■■■□□|□□■□□■■□|□□□□■□■□ into two pieces:
If the subnetwork owner (say OmniCorp) wanted more internal IP’s, they could buy up more (say 8+8=16 bits) of the righthand side of the network, like this:
Clearly there is a tradeoff within the 32-bit = 2³² = 4,294,967,296-option address space: if you buy up more network ID’s (lefthand side) your internal network has more host ID’s (righthand side) to assign.
Cheap people therefore have a subnet mask of
255.255.255.0 = ■■■■■■■■|■■■■■■■■|■■■■■■■■|□□□□□□□□.
Even cheaper people have
255.255.255.128 = ■■■■■■■■|■■■■■■■■|■■■■■■■■|■□□□□□□□
or 255.255.255.192 = ■■■■■■■■|■■■■■■■■|■■■■■■■■|■■□□□□□□.
According to folklore, it wasn’t actually Roger Miller, but a lowly sysadmin with a 255.255.255.254 mask who originally wrote King of the Road, substituting “I ain’t got a large subnet” for “I ain’t got no cigarettes”.
(Why are the masks of the lowly filled with such high numbers? Because, like Miller’s narrator, subnet masks count all the things you don’t have.)
What does the trailing slash after an IP mean? (eg, 194.60.38.10/24)
Since subnet masks (which divide “theirs” from “ours”) always begin with
1’s, and since we hate summing up powers-of-two even more than we hate figuring the powers-of-two in the first place, someone invented CIDR (the slash after an IP).194.60.38.10/24 means "the submask has 24 ones, then the rest are zeroes", so
■■■■■■■■|■■■■■■■■|■■■■■■■■|□□□□□□□□ with 8+8+8 bits belonging to “them” and 8 bits belonging to “us”.
Reversing the hobo’s anthem above,
/31is the songwriter/24is middle-class (255.255.255.0= ■■■■■■■■|■■■■■■■■|■■■■■■■■|□□□□□□□□/16is rich ■■■■■■■■|■■■■■■■■|□□□□□□□□|□□□□□□□□/8is super rich ■■■■■■■■|□□□□□□□□|□□□□□□□□|□□□□□□□□/1or/0would be the IANA or something.† Use
bc -l; obase=10; 60for example.网络范围：网络始终由 2 个数字引用：一个用于确定网络，另一个用于确定该网络上的计算机（或主机）。由于每个网络地址都是 32 位长，因此两个数字都必须适合这 32 位。
网络编号很重要，因为它是 ICANN 在您要求网络 IP 范围时分发的。如果我们没有它，没有人能够分辨我的网络和 AT&T 之间的区别。因此，虽然这些编号必须是唯一的，但没有人愿意为我网络上的主机分配编号。因此分裂 - 第一部分由网络人员管理，第二部分全部由我提供给我想要的任何机器。
网络号并不固定在一定的位数——例如，如果我只有 200 台机器要管理自己，我会非常满意使用 24 位的网络号，而我自己只有 8 位- 最多可容纳 255 台主机。由于网络号使用 24 位，我们可以有很多，这意味着很多人可以拥有自己的网络。
在过去，这被称为 C 类网络。（B 类网络号使用 16 位，A 类使用 8 位，所以目前存在的 A 类网络很少）。
如今，这种命名约定已经过时了。它被称为 CIDR 的概念所取代。CIDR 明确地将主机的位数放在斜杠之后。因此，我上面的示例（C 类）现在称为 CIDR /24。
这确实给了我们更多的灵活性，以前如果我要管理 300 台主机，我需要一个 B 类网络！现在，我可以得到一个 /23 CIDR，所以我有 9 位给我，23 位给我的网络号。ICANN 可能没有这类网络，但如果我有一个内部网络，或者我从 ISP 租用部分网络，这将更容易管理 - 特别是因为他们的所有客户都可以获得 /29（离开我. . 3 位或最多 8 台机器），这允许更多人拥有自己的一小部分可用 IP 地址。在我们获得 IPv6 之前，这非常重要。
但是......虽然我知道 /24 CIDR 相当于旧的 C 类网络，而 /16 是 B 类，而 /8 是 A 类......我仍然难以计算 /22 in我的头。幸运的是，有一些工具可以为我做到这一点:)
但是 - 如果您知道 /24 是主机的 8 位（而网络是 24 位），那么我知道 /23 给了我一个额外的位，它使主机数量增加了一倍。
While the above is correct (sorry, TL;DR), calculating subnets still causes many network administrators a lot of grief. There actually is a very easy way to do subnet calculation, you can do most of it in your head, and there is very little you have to memorize. For most applications, it's not even necessary to understand the binary representation, though it is helpful for a complete understanding of subnetting. Here I will only discuss IPv4; IPv6 is outside of the scope of this discussion.
Remember this:
There are three key things to remember: all subnets are based on powers of two, and there are two key numbers: 256 and 32. More on that later.
First, lets look at a table containing powers of 2:
Calculating powers of 2 is easy: each integer increase in the power doubles the result. 1+1=2, 2+2=4, 4+4=8, 8+8=16, and so on. The total number of addresses in a subnet must always be a power of 2.
Since each octet of an IPv4 subnet goes up to 256, 256 is a very important number and forms the basis for the rest of the math.
Sizing the subnet
We'll start with an easy question: "how many addresses in a subnet if the mask is 255.255.255.248?" We will ignore the first three octets for now and look at the last. Here is how easy it is: subtract 248 from 256. 256 minus 248 equals 8. There are 8 addresses available (including the network and broadcast addresses). The reverse also works: "if I want to have a subnet with 16 addresses, what will the subnet mask be?" 256 minus 16 equals 240. The subnet mask will be 255.255.255.240.
Now if we want to expand beyond 256 addresses (historically, a "class C"), it gets only a tiny bit more complicated: if our last octet is 0 and our third octet is, say, 240, (255.255.240.0) then we do the math on the third octet and find that there would be 16 addresses. So we multiply 16 by 256 (the number of addresses in the last octet) to get 4,096. If both the last two octets are 0, (ex. 255.240.0.0) then we take the subtraction result from the second octet (we'll say it's 16 again), multiply but 256 (addresses in the third octet), multiply again by 256 (addresses in the last octet) to get 1,048,576 addresses. Easy as that! (OK, so the reverse is a little more difficult. If we want a subnet with 1,048,576 addresses, we'll have to divide that number by 256 a couple of times to get a number we can subtract from 256.)
Network address
Now that we know how to calculate the subnet mask, how do we figure out what the network address is? That's easy: it's always a multiple of the number of addresses in our subnet. So if we have 16 addresses in our subnet, the possible network addresses will be 0, 16, 32, 48, 64, and so on up to 240. (Note that 0 is a valid multiple of any number, as any number multiplied by 0 equals 0.)
And, of course, the broadcast address will be the last address in the scope. So if we have 16 address in our subnet, and we've chosen a network address of 10.3.54.64, the broadcast address will be (64+16-1=79) 10.3.54.79.
CIDR Notation
So how about CIDR notation? How do translate that to and from an IPv4-style subnet mask?
Remember our powers of two? Well, now we have another key number to remember besides 256: 32. Remember, CIDR notation describes the number of significant bits in the IPv4 address, and there are 32 bits in an IPv4 address, 8 for each octet. So if we have a subnet mask of 255.255.255.240, that is 16 addresses. If we look at our "powers of 2" table above, we see that 16 is two to the fourth power (2^4). So we subtract that power number -- 4 -- from 32 and get 28. Our CIDR notation for a subnet mask of 255.255.255.240, our CIDR notation is /28.
And if we are given a CIDR of /28, we subtract that (28) from 32 to get 4; raise 2 to that (4th) power (2^4) to get 16; then subtract that (16) from 256 to get 240; or 255.255.255.240.
I also feel that there should atleast be a mention of NATs, because they are used so commonly in modern networks in place of Subnets, because of IPv4 address exhaustion,among other things. (Also, when I was first learning about subnets, I was very confused as to how subnetting relates to the networks created by WiFi routers).
NAT (network address translation) is a technique (commonly) used to create private networks by mapping one address space (IP:Port) to another. Majorly, this is used to create a private network of multiple private IPs behind one public address, for example, in Wifi routers, by organizations(like a university or a corporation), or sometimes by ISPs.
The actual address translation is done transparently in NAT capable nodes, usually routers. It may be of many forms, Full Cone, Address Restricted, Port restricted etc. or a mixture of these, which dictates how the connections across the node may be initiated.
Full details can be found on Wikipedia, but for example consider a Wifi router with 2 devices connected to it. The public IP of the router is
10.9.20.21/24, and the IP of the devices(Private IPs) areA: 192.168.0.2,B: 192.168.0.3and that of the router isR: 192.168.0.1. Thus ifAwants to connect to serverS: 10.9.24.5/24, (which is actually on a different subnet w.r.t the router here):R(which would be the default gateway) with the source IP192.168.0.2, src port (say)14567, and destination IP:10.9.24.5(Although port is actually a part of the TCP header).14567to deviceAand changes the source on the IP packet to10.9.20.21(which is the public IP of the router). This is in contrast to subnetting described above, where the IP packets are actually never changed.Srecieves the series of TCP packets(with src IP:10.9.20.21, src Port:14567) and send response packets with those values in the destination fields.Rchecks the destination port, which is14567and forwards the packet toA.Areceives the response packet.In the above situation, if
Btried to open a connection on the same source port (14567), it would be mapped to a different port byR(and the port in the outgoing packet changed) before sending toS. That is, there would also be port translation instead of just IP.Two things to note here: