第 69 题： 如何把一个字符串的大小写取反（大写变小写小写变大写），例如 ’AbC' 变成 'aBc' 。

[zeroone001]

function processString (s) {
    var arr = s.split('');
    var new_arr = arr.map((item) => {
        return item === item.toUpperCase() ? item.toLowerCase() : item.toUpperCase();
    });
    return new_arr.join('');
}
console.log(processString('AbC'));

[iotale]

有没有想到用ascii码的？

const STEP = 'a'.charCodeAt() - 'A'.charCodeAt();

function transCase(char) {
  const asciiCode = char.charCodeAt();
  const resultCode = asciiCode < 'a'.charCodeAt() ? asciiCode + STEP : asciiCode - STEP;
  return String.fromCharCode(resultCode);
}

function transStr(str) {
  const charArr = str.split('');
  return charArr.map(char => transCase(char)).join('');
}

问题是只适用于大小写字母区间，不然表现会很怪异。

优化的时候可以做做边界条件。思路应该没问题。

[suguoyao]

马上想到的也是一楼的方法，另外也可以：

function swapString(str) {
  var result = ''

  for (var i = 0; i < str.length; i++) {
    var c = str[i]

    if (c === c.toUpperCase()) {
      result += c.toLowerCase()
    } else {
      result += c.toUpperCase()
    }
  }

  return result
}

swapString('ADasfads123!@$!@#') // => 'adASFADS123!@$!@#'

[suguoyao]

@iotale 你这个只考虑了字母，如果有其他字符就行不通了

transStr('adASjOdapASJO!@#4123123.l124')
// "ADasJoDAPasjoA`CTQRSQRSNLQRT"

[zhuzhh]

var str = 'AsdfsCsdefsd,$qwsDR'
var mapCode = {
    'A': 'A'.charCodeAt(0),
    'Z': 'Z'.charCodeAt(0),
    'a': 'a'.charCodeAt(0),
    'z': 'z'.charCodeAt(0),
}
var diff = mapCode.a - mapCode.A
var arr = str.split('')
for(var i = 0; i < arr.length; i++) {
    var code = arr[i].charCodeAt(0)
    if(code >= mapCode.A && code <= mapCode.Z) { // 大写
        arr[i] = String.fromCharCode(code + diff) // 转小写
    }else if(code >= mapCode.a && code <= mapCode.z){ // 小写
        arr[i] = String.fromCharCode(code - diff) // 转大写
    }else { // 不是字母
        console.log(arr[i], "不是字母")
        arr.splice(i, 1)
        i--
    }
}
console.log(arr.join(''))

[kungithub]

'AbcDefGh'.replace(/[a-zA-Z]/g,function(a){ return /[a-z]/.test(a)?a.toUpperCase():a.toLowerCase(); });

[YouziXR]

用ASCII做了一下。

// 第 69 题： 如何把一个字符串的大小写取反（大写变小写小写变大写），例如 ’AbC' 变成 'aBc' 。
const reverseStr = (str) => {
  let tmpAry = str.split('')
  let resultAry = []
  let a = 'a'.charCodeAt()
  let A = 'A'.charCodeAt()
  tmpAry.map((val) => {
    // debugger
    if (val <= 'Z' && val >= 'A') {
      resultAry.push(String.fromCharCode(val.charCodeAt() + (a - A)))
    } else if (val <= 'z' && val >= 'a') {
      resultAry.push(String.fromCharCode(val.charCodeAt() - (a - A)))
    } else {
      resultAry.push(val)
    }
  })
  return resultAry.join('')
}
console.log(reverseStr('aBCDefgh!@##%^$^*!@#$%'))

[btea]

[].map.call(str, function(item){     
     return /[a-z]/.test(item) ? item.toUpperCase() : item.toLowerCase(); 
}).join('');

[ZodiacSyndicate]

const reverse = str => {
        let result = ''
	for (let i = 0; i < str.length; i++) {
		if (str[i] > 'Z') {
			result += str[i].toUpperCase()
		} else {
			result += str[i].toLowerCase()
		}
	}
	return result
}

[Seasonley]

fn=(str)=>str.replace(/[A-Za-z]/g,c=>String.fromCharCode(c.charCodeAt()+(c<'['?32:-32)))
fn('-@A[Bc')//"-@a[bC"

[wangminglmm]

用了3种实现方法处理千万级别长度字符，对比了下时间，分享给大家，for循环+unicode转行相对较快 function getRandomStr() { let str = '' let arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ] for (let i = 0; i < 10000000; i++) { let num = parseInt(Math.random() * 53) str += arr[num] } return str }

    function transformStr1() {
        console.time('生成1千万长度字符串用时')
        let str = getRandomStr()
        console.timeEnd('生成1千万长度字符串用时')
        // console.log(str)
        console.time('使用正则替换用时')
        let str1 = str.replace(/./g, (input) => {
            let num = input.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                return String.fromCharCode(num + 32)
            } else {
                return String.fromCharCode(num - 32)
            }
        })
        console.timeEnd('使用正则替换用时')
        // console.log(str)
        console.time('使用for循环耗时')
        let str2 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let num = s.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                str2 += String.fromCharCode(num + 32)
            } else {
                str2 += String.fromCharCode(num - 32)
            }
        }
        console.timeEnd('使用for循环耗时')
        console.log(str1 === str2)
        console.time('使用toUppercase逐个转换耗时')
        let str3 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let sUp = s.toUpperCase()
            if (sUp === s) {
                str3 += s.toLocaleLowerCase()
            } else {
                str3 += sUp
            }
        }
        console.timeEnd('使用toUppercase逐个转换耗时')
        console.log(str2 === str3)
        console.time('使用toUppercase转换字符')
    }

[FounderIsShadowWalker]

let a = 'aB1cd';

const gap = 'a'.charCodeAt() - 'A'.charCodeAt(); const A_ASCII = 'A'.charCodeAt(); const Z_ASCII = 'Z'.charCodeAt();

const test = (a) => a.replace(/[a-zA-Z]/g, (str, value) => { let ascii_code = str.charCodeAt(); if(ascii_code >= A_ASCII && ascii_code <= Z_ASCII){ //大写 return String.fromCharCode(ascii_code + gap) //转小写 }else{ return String.fromCharCode(ascii_code - gap); } })

console.error(test(a));

[xiatian]

正则实现： str.replace(/(\w)/g, m => m === m.toUpperCase() ? m.toLowerCase() : m.toUpperCase())

[fuqianxi]

const str = 'AjklAJIBNiuh'; console.log(str)

let newStr = ''
for (const i of str) {
  let j = '';
  if (/[A-Z]/.test(i)) {
   j =  i.toLowerCase();
   
  } else {
   j = i.toUpperCase();
   
  }
  newStr+=j
}
console.log(newStr)

[Bottle1206]

不用转成数组直接replace操作字符串

function transfer(str) {
  return str.replace(/[a-zA-Z]/g, match => {
    return /[a-z]/.test(match) ? match.toUpperCase() : match.toLowerCase()
  })
}

[lxinr]

function transString(str) {
  if(typeof str !== 'string') return
  let strArr = str.split('')
  return strArr.reduce((acc, cur) => acc += (cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase()))
}

[weiweixuan]

str = 'abcDEFg' strRes = str.replace(/[a-zA-Z]/g,(item)=>{ if(item===item.toUpperCase()){ return item.toLowerCase(); } return item.toUpperCase() })

[kingstone3]

function transString (str){
    return Array.prototype.reduce.call(str, (acc, cur) => acc + (cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase()), '');
}

[susiwen8]

function test(str) {
  str = str.split('').map(item => {
    if (item === item.toUpperCase()) {
      return item.toLowerCase();
    } else {
      return item.toUpperCase();
    }
  }).join('');
  console.log(str);
}

[Gintangible]

function transString(str){
     return str.split('').map((item) =>{
          return item == item.toLowerCase() ? item.toUpperCase() : item.toLowerCase();
     }).join('');
}

[GuoYuFu123]

    /**
    @param: {str} 
    */
    function reversal(str) {
        let newstr = '';
        for(let i = 0 ; i < str.length; i++) {
            console.log(str[i].toUpperCase())
            newstr += (str[i] === str[i].toUpperCase() ? str[i].toLowerCase() : str[i].toUpperCase())
        }
        return newstr;
    }
    console.log(reversal('AbC'))

[44021987]

function tranStr(str) {
  if (typeof str !== 'string') return ''
  const splitStr = str.split('')
  return splitStr.reduce((res, s) => {
    if (/[a-z]/g.test(s)) {
      res += s.toLocaleUpperCase()
    } else if (/[A-Z]/g.test(s)) {
      res += s.toLocaleLowerCase()
    } else {
      res += s
    }
    return res
  }, '')
}

[44021987]

/**
 * 把一个字符串的大小写取反（大写变小写小写变大写），例如 ’AbC' 变成 'aBc'
 * @param {*} str 
 */
function tranStr2(str) {
  if (typeof str !== 'string') return str
  return str.replace(/[a-zA-Z]/g, function(s) {
    return /[a-z]/g.test(s) ? s.toLocaleUpperCase() : /[A-Z]/g.test(s) ? s.toLocaleLowerCase() : s
  })
}

[cheungkin24]

function transString(str) {
  if(typeof str !== 'string') return
  let strArr = str.split('')
  return strArr.reduce((acc, cur) => acc += (cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase()))
}

第一个字母没有转换吧==

[LiuMengzhou]

  reverseCase = function (s) {
    const isLowerCase = char => {
      const range = ['a'.charCodeAt(), 'z'.charCodeAt()];
      const charCode = char.charCodeAt();
      return charCode >= range[0] && charCode <= range[1];
    }
    const isUpperCase = char => {
      const range = ['A'.charCodeAt(), 'Z'.charCodeAt()];
      const charCode = char.charCodeAt();
      return charCode >= range[0] && charCode <= range[1];
    }
    return s.split('').map(char => {
      if (isLowerCase(char)) return char.toUpperCase();
      if (isUpperCase(char)) return char.toLowerCase();
    }).join('');
  }

[LiuMengzhou]

用了3种实现方法处理千万级别长度字符，对比了下时间，分享给大家，for循环+unicode转行相对较快 function getRandomStr() { let str = '' let arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ] for (let i = 0; i < 10000000; i++) { let num = parseInt(Math.random() * 53) str += arr[num] } return str }

    function transformStr1() {
        console.time('生成1千万长度字符串用时')
        let str = getRandomStr()
        console.timeEnd('生成1千万长度字符串用时')
        // console.log(str)
        console.time('使用正则替换用时')
        let str1 = str.replace(/./g, (input) => {
            let num = input.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                return String.fromCharCode(num + 32)
            } else {
                return String.fromCharCode(num - 32)
            }
        })
        console.timeEnd('使用正则替换用时')
        // console.log(str)
        console.time('使用for循环耗时')
        let str2 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let num = s.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                str2 += String.fromCharCode(num + 32)
            } else {
                str2 += String.fromCharCode(num - 32)
            }
        }
        console.timeEnd('使用for循环耗时')
        console.log(str1 === str2)
        console.time('使用toUppercase逐个转换耗时')
        let str3 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let sUp = s.toUpperCase()
            if (sUp === s) {
                str3 += s.toLocaleLowerCase()
            } else {
                str3 += sUp
            }
        }
        console.timeEnd('使用toUppercase逐个转换耗时')
        console.log(str2 === str3)
        console.time('使用toUppercase转换字符')
    }

为啥不顺手把输出结果也贴出来 =。 =

[wangminglmm]

用了3种实现方法处理千万级别长度字符，对比了下时间，分享给大家，for循环+unicode转行相对较快 function getRandomStr() { let str = '' let arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ] for (let i = 0; i < 10000000; i++) { let num = parseInt(Math.random() * 53) str += arr[num] } return str }

    function transformStr1() {
        console.time('生成1千万长度字符串用时')
        let str = getRandomStr()
        console.timeEnd('生成1千万长度字符串用时')
        // console.log(str)
        console.time('使用正则替换用时')
        let str1 = str.replace(/./g, (input) => {
            let num = input.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                return String.fromCharCode(num + 32)
            } else {
                return String.fromCharCode(num - 32)
            }
        })
        console.timeEnd('使用正则替换用时')
        // console.log(str)
        console.time('使用for循环耗时')
        let str2 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let num = s.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                str2 += String.fromCharCode(num + 32)
            } else {
                str2 += String.fromCharCode(num - 32)
            }
        }
        console.timeEnd('使用for循环耗时')
        console.log(str1 === str2)
        console.time('使用toUppercase逐个转换耗时')
        let str3 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let sUp = s.toUpperCase()
            if (sUp === s) {
                str3 += s.toLocaleLowerCase()
            } else {
                str3 += sUp
            }
        }
        console.timeEnd('使用toUppercase逐个转换耗时')
        console.log(str2 === str3)
        console.time('使用toUppercase转换字符')
    }

为啥不顺手把输出结果也贴出来 =。 =

用了3种实现方法处理千万级别长度字符，对比了下时间，分享给大家，for循环+unicode转行相对较快 function getRandomStr() { let str = '' let arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ] for (let i = 0; i < 10000000; i++) { let num = parseInt(Math.random() * 53) str += arr[num] } return str }

    function transformStr1() {
        console.time('生成1千万长度字符串用时')
        let str = getRandomStr()
        console.timeEnd('生成1千万长度字符串用时')
        // console.log(str)
        console.time('使用正则替换用时')
        let str1 = str.replace(/./g, (input) => {
            let num = input.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                return String.fromCharCode(num + 32)
            } else {
                return String.fromCharCode(num - 32)
            }
        })
        console.timeEnd('使用正则替换用时')
        // console.log(str)
        console.time('使用for循环耗时')
        let str2 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let num = s.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                str2 += String.fromCharCode(num + 32)
            } else {
                str2 += String.fromCharCode(num - 32)
            }
        }
        console.timeEnd('使用for循环耗时')
        console.log(str1 === str2)
        console.time('使用toUppercase逐个转换耗时')
        let str3 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let sUp = s.toUpperCase()
            if (sUp === s) {
                str3 += s.toLocaleLowerCase()
            } else {
                str3 += sUp
            }
        }
        console.timeEnd('使用toUppercase逐个转换耗时')
        console.log(str2 === str3)
        console.time('使用toUppercase转换字符')
    }

[wangminglmm]

用了3种实现方法处理千万级别长度字符，对比了下时间，分享给大家，for循环+unicode转行相对较快 function getRandomStr() { let str = '' let arr = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ] for (let i = 0; i < 10000000; i++) { let num = parseInt(Math.random() * 53) str += arr[num] } return str }

    function transformStr1() {
        console.time('生成1千万长度字符串用时')
        let str = getRandomStr()
        console.timeEnd('生成1千万长度字符串用时')
        // console.log(str)
        console.time('使用正则替换用时')
        let str1 = str.replace(/./g, (input) => {
            let num = input.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                return String.fromCharCode(num + 32)
            } else {
                return String.fromCharCode(num - 32)
            }
        })
        console.timeEnd('使用正则替换用时')
        // console.log(str)
        console.time('使用for循环耗时')
        let str2 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let num = s.charCodeAt(0)
            if (num >= 65 && num <= 90) {
                str2 += String.fromCharCode(num + 32)
            } else {
                str2 += String.fromCharCode(num - 32)
            }
        }
        console.timeEnd('使用for循环耗时')
        console.log(str1 === str2)
        console.time('使用toUppercase逐个转换耗时')
        let str3 = ''
        for (let i = 0, len = str.length; i < len; i++) {
            let s = str[i]
            let sUp = s.toUpperCase()
            if (sUp === s) {
                str3 += s.toLocaleLowerCase()
            } else {
                str3 += sUp
            }
        }
        console.timeEnd('使用toUppercase逐个转换耗时')
        console.log(str2 === str3)
        console.time('使用toUppercase转换字符')
    }

为啥不顺手把输出结果也贴出来 =。 =

贴上去了

[LiuMengzhou]

@wangminglmm 感谢，很直观

[pengcc]

好像没看到用spread的，我写一下，用regex判断是否是字母, 以及用String.fromCharCode和String.prototype.charCodeAt()来切换大小写。

const flipByCharCode = (str) => [...str].map((char) => {
    let isAlphabet = /[a-z]/i.test(char);
    let isLowercase = /[a-z]/.test(char);

    return !isAlphabet ? char : String.fromCharCode(char.charCodeAt(0) + 32 * (isLowercase ? -1 : 1));
}).join('');

# 代码写成同行，对手机阅读不友好
const flipByCharCode = (str) => [...str].map((s) => !/[a-z]/i.test(s) ? s : String.fromCharCode(s.charCodeAt(0) + 32 * (/[a-z]/.test(s) ? -1 : 1))).join('');

[leemotive]

'asdARRADFafkAIoOHFohfhii'.replace(/([a-z]+)|([A-Z]+)/g, function(s, s1, s2){
	return s1 ? s1.toUpperCase() : s2.toLowerCase();
})
// ASDarradfAFKaiOohfOHFHII

[cleverboy32]

let map = {
     'a': 'A',
     ....
     'Z': 'z'
};

function reserveCase (str) {
     return str.replace(/([a-z]+)|([A-Z]+)/g, function(a){
	return map[a] || '';
    });
}

[Nolaaaaa]

循环字符串，判断是小写还是大写，小写的转化成大写，大写的转化成小写，其他类型的不做处理

let str = 'aBc'
let newStr = ''
for(let i of str) {
  if(/[a-z]/.test(i)) {
    i = i.toUpperCase() 
  } else if(/[A-Z]/.test(i)) {
    i = i.toLowerCase() 
  }
  newStr += i
}
console.log(newStr)

【地址】

[FlySnails]

ES6来一波

const transFormStr = (str) => {
    return str.split('').map(c => c = c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase()).join('');
};

console.log(transFormStr('AbC'))

[wushufen]

'AbC'.replace(/[a-z]/ig, i=> i.match(/[A-Z]/)? i.toLowerCase(): i.toUpperCase())

[zhangxuanlin]

(str.split('').map(v => v.charCodeAt() > 90 ? v.toLocaleUpperCase() : v.toLocaleLowerCase()).join('')

[dorseysen]

//  the first solution —— 利用 toLowerCase 和 toUpperCase

const reverseLetter0 = str => str.split('').map(item => item !== item.toLowerCase() ? item.toLowerCase() : item.toUpperCase()).join(''); 

console.log(reverseLetter0('Dorsey Hello'));

//  the second solution —— 利用unicode码值
const reverseLetter = str => {

    let res = '';

    for(let i = 0; i < str.length; i ++) {

        res += str[i].charCodeAt() >= 65 && str[i].charCodeAt() <= 90 ? 
            
        String.fromCharCode(str[i].charCodeAt() + 32) : 
        String.fromCharCode(str[i].charCodeAt() - 32);
    }
    return res;
}
console.log(reverseLetter0('AbC'));

[bluebrid]

function func(str) { 
   return (str+'').split('').reduce((init, next) => {   
       init = init +  next [next.toUpperCase() === next ? 'toLowerCase' : 'toUpperCase']();
       return init
   }, '')
}
function func1(str) {
    return str.replace(/([a-z])|([A-Z])/g,(match, $1, $2) => $1 ? $1.toUpperCase() : $2.toLowerCase())
}
console.log(func('aBcdFddfs'))
console.log(func1('aBcdFddfs'))

[yucopowo]

'AbC'.split('').map((x)=> (x === x.toLowerCase())?x.toUpperCase():x.toLowerCase()).join('')

[web3fans]

function processString (s) { if（!s）{ return s; } var arr = s.split(''); var new_arr = arr.map((item) => { if(item >= 'a' && item <= 'z' || item > 'A' && item < 'Z'){ return item === item.toUpperCase() ? item.toLowerCase() : item.toUpperCase(); } else{ return item; }
}); return new_arr.join(''); } console.log(processString('AbC$$&^88'));

[Jhin926]

'AbC'.replace(/[a-z]/ig, s => /[a-z]/.test(s) ? s.toUpperCase():s.toLowerCase())

[Jhin926]

'AbCaBBHFc'.replace(/([a-z])|[A-Z]/g, (s, c) => c ? s.toUpperCase():s.toLowerCase())

[Any-time]

Array.from("AbCDe").reduce((arr, item) => {
  arr.push( /[A-Z]/.test(item) ? item.toLocaleLowerCase() : item.toLocaleUpperCase())
  return arr
}, []).join("")

[kerrysheng]

var s='Asxxd3443@'.replace(/([a-z])|([A-Z])/g,(v,...pn)=>pn[0]&&pn[0].toUpperCase()||pn[1]&&pn[1].toLowerCase())
console.log(s)//aSXXD3443@

字符串可以是任意字符

[leehf]

"aadGbDDD@44454545/".split("").map(item=>{return item===item.toLowerCase()?item.toUpperCase():item.toLowerCase()}).join('')

[liuwenai]

function wapString(str) { let result = '' for (let i = 0; i < str.length; i++) { if (str[i] <= 'Z' && str[i] >= 'A') { result += str[i].toLowerCase() } else { result += str[i].toUpperCase() } } console.log(result) } wapString('AbC');

[masterminmcj]

function fn(str) {
    return Array.prototype.map.call(str,t=>t.toUpperCase()==t?t.toLowerCase():t.toUpperCase()).join('');
}

var s = 'aBcDeFgHiGk';
console.log(fn(s))

[bWhirring]

str
  .split('')
  .reverse()
  .reduce(
    (str, v) =>
      (str +=
        v === v.toLocaleLowerCase()
          ? v.toLocaleUpperCase()
          : v.toLocaleLowerCase()),
    ''
  );

[LastStranger]

for (let index in arr){
	if(arr[index].charCodeAt() >90){
		arr[index] = arr[index].toUpperCase()
	}else {
		arr[index] = arr[index].toLowerCase()
	}
}
console.log(arr.join(''));

[fyZhang66]

function transfer(str){
  let result = []
  let arr = str.split('')
  arr.forEach((item)=>{
    let tmp = item.toUpperCase() === item ? item.toLowerCase():item.toUpperCase()
    result.push(tmp)
  })
  return result.join('')
}

console.log(transfer('aBc'))

[pagnkelly]

应该是没人回答位运算吧，ASCII 码中'A' => 65 'a' => 97 差了32 其实只要 运用异或符号一下就可以

65 ^ 32 => 97 97 ^ 32 => 65

String.fromCharCode('A'.charCodeAt() ^ 32 )

[helloyoucan]

'AbC'.split('').map((item)=>{
	if(item.match(/[a-z]/)){
		return item.toUpperCase()
	}else if(item.match(/[A-Z]/)){
		return item.toLowerCase()
	}
	return item
}).join('')

[1045598742]

let str = 'AbC123CCmz'; let reg = /[A-z]/g; let newStr = str.replace(reg, a => a.charCodeAt()<97?a.toLowerCase():a.toUpperCase()) console.log(newStr);

[yft]

关于 @wangminglmm 的 https://github.com/Advanced-Frontend/Daily-Interview-Question/issues/116#issuecomment-491172168

为什么会在 node 下运行结果不同？求解惑

[GoldWorker]

'aBcD'.split('').map((item,i)=>{
    return /[a-z]/.test(item)?item.toUpperCase():item.toLowerCase()
}).join('')

[K-walker]

function fun (s) {
  var a = 97 ;
  var z = a + 25 ;
  var A = 65 ;
  var Z = A + 25;
  const result = Array.from(s).map( char => {
    var code = char.charCodeAt(0);
    if(code >= a && code <= z) return String.fromCharCode(code - 32);
    if(code >= A && code <= Z) return String.fromCharCode(code + 32);
    return char ;
  }) 
  return result.join('')
}

[K-walker]

完善版：

function upperOrLower (s) {
  return Array.from(s).map( char => {
    if(/[a-z]/.test(char)) return char.toUpperCase();
    if(/[A-Z]/.test(char)) return char.toLowerCase();
    return char ;
  }).join('')
}

console.log(upperOrLower('A@nD1!eO'))

[daiyunchao]

var str="AbC";
var newStr="";
for(let i=0;i<str.length;i++){
	let keyCode=str.charCodeAt(i);
	if(keyCode>=65&&keyCode<=90){
		//是大写字母:
		newStr+=str[i].toLowerCase();
	}else if(keyCode>=97&&keyCode<=122){
		newStr+=str[i].toUpperCase();
	}
	else{
		newStr+=str[i]
	}
}

console.log(newStr)

[Linkontoask]

String.fromCharCode(...[...'abC'].map(item => item.charCodeAt() < 97 ? item.charCodeAt() + 32 : item.charCodeAt() - 32))

[zockbell]

var str = 'AbC';

	function foo(str) {
		const arr = str.split("");
		for(let i=0; i<arr.length; i++){
			if(arr[i] === arr[i].toUpperCase()){
				arr[i] = arr[i].toLowerCase();
			}else{
				arr[i] = arr[i].toUpperCase();
			}
		}
		return arr.join("");
	}

	console.log( foo(str) );

[Lokya]

let a = "aBc123" [...a].map(a => {return a.toUpperCase() === a ? a.toLowerCase() : a.toUpperCase()}).join('') // 输出 "AbC123"

[KiraYo4kage]

['', ...'AbC'].reduce((pre, now) => pre + (now === now.toUpperCase() ? now.toLowerCase() : now.toUpperCase()))

[spongege]

    const a = 'AaAaAaAa123456'
    const func = str => str.replace(/[a-zA-Z]/g, v => /[a-z]/.test(v) ? v.toUpperCase() : v.toLowerCase())
    console.log(a); // 'AaAaAaAa123456'
    console.log(func(a)); // 'aAaAaAaA123456'

[wxGoldking]

function handle(string){
    return Array.prototype.map.call(string, (item)=>{
        return item === item.toUpperCase() ? item.toLowerCase() : item.toUpperCase();
    }).join('')
}

[huangd-d]

'2aabbAAbDssD1'.replace(/([a-z]+)|([A-Z]+)/g,function(m,s,d){if(d){return d.toLocaleLowerCase() };if(s){return s.toLocaleUpperCase()}}); // "2AABBaaBdSSd1";

[307590317]

function opposite(str) {
  return str.replace(/[a-z]/ig,function (item) {
    return /[A-Z]/.test(item) ? item.toLowerCase() : item.toUpperCase();
  })
}
console.log(opposite('我w的天dxsdEsdf下')); //我W的天DXSDeSDF下

有问题欢迎指正

[listentolife]

function transString(str) {
  if(typeof str !== 'string') return
  let strArr = str.split('')
  return strArr.reduce((acc, cur) => acc += (cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase()))
}

第一个字母没有转换吧==

改成这样就可以了

function transString(str) {
    if(typeof str !== 'string') return
    let strArr = str.split('')
    return strArr.reduce((acc, cur) => acc += (cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase()), '')
}

[Wuxiaa]

const res = '';
for(let item of str){
    res += item.toUpperCase() == item ? item.toLowerCase() : item.toUpperCase()
}
console.log(res)

[tywei90]

[...a].map((v) => v===v.toUpperCase() ? v.toLowerCase() : v.toUpperCase()).join('')

[soneway]

[...'AbC'].map(i => i.toLowerCase() === i ? i.toUpperCase() : i.toLowerCase()).join('')

[772658652]

let string = 'aBc'; let newString = ''; for (let item of string){ if(item ==item.toLowerCase()){ newString+=item.toUpperCase(); }else{ newString+=item.toLowerCase(); } }

console.log(newString);

[licc12]

let str = "AbC";
    let aa = str.replace(/[A-Za-z]/g,(e)=>{
        if(/[A-Z]/g.test(e)){
            return e.toLowerCase();
        }else if(/[a-z]/g.test(e)){
            return e.toUpperCase();
        }else{
            return e;
        }
    });
console.log(aa);//aBc

[coveyz]

是这道题我理解的有问题吗? ??

const processString = str => {
  let newStr =''
  for (let index = 0; index < str.length; index++) {
    newStr += str[index] === str[index].toUpperCase() ? str[index].toLowerCase() : str[index].toUpperCase()
  }
  return newStr
}

[xiaoang]

"aBcdEfg".replace(/\w/g,function(item){return item === item.toUpperCase() ? item.toLowerCase() : item.toUpperCase() })

[xiaoshenjing]

const str = 'aBcDcAS'
const transform = str => str.replace(/([a-z])|([A-Z])/g, (e) => {
    return /[a-z]/.test(e) ? e.toUpperCase() : e.toLowerCase()
})
transform(str)

[lakalakaka]

let  invertString = (str) => {
  let stringArr = str.split('');
  let newArr = [];
  for (let index = 0; index < stringArr.length; index++) {
    var element = stringArr[index];
    if(element<'A' || element>'Z') {
      element = element.toUpperCase();
    } else {
      element = element.toLowerCase();
    }
    newArr.push(element);
  }
  return newArr.join('');
}

[SnailOwO]

// 想法是根据unciode来的 let tmp = ''; let str = 'AbC'; for (let i = 0; i < str.length; i++) { if (str.codePointAt(i) >= 65 && str.codePointAt(i) <= 90) { tmp += str[i].toLowerCase(); } else { tmp += str[i].toUpperCase(); } } console.log(tmp);

[zenglinan]

"AbC".replace(/\w/g, (s) => {
    return s === s.toLowerCase() ? s.toUpperCase() : s.toLowerCase()
})

[PengSama]

'AHdjjjSSS'.replace(/[a-zA-Z]/g, function(match){
  if (match.charCodeAt(0) < 97) {
    return match.toLowerCase()
  }
    return match.toUpperCase()
})

[litokele2018]

let str1 = 'AbC'

function toggle(str) {
  let s =''
  for (let i in str) {
    if (str[i] === str[i].toUpperCase()) {
      s += str[i].toLowerCase()
    } else {
      s += str[i].toUpperCase()
    }
  }
  return s
}

toggle(str1)

[jingsy]

let str = 'AbC';

const stringReverse = (str) => str.split('').map(i =>
 i===i.toUpperCase()?i.toLowerCase():i.toUpperCase()).join('')

let res = stringReverse(str)
console.log(res); //'aBc'

[zuoyi615]

const str = 'AbC'
let result = ''
const a = 91

for (let i = 0; i < str.length; ++i) {
  const code = str.charCodeAt(i)
  result += code > 91 ? str[i].toUpperCase() : str[i].toLowerCase()
}

console.log(result)

[UnrealCherry]

'AbC'.split('').map(x => {if (x.charCodeAt() <= 97) return x.toLocaleLowerCase(); return x.toLocaleUpperCase()}).join('')

[aitexiaoy]

aa.replace(/([a-z])|([A-Z])/g,function(a,b,c){
    return b?b.toUpperCase():c.toLowerCase()
})

正则处理一下，当然正则效率低

[chinadbo]

const processStr = str => str.split('').map(
    item => item === item.toUpperCase() 
    ? item.toLowerCase() 
    : item.toUpperCase()
).join('')

[zhangpanfei]

function overturnStr(str) {
  let newStr = ''
  for (let s of str) {
    if (s.toUpperCase() === s) {
      newStr += s.toLowerCase()
    }
    newStr += s.toUpperCase()
  }
  return newStr
}

[lanshanmao]

var str = 'AbC' str.replace(/[a-zA-Z]/g, (s) => { const l = /[a-z]/g const u = /[A-Z]/g if (l.test(s)) { return s.toUpperCase() } if (u.test(s)) { return s.toLowerCase() } })

[eatureide]

const str = 'AbC'

console.log(
  str.split('').map((item) => (item.toUpperCase() !== item ? item.toUpperCase() : item.toLowerCase())).join('')
)

[jackchang2015]

function strA(str){ 
    let p = str.split('');
    let s ='';
    for(let i =0; i< p.length; i++){
        if(p[i].toUpperCase() === p[i]){
            s += p[i].toLowerCase();
        }else {
           s += p[i].toUpperCase();
       }
    }
    return s;
};
strA('aBc') // => "AbC"

[lsbbd]

const str = 'aBc';

str
  .split('')
  .map((char) => {
    const tmp = char.toUpperCase();
    return tmp === char ? char.toLowerCase() : tmp;
  })
  .join('');

[zockbell]

------------------ 原始邮件 ------------------ 发件人: "Advanced-Frontend/Daily-Interview-Question" <[email protected]>; 发送时间: 2020年7月16日(星期四) 晚上6:12 收件人: "Advanced-Frontend/Daily-Interview-Question"<[email protected]>; 抄送: "my9080"<[email protected]>;"Comment"<[email protected]>; 主题: Re: [Advanced-Frontend/Daily-Interview-Question] 第 69 题： 如何把一个字符串的大小写取反（大写变小写小写变大写），例如 ’AbC' 变成 'aBc' 。 (#116)

const str = 'aBc'; str .split('') .map((char) => { const tmp = char.toUpperCase(); return tmp === char ? char.toLowerCase() : tmp; }) .join('');

— You are receiving this because you commented. Reply to this email directly, view it on GitHub, or unsubscribe.

[taichiyi]

// 版本一
const reverseCharacterCase = str => [...str]
  .map(character => {
    /* TODO 验证参数 */
    const charCode = character.charCodeAt();
    return String.fromCharCode(charCode + (charCode > 90 ? -32 : 32));
  })
  .join('');
console.log(reverseCharacterCase('sdFuIa')); // SDfUiA

// 版本二
const reverseCharacterCaseSlim = str => [...str].map(character => String.fromCharCode(character.charCodeAt() + (character.charCodeAt() > 90 ? -32 : 32))).join('');
console.log(reverseCharacterCaseSlim('sdFuIa')); // SDfUiA

[jackchang2015]

const reverseCase = str => {
    let s = '';
    for(let i of str){
        if(i === i.toUpperCase()){
            s += i.toLowerCase();
        }else {
           s += i.toUpperCase();
        }
    }
    return s;
};
reverseCase('abCDeFgHe'); // "ABcdEfGhE"

[RoeyXie]

var str = "AbC==-3.$%^&*……"


str.replace(/([a-zA-Z])/g, (match) => /[a-z]/.test(match) ? match.toUpperCase() : match.toLowerCase())

[jackchang2015]

function reverseCase(str){
    return str.split('').map(item => {
        return item === item.toUpperCase()? item.toLowerCase(): item.toUpperCase()}).join('');
};
reverseCase('abCDeFgHe'); // "ABcdEfGhE"

[XuedaoYuan]

str
.split('')
.map((char) => {
	const code = char.charCodeAt()
	if (code >= 97) {
		return String.fromCharCode(code - 32)
	} else {
		return String.fromCharCode(code + 32)
	}
})
.join('')

[gogoend]

let invertCase = (str)=>{
    let [uA,uZ,ua,uz] = ['A'.charCodeAt(), 'Z'.charCodeAt(), 'a'.charCodeAt(), 'z'.charCodeAt()]

    return Array.prototype.map.call(str, (item,index)=>{
        if (item.charCodeAt() >= uA && item.charCodeAt() <= uZ)
            return item.toLowerCase()
        else if (item.charCodeAt() >= ua && item.charCodeAt() <= uz)
            return item.toUpperCase()
        else
            return item
    }
    ).join('')
}

[m7yue]

const reverseChar= (c) => {
  const lc = c.toLowerCase()
  return c == lc ? c.toUpperCase() : lc
}
const reverseCase = (str) => {
  let len = str.length
  let res = ''
  for(let i=0; i<len; i++) {
    res += reverseChar(str[i])
  }
  return res
}
console.log(reverseCase('AbC'))

[hanhang123]

@iotale 你这个只考虑了字母，如果有其他字符就行不通了

transStr('adASjOdapASJO!@#4123123.l124')
// "ADasJoDAPasjoA`CTQRSQRSNLQRT"

题目不是只包含字母嘛

[Dujishi]

const reverseCase = s=>s.split('').reduce((t,c)=>${t}${c.toUpperCase() === c?c.toLowerCase():c.toUpperCase()},'')

[blank1u]

const toLowerUpperCase = (str = '') => {
    return str.split('').map(val => val === val.toUpperCase() ? val.toLowerCase() : val.toUpperCase()).join('')
}

console.log(toLowerUpperCase('AbC'));