Regex 通过从文件中获取输入来构建哈希，如果键不唯一，则追加值

我有这个档案

affaire,chose,question
chose,emploi,fonction,service,travail,tâche
cause,chose,matière
chose,point,question,tête
chose,objet,élément
chose,machin,truc

我希望有这样一个关联数组：

affaire => chose, question
cause => chose, matière
chose => emploi, fonction, service, travail, tache, point, question, tete, objet élément, machin, truc

或者更好的是，每当我发现一个新词时，将该词保存为键，将上下文（左或/和右）保存为值。。。例如：

affaire => chose, question
cause => chose, matière
chose => affaire, question, cause, matière, emploi, fonction, service, travail, tache, point, question, tete, objet élément, machin, truc

目前，我正在尝试以以下方式创建关联数组：

 $in = "test.txt";
 $out = "res_test.txt";

open(IN, "<", $in); 
open(OUT, ">", $out);

%list = '';
while(defined($l = <IN>)){
    if ($l =~ /((\w+),(.*))/){
        #2,3
        $list{$2} = $3;
    }
}


    while(my($k,$v) = each(%list)){
            print OUT $k." => ".$v."\n";
    }

为什么它不增加新的价值？ 谢谢您的帮助。

在散列（关联数组）中，键必须是唯一的。这就是为什么在您的情况下，

选择

会导致问题

#!/usr/bin/perl
# your code goes here
use strict;
use warnings;
use Data::Dumper;
my %hash;
while(chomp(my $line = <DATA>)){
        my (@values) = split /,/,$line;
        my $key = shift @values;
        if(exists $hash{$key}){
        my $ref_value = $hash{"$key"};
        push @values, @$ref_value;
        $hash{"$key"} = [@values];
        }   
        else{
        $hash{"$key"} = [@values];
        }
}
print Dumper %hash;

__DATA__
affaire,chose,question
chose,emploi,fonction,service,travail,tâche
cause,chose,matière
chose,point,question,tête
chose,objet,élément
chose,machin,truc

#/usr/bin/perl
#你的密码在这里
严格使用；
使用警告；
使用数据：：转储程序；
我的%hash；
while（chomp（my$line=））{
my（@values）=拆分/，/，$line；
我的$key=shift@values；
if（存在$hash{$key}）{
我的$ref_值=$hash{“$key”}；
推送@values，@$ref_值；
$hash{“$key”}=[@values]；
}   
否则{
$hash{“$key”}=[@values]；
}
}
打印转储程序%hash；
__资料__
阿菲尔，阿菲尔，问题
选择，雇佣，工作，服务，辛苦
事业，选择，马蒂埃
选择、重点、问题
选择、对象、事件
选择，机器，休战

在散列（关联数组）中，键必须是唯一的。这就是为什么在您的情况下，

选择

会导致问题

#!/usr/bin/perl
# your code goes here
use strict;
use warnings;
use Data::Dumper;
my %hash;
while(chomp(my $line = <DATA>)){
        my (@values) = split /,/,$line;
        my $key = shift @values;
        if(exists $hash{$key}){
        my $ref_value = $hash{"$key"};
        push @values, @$ref_value;
        $hash{"$key"} = [@values];
        }   
        else{
        $hash{"$key"} = [@values];
        }
}
print Dumper %hash;

__DATA__
affaire,chose,question
chose,emploi,fonction,service,travail,tâche
cause,chose,matière
chose,point,question,tête
chose,objet,élément
chose,machin,truc

#/usr/bin/perl
#你的密码在这里
严格使用；
使用警告；
使用数据：：转储程序；
我的%hash；
while（chomp（my$line=））{
my（@values）=拆分/，/，$line；
我的$key=shift@values；
if（存在$hash{$key}）{
我的$ref_值=$hash{“$key”}；
推送@values，@$ref_值；
$hash{“$key”}=[@values]；
}   
否则{
$hash{“$key”}=[@values]；
}
}
打印转储程序%hash；
__资料__
阿菲尔，阿菲尔，问题
选择，雇佣，工作，服务，辛苦
事业，选择，马蒂埃
选择、重点、问题
选择、对象、事件
选择，机器，休战

---

当您确实想要附加旧的散列值时，您会覆盖它们，所以 解决方案是连接字符串

my %list;
while (my $l = <IN>) {
    if ($l =~ /((\w+),(.*))/) {

      # $list{$2} //= ""; # initialize to empty string
      # # add comma in front depending on $list{$2} content
      # $list{$2} .= length($list{$2}) ? ",$3" : $3;
      if (defined $list{$2}) { $list{$2} .= ",$3" }
      else                   { $list{$2}  = $3 }
    }
}

my%列表；
而（我的$l=）{
如果（$l=~/（\w+），（.*）/）{
#$list{$2}/=“”#初始化为空字符串
##根据$list{$2}内容，在前面添加逗号
#$list{$2}.=长度（$list{$2}）“，$3”：$3；
如果（定义的$list{$2}）{$list{$2}.=“，$3”}
else{$list{$2}=$3}
}
}

或者使用更常见的数组散列来存储值

my %list;
while (my $l = <IN>) {
    my ($k, @vals) = split /,/, $l;
    push @{ $list{$k} }, @vals;
}
use Data::Dumper; print Dumper \%list;

my%列表；
而（我的$l=）{
my（$k，@VAL）=拆分/，/，$l；
推送{$list{$k}，@vals；
}
使用数据：：转储程序；打印转储程序\%列表；

当您确实想要附加旧的散列值时，您会覆盖它们，所以 解决方案是连接字符串

my %list;
while (my $l = <IN>) {
    if ($l =~ /((\w+),(.*))/) {

      # $list{$2} //= ""; # initialize to empty string
      # # add comma in front depending on $list{$2} content
      # $list{$2} .= length($list{$2}) ? ",$3" : $3;
      if (defined $list{$2}) { $list{$2} .= ",$3" }
      else                   { $list{$2}  = $3 }
    }
}

my%列表；
而（我的$l=）{
如果（$l=~/（\w+），（.*）/）{
#$list{$2}/=“”#初始化为空字符串
##根据$list{$2}内容，在前面添加逗号
#$list{$2}.=长度（$list{$2}）“，$3”：$3；
如果（定义的$list{$2}）{$list{$2}.=“，$3”}
else{$list{$2}=$3}
}
}

或者使用更常见的数组散列来存储值

my %list;
while (my $l = <IN>) {
    my ($k, @vals) = split /,/, $l;
    push @{ $list{$k} }, @vals;
}
use Data::Dumper; print Dumper \%list;

my%列表；
而（我的$l=）{
my（$k，@VAL）=拆分/，/，$l；
推送{$list{$k}，@vals；
}
使用数据：：转储程序；打印转储程序\%列表；

每次有新值时，都会将此新值指定给哈希键的值，从而覆盖旧值

一个简单的解决方案：

#!/usr/bin/perl

use strict;
use warnings;

my $in  = "in";                                                                                    
my $out = "out";                                                                                    

open IN, "<", $in                                                                                   
    or die "$!";                                                                                    
open OUT, ">", $out                                                                                 
    or die "$!";                                                                                    

my %list = ();                                                                                      

while (defined(my $l = <IN>)) {                                                                     
    if ($l =~ /(\w+),(.*)/) {                                                                       
        $list{$1} .= exists($list{$1}) ? ",$2" : $2;                                                
    }                                                                                               
}                                                                                                   

while(my($k,$v) = each(%list)){                                                                     
    print OUT $k." => ".$v."\n";                                                                    
}

#/usr/bin/perl
严格使用；
使用警告；
我的$in=“in”；
我的$out=“out”；
在“，”中打开，$out
或者死“$！”；
我的%list=（）；
而（已定义（my$l=）{
如果（$l=~/（\w+），（.*）/）{
$list{$1}.=存在（$list{$1}）“，$2”：$2；
}                                                                                               
}                                                                                                   
而（my（$k，$v）=每个（%list））{
打印出$k.“=>”$v.“\n”；
}

每次有新值时，都会将此新值指定给哈希键的值，从而覆盖旧值

一个简单的解决方案：

#!/usr/bin/perl

use strict;
use warnings;

my $in  = "in";                                                                                    
my $out = "out";                                                                                    

open IN, "<", $in                                                                                   
    or die "$!";                                                                                    
open OUT, ">", $out                                                                                 
    or die "$!";                                                                                    

my %list = ();                                                                                      

while (defined(my $l = <IN>)) {                                                                     
    if ($l =~ /(\w+),(.*)/) {                                                                       
        $list{$1} .= exists($list{$1}) ? ",$2" : $2;                                                
    }                                                                                               
}                                                                                                   

while(my($k,$v) = each(%list)){                                                                     
    print OUT $k." => ".$v."\n";                                                                    
}

#/usr/bin/perl
严格使用；
使用警告；
我的$in=“in”；
我的$out=“out”；
在“，”中打开，$out
或者死“$！”；
我的%list=（）；
而（已定义（my$l=）{
如果（$l=~/（\w+），（.*）/）{
$list{$1}.=存在（$list{$1}）“，$2”：$2；
}                                                                                               
}                                                                                                   
而（my（$k，$v）=每个（%list））{
打印出来$