It\'s theoretically possible 但需要重新加载页面，因为在最初加载内容进行编辑后，可以更改页面模板；与post类型不同。

（可能尝试使用UpdateSettings 尽管如此documentation is scarce.

嘿，所以有可能做到这一点，我写了一篇文章。您需要使用Gutenberg的data module api.

下面的代码将为您启动并运行此程序。

/** main.js **/
import BlockRestrictor from \'./BlockRestrictor\'

/*
 * Add a mapping of block names and what templates they are
 * restricted to.
 */
const blockTemplateRestrictions = {
    \'core/code\': [
        \'template-super-cool.php\',
    ],
}

wp.domReady(() => {
    const restrictor = new BlockRestrictor(blockTemplateRestrictions)
    const templateWhitelister = new TemplateWhitelister(blockTemplateRestrictions)

    restrictor.run()
    templateWhitelister.run()
})

const { data } = window.wp
const { select, dispatch, subscribe } = data
const { getEditedPostAttribute } = select(\'core/editor\')
const { isTyping } = select(\'core/block-editor\')
const { getBlockType } = select(\'core/blocks\')
const { addBlockTypes, removeBlockTypes } = dispatch(\'core/blocks\')

class BlockRestrictor {
    /**
     * Currently selected template.
     * @type {string}
     */
    currentTemplate = \'\'

    /**
     * Map block names to the actual block object.
     *
     * @type {object}
     */
    unregisteredBlocks = {}

    constructor(blockTemplateRestrictions) {
        this.blockTemplateRestrictions = blockTemplateRestrictions
    }

    /**
     * Initiates listening to the redux store for when a restricted block is either
     * added or removed.
     */
    run() {
        this.currentTemplate = getEditedPostAttribute(\'template\') || \'default\'

        this.restrictBlocksToTemplate()

        /**
         * subscribe fires whenever the redux store in gutenberg updates
         */
        subscribe(() => {
            /**
             * ensure we don\'t run our logic when the user is typing.
             */
            if (isTyping() === true) {
                return false
            }

            const newTemplate = getEditedPostAttribute(\'template\') || \'default\'

            if (this.currentTemplate !== newTemplate) {
                this.currentTemplate = newTemplate
                this.restrictBlocksToTemplate()
            }
        })
    }

    /**
     * Helps decide which blocks we actually want to add or remove from
     * the store.
     */
    templateBlockRegistry() {
        let blocksToAdd = []
        let blocksToRemove = []

        Object.keys(this.blockTemplateRestrictions).forEach((blockName) => {
            if (this.blockTemplateRestrictions[blockName].includes(this.currentTemplate)) {
                blocksToAdd.push(blockName)
            } else {
                blocksToRemove.push(blockName)
            }
        })

        return {
            blocksToAdd,
            blocksToRemove,
        }
    }

    /**
     * Either removes or adds blocks to the store based on what the current
     * template is.
     */
    restrictBlocksToTemplate() {
        const { blocksToAdd, blocksToRemove } = this.templateBlockRegistry()

        if (blocksToRemove.length) {
            blocksToRemove.forEach((blockName) => {
                const blockExists = getBlockType(blockName)
                const isRegistered = typeof this.unregisteredBlocks[blockName] === \'undefined\'
                if (blockExists && isRegistered) {
                    this.unregisteredBlocks[blockName] = getBlockType(blockName)
                }
            })
            removeBlockTypes(Object.keys(this.unregisteredBlocks))
        }

        if (blocksToAdd.length) {
            let registeredBlocks = []
            blocksToAdd.forEach(blockName => {
                const blockExists = typeof getBlockType(blockName) === \'undefined\'
                const isUnregistered = typeof this.unregisteredBlocks[blockName] !== \'undefined\'

                if (blockExists && isUnregistered) {
                    registeredBlocks.push(this.unregisteredBlocks[blockName])
                    delete this.unregisteredBlocks[blockName]
                }
            })
            addBlockTypes(registeredBlocks)
        }
    }

}

export default BlockRestrictor

在此扩展一些现有技术。您需要从js/editor方面处理模板切换。下面是我用来解决这个问题的一个简短片段。

Key Idea:检查模板匹配，删除所有不在白名单中的块，强制取消注册。在注销之前，必须从编辑器中删除所有不允许的块，以防止出现一系列错误。这里的反弹可能会推得更高。

import domReady from \'@wordpress/dom-ready\';
import { dispatch, subscribe, select } from \'@wordpress/data\';
import { getBlockTypes, unregisterBlockType } from \'@wordpress/blocks\'
import { debounce } from \'lodash\';

/**
 * Template Updating.
 */
domReady(() => {
  // Get current block list func.
  const getBlockList = () => select(\'core/block-editor\').getBlocks();

  subscribe(
    debounce(() => {
      // Get Blocks.
      const currentBlockList = getBlockList();

      // Get Template.
      const template = select(\'core/editor\').getEditedPostAttribute(
        \'template\',
      );

      // Set allowed.
      const allowedBlocks = [
        \'core/paragraph\',
      ];
      
      // Check whatever template.
      if (template === \'template-chapters.php\') {
        // Compare current blocks with allowed
        if (currentBlockList.length > 0) {

          // Array of allowed blocks.
          const tmp = currentBlockList.filter(block => {
            return -1 !== allowedBlocks.indexOf(block.name);
          });


          if (tmp.length !== currentBlockList.length && currentBlockList.length > 1) {
            // Remove all offending blocks.
            dispatch(\'core/block-editor\').resetBlocks(tmp);
            return;
          }
        }

        // Proceed to unregister.
        getBlockTypes().forEach( function ( blockType ) {
            if ( allowedBlocks.indexOf( blockType.name ) === -1 ) {
              unregisterBlockType( blockType.name );
            }
        } );
      }
    }, 100)
  );
});