昨天看了一道题，惭愧，闹到一浆糊了，都没有写出来，题目内容如下：

完成一个转换函数，将数字转成对应的大写字母，满足下面的对应关系

 1 => A；   2 => B；    3 => C ... 

26 => Z； 27 => AA；28 => AB；29 => AC ...

52 => AZ; 53 => BA；54 => BB;    ...

 这个题目我想了到了进制转换。二进制转换就是一直除以2。除以转换的进制 数。但是这个算法，我都没有写出来。

今天

/**
 * 获取字符串，比较笨的写法 let arr = [A-z]
 * @param start {number} 开始字符
 * @param num {number} 获取多少个
 * @return {[]} 返回字符串数组
 */
function getLetters (start = 65, num = 26) {
  let end = start + num;
  let arr = [];
  while (start < end) {
    arr.push(String.fromCharCode(start));
    start++;
  }
  return arr;
}

/**
 * 26进制转换函数
 * @param num {number} 转换数组
 * @return {unknown[]}
 */
function convert (num) {
  if (Object.prototype.toString.call(num)!=='[object Number]'||isNaN(num)) {
    throw new Error('输入的不是数字');
  }
  let letters = getLetters();
  let m = (num).toString(26).split('');
  return m.map((num) => {
    num = parseInt(num);
    if (num === 0) {
      return 'Z';
    } else {
      return letters[num - 1];
    }
  });
}

console.log(convert(1));
console.log(convert(2));
console.log(convert(26));
console.log(convert(27));
console.log(convert(28));
console.log(convert(29));
console.log(convert(52));
console.log(convert(53));
console.log(convert(54));

再想想，可以优化下：

function decimalTo26Alphabet(num) {
    let result = '';
    
    while (num > 0) {
        let charCode = (num - 1) % 26;
        result = String.fromCharCode(65 + charCode) + result; // 65是字母A的ASCII码
        num = Math.floor((num - 1) / 26);
    }
    
    return result;
}

// 测试代码
console.log(decimalTo26Alphabet(1)); // A
console.log(decimalTo26Alphabet(26)); // Z
console.log(decimalTo26Alphabet(27)); // AA
console.log(decimalTo26Alphabet(28)); // AB
console.log(decimalTo26Alphabet(52)); // AZ
console.log(decimalTo26Alphabet(53)); // BA
console.log(decimalTo26Alphabet(54)); // BB

多简单呀。居然写了半天写不出来。有时候脑壳卡壳。就是没有思路

还有一个就晚睡。前天晚睡2点才睡。

所以还是早睡早起，如果问题卡主了。待会儿在来想。

………………………………………………………………………………………………………………………………

变量赋值

基本类型变量赋值

var a = "apple";
var b = a;
a = "banana";

此时，a 值为banana  b值为apple

引用类型变量赋值

var a = {name: "apple"};
var b = a;
a.name = "banana";
b.name//banana

此时，a.name 值为 banana;   b.name 值为banana

变量取值引用类型的值

var a = {name: "apple"};
var b = a.name;
b= "banana";
a.name//apple

这个要从ECMAScript的变量值类型说起~

类型共有两种：

• 基本类型 (primitive values) - 包括Undefined, Null, Boolean, Number和String五种基本数据类型

• 引用类型 (reference values) - 保存在内存中的对象们，不能直接操作，只能通过保存在变量中的地址引用对其进行操作

现在回来看第一个例子例1.1

"apple"是String类型，属于基本类型，这时值是这样储存的：

这时a的值被copy了一份赋给了b：

所以，从此a和b井水不犯河水，各自怎么修改都不会影响对方了~

再来看第二个例子例1.2

{name: "apple"}是一个Object，属于引用类型，赋值前后值是这样存储的：

所以当a.name = "banana";时，修改的是大家共同指向的内存中的object的属性值，所以b.name的值也就跟着变了。

例1.3中

var a = {name: "apple"};
var b = a;
a = {name: "banana"};
// {name: "banana"} 是内存中的一个新的Object了，
// a变量存储的地址也是指向这个新的Object的了，所以和b又无关了
b.name //还是"apple"

例1.4中

var a = {count: 2};
var b = a.count;
// a.count是Number类型，所以值被copy给b，
// 从此再怎么修改与b无关了
a.count = 3;
b //还是2

小总结，变量赋值时总是会copy一份的，如果是基本类型，copy的就是实际的值，如果是引用类型，copy的是指向Object的地址值，所以指向的还是同一个Object。

变量比较

对于基本类型，比较的就是实际的值，而对于引用类型（Array也是一种Object），比较的是地址值，虽然两个数组内容是一样的，但它们在内存中是两个Object，地址是不一样，所以比较的结果是false。

转载本站文章《26进制转换：转换函数将数字转成对应的大写字母——toString》,
请注明出处：https://www.zhoulujun.cn/html/webfront/ECMAScript/js/2015_1111_348.html