# java

```java
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class WakeOnLan {
    public static void main(String[] args) {
        String targetMacAddress = "XX:XX:XX:XX:XX:XX"; // 替换为目标计算机的MAC地址

        try {
            wakeUp(targetMacAddress);
            System.out.println("Wake-on-LAN packet sent successfully.");
        } catch (IOException e) {
            System.err.println("Error sending Wake-on-LAN packet: " + e.getMessage());
        }
    }

    public static void wakeUp(String macAddress) throws IOException {
        byte[] macBytes = parseMacAddress(macAddress);

        byte[] magicPacket = new byte[102];
        for (int i = 0; i < 6; i++) {
            magicPacket[i] = (byte) 0xFF;
        }

        for (int i = 6; i < magicPacket.length; i += macBytes.length) {
            System.arraycopy(macBytes, 0, magicPacket, i, macBytes.length);
        }

        InetAddress broadcastAddress = InetAddress.getByName("255.255.255.255");
        int port = 9;

        try (DatagramSocket socket = new DatagramSocket()) {
            DatagramPacket packet = new DatagramPacket(magicPacket, magicPacket.length, broadcastAddress, port);
            socket.send(packet);
        }
    }

    private static byte[] parseMacAddress(String macAddress) {
        String[] macParts = macAddress.split(":");
        byte[] macBytes = new byte[macParts.length];

        for (int i = 0; i < macParts.length; i++) {
            macBytes[i] = (byte) Integer.parseInt(macParts[i], 16);
        }

        return macBytes;
    }
}

```

# c#

```c#
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class WakeOnLan
{
    public static void Main(string[] args)
    {
        string targetMacAddress = "XX:XX:XX:XX:XX:XX"; // 替换为目标计算机的MAC地址

        try
        {
            WakeUp(targetMacAddress);
            Console.WriteLine("Wake-on-LAN packet sent successfully.");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error sending Wake-on-LAN packet: " + ex.Message);
        }
    }

    public static void WakeUp(string macAddress)
    {
        byte[] macBytes = ParseMacAddress(macAddress);

        byte[] magicPacket = new byte[102];
        for (int i = 0; i < 6; i++)
        {
            magicPacket[i] = 0xFF;
        }

        for (int i = 6; i < magicPacket.Length; i += macBytes.Length)
        {
            Array.Copy(macBytes, 0, magicPacket, i, macBytes.Length);
        }

        IPAddress broadcastAddress = IPAddress.Parse("255.255.255.255");
        int port = 9;

        using (UdpClient udpClient = new UdpClient())
        {
            udpClient.EnableBroadcast = true;
            udpClient.Send(magicPacket, magicPacket.Length, new IPEndPoint(broadcastAddress, port));
        }
    }

    private static byte[] ParseMacAddress(string macAddress)
    {
        string[] macParts = macAddress.Split(':');
        byte[] macBytes = new byte[macParts.Length];

        for (int i = 0; i < macParts.Length; i++)
        {
            macBytes[i] = Convert.ToByte(macParts[i], 16);
        }

        return macBytes;
    }
}

```

# php

```php
<?php
function wakeOnLan($macAddress) {
    // 将MAC地址转换为字节格式
    $macBytes = str_split(str_replace(':', '', $macAddress), 2);
    $macHex = implode(array_map('hex2bin', $macBytes));

    // 构造Wake-on-LAN数据包
    $magicPacket = str_repeat(chr(0xFF), 6) . str_repeat($macHex, 16);

    // 发送数据包到目标计算机的局域网广播地址
    $broadcastIp = '255.255.255.255';
    $port = 9;

    // 创建UDP Socket
    $socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
    socket_set_option($socket, SOL_SOCKET, SO_BROADCAST, 1);

    // 发送数据包
    socket_sendto($socket, $magicPacket, strlen($magicPacket), 0, $broadcastIp, $port);

    // 关闭Socket
    socket_close($socket);
}

// 使用目标计算机的MAC地址唤醒计算机
$targetMacAddress = 'XX:XX:XX:XX:XX:XX';
wakeOnLan($targetMacAddress);

```

# nodejs

```javascript
const dgram = require('dgram');

const server = dgram.createSocket('udp4');

server.on('message', (msg, rinfo) => {
  const targetMacAddress = msg.toString('utf8');
  console.log('Received MAC address:', targetMacAddress);
  
  // 在这里发送Wake-on-LAN数据包到目标计算机的局域网广播地址
  // 可以使用与之前示例相同的代码来发送数据包
  // ...

  // 假设数据包已发送成功，向前端发送响应
  server.send('Wake-on-LAN packet sent successfully.', rinfo.port, rinfo.address);
});

server.on('listening', () => {
  const address = server.address();
  console.log(`Server listening on ${address.address}:${address.port}`);
});

const port = 8080; // 替换为你的服务器端口
server.bind(port);

```

# python 

```python
import socket

def wake_on_lan(mac_address):
    # 将MAC地址转换为字节格式
    mac_hex = mac_address.replace(':', '').decode('hex')
    
    # 构造Wake-on-LAN数据包
    magic_packet = b'\xff' * 6 + mac_hex * 16
    
    # 发送数据包到目标计算机的局域网广播地址
    broadcast_ip = '255.255.255.255'
    port = 9
    
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        s.sendto(magic_packet, (broadcast_ip, port))

# 使用目标计算机的MAC地址唤醒计算机
target_mac_address = 'XX:XX:XX:XX:XX:XX'
wake_on_lan(target_mac_address)
```