Arrays Perl中的哈希数组按键排序

我定义了如下哈希数组：

while (my $line = <PILEUP>) {
    if ($line =~ /INDEL/ and $line !~ /^#/) {
        chop $line;
        my @splitline = split(/\t/, $line);
        $hash2{$splitline[1]}{len} = length($splitline[4]);
        $hash2{$splitline[1]}{type} = "INDEL";
        push @{$hash1{$splitline[0]}}, %hash2;
    }
}

while（我的$line=）{
如果（$line=~/INDEL/和$line！~/^#/）{
切掉$line；
my@splitline=split（/\t/，$line）；
$hash2{$splitline[1]}{len}=length（$splitline[4]）；
$hash2{$splitline[1]}{type}=“INDEL”；
推送{$hash1{$splitline[0]}，%hash2；
}
}

然后，我想按照每个散列的键对该数组进行排序：

for my $chr (keys %hash1) {
    my @sorted =  sort { $a->{ } <=> $b->{ } } @{%hash1{$chr}};
}

用于我的$chr（键%1）{
my@sorted=sort{$a->{}$b->{}}{%hash1{$chr}}；
}

但是，不知道如何在这里继续下去

我定义了如下哈希数组：

while (my $line = <PILEUP>) {
    if ($line =~ /INDEL/ and $line !~ /^#/) {
        chop $line;
        my @splitline = split(/\t/, $line);
        $hash2{$splitline[1]}{len} = length($splitline[4]);
        $hash2{$splitline[1]}{type} = "INDEL";
        push @{$hash1{$splitline[0]}}, %hash2;
    }
}

不，你没有。您可以这样定义数组的散列

    chop $line;

几乎在任何情况下，

chomp

都是最好的选择。在10年的Perl编程过程中，我只是好奇地使用了

chop

    $hash2{$splitline[1]}{len} = length($splitline[4]);
    $hash2{$splitline[1]}{type} = "INDEL";
    push @{$hash1{$splitline[0]}}, %hash2;

在这里，将

%hash2

的键和值推送到

%hash1

中的数组中。您可能想要推送hash ref:

\%hash2

。但在这种情况下，您需要将其限定在词汇范围内，否则它将多次推送同一引用

for my $chr (keys %hash1) {
    my @sorted =  sort { $a->{ } <=> $b->{ } } @{%hash1{$chr}};
}

用于我的$chr（键%1）{
my@sorted=sort{$a->{}$b->{}}{%hash1{$chr}}；
}

这是正确的方向，只是您必须选择一个（或多个）散列值进行排序。例如长度和类型。不能使用循环

my @sorted_keys = sort { $hash1{$a}{len}  <=> $hash1{$b}{len} ||
                         $hash1{$a}{type} cmp $hash1{$b}{type} } keys %hash1;

my@sorted_keys=sort{$hash1{$a}{len}$hash1{$b}{len}||
$hash1{$a}{type}cmp$hash1{$b}{type}}键%hash1；

我定义了如下哈希数组：

while (my $line = <PILEUP>) {
    if ($line =~ /INDEL/ and $line !~ /^#/) {
        chop $line;
        my @splitline = split(/\t/, $line);
        $hash2{$splitline[1]}{len} = length($splitline[4]);
        $hash2{$splitline[1]}{type} = "INDEL";
        push @{$hash1{$splitline[0]}}, %hash2;
    }
}

不，你没有。您可以这样定义数组的散列

    chop $line;

几乎在任何情况下，

chomp

都是最好的选择。在10年的Perl编程过程中，我只是好奇地使用了

chop

    $hash2{$splitline[1]}{len} = length($splitline[4]);
    $hash2{$splitline[1]}{type} = "INDEL";
    push @{$hash1{$splitline[0]}}, %hash2;

在这里，将

%hash2

的键和值推送到

%hash1

中的数组中。您可能想要推送hash ref:

\%hash2

。但在这种情况下，您需要将其限定在词汇范围内，否则它将多次推送同一引用

for my $chr (keys %hash1) {
    my @sorted =  sort { $a->{ } <=> $b->{ } } @{%hash1{$chr}};
}

用于我的$chr（键%1）{
my@sorted=sort{$a->{}$b->{}}{%hash1{$chr}}；
}

这是正确的方向，只是您必须选择一个（或多个）散列值进行排序。例如长度和类型。不能使用循环

my @sorted_keys = sort { $hash1{$a}{len}  <=> $hash1{$b}{len} ||
                         $hash1{$a}{type} cmp $hash1{$b}{type} } keys %hash1;

my@sorted_keys=sort{$hash1{$a}{len}$hash1{$b}{len}||
$hash1{$a}{type}cmp$hash1{$b}{type}}键%hash1；

我定义了如下哈希数组：

while (my $line = <PILEUP>) {
    if ($line =~ /INDEL/ and $line !~ /^#/) {
        chop $line;
        my @splitline = split(/\t/, $line);
        $hash2{$splitline[1]}{len} = length($splitline[4]);
        $hash2{$splitline[1]}{type} = "INDEL";
        push @{$hash1{$splitline[0]}}, %hash2;
    }
}

不，你没有。您可以这样定义数组的散列

    chop $line;

几乎在任何情况下，

chomp

都是最好的选择。在10年的Perl编程过程中，我只是好奇地使用了

chop

    $hash2{$splitline[1]}{len} = length($splitline[4]);
    $hash2{$splitline[1]}{type} = "INDEL";
    push @{$hash1{$splitline[0]}}, %hash2;

在这里，将

%hash2

的键和值推送到

%hash1

中的数组中。您可能想要推送hash ref:

\%hash2

。但在这种情况下，您需要将其限定在词汇范围内，否则它将多次推送同一引用

for my $chr (keys %hash1) {
    my @sorted =  sort { $a->{ } <=> $b->{ } } @{%hash1{$chr}};
}

用于我的$chr（键%1）{
my@sorted=sort{$a->{}$b->{}}{%hash1{$chr}}；
}

这是正确的方向，只是您必须选择一个（或多个）散列值进行排序。例如长度和类型。不能使用循环

my @sorted_keys = sort { $hash1{$a}{len}  <=> $hash1{$b}{len} ||
                         $hash1{$a}{type} cmp $hash1{$b}{type} } keys %hash1;

my@sorted_keys=sort{$hash1{$a}{len}$hash1{$b}{len}||
$hash1{$a}{type}cmp$hash1{$b}{type}}键%hash1；

我定义了如下哈希数组：

while (my $line = <PILEUP>) {
    if ($line =~ /INDEL/ and $line !~ /^#/) {
        chop $line;
        my @splitline = split(/\t/, $line);
        $hash2{$splitline[1]}{len} = length($splitline[4]);
        $hash2{$splitline[1]}{type} = "INDEL";
        push @{$hash1{$splitline[0]}}, %hash2;
    }
}

不，你没有。您可以这样定义数组的散列

    chop $line;

几乎在任何情况下，

chomp

都是最好的选择。在10年的Perl编程过程中，我只是好奇地使用了

chop

    $hash2{$splitline[1]}{len} = length($splitline[4]);
    $hash2{$splitline[1]}{type} = "INDEL";
    push @{$hash1{$splitline[0]}}, %hash2;

在这里，将

%hash2

的键和值推送到

%hash1

中的数组中。您可能想要推送hash ref:

\%hash2

。但在这种情况下，您需要将其限定在词汇范围内，否则它将多次推送同一引用

for my $chr (keys %hash1) {
    my @sorted =  sort { $a->{ } <=> $b->{ } } @{%hash1{$chr}};
}

用于我的$chr（键%1）{
my@sorted=sort{$a->{}$b->{}}{%hash1{$chr}}；
}

这是正确的方向，只是您必须选择一个（或多个）散列值进行排序。例如长度和类型。不能使用循环

my @sorted_keys = sort { $hash1{$a}{len}  <=> $hash1{$b}{len} ||
                         $hash1{$a}{type} cmp $hash1{$b}{type} } keys %hash1;

my@sorted_keys=sort{$hash1{$a}{len}$hash1{$b}{len}||
$hash1{$a}{type}cmp$hash1{$b}{type}}键%hash1；

你能举个例子吗？我不清楚你到底想分类什么。我认为您可能混淆了特殊的排序变量

$a

和

$b

，因为在对数组进行排序时，数组元素的值。数组中有许多散列。我只想对数组中的元素进行排序，这些元素是散列，根据它们的键。如果你的数组中有散列，你如何比较两个不同散列的相等性？你能举个例子吗？我不清楚你到底想分类什么。我认为您可能混淆了特殊的排序变量

$a

和

$b

，因为在对数组进行排序时，数组元素的值。数组中有许多散列。我只想对数组中的元素进行排序，这些元素是散列，根据它们的键。如果你的数组中有散列，你如何比较两个不同散列的相等性？你能举个例子吗？我不清楚你到底想分类什么。我认为您可能混淆了特殊的排序变量

$a

和

$b

，因为在对数组进行排序时，数组元素的值。数组中有许多散列。我只想对数组中的元素进行排序，这些元素是散列，根据它们的键。如果你的数组中有散列，你如何比较两个不同散列的相等性？你能举个例子吗？我不清楚你到底想干什么