Ruby에서 문자열에 하위 문자열이 포함되어 있는지 확인하는 방법은 무엇입니까?

Ruby에서 문자열에 하위 문자열이 포함되어 있는지 확인하는 방법은 무엇입니까?

---

다음과 같은 내용이있는 문자열 변수가 있습니다.

varMessage =   
            "hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"


            "/my/name/is/balaji.so\n"
            "call::myFunction(int const&)\n"
            "void::secondFunction(char const&)\n"
             .
             .
             .
            "this/is/last/line/liobrary.so"

위의 문자열에서 하위 문자열을 찾아야합니다.

"hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"


"/my/name/is/balaji.so\n"
"call::myFunction(int const&)\n"

어떻게 찾을 수 있습니까? 하위 문자열이 있는지 여부 만 확인하면됩니다.

---

다음 include?방법을 사용할 수 있습니다 .

my_string = "abcdefg"
if my_string.include? "cde"
   puts "String includes 'cde'"
end

---

대소 문자가 관련이없는 경우 대소 문자를 구분하지 않는 정규식 이 좋은 해결책입니다.

'aBcDe' =~ /bcd/i  # evaluates as true

이것은 여러 줄 문자열에서도 작동합니다.

Ruby의 Regexp 클래스를 참조하십시오 .

---

당신은 또한 이것을 할 수 있습니다 ...

my_string = "Hello world"

if my_string["Hello"]
  puts 'It has "Hello"'
else
  puts 'No "Hello" found'
end

# => 'It has "Hello"'

---

Clint Pachl의 답변을 확장합니다.

Ruby의 정규식 일치 는 표현식이 일치하지 않으면 nil을 반환합니다 . 일치하면 일치가 발생하는 문자의 인덱스를 반환합니다. 예를 들면

"foobar" =~ /bar/  # returns 3
"foobar" =~ /foo/  # returns 0
"foobar" =~ /zzz/  # returns nil

It's important to note that in Ruby only nil and the boolean expression false evaluate to false. Everything else, including an empty array, empty hash, or the integer 0, evaluates to true.

이것이 위의 / foo / 예제가 작동하는 이유입니다.

if "string" =~ /regex/

예상대로 작동합니다. 일치가 발생한 경우 if 블록의 'true'부분 만 입력합니다.

---

Rails (3.1.0 이상에서)에서 사용할 수있는 위에서 허용 된 답변보다 더 간결한 관용구 는 .in?.

예 :

my_string = "abcdefg"
if "cde".in? my_string
  puts "'cde' is in the String."
  puts "i.e. String includes 'cde'"
end

또한 더 읽기 쉽다고 생각합니다.

cf http://apidock.com/rails/v3.1.0/Object/in%3F

( 순수한 Ruby가 아닌 Rails 에서만 사용할 수 있습니다 .)

---

삼항 방식

my_string.include?('ahr') ? (puts 'String includes ahr') : (puts 'String does not include ahr')

또는

puts (my_string.include?('ahr') ? 'String includes ahr' : 'String not includes ahr')

---

문자열 요소 참조 방법을 사용할 수 있습니다.[]

Inside the [] can either be a literal substring, an index, or a regex:

> s='abcdefg'
=> "abcdefg"
> s['a']
=> "a"
> s['z']
=> nil

Since nil is functionally the same as false and any substring returned from [] is true you can use the logic as if you use the method .include?:

0> if s[sub_s]
1>    puts "\"#{s}\" has \"#{sub_s}\""
1> else 
1*    puts "\"#{s}\" does not have \"#{sub_s}\""
1> end
"abcdefg" has "abc"

0> if s[sub_s]
1>    puts "\"#{s}\" has \"#{sub_s}\""
1> else 
1*    puts "\"#{s}\" does not have \"#{sub_s}\""
1> end
"abcdefg" does not have "xyz" 

Just make sure you don't confuse an index with a sub string:

> '123456790'[8]    # integer is eighth element, or '0'
=> "0"              # would test as 'true' in Ruby
> '123456790'['8']  
=> nil              # correct

You can also use a regex:

> s[/A/i]
=> "a"
> s[/A/]
=> nil

---

user_input = gets.chomp
user_input.downcase!

if user_input.include?('substring')
  # Do something
end

This will help you check if the string contains substring or not

puts "Enter a string"
user_input = gets.chomp  # Ex: Tommy
user_input.downcase!    #  tommy


if user_input.include?('s')
    puts "Found"
else
    puts "Not found"
end

---

How to check whether a string contains a substring in Ruby?

When you say 'check', I assume you want a boolean returned in which case you may use String#match?. match? accepts strings or regexes as its first parameter, if it's the former then it's automatically converted to a regex. So your use case would be:

str = 'string'
str.match? 'strings' #=> false
str.match? 'string'  #=> true
str.match? 'strin'   #=> true
str.match? 'trin'    #=> true
str.match? 'tri'     #=> true

String#match? has the added benefit of an optional second argument which specifies an index from which to search the string. By default this is set to 0.

str.match? 'tri',0   #=> true
str.match? 'tri',1   #=> true
str.match? 'tri',2   #=> false

참고URL : https://stackoverflow.com/questions/8258517/how-to-check-whether-a-string-contains-a-substring-in-ruby