宜宾网站建设公司

字符串有哪些操作方法

小编给大家分享一下字符串有哪些操作方法，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！

站在用户的角度思考问题，与客户深入沟通，找到喀喇沁网站设计与喀喇沁网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：成都网站设计、成都做网站、企业官网、英文网站、手机端网站、网站推广、申请域名、虚拟主机、企业邮箱。业务覆盖喀喇沁地区。

字符串属性和方法

字符串用于表示和操作字符序列。字符串属性和方法有很多。以下是可供参考的代码示例，包括ES2020中的“matchAll”和ES2021中的“replaceAll”。

const str = Today is a nice day! ;         console.log(str.length); // 20       console.log(str[2]); // "d"       console.log(typeof str); // "string"       console.log(typeof str[2]); // "string"       console.log(typeofString(5)); //"string"       console.log(typeofnewString(str)); //"object"       console.log(str.indexOf( is )); // 6       console.log(str.indexOf( today )); // -1       console.log(str.includes( is )); // true       console.log(str.includes( IS )); // false       console.log(str.startsWith( Today )); // true       console.log(str.endsWith( day )); // false       console.log(str.split(   )); // ["Today", "is", "a", "nice","day!"]       console.log(str.split(  )); // ["T", "o", "d", "a","y", " ", "i", "s", " ","a", " ", "n", "i", "c","e", " ", "d", "a", "y","!"]       console.log(str.split( a )); // ["Tod", "y is ", " nice d","y!"]       console.log(str +1+2); // "Today is a nice day!12"       console.log(str + str); // "Today is a nice day!Today is a niceday!"       console.log(str.concat(str)); // "Today is a nice day!Today is a niceday!"       console.log(str.repeat(2)); // "Today is a nice day!Today is a nice day!"       console.log( abc < bcd ); // true       console.log( abc .localeCompare( bcd )); // -1       console.log( a .localeCompare( A )); // -1       console.log( a .localeCompare( A , undefined, { numeric: true })); // -1       console.log( a .localeCompare( A , undefined, { sensitivity:  accent  })); // 0       console.log( a .localeCompare( A , undefined, { sensitivity:  base  })); // 0       console.log( a .localeCompare( A! , undefined, { sensitivity:  base , ignorePunctuation: true })); // 0       console.log( abc .toLocaleUpperCase()); // "ABC"       console.log(str.padStart(25,  * )); // "*****Todayis a nice day!"       console.log(str.padEnd(22,  ! )); // "Today is anice day!!!"       console.log(    middle  .trim().length); // 6       console.log(    middle  .trimStart().length); // 8       console.log(    middle  .trimEnd().length); // 9       console.log(str.slice(6, 8)); // "is"       console.log(str.slice(-4)); // "day!"       console.log(str.substring(6, 8)); // "is"       console.log(str.substring(-4)); // "Today is a nice day!"       console.log( a .charCodeAt()); // 97       console.log(String.fromCharCode(97)); // "a"       console.log(str.search(/[a-c]/)); // 3       console.log(str.match(/[a-c]/g)); // ["a", "a", "c", "a"]       console.log([...str.matchAll(/[a-c]/g)]);       // [Array(1), Array(1), Array(1), Array(1)]       // 0: ["a", index: 3, input: "Today is a nice day!",groups: undefined]       // 1: ["a", index: 9, input: "Today is a nice day!",groups: undefined]       // 2: ["c", index: 13, input: "Today is a niceday!", groups: undefined]       // 3: ["a", index: 17, input: "Today is a niceday!", groups: undefined]       console.log([... test1test2 .matchAll(/t(e)(st(d?))/g)]);       // [Array(4), Array(4)]       // 0: (4) ["test1", "e", "st1","1", index: 0, input: "test1test2", groups: undefined]       // 1: (4) ["test2", "e", "st2","2", index: 5, input: "test1test2", groups: undefined]       console.log(str.replace( a ,  z )); // Todzy is anice day!       console.log(str.replace(/[a-c]/,  z )); // Todzy is anice day!       console.log(str.replace(/[a-c]/g,  z )); // Todzy is znize dzy!       console.log(str.replaceAll( a ,  z )); // Todzy is znice dzy!       console.log(str.replaceAll(/[a-c]/g,  z )); // Todzy is znize dzy!       console.log(str.replaceAll(/[a-c]/,  z )); // TypeError:String.prototype.replaceAll called with a non-global RegExp argument

映射和集合

对于字符串操作，我们需要在某处存储中间值。数组、映射和集合都是需要掌握的常用数据结构，本文主要讨论集合和映射。

(1) 集合

Set是存储所有类型的唯一值的对象。以下是供参考的代码示例，一目了然。

const set =newSet( aabbccdefghi );                         console.log(set.size); // 9                        console.log(set.has( d )); // true                        console.log(set.has( k )); // false                        console.log(set.add( k )); // {"a", "b", "c", "d","e" "f", "g", "h", "i","k"}                        console.log(set.has( k )); // true                        console.log(set.delete( d )); // true                        console.log(set.has( d )); // false                        console.log(set.keys()); // {"a", "b", "c","e" "f", "g", "h", "i","k"}                        console.log(set.values()); // {"a", "b", "c","e" "f", "g", "h", "i","k"}                        console.log(set.entries()); // {"a" => "a","b" => "b", "c" => "c","e" => "e",                        // "f"=> "f", "g" => "g", "h" =>"h"}, "i" => "i", "k" =>"k"}                        const set2 =newSet();                        set.forEach(item => set2.add(item.toLocaleUpperCase()));                        set.clear();                        console.log(set); // {}                        console.log(set2); //{"A", "B", "C", "E", "F","G", "H", "I", "K"}                        console.log(newSet([{ a: 1, b: 2, c: 3 }, { d: 4, e: 5 }, { d: 4, e: 5 }]));                        // {{a: 1, b: 2,c: 3}, {d: 4, e: 5}, {d: 4, e: 5}}                        const item = { f: 6, g: 7 };                        console.log(newSet([{ a: 1, b: 2, c: 3 }, item, item]));                        // {{a: 1, b: 2,c: 3}, {f: 6, g: 7}}

(2) 映射

映射是保存键值对的对象。任何值都可以用作键或值。映射会记住键的原始插入顺序。以下是供参考的代码示例：

const map =newMap();          console.log(map.set(1,  first )); // {1 =>"first"}       console.log(map.set( a ,  second )); // {1 =>"first", "a" => "second"}       console.log(map.set({ obj:  123  }, [1, 2, 3]));       // {1 => "first", "a" =>"second", {obj: "123"} => [1, 2, 3]}       console.log(map.set([2, 2, 2], newSet( abc )));       // {1 => "first", "a" => "second",{obj: "123"} => [1, 2, 3], [2, 2, 2] => {"a","b", "c"}}       console.log(map.size); // 4       console.log(map.has(1)); // true       console.log(map.get(1)); // "first"       console.log(map.get( a )); // "second"       console.log(map.get({ obj:  123  })); // undefined       console.log(map.get([2, 2, 2])); // undefined       console.log(map.delete(1)); // true       console.log(map.has(1)); // false       const arr = [3, 3];       map.set(arr, newSet( xyz ));       console.log(map.get(arr)); // {"x", "y", "z"}       console.log(map.keys()); // {"a", {obj: "123"}, [2, 2,2], [3, 3]}       console.log(map.values()); // {"second", [1, 2, 3], {"a","b", "c"}, {"x", "y", "z"}}       console.log(map.entries());       // {"a" => "second", {obj: "123"}=> [1, 2, 3], [2, 2, 2] => {"a", "b", "c"},[3, 3] => {"x", "y", "z"}}       const map2 =newMap([[ a , 1], [ b , 2], [ c , 3]]);       map2.forEach((value, key, map) => console.log(`value = ${value}, key = ${key}, map = ${map.size}`));       // value = 1, key = a, map = 3       // value = 2, key = b, map = 3       // value = 3, key = c, map = 3       map2.clear();       console.log(map2.entries()); // {}

应用题

面试中有英语应用题，我们探索了一些经常用于测试的算法。

(1) 等值线

等值线图是指所含字母均只出现一次的单词。

  • dermatoglyphics (15个字母)

  • hydropneumatics (15个字母)

  • misconjugatedly (15个字母)

  • uncopyrightable (15个字母)

  • uncopyrightables (16个字母)

  • subdermatoglyphic (17个字母)

如何写一个算法来检测字符串是否是等值线图?有很多方法可以实现。可以把字符串放在集合中，然后自动拆分成字符。由于集合是存储唯一值的对象，如果它是一个等值线图，它的大小应该与字符串长度相同。

/**     * An algorithm to verify whethera given string is an isogram     * @param {string} str The string to be verified     * @return {boolean} Returns whether it is an isogram     */    functionisIsogram(str) {     if (!str) {        returnfalse;     }             const set =newSet(str);     return set.size=== str.length;    }

以下是验证测试：

console.log(isIsogram(  )); // false                              console.log(isIsogram( a )); // true                             console.log(isIsogram( misconjugatedly )); // true                             console.log(isIsogram( misconjugatledly )); // false

(2) 全字母短句

全字母短句是包含字母表中所有26个字母的句子，不分大小写。理想情况下，句子越短越好。以下为全字母短句:

  • Waltz, bad nymph, for quick jigs vex. (28个字母)

  • Jived fox nymph grabs quick waltz. (28个字母)

  • Glib jocks quiz nymph to vex dwarf. (28个字母)

  • Sphinx of black quartz, judge my vow. (29个字母)

  • How vexingly quick daft zebras jump! (30个字母)

  • The five boxing wizards jump quickly. (31个字母)

  • Jackdaws love my big sphinx of quartz. (31个字母)

  • Pack my box with five dozen liquor jugs. (32个字母)

  • The quick brown fox jumps over a lazy dog. (33个字母)

还有很多方法可以验证给定的字符串是否是全字母短句。这一次，我们将每个字母(转换为小写)放入映射中。如果映射大小为26，那么它就是全字母短句。

/**        * An algorithm to verify whethera given string is a pangram     * @param {string} str The string to be verified     * @return {boolean} Returns whether it is a pangram     */    functionisPangram(str) {     const len = str.length;     if (len <26) {        returnfalse;     }                const map =newMap();     for (let i =0; i < len; i++) {        if (str[i].match(/[a-z]/i)) { // if it is letter a to z, ignoring the case          map.set(str[i].toLocaleLowerCase(), true); // use lower case letter as a key        }     }     return map.size===26;    }

以下是验证测试：

console.log(isPangram(  )); // false                              console.log(isPangram( Bawds jog, flick quartz, vex nymphs. )); // true                             console.log(isPangram( The quick brown fox jumped over the lazy sleepingdog. )); // true                             console.log(isPangram( Roses are red, violets are blue, sugar is sweet,and so are you. )); // false

(3) 同构字符串

给定两个字符串s和t，如果可以替换掉s中的字符得到t，那么这两个字符串是同构的。s中的所有字符转换都必须应用到s中相同的字符上，例如，murmur与tartar为同构字符串，如果m被t替换，u被a替换，r被自身替换。以下算法使用数组来存储转换字符，也适用于映射。

/**     * An algorithm to verify whethertwo given strings are isomorphic     * @param {string} s The first string     * @param {string} t The second string     * @return {boolean} Returns whether these two strings are isomorphic     */    functionareIsomorphic(s, t) {     // strings with different lengths are notisomorphic     if (s.length !== t.length) {          returnfalse;     }                // the conversion array     const convert = [];     for (let i =0; i < s.length; i++) {          // if the conversioncharacter exists          if (convert[s[i]]) {              // apply the conversion and compare              if (t[i] === convert[s[i]]) { // so far so good                  continue;              }              returnfalse; // not isomorphic          }                    // set the conversion character for future use          convert[s[i]] = t[i];     }                // these two strings are isomorphic since there are no violations     returntrue;    };

以下是验证测试：

onsole.log(areIsomorphic( atlatl ,  tartar )); // true                                     console.log(areIsomorphic( atlatlp ,  tartarq )); // true                                     console.log(areIsomorphic( atlatlpb ,  tartarqc )); // true                                     console.log(areIsomorphic( atlatlpa ,  tartarqb )); // false

(4) 相同字母异构词

相同字母异构词是通过重新排列不同单词的字母而形成的单词，通常使用所有原始字母一次。从一个池中重新排列单词有很多种可能性。例如，cat的相同字母异构词有cat、act、atc、tca、atc和tac。我们可以添加额外的要求，即新单词必须出现在源字符串中。如果源实际上是actually，则结果数组是[“act”]。

/**     * Given a pool to compose ananagram, show all anagrams contained (continuously) in the source     * @param {string} source A source string to draw an anagram from     * @param {string} pool A pool to compose an anagram     * @return {array} Returns an array of anagrams that are contained by the source string     */    functionshowAnagrams(source, pool) {     // if source is not long enough to hold theanagram     if (source.length< pool.length) {        return [];     }                const sourceCounts = []; // an array tohold the letter counts in source     const poolCounts = []; // an array tohold the letter counts in pool                // initialize counts for 26 letters to be 0     for (let i =0; i <26; i++) {        sourceCounts[i] =0;        poolCounts[i] =0;     }                // convert both strings to lower cases     poolpool = pool.toLocaleLowerCase();     const lowerSource = source.toLocaleLowerCase();                for (let i =0; i < pool.length; i++) {         // calculatepoolCounts for each letter in pool, mapping a - z to 0 - 25        poolCounts[pool[i].charCodeAt() -97]++;     }                const result = [];     for (let i =0; i < lowerSource.length; i++) {        // calculatesourceCounts for each letter for source, mapping a - z to 0 - 25        sourceCounts[lowerSource[i].charCodeAt() -97]++;        if (i >= pool.length-1) { // if source islong enough          // if sourceCountsis the same as poolCounts          if (JSON.stringify(sourceCounts) ===JSON.stringify(poolCounts)) {            // save the found anagram, using the original source to make stringcase-preserved            result.push(source.slice(i - pool.length+1, i +1));          }          // shift thestarting window by 1 index (drop the current first letter)          sourceCounts[lowerSource[i - pool.length+1].charCodeAt() -97]--;        }     }           // removeduplicates by a Set     return [...newSet(result)];    }

以下是验证测试：

console.log(showAnagrams( AaaAAaaAAaa ,  aa )); // ["Aa", "aa", "aA", "AA"]                                         console.log(showAnagrams( CbatobaTbacBoat ,  Boat ));  //["bato", "atob", "toba", "obaT","Boat"]                                         console.log(showAnagrams( AyaKkayakkAabkk ,  Kayak ));                                         // ["AyaKk", "yaKka", "aKkay", "Kkaya","kayak", "ayakk", "yakkA"]

(5) 回文

回文是从前往后读和从后往前读读法相同的单词或句子。有很多回文，比如A，Bob，还有 “A man, a plan, a canal —  Panama”。检查回文的算法分为两种。使用循环或使用递归从两端检查是否相同。下列代码使用递归方法：

/**     * An algorithm to verify whethera given string is a palindrome     * @param {string} str The string to be verified     * @return {boolean} Returns whether it is a palindrome     */    functionisPalindrome(str) {     functioncheckIsPalindrome(s) {        // empty stringor one letter is a defecto palindrome        if (s.length<2) {          returntrue;        }                  if ( // if two ends notequal, ignoring the case          s[0].localeCompare(s[s.length-1], undefined, {            sensitivity:  base ,          }) !== 0        ) {          returnfalse;        }                  // since two ends equal, checking the inside        returncheckIsPalindrome(s.slice(1, -1));     }          // check whether it is a palindrome, removing noneletters and digits     returncheckIsPalindrome(str.replace(/[^A-Za-z0-9]/g,   ));    }

以下是验证测试：

console.log(isPalindrome(  )); // true                                console.log(isPalindrome( a )); // true                                console.log(isPalindrome( Aa )); // true                                console.log(isPalindrome( Bob )); // true                                console.log(isPalindrome( Odd or even )); // false                                console.log(isPalindrome( Never odd or even )); // true                                console.log(isPalindrome( 02/02/2020 )); // true                                console.log(isPalindrome( 2/20/2020 )); // false                                console.log(isPalindrome( A man, a plan, a canal – Panama )); // true

回文面试题有很多不同的变形题，下面是一个在给定字符串中寻找最长回文的算法。

/**                                            * An algorithm to find thelongest palindrome in a given string     * @param {string} source The source to find the longest palindrome from     * @return {string} Returns the longest palindrome     */    functionfindLongestPalindrome(source) {     // convert to lower cases and only keep lettersand digits     constlettersAndDigits = source.replace(/[^A-Za-z0-9]/g,   );     const str = lettersAndDigits.toLocaleLowerCase();                const len = str.length;               // empty string or one letter is a defecto palindrome     if (len <2) {        return str;     }                // the first letter is the current longest palindrome     let maxPalindrome = lettersAndDigits[0];                // assume that the index is the middle of a palindrome     for (let i =0; i < len; i++) {                  // try the case that the palindrome has one middle        for (          let j =1; // start with onestep away (inclusive)          j < len &&// end with the len end (exclusive)          i - j >= 0&&// cannot pass the start index (inclusive)          i + j < len &&// cannot exceed end index (exclusive)          Math.min(2 * i +1, 2 * (len - i) -1) > maxPalindrome.length; // potential max length should be longer than thecurrent length          j++        ) {          if (str[i - j] !== str[i + j]) { // if j stepsbefore the middle is different from j steps after the middle            break;          }          if (2 * j +1> maxPalindrome.length) { // if it is longerthan the current length            maxPalindrome = lettersAndDigits.slice(i - j, i + j +1); // j steps before, middle, and j steps after          }        }                  // try the case that the palindrome has two middles        if (i < len -1&& str[i] === str[i +1]) { // if two middles are the same          if (maxPalindrome.length<2) { // the string withtwo middles could be the current longest palindrome            maxPalindrome = lettersAndDigits.slice(i, i +2);          }          for (            let j =1; // start with one step away (inclusive)            j < len -1&&// end with the len - 1 end (exclusive)            i - j >= 0&&// cannot pass the start index (inclusive)            i + j +1< len &&// cannot exceed end index (exclusive)            Math.min(2 * i +2, 2 * (len - i)) > maxPalindrome.length; // potential max length should be longer than thecurrent length            j++          ) {            if (str[i - j] !== str[i + j +1]) { // if j stepsbefore the left middle is different from j steps after the right middle              break;            }            if (2 * j +2> maxPalindrome.length) { // if it is longer than the current length              maxPalindrome = lettersAndDigits.slice(i - j, i + j +2); // j steps before, middles, and j steps after            }          }        }     }     return maxPalindrome;    }

以下是验证测试：

console.log(findLongestPalindrome(  )); // ""                                          console.log(findLongestPalindrome( abc )); // "a"                                         console.log(findLongestPalindrome( Aabcd )); // "Aa"                                         console.log(findLongestPalindrome( I am Bob. )); // "Bob"                                         console.log(findLongestPalindrome( Odd or even )); // "Oddo"                                         console.log(findLongestPalindrome( Never odd or even )); // "Neveroddoreven"                                         console.log(findLongestPalindrome( Today is 02/02/2020. )); // "02022020"                                         console.log(findLongestPalindrome( It is 2/20/2020. )); // "20202"                                         console.log(findLongestPalindrome( A man, a plan, a canal – Panama )); // "AmanaplanacanalPanama"

以上是“字符串有哪些操作方法”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！


当前题目：字符串有哪些操作方法
当前链接：http://ybzwz.com/article/gpogjo.html

其他资讯