golang 字符串操作实例介绍linux操作系统

“心水小桃花”通过精心收集，向本站投稿了5篇golang 字符串操作实例介绍linux操作系统，下面是小编为大家整理后的golang 字符串操作实例介绍linux操作系统，仅供参考，大家一起来看看吧。

篇1：golang 字符串操作实例介绍linux操作系统

本文章来给各位同学介绍关于golang 字符串操作实例，希望此方法对各位同学会有所帮助，

例1

package main

import s “strings”

//别名

import (

“fmt”

)

var p = fmt.Println

func main {

p(“Contains: ”, s.Contains(“test”, “es”)) //是否包含 true

p(“Count: ”, s.Count(“test”, “t”)) //字符串出现字符的次数 2

p(“HasPrefix: ”, s.HasPrefix(“test”, “te”)) //判断字符串首部 true

p(“HasSuffix: ”, s.HasSuffix(“test”, “st”)) //判断字符串结尾 true

p(“Index: ”, s.Index(“test”, “e”)) //查询字符串位置 1

p(“Join: ”, s.Join([]string{“a”, “b”}, “-”))//字符串数组 连接 a-b

p(“Repeat: ”, s.Repeat(“a”, 5)) //重复一个字符串 aaaaa

p(“Replace: ”, s.Replace(“foo”, “o”, “0”, -1)) //字符串替换 指定起始位置为小于0,则全部替换 f00

p(“Replace: ”, s.Replace(“foo”, “o”, “0”, 1)) //字符串替换 指定起始位置1 f0o

p(“Split: ”, s.Split(“a-b-c-d-e”, “-”)) //字符串切割 [a b c d e]

p(“ToLower: ”, s.ToLower(“TEST”)) //字符串 小写转换 test

p(“ToUpper: ”, s.ToUpper(“test”)) //字符串 大写转换 TEST

p()

p(“Len: ”, len(“hello”)) //字符串长度

p(“Char:”, “hello”[1]) //标取字符串中的字符，类型为byte

}

例

2package main

import (

“fmt”

“strings”

//“unicode/utf8”

)

func main() {

fmt.Println(“查找子串是否在指定的字符串中”)

fmt.Println(“ Contains 函数的用法”)

fmt.Println(strings.Contains(“seafood”, “foo”)) //true

fmt.Println(strings.Contains(“seafood”, “bar”)) //false

fmt.Println(strings.Contains(“seafood”, “”)) //true

fmt.Println(strings.Contains(“”, “”)) //true 这里要特别注意

fmt.Println(strings.Contains(“我是中国人”, “我”)) //true

fmt.Println(“”)

fmt.Println(“ ContainsAny 函数的用法”)

fmt.Println(strings.ContainsAny(“team”, “i”)) // false

fmt.Println(strings.ContainsAny(“failure”, “u & i”)) // true

fmt.Println(strings.ContainsAny(“foo”, “”)) // false

fmt.Println(strings.ContainsAny(“”, “”)) // false

fmt.Println(“”)

fmt.Println(“ ContainsRune 函数的用法”)

fmt.Println(strings.ContainsRune(“我是中国”, '我')) // true 注意第二个参数，用的是字符

fmt.Println(“”)

fmt.Println(“ Count 函数的用法”)

fmt.Println(strings.Count(“cheese”, “e”)) // 3

fmt.Println(strings.Count(“five”, “”)) // before & after each rune result: 5 , 源码中有实现

fmt.Println(“”)

fmt.Println(“ EqualFold 函数的用法”)

fmt.Println(strings.EqualFold(“Go”, “go”)) //大小写忽略

fmt.Println(“”)

fmt.Println(“ Fields 函数的用法”)

fmt.Println(“Fields are: %q”, strings.Fields(“ foo bar baz ”)) //[“foo” “bar” “baz”] 返回一个列表

//相当于用函数做为参数，支持匿名函数

for _, record := range []string{“ aaa*1892*122”, “aaataat”, “124|939|22”} {

fmt.Println(strings.FieldsFunc(record, func(ch rune) bool {

switch {

case ch > '5':

return true

}

return false

}))

}

fmt.Println(“”)

fmt.Println(“ HasPrefix 函数的用法”)

fmt.Println(strings.HasPrefix(“NLT_abc”, “NLT”)) //前缀是以NLT开头的

fmt.Println(“”)

fmt.Println(“ HasSuffix 函数的用法”)

fmt.Println(strings.HasSuffix(“NLT_abc”, “abc”)) //后缀是以NLT开头的

fmt.Println(“”)

fmt.Println(“ Index 函数的用法”)

fmt.Println(strings.Index(“NLT_abc”, “abc”)) // 返回第一个匹配字符的位置，这里是4

fmt.Println(strings.Index(“NLT_abc”, “aaa”)) // 在存在返回 -1

fmt.Println(strings.Index(“我是中国人”, “中”)) // 在存在返回 6

fmt.Println(“”)

fmt.Println(“ IndexAny 函数的用法”)

fmt.Println(strings.IndexAny(“我是中国人”, “中”)) // 在存在返回 6

fmt.Println(strings.IndexAny(“我是中国人”, “和”)) // 在存在返回 -1

fmt.Println(“”)

fmt.Println(“ Index 函数的用法”)

fmt.Println(strings.IndexRune(“NLT_abc”, 'b')) // 返回第一个匹配字符的位置，这里是4

fmt.Println(strings.IndexRune(“NLT_abc”, 's')) // 在存在返回 -1

fmt.Println(strings.IndexRune(“我是中国人”, '中')) // 在存在返回 6

fmt.Println(“”)

fmt.Println(“ Join 函数的用法”)

s := []string{“foo”, “bar”, “baz”}

fmt.Println(strings.Join(s, “, ”)) // 返回字符串：foo, bar, baz

fmt.Println(“”)

fmt.Println(“ LastIndex 函数的用法”)

fmt.Println(strings.LastIndex(“go gopher”, “go”)) // 3

fmt.Println(“”)

fmt.Println(“ LastIndexAny 函数的用法”)

fmt.Println(strings.LastIndexAny(“go gopher”, “go”)) // 4

fmt.Println(strings.LastIndexAny(“我是中国人”, “中”)) // 6

fmt.Println(“”)

fmt.Println(“ Map 函数的用法”)

rot13 := func(r rune) rune {

switch {

case r >= 'A' && r <= 'Z':

return 'A' + (r-'A'+13)%26

case r >= 'a' && r <= 'z':

return 'a' + (r-'a'+13)%26

}

return r

}

fmt.Println(strings.Map(rot13, “'Twas brillig and the slithy gopher...”))

fmt.Println(“”)

fmt.Println(“ Repeat 函数的用法”)

fmt.Println(“ba” + strings.Repeat(“na”, 2)) //banana

fmt.Println(“”)

fmt.Println(“ Replace 函数的用法”)

fmt.Println(strings.Replace(“oink oink oink”, “k”, “ky”, 2))

fmt.Println(strings.Replace(“oink oink oink”, “oink”, “moo”, -1))

fmt.Println(“”)

fmt.Println(“ Split 函数的用法”)

fmt.Printf(“%qn”, strings.Split(“a,b,c”, “,”))

fmt.Printf(“%qn”, strings.Split(“a man a plan a canal panama”, “a ”))

fmt.Printf(“%qn”, strings.Split(“ xyz ”, “”))

fmt.Printf(“%qn”, strings.Split(“”, “Bernardo O'Higgins”))

fmt.Println(“”)

fmt.Println(“ SplitAfter 函数的用法”)

fmt.Printf(“%qn”, strings.SplitAfter(“/home/m_ta/src”, “/”)) //[“/” “home/” “m_ta/” “src”]

fmt.Println(“”)

fmt.Println(“ SplitAfterN 函数的用法”)

fmt.Printf(“%qn”, strings.SplitAfterN(“/home/m_ta/src”, “/”, 2)) //[“/” “home/m_ta/src”]

fmt.Printf(“%qn”, strings.SplitAfterN(“#home#m_ta#src”, “#”, -1)) //[“/” “home/” “m_ta/” “src”]

fmt.Println(“”)

fmt.Println(“ SplitN 函数的用法”)

fmt.Printf(“%qn”, strings.SplitN(“/home/m_ta/src”, “/”, 1))

fmt.Printf(“%qn”, strings.SplitN(“/home/m_ta/src”, “/”, 2)) //[“/” “home/” “m_ta/” “src”]

fmt.Printf(“%qn”, strings.SplitN(“/home/m_ta/src”, “/”, -1)) //[“” “home” “m_ta” “src”]

fmt.Printf(“%qn”, strings.SplitN(“home,m_ta,src”, “,”, 2)) //[“/” “home/” “m_ta/” “src”]

fmt.Printf(“%qn”, strings.SplitN(“#home#m_ta#src”, “#”, -1)) //[“/” “home/” “m_ta/” “src”]

fmt.Println(“”)

fmt.Println(“ Title 函数的用法”) //这个函数，还真不知道有什么用

fmt.Println(strings.Title(“her royal highness”))

fmt.Println(“”)

fmt.Println(“ ToLower 函数的用法”)

fmt.Println(strings.ToLower(“Gopher”)) //gopher

fmt.Println(“”)

fmt.Println(“ ToLowerSpecial 函数的用法”)

fmt.Println(“”)

fmt.Println(“ ToTitle 函数的用法”)

fmt.Println(strings.ToTitle(“loud noises”))

fmt.Println(strings.ToTitle(“loud 中国”))

fmt.Println(“”)

fmt.Println(“ Replace 函数的用法”)

fmt.Println(strings.Replace(“ABAACEDF”, “A”, “a”, 2)) // aBaACEDF

//第四个参数小于0，表示所有的都替换， 可以看下golang的文档

fmt.Println(strings.Replace(“ABAACEDF”, “A”, “a”, -1)) // aBaaCEDF

fmt.Println(“”)

fmt.Println(“ ToUpper 函数的用法”)

fmt.Println(strings.ToUpper(“Gopher”)) //GOPHER

fmt.Println(“”)

fmt.Println(“ Trim 函数的用法”)

fmt.Printf(“[%q]”, strings.Trim(“ !!! Achtung !!! ”, “! ”)) // [“Achtung”]

fmt.Println(“”)

fmt.Println(“ TrimLeft 函数的用法”)

fmt.Printf(“[%q]”, strings.TrimLeft(“ !!! Achtung !!! ”, “! ”)) // [“Achtung !!! ”]

fmt.Println(“”)

fmt.Println(“ TrimSpace 函数的用法”)

fmt.Println(strings.TrimSpace(“ tn a lone gopher ntrn”)) // a lone gopher

}

篇2：shell 字符串 查找 替换 正则 操作linux操作系统

# $

?o $

bcd

?o $

cd

?o $

abcd

?o $

ab

%pos=1

%len=2

?o $

bc

匹配正则表达式

代码:

# 打印匹配长度

%expr match $x “.”

1

%expr match $x “abc”

3

%expr match $x “bc”

0

字符串的掐头去尾

代码:

%x=aabbaarealwwvvww

?o “$”

aabbaarealwwvv

?o “$”

aabbaareal

?o “$”

lwwvvww

?o “$”

bbaarealwwvvww

其中 , # 表示掐头， 因为键盘上 # 在 $ 的左面。

其中 , % 表示%， 因为键盘上 % 在 $ 的右面。

单个的表示最小匹配，双个表示最大匹配。

也就是说，当匹配的有多种方案的时候，选择匹配的最大长度还是最小长度，

字符串的替换

代码:

%x=abcdabcd

?o $ # 只替换一个

bbcdabcd

?o $ # 替换所有

bbcdbbcd

不可以使用 regexp ， 只能用 * ? 的文件扩展方式

三、性能比较

在shell中，通过awk,sed,expr等都可以实现，字符串上述操作。下面我们进行性能比较。

[chengmo@localhost ~]$test='c:/windows/boot.ini'

[chengmo@localhost ~]$ time for i in $(seq 10000);doa=${#test};done;

real 0m0.173s

user 0m0.139s

sys 0m0.004s

[chengmo@localhost ~]$ time for i in $(seq 10000);do a=$(expr length$test);done;

real 0m9.734s

user 0m1.628s

象专业人员那样截断字符串

尽管 basename 和 dirname 是很好的工具，但有时可能需要执行更高级的字符串“截断”，而不只是标准的路径名操作。当需要更强的说服力时，可以利用 bash 内置的变量扩展功能。已经使用了类似于 ${MYVAR} 的标准类型的变量扩展。但是 bash 自身也可以执行一些便利的字符串截断。看一下这些例子：

第一种方法:

${varible##*string} 从左向右截取最后一个string后的字符串

${varible#*string}从左向右截取第一个string后的字符串

${varible%%string*}从右向左截取最后一个string后的字符串

${varible%string*}从右向左截取第一个string后的字符串

“*”只是一个通配符可以不要

$ MYVAR=foodforthought.jpg

$ echo ${MYVAR##*fo}

rthought.jpg

$ echo ${MYVAR#*fo}

odforthought.jpg

在第一个例子中，输入了 ${MYVAR##*fo}。它的确切含义是什么？基本上，在 ${ } 中输入环境变量名称，两个 ##，然后是通配符 (“*fo”)。然后，bash 取得 MYVAR，找到从字符串 “foodforthought.jpg” 开始处开始、且匹配通配符 “*fo” 的 最长 子字符串，然后将其从字符串的开始处截去。刚开始理解时会有些困难，为了感受一下这个特殊的 “##” 选项如何工作，让我们一步步地看看 bash 如何完成这个扩展。首先，它从 “foodforthought.jpg” 的开始处搜索与 “*fo” 通配符匹配的子字符串。以下是检查到的子字符串：

f

fo     MATCHES *fo

foo

food

foodf

foodfo     MATCHES *fo

foodfor

foodfort

foodforth

foodfortho

foodforthou

foodforthoug

foodforthought

foodforthought.j

foodforthought.jp

foodforthought.jpg

在搜索了匹配的字符串之后，可以看到 bash 找到两个匹配。它选择最长的匹配，从初始字符串的开始处除去，然后返回结果。

上面所示的第二个变量扩展形式看起来与第一个相同，但是它只使用一个 “#” -- 并且 bash 执行 几乎同样的过程。它查看与第一个例子相同的子字符串系列，但是 bash 从初始字符串除去 最短 的匹配，然后返回结果。所以，一查到 “fo” 子字符串，它就从字符串中除去 “fo”，然后返回 “odforthought.jpg”。

这样说可能会令人十分困惑，下面以一简单方式记住这个功能。当搜索最长匹配时，使用 ##（因为 ## 比 # 长）。当搜索最短匹配时，使用 #。看，不难记吧！等一下，怎样记住应该使用 '#' 字符来从字符串开始部分除去？很简单！注意到了吗：在美国键盘上，shift-4 是 “$”，它是 bash 变量扩展字符。在键盘上，紧靠 “$” 左边的是 “#”。这样，可以看到：“#” 位于 “$” 的“开始处”，因此（根据我们的记忆法），“#” 从字符串的开始处除去字符。您可能要问：如何从字符串末尾除去字符。如果猜到我们使用美国键盘上紧靠 “$” 右边 的字符 (“%)，那就猜对了。这里有一些简单的例子，解释如何截去字符串的末尾部分：

$ MYFOO=”chickensoup.tar.gz“

$ echo ${MYFOO%%.*}

chickensoup

$ echo ${MYFOO%.*}

chickensoup.tar

正如您所见，除了将匹配通配符从字符串末尾除去之外，% 和 %% 变量扩展选项与 # 和 ## 的工作方式相同。请注意：如果要从末尾除去特定子字符串，不必使用 ”*“ 字符：

MYFOOD=”chickensoup“

$ echo ${MYFOOD%%soup}

chicken

在此例中，使用 ”%%“ 或 ”%“ 并不重要，因为只能有一个匹配。还要记住：如果忘记了应该使用 ”#“ 还是 ”%“，则看一下键盘上的 3、4 和 5 键，然后猜出来。

第二种方法：${varible:n1:n2}:截取变量varible从n1到n2之间的字符串。

可以根据特定字符偏移和长度，使用另一种形式的变量扩展，来选择特定子字符串。试着在 bash 中输入以下行：

$ EXCLAIM=cowabunga

$ echo ${EXCLAIM:0:3}

cow

$ echo ${EXCLAIM:3:7}

abunga

这种形式的字符串截断非常简便，只需用冒号分开来指定起始字符和子字符串长度。

应用字符串截断

现在我们已经学习了所有截断字符串的知识，下面写一个简单短小的 shell 脚本。我们的脚本将接受一个文件作为自变量，然后打印：该文件是否是一个 tar 文件。要确定它是否是 tar 文件，将在文件末尾查找模式 ”.tar“。如下所示：

mytar.sh -- 一个简单的脚本

#!/bin/bash

if [ ”${1##*.}“ = ”tar“ ]

then

echo This appears to be a tarball.

else

echo At first glance, this does not appear to be a tarball.

fi

要运行此脚本，将它输入到文件 mytar.sh 中，然后输入 ”chmod 755 mytar.sh“，生成可执行文件。然后，如下做一下 tar 文件试验：

$ ./mytar.sh thisfile.tar

This appears to be a tarball.

$ ./mytar.sh thatfile.gz

At first glance, this does not appear to be a tarball.

好，成功运行，但是不太实用。在使它更实用之前，先看一下上面使用的 ”if“ 语句。语句中使用了一个布尔表达式。在 bash 中，”=“ 比较运算符检查字符串是否相等。在 bash 中，所有布尔表达式都用方括号括起。但是布尔表达式实际上测试什么？让我们看一下左边。根据前面所学的字符串截断知识，”${1##*.}“ 将从环境变量 ”1“ 包含的字符串开始部分除去最长的 ”*.“ 匹配，并返回结果。这将返回文件中最后一个 ”.“ 之后的所有部分。显然，如果文件以 ”.tar“ 结束，结果将是 ”tar“，条件也为真。

您可能会想：开始处的 ”1“ 环境变量是什么。很简单 -- $1 是传给脚本的第一个命令行自变量，$2 是第二个，以此类推。

篇3：linux复制文件夹与文件实例介绍linux操作系统

本文章来介绍一下关于linux复制文件夹与文件的一些基础用法，有需要学习的朋友可参考一下本文章，

CP命令

格式: CP [选项] 源文件或目录  目的文件或目录

选项说明:-b 同名,备分原来的文件

-f 强制覆盖同名文件

-r 按递归方式保留原目录结构复制文件

cp    -r        /tmp/a             /root/a

例

.复制文件，只有源文件较目的文件的修改时间新时，才复制文件

cp -u -v file1 file2

.将文件file1复制成文件file2

cp file1 file2

.采用交互方式将文件file1复制成文件file2

cp -i file1 file2

.将文件file1复制成file2，因为目的文件已经存在，所以指定使用强制复制的模式

cp -f file1 file2

.将目录dir1复制成目录dir2

cp -R file1 file2

.同时将文件file1、file2、file3与目录dir1复制到dir2

cp -R file1 file2 file3 dir1 dir2

.复制时保留文件属性

cp -p a.txt tmp/

.复制时保留文件的目录结构

cp -P /var/tmp/a.txt ./temp/

.复制时产生备份文件

cp -b a.txt tmp/

.复制时产生备份文件，尾标 ~1~格式

cp -b -V t  a.txt /tmp

.指定备份文件尾标

cp -b -S _bak a.txt /tmp

复制文件不提示

# vi ~/.bashrc

如果你看到如下内容，以下命令都会用别名执行了，就是说自动加了 -i 参数

alias rm=’rm -i’

alias cp=’cp -i’

alias mv=’mv -i’

为了让复制和移动大量文件去覆盖目标时，不会产生一个个的提示，命令应该这样写

# cp -rf /home/huzs.net/* /www/huzs.net/

注意 cp 命令前加了 ，意思是不让它用~/.bashrc里的别名运行，即 -i 参数

cp命令

功能：将给出的文件或目录拷贝到另一文件或目录中，就如同DOS下的copy命令一样，功能非常强大，

语法：cp [选项] 源文件或目录 目标文件或目录

说明：该命令把指定的源文件复制到目标文件或把多个源文件复制到目标目录中。

篇4：perl中的字符串操作函数chomp与chop介绍

这篇文章主要介绍了perl中的字符串操作函数chomp与chop介绍,chomp与chop都是用于去除字符串变量尾部的字符，但它们有各自的区别,需要的朋友可以参考下

chomp与chop都是用于去除字符串变量尾部的字符，但它们有各自的区别，

chomp函数对变量起作用，而此变量含有字符串。如果字符串结尾有换行符，chomp可以去掉它。这基本上就是它能完成的所有功能，如下例：

代码如下:

$text=”alineoftextn     “; #也可以由输入

chomp($text);   #去掉换行符(n)。

它非常有用，基本上你的每一个程序都会用到它。如你将知道，这是将字符串末尾换行符去掉的最好方法。基于 Perl 中的一条基本原则：在需要使用变量的地方，可以使用赋值表达式来代替。我们有更简单的使用 chomp 的方法。Perl 首先做赋值运算，再使用这个变量。因此使用 chomp 的最常用方法是：

代码如下:

chomp($text=);   #读入，但不含换行符

$text=;

chomp($text);

#同上，但用两步完成

第一眼见到时，第一种组合的方法看起来复杂些。如果把上述其看成两步操作，读一行再 chomp，那写成两个语句的方法看起来自然些。如果将其看作一个操作，读入一行但不包括换行符，那写成一个语句的方法更恰当。由于绝大多数 Perl 程序员使用第一种写法，你也应该使用它。

chomp 是一个函数。作为一个函数，它有一个返回值，为移除的字符的个数。这个数字基本上没什么用：

代码如下:

$food=;

$betty=chomp($food); #得到值 1

如上，在使用 chomp 时，可以使用或不使用括号。这又是 Perl 中的一条通用规则：除非移除它们时含义会变，否则括号是可以省略的。如果结尾有两个或两个以上的换行符，chomp 仅去掉一个。如果没有，那什么也不做，返回 0。这种情况在一次读入一行时不会发生，但使用了输入分隔符(input separator)($/)(其不为换行符(n))，read 函数，或者将一些字符串结合起来就有可能发生，

在编写Perl程序代码的时候，也许你会有时会用chop() 函数来去掉输入的换行符”n“，有时候使用chomp() 函数。其实上面的用法都可以达到预期的效果，但它们也有细微的差别。

chop()函数，只是去除最后一个字符。

chomp()函数，就要首先判断最后一个字符是不是为”n“，它才去除。

chop函数会砍掉字符串变量的最后一个字符，并返回砍掉的字符，chop函数不管字符串里是什么都会剪短它，而chomp函数则更有选择性一些。不能chop直接量，只能chop变量。

用法:

代码如下:

chop VARIABLE

chop LIST

chop

例子：

如果chop一列LIST变量，那么列表中的每个字符串都会被剪短：

代码如下:

@lines=`cat myfile`;

chop @lines;

在最常见的情况下，chop可以用substr来表示：

代码如下:

$last_char = chop($var);

$last_char = substr($var, -1, 1, ”“); # 同上

再来看下面的完整的例子：

代码如下:

#!/usr/bin/perl

$string1 = ”This is test“;

$retval = chop( $string1 );

print ” Choped String is : $string1n“;

print ” Character removed : $retvaln“;

结果：

代码如下:

Choped String is : This is tes

Number of characters removed : t

篇5：tomcat配置ip限制访问实例介绍linux操作系统

本文章来给各位同学介绍关于tomcat配置ip限制访问实例介绍，希望此方法对各位同学会有所帮助呀，

今天项目组要求单独对tomcat进行ip限制访问,好吧,这里说下我的环境,tomcat是独立访问的,没有跟httpd整合,所以项目组觉得不安全吧,为了满足项目组的要求,只需要对tomcat的server.xml进行编译就可以了.

系统:centos 5.x

软件版本:apache-tomcat-7.0.42.tar.gz

1.安装tomcat

这个我就不说了,大家可以自己去找下怎么安装.

2.编辑server.xml

移动文件最后,如下:

prefix=”localhost_access_log.“ suffix=”.txt“ pattern=”common“ resolveHosts=”false“/>

-->

然后在上添加: