diff --git a/convertxml/js_convertxml.cpp b/convertxml/js_convertxml.cpp
index 727565fbfb941d4e75a6feea024641ce787c9ef3..7d435782b826942823053a87331d86e285974242 100755
--- a/convertxml/js_convertxml.cpp
+++ b/convertxml/js_convertxml.cpp
@@ -86,7 +86,7 @@ std::string ConvertXml::Trim(std::string strXmltrim)
     }
     size_t i = 0;
     size_t strlen = strXmltrim.size();
-    for (; i < strlen;) {
+    for (; i < strlen; ) {
         if (strXmltrim[i] == ' ') {
             i++;
         } else {
@@ -114,12 +114,16 @@ void ConvertXml::GetPrevNodeList(xmlNodePtr curNode)
         if (curNode->type == xmlElementType::XML_PI_NODE && !m_Options.ignoreInstruction) {
             SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
             SetKeyValue(elementsObject, m_Options.name, (char*)curNode->name);
-            SetKeyValue(elementsObject, m_Options.instruction, (const char*)xmlNodeGetContent(curNode));
+            if (xmlNodeGetContent(curNode) != nullptr) {
+                SetKeyValue(elementsObject, m_Options.instruction, (const char*)xmlNodeGetContent(curNode));
+            }
             m_prevObj.push_back(elementsObject);
         }
         if (curNode->type == xmlElementType::XML_COMMENT_NODE && !m_Options.ignoreComment) {
             SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
-            SetKeyValue(elementsObject, m_Options.comment, (const char*)xmlNodeGetContent(curNode));
+            if (xmlNodeGetContent(curNode) != nullptr) {
+                SetKeyValue(elementsObject, m_Options.comment, (const char*)xmlNodeGetContent(curNode));
+            }
             m_prevObj.push_back(elementsObject);
         }
         if (curNode->type == xmlElementType::XML_DTD_NODE && !m_Options.ignoreDoctype) {
@@ -147,34 +151,44 @@ void ConvertXml::SetAttributes(xmlNodePtr curNode, napi_value &elementsObject)
 void ConvertXml::SetXmlElementType(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag)
 {
     if (curNode->type == xmlElementType::XML_PI_NODE && !m_Options.ignoreInstruction) {
-        SetKeyValue(elementsObject, m_Options.instruction.c_str(), (const char*)xmlNodeGetContent(curNode));
-        bFlag = true;
+        if (xmlNodeGetContent(curNode) != nullptr) {
+            SetKeyValue(elementsObject, m_Options.instruction.c_str(), (const char*)xmlNodeGetContent(curNode));
+            bFlag = true;
+        }
     } else if (curNode->type == xmlElementType::XML_COMMENT_NODE && !m_Options.ignoreComment) {
-        SetKeyValue(elementsObject, m_Options.comment.c_str(), (const char*)xmlNodeGetContent(curNode));
-        bFlag = true;
+        if (xmlNodeGetContent(curNode) != nullptr) {
+            SetKeyValue(elementsObject, m_Options.comment.c_str(), (const char*)xmlNodeGetContent(curNode));
+            bFlag = true;
+        }
     } else if (curNode->type == xmlElementType::XML_CDATA_SECTION_NODE && !m_Options.ignoreCdata) {
-        SetKeyValue(elementsObject, m_Options.cdata, (const char*)xmlNodeGetContent(curNode));
-        bFlag = true;
+        if (xmlNodeGetContent(curNode) != nullptr) {
+            SetKeyValue(elementsObject, m_Options.cdata, (const char*)xmlNodeGetContent(curNode));
+            bFlag = true;
+        }
     }
 }
 void ConvertXml::SetNodeInfo(xmlNodePtr curNode, napi_value &elementsObject)
 {
-    if (curNode->type == xmlElementType::XML_PI_NODE) {
-        if (!m_Options.ignoreInstruction) {
-            SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
-        }
+    if (curNode->type == xmlElementType::XML_TEXT_NODE) {
+        return;
     } else {
-        SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
-    }
-    if ((curNode->type != xmlElementType::XML_COMMENT_NODE) &&
-        (curNode->type != xmlElementType::XML_CDATA_SECTION_NODE)) {
-        if (!(curNode->type == xmlElementType::XML_PI_NODE && m_Options.ignoreInstruction)) {
-            SetKeyValue(elementsObject, m_Options.name, (char*)curNode->name);
+        if (curNode->type == xmlElementType::XML_PI_NODE) {
+            if (!m_Options.ignoreInstruction) {
+                SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
+            }
+        } else {
+                SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
+        }
+        if ((curNode->type != xmlElementType::XML_COMMENT_NODE) &&
+            (curNode->type != xmlElementType::XML_CDATA_SECTION_NODE)) {
+            if (!(curNode->type == xmlElementType::XML_PI_NODE && m_Options.ignoreInstruction)) {
+                SetKeyValue(elementsObject, m_Options.name, (char*)curNode->name);
+            }
         }
     }
 }
 
-void ConvertXml::SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag, bool &bText, int32_t index)
+void ConvertXml::SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag)
 {
     SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type));
     if (curNode->type == xmlElementType::XML_ELEMENT_NODE) {
@@ -182,16 +196,17 @@ void ConvertXml::SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool
         bFlag = true;
     } else if (curNode->type == xmlElementType::XML_TEXT_NODE) {
         if (m_Options.trim) {
-            SetKeyValue(elementsObject, m_Options.text, Trim((const char*)xmlNodeGetContent(curNode)));
+            if (xmlNodeGetContent(curNode) != nullptr) {
+                SetKeyValue(elementsObject, m_Options.text, Trim((const char*)xmlNodeGetContent(curNode)));
+            }
         } else {
-            SetKeyValue(elementsObject, m_Options.text, (const char*)xmlNodeGetContent(curNode));
+            if (xmlNodeGetContent(curNode) != nullptr) {
+                SetKeyValue(elementsObject, m_Options.text, (const char*)xmlNodeGetContent(curNode));
+            }
         }
         if (!m_Options.ignoreText) {
             bFlag = true;
         }
-        if (index != 0) {
-            bText = false;
-        }
     }
 }
 
@@ -208,21 +223,17 @@ void ConvertXml::GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag)
 {
     napi_value elements = nullptr;
     napi_create_array(env_, &elements);
-    napi_value recvElement;
+    napi_value recvElement = nullptr;
     napi_create_array(env_, &recvElement);
     xmlNodePtr pNode = curNode;
     int32_t index = 0;
     int32_t index1 = 0;
     bool bFlag = false;
-    bool bText = true;
     while (pNode != nullptr) {
         bFlag = false;
-        bText = true;
         napi_value elementsObject = nullptr;
         napi_create_object(env_, &elementsObject);
-        if (flag == 0 || (index % 2 != 0)) { // 2:pNode
-            SetNodeInfo(pNode, elementsObject);
-        }
+        SetNodeInfo(pNode, elementsObject);
         SetAttributes(pNode, elementsObject);
         napi_value tempElement = nullptr;
         napi_create_array(env_, &tempElement);
@@ -233,16 +244,15 @@ void ConvertXml::GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag)
                 curNode = pNode->children;
                 GetXMLInfo(curNode, elementsObject, 1);
                 bFlag = true;
-            } else if (index % 2 != 0) { // 2:pNode
+            } else {
                 SetXmlElementType(pNode, elementsObject, bFlag);
-            } else if (pNode->next == nullptr) {
-                SetEndInfo(pNode, elementsObject, bFlag, bText, index);
+                SetEndInfo(pNode, elementsObject, bFlag);
             }
         }
         SetPrevInfo(recvElement, flag, index1);
-        if (elementsObject != nullptr && bFlag && bText) {
-                napi_set_element(env_, recvElement, index1++, elementsObject);
-                elementsObject = nullptr;
+        if (elementsObject != nullptr && bFlag) {
+            napi_set_element(env_, recvElement, index1++, elementsObject);
+            elementsObject = nullptr;
         }
         index++;
         pNode = pNode->next;
@@ -252,52 +262,60 @@ void ConvertXml::GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag)
     }
 }
 
+void ConvertXml::SetSpacesInfo(napi_value &object)
+{
+    napi_value iTemp = nullptr;
+    switch (m_SpaceType) {
+    case (SpaceType::T_INT32):
+        napi_create_int32(env_, m_iSpace, &iTemp);
+        napi_set_named_property(env_, object, "spaces", iTemp);
+        break;
+    case (SpaceType::T_STRING):
+        SetKeyValue(object, "spaces", m_strSpace);
+        break;
+    case (SpaceType::T_INIT):
+        SetKeyValue(object, "spaces", m_strSpace);
+        break;
+    default:
+        break;
+    }
+}
+
 napi_value ConvertXml::convert(std::string strXml)
 {
     xmlDocPtr doc = NULL;
     xmlNodePtr curNode = NULL;
     napi_status status = napi_ok;
-    size_t len = strXml.size();
-    doc = xmlParseMemory(strXml.c_str(), len);
-    if (!doc) {
-        xmlFreeDoc(doc);
-    }
     napi_value object = nullptr;
     status = napi_create_object(env_, &object);
     if (status != napi_ok) {
         return NULL;
     }
+    size_t len = strXml.size();
+    doc = xmlParseMemory(strXml.c_str(), len);
+    if (!doc) {
+        xmlFreeDoc(doc);
+        return object;
+    }
     napi_value subObject = nullptr;
     napi_value subSubObject = nullptr;
-    napi_value napiKey = nullptr;
     napi_create_object(env_, &subSubObject);
     napi_create_object(env_, &subObject);
-    napi_create_string_utf8(env_, (const char*)doc->version, NAPI_AUTO_LENGTH, &napiKey);
-    napi_set_named_property(env_, subSubObject, "version", napiKey);
-    napi_create_string_utf8(env_, (const char*)doc->encoding, NAPI_AUTO_LENGTH, &napiKey);
-    napi_set_named_property(env_, subSubObject, "encoding", napiKey);
-    if (!m_Options.ignoreDeclaration) {
+    if (doc->version != nullptr) {
+        SetKeyValue(subSubObject, "version", (const char*)doc->version);
+    }
+    if (doc->encoding != nullptr) {
+        SetKeyValue(subSubObject, "encoding", (const char*)doc->encoding);
+    }
+    
+    if (!m_Options.ignoreDeclaration && strXml.find("xml")!=std::string::npos ) {
         napi_set_named_property(env_, subObject, m_Options.attributes.c_str(), subSubObject);
         napi_set_named_property(env_, object, m_Options.declaration.c_str(), subObject);
     }
     curNode = xmlDocGetRootElement(doc);
     GetPrevNodeList(curNode);
     GetXMLInfo(curNode, object, 0);
-    napi_value iTemp = nullptr;
-    switch (m_SpaceType) {
-        case (SpaceType::T_INT32):
-            napi_create_int32(env_, m_iSpace, &iTemp);
-            napi_set_named_property(env_, object, "spaces", iTemp);
-            break;
-        case (SpaceType::T_STRING):
-            SetKeyValue(object, "spaces", m_strSpace);
-            break;
-        case (SpaceType::T_INIT):
-            SetKeyValue(object, "spaces", m_strSpace);
-            break;
-        default:
-            break;
-    }
+    SetSpacesInfo(object);
     return object;
 }
 
@@ -310,9 +328,10 @@ napi_status ConvertXml::DealNapiStrValue(napi_value napi_StrValue, std::string &
     if (status != napi_ok) {
         return status;
     }
-    buffer = new char[bufferSize + 1];
-    napi_get_value_string_utf8(env_, napi_StrValue, buffer, bufferSize + 1, &bufferSize);
-
+    if (bufferSize > 0) {
+        buffer = new char[bufferSize + 1];
+        napi_get_value_string_utf8(env_, napi_StrValue, buffer, bufferSize + 1, &bufferSize);
+    }
     if (buffer != nullptr) {
         result = buffer;
         delete []buffer;
@@ -341,8 +360,9 @@ void ConvertXml::DealSpaces(napi_value napi_obj)
 
 void ConvertXml::DealIgnore(napi_value napi_obj)
 {
-    std::vector<std::string>vctIgnore = { "compact", "trim", "ignoreDeclaration", "ignoreInstruction",
-        "ignoreAttributes", "ignoreComment", "ignoreCdata", "ignoreDoctype", "ignoreText" };
+    std::vector<std::string> vctIgnore = {"compact", "trim", "ignoreDeclaration", "ignoreInstruction",
+                                          "ignoreAttributes", "ignoreComment", "ignoreCdata",
+                                          "ignoreDoctype", "ignoreText"};
     for (size_t i = 0; i < vctIgnore.size(); ++i) {
         napi_value recvTemp = nullptr;
         bool bRecv = false;
@@ -426,8 +446,9 @@ void ConvertXml::SetDefaultKey(size_t i, std::string strRecv)
 
 void ConvertXml::DealOptions(napi_value napi_obj)
 {
-    std::vector<std::string>vctOptions = { "declarationKey", "instructionKey", "attributesKey", "textKey",
-    "cdataKey", "doctypeKey", "commentKey", "parentKey", "typeKey", "nameKey", "elementsKey" };
+    std::vector<std::string> vctOptions = {"declarationKey", "instructionKey", "attributesKey", "textKey",
+                                           "cdataKey", "doctypeKey", "commentKey", "parentKey", "typeKey",
+                                           "nameKey", "elementsKey"};
     for (size_t i = 0; i < vctOptions.size(); ++i) {
         napi_value recvTemp = nullptr;
         std::string strRecv = "";
@@ -438,4 +459,4 @@ void ConvertXml::DealOptions(napi_value napi_obj)
     }
     DealIgnore(napi_obj);
     DealSpaces(napi_obj);
-}
+}
\ No newline at end of file
diff --git a/convertxml/js_convertxml.h b/convertxml/js_convertxml.h
index bbe2381f45ee7f6bed5299e47fec8a62e98ed162..a44b731cc204c65927553544b2bcb8ceeb5c59e7 100755
--- a/convertxml/js_convertxml.h
+++ b/convertxml/js_convertxml.h
@@ -66,7 +66,7 @@ public:
         void SetAttributes(xmlNodePtr curNode, napi_value &elementsObject);
         void SetXmlElementType(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag);
         void SetNodeInfo(xmlNodePtr curNode, napi_value &elementsObject);
-        void SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag, bool &bText, int32_t index);
+        void SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag);
         void GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag = 0);
         napi_value convert(std::string strXml);
         std::string GetNodeType(xmlElementType enumType);
@@ -79,6 +79,7 @@ public:
         void DealIgnore(napi_value napi_obj);
         void SetPrevInfo(napi_value &recvElement, int flag, int32_t &index1);
         void SetDefaultKey(size_t i, std::string strRecv);
+        void SetSpacesInfo(napi_value &object);
 private:
         napi_env env_;
         SpaceType m_SpaceType;
diff --git a/convertxml/js_convertxml.js b/convertxml/js_convertxml.js
index a0305b036471c70e26b7e2e989878f63a6464e36..3b6b5ba221d3c3aecea7eaa9182d0d81cc6bc465 100755
--- a/convertxml/js_convertxml.js
+++ b/convertxml/js_convertxml.js
@@ -21,6 +21,7 @@ class ConvertXml {
         this.convertxmlclass = new convertXml.ConvertXml();
     }
     convert(strXml, options) {
+        strXml = DealXml(strXml);
         let converted = this.convertxmlclass.convert(strXml, options);
         let space = 0;
         if (converted.hasOwnProperty("spaces")) {
@@ -31,6 +32,58 @@ class ConvertXml {
     }
 }
 
+function DealXml(strXml)
+{
+    var idx = -1;
+    var idxSec = 0;
+    var idxThir = 0;
+    var idxCData = 0;
+    var idxCDataSec = 0;
+    while ((idx = strXml.indexOf('>', idxSec)) != -1) {
+        idxThir = strXml.indexOf('<', idx);
+        var i = idx + 1;
+        for (; i < idxThir ; i++) {
+            var cXml = strXml.charAt(i);
+            if (cXml != '\n' && cXml != '\v' && cXml != '\t' && cXml != ' ')
+            {
+                break;
+            }
+        }
+        var j = idx + 1;
+        for (; j < strXml.indexOf('<', idx) ; j++) {
+            var cXml = strXml.charAt(j);
+            if (i != idxThir) {
+                switch (cXml) {
+                case '\n':
+                    strXml = strXml.substring(0, j) + '\\n' + strXml.substring(j + 1);
+                    break;
+                case '\v':
+                    strXml = strXml.substring(0, j) + '\\v' + strXml.substring(j + 1);
+                    break;
+                case '\t':
+                    strXml = strXml.substring(0, j) + '\\t' + strXml.substring(j + 1);
+                    break;
+                }
+            } else {
+                strXml = strXml.substring(0, j) + strXml.substring(j + 1);
+                --j;
+            }
+        }
+        if (strXml.indexOf('<', idx) != -1) {
+            idxCData = strXml.indexOf('<![CDATA', idxCDataSec);
+            idxSec = strXml.indexOf('<', idx);
+            if (idxSec == idxCData) {
+                idxSec = strXml.indexOf(']]', idxCData);
+                idxCDataSec = idxSec;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return strXml;
+}
+
 export default {
     ConvertXml : ConvertXml
 }
diff --git a/convertxml/native_module_convertxml.cpp b/convertxml/native_module_convertxml.cpp
index 25223d8adad4cf2b0b437238bfab6b4d63aaa71f..cfca087e5b7449af1fed82288be92e85b525d6a5 100755
--- a/convertxml/native_module_convertxml.cpp
+++ b/convertxml/native_module_convertxml.cpp
@@ -106,7 +106,8 @@ static napi_module ConvertXmlModule = {
     .reserved = { 0 },
 };
 
-extern "C" __attribute__ ((constructor)) void RegisterModule() {
+extern "C" __attribute__ ((constructor)) void RegisterModule()
+{
     napi_module_register(&ConvertXmlModule);
 }
 
diff --git a/uri/js_uri.cpp b/uri/js_uri.cpp
index 3af8ab0c9e651343528f5e1b2bca77c21d5525ec..34452121891811f25686dfb49a533cf1a2d2b1fe 100755
--- a/uri/js_uri.cpp
+++ b/uri/js_uri.cpp
@@ -15,14 +15,14 @@
 #include "js_uri.h"
 #include "utils/log.h"
 namespace OHOS::Uri {
-    std::bitset <MAX_BIT_SIZE> g_ruleAlpha;
-    std::bitset <MAX_BIT_SIZE> g_ruleScheme;
-    std::bitset <MAX_BIT_SIZE> g_ruleUrlc;
-    std::bitset <MAX_BIT_SIZE> g_rulePath;
-    std::bitset <MAX_BIT_SIZE> g_ruleUserInfo;
-    std::bitset <MAX_BIT_SIZE> g_ruleScope;
-    std::bitset <MAX_BIT_SIZE> g_ruleDigit;
-    std::bitset <MAX_BIT_SIZE> g_rulePort;
+    std::bitset<MAX_BIT_SIZE> g_ruleAlpha;
+    std::bitset<MAX_BIT_SIZE> g_ruleScheme;
+    std::bitset<MAX_BIT_SIZE> g_ruleUrlc;
+    std::bitset<MAX_BIT_SIZE> g_rulePath;
+    std::bitset<MAX_BIT_SIZE> g_ruleUserInfo;
+    std::bitset<MAX_BIT_SIZE> g_ruleScope;
+    std::bitset<MAX_BIT_SIZE> g_ruleDigit;
+    std::bitset<MAX_BIT_SIZE> g_rulePort;
     void Uri::PreliminaryWork() const
     {
         std::string digitAggregate = "0123456789";
diff --git a/uri/native_module_uri.cpp b/uri/native_module_uri.cpp
index cb013be86fad1ddea9a9f16941cf4596062376e5..98d9c005d72f92406329d73b6bba5163813c0f4e 100755
--- a/uri/native_module_uri.cpp
+++ b/uri/native_module_uri.cpp
@@ -264,7 +264,7 @@ namespace OHOS::Uri {
             DECLARE_NAPI_GETTER("isFailed", IsFailed),
         };
         NAPI_CALL(env, napi_define_class(env, uriClassName, strlen(uriClassName), UriConstructor,
-        nullptr, sizeof(uriDesc) / sizeof(uriDesc[0]), uriDesc, &uriClass));
+                  nullptr, sizeof(uriDesc) / sizeof(uriDesc[0]), uriDesc, &uriClass));
         static napi_property_descriptor desc[] = {
             DECLARE_NAPI_PROPERTY("Uri", uriClass)
         };
diff --git a/url/js_url.cpp b/url/js_url.cpp
index ba9f1b93303998245c5fce2510b399e6e78a845f..e564486719c6b82c999e56a6868a63bb3b1fcd06 100755
--- a/url/js_url.cpp
+++ b/url/js_url.cpp
@@ -113,7 +113,7 @@ namespace OHOS::Url {
         }
         size_t i = 0;
         size_t strlen = str.size();
-        for (; i < strlen;) {
+        for (; i < strlen; ) {
             if (str[i] >= '\0' && str[i] <= ' ') {
                 i++;
             } else {
@@ -133,7 +133,7 @@ namespace OHOS::Url {
 
     static void DeleteTabOrNewline(std::string& str1)
     {
-        for (auto item = str1.begin(); item != str1.end();) {
+        for (auto item = str1.begin(); item != str1.end(); ) {
             if (IsASCIITabOrNewline(*item)) {
                 item = str1.erase(item);
             } else {
@@ -364,7 +364,7 @@ namespace OHOS::Url {
         int count = 0;
         size_t maxZeroIndex = 0;
         size_t strlen = tempIPV6.size();
-        for (size_t i = 0; i < strlen;) {
+        for (size_t i = 0; i < strlen; ) {
             if (tempIPV6[i] == "0" && (i + 1 < strlen && tempIPV6[i + 1] == "0")) {
                 int index = i;
                 while (i < strlen && tempIPV6[i] == "0") {
@@ -929,7 +929,7 @@ namespace OHOS::Url {
             size_t pos = 0;
             bool special = true;
             size_t inputLen = input.size();
-            for (; pos < inputLen;) {
+            for (; pos < inputLen; ) {
                 if (input[pos] == '/' || input[pos] == '\\') {
                     pos++;
                 } else {
@@ -1705,7 +1705,7 @@ namespace OHOS::Url {
                     (charaEncode & 0x0000003F)]; // Acquisition method of the second byte
                 output += output1 + output2;
             } else if ((charaEncode >= 0x0000E000) ||
-                        (charaEncode <= 0x0000D7FF)) { // Convert the Unicode code into three bytes
+                       (charaEncode <= 0x0000D7FF)) { // Convert the Unicode code into three bytes
                 std::string output1 = reviseChar[0x000000E0 |
                     (charaEncode / 4096)]; // 4096:Acquisition method of the first byte
                 std::string output2 = reviseChar[numOfAscii |
@@ -1935,7 +1935,7 @@ namespace OHOS::Url {
             sname = ToUSVString(name);
         }
         delete[] name;
-        for (std::vector<std::string>::iterator iter = searchParams.begin(); iter != searchParams.end();) {
+        for (std::vector<std::string>::iterator iter = searchParams.begin(); iter != searchParams.end(); ) {
             if (*iter == sname) {
                 iter = searchParams.erase(iter, iter + 2); // 2:Searching for the number and number of keys and values
             } else {
@@ -2032,7 +2032,7 @@ namespace OHOS::Url {
             delete[] buffer1;
         }
         bool flag = false;
-        for (std::vector<std::string>::iterator it = searchParams.begin(); it < searchParams.end() - 1;) {
+        for (std::vector<std::string>::iterator it = searchParams.begin(); it < searchParams.end() - 1; ) {
             if (*it == cppName) {
                 if (!flag) {
                     *(it + 1) = cppValue;
diff --git a/url/native_module_url.cpp b/url/native_module_url.cpp
index 279f4316738e6d8449c3ebcb9578845a00c8589c..8dcd481cef478b05c71fdcaa4f995186ba55f8e6 100755
--- a/url/native_module_url.cpp
+++ b/url/native_module_url.cpp
@@ -884,7 +884,7 @@ namespace OHOS::Url {
             DECLARE_NAPI_GETTER("GetIsIpv6", GetIsIpv6),
         };
         NAPI_CALL(env, napi_define_class(env, urlClassName, strlen(urlClassName), UrlConstructor,
-        nullptr, sizeof(UrlDesc) / sizeof(UrlDesc[0]), UrlDesc, &urlClass));
+                  nullptr, sizeof(UrlDesc) / sizeof(UrlDesc[0]), UrlDesc, &urlClass));
         static napi_property_descriptor desc[] = {
             DECLARE_NAPI_PROPERTY("Url", urlClass)
         };