为什么要单独写个方法去做不同进制之间的转换呢？因为自带的方法在进行十六进制转为二进制的时候，精度在13位字符后就会出现丢失，为了让精度不丢失就自己根据16进制转换2进制的原理写了两个方法

    如果长度没有超过13位，可以用parseInt("125adf8",16).toString(2)='1001001011010110111111000',

   十六进制转换二进制  (本次转换的方法没有考虑带小数点的情况)

function hex_to_bin(str) {
            let hex_array = [{key:0,val:"0000"},{key:1,val:"0001"},{key:2,val:"0010"},{key:3,val:"0011"},{key:4,val:"0100"},{key:5,val:"0101"},{key:6,val:"0110"},{key:7,val:"0111"},
                {key:8,val:"1000"},{key:9,val:"1001"},{key:'a',val:"1010"},{key:'b',val:"1011"},{key:'c',val:"1100"},{key:'d',val:"1101"},{key:'e',val:"1110"},{key:'f',val:"1111"}]

            let value=""
            for(let i=0;i<str.length;i++){
                for(let j=0;j<hex_array.length;j++){
                    if(str.charAt(i).toLowerCase()== hex_array[j].key){
                        value = value.concat(hex_array[j].val)
                        break
                    }
                }
            }
            console.log(value)
            return value
        }

二进制转十六进制    (本次转换的方法没有考虑带小数点的情况)

function bin_to_hex(str) {
            let hex_array = [{key:0,val:"0000"},{key:1,val:"0001"},{key:2,val:"0010"},{key:3,val:"0011"},{key:4,val:"0100"},{key:5,val:"0101"},{key:6,val:"0110"},{key:7,val:"0111"},
                {key:8,val:"1000"},{key:9,val:"1001"},{key:'a',val:"1010"},{key:'b',val:"1011"},{key:'c',val:"1100"},{key:'d',val:"1101"},{key:'e',val:"1110"},{key:'f',val:"1111"}]
            let value = ''
            let list=[]
            console.log(str)
            if(str.length%4!==0){
                let a = "0000"
                let b=a.substring(0,4-str.length%4)
                str = b.concat(str)
            }
            console.log(str)
            while (str.length > 4) {
                list.push(str.substring(0, 4))
                str = str.substring(4);
            }
            list.push(str)
            console.log(list)
            for(let i=0;i<list.length;i++){
                for(let j=0;j<hex_array.length;j++){
                    if(list[i]==hex_array[j].val){
                        value = value.concat(hex_array[j].key)
                        break
                    }
                }
            }
            console.log(value)
            return value
        }

异或运算 （需要上面两个方法做基础）

function xor(a ,b){
            let A = hex_to_bin(a)
            let B = hex_to_bin(b)
            console.log(a+"   a的二进制:"+A)
            console.log(b+"   b的二进制:"+B)
            let o = "00000000000000000000000000000000000"
            if(A.toString().length > B.toString().length){
                let c = A.toString().length - B.toString().length
                B = o.substr(0,c).concat(B)
            }else if(A.toString().length < B.toString().length){
                let c = B.toString().length - A.toString().length
                A = o.substr(0,c).concat(A)
            }
            console.log('B:'+B)
            console.log('A:'+A)
            let d = ""
            for(let i=0;i<A.toString().length;i++){
                if(A.toString()[i]==B.toString()[i]){
                    let q="0"
                    d = d.concat(q)
                }else{
                    let p="1"
                    d = d.concat(p)
                }
            }
            console.log(bin_to_hex(d))
            return bin_to_hex(d)
        }

版权声明：本文为博主原创文章，未经博主允许不得转载。https://blog.csdn.net/lixiwoaini/article/details/82179094

已迁往：http://www.iteblog.com/archives/141
题目描述：
将一个长度超过100位数字的十进制非负整数转换为二进制数输出。
输入：
多组数据，每行为一个长度不超过30位的十进制非负整数。
（注意是10进制数字的个数可能有30个，而非30bits的整数）
输出：
每行输出对应的二进制数。
样例输入：
0
1
3
8
样例输出：
0
1
11
1000
分析：这个数不应该存储到一个int类型变量里面去，同样和前几篇帖子一样，也是用向量来处理，处理出的结果用binary存储，最后输出就是我们要的结果
C++代码如下：
//	w397090770
//	wyphao.2007@163.com
//	2012.07.14
#include <iostream>
#include <string>
#include <vector>

using namespace std;

//convert decimal to Binary
void dec2bin(string s){
	int sum(0);
	vector<char>v;
	int i, j;
	string binary;
	char ch; 
	
	//把每一位存到v里面去 
	for(int i(s.length() - 1); i >= 0; --i){
		v.insert(v.begin(), s[i] - '0');
	}
	
	//计算二进制 
	while(1){
		j = v.size() - 1;
	 	ch = v[j] % 2 + '0';
		binary.insert(binary.begin(), 1, ch);
		for(sum = 0, i = 0; i <= j; i++){
			if(i < j){
				//v[i + 1] += (v[i] % 2) * 10;
				v[i + 1] += (v[i] - ((v[i] >> 1) << 1)) * 10;
			}
			//v[i] /= 2;
			v[i] >>= 1;
			sum += v[i];
		}
		if(sum == 0){
			break;
		}
	}
	cout<< binary <<endl;
}

int main(){
	string dec;
	while(cin>>dec){
		dec2bin(dec);
	}
	return 0;
}
运行结果：

我在网上搜索了一下，看到有人用java写了一个版本，函数很简单：如下：
import java.math.BigInteger;
import java.util.Scanner;

public class Q1138 {
        public static void main(String[] args) {
                Scanner cin = new Scanner(System.in);
                while(cin.hasNext()){
                        System.out.println(new BigInteger(cin.next()).toString(2));
                }
        }
}
结果：
从上面看出，java语言的确很方便，很强大，但是java代码运行时间明显要比C++实现的要长。
（转载请注明：http://www.iteblog.com/archives/141，请不要用于商业目的。）

题目描述

将一个长度最多为30位数字的十进制非负整数转换为二进制数输出。

输入描述:

多组数据，每行为一个长度不超过30位的十进制非负整数。
（注意是10进制数字的个数可能有30个，而非30bits的整数）

输出描述:

每行输出对应的二进制数。

示例1

输入

0
1
3
8


输出

0
1
11
1000

注意

① 本题输入的数可能多达30多位，因此无法用整型数来保存该题输入，只能用字符串来模拟

② 对于取模运算，可以将其转换为对字符串最低数位进行取模运算

③ 对于整除运算，则需要重新写一个函数来模拟：

把字符串从高到低逐位除以除数，保留余数，余数乘以10后和低一位一起进行处理。（可能会前置多余的0，这时只需取首个非0位之后的字符串）

代码

#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
using namespace std;
string divide(string str,int x)//字符串除法
{
    int remainder = 0; //保留余数
    for(int i=0;i<str.size();i++)
    {
        int current =remainder*10+str[i]-'0';
        str[i]=current/x+'0';
        remainder=current % x;
    }
    int pos=0;
    while(str[pos]=='0')//寻找首个非0下标
        pos++;
    return str.substr(pos);//删除前置多余的0
}
int main()
{
    string str;
    while(cin>>str)
    {
        vector<int> binary;
        while(str.size()!=0)
        {
            int last=str[str.size()-1]-'0';//最低位的值
            binary.push_back(last%2);//取模运算
            str=divide(str,2);//整除运算
        }
        for(int i=binary.size()-1;i>=0;i--)
            cout<<binary[i];
        cout<<endl;
    }
    return 0;
}

 

输入1个无符号的十进制整数，将其转换成二进制，并输出。（10分）
题目内容：
从键盘输入1个小于65536的无符号的十进制整数，将其转换成16位二进制，并输出。
具体要求完成的功能如下：
1）如输入负数，则输出 “数据小于0”
2）如超过65535，则输出“超过最大数”
3）输出转换过的16位二进制数；
输入格式:
输入一个小于65536的正整数
输出格式：
二进制数每8位数字后空一格，不足16位补0，行末没有空格。
输入样例：
765

输出样例：
00000010 11111101

#include<stdio.h>
int main(){
	int a[16]={0},m,i,time;//数组会往后补0，但是不会往前 
	
	scanf("%d",&m);//输入一个整数m 
	
	if(m>=0&&m<=65535)
	{
		time=0;
		while(m!=0){
			time++;
			if(m%2==1){
				a[16-time]=1;
			}
			
			else if(m%2==0){
				a[16-time]=0;
			}
			m=m/2;//用除二法对十进制数进行转化 
		}
		for(i=0;i<=7;i++)
		{
			printf("%d",a[i]);
		}
		printf(" ");
		for(i=8;i<16;i++)
		{
			printf("%d",a[i]);
		 } 
	}
	 else if(m<0)
	 printf("数据小于0");
	 else
	 printf("超过最大数");
	 
	 return 0;
}