Javascript 使用热键更改文本的大小写（如MS Word中的Shift+；F3）

我正在使用tinymce插件&我正在尝试在一个热键上做一个更改字母大小写功能，就像在MS Word（shift+f3）中一样

我已经成功地通过选择来做到这一点，但即使没有选择单词，MS Word也可以工作

它获取光标的当前位置，在该位置分离出一个单词，并将功能应用于该单词。tinymce也需要同样的

到目前为止，我有：

editor.addShortcut("ctrl+e", "ll", function () {
    var sel = editor.dom.decode(editor.selection.getContent());
    if (/^[a-zа-я]+$/g.test(sel)) {
        sel = sel.substr(0, 1).toUpperCase() + sel.substr(1);
    }
    else if (/^[А-ЯA-Z]+$/g.test(sel)) {
        sel = sel.toLowerCase();
    }
    else {
        sel = sel.toUpperCase();
    }
    editor.selection.setContent(sel);
    console.log(editor.selection);
    editor.save();
    editor.isNotDirty = true;
});

资料来源：

小提琴：

---

以下代码可能会给出您想要的结果。它应该在以下情况下工作：

• 已完全选择一个或多个单词
• 部分选择了一个或多个单词
• 未选择任何文本
• 所选文本属于多个段落
• 在单词中设置了各种文本属性

tinymce.init({
选择器：“文本区域”，
插件：[
“advlist autolink列出链接图像charmap打印预览锚”，
“searchreplace visualblocks代码全屏显示”，
“insertdatetime媒体表上下文菜单粘贴”
],
工具栏：“插入文件撤消重做|样式选择|粗体斜体|对齐左对齐中心对齐右对齐对齐对齐|粗体numlist outdent缩进|链接图像”，
设置：函数（编辑器）{
editor.addShortcut（“ctrl+e”、“ll”、函数（）{
var isWordChar=函数（chr）{
返回/\w/.test（chr）；
};
var isTextNode=函数（节点）{
return node.nodeType==3；
};
var getAllTextNodes=函数（结果，节点）{
if（isTextNode（node））{
结果：推送（节点）；
}
else if（node.childNodes）{
如果（node.tagName==“P”）{
结果：推送（节点）；
}
var children=node.childNodes；
对于（变量i=0；i=0&&！found；i--）
{
node=textNodes[i]；
if（isTextNode（node））{
wordStartNodeIndex=i；
lastCharIndex=node.textContent.length-1；
wordStartOffset=Math.max（0，Math.min（lastCharIndex，node==selStartChildNode？selStartOffset-1:lastCharIndex））；
对于（；wordStartOffset>=0；wordStartOffset--）{
chr=node.textContent[wordStartOffset]；
if（isWordChar（chr））{
wordTextContent=chr+wordTextContent；
}否则{
发现=真；
打破
}
}
}否则{
发现=真；
打破
}
}
wordStartOffset=Math.max（0，wordStartOffset）；
var endNodeFound=false；
var pastEndNode=false；
var isAfterSelection=false；
发现=错误；
//查找最后一个选定单词的结尾
对于（i=selStartNodeIndex；i=selEndOffset-（iscollected？0:1））；
if（isWordChar（chr）| |！isAfterSelection）{
wordTextContent=wordTextContent+chr；
}否则{
发现=真；
打破
}
}
}else if（粘贴节点）{
发现=真；
打破
}
}
//确定要应用的案例样式
var caseMode=''；
如果（/^（[a-z0-9]|\W）+$/g.test（wordTextContent））{
caseMode=‘大写单词’；
}
否则如果（/^（[A-Z0-9]|\W）+$/g.test（wordTextContent））{
caseMode='小写'；
}
否则{
caseMode='大写'；
}
var startCharIndex、endCharIndex、currentIsWordChar；
var prevIsWordChar=false；
var内容=“”；
//应用程序
editor.selection.getRng().startOffset returns the cursor position

tinymce.init({
    selector: "textarea",
    plugins: [
        "advlist autolink lists link image charmap print preview anchor",
        "searchreplace visualblocks code fullscreen",
        "insertdatetime media table contextmenu paste"
    ],
    toolbar: "insertfile undo redo | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image",
    setup: function (editor) {

        editor.addShortcut("ctrl+e", "ll", function () {

            var isWordChar = function (chr) {
                return /\w/.test(chr);
            };

            var isTextNode = function (node) {
                return node.nodeType == 3;
            };

            var getAllTextNodes = function (result, node) {
                if (isTextNode(node)) {
                    result.push(node);
                }
                else if (node.childNodes) {
                    if (node.tagName == 'P') {
                        result.push(node);
                    }
                    var children = node.childNodes;
                    for (var i = 0; i < children.length; i++) {
                        getAllTextNodes(result, children[i]);
                    }
                }
                return result;
            }

            // Get current selection parameters
            var range = editor.selection.getRng();
            var isCollapsed = editor.selection.isCollapsed();
            var selStartChildNode = range.startContainer;
            var selEndChildNode = range.endContainer;
            var selStartOffset = range.startOffset;
            var selEndOffset = range.endOffset;

            // Retrieve all the text nodes in the editor
            var textNodes = [];
            getAllTextNodes(textNodes, editor.dom.getRoot());

            var selStartNodeIndex = textNodes.indexOf(selStartChildNode);
            var selEndNodeIndex = textNodes.indexOf(selEndChildNode);
            var wordStartNodeIndex, wordEndNodeIndex;
            var wordStartOffset, wordEndOffset;
            var wordTextContent = '';
            var found = false;
            var node, chr, lastCharIndex;
            var i, j;

            // Find the start of the first selected word
            for (i = selStartNodeIndex; i >= 0 && !found; i--)
            {
                node = textNodes[i];
                if (isTextNode(node)) {
                    wordStartNodeIndex = i;
                    lastCharIndex = node.textContent.length - 1;
                    wordStartOffset = Math.max(0, Math.min(lastCharIndex, node == selStartChildNode ? selStartOffset - 1 : lastCharIndex));
                    for (; wordStartOffset >= 0; wordStartOffset--) {
                        chr = node.textContent[wordStartOffset];
                        if (isWordChar(chr)) {
                            wordTextContent = chr + wordTextContent;
                        } else {
                            found = true;
                            break;
                        }
                    }
                } else {
                    found = true;
                    break;
                }
            }

            wordStartOffset = Math.max(0, wordStartOffset);

            var endNodeFound = false;
            var pastEndNode = false;
            var isAfterSelection = false;
            found = false;

            // Find the end of the last selected word
            for (i = selStartNodeIndex; i < textNodes.length && !found; i++) {
                node = textNodes[i];
                pastEndNode = endNodeFound;
                if (isTextNode(node)) {
                    wordEndNodeIndex = i;
                    wordEndOffset = Math.min(node == selStartChildNode ? selStartOffset : 0, node.textContent.length - 1);
                    endNodeFound = endNodeFound || node == selEndChildNode;

                    for (; wordEndOffset < node.textContent.length; wordEndOffset++) {
                        chr = node.textContent[wordEndOffset];
                        isAfterSelection = pastEndNode || (endNodeFound && wordEndOffset >= selEndOffset - (isCollapsed ? 0 : 1));
                        if (isWordChar(chr) || !isAfterSelection) {
                            wordTextContent = wordTextContent + chr;
                        } else {
                            found = true;
                            break;
                        }
                    }
                } else if (pastEndNode) {
                    found = true;
                    break;
                }
            }

            // Determine the case style to be applied
            var caseMode = '';
            if (/^([a-z0-9]|\W)+$/g.test(wordTextContent)) {
                caseMode = 'CapitalizeWords';
            }
            else if (/^([A-Z0-9]|\W)+$/g.test(wordTextContent)) {
                caseMode = 'LowerCase';
            }
            else {
                caseMode = 'UpperCase';
            }

            var startCharIndex, endCharIndex, currentIsWordChar;
            var prevIsWordChar = false;
            var content = '';

            // Apply the new case style to the selected nodes
            for (i = wordStartNodeIndex; i <= wordEndNodeIndex; i++) {
                node = textNodes[i];
                if (isTextNode(node)) {
                    startCharIndex = (i == wordStartNodeIndex ? wordStartOffset : 0);
                    endCharIndex = (i == wordEndNodeIndex ? wordEndOffset : node.textContent.length);
                    content = node.textContent.substring(0, startCharIndex);
                    switch (caseMode) {
                        case 'CapitalizeWords':
                            for (j = startCharIndex; j < endCharIndex; j++) {
                                chr = node.textContent[j];
                                currentIsWordChar = /\w/.test(chr);
                                content += (currentIsWordChar && !prevIsWordChar ? chr.toUpperCase() : chr);
                                prevIsWordChar = currentIsWordChar;
                            }
                            break;
                        case 'LowerCase':
                            content += node.textContent.substring(startCharIndex, endCharIndex).toLowerCase();
                            break;
                        case 'UpperCase':
                            content += node.textContent.substring(startCharIndex, endCharIndex).toUpperCase();
                            break;
                    }
                    content += node.textContent.substring(endCharIndex);
                    node.textContent = content;
                } else {
                    prevIsWordChar = false;
                }
            }

            // Restore the selection range
            range.setStart(selStartChildNode, selStartOffset);
            range.setEnd(selEndChildNode, selEndOffset);
            editor.selection.setRng(range);

            editor.save();
            editor.isNotDirty = true;
        });
    }
});