以下是一个示例代码，演示如何按照子-父依赖关系对数组进行排序：

// 定义一个依赖关系的数据结构
class Dependency {
  constructor(child, parent) {
    this.child = child;
    this.parent = parent;
  }
}

// 按照子-父依赖关系对数组进行排序的函数
function sortArrayByDependency(array, dependencies) {
  // 用于存储节点和其对应的父节点的映射关系
  const parentMap = {};

  // 构建节点和其对应的父节点的映射关系
  for (let dependency of dependencies) {
    const { child, parent } = dependency;
    if (!parentMap[child]) {
      parentMap[child] = [];
    }
    parentMap[child].push(parent);
  }

  // 用于存储已排序的节点
  const sortedArray = [];

  // 递归排序节点
  function sortNode(node) {
    if (sortedArray.includes(node)) {
      return;
    }

    // 先排序父节点
    const parents = parentMap[node];
    if (parents) {
      for (let parent of parents) {
        sortNode(parent);
      }
    }

    // 将节点添加到已排序数组中
    sortedArray.push(node);
  }

  // 遍历数组中的每个节点，进行排序
  for (let node of array) {
    sortNode(node);
  }

  return sortedArray;
}

// 示例用法
const array = [5, 2, 7, 1, 4];
const dependencies = [
  new Dependency(2, 1),
  new Dependency(5, 4),
  new Dependency(7, 1),
  new Dependency(7, 5),
];

const sortedArray = sortArrayByDependency(array, dependencies);
console.log(sortedArray); // 输出: [1, 4, 5, 2, 7]

在上述示例代码中，我们首先定义了一个Dependency类，用于表示子-父依赖关系。然后，我们定义了一个sortArrayByDependency函数，该函数接受一个数组和一个依赖关系的数组作为参数。

在函数内部，我们首先构建了一个节点和其对应的父节点的映射关系，存储在parentMap对象中。然后，我们定义了一个sortNode函数，用于递归地排序节点。在sortNode函数中，我们先排序父节点（如果存在），然后将节点添加到已排序的数组中。

最后，我们遍历数组中的每个节点，并调用sortNode函数进行排序。排序完成后，我们返回已排序的数组。