Question

使用键将值添加到对象（输入的值，只有id的键是js.file中定义的变量。

在将id的初始值设置为0（id = 0）时，现在我需要找到一种方法，以在不将其id重置为给定值0的情况下增加id。

因此，我确定在增量时，将新值（id）压入对象，然后将该对象压入数组（具有所有输入值和id值，然后压入主localStorage）和新值（增量id ），然后保存到localStorage（仅用于id中）。

现在的问题是，每次新点击都要求我访问id的localStorage并用它来存放语句，以便从中获取值（每次我创建新的id时，它都会增加数组的长度，因此在点击时我被卡住了在无限循环中。

我需要一种将增量ID推入主数组（所有值）的方法，但同时要对增量ID的最后一个值具有访问权限，以便可以再次对其进行增量。

对不起我的英语不好和解释不好

let testObjectOne = {

        //'title' is key and $title.val() is value of that key

        'title': $title.val(), 

        'typ': $typ.val(),

        'assign': $assign.val(),

        'files': $file.val().match(/[\/\\]([\w\d\s\.\-\(\)]+)$/)[0],

        'priority': $priority.val(),

        'category': $category.val(),

        'textField': $textField.val(),

        'end_date': $date.val(),

        'id':id,

    };

let id = 0;

    let array_id = [];

    array_id.push(id);

    let string_array_id = JSON.stringify(array_id);

    localStorage.setItem('id' , string_array_id);



let savedId = localStorage.getItem('id'),

            array_savedId = JSON.parse(savedId);  


        console.log(savedId);

        console.log(array_savedId);

//looping id array 

        for (let k = 0; k < array_savedId.length; k++){

            console.log(array_savedId[k]);


//increments 0 to 1 , later on increments 0 to 1 and 1 to 2 and so on


            let newValue = array_savedId[k] + 1;

//checks if new value is not matching to values in array 

            if (newValue !== array_savedId[k]){

//then pushes new value into array creating new index

                array_savedId.push(newValue);

//id inside testObjectOne is set to new value

                testObjectOne['id'] = newValue;

//pushing testObjectOne into main array 

                let save_newValue_withID = localStorage.getItem('key'),

                    array_s_nV_wID = JSON.parse(save_newValue_withID);

                array_s_nV_wID.push(testObjectOne);

              let string_newValue_withID =JSON.stringify(array_s_nV_wID);

                localStorage.setItem('key' , string_newValue_withID);

            }

        }

let test = localStorage.getItem('key'), 

array_test = JSON.parse(test);

array_test.push(testObjectOne);

        let back_to_string = JSON.stringify(array_test);   

        localStorage.setItem('key', back_to_string);

Answer 1

根据您的情况，看来您必须保留2个数组。

存储对象的主数组
支持数组仅存储对象的ID。

从循环的结构方式，循环array_savedId的位置以及在循环期间向其中添加新项的过程，您将陷入无限循环。

//looping id array 
for (let k = 0; k < array_savedId.length; k++){
   // somewhere in the loop, you are adding item into the array,
   // this is the recipe for infinite loop
   array_savedId.push(newValue);
}

如果只需要对象的唯一ID，则可以获取最后一个对象并增加ID。完全不需要循环数组。

// Load the object array
let save_newValue_withID = localStorage.getItem('key')
let array_s_nV_wID = JSON.parse(save_newValue_withID);

if (array_s_nV_wID.length == 0) {
  // Empty array, so we are adding first item
  testObjectOne['id'] = 1;
}
else {
  // Find the last object, increment the id
  let lastItem = array_s_nV_wID[array_s_nV_wID.length - 1]
  testObjectOne['id'] = lastItem['id'] + 1
}

// Save to storage
array_s_nV_wID.push(testObject) // <-- We will need this again later
let string_newValue_withID = JSON.stringify(array_s_nV_wID);
localStorage.setItem('key' , string_newValue_withID);

现在，我们完成了主数组，让我们处理id数组。为了避免2阵列由于诸如我们忘记更新之类的原因而不同步我们添加/删除/编辑主数组时使用ids数组，并且继续进行不同步的数组，我们将根据主数组的最新值重建ids数组

const newIdsArray = array_s_nV_wID.map(a => a.id)
localStorage.setItem('id' , newIdsArray);

递增id ++并保存新的递增值，以便可以再次调用它并对其进行递增

2 个答案: