awk 多字符分隔符

最新推荐文章于 2024-02-01 09:53:21 发布
最新推荐文章于 2024-02-01 09:53:21 发布
阅读量4.3k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aquastar/article/details/8045574
版权

多字符作为分隔符：


一，如果是A或B的关系的话就用

echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 



结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  











多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  




多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  








多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  






多字符作为分隔符：







一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  

多字符作为分隔符：






一，如果是A或B的关系的话就用


echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是


x|xx|xxx







二，如果是AB整体作为分隔符




echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
结果是



x|xx







三，一个特别情况


碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）


于是我就写成


echo "x|||xx" | awk -F '|||' '{print $1}' 



结果是



x|||xx




相当于说三个竖杠相当于没有起作用


经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：




echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
结果是




x|xx|xxx














  
  

   
   


  
  


 

 

 
 
多字符作为分隔符：
 
 

 
 
 
一，如果是A或B的关系的话就用
 
 
echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是 
 
 
 
x|xx|xxx
 
 

 
 
 
二，如果是AB整体作为分隔符
 
 
 
 
echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
 
 结果是
  
 
x|xx
 
 

 
 
 
三，一个特别情况
 
 
碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）
 
 
于是我就写成
 
 
echo "x|||xx" | awk -F '|||' '{print $1}' 
 
 
 
 结果是 
 
 
 
 
 x|||xx 
 
 
 
 
 
相当于说三个竖杠相当于没有起作用
 
 
经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：
 
 
 
 
echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
 
 结果是
  
 
 
 x|xx|xxx 
 
 
 
 
 

 
 
 

 
 
 
 
  
  
 
 

 

 
 
多字符作为分隔符：
 
 

 
 
 
一，如果是A或B的关系的话就用
 
 
echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是 
 
 
 
x|xx|xxx
 
 

 
 
 
二，如果是AB整体作为分隔符
 
 
 
 
echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
 
 结果是
  
 
x|xx
 
 

 
 
 
三，一个特别情况
 
 
碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）
 
 
于是我就写成
 
 
echo "x|||xx" | awk -F '|||' '{print $1}' 
 
 
 
 结果是 
 
 
 
 
 x|||xx 
 
 
 
 
 
相当于说三个竖杠相当于没有起作用
 
 
经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：
 
 
 
 
echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
 
 结果是
  
 
 
 x|xx|xxx 
 
 
 
 
 

 
 
 

 
 
 
 
  
  
 
 

 

 
 
多字符作为分隔符：
 
 

 
 
 
一，如果是A或B的关系的话就用
 
 
echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是 
 
 
 
x|xx|xxx
 
 

 
 
 
二，如果是AB整体作为分隔符
 
 
 
 
echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
 
 结果是
  
 
x|xx
 
 

 
 
 
三，一个特别情况
 
 
碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）
 
 
于是我就写成
 
 
echo "x|||xx" | awk -F '|||' '{print $1}' 
 
 
 
 结果是 
 
 
 
 
 x|||xx 
 
 
 
 
 
相当于说三个竖杠相当于没有起作用
 
 
经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：
 
 
 
 
echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
 
 结果是
  
 
 
 x|xx|xxx 
 
 
 
 
 

 
 
 

 
 
 
 
  
  
 
 

 

 
 
多字符作为分隔符：
 
 

 
 
 
一，如果是A或B的关系的话就用
 
 
echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是 
 
 
 
x|xx|xxx
 
 

 
 
 
二，如果是AB整体作为分隔符
 
 
 
 
echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
 
 结果是
  
 
x|xx
 
 

 
 
 
三，一个特别情况
 
 
碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）
 
 
于是我就写成
 
 
echo "x|||xx" | awk -F '|||' '{print $1}' 
 
 
 
 结果是 
 
 
 
 
 x|||xx 
 
 
 
 
 
相当于说三个竖杠相当于没有起作用
 
 
经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：
 
 
 
 
echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
 
 结果是
  
 
 
 x|xx|xxx 
 
 
 
 
 

 
 
 

 
 
 
 
  
  
 
 

 

 
 
多字符作为分隔符：
 
 

 
 
 
一，如果是A或B的关系的话就用
 
 
echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是 
 
 
 
x|xx|xxx
 
 

 
 
 
二，如果是AB整体作为分隔符
 
 
 
 
echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
 
 结果是
  
 
x|xx
 
 

 
 
 
三，一个特别情况
 
 
碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）
 
 
于是我就写成
 
 
echo "x|||xx" | awk -F '|||' '{print $1}' 
 
 
 
 结果是 
 
 
 
 
 x|||xx 
 
 
 
 
 
相当于说三个竖杠相当于没有起作用
 
 
经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：
 
 
 
 
echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
 
 结果是
  
 
 
 x|xx|xxx 
 
 
 
 
 

 
 
 

 
 
 
 
  
  
 
 

 

 
 
多字符作为分隔符：
 
 

 
 
 
一，如果是A或B的关系的话就用
 
 
echo "xAxxBxxx" | awk -F '[AB]' '{print $1"|"$2"|"$3}' 
结果是 
 
 
 
x|xx|xxx
 
 

 
 
 
二，如果是AB整体作为分隔符
 
 
 
 
echo "xABxx" | awk -F 'AB' '{print $1"|"$2}' 
 
 结果是
  
 
x|xx
 
 

 
 
 
三，一个特别情况
 
 
碰到一个实际情况，我需要用三个竖杠来做分隔符（"|||"）
 
 
于是我就写成
 
 
echo "x|||xx" | awk -F '|||' '{print $1}' 
 
 
 
 结果是 
 
 
 
 
 x|||xx 
 
 
 
 
 
相当于说三个竖杠相当于没有起作用
 
 
经过小想和实践，竖杠需要转义，转义符也需要转义(原因不明)：
 
 
 
 
echo "x|||xx|||xxx" | awk -F '\\|\\|\\|' '{print $1"|"$2"|"$3}' 
 
 结果是
  
 
 
 x|xx|xxx 
 
 
 
 
 

 
 
 

 
 
 
 
  
  
 
 


                

        

    

  



    

      

        

            

              
                
                  aquastar
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
awk指定输入分隔符，输出分隔符

				
			

			

				

					qq_21478261的博客
				

				

					03-26
					
					1008
					
				

			

		

		

			
				
FS='@' ，指定输入分割符为@OFS=','，指定输出分割符为,

			
		

	



                

            
              



	

		

			

				
					
linux下sed awk gsub 替换分隔符效率比较

				
			

			

				

					huazicomeon的博客
				

				

					12-16
					
					2623
					
				

			

		

		

			
				
同事有个替换分隔符的需求，','替换为'\x01'，文件记录数有2亿+。使用sed处理1000w条数据大约用了10分钟，算下来整个文件处理完要用200分钟，时间过长。记得去掉csv文件每行记录的最后一个字段时awk处理要比sed快很多，于是尝试使用awk来替换分隔符，经过测试效率能够提高5-6倍，在此记录一下。

一、对一个200w+的文件处理，每行有6个字段



1、使用sed处理（用时76s...

			
		

	



              


  
              

                


	

		

			

				
					
awk 使用多个分隔符以及 打印奇偶行

				
			

			

				

					郑泽林
				

				

					03-12
					
					2350
					
				

			

		

		

			
				
文章目录☆☆☆   AWK 高级用法：1、多个分隔符 以及 连续相同的分隔符、字符串分隔符：2、awk 中 打印奇偶行：
 
这个是我自己写的 全部关于 awk学习的目录导航 ，感兴趣的可以看看。
 

☆☆☆   AWK 高级用法：
 
1、多个分隔符 以及 连续相同的分隔符、字符串分隔符：

当需要指定 多个分隔符的时候，怎么做？


当你不小...

			
		

	





	

		

			

				
					
linux awk 多分隔符

				
			

			

				

					zhenghe12365的博客
				

				

					02-01
					
					1826
					
				

			

		

		

			
				
上面虽然介绍了awk中使用多个记录分隔符的写法，但是这些记录分隔符都是单个字符，如果记录分隔符是个字符串怎么办呢？其实呢，通过在awk中指定两个记录分隔符（空格和:），即可一次性的提取出width和height后面的值，在awk中支持多个记录分隔符的写法如下。之前说过，awk支持正则表达式形式的记录分隔符，那就写个正则表达式就好，比如要指定分隔符为one和two。awk的-F参数可以指定新的记录分隔符，有些时候可能需求指定多个分隔符，比如下面的内容。

			
		

	



		

			
		



	

		

			

				
					
awk支持多个记录分隔符的写法

				
			

			

				

					weixin_34127717的博客
				

				

					05-05
					
					886
					
				

			

		

		

			
				
awk的-F参数可以指定新的记录分隔符，有些时候可能需求指定多个分隔符，比如下面的内容width:720height:360如果需要取出width和height后面的值的话，一般大家会这样做，即做两次awk操作#echo"width:720height:360"|awk'{print$1;print$2}'|awk-F:'{print$2}'
72...

			
		

	





	

		

			

				
					
awk linux 分隔_awk多分隔符

				
			

			

				

					weixin_39862097的博客
				

				

					12-22
					
					1285
					
				

			

		

		

			
				
awk的-F参数可以指定新的分隔符，有些时候可能需求指定多个分隔符，比如下面的内容[root@N1 ~]# netstat -an | grep ESTABudp        0      0 192.168.1.120:35570     212.47.249.141:123      ESTABLISHEDudp        0      0 192.168.1.120:55589    ...

			
		

	





	

		

			

				
					
Linux：awk指定输入和输出分隔符

					
热门推荐

				
			

			

				

					liangbilin的博客
				

				

					09-15
					
					8万+
					
				

			

		

		

			
				
awk默认的分隔符为空格和tab。然而，实践中往往需要指定其它符号作为分隔符。
输入分隔符
输出分隔符
参考资料
awk从放弃到入门（2）：awk分隔符



			
		

	





	

		

			

				
					
awk 单引号分隔符

					
最新发布

				
			

			

				

					08-17
				

			

		

		

			
				
默认情况下，`awk` 使用空格作为字段分隔符，但如果数据是以其他字符分隔的，可以通过 `-F` 选项来指定一个自定义的分隔符。  当你需要使用单引号来指定分隔符时，应该注意单引号用于指示字符串，`awk` 并不会将单...

			
		

	





	

		

			

				
					
awk技巧一则——指定多个分隔符

				
			

			

				

					dhissfn3643的博客
				

				

					05-02
					
					842
					
				

			

		

		

			
				
cat /proc/net/dev
Inter-|   Receive                                                |  Transmit
 face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo ...

			
		

	





	

		

			

				
					
awk(gawk)用法小结

				
			

			

				

					weixin_30252155的博客
				

				

					12-29
					
					322
					
				

			

		

		

			
				
awk 用法：awk ' pattern {action} ' 
变量名        含义ARGC        命令行变元个数ARGV        命令行变元数组FILENAME    当前输入文件名FNR        当前文件中的记录号FS        输入域分隔符，默认为一个空格RS   ...

			
		

	





	

		

			

				
					
awk 用多个分隔符处理字符串/以及自定义分隔符

				
			

			

				

					liulanba的博客
				

				

					12-20
					
					4475
					
				

			

		

		

			
				
需求：获取hello world这个字符串
s1="windows<hello world>Linux<github>"

解决：使用通配符[]
表示任取中括号里面的一个字符，因此里面的每一个字符都会被当作分隔符
Administrator@XTZJ-20211002VW MINGW64 ~
$ echo $s1 | awk -F "[<>]" '{print $2}'
hello world


......

			
		

	





	

		

			

				
					
awk多分隔符

				
			

			

				

					weixin_33871366的博客
				

				

					07-17
					
					141
					
				

			

		

		

			
				
一般我们在使用awk的过程中，分隔符可以使用默认的空格（默认可以省略）和指定分隔符的方式。默认格式：awk '{print $n}' filename #n为字段值如：
echo"0123456"|awk'{print$2}'
1指定分隔符的格式：awk -F':' '{print $n}' filename...

			
		

	





	

		

			

				
					
awk的求和计算使用；awk多个分隔符如何使用？

				
			

			

				

					weixin_34130269的博客
				

				

					05-24
					
					1062
					
				

			

		

		

			
				
1、对于下图，如何使用awk求所有各列的和
    
和：175 16 78 19
方法：awk '{for(n=1;n&lt;=NF;n++)t[n]+=$n}END{for(n=1;n&lt;=NF;n++)printf t[n]" ";print"\n"}'
2、求某一列的和：
[linux@test /tmp]$ awk '{sum += $1};END {print sum}' test...

			
		

	





	

		

			

				
					
awk 分隔符 多个空格_awk多分隔符

				
			

			

				

					weixin_42604188的博客
				

				

					01-17
					
					3939
					
				

			

		

		

			
				
一般我们在使用awk的过程中，分隔符可以使用默认的空格(默认可以省略)和指定分隔符的方式。默认格式：awk '{print $n}' filename #n为字段值如：echo"0123456"|awk'{print$2}'1指定分隔符的格式：awk -F':' '{print $n}' filename或awk -F: '{print $n}' filename #如按...

			
		

	





	

		

			

				
					
awk以多个字符串作为分隔符

				
			

			

				

					ustc_sse_shenzhang的博客
				

				

					04-09
					
					736
					
				

			

		

		

			
				
awk -F"meta_mc_id|ader_id" ‘{print $1, $3}’ utf8.data

			
		

	





	

		

			

				
					
awk 多分隔符

				
			

			

				

					weixin_30325487的博客
				

				

					09-03
					
					103
					
				

			

		

		

			
				
#!/bin/bash 
log_path="./log/"
dates=`date -d '-1 days' +'%Y%m%d'`
cd $log_path;
for i in `cat list`;do wget $i:/home/work/odp/log/search/search.log.${dates}22 ./;done
cd ../;
cat ${log_path}/se...

			
		

	





	

		

			

				
					
awk 多个分隔符

				
			

			

				

					weixin_30298497的博客
				

				

					11-06
					
					113
					
				

			

		

		

			
				
默认分隔符是空格 awk '{print $1}' file  单个分隔符 awk –F : '{print $1}' file  多个分隔符 awk -F '[:=]' '{print $1}' file   上面的''都是单引号。
转载于:https://www.cnblogs.com/helloweworld/p/...

			
		

	





	

		

			

				
					
awk分隔符设定为多个字符或字符串

				
			

			

				

					陈泽锦的博客
				

				

					07-04
					
					4545
					
				

			

		

		

			
				
awk -F"[01]" '{}'  这种形式指定的分隔符是或的关系，即0或1作为分隔符；
awk -F"[0][1]" '{}' 这种形式指定的分隔符是合并的关系，即以“01”作为一个字符为分隔符。



故假如有test.txt文本文件只有一行:
1. mail from: tomcat@gmail.com  2. subject:hello  3. data:2012-07-12

			
		

	





	

		

			

				
					
awk多分隔符操作

				
			

			

				

					
				

				

					11-06
					
					118
					
				

			

		

		

			
				
awk中-F"[:/]"表示：和/都是字段分隔符
[root@localhost edm]# tail -n 2 /etc/passwd
mysql:x:27:27:MySQL Server:/var/lib/mysql:/...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值