A practical record of the internationalized solution of a front-end Vue project

const fs = require('fs');  
const path = require('path');    
const chineseRegex = /[\u4e00-\u9fa5]+/g;  
  
function extractChineseFromFile(filePath) {  
  const content = (filePath, 'utf-8');  
  const chineseWords = (chineseRegex);  
  return chineseWords || [];  
}  
  
function processDirectory(directoryPath) {  
  const files = (directoryPath);  
  const chineseSentences = [];  
  
  ((fileName) => {  
    const filePath = (directoryPath, fileName);  
    const stats = (filePath);
  
    if (()) {  
      (...processDirectory(filePath));  
    } else if (() && ['.js', '.vue'].indexOf((filePath)) > -1) {
      const chineseWords = extractChineseFromFile(filePath);  
      (...chineseWords);  
    }  
  });  
  
  return chineseSentences;  
}  
  
function main() {  
  const srcDirectory = (__dirname, 'src');  
  const componentsDirectory = (srcDirectory, 'components');  
  const pagesDirectory = (srcDirectory, 'pages');  
  
  const componentsChineseSentences = processDirectory(componentsDirectory);  
  const pagesChineseSentences = processDirectory(pagesDirectory);  
  const allChineseSentences = [...componentsChineseSentences, ...pagesChineseSentences];  
  
  //const allChineseSentences = componentsChineseSentences;  
  
  const outputPath = (__dirname, ''); 
  // Use Set object to reload  let backString = (new Set(allChineseSentences)); 
  // Sort the array after deduplication  ();
  (outputPath, (backString, null, 2), 'utf-8');  
  
  ('The extracted Chinese word or statement has been saved to the file.  ');  
}  
  
main();

const fs = require('fs');  
const axios = require('axios');  
const appId = '123456789'; // Replace it with your Baidu Translate APP IDconst secretKey = '999999999'; // Replace it with your Baidu Translation key  

const crypto = require('crypto');  
["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8";
  
function md5Hash(input) {  
  // Create a hash object  const hash = ('md5');  
  
  // Update the content of the hash object  (input);  
  
  // Get the binary representation of the hash value  const hashBuffer = ();  
  
  // Convert binary to hexadecimal representation  const hashHex = ('hex');  
  
  // Returns lowercase hash value  return ();  
}  
  
  
// Use Baidu Translation API for translationasync function translateToEnglish(text) { 
    const params = {  
        q: text,  
        appid: appId,  
        salt: (),  
        from: 'zh',  
        to: 'en',  
        sign: ''  
    };
        
    // Calculate the signature     = md5Hash( +  +  + secretKey);
    
    // Request a translation    const url = `/api/trans/vip/translate?q=${encodeURIComponent()}&from=zh&to=en&appid=${}&salt=${}&sign=${}`;
    const response = await (url); 
    //(url);
    //()
    // Return to translation results    return .trans_result[0].dst;  
}  

function sleep(ms) {  
  return new Promise(resolve => setTimeout(resolve, ms));  
}  
  
async function mysleep() {  
  ('Rest for 1 second............');  
  await sleep(1000); // Pause for 1 second  ('Rest completed...');  
} 
  
async function process() {  
    // Read json file    const data = (('', 'utf8'));  
    
    // Objects that store translation results    let translationData = {};  
    
    let execNumber = 1;
    // traverse the Chinese string array and translate    for (let i = 0; i < ; i++) {  
        const chineseString = data[i];  
        const englishString = await translateToEnglish(chineseString);  
        // Store the original Chinese string and English string into key-value pairs into translationData object        translationData[chineseString] = englishString;
        
        if (execNumber >= 120) {   // If you don't want to execute all, how many fields will be executed?            break;
        } else if (i == execNumber*20) { // Every 20 interface calls are executed, you will have a rest of 1 second            execNumber++;
            await mysleep()
        }
    }
     
    // Write the translation result into the file    ('translated_zh_en.json', (translationData, null, 2));  
}  
  
process().catch(error => {  
    (error);  
});

const fs = require('fs');  
  
// Read the original JSON fileconst data = (('translated_zh_en.json', 'utf8'));  
  
// Chinese and English JSON filesconst chineseData = {};  
const englishData = {};  
  
let serialNumber = 00001;  
  
// Iterate through the original data and generate new key-value pairsfor (let chinese in data) {  
  const english = data[chinese];  
  
  // Generate new key-value pairs with 5 digits  const key = `N${String(serialNumber).padStart(5, '0')}`;  
    
  chineseData[key] = chinese;  
  englishData[key] = english;  
  
  serialNumber++;  
}  
  
// Write JSON data in Chinese and English to a file('', (chineseData, null, 2));  
('', (englishData, null, 2));

const fs = require('fs');
const path = require('path');

// Read the file and parse JSON datafunction loadTranslations() {
    const cnJsonPath = (__dirname, 'src', 'lang', '');
    const content = (cnJsonPath, 'utf-8');
    return (content);
}

// Determine whether the string begins with the specified prefixfunction startsWith(str, prefix) {
    return (prefix);
}

/**
  * Scene matching for each key-value pair
  * @param {String} fileContent file content
  * @param {String} key Internationalized variable name
  * @param {String} value Chinese string
  */
function replaceAllScene(fileContent, key, value) {
    
    // Scene:>Cancel<    let searchValue = `&gt;${value}&lt;`;
    let replaceValue = `&gt;{{$lang('${key}', '~${value}~')}}&lt;`;
    fileContent = (searchValue).join(replaceValue);  
    
    // Scene: title="quantity"    searchValue = `title="${value}"`;
    replaceValue = `:title="$lang('${key}', '~${value}~')"`;
    fileContent = (searchValue).join(replaceValue);
    
    // Scene: placeholder="Select date"    searchValue = `placeholder="${value}"`;
    replaceValue = `:placeholder="$lang('${key}', '~${value}~')"`;
    fileContent = (searchValue).join(replaceValue);
    
    // Scenario: message("Please check batch settings"    searchValue = `message("${value}"`;
    replaceValue = `message(this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    // Scenario: message('Please check batch settings'    searchValue = `message('${value}'`;
    replaceValue = `message(this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    
    // Scenario: confirm("Are you sure you want to set business losses?"    searchValue = `confirm("${value}"`;
    replaceValue = `confirm(this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    // Scenario: confirm('Are you sure you want to set business losses?'    searchValue = `confirm('${value}'`;
    replaceValue = `confirm(this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    
    // confirmButtonText: "OK",    searchValue = `confirmButtonText: "${value}",`;
    replaceValue = `confirmButtonText: this.$lang('${key}', '~${value}~'),`;
    fileContent = (searchValue).join(replaceValue);
    // cancelButtonText: "Cancel",    searchValue = `cancelButtonText: "${value}",`;
    replaceValue = `cancelButtonText: this.$lang('${key}', '~${value}~'),`;
    fileContent = (searchValue).join(replaceValue);
    
    // message: "Save failed"    searchValue = `message: "${value}"`;
    replaceValue = `message: this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    // message: 'Save failed''    searchValue = `message: '${value}'`;
    replaceValue = `message: this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    
    // title: "Delete error"    searchValue = `title: "${value}"`;
    replaceValue = `title: this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    // title: 'Delete error'    searchValue = `title: '${value}'`;
    replaceValue = `title: this.$lang('${key}', '~${value}~')`;
    fileContent = (searchValue).join(replaceValue);
    
    
    return fileContent;
}

// Replace the specified string in the given filefunction replaceStringsInFile(filePath, replacements) {
    const content = (filePath, 'utf-8');
    let newContent = content;

    for (const [key, value] of (replacements)) {

        // If the matching string is preceded by "message(", remove the double quotes on the left and right sides        //const searchValue = startsWith(value, 'message("') ? (8, -1) : value;

        newContent = replaceAllScene(newContent, key, value);

        //newContent = (searchValue).join("$lang('" + key + "',')" + searchValue + "'");
    }

    if (newContent !== content) {
        (filePath, newContent, 'utf-8');
        (`Replaced strings in ${filePath}`);
    }
}

// Process all files in the specified directoryfunction processDirectory(directoryPath, replacements) {
    const files = (directoryPath);

    ((fileName) =&gt; {
        const filePath = (directoryPath, fileName);
        const stats = (filePath);

        if (()) {
            processDirectory(filePath, replacements);
        } else if (()) {
            replaceStringsInFile(filePath, replacements);
        }
    });
}

function main() {
    const translations = loadTranslations();
    const componentsDirectory = (__dirname, 'src', 'components');
    const pagesDirPath = (__dirname, 'src', 'pages');
    
    processDirectory(componentsDirectory, translations);
    processDirectory(pagesDirPath, translations);
}

main();