Konvertieren Sie bytes32 in geordnete bytes2, bytes4 usw

Zum Beispiel muss ich meine bytes32-Variable in Stücke schneiden und das Ergebnis in 5 Variablen einfügen, die Reihenfolge speichern, bytes2, bytes2, bytes2, bytes2, bytes8, bytes1(auch bekannt als byte), die Reihenfolge sollte gespeichert werden, und ich kümmere mich nicht wirklich um den Rest der Bytes .

Hat Solidity einige Werkzeuge dafür? Oder es ist nur mit Bitoperationen möglich.

Ich fand einige Schwierigkeiten bei der Arbeit mit diesen Low-Level-Typen.

UPDATE: Also habe ich diese Funktion vorbereitet, die numBytesBytes sourceab startByte analysiert.

function bytesChunck(bytes32 source, uint start, uint numBytes) constant returns(uint _result){
            uint counter = 0;
            uint result;

            for(uint i = 0; i < numBytes; i++) {
                result += uint8(source[start + i]);
            }
            return result;
            // 
    }

dann konvertiere ich das Ergebnis einfach in benötigte Bytes, wie bytes8(result). Aber es scheint übergelaufen zu sein, denn wenn ich 8 Bytes habe, sind die ersten Bytes immer Nullen. Irgendwelche Ideen? :)

Vielen Dank.

Das ist irgendwie verwirrend. Wenn Sie "Reihenfolge speichern" sagen, meinen Sie, die Bytes in der ursprünglichen Reihenfolge zu behalten, oder meinen Sie, sie zu sortieren? Können Sie uns auch 5 Variablen geben, die zusammen 32 Bytes ergeben, damit wir wissen, was Sie wollen? Schließlich ist der erste Gedanke, dass es am besten wäre, wenn möglich, die großen Bytes in diese fünf Blöcke zu zerhacken, bevor Sie mit dem Vertrag interagieren. Ist es wirklich notwendig, diesen Schritt innerhalb des Smart Contracts durchzuführen? Die Kontrolle der Benzinkosten neigt dazu, solche Dinge in Solidity zu vermeiden.
@RobHitchens danke für den Kommentar. Ich möchte die ursprüngliche Reihenfolge speichern (nicht erneut sortieren). Ich werde Proben etwas später hinzufügen.

Antworten (1)

Deine Frage ist nicht klar genug. Wenn Sie 32 Bytes in 5 Variablen aufteilen möchten, die eine Gesamtlänge von 2+2+2+2+8+1 = 17haben, sollten Sie angeben, welche Bytes aufgeteilt werden sollen (Bytes von links oder Bytes von rechts).

Ich habe ein Beispiel geschrieben, das Ihr Problem löst, soweit ich es verstehen konnte. Kommentieren Sie die Antwort - erklären Sie, was Sie genau brauchen, und ich werde den Code ändern.

pragma solidity ^0.4.0;

contract BytesChunkTest
{
    bytes32 constant public test_source=0x000000000000000000ff11223344556677889900aabbccddeeff;

    bytes32 constant mask1 = 0xff00000000000000000000000000000000000000000000000000000000000000;
    bytes32 constant mask2 = 0xffff000000000000000000000000000000000000000000000000000000000000;
    bytes32 constant mask8 = 0xffffffffffffffff000000000000000000000000000000000000000000000000;
    uint    constant main_shift=15;

    function sourceToChunk(bytes32 source) constant
    returns
        (
            bytes2 r1_2,
            bytes2 r2_2,
            bytes2 r3_2,
            bytes2 r4_2,
            bytes8 r5_8,
            bytes1 r6_1
        )
    {

        r1_2 = bytes2(source<<(main_shift*8)&mask2);
        r2_2 = bytes2((source<<(main_shift+2)*8)&mask2);
        r3_2 = bytes2((source<<(main_shift+4)*8)&mask2);
        r4_2 = bytes2((source<<(main_shift+6)*8)&mask2);
        r5_8 = bytes8((source<<(main_shift+8)*8)&mask8);
        r6_1 = bytes1((source<<(main_shift+16)*8)&mask1);
    }


    function test() constant
    returns
        (
            bytes2,
            bytes2,
            bytes2,
            bytes2,
            bytes8,
            bytes1
        )
    {
        return sourceToChunk(test_source);
    }
}
Konvertieren Sie bytes32 in geordnete bytes2, bytes4 usw
AntwortenHierDatenschutz-Bestimmungen1y, 0v