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

zeroone001 · 2019-05-07T23:31:56Z

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 · 2019-05-08T00:36:34Z

有没有想到用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 · 2019-05-08T00:41:18Z

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

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 · 2019-05-08T00:44:10Z

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

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

zhuzhh · 2019-05-08T00:50:26Z

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 · 2019-05-08T01:07:49Z

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

YouziXR · 2019-05-08T01:09:46Z

用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 · 2019-05-08T01:14:39Z

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

ZodiacSyndicate · 2019-05-08T02:34:31Z

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 · 2019-05-08T02:41:35Z

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

wangminglmm · 2019-05-08T02:49:35Z

用了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 · 2019-05-08T02:52:22Z

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 · 2019-05-08T04:21:05Z

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

fuqianxi · 2019-05-08T04:45:35Z

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 · 2019-05-08T05:04:29Z

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

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

lxinr · 2019-05-08T07:17:51Z

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 · 2019-05-08T07:58:46Z

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

kingstone3 · 2019-05-08T08:00:01Z

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

susiwen8 · 2019-05-09T06:43:22Z

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

Gintangible · 2019-05-09T07:08:36Z

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

GuoYuFu123 · 2019-05-09T11:33:55Z

    /**
    @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 · 2019-05-10T02:00:16Z

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 · 2019-05-10T02:11:34Z

/**
 * 把一个字符串的大小写取反（大写变小写小写变大写），例如 ’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 · 2019-05-10T05:57:21Z

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 · 2019-05-10T06:04:50Z

  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 · 2019-05-10T06:17:48Z

用了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 · 2019-05-10T06:26:23Z

用了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 · 2019-05-10T06:27:04Z

用了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 · 2019-05-10T06:28:14Z

@wangminglmm 感谢，很直观

pengcc · 2019-05-10T21:45:01Z

好像没看到用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('');

orime · 2021-01-30T09:02:06Z

function transStr(str){
  console.log(str)
  return [...str].map((s) => {
    console.log(s)
    return s.toUpperCase() === s ? s.toLowerCase() : s.toUpperCase()
  }).join('')
}
const strTest = 'AbC'
console.log(transStr(strTest))

3104026951 · 2021-03-04T14:35:29Z

function transStr(str) {
return str.split('').map(it => String.fromCharCode(it.charCodeAt()<91?it.charCodeAt()+32:it.charCodeAt()-32)).join('')
}

ZhengXiaowei · 2021-03-15T07:04:08Z

function tranformText(text) {
  var text2 = text.toLowerCase();
  var result = "";
  for(let i = 0; i < text.length; i++) {
    if (text[i] === text2[i]) result+=text[i].toUpperCase();
    else result+=text2[i]
  }
  return result;
}

Otresuguka · 2021-03-16T08:15:17Z

function foo(s) {
return s.replace(/([a-zA-Z])/g, function (match, b, offset, string) {
return match < 'a' ? match.toLowerCase() : match.toUpperCase()
})
}

MrLeihe · 2021-04-26T10:03:04Z

1、使用 `toLowerCase` 和 `toUpperCase`

function reverse(str) {
  var origin = str.split('')
  return origin.map(char => {
    if(char.toLowerCase() === char) {
      return char.toUpperCase()
    } else {
      return char.toLowerCase()
    }
  }).join('')
}

2、使用 `fromCharCode`

这种方法只适用于只存在英文字母的情况

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

ruanlinxin · 2021-05-05T13:04:39Z

// 大写的A-Z 转码比较结果比  小写a 要小
function turn(str){
        const strArr = str.split('')
        return strArr.map(key=> key < 'a' ? key.toLowerCase() : key.toUpperCase()).join('')
    }

zhelingwang · 2021-05-10T08:05:11Z

let str = 'GuanWeiChang', result = '';
let UpperCaseIdx = [];
str.replace(/[A-Z]/g, function (match, idx) {
  UpperCaseIdx.push(idx);
});
for (let i = 0; i < str.length; i++) {
  const char = str[i];
  result += UpperCaseIdx.includes(i) ? char.toLowerCase() : char.toUpperCase();
}
console.log(result);

zhuyuzhu · 2021-05-16T05:35:56Z

        var str = 'AbC'
        var reg = /([A-Z])|([a-z])/g
        var result = str.replace(reg, function (match, p1, p2) {
            if (p1) {
                return p1.toLowerCase()
            }
            if (p2) {
                return p2.toUpperCase()
            }
        })
        console.log(result)//aBc

wmb0412 · 2021-06-09T09:13:57Z

const changeCase = (string) => {
	return [...string].reduce((total, item) => {
		total += (item.toLowerCase() == item ? item.toUpperCase() : item.toLowerCase())
		return total
	},'')
}
console.log(changeCase('AFDdhfaADvD'))

3fatty · 2021-06-23T12:22:26Z

"AabBcZz123,./".replace(/[a-zA-Z]/g, c=>c.charCodeAt(0)<91?c.toLowerCase(): c.toUpperCase());
// 得到 'aABbCzZ123,./'

635864859 · 2021-07-14T10:06:53Z

function letterUpperCaseReserve(string){
let result = [...string].map(item =>{
if(/^[a-z]+$/.test(item)) return item.toUpperCase();
return item.toLowerCase();
})
return result.join('');
}

gogopaner · 2021-08-30T07:08:23Z

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

   ` console.log(reverse('aBCd'), 'reverse(str)');`

xiangfei1 · 2021-10-16T03:26:56Z

//我也写了用ascall码的，只适用于英文字母字符串
function reverseNum(str) {
    let res = [];
    let arr = str.split('');
    let len = 'a'.charCodeAt();
    for(let i=0;i<arr.length;i++){
        let item = arr[i].charCodeAt();
        res.push(String.fromCharCode(item>=len?item-32:item+32));
    }
    return res.join('');
}

SnailOwO · 2021-12-21T07:02:37Z

// Ascii码
 let res = []
    let str = 'Abc'
    for (let val of str) {
        // console.log(val);
        if (val.codePointAt(0) >= 65 && val.codePointAt(0) <= 90) {
            res.push(val.toLowerCase())
        }
        if (val.codePointAt(0) >= 97 && val.codePointAt(0) <= 122) {
            res.push(val.toUpperCase())
        }
    }
    console.log(res.join(''));

44021987 · 2021-12-21T07:02:58Z

天天开心！

Four-Names · 2022-02-24T08:29:42Z

let isUpperCase = (s = String) => s.charCodeAt() > 64 && s.charCodeAt() < 91;
let isLowerCase = (s = String) => s.charCodeAt() > 96 && s.charCodeAt() < 123;
let reverseCharCase = (str = String) =>
  str
    .split("")
    .map((v, i) => (isLowerCase(v) ? v.toUpperCase() : v.toLowerCase()))
    .join("");

44021987 · 2022-02-24T08:30:04Z

天天开心！

daolou · 2022-02-24T09:20:27Z

function isLowerByAsciiCode(code){
    return code > 64 && code <91;
}

function isUpperByAsciiCode(code){
    return code > 96 && code <122;
}

function isLetterByAsciiCode(code){
    return isLowerByAsciiCode(code) || isUpperByAsciiCode(code);
}

function flipLetter (str){
    let newStr = '';
    for (i of str) {
        const asciiCode = i.charCodeAt();
        if(isLetterByAsciiCode(asciiCode)){
            newStr += String.fromCharCode(asciiCode ^ 32);
        }else{
            newStr += i;
        }
    }
    return newStr;
}

flipLetter('adASjOdapASJO!@#4123123.l124');
// 'ADasJoDAPasjo!@#4123123.L124'

Long-Xin1111 · 2022-03-03T08:08:30Z

function convertString(str){
    let newStr = '';
    for (i of str){
        /[A-Z]/.test(i) ? newStr+=i.toLowerCase() : newStr+=i.toUpperCase();
    }
    return newStr;
}
console.log(convertString('aSa123,./'));   //AsA123,./

bluebrid · 2022-05-17T02:05:29Z

let str = 'ADasfads123!@$!@#'
str = str.replace(/([a-z])|([A-Z])/g, ($match, $1, $2) => {
return $2?.toLowerCase() || $1?.toUpperCase()
})
console.log(str)

leehf · 2022-05-17T02:05:57Z

已收到

44021987 · 2022-05-17T02:05:57Z

天天开心！

SceneryCN · 2023-02-21T07:30:24Z

正则判断一下是否为字母其余的不做修改

const pase = (str) => {
  const arr = str.split("");
  for (let i = 0; i < arr.length && /[a-z,A-Z]/g.test(str); i++) {
    if (arr[i].charCodeAt() >= 97) {
      arr[i] = arr[i].toUpperCase();
    } else {
      arr[i] = arr[i].toLowerCase();
    }
  }
  return arr.join("");
};

44021987 · 2023-02-21T07:30:50Z

天天开心！

leehf · 2023-02-21T07:30:52Z

已收到

benzhemin · 2023-02-24T06:39:07Z

const reverseCase = rawString => {
    const [lowerCharBase, lowerCharCap] = ['a'.charCodeAt(0), 'z'.charCodeAt(0)];
    const [upperCharBase, upperCharCap] = ['A'.charCodeAt(0), 'Z'.charCodeAt(0)];

    const transformCharList = rawString.split('').reduce((res, charItem) => {
        const code = charItem.charCodeAt(0);

        if (code >= lowerCharBase && code <= lowerCharCap) {
            res.push(charItem.toUpperCase());
        } else if (
            code >= upperCharBase && code <= upperCharCap) {
            res.push(charItem.toLowerCase());
        } else {
            res.push(charItem)
        }

        return res;
    }, [])

    return transformCharList.join('');
}

const inputString = 'AbC';
const result = reverseCase(inputString);

console.log(result);

chenzhengduan · 2024-05-30T08:47:36Z

function swapCase(str) {
// 将字符串转换为字符数组
let charArray = str.split('');

// 遍历数组并处理每个字符
for (let i = 0; i < charArray.length; i++) {
    let char = charArray[i];
    
    // 检查字符是否为大写，并转换为小写
    if (char === char.toUpperCase()) {
        charArray[i] = char.toLowerCase();
    } 
    // 检查字符是否为小写，并转换为大写
    else if (char === char.toLowerCase()) {
        charArray[i] = char.toUpperCase();
    }
}

// 将处理后的字符数组重新合并成一个字符串
return charArray.join('');

}

// 示例
let originalString = 'AbC';
let swappedString = swapCase(originalString);
console.log(swappedString); // 输出 'aBc'

listentolife · 2024-05-30T08:48:11Z

你的邮件我已收到，我会马上查看！ —————————————————————— 现在的追逐梦想是为了日后能拥有美好的“那些年”！

44021987 · 2024-05-30T08:48:14Z

天天开心！

leehf · 2024-05-30T08:48:48Z

已收到

yygmind mentioned this issue May 10, 2019

用正则判断是否为小写字母 #117

Closed

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

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

Comments

zeroone001 commented May 7, 2019 • edited Loading

iotale commented May 8, 2019 • edited Loading

suguoyao commented May 8, 2019

suguoyao commented May 8, 2019

zhuzhh commented May 8, 2019

kungithub commented May 8, 2019

YouziXR commented May 8, 2019

btea commented May 8, 2019 • edited Loading

ZodiacSyndicate commented May 8, 2019

Seasonley commented May 8, 2019

wangminglmm commented May 8, 2019

FounderIsShadowWalker commented May 8, 2019

xiatian commented May 8, 2019

fuqianxi commented May 8, 2019

Bottle1206 commented May 8, 2019 • edited Loading

lxinr commented May 8, 2019

weiweixuan commented May 8, 2019

kingstone3 commented May 8, 2019 • edited Loading

susiwen8 commented May 9, 2019

Gintangible commented May 9, 2019

GuoYuFu123 commented May 9, 2019

44021987 commented May 10, 2019

44021987 commented May 10, 2019

cheungkin24 commented May 10, 2019

LiuMengzhou commented May 10, 2019

LiuMengzhou commented May 10, 2019

wangminglmm commented May 10, 2019

wangminglmm commented May 10, 2019

LiuMengzhou commented May 10, 2019

pengcc commented May 10, 2019

orime commented Jan 30, 2021

3104026951 commented Mar 4, 2021

ZhengXiaowei commented Mar 15, 2021

Otresuguka commented Mar 16, 2021

MrLeihe commented Apr 26, 2021 • edited Loading

1、使用 toLowerCase 和 toUpperCase

2、使用 fromCharCode

ruanlinxin commented May 5, 2021

zhelingwang commented May 10, 2021

zhuyuzhu commented May 16, 2021

wmb0412 commented Jun 9, 2021

3fatty commented Jun 23, 2021 • edited Loading

635864859 commented Jul 14, 2021

gogopaner commented Aug 30, 2021 • edited Loading

xiangfei1 commented Oct 16, 2021

SnailOwO commented Dec 21, 2021 • edited Loading

44021987 commented Dec 21, 2021 via email

Four-Names commented Feb 24, 2022

44021987 commented Feb 24, 2022 via email

daolou commented Feb 24, 2022

Long-Xin1111 commented Mar 3, 2022

bluebrid commented May 17, 2022

leehf commented May 17, 2022 via email

44021987 commented May 17, 2022 via email

SceneryCN commented Feb 21, 2023

44021987 commented Feb 21, 2023 via email

leehf commented Feb 21, 2023 via email

benzhemin commented Feb 24, 2023

chenzhengduan commented May 30, 2024

listentolife commented May 30, 2024 via email

44021987 commented May 30, 2024 via email

leehf commented May 30, 2024 via email

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

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

zeroone001 commented May 7, 2019 •

edited

Loading

iotale commented May 8, 2019 •

edited

Loading

btea commented May 8, 2019 •

edited

Loading

Bottle1206 commented May 8, 2019 •

edited

Loading

kingstone3 commented May 8, 2019 •

edited

Loading

MrLeihe commented Apr 26, 2021 •

edited

Loading

1、使用 `toLowerCase` 和 `toUpperCase`

2、使用 `fromCharCode`

3fatty commented Jun 23, 2021 •

edited

Loading

gogopaner commented Aug 30, 2021 •

edited

Loading

SnailOwO commented Dec 21, 2021 •

edited

Loading