В этой статье я покажу вам, как я создал и опубликовал пакет npm, который преобразует десятичные, двоичные и двоично-десятичные числа в десятичные и десятичные числа в двоичные с помощью javascript.

Вы можете прочитать, как выполняются преобразования здесь.

Для начала я создал пустой каталог.

mkdir Conbaseили на терминале

cd Conbaseили

Преобразование двоичного кода в десятичный conbaseor

Я создал файл b2d.js и написал conbaseor функции. б2д и д2б

function b2d(value) {
}
function d2b(value) {
}

Для функции b2d первое, что нужно сделать, это проверить, является ли полученное значение двоичным числом в виде строки. Я реализовал это как строку, потому что javascript усекает 0zeros перед целочисленными значениями.

001 === 1 //true

Затем мне пришлось сравнить каждый символ в строке, чтобы увидеть, был ли он «0» или «1». Функции возвращают true или false и сообщение об ошибке.

function isBinary(value) {
// Step 1. Verify input type is string
if (typeof value != 'string') {
binaryError();
return;
}
// Step 2. Loop through every character, and compare it with a 
binary number {0,1}
let cont = value.length-1;
let isBin = value[cont] === "1" || value[cont] === "0";
while (isBin && cont >= 0) {
isBin = value[cont] === "1" || value[cont] === "0";
cont--;
}
//Step 3. if all characters are binaries returns
if(!isBin) {
binaryError();
return false
}
return true
}

Затем мы можем использовать функцию isBinary в нашей функции b2d.

Если это не двоичное число в строке, оно вернет undefined.

Я реализовал логику преобразования десятичного числа в двоичное с помощью двух переменных, первая из которых будет содержать фактическую сумму десятичного числа, а вторая — счетчик, представляющий соответствующую степень двоичной цифры в позиции цикла.

Я начал цикл справа, чтобы счетчик совпадал с соответствующей мощностью.

Затем я добавил к текущей десятичной сумме результат умножения ее степени на значение строки, либо «0», либо «1».

function b2d(value) {
// Step 1. Verify if input is a binary number
if (!isBinary(value)) {
return
}
// Step 2. Set counters.
let decimal = 0;
let power = 0;
// Step 3. Add to the counter the result of multipling each digit
to its corresponding power, base is always 2.
for (let i = value.length; i > 0; i--) {
decimal = decimal + Math.pow(2, power)*value[i-1];
power++;
}
// Step 4. Counter to String.
decimal = decimal.toString();
return decimal;
}

Преобразование десятичного в двоичный conbaseor

Теперь пришлось идти обратным путем. Получите значение, проверьте, является ли оно десятичным значением, хранящимся в строке, и преобразуйте его в двоичное значение в строке.

function d2b(value) {
}

Как и прежде, мы сначала проверяем, является ли полученное значение десятичным числом в виде строки.

Я должен был проверить, что в нем нет десятичных знаков и он положительный.

function isDecimal(value){
// Step 1. Compare type of value with string.
if( typeof value != 'string') {
decimalError();
return
}
// Step 2. Parse value to int, verify if it is a positive Integer.
if( Number.isInteger(parseInt(value)) === false || value < 0){
decimalError();
return false
}
return true
}

Теперь мы можем использовать функцию isDecimal в нашей функции d2b.

Если это не десятичное число, оно вернет undefined.

Я реализовал десятичную двоичную логику, последовательно разделив на 2 (двоичную базу) десятичную переменную, которая изначально содержала переданное значение . Затем я проверил, был ли остаток целым числом или нет. И добавление соответствующего «0», если остатка не было, или «1», если он был, к полученному двоичному числу в виде строки. Затем я добавил к строке соответствующий десятичный остаток и перевернул его, поскольку двоичные числа — это обратные действия по сравнению с конкатенацией остатков.

function d2b(value) {
// Step 1. Verify if value is a
if (!isDecimal(value)) {
return
}
// Step 2. Initialize counters.
let binary = '';
let decimal = value;
//Step 3. Succesively divide de decimal number by 2. Add reminder to 
he counter
while (decimal > 1){
decimal = decimal / 2;
if (Number.isInteger(decimal) ) {
binary = binary + '0';
} else {
binary = binary + '1';
decimal = Math.floor(decimal);
}
}
//Step 4. Add the final decimal to the string.
binary = binary + decimal;
//Step 5. Reverse binary according to the way decimals are conbased 
to binary.
binary = reverseString(binary);
return binary;
}

Обратная строка создается с использованием массивов и строк. Его пришлось использовать, потому что двоичный файл — это перевернутые результаты последовательных делений.

function reverseString(str) {
// Step 1. Use the split() method to return a new array
var splitString = str.split("");
// Step 2. Use the reverse() method to reverse the new created array
var reverseArray = splitString.reverse();
// Step 3. Use the join() method to join all elements of the array into a string
var joinArray = reverseArray.join("");
//Step 4. Return the reversed string
return joinArray;
}

Наконец, мы экспортируем конбасоры как модуль. Следующее

let bcd = require('./bcd');
let binary2decimal = require('./b2d')
//Exports conbaseors
module.exports = {b2d: binary2decimal.b2d,
d2b: binary2decimal.d2b,
d2bcd: bcd.d2bcd,
bcd2d: bcd.bcd2d
}

Реализация bcd conbaseor

Создайте файл и назовите его bcd.js.

Во-первых, я реализовал Hastable, который получает десятичное или двоично-десятичное число и возвращает соответствующее число в двоично-десятичном формате и десятичное число.

function bcd2dHash(value) {
//Step 1. Create the array of equivalences.
const d2bcd = [
{
bcd: '0000',
decimal: '0',
},
{
bcd: '0001',
decimal: '1',
},
{
bcd: '0010',
decimal: '2',
},
{
bcd: '0011',
decimal: '3',
},
{
bcd: '0100',
decimal: '4',
},
{
bcd: '0101',
decimal: '5',
},
{
bcd: '0110',
decimal: '6',
},
{
bcd: '0111',
decimal: '7',
},
{
bcd: '1000',
decimal: '8',
},
{
bcd: '1001',
decimal: '9',
}
]
//Step 2. Get the corresponding decimal and bcd values.
let decimal = d2bcd.filter( e => e.decimal === value);
let bcd = d2bcd.filter( e => e.bcd === value)
//Step 3. Return any value obtained.
if(bcd.length != 0) {
return bcd[0]
} else if (decimal.length != 0) {
return decimal[0]
} else
return
}

Реализация bcd в десятичный conbaseor

Я реализовал функцию, которая получает количество двоично-десятичных чисел в виде строки и возвращает массив объектов:

[{bcd: ‘####’, десятичное: ‘#’}, {bcd: ‘####’, десятичное: ‘#’}]

function bcd2d(value) {
//Step 1. Splits value into an array. Each position will have 4 
igits
let len = value.length;
let arr = value.match(/.{1,4}/g);
//Step2. verify that bcd number is multiple of 4
if(!(len%4 === 0) || (value == "")) {
bcdError();
return
}
//Step 3. Match each string in the array with it's corresponding 
value in the Hashtable. Incorrect bcd numbers will be returned as 
undefined
let bcdArray = arr.map( (e, index) => {
return bcd2dHash(e);
})
return bcdArray;
}

Внедрение десятичного числа в bcd conbaseor

Я реализовал функцию, которая принимает десятичное число в виде строки и возвращает массив объектов:

[{bcd: ‘####’, десятичное: ‘#’}, {bcd: ‘####’, десятичное: ‘#’}]

function d2bcd(value) {
//Step 1. Verify if input is a string;
if(typeof value != 'string'){
decimalError();
return
}
//Step 2. Arrayifies the string value.
let decimal = value.split('');
//Step 3. Verifies if array for integers
if(!decimal.every( (e, index) => {
// true if each character in the string is a number
return Number.isInteger(parseInt(decimal[index]))
})) {
decimalError();
return;
}
//Step 4. Looks for the number in the hastable, stores in the 
eturned array.
let bcd = decimal.map( e => {
return bcd2dHash(e);
});
return bcd
}

Наконец, мы экспортируем обе функции.

//Exports conbaseors
module.exports = {
bcd2d: bcd2d,
d2bcd: d2bcd
}

Реализация модуля экспорта

Создайте файл и назовите его index.js.

Это файл, который мы будем экспортировать, в него мы включим конбасоры между разными числами.

let bcd = require('./bcd');
let binary2decimal = require('./b2d')
//Export module containing conbaseors
module.exports = {
b2d: binary2decimal.b2d,
d2b: binary2decimal.d2b,
d2bcd: bcd.d2bcd,
bcd2d: bcd.bcd2d
}

Опубликовать пакет NPM

Сначала мы инициализируем наш package.json, который будет экспортирован.

npm init

После заполнения формы у нас должен получиться файл package.json, похожий на этот.

{
"name": "conbasor",
"version": "1.0.0",
"description": "Converts between bases decimal, binary, bcd",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}

Затем мы публикуем его с. Вы должны войти в npm

npm publish

И это все. Чтобы использовать его в файле app.js, выполните

npm install conbaseor

а затем добавьте его в файл с помощью

let conbaseor= require('conbaseor');

Запуск тестов

В нашем файле app.js

let conbasor = require('conbasor');
// conbaseor = {
//    b2d: [Function: b2d],
//    d2b: [Function: d2b],
//    d2bcd: [Function: d2bcd],
//    bcd2d: [Function: bcd2d]
// }
let d2b = conbaseor.d2b('13');
// '1101'
let b2d = conbaseor.b2d('1101');
// '13'
let d2bcd = conbaseor.d2bcd('0001')
// [ { bcd: '0000', decimal: '0' },
// { bcd: '0000', decimal: '0' },
// { bcd: '0000', decimal: '0' },
// { bcd: '0001', decimal: '1' } ]
let bcd2d = conbaseor.bcd2d('0001')
// [ { bcd: '0001', decimal: '1' } ]

Затем мы можем запустить приложение узла.

И это все.

Спасибо за чтение,

Надеюсь, вам понравилось и вы чему-то научились. Для меня это был отличный опыт, так как я смог применить на практике свои знания в node.js. Сейчас я сделаю руководство о том, как выполняются преобразования, а затем продолжу работу с другими основаниями, такими как шестнадцатеричная и восьмеричная.

Вот репозиторий проекта — https://github.com/florovarelaa/conbaseor