Anda boleh menggunakan 更新penolong kebolehubah untuk mencapai ini : p>

this.setState({
  items: update(this.state.items, {1: {name: {$set: 'updated field name'}}})
})

Sebagai alternatif, jika anda tidak peduli untuk dapat mengesan perubahan pada ini menggunakan kaedah kitar hayat === 在 shouldComponentUpdate(), anda boleh mengedit keadaan secara terus dan memaksa komponen untuk dipaparkan semula - ini sebenarnya sama dengan jawapan @limelights, kerana ia menarik objek keluar dari keadaan dan Editnya.

this.state.items[1].name = 'updated field name'
this.forceUpdate()

Suntingan kemudian ditambahkan:

Lihat pelajaran dalam Komunikasi Komponen Mudah latihan tindak balas untuk contoh cara menghantar fungsi panggil balik daripada keadaan penahanan komponen induk kepada komponen anak yang perlu mencetuskan perubahan keadaan.

Begini cara melakukannya tanpa perpustakaan pembantu:

handleChange: function (e) {
    // 1. Make a shallow copy of the items
    let items = [...this.state.items];
    // 2. Make a shallow copy of the item you want to mutate
    let item = {...items[1]};
    // 3. Replace the property you're intested in
    item.name = 'newName';
    // 4. Put it back into our array. N.B. we *are* mutating the array here, 
    //    but that's why we made a copy first
    items[1] = item;
    // 5. Set the state to our new copy
    this.setState({items});
},

Anda boleh menggabungkan langkah 2 dan 3 jika perlu:

let item = {
    ...items[1],
    name: 'newName'
}

Atau anda boleh melakukan semuanya dalam satu baris:

this.setState(({items}) => ({
    items: [
        ...items.slice(0,1),
        {
            ...items[1],
            name: 'newName',
        },
        ...items.slice(2)
    ]
}));

Nota: Saya mencipta items sebagai tatasusunan. OP menggunakan objek. Walau bagaimanapun, konsepnya adalah sama.

Anda boleh melihat apa yang berlaku di terminal/konsol:

❯ node
> items = [{name:'foo'},{name:'bar'},{name:'baz'}]
[ { name: 'foo' }, { name: 'bar' }, { name: 'baz' } ]
> clone = [...items]
[ { name: 'foo' }, { name: 'bar' }, { name: 'baz' } ]
> item1 = {...clone[1]}
{ name: 'bar' }
> item1.name = 'bacon'
'bacon'
> clone[1] = item1
{ name: 'bacon' }
> clone
[ { name: 'foo' }, { name: 'bacon' }, { name: 'baz' } ]
> items
[ { name: 'foo' }, { name: 'bar' }, { name: 'baz' } ] // good! we didn't mutate `items`
> items === clone
false // these are different objects
> items[0] === clone[0]
true // we don't need to clone items 0 and 2 because we're not mutating them (efficiency gains!)
> items[1] === clone[1]
false // this guy we copied