# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

To view all translated materials including this page, select Japan from the country navigator on the bottom of this page.

# strcmpi

Compare strings (case insensitive)

## Syntax

``tf = strcmpi(s1,s2)``

## Description

example

````tf = strcmpi(s1,s2)` compares `s1` and `s2`, ignoring any differences in letter case. The function returns `1` (`true`) if the two are identical and `0` (`false`) otherwise. Text is considered identical if the size and content of each are the same, aside from case. The return result `tf` is of data type `logical`.The input arguments can be any combination of string arrays, character vectors, and cell arrays of character vectors.```

## Examples

collapse all

Compare two different character vectors, ignoring any differences in letter case.

```s1 = 'Yes'; s2 = 'No'; tf = strcmpi(s1,s2)```
```tf = logical 0 ```

`strcmpi` returns `0` because `s1` and `s2` are not equal, even when ignoring case.

Compare two equal character vectors.

```s1 = 'Yes'; s2 = 'yes'; tf = strcmpi(s1,s2)```
```tf = logical 1 ```

`strcmpi` returns `1` because `s1` and `s2` are equal when ignoring case.

Find text that matches the word `'once'` in a cell array of character vectors. Ignore case.

```s1 = 'once'; s2 = {'Once','upon'; 'a','time'}; tf = strcmpi(s1,s2)```
```tf = 2x2 logical array 1 0 0 0 ```

When you ignore case, there is one occurrence of `s1` in the array `s2`, and it occurs at the element `s2(1,1)`.

Create two cell arrays of character vectors. To compare them while ignoring case, use the `strcmpi` function.

```s1 = {'Tinker', 'Tailor'; ' Soldier', 'Spy'}; s2 = {'Tinker', 'Baker'; 'Soldier', 'SPY'}; tf = strcmpi(s1,s2)```
```tf = 2x2 logical array 1 0 0 1 ```

`tf(1,1)` is `1` because `'Tinker'` is in the first cell of both arrays. `tf(2,2)` is `1` because `'Spy'` and `'SPY'` differ only in case. `tf(2,1)` is `0` because `' Soldier'` in `s1(2,1)` has whitespace characters, and `'Soldier'` in `s2(2,1)` does not.

Starting in R2017a, you can create strings using double quotes instead of the `string` function. Compare two string arrays, ignoring case, using `strcmpi`.

```s1 = ["A","bc"; "def","G"]; s2 = ["B","c"; "DEF","G"]; tf = strcmpi(s1,s2)```
```tf = 2x2 logical array 0 0 1 1 ```

## Input Arguments

collapse all

Input text, with each input specified as a character vector, a character array, a cell array of character vectors, or a string array. The order of the inputs does not affect the comparison results.

• If both `s1` and `s2` are string arrays or cell arrays of character vectors, then `s1` and `s2` must be the same size, unless one of them is scalar.

• If both `s1` and `s2` are character arrays with multiple rows, then `s1` and `s2` can have different numbers of rows.

• When comparing a nonscalar cell array of character vectors or a string array to a multirow character array, the cell array or string array must be a column vector with the same number of rows as the character array.

Data Types: `char` | `cell` | `string`

## Output Arguments

collapse all

True or false result, returned as a `1` or `0` of data type `logical`.

• If each input is either a string scalar or a character vector, then `tf` is a scalar.

• If at least one input is either a string array or a cell array of character vectors, then `tf` is an array the same size as the input array.

• If one input is a character array with multiple rows, and the other input is either a scalar cell or a string scalar, then `tf` is an `n`-by-`1` array, where `n` is the number of rows in the character array.

• If both inputs are character arrays, `tf` is a scalar.

## Tips

• The `strcmpi` function is intended for comparison of text. If used on an unsupported data type, `strcmpi` always returns `0`.

• For case-sensitive text comparison, use `strcmp` instead of `strcmpi`.

• Although `strcmpi` shares a name with a C function, it does not follow the C language convention of returning `0` when the text inputs match.