Advanced-Frontend/Daily-Interview-Question

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

zeroone001 opened this issue · 131 comments

zeroone001 commented 
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 commented

有没有想到用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('');
}

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

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

  • 👍21
  • 👎2
  • 🚀9
  • 👀4
suguoyao commented

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

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!@$!@#'
  • 👍3
  • ❤️5
suguoyao commented

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

transStr('adASjOdapASJO!@#4123123.l124')
// "ADasJoDAPasjoA`CTQRSQRSNLQRT"
  • 😄1
zhuzhh commented 
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(''))
  • 👍5
kungithub commented

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

  • 👍76
  • 👎1
  • 😄4
  • 🎉2
  • 🚀16
YouziXR commented

用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 commented 
[].map.call(str, function(item){     
     return /[a-z]/.test(item) ? item.toUpperCase() : item.toLowerCase(); 
}).join('');
  • 👍15
ZodiacSyndicate commented 
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
}
  • 😄2
Seasonley commented 
fn=(str)=>str.replace(/[A-Za-z]/g,c=>String.fromCharCode(c.charCodeAt()+(c<'['?32:-32)))
fn('-@A[Bc')//"-@a[bC"
  • 👍2
wangminglmm commented

用了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转换字符')
    }
  • 👍6
FounderIsShadowWalker commented

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 commented

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

  • 👍11
fuqianxi commented

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 commented

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

function transfer(str) {
  return str.replace(/[a-zA-Z]/g, match => {
    return /[a-z]/.test(match) ? match.toUpperCase() : match.toLowerCase()
  })
}
  • 👍3
lxinr commented 
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 commented

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

kingstone3 commented 
function transString (str){
    return Array.prototype.reduce.call(str, (acc, cur) => acc + (cur === cur.toUpperCase() ? cur.toLowerCase() : cur.toUpperCase()), '');
}
susiwen8 commented 
function test(str) {
  str = str.split('').map(item => {
    if (item === item.toUpperCase()) {
      return item.toLowerCase();
    } else {
      return item.toUpperCase();
    }
  }).join('');
  console.log(str);
}
Gintangible commented 
function transString(str){
     return str.split('').map((item) =>{
          return item == item.toLowerCase() ? item.toUpperCase() : item.toLowerCase();
     }).join('');
}
GuoYuFu123 commented 
    /**
    @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'))
  • 👍1
44021987 commented 
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 commented 
/**
 * 把一个字符串的大小写取反（大写变小写小写变大写），例如 ’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 commented 
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 commented 
  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 commented

用了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 commented

用了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转换字符')
    }

image

wangminglmm commented

用了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 commented

@wangminglmm 感谢，很直观

pengcc commented

好像没看到用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 commented 
'asdARRADFafkAIoOHFohfhii'.replace(/([a-z]+)|([A-Z]+)/g, function(s, s1, s2){
	return s1 ? s1.toUpperCase() : s2.toLowerCase();
})
// ASDarradfAFKaiOohfOHFHII
cleverboy32 commented 
let map = {
     'a': 'A',
     ....
     'Z': 'z'
};

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

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

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 commented

ES6来一波

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

console.log(transFormStr('AbC'))

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

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

  • 👍1
dorseysen commented 
//  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 commented 
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 commented

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

web3fans commented

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 commented

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

Jhin926 commented

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

Any-time commented 
Array.from("AbCDe").reduce((arr, item) => {
  arr.push( /[A-Z]/.test(item) ? item.toLocaleLowerCase() : item.toLocaleUpperCase())
  return arr
}, []).join("")
kerrysheng commented 
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 commented

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

liuwenai commented

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 commented 
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 commented 
str
  .split('')
  .reverse()
  .reduce(
    (str, v) =>
      (str +=
        v === v.toLocaleLowerCase()
          ? v.toLocaleUpperCase()
          : v.toLocaleLowerCase()),
    ''
  );
LastStranger commented 
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 commented 
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 commented

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

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

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

  • 👍8
  • 🎉1
  • ❤️1
helloyoucan commented 
'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 commented

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 commented

关于 @wangminglmm 的 #116 (comment)

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

image

GoldWorker commented 
'aBcD'.split('').map((item,i)=>{
    return /[a-z]/.test(item)?item.toUpperCase():item.toLowerCase()
}).join('')
  • 👍1
K-walker commented 
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 commented

完善版：

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 commented 
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 commented 
String.fromCharCode(...[...'abC'].map(item => item.charCodeAt() < 97 ? item.charCodeAt() + 32 : item.charCodeAt() - 32))
  • 👍1
zockbell commented

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) );
  • 😄1
Lokya commented

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

KiraYo4kage commented 
['', ...'AbC'].reduce((pre, now) => pre + (now === now.toUpperCase() ? now.toLowerCase() : now.toUpperCase()))
spongege commented 
    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 commented 
function handle(string){
    return Array.prototype.map.call(string, (item)=>{
        return item === item.toUpperCase() ? item.toLowerCase() : item.toUpperCase();
    }).join('')
}
huangd-d commented

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

307590317 commented 
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 commented 
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 commented 
const res = '';
for(let item of str){
    res += item.toUpperCase() == item ? item.toLowerCase() : item.toUpperCase()
}
console.log(res)
tywei90 commented 
[...a].map((v) => v===v.toUpperCase() ? v.toLowerCase() : v.toUpperCase()).join('')
soneway commented 
[...'AbC'].map(i => i.toLowerCase() === i ? i.toUpperCase() : i.toLowerCase()).join('')
772658652 commented

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 commented 
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 commented

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

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
}

1576484742347

xiaoang commented

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

xiaoshenjing commented 
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 commented 
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('');
}
  • 👍1
  • 😄1
  • 🎉1
  • ❤️1
  • 🚀1
SnailOwO commented

// 想法是根据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 commented 
"AbC".replace(/\w/g, (s) => {
    return s === s.toLowerCase() ? s.toUpperCase() : s.toLowerCase()
})
PengSama commented 
'AHdjjjSSS'.replace(/[a-zA-Z]/g, function(match){
  if (match.charCodeAt(0) < 97) {
    return match.toLowerCase()
  }
    return match.toUpperCase()
})
litokele2018 commented 
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)
zuoyi615 commented 
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 commented

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

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

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

chinadbo commented 
const processStr = str => str.split('').map(
    item => item === item.toUpperCase() 
    ? item.toLowerCase() 
    : item.toUpperCase()
).join('')
zhangpanfei commented 
function overturnStr(str) {
  let newStr = ''
  for (let s of str) {
    if (s.toUpperCase() === s) {
      newStr += s.toLowerCase()
    }
    newStr += s.toUpperCase()
  }
  return newStr
}
lanshanmao commented

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 commented 
const str = 'AbC'

console.log(
  str.split('').map((item) => (item.toUpperCase() !== item ? item.toUpperCase() : item.toLowerCase())).join('')
)
jackchang2015 commented 
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 commented 
const str = 'aBc';

str
  .split('')
  .map((char) => {
    const tmp = char.toUpperCase();
    return tmp === char ? char.toLowerCase() : tmp;
  })
  .join('');
zockbell commented
taichiyi commented 
// 版本一
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 commented 
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 commented 
var str = "AbC==-3.$%^&*……"


str.replace(/([a-zA-Z])/g, (match) => /[a-z]/.test(match) ? match.toUpperCase() : match.toLowerCase())
jackchang2015 commented 
function reverseCase(str){
    return str.split('').map(item => {
        return item === item.toUpperCase()? item.toLowerCase(): item.toUpperCase()}).join('');
};
reverseCase('abCDeFgHe'); // "ABcdEfGhE"
XuedaoYuan commented 
str
.split('')
.map((char) => {
	const code = char.charCodeAt()
	if (code >= 97) {
		return String.fromCharCode(code - 32)
	} else {
		return String.fromCharCode(code + 32)
	}
})
.join('')
  • 👍1
gogoend commented 
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 commented 
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 commented

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

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

题目不是只包含字母嘛

Dujishi commented

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

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

console.log(toLowerUpperCase('AbC'));
Yusup64 commented 
'AbC'.split('').map(char => {
    let asciiNo = char.codePointAt(0)
    if (asciiNo >= 65 && asciiNo < 97) {
        return String.fromCodePoint(asciiNo + 32)
    } else {
        return String.fromCodePoint(asciiNo - 32)
    }
}).join('')
  • 👍1
  • 🚀1